git.oblomov.eu Git - wine/blob - dlls/gdiplus/image.c

   1 /*
   2  * Copyright (C) 2007 Google (Evan Stade)
   3  * Copyright (C) 2012 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 #define PIXELFORMATBPP(x) ((x) ? ((x) >> 8) & 255 : 24)
  44
  45 static const struct
  46 {
  47     const WICPixelFormatGUID *wic_format;
  48     PixelFormat gdip_format;
  49     /* predefined palette type to use for pixel format conversions */
  50     WICBitmapPaletteType palette_type;
  51 } pixel_formats[] =
  52 {
  53     { &GUID_WICPixelFormatBlackWhite, PixelFormat1bppIndexed, WICBitmapPaletteTypeFixedBW },
  54     { &GUID_WICPixelFormat1bppIndexed, PixelFormat1bppIndexed, WICBitmapPaletteTypeFixedBW },
  55     { &GUID_WICPixelFormat8bppGray, PixelFormat8bppIndexed, WICBitmapPaletteTypeFixedGray256 },
  56     { &GUID_WICPixelFormat8bppIndexed, PixelFormat8bppIndexed, WICBitmapPaletteTypeFixedHalftone256 },
  57     { &GUID_WICPixelFormat16bppBGR555, PixelFormat16bppRGB555, WICBitmapPaletteTypeFixedHalftone256 },
  58     { &GUID_WICPixelFormat24bppBGR, PixelFormat24bppRGB, WICBitmapPaletteTypeFixedHalftone256 },
  59     { &GUID_WICPixelFormat32bppBGR, PixelFormat32bppRGB, WICBitmapPaletteTypeFixedHalftone256 },
  60     { &GUID_WICPixelFormat32bppBGRA, PixelFormat32bppARGB, WICBitmapPaletteTypeFixedHalftone256 },
  61     { &GUID_WICPixelFormat32bppPBGRA, PixelFormat32bppPARGB, WICBitmapPaletteTypeFixedHalftone256 },
  62     { NULL }
  63 };
  64
  65 static ColorPalette *get_palette(IWICBitmapFrameDecode *frame, WICBitmapPaletteType palette_type)
  66 {
  67     HRESULT hr;
  68     IWICImagingFactory *factory;
  69     IWICPalette *wic_palette;
  70     ColorPalette *palette = NULL;
  71
  72     hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
  73                           &IID_IWICImagingFactory, (void **)&factory);
  74     if (hr != S_OK) return NULL;
  75
  76     hr = IWICImagingFactory_CreatePalette(factory, &wic_palette);
  77     if (hr == S_OK)
  78     {
  79         hr = WINCODEC_ERR_PALETTEUNAVAILABLE;
  80         if (frame)
  81             hr = IWICBitmapFrameDecode_CopyPalette(frame, wic_palette);
  82         if (hr != S_OK)
  83         {
  84             TRACE("using predefined palette %#x\n", palette_type);
  85             hr = IWICPalette_InitializePredefined(wic_palette, palette_type, FALSE);
  86         }
  87         if (hr == S_OK)
  88         {
  89             UINT count;
  90             BOOL mono, gray;
  91
  92             IWICPalette_IsBlackWhite(wic_palette, &mono);
  93             IWICPalette_IsGrayscale(wic_palette, &gray);
  94
  95             IWICPalette_GetColorCount(wic_palette, &count);
  96             palette = HeapAlloc(GetProcessHeap(), 0, 2 * sizeof(UINT) + count * sizeof(ARGB));
  97             IWICPalette_GetColors(wic_palette, count, palette->Entries, &palette->Count);
  98
  99             if (mono)
 100                 palette->Flags = 0;
 101             else if (gray)
 102                 palette->Flags = PaletteFlagsGrayScale;
 103             else
 104                 palette->Flags = PaletteFlagsHalftone;
 105         }
 106         IWICPalette_Release(wic_palette);
 107     }
 108     IWICImagingFactory_Release(factory);
 109     return palette;
 110 }
 111
 112 static INT ipicture_pixel_height(IPicture *pic)
 113 {
 114     HDC hdcref;
 115     OLE_YSIZE_HIMETRIC y;
 116
 117     IPicture_get_Height(pic, &y);
 118
 119     hdcref = GetDC(0);
 120
 121     y = MulDiv(y, GetDeviceCaps(hdcref, LOGPIXELSY), INCH_HIMETRIC);
 122     ReleaseDC(0, hdcref);
 123
 124     return y;
 125 }
 126
 127 static INT ipicture_pixel_width(IPicture *pic)
 128 {
 129     HDC hdcref;
 130     OLE_XSIZE_HIMETRIC x;
 131
 132     IPicture_get_Width(pic, &x);
 133
 134     hdcref = GetDC(0);
 135
 136     x = MulDiv(x, GetDeviceCaps(hdcref, LOGPIXELSX), INCH_HIMETRIC);
 137
 138     ReleaseDC(0, hdcref);
 139
 140     return x;
 141 }
 142
 143 GpStatus WINGDIPAPI GdipBitmapApplyEffect(GpBitmap* bitmap, CGpEffect* effect,
 144     RECT* roi, BOOL useAuxData, VOID** auxData, INT* auxDataSize)
 145 {
 146     FIXME("(%p %p %p %d %p %p): stub\n", bitmap, effect, roi, useAuxData, auxData, auxDataSize);
 147     /*
 148      * Note: According to Jose Roca's GDI+ docs, this function is not
 149      * implemented in Windows's GDI+.
 150      */
 151     return NotImplemented;
 152 }
 153
 154 GpStatus WINGDIPAPI GdipBitmapCreateApplyEffect(GpBitmap** inputBitmaps,
 155     INT numInputs, CGpEffect* effect, RECT* roi, RECT* outputRect,
 156     GpBitmap** outputBitmap, BOOL useAuxData, VOID** auxData, INT* auxDataSize)
 157 {
 158     FIXME("(%p %d %p %p %p %p %d %p %p): stub\n", inputBitmaps, numInputs, effect, roi, outputRect, outputBitmap, useAuxData, auxData, auxDataSize);
 159     /*
 160      * Note: According to Jose Roca's GDI+ docs, this function is not
 161      * implemented in Windows's GDI+.
 162      */
 163     return NotImplemented;
 164 }
 165
 166 static inline void getpixel_1bppIndexed(BYTE *index, const BYTE *row, UINT x)
 167 {
 168     *index = (row[x/8]>>(7-x%8)) & 1;
 169 }
 170
 171 static inline void getpixel_4bppIndexed(BYTE *index, const BYTE *row, UINT x)
 172 {
 173     if (x & 1)
 174         *index = row[x/2]&0xf;
 175     else
 176         *index = row[x/2]>>4;
 177 }
 178
 179 static inline void getpixel_8bppIndexed(BYTE *index, const BYTE *row, UINT x)
 180 {
 181     *index = row[x];
 182 }
 183
 184 static inline void getpixel_16bppGrayScale(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 185     const BYTE *row, UINT x)
 186 {
 187     *r = *g = *b = row[x*2+1];
 188     *a = 255;
 189 }
 190
 191 static inline void getpixel_16bppRGB555(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 192     const BYTE *row, UINT x)
 193 {
 194     WORD pixel = *((const WORD*)(row)+x);
 195     *r = (pixel>>7&0xf8)|(pixel>>12&0x7);
 196     *g = (pixel>>2&0xf8)|(pixel>>6&0x7);
 197     *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
 198     *a = 255;
 199 }
 200
 201 static inline void getpixel_16bppRGB565(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 202     const BYTE *row, UINT x)
 203 {
 204     WORD pixel = *((const WORD*)(row)+x);
 205     *r = (pixel>>8&0xf8)|(pixel>>13&0x7);
 206     *g = (pixel>>3&0xfc)|(pixel>>9&0x3);
 207     *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
 208     *a = 255;
 209 }
 210
 211 static inline void getpixel_16bppARGB1555(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 212     const BYTE *row, UINT x)
 213 {
 214     WORD pixel = *((const WORD*)(row)+x);
 215     *r = (pixel>>7&0xf8)|(pixel>>12&0x7);
 216     *g = (pixel>>2&0xf8)|(pixel>>6&0x7);
 217     *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
 218     if ((pixel&0x8000) == 0x8000)
 219         *a = 255;
 220     else
 221         *a = 0;
 222 }
 223
 224 static inline void getpixel_24bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 225     const BYTE *row, UINT x)
 226 {
 227     *r = row[x*3+2];
 228     *g = row[x*3+1];
 229     *b = row[x*3];
 230     *a = 255;
 231 }
 232
 233 static inline void getpixel_32bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 234     const BYTE *row, UINT x)
 235 {
 236     *r = row[x*4+2];
 237     *g = row[x*4+1];
 238     *b = row[x*4];
 239     *a = 255;
 240 }
 241
 242 static inline void getpixel_32bppARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 243     const BYTE *row, UINT x)
 244 {
 245     *r = row[x*4+2];
 246     *g = row[x*4+1];
 247     *b = row[x*4];
 248     *a = row[x*4+3];
 249 }
 250
 251 static inline void getpixel_32bppPARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 252     const BYTE *row, UINT x)
 253 {
 254     *a = row[x*4+3];
 255     if (*a == 0)
 256         *r = *g = *b = 0;
 257     else
 258     {
 259         *r = row[x*4+2] * 255 / *a;
 260         *g = row[x*4+1] * 255 / *a;
 261         *b = row[x*4] * 255 / *a;
 262     }
 263 }
 264
 265 static inline void getpixel_48bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 266     const BYTE *row, UINT x)
 267 {
 268     *r = row[x*6+5];
 269     *g = row[x*6+3];
 270     *b = row[x*6+1];
 271     *a = 255;
 272 }
 273
 274 static inline void getpixel_64bppARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 275     const BYTE *row, UINT x)
 276 {
 277     *r = row[x*8+5];
 278     *g = row[x*8+3];
 279     *b = row[x*8+1];
 280     *a = row[x*8+7];
 281 }
 282
 283 static inline void getpixel_64bppPARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 284     const BYTE *row, UINT x)
 285 {
 286     *a = row[x*8+7];
 287     if (*a == 0)
 288         *r = *g = *b = 0;
 289     else
 290     {
 291         *r = row[x*8+5] * 255 / *a;
 292         *g = row[x*8+3] * 255 / *a;
 293         *b = row[x*8+1] * 255 / *a;
 294     }
 295 }
 296
 297 GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap* bitmap, INT x, INT y,
 298     ARGB *color)
 299 {
 300     BYTE r, g, b, a;
 301     BYTE index;
 302     BYTE *row;
 303     TRACE("%p %d %d %p\n", bitmap, x, y, color);
 304
 305     if(!bitmap || !color ||
 306        x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
 307         return InvalidParameter;
 308
 309     row = bitmap->bits+bitmap->stride*y;
 310
 311     switch (bitmap->format)
 312     {
 313         case PixelFormat1bppIndexed:
 314             getpixel_1bppIndexed(&index,row,x);
 315             break;
 316         case PixelFormat4bppIndexed:
 317             getpixel_4bppIndexed(&index,row,x);
 318             break;
 319         case PixelFormat8bppIndexed:
 320             getpixel_8bppIndexed(&index,row,x);
 321             break;
 322         case PixelFormat16bppGrayScale:
 323             getpixel_16bppGrayScale(&r,&g,&b,&a,row,x);
 324             break;
 325         case PixelFormat16bppRGB555:
 326             getpixel_16bppRGB555(&r,&g,&b,&a,row,x);
 327             break;
 328         case PixelFormat16bppRGB565:
 329             getpixel_16bppRGB565(&r,&g,&b,&a,row,x);
 330             break;
 331         case PixelFormat16bppARGB1555:
 332             getpixel_16bppARGB1555(&r,&g,&b,&a,row,x);
 333             break;
 334         case PixelFormat24bppRGB:
 335             getpixel_24bppRGB(&r,&g,&b,&a,row,x);
 336             break;
 337         case PixelFormat32bppRGB:
 338             getpixel_32bppRGB(&r,&g,&b,&a,row,x);
 339             break;
 340         case PixelFormat32bppARGB:
 341             getpixel_32bppARGB(&r,&g,&b,&a,row,x);
 342             break;
 343         case PixelFormat32bppPARGB:
 344             getpixel_32bppPARGB(&r,&g,&b,&a,row,x);
 345             break;
 346         case PixelFormat48bppRGB:
 347             getpixel_48bppRGB(&r,&g,&b,&a,row,x);
 348             break;
 349         case PixelFormat64bppARGB:
 350             getpixel_64bppARGB(&r,&g,&b,&a,row,x);
 351             break;
 352         case PixelFormat64bppPARGB:
 353             getpixel_64bppPARGB(&r,&g,&b,&a,row,x);
 354             break;
 355         default:
 356             FIXME("not implemented for format 0x%x\n", bitmap->format);
 357             return NotImplemented;
 358     }
 359
 360     if (bitmap->format & PixelFormatIndexed)
 361         *color = bitmap->image.palette->Entries[index];
 362     else
 363         *color = a<<24|r<<16|g<<8|b;
 364
 365     return Ok;
 366 }
 367
 368 static inline UINT get_palette_index(BYTE r, BYTE g, BYTE b, BYTE a, ColorPalette *palette)
 369 {
 370     BYTE index = 0;
 371     int best_distance = 0x7fff;
 372     int distance;
 373     int i;
 374
 375     if (!palette) return 0;
 376     /* This algorithm scans entire palette,
 377        computes difference from desired color (all color components have equal weight)
 378        and returns the index of color with least difference.
 379
 380        Note: Maybe it could be replaced with a better algorithm for better image quality
 381        and performance, though better algorithm would probably need some pre-built lookup
 382        tables and thus may actually be slower if this method is called only few times per
 383        every image.
 384     */
 385     for(i=0;i<palette->Count;i++) {
 386         ARGB color=palette->Entries[i];
 387         distance=abs(b-(color & 0xff)) + abs(g-(color>>8 & 0xff)) + abs(r-(color>>16 & 0xff)) + abs(a-(color>>24 & 0xff));
 388         if (distance<best_distance) {
 389             best_distance=distance;
 390             index=i;
 391         }
 392     }
 393     return index;
 394 }
 395
 396 static inline void setpixel_8bppIndexed(BYTE r, BYTE g, BYTE b, BYTE a,
 397     BYTE *row, UINT x, ColorPalette *palette)
 398 {
 399      BYTE index = get_palette_index(r,g,b,a,palette);
 400      row[x]=index;
 401 }
 402
 403 static inline void setpixel_1bppIndexed(BYTE r, BYTE g, BYTE b, BYTE a,
 404     BYTE *row, UINT x, ColorPalette *palette)
 405 {
 406     row[x/8]  = (row[x/8] & ~(1<<(7-x%8))) | (get_palette_index(r,g,b,a,palette)<<(7-x%8));
 407 }
 408
 409 static inline void setpixel_4bppIndexed(BYTE r, BYTE g, BYTE b, BYTE a,
 410     BYTE *row, UINT x, ColorPalette *palette)
 411 {
 412     if (x & 1)
 413         row[x/2] = (row[x/2] & 0xf0) | get_palette_index(r,g,b,a,palette);
 414     else
 415         row[x/2] = (row[x/2] & 0x0f) | get_palette_index(r,g,b,a,palette)<<4;
 416 }
 417
 418 static inline void setpixel_16bppGrayScale(BYTE r, BYTE g, BYTE b, BYTE a,
 419     BYTE *row, UINT x)
 420 {
 421     *((WORD*)(row)+x) = (r+g+b)*85;
 422 }
 423
 424 static inline void setpixel_16bppRGB555(BYTE r, BYTE g, BYTE b, BYTE a,
 425     BYTE *row, UINT x)
 426 {
 427     *((WORD*)(row)+x) = (r<<7&0x7c00)|
 428                         (g<<2&0x03e0)|
 429                         (b>>3&0x001f);
 430 }
 431
 432 static inline void setpixel_16bppRGB565(BYTE r, BYTE g, BYTE b, BYTE a,
 433     BYTE *row, UINT x)
 434 {
 435     *((WORD*)(row)+x) = (r<<8&0xf800)|
 436                          (g<<3&0x07e0)|
 437                          (b>>3&0x001f);
 438 }
 439
 440 static inline void setpixel_16bppARGB1555(BYTE r, BYTE g, BYTE b, BYTE a,
 441     BYTE *row, UINT x)
 442 {
 443     *((WORD*)(row)+x) = (a<<8&0x8000)|
 444                         (r<<7&0x7c00)|
 445                         (g<<2&0x03e0)|
 446                         (b>>3&0x001f);
 447 }
 448
 449 static inline void setpixel_24bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
 450     BYTE *row, UINT x)
 451 {
 452     row[x*3+2] = r;
 453     row[x*3+1] = g;
 454     row[x*3] = b;
 455 }
 456
 457 static inline void setpixel_32bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
 458     BYTE *row, UINT x)
 459 {
 460     *((DWORD*)(row)+x) = (r<<16)|(g<<8)|b;
 461 }
 462
 463 static inline void setpixel_32bppARGB(BYTE r, BYTE g, BYTE b, BYTE a,
 464     BYTE *row, UINT x)
 465 {
 466     *((DWORD*)(row)+x) = (a<<24)|(r<<16)|(g<<8)|b;
 467 }
 468
 469 static inline void setpixel_32bppPARGB(BYTE r, BYTE g, BYTE b, BYTE a,
 470     BYTE *row, UINT x)
 471 {
 472     r = r * a / 255;
 473     g = g * a / 255;
 474     b = b * a / 255;
 475     *((DWORD*)(row)+x) = (a<<24)|(r<<16)|(g<<8)|b;
 476 }
 477
 478 static inline void setpixel_48bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
 479     BYTE *row, UINT x)
 480 {
 481     row[x*6+5] = row[x*6+4] = r;
 482     row[x*6+3] = row[x*6+2] = g;
 483     row[x*6+1] = row[x*6] = b;
 484 }
 485
 486 static inline void setpixel_64bppARGB(BYTE r, BYTE g, BYTE b, BYTE a,
 487     BYTE *row, UINT x)
 488 {
 489     UINT64 a64=a, r64=r, g64=g, b64=b;
 490     *((UINT64*)(row)+x) = (a64<<56)|(a64<<48)|(r64<<40)|(r64<<32)|(g64<<24)|(g64<<16)|(b64<<8)|b64;
 491 }
 492
 493 static inline void setpixel_64bppPARGB(BYTE r, BYTE g, BYTE b, BYTE a,
 494     BYTE *row, UINT x)
 495 {
 496     UINT64 a64, r64, g64, b64;
 497     a64 = a * 257;
 498     r64 = r * a / 255;
 499     g64 = g * a / 255;
 500     b64 = b * a / 255;
 501     *((UINT64*)(row)+x) = (a64<<48)|(r64<<32)|(g64<<16)|b64;
 502 }
 503
 504 GpStatus WINGDIPAPI GdipBitmapSetPixel(GpBitmap* bitmap, INT x, INT y,
 505     ARGB color)
 506 {
 507     BYTE a, r, g, b;
 508     BYTE *row;
 509     TRACE("bitmap:%p, x:%d, y:%d, color:%08x\n", bitmap, x, y, color);
 510
 511     if(!bitmap || x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
 512         return InvalidParameter;
 513
 514     a = color>>24;
 515     r = color>>16;
 516     g = color>>8;
 517     b = color;
 518
 519     row = bitmap->bits + bitmap->stride * y;
 520
 521     switch (bitmap->format)
 522     {
 523         case PixelFormat16bppGrayScale:
 524             setpixel_16bppGrayScale(r,g,b,a,row,x);
 525             break;
 526         case PixelFormat16bppRGB555:
 527             setpixel_16bppRGB555(r,g,b,a,row,x);
 528             break;
 529         case PixelFormat16bppRGB565:
 530             setpixel_16bppRGB565(r,g,b,a,row,x);
 531             break;
 532         case PixelFormat16bppARGB1555:
 533             setpixel_16bppARGB1555(r,g,b,a,row,x);
 534             break;
 535         case PixelFormat24bppRGB:
 536             setpixel_24bppRGB(r,g,b,a,row,x);
 537             break;
 538         case PixelFormat32bppRGB:
 539             setpixel_32bppRGB(r,g,b,a,row,x);
 540             break;
 541         case PixelFormat32bppARGB:
 542             setpixel_32bppARGB(r,g,b,a,row,x);
 543             break;
 544         case PixelFormat32bppPARGB:
 545             setpixel_32bppPARGB(r,g,b,a,row,x);
 546             break;
 547         case PixelFormat48bppRGB:
 548             setpixel_48bppRGB(r,g,b,a,row,x);
 549             break;
 550         case PixelFormat64bppARGB:
 551             setpixel_64bppARGB(r,g,b,a,row,x);
 552             break;
 553         case PixelFormat64bppPARGB:
 554             setpixel_64bppPARGB(r,g,b,a,row,x);
 555             break;
 556         case PixelFormat8bppIndexed:
 557             setpixel_8bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
 558             break;
 559         case PixelFormat4bppIndexed:
 560             setpixel_4bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
 561             break;
 562         case PixelFormat1bppIndexed:
 563             setpixel_1bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
 564             break;
 565         default:
 566             FIXME("not implemented for format 0x%x\n", bitmap->format);
 567             return NotImplemented;
 568     }
 569
 570     return Ok;
 571 }
 572
 573 GpStatus convert_pixels(INT width, INT height,
 574     INT dst_stride, BYTE *dst_bits, PixelFormat dst_format,
 575     INT src_stride, const BYTE *src_bits, PixelFormat src_format,
 576     ColorPalette *palette)
 577 {
 578     INT x, y;
 579
 580     if (src_format == dst_format ||
 581         (dst_format == PixelFormat32bppRGB && PIXELFORMATBPP(src_format) == 32))
 582     {
 583         UINT widthbytes = PIXELFORMATBPP(src_format) * width / 8;
 584         for (y=0; y<height; y++)
 585             memcpy(dst_bits+dst_stride*y, src_bits+src_stride*y, widthbytes);
 586         return Ok;
 587     }
 588
 589 #define convert_indexed_to_rgb(getpixel_function, setpixel_function) do { \
 590     for (x=0; x<width; x++) \
 591         for (y=0; y<height; y++) { \
 592             BYTE index; \
 593             ARGB argb; \
 594             BYTE *color = (BYTE *)&argb; \
 595             getpixel_function(&index, src_bits+src_stride*y, x); \
 596             argb = (palette && index < palette->Count) ? palette->Entries[index] : 0; \
 597             setpixel_function(color[2], color[1], color[0], color[3], dst_bits+dst_stride*y, x); \
 598         } \
 599     return Ok; \
 600 } while (0);
 601
 602 #define convert_rgb_to_rgb(getpixel_function, setpixel_function) do { \
 603     for (x=0; x<width; x++) \
 604         for (y=0; y<height; y++) { \
 605             BYTE r, g, b, a; \
 606             getpixel_function(&r, &g, &b, &a, src_bits+src_stride*y, x); \
 607             setpixel_function(r, g, b, a, dst_bits+dst_stride*y, x); \
 608         } \
 609     return Ok; \
 610 } while (0);
 611
 612 #define convert_rgb_to_indexed(getpixel_function, setpixel_function) do { \
 613     for (x=0; x<width; x++) \
 614         for (y=0; y<height; y++) { \
 615             BYTE r, g, b, a; \
 616             getpixel_function(&r, &g, &b, &a, src_bits+src_stride*y, x); \
 617             setpixel_function(r, g, b, a, dst_bits+dst_stride*y, x, palette); \
 618         } \
 619     return Ok; \
 620 } while (0);
 621
 622     switch (src_format)
 623     {
 624     case PixelFormat1bppIndexed:
 625         switch (dst_format)
 626         {
 627         case PixelFormat16bppGrayScale:
 628             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppGrayScale);
 629         case PixelFormat16bppRGB555:
 630             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppRGB555);
 631         case PixelFormat16bppRGB565:
 632             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppRGB565);
 633         case PixelFormat16bppARGB1555:
 634             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppARGB1555);
 635         case PixelFormat24bppRGB:
 636             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_24bppRGB);
 637         case PixelFormat32bppRGB:
 638             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppRGB);
 639         case PixelFormat32bppARGB:
 640             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppARGB);
 641         case PixelFormat32bppPARGB:
 642             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppPARGB);
 643         case PixelFormat48bppRGB:
 644             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_48bppRGB);
 645         case PixelFormat64bppARGB:
 646             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_64bppARGB);
 647         default:
 648             break;
 649         }
 650         break;
 651     case PixelFormat4bppIndexed:
 652         switch (dst_format)
 653         {
 654         case PixelFormat16bppGrayScale:
 655             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppGrayScale);
 656         case PixelFormat16bppRGB555:
 657             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppRGB555);
 658         case PixelFormat16bppRGB565:
 659             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppRGB565);
 660         case PixelFormat16bppARGB1555:
 661             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppARGB1555);
 662         case PixelFormat24bppRGB:
 663             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_24bppRGB);
 664         case PixelFormat32bppRGB:
 665             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppRGB);
 666         case PixelFormat32bppARGB:
 667             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppARGB);
 668         case PixelFormat32bppPARGB:
 669             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppPARGB);
 670         case PixelFormat48bppRGB:
 671             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_48bppRGB);
 672         case PixelFormat64bppARGB:
 673             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_64bppARGB);
 674         default:
 675             break;
 676         }
 677         break;
 678     case PixelFormat8bppIndexed:
 679         switch (dst_format)
 680         {
 681         case PixelFormat16bppGrayScale:
 682             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppGrayScale);
 683         case PixelFormat16bppRGB555:
 684             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppRGB555);
 685         case PixelFormat16bppRGB565:
 686             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppRGB565);
 687         case PixelFormat16bppARGB1555:
 688             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppARGB1555);
 689         case PixelFormat24bppRGB:
 690             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_24bppRGB);
 691         case PixelFormat32bppRGB:
 692             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppRGB);
 693         case PixelFormat32bppARGB:
 694             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppARGB);
 695         case PixelFormat32bppPARGB:
 696             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppPARGB);
 697         case PixelFormat48bppRGB:
 698             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_48bppRGB);
 699         case PixelFormat64bppARGB:
 700             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_64bppARGB);
 701         default:
 702             break;
 703         }
 704         break;
 705     case PixelFormat16bppGrayScale:
 706         switch (dst_format)
 707         {
 708         case PixelFormat1bppIndexed:
 709             convert_rgb_to_indexed(getpixel_16bppGrayScale, setpixel_1bppIndexed);
 710         case PixelFormat8bppIndexed:
 711             convert_rgb_to_indexed(getpixel_16bppGrayScale, setpixel_8bppIndexed);
 712         case PixelFormat16bppRGB555:
 713             convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppRGB555);
 714         case PixelFormat16bppRGB565:
 715             convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppRGB565);
 716         case PixelFormat16bppARGB1555:
 717             convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppARGB1555);
 718         case PixelFormat24bppRGB:
 719             convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_24bppRGB);
 720         case PixelFormat32bppRGB:
 721             convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppRGB);
 722         case PixelFormat32bppARGB:
 723             convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppARGB);
 724         case PixelFormat32bppPARGB:
 725             convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppPARGB);
 726         case PixelFormat48bppRGB:
 727             convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_48bppRGB);
 728         case PixelFormat64bppARGB:
 729             convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_64bppARGB);
 730         default:
 731             break;
 732         }
 733         break;
 734     case PixelFormat16bppRGB555:
 735         switch (dst_format)
 736         {
 737         case PixelFormat1bppIndexed:
 738             convert_rgb_to_indexed(getpixel_16bppRGB555, setpixel_1bppIndexed);
 739         case PixelFormat8bppIndexed:
 740             convert_rgb_to_indexed(getpixel_16bppRGB555, setpixel_8bppIndexed);
 741         case PixelFormat16bppGrayScale:
 742             convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppGrayScale);
 743         case PixelFormat16bppRGB565:
 744             convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppRGB565);
 745         case PixelFormat16bppARGB1555:
 746             convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppARGB1555);
 747         case PixelFormat24bppRGB:
 748             convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_24bppRGB);
 749         case PixelFormat32bppRGB:
 750             convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppRGB);
 751         case PixelFormat32bppARGB:
 752             convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppARGB);
 753         case PixelFormat32bppPARGB:
 754             convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppPARGB);
 755         case PixelFormat48bppRGB:
 756             convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_48bppRGB);
 757         case PixelFormat64bppARGB:
 758             convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_64bppARGB);
 759         default:
 760             break;
 761         }
 762         break;
 763     case PixelFormat16bppRGB565:
 764         switch (dst_format)
 765         {
 766         case PixelFormat1bppIndexed:
 767             convert_rgb_to_indexed(getpixel_16bppRGB565, setpixel_1bppIndexed);
 768         case PixelFormat8bppIndexed:
 769             convert_rgb_to_indexed(getpixel_16bppRGB565, setpixel_8bppIndexed);
 770         case PixelFormat16bppGrayScale:
 771             convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppGrayScale);
 772         case PixelFormat16bppRGB555:
 773             convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppRGB555);
 774         case PixelFormat16bppARGB1555:
 775             convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppARGB1555);
 776         case PixelFormat24bppRGB:
 777             convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_24bppRGB);
 778         case PixelFormat32bppRGB:
 779             convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppRGB);
 780         case PixelFormat32bppARGB:
 781             convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppARGB);
 782         case PixelFormat32bppPARGB:
 783             convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppPARGB);
 784         case PixelFormat48bppRGB:
 785             convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_48bppRGB);
 786         case PixelFormat64bppARGB:
 787             convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_64bppARGB);
 788         default:
 789             break;
 790         }
 791         break;
 792     case PixelFormat16bppARGB1555:
 793         switch (dst_format)
 794         {
 795         case PixelFormat1bppIndexed:
 796             convert_rgb_to_indexed(getpixel_16bppARGB1555, setpixel_1bppIndexed);
 797         case PixelFormat8bppIndexed:
 798             convert_rgb_to_indexed(getpixel_16bppARGB1555, setpixel_8bppIndexed);
 799         case PixelFormat16bppGrayScale:
 800             convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppGrayScale);
 801         case PixelFormat16bppRGB555:
 802             convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppRGB555);
 803         case PixelFormat16bppRGB565:
 804             convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppRGB565);
 805         case PixelFormat24bppRGB:
 806             convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_24bppRGB);
 807         case PixelFormat32bppRGB:
 808             convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppRGB);
 809         case PixelFormat32bppARGB:
 810             convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppARGB);
 811         case PixelFormat32bppPARGB:
 812             convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppPARGB);
 813         case PixelFormat48bppRGB:
 814             convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_48bppRGB);
 815         case PixelFormat64bppARGB:
 816             convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_64bppARGB);
 817         default:
 818             break;
 819         }
 820         break;
 821     case PixelFormat24bppRGB:
 822         switch (dst_format)
 823         {
 824         case PixelFormat1bppIndexed:
 825             convert_rgb_to_indexed(getpixel_24bppRGB, setpixel_1bppIndexed);
 826         case PixelFormat8bppIndexed:
 827             convert_rgb_to_indexed(getpixel_24bppRGB, setpixel_8bppIndexed);
 828         case PixelFormat16bppGrayScale:
 829             convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppGrayScale);
 830         case PixelFormat16bppRGB555:
 831             convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppRGB555);
 832         case PixelFormat16bppRGB565:
 833             convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppRGB565);
 834         case PixelFormat16bppARGB1555:
 835             convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppARGB1555);
 836         case PixelFormat32bppRGB:
 837             convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppRGB);
 838         case PixelFormat32bppARGB:
 839             convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppARGB);
 840         case PixelFormat32bppPARGB:
 841             convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppPARGB);
 842         case PixelFormat48bppRGB:
 843             convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_48bppRGB);
 844         case PixelFormat64bppARGB:
 845             convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_64bppARGB);
 846         default:
 847             break;
 848         }
 849         break;
 850     case PixelFormat32bppRGB:
 851         switch (dst_format)
 852         {
 853         case PixelFormat1bppIndexed:
 854             convert_rgb_to_indexed(getpixel_32bppRGB, setpixel_1bppIndexed);
 855         case PixelFormat8bppIndexed:
 856             convert_rgb_to_indexed(getpixel_32bppRGB, setpixel_8bppIndexed);
 857         case PixelFormat16bppGrayScale:
 858             convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppGrayScale);
 859         case PixelFormat16bppRGB555:
 860             convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppRGB555);
 861         case PixelFormat16bppRGB565:
 862             convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppRGB565);
 863         case PixelFormat16bppARGB1555:
 864             convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppARGB1555);
 865         case PixelFormat24bppRGB:
 866             convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_24bppRGB);
 867         case PixelFormat32bppARGB:
 868             convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_32bppARGB);
 869         case PixelFormat32bppPARGB:
 870             convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_32bppPARGB);
 871         case PixelFormat48bppRGB:
 872             convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_48bppRGB);
 873         case PixelFormat64bppARGB:
 874             convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_64bppARGB);
 875         default:
 876             break;
 877         }
 878         break;
 879     case PixelFormat32bppARGB:
 880         switch (dst_format)
 881         {
 882         case PixelFormat1bppIndexed:
 883             convert_rgb_to_indexed(getpixel_32bppARGB, setpixel_1bppIndexed);
 884         case PixelFormat8bppIndexed:
 885             convert_rgb_to_indexed(getpixel_32bppARGB, setpixel_8bppIndexed);
 886         case PixelFormat16bppGrayScale:
 887             convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppGrayScale);
 888         case PixelFormat16bppRGB555:
 889             convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppRGB555);
 890         case PixelFormat16bppRGB565:
 891             convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppRGB565);
 892         case PixelFormat16bppARGB1555:
 893             convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppARGB1555);
 894         case PixelFormat24bppRGB:
 895             convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_24bppRGB);
 896         case PixelFormat32bppPARGB:
 897             convert_32bppARGB_to_32bppPARGB(width, height, dst_bits, dst_stride, src_bits, src_stride);
 898             return Ok;
 899         case PixelFormat48bppRGB:
 900             convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_48bppRGB);
 901         case PixelFormat64bppARGB:
 902             convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_64bppARGB);
 903         default:
 904             break;
 905         }
 906         break;
 907     case PixelFormat32bppPARGB:
 908         switch (dst_format)
 909         {
 910         case PixelFormat1bppIndexed:
 911             convert_rgb_to_indexed(getpixel_32bppPARGB, setpixel_1bppIndexed);
 912         case PixelFormat8bppIndexed:
 913             convert_rgb_to_indexed(getpixel_32bppPARGB, setpixel_8bppIndexed);
 914         case PixelFormat16bppGrayScale:
 915             convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppGrayScale);
 916         case PixelFormat16bppRGB555:
 917             convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppRGB555);
 918         case PixelFormat16bppRGB565:
 919             convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppRGB565);
 920         case PixelFormat16bppARGB1555:
 921             convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppARGB1555);
 922         case PixelFormat24bppRGB:
 923             convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_24bppRGB);
 924         case PixelFormat32bppRGB:
 925             convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_32bppRGB);
 926         case PixelFormat32bppARGB:
 927             convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_32bppARGB);
 928         case PixelFormat48bppRGB:
 929             convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_48bppRGB);
 930         case PixelFormat64bppARGB:
 931             convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_64bppARGB);
 932         default:
 933             break;
 934         }
 935         break;
 936     case PixelFormat48bppRGB:
 937         switch (dst_format)
 938         {
 939         case PixelFormat1bppIndexed:
 940             convert_rgb_to_indexed(getpixel_48bppRGB, setpixel_1bppIndexed);
 941         case PixelFormat8bppIndexed:
 942             convert_rgb_to_indexed(getpixel_48bppRGB, setpixel_8bppIndexed);
 943         case PixelFormat16bppGrayScale:
 944             convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppGrayScale);
 945         case PixelFormat16bppRGB555:
 946             convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppRGB555);
 947         case PixelFormat16bppRGB565:
 948             convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppRGB565);
 949         case PixelFormat16bppARGB1555:
 950             convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppARGB1555);
 951         case PixelFormat24bppRGB:
 952             convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_24bppRGB);
 953         case PixelFormat32bppRGB:
 954             convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppRGB);
 955         case PixelFormat32bppARGB:
 956             convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppARGB);
 957         case PixelFormat32bppPARGB:
 958             convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppPARGB);
 959         case PixelFormat64bppARGB:
 960             convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_64bppARGB);
 961         default:
 962             break;
 963         }
 964         break;
 965     case PixelFormat64bppARGB:
 966         switch (dst_format)
 967         {
 968         case PixelFormat1bppIndexed:
 969             convert_rgb_to_indexed(getpixel_64bppARGB, setpixel_1bppIndexed);
 970         case PixelFormat8bppIndexed:
 971             convert_rgb_to_indexed(getpixel_64bppARGB, setpixel_8bppIndexed);
 972         case PixelFormat16bppGrayScale:
 973             convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppGrayScale);
 974         case PixelFormat16bppRGB555:
 975             convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppRGB555);
 976         case PixelFormat16bppRGB565:
 977             convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppRGB565);
 978         case PixelFormat16bppARGB1555:
 979             convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppARGB1555);
 980         case PixelFormat24bppRGB:
 981             convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_24bppRGB);
 982         case PixelFormat32bppRGB:
 983             convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppRGB);
 984         case PixelFormat32bppARGB:
 985             convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppARGB);
 986         case PixelFormat32bppPARGB:
 987             convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppPARGB);
 988         case PixelFormat48bppRGB:
 989             convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_48bppRGB);
 990         default:
 991             break;
 992         }
 993         break;
 994     case PixelFormat64bppPARGB:
 995         switch (dst_format)
 996         {
 997         case PixelFormat1bppIndexed:
 998             convert_rgb_to_indexed(getpixel_64bppPARGB, setpixel_1bppIndexed);
 999         case PixelFormat8bppIndexed:
1000             convert_rgb_to_indexed(getpixel_64bppPARGB, setpixel_8bppIndexed);
1001         case PixelFormat16bppGrayScale:
1002             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppGrayScale);
1003         case PixelFormat16bppRGB555:
1004             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppRGB555);
1005         case PixelFormat16bppRGB565:
1006             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppRGB565);
1007         case PixelFormat16bppARGB1555:
1008             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppARGB1555);
1009         case PixelFormat24bppRGB:
1010             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_24bppRGB);
1011         case PixelFormat32bppRGB:
1012             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppRGB);
1013         case PixelFormat32bppARGB:
1014             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppARGB);
1015         case PixelFormat32bppPARGB:
1016             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppPARGB);
1017         case PixelFormat48bppRGB:
1018             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_48bppRGB);
1019         case PixelFormat64bppARGB:
1020             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_64bppARGB);
1021         default:
1022             break;
1023         }
1024         break;
1025     default:
1026         break;
1027     }
1028
1029 #undef convert_indexed_to_rgb
1030 #undef convert_rgb_to_rgb
1031
1032     return NotImplemented;
1033 }
1034
1035 /* This function returns a pointer to an array of pixels that represents the
1036  * bitmap. The *entire* bitmap is locked according to the lock mode specified by
1037  * flags.  It is correct behavior that a user who calls this function with write
1038  * privileges can write to the whole bitmap (not just the area in rect).
1039  *
1040  * FIXME: only used portion of format is bits per pixel. */
1041 GpStatus WINGDIPAPI GdipBitmapLockBits(GpBitmap* bitmap, GDIPCONST GpRect* rect,
1042     UINT flags, PixelFormat format, BitmapData* lockeddata)
1043 {
1044     INT bitspp = PIXELFORMATBPP(format);
1045     GpRect act_rect; /* actual rect to be used */
1046     GpStatus stat;
1047
1048     TRACE("%p %p %d 0x%x %p\n", bitmap, rect, flags, format, lockeddata);
1049
1050     if(!lockeddata || !bitmap)
1051         return InvalidParameter;
1052
1053     if(rect){
1054         if(rect->X < 0 || rect->Y < 0 || (rect->X + rect->Width > bitmap->width) ||
1055           (rect->Y + rect->Height > bitmap->height) || !flags)
1056             return InvalidParameter;
1057
1058         act_rect = *rect;
1059     }
1060     else{
1061         act_rect.X = act_rect.Y = 0;
1062         act_rect.Width  = bitmap->width;
1063         act_rect.Height = bitmap->height;
1064     }
1065
1066     if(bitmap->lockmode)
1067     {
1068         WARN("bitmap is already locked and cannot be locked again\n");
1069         return WrongState;
1070     }
1071
1072     if (bitmap->bits && bitmap->format == format && !(flags & ImageLockModeUserInputBuf))
1073     {
1074         /* no conversion is necessary; just use the bits directly */
1075         lockeddata->Width = act_rect.Width;
1076         lockeddata->Height = act_rect.Height;
1077         lockeddata->PixelFormat = format;
1078         lockeddata->Reserved = flags;
1079         lockeddata->Stride = bitmap->stride;
1080         lockeddata->Scan0 = bitmap->bits + (bitspp / 8) * act_rect.X +
1081                             bitmap->stride * act_rect.Y;
1082
1083         bitmap->lockmode = flags | ImageLockModeRead;
1084         bitmap->numlocks++;
1085
1086         return Ok;
1087     }
1088
1089     /* Make sure we can convert to the requested format. */
1090     if (flags & ImageLockModeRead)
1091     {
1092         stat = convert_pixels(0, 0, 0, NULL, format, 0, NULL, bitmap->format, NULL);
1093         if (stat == NotImplemented)
1094         {
1095             FIXME("cannot read bitmap from %x to %x\n", bitmap->format, format);
1096             return NotImplemented;
1097         }
1098     }
1099
1100     /* If we're opening for writing, make sure we'll be able to write back in
1101      * the original format. */
1102     if (flags & ImageLockModeWrite)
1103     {
1104         stat = convert_pixels(0, 0, 0, NULL, bitmap->format, 0, NULL, format, NULL);
1105         if (stat == NotImplemented)
1106         {
1107             FIXME("cannot write bitmap from %x to %x\n", format, bitmap->format);
1108             return NotImplemented;
1109         }
1110     }
1111
1112     lockeddata->Width  = act_rect.Width;
1113     lockeddata->Height = act_rect.Height;
1114     lockeddata->PixelFormat = format;
1115     lockeddata->Reserved = flags;
1116
1117     if(!(flags & ImageLockModeUserInputBuf))
1118     {
1119         lockeddata->Stride = (((act_rect.Width * bitspp + 7) / 8) + 3) & ~3;
1120
1121         bitmap->bitmapbits = GdipAlloc(lockeddata->Stride * act_rect.Height);
1122
1123         if (!bitmap->bitmapbits) return OutOfMemory;
1124
1125         lockeddata->Scan0  = bitmap->bitmapbits;
1126     }
1127
1128     if (flags & ImageLockModeRead)
1129     {
1130         static int fixme=0;
1131
1132         if (!fixme && (PIXELFORMATBPP(bitmap->format) * act_rect.X) % 8 != 0)
1133         {
1134             FIXME("Cannot copy rows that don't start at a whole byte.\n");
1135             fixme = 1;
1136         }
1137
1138         stat = convert_pixels(act_rect.Width, act_rect.Height,
1139             lockeddata->Stride, lockeddata->Scan0, format,
1140             bitmap->stride,
1141             bitmap->bits + bitmap->stride * act_rect.Y + PIXELFORMATBPP(bitmap->format) * act_rect.X / 8,
1142             bitmap->format, bitmap->image.palette);
1143
1144         if (stat != Ok)
1145         {
1146             GdipFree(bitmap->bitmapbits);
1147             bitmap->bitmapbits = NULL;
1148             return stat;
1149         }
1150     }
1151
1152     bitmap->lockmode = flags | ImageLockModeRead;
1153     bitmap->numlocks++;
1154     bitmap->lockx = act_rect.X;
1155     bitmap->locky = act_rect.Y;
1156
1157     return Ok;
1158 }
1159
1160 GpStatus WINGDIPAPI GdipBitmapSetResolution(GpBitmap* bitmap, REAL xdpi, REAL ydpi)
1161 {
1162     TRACE("(%p, %.2f, %.2f)\n", bitmap, xdpi, ydpi);
1163
1164     if (!bitmap || xdpi == 0.0 || ydpi == 0.0)
1165         return InvalidParameter;
1166
1167     bitmap->image.xres = xdpi;
1168     bitmap->image.yres = ydpi;
1169
1170     return Ok;
1171 }
1172
1173 GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap* bitmap,
1174     BitmapData* lockeddata)
1175 {
1176     GpStatus stat;
1177     static int fixme=0;
1178
1179     TRACE("(%p,%p)\n", bitmap, lockeddata);
1180
1181     if(!bitmap || !lockeddata)
1182         return InvalidParameter;
1183
1184     if(!bitmap->lockmode)
1185         return WrongState;
1186
1187     if(!(lockeddata->Reserved & ImageLockModeWrite)){
1188         if(!(--bitmap->numlocks))
1189             bitmap->lockmode = 0;
1190
1191         GdipFree(bitmap->bitmapbits);
1192         bitmap->bitmapbits = NULL;
1193         return Ok;
1194     }
1195
1196     if (!bitmap->bitmapbits && !(lockeddata->Reserved & ImageLockModeUserInputBuf))
1197     {
1198         /* we passed a direct reference; no need to do anything */
1199         bitmap->lockmode = 0;
1200         bitmap->numlocks = 0;
1201         return Ok;
1202     }
1203
1204     if (!fixme && (PIXELFORMATBPP(bitmap->format) * bitmap->lockx) % 8 != 0)
1205     {
1206         FIXME("Cannot copy rows that don't start at a whole byte.\n");
1207         fixme = 1;
1208     }
1209
1210     stat = convert_pixels(lockeddata->Width, lockeddata->Height,
1211         bitmap->stride,
1212         bitmap->bits + bitmap->stride * bitmap->locky + PIXELFORMATBPP(bitmap->format) * bitmap->lockx / 8,
1213         bitmap->format,
1214         lockeddata->Stride, lockeddata->Scan0, lockeddata->PixelFormat, NULL);
1215
1216     if (stat != Ok)
1217     {
1218         ERR("failed to convert pixels; this should never happen\n");
1219     }
1220
1221     GdipFree(bitmap->bitmapbits);
1222     bitmap->bitmapbits = NULL;
1223     bitmap->lockmode = 0;
1224     bitmap->numlocks = 0;
1225
1226     return stat;
1227 }
1228
1229 GpStatus WINGDIPAPI GdipCloneBitmapArea(REAL x, REAL y, REAL width, REAL height,
1230     PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
1231 {
1232     BitmapData lockeddata_src, lockeddata_dst;
1233     int i;
1234     UINT row_size;
1235     Rect area;
1236     GpStatus stat;
1237
1238     TRACE("(%f,%f,%f,%f,0x%x,%p,%p)\n", x, y, width, height, format, srcBitmap, dstBitmap);
1239
1240     if (!srcBitmap || !dstBitmap || srcBitmap->image.type != ImageTypeBitmap ||
1241         x < 0 || y < 0 ||
1242         x + width > srcBitmap->width || y + height > srcBitmap->height)
1243     {
1244         TRACE("<-- InvalidParameter\n");
1245         return InvalidParameter;
1246     }
1247
1248     if (format == PixelFormatDontCare)
1249         format = srcBitmap->format;
1250
1251     area.X = roundr(x);
1252     area.Y = roundr(y);
1253     area.Width = roundr(width);
1254     area.Height = roundr(height);
1255
1256     stat = GdipBitmapLockBits(srcBitmap, &area, ImageLockModeRead, format,
1257         &lockeddata_src);
1258     if (stat != Ok) return stat;
1259
1260     stat = GdipCreateBitmapFromScan0(lockeddata_src.Width, lockeddata_src.Height,
1261         0, lockeddata_src.PixelFormat, NULL, dstBitmap);
1262     if (stat == Ok)
1263     {
1264         stat = GdipBitmapLockBits(*dstBitmap, NULL, ImageLockModeWrite,
1265             lockeddata_src.PixelFormat, &lockeddata_dst);
1266
1267         if (stat == Ok)
1268         {
1269             /* copy the image data */
1270             row_size = (lockeddata_src.Width * PIXELFORMATBPP(lockeddata_src.PixelFormat) +7)/8;
1271             for (i=0; i<lockeddata_src.Height; i++)
1272                 memcpy((BYTE*)lockeddata_dst.Scan0+lockeddata_dst.Stride*i,
1273                        (BYTE*)lockeddata_src.Scan0+lockeddata_src.Stride*i,
1274                        row_size);
1275
1276             GdipBitmapUnlockBits(*dstBitmap, &lockeddata_dst);
1277         }
1278
1279         if (stat != Ok)
1280             GdipDisposeImage((GpImage*)*dstBitmap);
1281     }
1282
1283     GdipBitmapUnlockBits(srcBitmap, &lockeddata_src);
1284
1285     if (stat != Ok)
1286     {
1287         *dstBitmap = NULL;
1288     }
1289
1290     return stat;
1291 }
1292
1293 GpStatus WINGDIPAPI GdipCloneBitmapAreaI(INT x, INT y, INT width, INT height,
1294     PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
1295 {
1296     TRACE("(%i,%i,%i,%i,0x%x,%p,%p)\n", x, y, width, height, format, srcBitmap, dstBitmap);
1297
1298     return GdipCloneBitmapArea(x, y, width, height, format, srcBitmap, dstBitmap);
1299 }
1300
1301 GpStatus WINGDIPAPI GdipCloneImage(GpImage *image, GpImage **cloneImage)
1302 {
1303     GpStatus stat = GenericError;
1304
1305     TRACE("%p, %p\n", image, cloneImage);
1306
1307     if (!image || !cloneImage)
1308         return InvalidParameter;
1309
1310     if (image->picture)
1311     {
1312         IStream* stream;
1313         HRESULT hr;
1314         INT size;
1315         LARGE_INTEGER move;
1316
1317         hr = CreateStreamOnHGlobal(0, TRUE, &stream);
1318         if (FAILED(hr))
1319             return GenericError;
1320
1321         hr = IPicture_SaveAsFile(image->picture, stream, FALSE, &size);
1322         if(FAILED(hr))
1323         {
1324             WARN("Failed to save image on stream\n");
1325             goto out;
1326         }
1327
1328         /* Set seek pointer back to the beginning of the picture */
1329         move.QuadPart = 0;
1330         hr = IStream_Seek(stream, move, STREAM_SEEK_SET, NULL);
1331         if (FAILED(hr))
1332             goto out;
1333
1334         stat = GdipLoadImageFromStream(stream, cloneImage);
1335         if (stat != Ok) WARN("Failed to load image from stream\n");
1336
1337     out:
1338         IStream_Release(stream);
1339         return stat;
1340     }
1341     else if (image->type == ImageTypeBitmap)
1342     {
1343         GpBitmap *bitmap = (GpBitmap*)image;
1344         BitmapData lockeddata_src, lockeddata_dst;
1345         int i;
1346         UINT row_size;
1347
1348         stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, bitmap->format,
1349             &lockeddata_src);
1350         if (stat != Ok) return stat;
1351
1352         stat = GdipCreateBitmapFromScan0(lockeddata_src.Width, lockeddata_src.Height,
1353             0, lockeddata_src.PixelFormat, NULL, (GpBitmap**)cloneImage);
1354         if (stat == Ok)
1355         {
1356             stat = GdipBitmapLockBits((GpBitmap*)*cloneImage, NULL, ImageLockModeWrite,
1357                 lockeddata_src.PixelFormat, &lockeddata_dst);
1358
1359             if (stat == Ok)
1360             {
1361                 /* copy the image data */
1362                 row_size = (lockeddata_src.Width * PIXELFORMATBPP(lockeddata_src.PixelFormat) +7)/8;
1363                 for (i=0; i<lockeddata_src.Height; i++)
1364                     memcpy((BYTE*)lockeddata_dst.Scan0+lockeddata_dst.Stride*i,
1365                            (BYTE*)lockeddata_src.Scan0+lockeddata_src.Stride*i,
1366                            row_size);
1367
1368                 GdipBitmapUnlockBits((GpBitmap*)*cloneImage, &lockeddata_dst);
1369             }
1370
1371             if (stat != Ok)
1372                 GdipDisposeImage(*cloneImage);
1373         }
1374
1375         GdipBitmapUnlockBits(bitmap, &lockeddata_src);
1376
1377         if (stat != Ok)
1378         {
1379             *cloneImage = NULL;
1380         }
1381         else memcpy(&(*cloneImage)->format, &image->format, sizeof(GUID));
1382
1383         return stat;
1384     }
1385     else
1386     {
1387         ERR("GpImage with no IPicture or bitmap?!\n");
1388         return NotImplemented;
1389     }
1390 }
1391
1392 GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename,
1393     GpBitmap **bitmap)
1394 {
1395     GpStatus stat;
1396     IStream *stream;
1397
1398     TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
1399
1400     if(!filename || !bitmap)
1401         return InvalidParameter;
1402
1403     stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
1404
1405     if(stat != Ok)
1406         return stat;
1407
1408     stat = GdipCreateBitmapFromStream(stream, bitmap);
1409
1410     IStream_Release(stream);
1411
1412     return stat;
1413 }
1414
1415 GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO* info,
1416                                                VOID *bits, GpBitmap **bitmap)
1417 {
1418     DWORD height, stride;
1419     PixelFormat format;
1420
1421     FIXME("(%p, %p, %p) - partially implemented\n", info, bits, bitmap);
1422
1423     if (!info || !bits || !bitmap)
1424         return InvalidParameter;
1425
1426     height = abs(info->bmiHeader.biHeight);
1427     stride = ((info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) >> 3) & ~3;
1428
1429     if(info->bmiHeader.biHeight > 0) /* bottom-up */
1430     {
1431         bits = (BYTE*)bits + (height - 1) * stride;
1432         stride = -stride;
1433     }
1434
1435     switch(info->bmiHeader.biBitCount) {
1436     case 1:
1437         format = PixelFormat1bppIndexed;
1438         break;
1439     case 4:
1440         format = PixelFormat4bppIndexed;
1441         break;
1442     case 8:
1443         format = PixelFormat8bppIndexed;
1444         break;
1445     case 16:
1446         format = PixelFormat16bppRGB555;
1447         break;
1448     case 24:
1449         format = PixelFormat24bppRGB;
1450         break;
1451     case 32:
1452         format = PixelFormat32bppRGB;
1453         break;
1454     default:
1455         FIXME("don't know how to handle %d bpp\n", info->bmiHeader.biBitCount);
1456         *bitmap = NULL;
1457         return InvalidParameter;
1458     }
1459
1460     return GdipCreateBitmapFromScan0(info->bmiHeader.biWidth, height, stride, format,
1461                                      bits, bitmap);
1462
1463 }
1464
1465 /* FIXME: no icm */
1466 GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename,
1467     GpBitmap **bitmap)
1468 {
1469     TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
1470
1471     return GdipCreateBitmapFromFile(filename, bitmap);
1472 }
1473
1474 GpStatus WINGDIPAPI GdipCreateBitmapFromResource(HINSTANCE hInstance,
1475     GDIPCONST WCHAR* lpBitmapName, GpBitmap** bitmap)
1476 {
1477     HBITMAP hbm;
1478     GpStatus stat = InvalidParameter;
1479
1480     TRACE("%p (%s) %p\n", hInstance, debugstr_w(lpBitmapName), bitmap);
1481
1482     if(!lpBitmapName || !bitmap)
1483         return InvalidParameter;
1484
1485     /* load DIB */
1486     hbm = LoadImageW(hInstance, lpBitmapName, IMAGE_BITMAP, 0, 0,
1487                      LR_CREATEDIBSECTION);
1488
1489     if(hbm){
1490         stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
1491         DeleteObject(hbm);
1492     }
1493
1494     return stat;
1495 }
1496
1497 GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap,
1498     HBITMAP* hbmReturn, ARGB background)
1499 {
1500     GpStatus stat;
1501     HBITMAP result;
1502     UINT width, height;
1503     BITMAPINFOHEADER bih;
1504     LPBYTE bits;
1505     BitmapData lockeddata;
1506     TRACE("(%p,%p,%x)\n", bitmap, hbmReturn, background);
1507
1508     if (!bitmap || !hbmReturn) return InvalidParameter;
1509
1510     GdipGetImageWidth((GpImage*)bitmap, &width);
1511     GdipGetImageHeight((GpImage*)bitmap, &height);
1512
1513     bih.biSize = sizeof(bih);
1514     bih.biWidth = width;
1515     bih.biHeight = height;
1516     bih.biPlanes = 1;
1517     bih.biBitCount = 32;
1518     bih.biCompression = BI_RGB;
1519     bih.biSizeImage = 0;
1520     bih.biXPelsPerMeter = 0;
1521     bih.biYPelsPerMeter = 0;
1522     bih.biClrUsed = 0;
1523     bih.biClrImportant = 0;
1524
1525     result = CreateDIBSection(0, (BITMAPINFO*)&bih, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1526
1527     if (result)
1528     {
1529         lockeddata.Stride = -width * 4;
1530         lockeddata.Scan0 = bits + (width * 4 * (height - 1));
1531
1532         stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead|ImageLockModeUserInputBuf,
1533             PixelFormat32bppPARGB, &lockeddata);
1534
1535         if (stat == Ok)
1536             stat = GdipBitmapUnlockBits(bitmap, &lockeddata);
1537     }
1538     else
1539         stat = GenericError;
1540
1541     if (stat != Ok && result)
1542     {
1543         DeleteObject(result);
1544         result = NULL;
1545     }
1546
1547     *hbmReturn = result;
1548
1549     return stat;
1550 }
1551
1552 GpStatus WINGDIPAPI GdipConvertToEmfPlus(const GpGraphics* ref,
1553     GpMetafile* metafile, BOOL* succ, EmfType emfType,
1554     const WCHAR* description, GpMetafile** out_metafile)
1555 {
1556     static int calls;
1557
1558     TRACE("(%p,%p,%p,%u,%s,%p)\n", ref, metafile, succ, emfType,
1559         debugstr_w(description), out_metafile);
1560
1561     if(!ref || !metafile || !out_metafile)
1562         return InvalidParameter;
1563
1564     *succ = FALSE;
1565     *out_metafile = NULL;
1566
1567     if(!(calls++))
1568         FIXME("not implemented\n");
1569
1570     return NotImplemented;
1571 }
1572
1573 /* FIXME: this should create a bitmap in the given size with the attributes
1574  * (resolution etc.) of the graphics object */
1575 GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics(INT width, INT height,
1576     GpGraphics* target, GpBitmap** bitmap)
1577 {
1578     static int calls;
1579     GpStatus ret;
1580
1581     TRACE("(%d, %d, %p, %p)\n", width, height, target, bitmap);
1582
1583     if(!target || !bitmap)
1584         return InvalidParameter;
1585
1586     if(!(calls++))
1587         FIXME("hacked stub\n");
1588
1589     ret = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat24bppRGB,
1590                                     NULL, bitmap);
1591
1592     return ret;
1593 }
1594
1595 GpStatus WINGDIPAPI GdipCreateBitmapFromHICON(HICON hicon, GpBitmap** bitmap)
1596 {
1597     GpStatus stat;
1598     ICONINFO iinfo;
1599     BITMAP bm;
1600     int ret;
1601     UINT width, height;
1602     GpRect rect;
1603     BitmapData lockeddata;
1604     HDC screendc;
1605     BOOL has_alpha;
1606     int x, y;
1607     BYTE *bits;
1608     BITMAPINFOHEADER bih;
1609     DWORD *src;
1610     BYTE *dst_row;
1611     DWORD *dst;
1612
1613     TRACE("%p, %p\n", hicon, bitmap);
1614
1615     if(!bitmap || !GetIconInfo(hicon, &iinfo))
1616         return InvalidParameter;
1617
1618     /* get the size of the icon */
1619     ret = GetObjectA(iinfo.hbmColor ? iinfo.hbmColor : iinfo.hbmMask, sizeof(bm), &bm);
1620     if (ret == 0) {
1621         DeleteObject(iinfo.hbmColor);
1622         DeleteObject(iinfo.hbmMask);
1623         return GenericError;
1624     }
1625
1626     width = bm.bmWidth;
1627
1628     if (iinfo.hbmColor)
1629         height = abs(bm.bmHeight);
1630     else /* combined bitmap + mask */
1631         height = abs(bm.bmHeight) / 2;
1632
1633     bits = HeapAlloc(GetProcessHeap(), 0, 4*width*height);
1634     if (!bits) {
1635         DeleteObject(iinfo.hbmColor);
1636         DeleteObject(iinfo.hbmMask);
1637         return OutOfMemory;
1638     }
1639
1640     stat = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppARGB, NULL, bitmap);
1641     if (stat != Ok) {
1642         DeleteObject(iinfo.hbmColor);
1643         DeleteObject(iinfo.hbmMask);
1644         HeapFree(GetProcessHeap(), 0, bits);
1645         return stat;
1646     }
1647
1648     rect.X = 0;
1649     rect.Y = 0;
1650     rect.Width = width;
1651     rect.Height = height;
1652
1653     stat = GdipBitmapLockBits(*bitmap, &rect, ImageLockModeWrite, PixelFormat32bppARGB, &lockeddata);
1654     if (stat != Ok) {
1655         DeleteObject(iinfo.hbmColor);
1656         DeleteObject(iinfo.hbmMask);
1657         HeapFree(GetProcessHeap(), 0, bits);
1658         GdipDisposeImage((GpImage*)*bitmap);
1659         return stat;
1660     }
1661
1662     bih.biSize = sizeof(bih);
1663     bih.biWidth = width;
1664     bih.biHeight = -height;
1665     bih.biPlanes = 1;
1666     bih.biBitCount = 32;
1667     bih.biCompression = BI_RGB;
1668     bih.biSizeImage = 0;
1669     bih.biXPelsPerMeter = 0;
1670     bih.biYPelsPerMeter = 0;
1671     bih.biClrUsed = 0;
1672     bih.biClrImportant = 0;
1673
1674     screendc = GetDC(0);
1675     if (iinfo.hbmColor)
1676     {
1677         GetDIBits(screendc, iinfo.hbmColor, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1678
1679         if (bm.bmBitsPixel == 32)
1680         {
1681             has_alpha = FALSE;
1682
1683             /* If any pixel has a non-zero alpha, ignore hbmMask */
1684             src = (DWORD*)bits;
1685             for (x=0; x<width && !has_alpha; x++)
1686                 for (y=0; y<height && !has_alpha; y++)
1687                     if ((*src++ & 0xff000000) != 0)
1688                         has_alpha = TRUE;
1689         }
1690         else has_alpha = FALSE;
1691     }
1692     else
1693     {
1694         GetDIBits(screendc, iinfo.hbmMask, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1695         has_alpha = FALSE;
1696     }
1697
1698     /* copy the image data to the Bitmap */
1699     src = (DWORD*)bits;
1700     dst_row = lockeddata.Scan0;
1701     for (y=0; y<height; y++)
1702     {
1703         memcpy(dst_row, src, width*4);
1704         src += width;
1705         dst_row += lockeddata.Stride;
1706     }
1707
1708     if (!has_alpha)
1709     {
1710         if (iinfo.hbmMask)
1711         {
1712             /* read alpha data from the mask */
1713             if (iinfo.hbmColor)
1714                 GetDIBits(screendc, iinfo.hbmMask, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1715             else
1716                 GetDIBits(screendc, iinfo.hbmMask, height, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1717
1718             src = (DWORD*)bits;
1719             dst_row = lockeddata.Scan0;
1720             for (y=0; y<height; y++)
1721             {
1722                 dst = (DWORD*)dst_row;
1723                 for (x=0; x<height; x++)
1724                 {
1725                     DWORD src_value = *src++;
1726                     if (src_value)
1727                         *dst++ = 0;
1728                     else
1729                         *dst++ |= 0xff000000;
1730                 }
1731                 dst_row += lockeddata.Stride;
1732             }
1733         }
1734         else
1735         {
1736             /* set constant alpha of 255 */
1737             dst_row = bits;
1738             for (y=0; y<height; y++)
1739             {
1740                 dst = (DWORD*)dst_row;
1741                 for (x=0; x<height; x++)
1742                     *dst++ |= 0xff000000;
1743                 dst_row += lockeddata.Stride;
1744             }
1745         }
1746     }
1747
1748     ReleaseDC(0, screendc);
1749
1750     DeleteObject(iinfo.hbmColor);
1751     DeleteObject(iinfo.hbmMask);
1752
1753     GdipBitmapUnlockBits(*bitmap, &lockeddata);
1754
1755     HeapFree(GetProcessHeap(), 0, bits);
1756
1757     return Ok;
1758 }
1759
1760 static void generate_halftone_palette(ARGB *entries, UINT count)
1761 {
1762     static const BYTE halftone_values[6]={0x00,0x33,0x66,0x99,0xcc,0xff};
1763     UINT i;
1764
1765     for (i=0; i<8 && i<count; i++)
1766     {
1767         entries[i] = 0xff000000;
1768         if (i&1) entries[i] |= 0x800000;
1769         if (i&2) entries[i] |= 0x8000;
1770         if (i&4) entries[i] |= 0x80;
1771     }
1772
1773     if (8 < count)
1774         entries[i] = 0xffc0c0c0;
1775
1776     for (i=9; i<16 && i<count; i++)
1777     {
1778         entries[i] = 0xff000000;
1779         if (i&1) entries[i] |= 0xff0000;
1780         if (i&2) entries[i] |= 0xff00;
1781         if (i&4) entries[i] |= 0xff;
1782     }
1783
1784     for (i=16; i<40 && i<count; i++)
1785     {
1786         entries[i] = 0;
1787     }
1788
1789     for (i=40; i<256 && i<count; i++)
1790     {
1791         entries[i] = 0xff000000;
1792         entries[i] |= halftone_values[(i-40)%6];
1793         entries[i] |= halftone_values[((i-40)/6)%6] << 8;
1794         entries[i] |= halftone_values[((i-40)/36)%6] << 16;
1795     }
1796 }
1797
1798 static GpStatus get_screen_resolution(REAL *xres, REAL *yres)
1799 {
1800     HDC screendc = GetDC(0);
1801
1802     if (!screendc) return GenericError;
1803
1804     *xres = (REAL)GetDeviceCaps(screendc, LOGPIXELSX);
1805     *yres = (REAL)GetDeviceCaps(screendc, LOGPIXELSY);
1806
1807     ReleaseDC(0, screendc);
1808
1809     return Ok;
1810 }
1811
1812 GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride,
1813     PixelFormat format, BYTE* scan0, GpBitmap** bitmap)
1814 {
1815     BITMAPINFO* pbmi;
1816     HBITMAP hbitmap=NULL;
1817     INT row_size, dib_stride;
1818     BYTE *bits=NULL, *own_bits=NULL;
1819     REAL xres, yres;
1820     GpStatus stat;
1821
1822     TRACE("%d %d %d 0x%x %p %p\n", width, height, stride, format, scan0, bitmap);
1823
1824     if (!bitmap) return InvalidParameter;
1825
1826     if(width <= 0 || height <= 0 || (scan0 && (stride % 4))){
1827         *bitmap = NULL;
1828         return InvalidParameter;
1829     }
1830
1831     if(scan0 && !stride)
1832         return InvalidParameter;
1833
1834     stat = get_screen_resolution(&xres, &yres);
1835     if (stat != Ok) return stat;
1836
1837     row_size = (width * PIXELFORMATBPP(format)+7) / 8;
1838     dib_stride = (row_size + 3) & ~3;
1839
1840     if(stride == 0)
1841         stride = dib_stride;
1842
1843     if (format & PixelFormatGDI && !(format & (PixelFormatAlpha|PixelFormatIndexed)) && !scan0)
1844     {
1845         pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
1846         if (!pbmi)
1847             return OutOfMemory;
1848
1849         pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1850         pbmi->bmiHeader.biWidth = width;
1851         pbmi->bmiHeader.biHeight = -height;
1852         pbmi->bmiHeader.biPlanes = 1;
1853         /* FIXME: use the rest of the data from format */
1854         pbmi->bmiHeader.biBitCount = PIXELFORMATBPP(format);
1855         pbmi->bmiHeader.biCompression = BI_RGB;
1856         pbmi->bmiHeader.biSizeImage = 0;
1857         pbmi->bmiHeader.biXPelsPerMeter = 0;
1858         pbmi->bmiHeader.biYPelsPerMeter = 0;
1859         pbmi->bmiHeader.biClrUsed = 0;
1860         pbmi->bmiHeader.biClrImportant = 0;
1861
1862         hbitmap = CreateDIBSection(0, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1863
1864         GdipFree(pbmi);
1865
1866         if (!hbitmap) return GenericError;
1867
1868         stride = dib_stride;
1869     }
1870     else
1871     {
1872         /* Not a GDI format; don't try to make an HBITMAP. */
1873         if (scan0)
1874             bits = scan0;
1875         else
1876         {
1877             INT size = abs(stride) * height;
1878
1879             own_bits = bits = GdipAlloc(size);
1880             if (!own_bits) return OutOfMemory;
1881
1882             if (stride < 0)
1883                 bits += stride * (1 - height);
1884         }
1885     }
1886
1887     *bitmap = GdipAlloc(sizeof(GpBitmap));
1888     if(!*bitmap)
1889     {
1890         DeleteObject(hbitmap);
1891         GdipFree(own_bits);
1892         return OutOfMemory;
1893     }
1894
1895     (*bitmap)->image.type = ImageTypeBitmap;
1896     memcpy(&(*bitmap)->image.format, &ImageFormatMemoryBMP, sizeof(GUID));
1897     (*bitmap)->image.flags = ImageFlagsNone;
1898     (*bitmap)->image.frame_count = 1;
1899     (*bitmap)->image.current_frame = 0;
1900     (*bitmap)->image.palette = NULL;
1901     (*bitmap)->image.xres = xres;
1902     (*bitmap)->image.yres = yres;
1903     (*bitmap)->width = width;
1904     (*bitmap)->height = height;
1905     (*bitmap)->format = format;
1906     (*bitmap)->image.picture = NULL;
1907     (*bitmap)->image.stream = NULL;
1908     (*bitmap)->hbitmap = hbitmap;
1909     (*bitmap)->hdc = NULL;
1910     (*bitmap)->bits = bits;
1911     (*bitmap)->stride = stride;
1912     (*bitmap)->own_bits = own_bits;
1913     (*bitmap)->metadata_reader = NULL;
1914
1915     /* set format-related flags */
1916     if (format & (PixelFormatAlpha|PixelFormatPAlpha|PixelFormatIndexed))
1917         (*bitmap)->image.flags |= ImageFlagsHasAlpha;
1918
1919     if (format == PixelFormat1bppIndexed ||
1920         format == PixelFormat4bppIndexed ||
1921         format == PixelFormat8bppIndexed)
1922     {
1923         (*bitmap)->image.palette = GdipAlloc(sizeof(UINT) * 2 + sizeof(ARGB) * (1 << PIXELFORMATBPP(format)));
1924
1925         if (!(*bitmap)->image.palette)
1926         {
1927             GdipDisposeImage(&(*bitmap)->image);
1928             *bitmap = NULL;
1929             return OutOfMemory;
1930         }
1931
1932         (*bitmap)->image.palette->Count = 1 << PIXELFORMATBPP(format);
1933
1934         if (format == PixelFormat1bppIndexed)
1935         {
1936             (*bitmap)->image.palette->Flags = PaletteFlagsGrayScale;
1937             (*bitmap)->image.palette->Entries[0] = 0xff000000;
1938             (*bitmap)->image.palette->Entries[1] = 0xffffffff;
1939         }
1940         else
1941         {
1942             if (format == PixelFormat8bppIndexed)
1943                 (*bitmap)->image.palette->Flags = PaletteFlagsHalftone;
1944
1945             generate_halftone_palette((*bitmap)->image.palette->Entries,
1946                 (*bitmap)->image.palette->Count);
1947         }
1948     }
1949
1950     TRACE("<-- %p\n", *bitmap);
1951
1952     return Ok;
1953 }
1954
1955 GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream* stream,
1956     GpBitmap **bitmap)
1957 {
1958     GpStatus stat;
1959
1960     TRACE("%p %p\n", stream, bitmap);
1961
1962     stat = GdipLoadImageFromStream(stream, (GpImage**) bitmap);
1963
1964     if(stat != Ok)
1965         return stat;
1966
1967     if((*bitmap)->image.type != ImageTypeBitmap){
1968         GdipDisposeImage(&(*bitmap)->image);
1969         *bitmap = NULL;
1970         return GenericError; /* FIXME: what error to return? */
1971     }
1972
1973     return Ok;
1974 }
1975
1976 /* FIXME: no icm */
1977 GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream* stream,
1978     GpBitmap **bitmap)
1979 {
1980     TRACE("%p %p\n", stream, bitmap);
1981
1982     return GdipCreateBitmapFromStream(stream, bitmap);
1983 }
1984
1985 GpStatus WINGDIPAPI GdipCreateCachedBitmap(GpBitmap *bitmap, GpGraphics *graphics,
1986     GpCachedBitmap **cachedbmp)
1987 {
1988     GpStatus stat;
1989
1990     TRACE("%p %p %p\n", bitmap, graphics, cachedbmp);
1991
1992     if(!bitmap || !graphics || !cachedbmp)
1993         return InvalidParameter;
1994
1995     *cachedbmp = GdipAlloc(sizeof(GpCachedBitmap));
1996     if(!*cachedbmp)
1997         return OutOfMemory;
1998
1999     stat = GdipCloneImage(&(bitmap->image), &(*cachedbmp)->image);
2000     if(stat != Ok){
2001         GdipFree(*cachedbmp);
2002         return stat;
2003     }
2004
2005     return Ok;
2006 }
2007
2008 GpStatus WINGDIPAPI GdipCreateHICONFromBitmap(GpBitmap *bitmap, HICON *hicon)
2009 {
2010     GpStatus stat;
2011     BitmapData lockeddata;
2012     ULONG andstride, xorstride, bitssize;
2013     LPBYTE andbits, xorbits, androw, xorrow, srcrow;
2014     UINT x, y;
2015
2016     TRACE("(%p, %p)\n", bitmap, hicon);
2017
2018     if (!bitmap || !hicon)
2019         return InvalidParameter;
2020
2021     stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead,
2022         PixelFormat32bppPARGB, &lockeddata);
2023     if (stat == Ok)
2024     {
2025         andstride = ((lockeddata.Width+31)/32)*4;
2026         xorstride = lockeddata.Width*4;
2027         bitssize = (andstride + xorstride) * lockeddata.Height;
2028
2029         andbits = GdipAlloc(bitssize);
2030
2031         if (andbits)
2032         {
2033             xorbits = andbits + andstride * lockeddata.Height;
2034
2035             for (y=0; y<lockeddata.Height; y++)
2036             {
2037                 srcrow = ((LPBYTE)lockeddata.Scan0) + lockeddata.Stride * y;
2038
2039                 androw = andbits + andstride * y;
2040                 for (x=0; x<lockeddata.Width; x++)
2041                     if (srcrow[3+4*x] >= 128)
2042                         androw[x/8] |= 1 << (7-x%8);
2043
2044                 xorrow = xorbits + xorstride * y;
2045                 memcpy(xorrow, srcrow, xorstride);
2046             }
2047
2048             *hicon = CreateIcon(NULL, lockeddata.Width, lockeddata.Height, 1, 32,
2049                 andbits, xorbits);
2050
2051             GdipFree(andbits);
2052         }
2053         else
2054             stat = OutOfMemory;
2055
2056         GdipBitmapUnlockBits(bitmap, &lockeddata);
2057     }
2058
2059     return stat;
2060 }
2061
2062 GpStatus WINGDIPAPI GdipDeleteCachedBitmap(GpCachedBitmap *cachedbmp)
2063 {
2064     TRACE("%p\n", cachedbmp);
2065
2066     if(!cachedbmp)
2067         return InvalidParameter;
2068
2069     GdipDisposeImage(cachedbmp->image);
2070     GdipFree(cachedbmp);
2071
2072     return Ok;
2073 }
2074
2075 GpStatus WINGDIPAPI GdipDrawCachedBitmap(GpGraphics *graphics,
2076     GpCachedBitmap *cachedbmp, INT x, INT y)
2077 {
2078     TRACE("%p %p %d %d\n", graphics, cachedbmp, x, y);
2079
2080     if(!graphics || !cachedbmp)
2081         return InvalidParameter;
2082
2083     return GdipDrawImage(graphics, cachedbmp->image, (REAL)x, (REAL)y);
2084 }
2085
2086 GpStatus WINGDIPAPI GdipEmfToWmfBits(HENHMETAFILE hemf, UINT cbData16,
2087     LPBYTE pData16, INT iMapMode, INT eFlags)
2088 {
2089     FIXME("(%p, %d, %p, %d, %d): stub\n", hemf, cbData16, pData16, iMapMode, eFlags);
2090     return NotImplemented;
2091 }
2092
2093 /* Internal utility function: Replace the image data of dst with that of src,
2094  * and free src. */
2095 static void move_bitmap(GpBitmap *dst, GpBitmap *src, BOOL clobber_palette)
2096 {
2097     assert(src->image.type == ImageTypeBitmap);
2098     assert(dst->image.type == ImageTypeBitmap);
2099
2100     GdipFree(dst->bitmapbits);
2101     GdipFree(dst->own_bits);
2102     DeleteDC(dst->hdc);
2103     DeleteObject(dst->hbitmap);
2104
2105     if (clobber_palette)
2106     {
2107         GdipFree(dst->image.palette);
2108         dst->image.palette = src->image.palette;
2109     }
2110     else
2111         GdipFree(src->image.palette);
2112
2113     dst->image.xres = src->image.xres;
2114     dst->image.yres = src->image.yres;
2115     dst->width = src->width;
2116     dst->height = src->height;
2117     dst->format = src->format;
2118     dst->hbitmap = src->hbitmap;
2119     dst->hdc = src->hdc;
2120     dst->bits = src->bits;
2121     dst->stride = src->stride;
2122     dst->own_bits = src->own_bits;
2123     if (dst->metadata_reader)
2124         IWICMetadataReader_Release(dst->metadata_reader);
2125     dst->metadata_reader = src->metadata_reader;
2126     if (dst->image.stream)
2127         IStream_Release(dst->image.stream);
2128     dst->image.stream = src->image.stream;
2129     dst->image.frame_count = src->image.frame_count;
2130     dst->image.current_frame = src->image.current_frame;
2131     dst->image.format = src->image.format;
2132
2133     src->image.type = ~0;
2134     GdipFree(src);
2135 }
2136
2137 static GpStatus free_image_data(GpImage *image)
2138 {
2139     if(!image)
2140         return InvalidParameter;
2141
2142     if (image->type == ImageTypeBitmap)
2143     {
2144         GdipFree(((GpBitmap*)image)->bitmapbits);
2145         GdipFree(((GpBitmap*)image)->own_bits);
2146         DeleteDC(((GpBitmap*)image)->hdc);
2147         DeleteObject(((GpBitmap*)image)->hbitmap);
2148         if (((GpBitmap*)image)->metadata_reader)
2149             IWICMetadataReader_Release(((GpBitmap*)image)->metadata_reader);
2150     }
2151     else if (image->type == ImageTypeMetafile)
2152     {
2153         GpMetafile *metafile = (GpMetafile*)image;
2154         GdipFree(metafile->comment_data);
2155         DeleteEnhMetaFile(CloseEnhMetaFile(metafile->record_dc));
2156         DeleteEnhMetaFile(metafile->hemf);
2157         if (metafile->record_graphics)
2158         {
2159             WARN("metafile closed while recording\n");
2160             /* not sure what to do here; for now just prevent the graphics from functioning or using this object */
2161             metafile->record_graphics->image = NULL;
2162             metafile->record_graphics->busy = TRUE;
2163         }
2164     }
2165     else
2166     {
2167         WARN("invalid image: %p\n", image);
2168         return ObjectBusy;
2169     }
2170     if (image->picture)
2171         IPicture_Release(image->picture);
2172     if (image->stream)
2173         IStream_Release(image->stream);
2174     GdipFree(image->palette);
2175
2176     return Ok;
2177 }
2178
2179 GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
2180 {
2181     GpStatus status;
2182
2183     TRACE("%p\n", image);
2184
2185     status = free_image_data(image);
2186     if (status != Ok) return status;
2187     image->type = ~0;
2188     GdipFree(image);
2189
2190     return Ok;
2191 }
2192
2193 GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage *image, ImageItemData* item)
2194 {
2195     static int calls;
2196
2197     TRACE("(%p,%p)\n", image, item);
2198
2199     if(!image || !item)
2200         return InvalidParameter;
2201
2202     if (!(calls++))
2203         FIXME("not implemented\n");
2204
2205     return NotImplemented;
2206 }
2207
2208 GpStatus WINGDIPAPI GdipGetImageItemData(GpImage *image, ImageItemData *item)
2209 {
2210     static int calls;
2211
2212     TRACE("(%p,%p)\n", image, item);
2213
2214     if (!(calls++))
2215         FIXME("not implemented\n");
2216
2217     return NotImplemented;
2218 }
2219
2220 GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect,
2221     GpUnit *srcUnit)
2222 {
2223     TRACE("%p %p %p\n", image, srcRect, srcUnit);
2224
2225     if(!image || !srcRect || !srcUnit)
2226         return InvalidParameter;
2227     if(image->type == ImageTypeMetafile){
2228         *srcRect = ((GpMetafile*)image)->bounds;
2229         *srcUnit = ((GpMetafile*)image)->unit;
2230     }
2231     else if(image->type == ImageTypeBitmap){
2232         srcRect->X = srcRect->Y = 0.0;
2233         srcRect->Width = (REAL) ((GpBitmap*)image)->width;
2234         srcRect->Height = (REAL) ((GpBitmap*)image)->height;
2235         *srcUnit = UnitPixel;
2236     }
2237     else{
2238         srcRect->X = srcRect->Y = 0.0;
2239         srcRect->Width = ipicture_pixel_width(image->picture);
2240         srcRect->Height = ipicture_pixel_height(image->picture);
2241         *srcUnit = UnitPixel;
2242     }
2243
2244     TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
2245           srcRect->Width, srcRect->Height, *srcUnit);
2246
2247     return Ok;
2248 }
2249
2250 GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width,
2251     REAL *height)
2252 {
2253     TRACE("%p %p %p\n", image, width, height);
2254
2255     if(!image || !height || !width)
2256         return InvalidParameter;
2257
2258     if(image->type == ImageTypeMetafile){
2259         HDC hdc = GetDC(0);
2260         REAL res = (REAL)GetDeviceCaps(hdc, LOGPIXELSX);
2261
2262         ReleaseDC(0, hdc);
2263
2264         *height = convert_unit(res, ((GpMetafile*)image)->unit) *
2265                         ((GpMetafile*)image)->bounds.Height;
2266
2267         *width = convert_unit(res, ((GpMetafile*)image)->unit) *
2268                         ((GpMetafile*)image)->bounds.Width;
2269     }
2270
2271     else if(image->type == ImageTypeBitmap){
2272         *height = ((GpBitmap*)image)->height;
2273         *width = ((GpBitmap*)image)->width;
2274     }
2275     else{
2276         *height = ipicture_pixel_height(image->picture);
2277         *width = ipicture_pixel_width(image->picture);
2278     }
2279
2280     TRACE("returning (%f, %f)\n", *height, *width);
2281     return Ok;
2282 }
2283
2284 GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image,
2285     GpGraphics **graphics)
2286 {
2287     HDC hdc;
2288     GpStatus stat;
2289
2290     TRACE("%p %p\n", image, graphics);
2291
2292     if(!image || !graphics)
2293         return InvalidParameter;
2294
2295     if (image->type == ImageTypeBitmap && ((GpBitmap*)image)->hbitmap)
2296     {
2297         hdc = ((GpBitmap*)image)->hdc;
2298
2299         if(!hdc){
2300             hdc = CreateCompatibleDC(0);
2301             SelectObject(hdc, ((GpBitmap*)image)->hbitmap);
2302             ((GpBitmap*)image)->hdc = hdc;
2303         }
2304
2305         stat = GdipCreateFromHDC(hdc, graphics);
2306
2307         if (stat == Ok)
2308         {
2309             (*graphics)->image = image;
2310             (*graphics)->xres = image->xres;
2311             (*graphics)->yres = image->yres;
2312         }
2313     }
2314     else if (image->type == ImageTypeMetafile)
2315         stat = METAFILE_GetGraphicsContext((GpMetafile*)image, graphics);
2316     else
2317         stat = graphics_from_image(image, graphics);
2318
2319     return stat;
2320 }
2321
2322 GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
2323 {
2324     TRACE("%p %p\n", image, height);
2325
2326     if(!image || !height)
2327         return InvalidParameter;
2328
2329     if(image->type == ImageTypeMetafile){
2330         HDC hdc = GetDC(0);
2331         REAL res = (REAL)GetDeviceCaps(hdc, LOGPIXELSX);
2332
2333         ReleaseDC(0, hdc);
2334
2335         *height = roundr(convert_unit(res, ((GpMetafile*)image)->unit) *
2336                         ((GpMetafile*)image)->bounds.Height);
2337     }
2338     else if(image->type == ImageTypeBitmap)
2339         *height = ((GpBitmap*)image)->height;
2340     else
2341         *height = ipicture_pixel_height(image->picture);
2342
2343     TRACE("returning %d\n", *height);
2344
2345     return Ok;
2346 }
2347
2348 GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *res)
2349 {
2350     if(!image || !res)
2351         return InvalidParameter;
2352
2353     *res = image->xres;
2354
2355     TRACE("(%p) <-- %0.2f\n", image, *res);
2356
2357     return Ok;
2358 }
2359
2360 GpStatus WINGDIPAPI GdipGetImagePaletteSize(GpImage *image, INT *size)
2361 {
2362     TRACE("%p %p\n", image, size);
2363
2364     if(!image || !size)
2365         return InvalidParameter;
2366
2367     if (!image->palette || image->palette->Count == 0)
2368         *size = sizeof(ColorPalette);
2369     else
2370         *size = sizeof(UINT)*2 + sizeof(ARGB)*image->palette->Count;
2371
2372     TRACE("<-- %u\n", *size);
2373
2374     return Ok;
2375 }
2376
2377 /* FIXME: test this function for non-bitmap types */
2378 GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format)
2379 {
2380     TRACE("%p %p\n", image, format);
2381
2382     if(!image || !format)
2383         return InvalidParameter;
2384
2385     if(image->type != ImageTypeBitmap)
2386         *format = PixelFormat24bppRGB;
2387     else
2388         *format = ((GpBitmap*) image)->format;
2389
2390     return Ok;
2391 }
2392
2393 GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
2394 {
2395     TRACE("(%p, %p)\n", image, format);
2396
2397     if(!image || !format)
2398         return InvalidParameter;
2399
2400     memcpy(format, &image->format, sizeof(GUID));
2401
2402     return Ok;
2403 }
2404
2405 GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
2406 {
2407     TRACE("%p %p\n", image, type);
2408
2409     if(!image || !type)
2410         return InvalidParameter;
2411
2412     *type = image->type;
2413
2414     return Ok;
2415 }
2416
2417 GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *res)
2418 {
2419     if(!image || !res)
2420         return InvalidParameter;
2421
2422     *res = image->yres;
2423
2424     TRACE("(%p) <-- %0.2f\n", image, *res);
2425
2426     return Ok;
2427 }
2428
2429 GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
2430 {
2431     TRACE("%p %p\n", image, width);
2432
2433     if(!image || !width)
2434         return InvalidParameter;
2435
2436     if(image->type == ImageTypeMetafile){
2437         HDC hdc = GetDC(0);
2438         REAL res = (REAL)GetDeviceCaps(hdc, LOGPIXELSX);
2439
2440         ReleaseDC(0, hdc);
2441
2442         *width = roundr(convert_unit(res, ((GpMetafile*)image)->unit) *
2443                         ((GpMetafile*)image)->bounds.Width);
2444     }
2445     else if(image->type == ImageTypeBitmap)
2446         *width = ((GpBitmap*)image)->width;
2447     else
2448         *width = ipicture_pixel_width(image->picture);
2449
2450     TRACE("returning %d\n", *width);
2451
2452     return Ok;
2453 }
2454
2455 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile * metafile,
2456     MetafileHeader * header)
2457 {
2458     static int calls;
2459
2460     TRACE("(%p, %p)\n", metafile, header);
2461
2462     if(!metafile || !header)
2463         return InvalidParameter;
2464
2465     if(!(calls++))
2466         FIXME("not implemented\n");
2467
2468     memset(header, 0, sizeof(MetafileHeader));
2469
2470     return Ok;
2471 }
2472
2473 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromEmf(HENHMETAFILE hEmf,
2474     MetafileHeader *header)
2475 {
2476     static int calls;
2477
2478     if(!hEmf || !header)
2479         return InvalidParameter;
2480
2481     if(!(calls++))
2482         FIXME("not implemented\n");
2483
2484     memset(header, 0, sizeof(MetafileHeader));
2485
2486     return Ok;
2487 }
2488
2489 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromFile(GDIPCONST WCHAR *filename,
2490     MetafileHeader *header)
2491 {
2492     static int calls;
2493
2494     TRACE("(%s,%p)\n", debugstr_w(filename), header);
2495
2496     if(!filename || !header)
2497         return InvalidParameter;
2498
2499     if(!(calls++))
2500         FIXME("not implemented\n");
2501
2502     memset(header, 0, sizeof(MetafileHeader));
2503
2504     return Ok;
2505 }
2506
2507 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromStream(IStream *stream,
2508     MetafileHeader *header)
2509 {
2510     static int calls;
2511
2512     TRACE("(%p,%p)\n", stream, header);
2513
2514     if(!stream || !header)
2515         return InvalidParameter;
2516
2517     if(!(calls++))
2518         FIXME("not implemented\n");
2519
2520     memset(header, 0, sizeof(MetafileHeader));
2521
2522     return Ok;
2523 }
2524
2525 GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage *image, UINT *num)
2526 {
2527     TRACE("(%p, %p)\n", image, num);
2528
2529     if (!image || !num) return InvalidParameter;
2530
2531     *num = 0;
2532
2533     if (image->type == ImageTypeBitmap)
2534     {
2535         if (((GpBitmap *)image)->metadata_reader)
2536             IWICMetadataReader_GetCount(((GpBitmap *)image)->metadata_reader, num);
2537     }
2538
2539     return Ok;
2540 }
2541
2542 GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT num, PROPID *list)
2543 {
2544     HRESULT hr;
2545     IWICMetadataReader *reader;
2546     IWICEnumMetadataItem *enumerator;
2547     UINT prop_count, i, items_returned;
2548
2549     TRACE("(%p, %u, %p)\n", image, num, list);
2550
2551     if (!image || !list) return InvalidParameter;
2552
2553     if (image->type != ImageTypeBitmap)
2554     {
2555         FIXME("Not implemented for type %d\n", image->type);
2556         return NotImplemented;
2557     }
2558
2559     reader = ((GpBitmap *)image)->metadata_reader;
2560     if (!reader)
2561     {
2562         if (num != 0) return InvalidParameter;
2563         return Ok;
2564     }
2565
2566     hr = IWICMetadataReader_GetCount(reader, &prop_count);
2567     if (FAILED(hr)) return hresult_to_status(hr);
2568
2569     if (num != prop_count) return InvalidParameter;
2570
2571     hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2572     if (FAILED(hr)) return hresult_to_status(hr);
2573
2574     IWICEnumMetadataItem_Reset(enumerator);
2575
2576     for (i = 0; i < num; i++)
2577     {
2578         PROPVARIANT id;
2579
2580         hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, NULL, &items_returned);
2581         if (hr != S_OK) break;
2582
2583         if (id.vt != VT_UI2)
2584         {
2585             FIXME("not supported propvariant type for id: %u\n", id.vt);
2586             list[i] = 0;
2587             continue;
2588         }
2589         list[i] = id.u.uiVal;
2590     }
2591
2592     IWICEnumMetadataItem_Release(enumerator);
2593
2594     return hr == S_OK ? Ok : hresult_to_status(hr);
2595 }
2596
2597 static UINT propvariant_size(PROPVARIANT *value)
2598 {
2599     switch (value->vt & ~VT_VECTOR)
2600     {
2601     case VT_EMPTY:
2602         return 0;
2603     case VT_I1:
2604     case VT_UI1:
2605         if (!(value->vt & VT_VECTOR)) return 1;
2606         return value->u.caub.cElems;
2607     case VT_I2:
2608     case VT_UI2:
2609         if (!(value->vt & VT_VECTOR)) return 2;
2610         return value->u.caui.cElems * 2;
2611     case VT_I4:
2612     case VT_UI4:
2613     case VT_R4:
2614         if (!(value->vt & VT_VECTOR)) return 4;
2615         return value->u.caul.cElems * 4;
2616     case VT_I8:
2617     case VT_UI8:
2618     case VT_R8:
2619         if (!(value->vt & VT_VECTOR)) return 8;
2620         return value->u.cauh.cElems * 8;
2621     case VT_LPSTR:
2622         return value->u.pszVal ? strlen(value->u.pszVal) + 1 : 0;
2623     case VT_BLOB:
2624         return value->u.blob.cbSize;
2625     default:
2626         FIXME("not supported variant type %d\n", value->vt);
2627         return 0;
2628     }
2629 }
2630
2631 GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID propid, UINT *size)
2632 {
2633     HRESULT hr;
2634     IWICMetadataReader *reader;
2635     PROPVARIANT id, value;
2636
2637     TRACE("(%p,%#x,%p)\n", image, propid, size);
2638
2639     if (!size || !image) return InvalidParameter;
2640
2641     if (image->type != ImageTypeBitmap)
2642     {
2643         FIXME("Not implemented for type %d\n", image->type);
2644         return NotImplemented;
2645     }
2646
2647     reader = ((GpBitmap *)image)->metadata_reader;
2648     if (!reader) return PropertyNotFound;
2649
2650     id.vt = VT_UI2;
2651     id.u.uiVal = propid;
2652     hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
2653     if (FAILED(hr)) return PropertyNotFound;
2654
2655     *size = propvariant_size(&value);
2656     if (*size) *size += sizeof(PropertyItem);
2657     PropVariantClear(&value);
2658
2659     return Ok;
2660 }
2661
2662 #ifndef PropertyTagTypeSByte
2663 #define PropertyTagTypeSByte  6
2664 #define PropertyTagTypeSShort 8
2665 #define PropertyTagTypeFloat  11
2666 #define PropertyTagTypeDouble 12
2667 #endif
2668
2669 static UINT vt_to_itemtype(UINT vt)
2670 {
2671     static const struct
2672     {
2673         UINT vt, type;
2674     } vt2type[] =
2675     {
2676         { VT_I1, PropertyTagTypeSByte },
2677         { VT_UI1, PropertyTagTypeByte },
2678         { VT_I2, PropertyTagTypeSShort },
2679         { VT_UI2, PropertyTagTypeShort },
2680         { VT_I4, PropertyTagTypeSLONG },
2681         { VT_UI4, PropertyTagTypeLong },
2682         { VT_I8, PropertyTagTypeSRational },
2683         { VT_UI8, PropertyTagTypeRational },
2684         { VT_R4, PropertyTagTypeFloat },
2685         { VT_R8, PropertyTagTypeDouble },
2686         { VT_LPSTR, PropertyTagTypeASCII },
2687         { VT_BLOB, PropertyTagTypeUndefined }
2688     };
2689     UINT i;
2690     for (i = 0; i < sizeof(vt2type)/sizeof(vt2type[0]); i++)
2691     {
2692         if (vt2type[i].vt == vt) return vt2type[i].type;
2693     }
2694     FIXME("not supported variant type %u\n", vt);
2695     return 0;
2696 }
2697
2698 static GpStatus propvariant_to_item(PROPVARIANT *value, PropertyItem *item,
2699                                     UINT size, PROPID id)
2700 {
2701     UINT item_size, item_type;
2702
2703     item_size = propvariant_size(value);
2704     if (size != item_size + sizeof(PropertyItem)) return InvalidParameter;
2705
2706     item_type = vt_to_itemtype(value->vt & ~VT_VECTOR);
2707     if (!item_type) return InvalidParameter;
2708
2709     item->value = item + 1;
2710
2711     switch (value->vt & ~VT_VECTOR)
2712     {
2713     case VT_I1:
2714     case VT_UI1:
2715         if (!(value->vt & VT_VECTOR))
2716             *(BYTE *)item->value = value->u.bVal;
2717         else
2718             memcpy(item->value, value->u.caub.pElems, item_size);
2719         break;
2720     case VT_I2:
2721     case VT_UI2:
2722         if (!(value->vt & VT_VECTOR))
2723             *(USHORT *)item->value = value->u.uiVal;
2724         else
2725             memcpy(item->value, value->u.caui.pElems, item_size);
2726         break;
2727     case VT_I4:
2728     case VT_UI4:
2729     case VT_R4:
2730         if (!(value->vt & VT_VECTOR))
2731             *(ULONG *)item->value = value->u.ulVal;
2732         else
2733             memcpy(item->value, value->u.caul.pElems, item_size);
2734         break;
2735     case VT_I8:
2736     case VT_UI8:
2737     case VT_R8:
2738         if (!(value->vt & VT_VECTOR))
2739             *(ULONGLONG *)item->value = value->u.uhVal.QuadPart;
2740         else
2741             memcpy(item->value, value->u.cauh.pElems, item_size);
2742         break;
2743     case VT_LPSTR:
2744         memcpy(item->value, value->u.pszVal, item_size);
2745         break;
2746     case VT_BLOB:
2747         memcpy(item->value, value->u.blob.pBlobData, item_size);
2748         break;
2749     default:
2750         FIXME("not supported variant type %d\n", value->vt);
2751         return InvalidParameter;
2752     }
2753
2754     item->length = item_size;
2755     item->type = item_type;
2756     item->id = id;
2757
2758     return Ok;
2759 }
2760
2761 GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID propid, UINT size,
2762                                         PropertyItem *buffer)
2763 {
2764     GpStatus stat;
2765     HRESULT hr;
2766     IWICMetadataReader *reader;
2767     PROPVARIANT id, value;
2768
2769     TRACE("(%p,%#x,%u,%p)\n", image, propid, size, buffer);
2770
2771     if (!image || !buffer) return InvalidParameter;
2772
2773     if (image->type != ImageTypeBitmap)
2774     {
2775         FIXME("Not implemented for type %d\n", image->type);
2776         return NotImplemented;
2777     }
2778
2779     reader = ((GpBitmap *)image)->metadata_reader;
2780     if (!reader) return PropertyNotFound;
2781
2782     id.vt = VT_UI2;
2783     id.u.uiVal = propid;
2784     hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
2785     if (FAILED(hr)) return PropertyNotFound;
2786
2787     stat = propvariant_to_item(&value, buffer, size, propid);
2788     PropVariantClear(&value);
2789
2790     return stat;
2791 }
2792
2793 GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT *size, UINT *count)
2794 {
2795     HRESULT hr;
2796     IWICMetadataReader *reader;
2797     IWICEnumMetadataItem *enumerator;
2798     UINT prop_count, prop_size, i;
2799     PROPVARIANT id, value;
2800
2801     TRACE("(%p,%p,%p)\n", image, size, count);
2802
2803     if (!image || !size || !count) return InvalidParameter;
2804
2805     if (image->type != ImageTypeBitmap)
2806     {
2807         FIXME("Not implemented for type %d\n", image->type);
2808         return NotImplemented;
2809     }
2810
2811     reader = ((GpBitmap *)image)->metadata_reader;
2812     if (!reader) return PropertyNotFound;
2813
2814     hr = IWICMetadataReader_GetCount(reader, &prop_count);
2815     if (FAILED(hr)) return hresult_to_status(hr);
2816
2817     hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2818     if (FAILED(hr)) return hresult_to_status(hr);
2819
2820     IWICEnumMetadataItem_Reset(enumerator);
2821
2822     prop_size = 0;
2823
2824     PropVariantInit(&id);
2825     PropVariantInit(&value);
2826
2827     for (i = 0; i < prop_count; i++)
2828     {
2829         UINT items_returned, item_size;
2830
2831         hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, &value, &items_returned);
2832         if (hr != S_OK) break;
2833
2834         item_size = propvariant_size(&value);
2835         if (item_size) prop_size += sizeof(PropertyItem) + item_size;
2836
2837         PropVariantClear(&id);
2838         PropVariantClear(&value);
2839     }
2840
2841     IWICEnumMetadataItem_Release(enumerator);
2842
2843     if (hr != S_OK) return PropertyNotFound;
2844
2845     *count = prop_count;
2846     *size = prop_size;
2847     return Ok;
2848 }
2849
2850 GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT size,
2851                                             UINT count, PropertyItem *buf)
2852 {
2853     GpStatus status;
2854     HRESULT hr;
2855     IWICMetadataReader *reader;
2856     IWICEnumMetadataItem *enumerator;
2857     UINT prop_count, prop_size, i;
2858     PROPVARIANT id, value;
2859     char *item_value;
2860
2861     TRACE("(%p,%u,%u,%p)\n", image, size, count, buf);
2862
2863     if (!image || !buf) return InvalidParameter;
2864
2865     if (image->type != ImageTypeBitmap)
2866     {
2867         FIXME("Not implemented for type %d\n", image->type);
2868         return NotImplemented;
2869     }
2870
2871     status = GdipGetPropertySize(image, &prop_size, &prop_count);
2872     if (status != Ok) return status;
2873
2874     if (prop_count != count || prop_size != size) return InvalidParameter;
2875
2876     reader = ((GpBitmap *)image)->metadata_reader;
2877     if (!reader) return PropertyNotFound;
2878
2879     hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2880     if (FAILED(hr)) return hresult_to_status(hr);
2881
2882     IWICEnumMetadataItem_Reset(enumerator);
2883
2884     item_value = (char *)(buf + prop_count);
2885
2886     PropVariantInit(&id);
2887     PropVariantInit(&value);
2888
2889     for (i = 0; i < prop_count; i++)
2890     {
2891         PropertyItem *item;
2892         UINT items_returned, item_size;
2893
2894         hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, &value, &items_returned);
2895         if (hr != S_OK) break;
2896
2897         if (id.vt != VT_UI2)
2898         {
2899             FIXME("not supported propvariant type for id: %u\n", id.vt);
2900             continue;
2901         }
2902
2903         item_size = propvariant_size(&value);
2904         if (item_size)
2905         {
2906             item = HeapAlloc(GetProcessHeap(), 0, item_size + sizeof(*item));
2907
2908             propvariant_to_item(&value, item, item_size + sizeof(*item), id.u.uiVal);
2909             buf[i].id = item->id;
2910             buf[i].type = item->type;
2911             buf[i].length = item_size;
2912             buf[i].value = item_value;
2913             memcpy(item_value, item->value, item_size);
2914             item_value += item_size;
2915
2916             HeapFree(GetProcessHeap(), 0, item);
2917         }
2918
2919         PropVariantClear(&id);
2920         PropVariantClear(&value);
2921     }
2922
2923     IWICEnumMetadataItem_Release(enumerator);
2924
2925     if (hr != S_OK) return PropertyNotFound;
2926
2927     return Ok;
2928 }
2929
2930 struct image_format_dimension
2931 {
2932     const GUID *format;
2933     const GUID *dimension;
2934 };
2935
2936 static const struct image_format_dimension image_format_dimensions[] =
2937 {
2938     {&ImageFormatGIF, &FrameDimensionTime},
2939     {&ImageFormatIcon, &FrameDimensionResolution},
2940     {NULL}
2941 };
2942
2943 GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
2944     GDIPCONST GUID* dimensionID, UINT* count)
2945 {
2946     TRACE("(%p,%s,%p)\n", image, debugstr_guid(dimensionID), count);
2947
2948     if(!image || !count)
2949         return InvalidParameter;
2950
2951     if (!dimensionID ||
2952         IsEqualGUID(dimensionID, &image->format) ||
2953         IsEqualGUID(dimensionID, &FrameDimensionPage) ||
2954         IsEqualGUID(dimensionID, &FrameDimensionTime))
2955     {
2956         *count = image->frame_count;
2957         return Ok;
2958     }
2959
2960     return InvalidParameter;
2961 }
2962
2963 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage *image,
2964     UINT* count)
2965 {
2966     TRACE("(%p, %p)\n", image, count);
2967
2968     /* Native gdiplus 1.1 does not yet support multiple frame dimensions. */
2969
2970     if(!image || !count)
2971         return InvalidParameter;
2972
2973     *count = 1;
2974
2975     return Ok;
2976 }
2977
2978 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image,
2979     GUID* dimensionIDs, UINT count)
2980 {
2981     int i;
2982     const GUID *result=NULL;
2983
2984     TRACE("(%p,%p,%u)\n", image, dimensionIDs, count);
2985
2986     if(!image || !dimensionIDs || count != 1)
2987         return InvalidParameter;
2988
2989     for (i=0; image_format_dimensions[i].format; i++)
2990     {
2991         if (IsEqualGUID(&image->format, image_format_dimensions[i].format))
2992         {
2993             result = image_format_dimensions[i].dimension;
2994             break;
2995         }
2996     }
2997
2998     if (!result)
2999         result = &FrameDimensionPage;
3000
3001     memcpy(dimensionIDs, result, sizeof(GUID));
3002
3003     return Ok;
3004 }
3005
3006 GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
3007                                           GpImage **image)
3008 {
3009     GpStatus stat;
3010     IStream *stream;
3011
3012     TRACE("(%s) %p\n", debugstr_w(filename), image);
3013
3014     if (!filename || !image)
3015         return InvalidParameter;
3016
3017     stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
3018
3019     if (stat != Ok)
3020         return stat;
3021
3022     stat = GdipLoadImageFromStream(stream, image);
3023
3024     IStream_Release(stream);
3025
3026     return stat;
3027 }
3028
3029 /* FIXME: no icm handling */
3030 GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,GpImage **image)
3031 {
3032     TRACE("(%s) %p\n", debugstr_w(filename), image);
3033
3034     return GdipLoadImageFromFile(filename, image);
3035 }
3036
3037 static GpStatus decode_image_wic(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3038 {
3039     GpStatus status=Ok;
3040     GpBitmap *bitmap;
3041     HRESULT hr;
3042     IWICBitmapDecoder *decoder;
3043     IWICBitmapFrameDecode *frame;
3044     IWICBitmapSource *source=NULL;
3045     IWICMetadataBlockReader *block_reader;
3046     WICPixelFormatGUID wic_format;
3047     PixelFormat gdip_format=0;
3048     ColorPalette *palette = NULL;
3049     WICBitmapPaletteType palette_type = WICBitmapPaletteTypeFixedHalftone256;
3050     int i;
3051     UINT width, height, frame_count;
3052     BitmapData lockeddata;
3053     WICRect wrc;
3054     HRESULT initresult;
3055
3056     initresult = CoInitialize(NULL);
3057
3058     hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
3059         &IID_IWICBitmapDecoder, (void**)&decoder);
3060     if (FAILED(hr)) goto end;
3061
3062     hr = IWICBitmapDecoder_Initialize(decoder, stream, WICDecodeMetadataCacheOnLoad);
3063     if (SUCCEEDED(hr))
3064     {
3065         IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
3066         hr = IWICBitmapDecoder_GetFrame(decoder, active_frame, &frame);
3067     }
3068
3069     if (SUCCEEDED(hr)) /* got frame */
3070     {
3071         hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &wic_format);
3072
3073         if (SUCCEEDED(hr))
3074         {
3075             IWICBitmapSource *bmp_source;
3076             IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICBitmapSource, (void **)&bmp_source);
3077
3078             for (i=0; pixel_formats[i].wic_format; i++)
3079             {
3080                 if (IsEqualGUID(&wic_format, pixel_formats[i].wic_format))
3081                 {
3082                     source = bmp_source;
3083                     gdip_format = pixel_formats[i].gdip_format;
3084                     palette_type = pixel_formats[i].palette_type;
3085                     break;
3086                 }
3087             }
3088             if (!source)
3089             {
3090                 /* unknown format; fall back on 32bppARGB */
3091                 hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, bmp_source, &source);
3092                 gdip_format = PixelFormat32bppARGB;
3093                 IWICBitmapSource_Release(bmp_source);
3094             }
3095             TRACE("%s => %#x\n", wine_dbgstr_guid(&wic_format), gdip_format);
3096         }
3097
3098         if (SUCCEEDED(hr)) /* got source */
3099         {
3100             hr = IWICBitmapSource_GetSize(source, &width, &height);
3101
3102             if (SUCCEEDED(hr))
3103                 status = GdipCreateBitmapFromScan0(width, height, 0, gdip_format,
3104                     NULL, &bitmap);
3105
3106             if (SUCCEEDED(hr) && status == Ok) /* created bitmap */
3107             {
3108                 status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeWrite,
3109                     gdip_format, &lockeddata);
3110                 if (status == Ok) /* locked bitmap */
3111                 {
3112                     wrc.X = 0;
3113                     wrc.Width = width;
3114                     wrc.Height = 1;
3115                     for (i=0; i<height; i++)
3116                     {
3117                         wrc.Y = i;
3118                         hr = IWICBitmapSource_CopyPixels(source, &wrc, abs(lockeddata.Stride),
3119                             abs(lockeddata.Stride), (BYTE*)lockeddata.Scan0+lockeddata.Stride*i);
3120                         if (FAILED(hr)) break;
3121                     }
3122
3123                     GdipBitmapUnlockBits(bitmap, &lockeddata);
3124                 }
3125
3126                 if (SUCCEEDED(hr) && status == Ok)
3127                     *image = (GpImage*)bitmap;
3128                 else
3129                 {
3130                     *image = NULL;
3131                     GdipDisposeImage((GpImage*)bitmap);
3132                 }
3133
3134                 if (SUCCEEDED(hr) && status == Ok)
3135                 {
3136                     double dpix, dpiy;
3137                     hr = IWICBitmapSource_GetResolution(source, &dpix, &dpiy);
3138                     if (SUCCEEDED(hr))
3139                     {
3140                         bitmap->image.xres = dpix;
3141                         bitmap->image.yres = dpiy;
3142                     }
3143                     hr = S_OK;
3144                 }
3145             }
3146
3147             IWICBitmapSource_Release(source);
3148         }
3149
3150         bitmap->metadata_reader = NULL;
3151         if (IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader) == S_OK)
3152         {
3153             UINT block_count = 0;
3154             if (IWICMetadataBlockReader_GetCount(block_reader, &block_count) == S_OK && block_count)
3155                 IWICMetadataBlockReader_GetReaderByIndex(block_reader, 0, &bitmap->metadata_reader);
3156             IWICMetadataBlockReader_Release(block_reader);
3157         }
3158
3159         palette = get_palette(frame, palette_type);
3160         IWICBitmapFrameDecode_Release(frame);
3161     }
3162
3163     IWICBitmapDecoder_Release(decoder);
3164
3165 end:
3166     if (SUCCEEDED(initresult)) CoUninitialize();
3167
3168     if (FAILED(hr) && status == Ok) status = hresult_to_status(hr);
3169
3170     if (status == Ok)
3171     {
3172         /* Native GDI+ used to be smarter, but since Win7 it just sets these flags. */
3173         bitmap->image.flags |= ImageFlagsReadOnly|ImageFlagsHasRealPixelSize|ImageFlagsHasRealDPI|ImageFlagsColorSpaceRGB;
3174         bitmap->image.frame_count = frame_count;
3175         bitmap->image.current_frame = active_frame;
3176         bitmap->image.stream = stream;
3177         if (palette)
3178         {
3179             GdipFree(bitmap->image.palette);
3180             bitmap->image.palette = palette;
3181         }
3182         else
3183         {
3184             if (IsEqualGUID(&wic_format, &GUID_WICPixelFormatBlackWhite))
3185                 bitmap->image.palette->Flags = 0;
3186         }
3187         /* Pin the source stream */
3188         IStream_AddRef(stream);
3189     }
3190
3191     return status;
3192 }
3193
3194 static GpStatus decode_image_icon(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3195 {
3196     return decode_image_wic(stream, &CLSID_WICIcoDecoder, active_frame, image);
3197 }
3198
3199 static GpStatus decode_image_bmp(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3200 {
3201     GpStatus status;
3202     GpBitmap* bitmap;
3203
3204     status = decode_image_wic(stream, &CLSID_WICBmpDecoder, active_frame, image);
3205
3206     bitmap = (GpBitmap*)*image;
3207
3208     if (status == Ok && bitmap->format == PixelFormat32bppARGB)
3209     {
3210         /* WIC supports bmp files with alpha, but gdiplus does not */
3211         bitmap->format = PixelFormat32bppRGB;
3212     }
3213
3214     return status;
3215 }
3216
3217 static GpStatus decode_image_jpeg(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3218 {
3219     return decode_image_wic(stream, &CLSID_WICJpegDecoder, active_frame, image);
3220 }
3221
3222 static GpStatus decode_image_png(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3223 {
3224     return decode_image_wic(stream, &CLSID_WICPngDecoder, active_frame, image);
3225 }
3226
3227 static GpStatus decode_image_gif(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3228 {
3229     return decode_image_wic(stream, &CLSID_WICGifDecoder, active_frame, image);
3230 }
3231
3232 static GpStatus decode_image_tiff(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3233 {
3234     return decode_image_wic(stream, &CLSID_WICTiffDecoder, active_frame, image);
3235 }
3236
3237 static GpStatus decode_image_olepicture_metafile(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3238 {
3239     IPicture *pic;
3240
3241     TRACE("%p %p\n", stream, image);
3242
3243     if(!stream || !image)
3244         return InvalidParameter;
3245
3246     if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
3247         (LPVOID*) &pic) != S_OK){
3248         TRACE("Could not load picture\n");
3249         return GenericError;
3250     }
3251
3252     /* FIXME: missing initialization code */
3253     *image = GdipAlloc(sizeof(GpMetafile));
3254     if(!*image) return OutOfMemory;
3255     (*image)->type = ImageTypeMetafile;
3256     (*image)->stream = NULL;
3257     (*image)->picture = pic;
3258     (*image)->flags   = ImageFlagsNone;
3259     (*image)->frame_count = 1;
3260     (*image)->current_frame = 0;
3261     (*image)->palette = NULL;
3262
3263     TRACE("<-- %p\n", *image);
3264
3265     return Ok;
3266 }
3267
3268 typedef GpStatus (*encode_image_func)(GpImage *image, IStream* stream,
3269     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params);
3270
3271 typedef GpStatus (*decode_image_func)(IStream *stream, REFCLSID clsid, UINT active_frame, GpImage **image);
3272
3273 typedef struct image_codec {
3274     ImageCodecInfo info;
3275     encode_image_func encode_func;
3276     decode_image_func decode_func;
3277 } image_codec;
3278
3279 typedef enum {
3280     BMP,
3281     JPEG,
3282     GIF,
3283     TIFF,
3284     EMF,
3285     WMF,
3286     PNG,
3287     ICO,
3288     NUM_CODECS
3289 } ImageFormat;
3290
3291 static const struct image_codec codecs[NUM_CODECS];
3292
3293 static GpStatus get_decoder_info(IStream* stream, const struct image_codec **result)
3294 {
3295     BYTE signature[8];
3296     const BYTE *pattern, *mask;
3297     LARGE_INTEGER seek;
3298     HRESULT hr;
3299     UINT bytesread;
3300     int i, j, sig;
3301
3302     /* seek to the start of the stream */
3303     seek.QuadPart = 0;
3304     hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
3305     if (FAILED(hr)) return hresult_to_status(hr);
3306
3307     /* read the first 8 bytes */
3308     /* FIXME: This assumes all codecs have signatures <= 8 bytes in length */
3309     hr = IStream_Read(stream, signature, 8, &bytesread);
3310     if (FAILED(hr)) return hresult_to_status(hr);
3311     if (hr == S_FALSE || bytesread == 0) return GenericError;
3312
3313     for (i = 0; i < NUM_CODECS; i++) {
3314         if ((codecs[i].info.Flags & ImageCodecFlagsDecoder) &&
3315             bytesread >= codecs[i].info.SigSize)
3316         {
3317             for (sig=0; sig<codecs[i].info.SigCount; sig++)
3318             {
3319                 pattern = &codecs[i].info.SigPattern[codecs[i].info.SigSize*sig];
3320                 mask = &codecs[i].info.SigMask[codecs[i].info.SigSize*sig];
3321                 for (j=0; j<codecs[i].info.SigSize; j++)
3322                     if ((signature[j] & mask[j]) != pattern[j])
3323                         break;
3324                 if (j == codecs[i].info.SigSize)
3325                 {
3326                     *result = &codecs[i];
3327                     return Ok;
3328                 }
3329             }
3330         }
3331     }
3332
3333     TRACE("no match for %i byte signature %x %x %x %x %x %x %x %x\n", bytesread,
3334         signature[0],signature[1],signature[2],signature[3],
3335         signature[4],signature[5],signature[6],signature[7]);
3336
3337     return GenericError;
3338 }
3339
3340 GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage *image, GDIPCONST GUID *dimensionID,
3341                                                UINT frame)
3342 {
3343     GpStatus stat;
3344     LARGE_INTEGER seek;
3345     HRESULT hr;
3346     const struct image_codec *codec = NULL;
3347     IStream *stream;
3348     GpImage *new_image;
3349
3350     TRACE("(%p,%s,%u)\n", image, debugstr_guid(dimensionID), frame);
3351
3352     if (!image || !dimensionID)
3353         return InvalidParameter;
3354
3355     if (frame >= image->frame_count)
3356         return InvalidParameter;
3357
3358     if (image->type != ImageTypeBitmap && image->type != ImageTypeMetafile)
3359     {
3360         WARN("invalid image type %d\n", image->type);
3361         return InvalidParameter;
3362     }
3363
3364     if (image->current_frame == frame)
3365         return Ok;
3366
3367     if (!image->stream)
3368     {
3369         TRACE("image doesn't have an associated stream\n");
3370         return Ok;
3371     }
3372
3373     hr = IStream_Clone(image->stream, &stream);
3374     if (FAILED(hr))
3375     {
3376         STATSTG statstg;
3377
3378         hr = IStream_Stat(image->stream, &statstg, STATFLAG_NOOPEN);
3379         if (FAILED(hr)) return hresult_to_status(hr);
3380
3381         stat = GdipCreateStreamOnFile(statstg.pwcsName, GENERIC_READ, &stream);
3382         if (stat != Ok) return stat;
3383     }
3384
3385     /* choose an appropriate image decoder */
3386     stat = get_decoder_info(stream, &codec);
3387     if (stat != Ok)
3388     {
3389         IStream_Release(stream);
3390         return stat;
3391     }
3392
3393     /* seek to the start of the stream */
3394     seek.QuadPart = 0;
3395     hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
3396     if (FAILED(hr))
3397     {
3398         IStream_Release(stream);
3399         return hresult_to_status(hr);
3400     }
3401
3402     /* call on the image decoder to do the real work */
3403     stat = codec->decode_func(stream, &codec->info.Clsid, frame, &new_image);
3404
3405     if (stat == Ok)
3406     {
3407         memcpy(&new_image->format, &codec->info.FormatID, sizeof(GUID));
3408         free_image_data(image);
3409         if (image->type == ImageTypeBitmap)
3410             *(GpBitmap *)image = *(GpBitmap *)new_image;
3411         else if (image->type == ImageTypeMetafile)
3412             *(GpMetafile *)image = *(GpMetafile *)new_image;
3413         new_image->type = ~0;
3414         GdipFree(new_image);
3415         return Ok;
3416     }
3417
3418     IStream_Release(stream);
3419     return stat;
3420 }
3421
3422 GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream *stream, GpImage **image)
3423 {
3424     GpStatus stat;
3425     LARGE_INTEGER seek;
3426     HRESULT hr;
3427     const struct image_codec *codec=NULL;
3428
3429     /* choose an appropriate image decoder */
3430     stat = get_decoder_info(stream, &codec);
3431     if (stat != Ok) return stat;
3432
3433     /* seek to the start of the stream */
3434     seek.QuadPart = 0;
3435     hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
3436     if (FAILED(hr)) return hresult_to_status(hr);
3437
3438     /* call on the image decoder to do the real work */
3439     stat = codec->decode_func(stream, &codec->info.Clsid, 0, image);
3440
3441     /* take note of the original data format */
3442     if (stat == Ok)
3443     {
3444         memcpy(&(*image)->format, &codec->info.FormatID, sizeof(GUID));
3445         return Ok;
3446     }
3447
3448     return stat;
3449 }
3450
3451 /* FIXME: no ICM */
3452 GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image)
3453 {
3454     TRACE("%p %p\n", stream, image);
3455
3456     return GdipLoadImageFromStream(stream, image);
3457 }
3458
3459 GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage *image, PROPID propId)
3460 {
3461     static int calls;
3462
3463     TRACE("(%p,%u)\n", image, propId);
3464
3465     if(!image)
3466         return InvalidParameter;
3467
3468     if(!(calls++))
3469         FIXME("not implemented\n");
3470
3471     return NotImplemented;
3472 }
3473
3474 GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item)
3475 {
3476     static int calls;
3477
3478     if (!image || !item) return InvalidParameter;
3479
3480     TRACE("(%p,%p:%#x,%u,%u,%p)\n", image, item, item->id, item->type, item->length, item->value);
3481
3482     if(!(calls++))
3483         FIXME("not implemented\n");
3484
3485     return NotImplemented;
3486 }
3487
3488 GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
3489                                         GDIPCONST CLSID *clsidEncoder,
3490                                         GDIPCONST EncoderParameters *encoderParams)
3491 {
3492     GpStatus stat;
3493     IStream *stream;
3494
3495     TRACE("%p (%s) %p %p\n", image, debugstr_w(filename), clsidEncoder, encoderParams);
3496
3497     if (!image || !filename|| !clsidEncoder)
3498         return InvalidParameter;
3499
3500     stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
3501     if (stat != Ok)
3502         return GenericError;
3503
3504     stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
3505
3506     IStream_Release(stream);
3507     return stat;
3508 }
3509
3510 /*************************************************************************
3511  * Encoding functions -
3512  *   These functions encode an image in different image file formats.
3513  */
3514 #define BITMAP_FORMAT_BMP   0x4d42 /* "BM" */
3515 #define BITMAP_FORMAT_JPEG  0xd8ff
3516 #define BITMAP_FORMAT_GIF   0x4947
3517 #define BITMAP_FORMAT_PNG   0x5089
3518 #define BITMAP_FORMAT_APM   0xcdd7
3519
3520 static GpStatus encode_image_WIC(GpImage *image, IStream* stream,
3521     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3522 {
3523     GpStatus stat;
3524     GpBitmap *bitmap;
3525     IWICBitmapEncoder *encoder;
3526     IWICBitmapFrameEncode *frameencode;
3527     IPropertyBag2 *encoderoptions;
3528     HRESULT hr;
3529     UINT width, height;
3530     PixelFormat gdipformat=0;
3531     WICPixelFormatGUID wicformat;
3532     GpRect rc;
3533     BitmapData lockeddata;
3534     HRESULT initresult;
3535     UINT i;
3536
3537     if (image->type != ImageTypeBitmap)
3538         return GenericError;
3539
3540     bitmap = (GpBitmap*)image;
3541
3542     GdipGetImageWidth(image, &width);
3543     GdipGetImageHeight(image, &height);
3544
3545     rc.X = 0;
3546     rc.Y = 0;
3547     rc.Width = width;
3548     rc.Height = height;
3549
3550     initresult = CoInitialize(NULL);
3551
3552     hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
3553         &IID_IWICBitmapEncoder, (void**)&encoder);
3554     if (FAILED(hr))
3555     {
3556         if (SUCCEEDED(initresult)) CoUninitialize();
3557         return hresult_to_status(hr);
3558     }
3559
3560     hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
3561
3562     if (SUCCEEDED(hr))
3563     {
3564         hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frameencode, &encoderoptions);
3565     }
3566
3567     if (SUCCEEDED(hr)) /* created frame */
3568     {
3569         hr = IWICBitmapFrameEncode_Initialize(frameencode, encoderoptions);
3570
3571         if (SUCCEEDED(hr))
3572             hr = IWICBitmapFrameEncode_SetSize(frameencode, width, height);
3573
3574         if (SUCCEEDED(hr))
3575             hr = IWICBitmapFrameEncode_SetResolution(frameencode, image->xres, image->yres);
3576
3577         if (SUCCEEDED(hr))
3578         {
3579             for (i=0; pixel_formats[i].wic_format; i++)
3580             {
3581                 if (pixel_formats[i].gdip_format == bitmap->format)
3582                 {
3583                     memcpy(&wicformat, pixel_formats[i].wic_format, sizeof(GUID));
3584                     gdipformat = bitmap->format;
3585                     break;
3586                 }
3587             }
3588             if (!gdipformat)
3589             {
3590                 memcpy(&wicformat, &GUID_WICPixelFormat32bppBGRA, sizeof(GUID));
3591                 gdipformat = PixelFormat32bppARGB;
3592             }
3593
3594             hr = IWICBitmapFrameEncode_SetPixelFormat(frameencode, &wicformat);
3595         }
3596
3597         if (SUCCEEDED(hr))
3598         {
3599             stat = GdipBitmapLockBits(bitmap, &rc, ImageLockModeRead, gdipformat,
3600                 &lockeddata);
3601
3602             if (stat == Ok)
3603             {
3604                 UINT row_size = (lockeddata.Width * PIXELFORMATBPP(gdipformat) + 7)/8;
3605                 BYTE *row;
3606
3607                 /* write one row at a time in case stride is negative */
3608                 row = lockeddata.Scan0;
3609                 for (i=0; i<lockeddata.Height; i++)
3610                 {
3611                     hr = IWICBitmapFrameEncode_WritePixels(frameencode, 1, row_size, row_size, row);
3612                     if (FAILED(hr)) break;
3613                     row += lockeddata.Stride;
3614                 }
3615
3616                 GdipBitmapUnlockBits(bitmap, &lockeddata);
3617             }
3618             else
3619                 hr = E_FAIL;
3620         }
3621
3622         if (SUCCEEDED(hr))
3623             hr = IWICBitmapFrameEncode_Commit(frameencode);
3624
3625         IWICBitmapFrameEncode_Release(frameencode);
3626         IPropertyBag2_Release(encoderoptions);
3627     }
3628
3629     if (SUCCEEDED(hr))
3630         hr = IWICBitmapEncoder_Commit(encoder);
3631
3632     IWICBitmapEncoder_Release(encoder);
3633
3634     if (SUCCEEDED(initresult)) CoUninitialize();
3635
3636     return hresult_to_status(hr);
3637 }
3638
3639 static GpStatus encode_image_BMP(GpImage *image, IStream* stream,
3640     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3641 {
3642     return encode_image_WIC(image, stream, &CLSID_WICBmpEncoder, params);
3643 }
3644
3645 static GpStatus encode_image_tiff(GpImage *image, IStream* stream,
3646     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3647 {
3648     return encode_image_WIC(image, stream, &CLSID_WICTiffEncoder, params);
3649 }
3650
3651 static GpStatus encode_image_png(GpImage *image, IStream* stream,
3652     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3653 {
3654     return encode_image_WIC(image, stream, &CLSID_WICPngEncoder, params);
3655 }
3656
3657 static GpStatus encode_image_jpeg(GpImage *image, IStream* stream,
3658     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3659 {
3660     return encode_image_WIC(image, stream, &CLSID_WICJpegEncoder, params);
3661 }
3662
3663 /*****************************************************************************
3664  * GdipSaveImageToStream [GDIPLUS.@]
3665  */
3666 GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage *image, IStream* stream,
3667     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3668 {
3669     GpStatus stat;
3670     encode_image_func encode_image;
3671     int i;
3672
3673     TRACE("%p %p %p %p\n", image, stream, clsid, params);
3674
3675     if(!image || !stream)
3676         return InvalidParameter;
3677
3678     /* select correct encoder */
3679     encode_image = NULL;
3680     for (i = 0; i < NUM_CODECS; i++) {
3681         if ((codecs[i].info.Flags & ImageCodecFlagsEncoder) &&
3682             IsEqualCLSID(clsid, &codecs[i].info.Clsid))
3683             encode_image = codecs[i].encode_func;
3684     }
3685     if (encode_image == NULL)
3686         return UnknownImageFormat;
3687
3688     stat = encode_image(image, stream, clsid, params);
3689
3690     return stat;
3691 }
3692
3693 /*****************************************************************************
3694  * GdipSaveAdd [GDIPLUS.@]
3695  */
3696 GpStatus WINGDIPAPI GdipSaveAdd(GpImage *image, GDIPCONST EncoderParameters *params)
3697 {
3698     FIXME("(%p,%p): stub\n", image, params);
3699     return Ok;
3700 }
3701
3702 /*****************************************************************************
3703  * GdipGetImagePalette [GDIPLUS.@]
3704  */
3705 GpStatus WINGDIPAPI GdipGetImagePalette(GpImage *image, ColorPalette *palette, INT size)
3706 {
3707     INT count;
3708
3709     TRACE("(%p,%p,%i)\n", image, palette, size);
3710
3711     if (!image || !palette)
3712         return InvalidParameter;
3713
3714     count = image->palette ? image->palette->Count : 0;
3715
3716     if (size < (sizeof(UINT)*2+sizeof(ARGB)*count))
3717     {
3718         TRACE("<-- InsufficientBuffer\n");
3719         return InsufficientBuffer;
3720     }
3721
3722     if (image->palette)
3723     {
3724         palette->Flags = image->palette->Flags;
3725         palette->Count = image->palette->Count;
3726         memcpy(palette->Entries, image->palette->Entries, sizeof(ARGB)*image->palette->Count);
3727     }
3728     else
3729     {
3730         palette->Flags = 0;
3731         palette->Count = 0;
3732     }
3733     return Ok;
3734 }
3735
3736 /*****************************************************************************
3737  * GdipSetImagePalette [GDIPLUS.@]
3738  */
3739 GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image,
3740     GDIPCONST ColorPalette *palette)
3741 {
3742     ColorPalette *new_palette;
3743
3744     TRACE("(%p,%p)\n", image, palette);
3745
3746     if(!image || !palette || palette->Count > 256)
3747         return InvalidParameter;
3748
3749     new_palette = GdipAlloc(2 * sizeof(UINT) + palette->Count * sizeof(ARGB));
3750     if (!new_palette) return OutOfMemory;
3751
3752     GdipFree(image->palette);
3753     image->palette = new_palette;
3754     image->palette->Flags = palette->Flags;
3755     image->palette->Count = palette->Count;
3756     memcpy(image->palette->Entries, palette->Entries, sizeof(ARGB)*palette->Count);
3757
3758     return Ok;
3759 }
3760
3761 /*************************************************************************
3762  * Encoders -
3763  *   Structures that represent which formats we support for encoding.
3764  */
3765
3766 /* ImageCodecInfo creation routines taken from libgdiplus */
3767 static const WCHAR bmp_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}; /* Built-in BMP */
3768 static const WCHAR bmp_extension[] = {'*','.','B', 'M', 'P',';', '*','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}; /* *.BMP;*.DIB;*.RLE */
3769 static const WCHAR bmp_mimetype[] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}; /* image/bmp */
3770 static const WCHAR bmp_format[] = {'B', 'M', 'P', 0}; /* BMP */
3771 static const BYTE bmp_sig_pattern[] = { 0x42, 0x4D };
3772 static const BYTE bmp_sig_mask[] = { 0xFF, 0xFF };
3773
3774 static const WCHAR jpeg_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'J','P','E','G', 0};
3775 static const WCHAR jpeg_extension[] = {'*','.','J','P','G',';', '*','.','J','P','E','G',';', '*','.','J','P','E',';', '*','.','J','F','I','F',0};
3776 static const WCHAR jpeg_mimetype[] = {'i','m','a','g','e','/','j','p','e','g', 0};
3777 static const WCHAR jpeg_format[] = {'J','P','E','G',0};
3778 static const BYTE jpeg_sig_pattern[] = { 0xFF, 0xD8 };
3779 static const BYTE jpeg_sig_mask[] = { 0xFF, 0xFF };
3780
3781 static const WCHAR gif_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'G','I','F', 0};
3782 static const WCHAR gif_extension[] = {'*','.','G','I','F',0};
3783 static const WCHAR gif_mimetype[] = {'i','m','a','g','e','/','g','i','f', 0};
3784 static const WCHAR gif_format[] = {'G','I','F',0};
3785 static const BYTE gif_sig_pattern[4] = "GIF8";
3786 static const BYTE gif_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
3787
3788 static const WCHAR tiff_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'T','I','F','F', 0};
3789 static const WCHAR tiff_extension[] = {'*','.','T','I','F','F',';','*','.','T','I','F',0};
3790 static const WCHAR tiff_mimetype[] = {'i','m','a','g','e','/','t','i','f','f', 0};
3791 static const WCHAR tiff_format[] = {'T','I','F','F',0};
3792 static const BYTE tiff_sig_pattern[] = {0x49,0x49,42,0,0x4d,0x4d,0,42};
3793 static const BYTE tiff_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
3794
3795 static const WCHAR emf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'E','M','F', 0};
3796 static const WCHAR emf_extension[] = {'*','.','E','M','F',0};
3797 static const WCHAR emf_mimetype[] = {'i','m','a','g','e','/','x','-','e','m','f', 0};
3798 static const WCHAR emf_format[] = {'E','M','F',0};
3799 static const BYTE emf_sig_pattern[] = { 0x01, 0x00, 0x00, 0x00 };
3800 static const BYTE emf_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
3801
3802 static const WCHAR wmf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'W','M','F', 0};
3803 static const WCHAR wmf_extension[] = {'*','.','W','M','F',0};
3804 static const WCHAR wmf_mimetype[] = {'i','m','a','g','e','/','x','-','w','m','f', 0};
3805 static const WCHAR wmf_format[] = {'W','M','F',0};
3806 static const BYTE wmf_sig_pattern[] = { 0xd7, 0xcd };
3807 static const BYTE wmf_sig_mask[] = { 0xFF, 0xFF };
3808
3809 static const WCHAR png_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'P','N','G', 0};
3810 static const WCHAR png_extension[] = {'*','.','P','N','G',0};
3811 static const WCHAR png_mimetype[] = {'i','m','a','g','e','/','p','n','g', 0};
3812 static const WCHAR png_format[] = {'P','N','G',0};
3813 static const BYTE png_sig_pattern[] = { 137, 80, 78, 71, 13, 10, 26, 10, };
3814 static const BYTE png_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
3815
3816 static const WCHAR ico_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'I','C','O', 0};
3817 static const WCHAR ico_extension[] = {'*','.','I','C','O',0};
3818 static const WCHAR ico_mimetype[] = {'i','m','a','g','e','/','x','-','i','c','o','n', 0};
3819 static const WCHAR ico_format[] = {'I','C','O',0};
3820 static const BYTE ico_sig_pattern[] = { 0x00, 0x00, 0x01, 0x00 };
3821 static const BYTE ico_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
3822
3823 static const struct image_codec codecs[NUM_CODECS] = {
3824     {
3825         { /* BMP */
3826             /* Clsid */              { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3827             /* FormatID */           { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3828             /* CodecName */          bmp_codecname,
3829             /* DllName */            NULL,
3830             /* FormatDescription */  bmp_format,
3831             /* FilenameExtension */  bmp_extension,
3832             /* MimeType */           bmp_mimetype,
3833             /* Flags */              ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3834             /* Version */            1,
3835             /* SigCount */           1,
3836             /* SigSize */            2,
3837             /* SigPattern */         bmp_sig_pattern,
3838             /* SigMask */            bmp_sig_mask,
3839         },
3840         encode_image_BMP,
3841         decode_image_bmp
3842     },
3843     {
3844         { /* JPEG */
3845             /* Clsid */              { 0x557cf401, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3846             /* FormatID */           { 0xb96b3caeU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3847             /* CodecName */          jpeg_codecname,
3848             /* DllName */            NULL,
3849             /* FormatDescription */  jpeg_format,
3850             /* FilenameExtension */  jpeg_extension,
3851             /* MimeType */           jpeg_mimetype,
3852             /* Flags */              ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3853             /* Version */            1,
3854             /* SigCount */           1,
3855             /* SigSize */            2,
3856             /* SigPattern */         jpeg_sig_pattern,
3857             /* SigMask */            jpeg_sig_mask,
3858         },
3859         encode_image_jpeg,
3860         decode_image_jpeg
3861     },
3862     {
3863         { /* GIF */
3864             /* Clsid */              { 0x557cf402, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3865             /* FormatID */           { 0xb96b3cb0U, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3866             /* CodecName */          gif_codecname,
3867             /* DllName */            NULL,
3868             /* FormatDescription */  gif_format,
3869             /* FilenameExtension */  gif_extension,
3870             /* MimeType */           gif_mimetype,
3871             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3872             /* Version */            1,
3873             /* SigCount */           1,
3874             /* SigSize */            4,
3875             /* SigPattern */         gif_sig_pattern,
3876             /* SigMask */            gif_sig_mask,
3877         },
3878         NULL,
3879         decode_image_gif
3880     },
3881     {
3882         { /* TIFF */
3883             /* Clsid */              { 0x557cf405, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3884             /* FormatID */           { 0xb96b3cb1U, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3885             /* CodecName */          tiff_codecname,
3886             /* DllName */            NULL,
3887             /* FormatDescription */  tiff_format,
3888             /* FilenameExtension */  tiff_extension,
3889             /* MimeType */           tiff_mimetype,
3890             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsEncoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3891             /* Version */            1,
3892             /* SigCount */           2,
3893             /* SigSize */            4,
3894             /* SigPattern */         tiff_sig_pattern,
3895             /* SigMask */            tiff_sig_mask,
3896         },
3897         encode_image_tiff,
3898         decode_image_tiff
3899     },
3900     {
3901         { /* EMF */
3902             /* Clsid */              { 0x557cf403, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3903             /* FormatID */           { 0xb96b3cacU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3904             /* CodecName */          emf_codecname,
3905             /* DllName */            NULL,
3906             /* FormatDescription */  emf_format,
3907             /* FilenameExtension */  emf_extension,
3908             /* MimeType */           emf_mimetype,
3909             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
3910             /* Version */            1,
3911             /* SigCount */           1,
3912             /* SigSize */            4,
3913             /* SigPattern */         emf_sig_pattern,
3914             /* SigMask */            emf_sig_mask,
3915         },
3916         NULL,
3917         decode_image_olepicture_metafile
3918     },
3919     {
3920         { /* WMF */
3921             /* Clsid */              { 0x557cf404, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3922             /* FormatID */           { 0xb96b3cadU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3923             /* CodecName */          wmf_codecname,
3924             /* DllName */            NULL,
3925             /* FormatDescription */  wmf_format,
3926             /* FilenameExtension */  wmf_extension,
3927             /* MimeType */           wmf_mimetype,
3928             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
3929             /* Version */            1,
3930             /* SigCount */           1,
3931             /* SigSize */            2,
3932             /* SigPattern */         wmf_sig_pattern,
3933             /* SigMask */            wmf_sig_mask,
3934         },
3935         NULL,
3936         decode_image_olepicture_metafile
3937     },
3938     {
3939         { /* PNG */
3940             /* Clsid */              { 0x557cf406, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3941             /* FormatID */           { 0xb96b3cafU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3942             /* CodecName */          png_codecname,
3943             /* DllName */            NULL,
3944             /* FormatDescription */  png_format,
3945             /* FilenameExtension */  png_extension,
3946             /* MimeType */           png_mimetype,
3947             /* Flags */              ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3948             /* Version */            1,
3949             /* SigCount */           1,
3950             /* SigSize */            8,
3951             /* SigPattern */         png_sig_pattern,
3952             /* SigMask */            png_sig_mask,
3953         },
3954         encode_image_png,
3955         decode_image_png
3956     },
3957     {
3958         { /* ICO */
3959             /* Clsid */              { 0x557cf407, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3960             /* FormatID */           { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3961             /* CodecName */          ico_codecname,
3962             /* DllName */            NULL,
3963             /* FormatDescription */  ico_format,
3964             /* FilenameExtension */  ico_extension,
3965             /* MimeType */           ico_mimetype,
3966             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3967             /* Version */            1,
3968             /* SigCount */           1,
3969             /* SigSize */            4,
3970             /* SigPattern */         ico_sig_pattern,
3971             /* SigMask */            ico_sig_mask,
3972         },
3973         NULL,
3974         decode_image_icon
3975     },
3976 };
3977
3978 /*****************************************************************************
3979  * GdipGetImageDecodersSize [GDIPLUS.@]
3980  */
3981 GpStatus WINGDIPAPI GdipGetImageDecodersSize(UINT *numDecoders, UINT *size)
3982 {
3983     int decoder_count=0;
3984     int i;
3985     TRACE("%p %p\n", numDecoders, size);
3986
3987     if (!numDecoders || !size)
3988         return InvalidParameter;
3989
3990     for (i=0; i<NUM_CODECS; i++)
3991     {
3992         if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
3993             decoder_count++;
3994     }
3995
3996     *numDecoders = decoder_count;
3997     *size = decoder_count * sizeof(ImageCodecInfo);
3998
3999     return Ok;
4000 }
4001
4002 /*****************************************************************************
4003  * GdipGetImageDecoders [GDIPLUS.@]
4004  */
4005 GpStatus WINGDIPAPI GdipGetImageDecoders(UINT numDecoders, UINT size, ImageCodecInfo *decoders)
4006 {
4007     int i, decoder_count=0;
4008     TRACE("%u %u %p\n", numDecoders, size, decoders);
4009
4010     if (!decoders ||
4011         size != numDecoders * sizeof(ImageCodecInfo))
4012         return GenericError;
4013
4014     for (i=0; i<NUM_CODECS; i++)
4015     {
4016         if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
4017         {
4018             if (decoder_count == numDecoders) return GenericError;
4019             memcpy(&decoders[decoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
4020             decoder_count++;
4021         }
4022     }
4023
4024     if (decoder_count < numDecoders) return GenericError;
4025
4026     return Ok;
4027 }
4028
4029 /*****************************************************************************
4030  * GdipGetImageEncodersSize [GDIPLUS.@]
4031  */
4032 GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size)
4033 {
4034     int encoder_count=0;
4035     int i;
4036     TRACE("%p %p\n", numEncoders, size);
4037
4038     if (!numEncoders || !size)
4039         return InvalidParameter;
4040
4041     for (i=0; i<NUM_CODECS; i++)
4042     {
4043         if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
4044             encoder_count++;
4045     }
4046
4047     *numEncoders = encoder_count;
4048     *size = encoder_count * sizeof(ImageCodecInfo);
4049
4050     return Ok;
4051 }
4052
4053 /*****************************************************************************
4054  * GdipGetImageEncoders [GDIPLUS.@]
4055  */
4056 GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
4057 {
4058     int i, encoder_count=0;
4059     TRACE("%u %u %p\n", numEncoders, size, encoders);
4060
4061     if (!encoders ||
4062         size != numEncoders * sizeof(ImageCodecInfo))
4063         return GenericError;
4064
4065     for (i=0; i<NUM_CODECS; i++)
4066     {
4067         if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
4068         {
4069             if (encoder_count == numEncoders) return GenericError;
4070             memcpy(&encoders[encoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
4071             encoder_count++;
4072         }
4073     }
4074
4075     if (encoder_count < numEncoders) return GenericError;
4076
4077     return Ok;
4078 }
4079
4080 GpStatus WINGDIPAPI GdipGetEncoderParameterListSize(GpImage *image,
4081     GDIPCONST CLSID* clsidEncoder, UINT *size)
4082 {
4083     static int calls;
4084
4085     TRACE("(%p,%s,%p)\n", image, debugstr_guid(clsidEncoder), size);
4086
4087     if(!(calls++))
4088         FIXME("not implemented\n");
4089
4090     *size = 0;
4091
4092     return NotImplemented;
4093 }
4094
4095 static PixelFormat get_16bpp_format(HBITMAP hbm)
4096 {
4097     BITMAPV4HEADER bmh;
4098     HDC hdc;
4099     PixelFormat result;
4100
4101     hdc = CreateCompatibleDC(NULL);
4102
4103     memset(&bmh, 0, sizeof(bmh));
4104     bmh.bV4Size = sizeof(bmh);
4105     bmh.bV4Width = 1;
4106     bmh.bV4Height = 1;
4107     bmh.bV4V4Compression = BI_BITFIELDS;
4108     bmh.bV4BitCount = 16;
4109
4110     GetDIBits(hdc, hbm, 0, 0, NULL, (BITMAPINFO*)&bmh, DIB_RGB_COLORS);
4111
4112     if (bmh.bV4RedMask == 0x7c00 &&
4113         bmh.bV4GreenMask == 0x3e0 &&
4114         bmh.bV4BlueMask == 0x1f)
4115     {
4116         result = PixelFormat16bppRGB555;
4117     }
4118     else if (bmh.bV4RedMask == 0xf800 &&
4119         bmh.bV4GreenMask == 0x7e0 &&
4120         bmh.bV4BlueMask == 0x1f)
4121     {
4122         result = PixelFormat16bppRGB565;
4123     }
4124     else
4125     {
4126         FIXME("unrecognized bitfields %x,%x,%x\n", bmh.bV4RedMask,
4127             bmh.bV4GreenMask, bmh.bV4BlueMask);
4128         result = PixelFormatUndefined;
4129     }
4130
4131     DeleteDC(hdc);
4132
4133     return result;
4134 }
4135
4136 /*****************************************************************************
4137  * GdipCreateBitmapFromHBITMAP [GDIPLUS.@]
4138  */
4139 GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap)
4140 {
4141     BITMAP bm;
4142     GpStatus retval;
4143     PixelFormat format;
4144     BitmapData lockeddata;
4145     INT y;
4146
4147     TRACE("%p %p %p\n", hbm, hpal, bitmap);
4148
4149     if(!hbm || !bitmap)
4150         return InvalidParameter;
4151
4152     if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
4153             return InvalidParameter;
4154
4155     /* TODO: Figure out the correct format for 16, 32, 64 bpp */
4156     switch(bm.bmBitsPixel) {
4157         case 1:
4158             format = PixelFormat1bppIndexed;
4159             break;
4160         case 4:
4161             format = PixelFormat4bppIndexed;
4162             break;
4163         case 8:
4164             format = PixelFormat8bppIndexed;
4165             break;
4166         case 16:
4167             format = get_16bpp_format(hbm);
4168             if (format == PixelFormatUndefined)
4169                 return InvalidParameter;
4170             break;
4171         case 24:
4172             format = PixelFormat24bppRGB;
4173             break;
4174         case 32:
4175             format = PixelFormat32bppRGB;
4176             break;
4177         case 48:
4178             format = PixelFormat48bppRGB;
4179             break;
4180         default:
4181             FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
4182             return InvalidParameter;
4183     }
4184
4185     retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, 0,
4186         format, NULL, bitmap);
4187
4188     if (retval == Ok)
4189     {
4190         retval = GdipBitmapLockBits(*bitmap, NULL, ImageLockModeWrite,
4191             format, &lockeddata);
4192         if (retval == Ok)
4193         {
4194             if (bm.bmBits)
4195             {
4196                 for (y=0; y<bm.bmHeight; y++)
4197                 {
4198                     memcpy((BYTE*)lockeddata.Scan0+lockeddata.Stride*y,
4199                            (BYTE*)bm.bmBits+bm.bmWidthBytes*(bm.bmHeight-1-y),
4200                            bm.bmWidthBytes);
4201                 }
4202             }
4203             else
4204             {
4205                 HDC hdc;
4206                 HBITMAP oldhbm;
4207                 BITMAPINFO *pbmi;
4208                 INT src_height, dst_stride;
4209                 BYTE *dst_bits;
4210
4211                 hdc = CreateCompatibleDC(NULL);
4212                 oldhbm = SelectObject(hdc, hbm);
4213
4214                 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
4215
4216                 if (pbmi)
4217                 {
4218                     pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
4219                     pbmi->bmiHeader.biBitCount = 0;
4220
4221                     GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
4222
4223                     src_height = abs(pbmi->bmiHeader.biHeight);
4224
4225                     if (pbmi->bmiHeader.biHeight > 0)
4226                     {
4227                         dst_bits = (BYTE*)lockeddata.Scan0+lockeddata.Stride*(src_height-1);
4228                         dst_stride = -lockeddata.Stride;
4229                     }
4230                     else
4231                     {
4232                         dst_bits = lockeddata.Scan0;
4233                         dst_stride = lockeddata.Stride;
4234                     }
4235
4236                     for (y=0; y<src_height; y++)
4237                     {
4238                         GetDIBits(hdc, hbm, y, 1, dst_bits+dst_stride*y,
4239                             pbmi, DIB_RGB_COLORS);
4240                     }
4241
4242                     GdipFree(pbmi);
4243                 }
4244                 else
4245                     retval = OutOfMemory;
4246
4247                 SelectObject(hdc, oldhbm);
4248                 DeleteDC(hdc);
4249             }
4250
4251             GdipBitmapUnlockBits(*bitmap, &lockeddata);
4252         }
4253
4254         if (retval == Ok && hpal)
4255         {
4256             WORD num_palette_entries;
4257             PALETTEENTRY *palette_entries=NULL;
4258             ColorPalette *palette=NULL;
4259             int i;
4260
4261             if (!GetObjectW(hpal, sizeof(num_palette_entries), &num_palette_entries))
4262                 retval = GenericError;
4263
4264             if (retval == Ok)
4265             {
4266                 palette_entries = GdipAlloc(sizeof(PALETTEENTRY) * num_palette_entries);
4267                 palette = GdipAlloc(sizeof(ColorPalette) + sizeof(ARGB) * (num_palette_entries-1));
4268
4269                 if (!palette_entries || !palette)
4270                     retval = OutOfMemory;
4271             }
4272
4273             if (retval == Ok)
4274             {
4275                 if (!GetPaletteEntries(hpal, 0, num_palette_entries, palette_entries))
4276                     retval = GenericError;
4277             }
4278
4279             if (retval == Ok)
4280             {
4281                 palette->Flags = 0;
4282                 palette->Count = num_palette_entries;
4283
4284                 for (i=0; i<num_palette_entries; i++)
4285                 {
4286                     PALETTEENTRY * entry = &palette_entries[i];
4287                     palette->Entries[i] = 0xff000000 | entry->peRed << 16 |
4288                         entry->peGreen << 8 | entry->peBlue;
4289                 }
4290
4291                 retval = GdipSetImagePalette((GpImage*)*bitmap, palette);
4292             }
4293
4294             GdipFree(palette_entries);
4295             GdipFree(palette);
4296         }
4297
4298         if (retval != Ok)
4299         {
4300             GdipDisposeImage((GpImage*)*bitmap);
4301             *bitmap = NULL;
4302         }
4303     }
4304
4305     return retval;
4306 }
4307
4308 GpStatus WINGDIPAPI GdipDeleteEffect(CGpEffect *effect)
4309 {
4310     FIXME("(%p): stub\n", effect);
4311     /* note: According to Jose Roca's GDI+ Docs, this is not implemented
4312      * in Windows's gdiplus */
4313     return NotImplemented;
4314 }
4315
4316 /*****************************************************************************
4317  * GdipSetEffectParameters [GDIPLUS.@]
4318  */
4319 GpStatus WINGDIPAPI GdipSetEffectParameters(CGpEffect *effect,
4320     const VOID *params, const UINT size)
4321 {
4322     static int calls;
4323
4324     TRACE("(%p,%p,%u)\n", effect, params, size);
4325
4326     if(!(calls++))
4327         FIXME("not implemented\n");
4328
4329     return NotImplemented;
4330 }
4331
4332 /*****************************************************************************
4333  * GdipGetImageFlags [GDIPLUS.@]
4334  */
4335 GpStatus WINGDIPAPI GdipGetImageFlags(GpImage *image, UINT *flags)
4336 {
4337     TRACE("%p %p\n", image, flags);
4338
4339     if(!image || !flags)
4340         return InvalidParameter;
4341
4342     *flags = image->flags;
4343
4344     return Ok;
4345 }
4346
4347 GpStatus WINGDIPAPI GdipTestControl(GpTestControlEnum control, void *param)
4348 {
4349     TRACE("(%d, %p)\n", control, param);
4350
4351     switch(control){
4352         case TestControlForceBilinear:
4353             if(param)
4354                 FIXME("TestControlForceBilinear not handled\n");
4355             break;
4356         case TestControlNoICM:
4357             if(param)
4358                 FIXME("TestControlNoICM not handled\n");
4359             break;
4360         case TestControlGetBuildNumber:
4361             *((DWORD*)param) = 3102;
4362             break;
4363     }
4364
4365     return Ok;
4366 }
4367
4368 GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR* fileName,
4369                             HDC hdc, EmfType type, GDIPCONST GpRectF *pFrameRect,
4370                             MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc,
4371                             GpMetafile **metafile)
4372 {
4373     FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
4374                                  frameUnit, debugstr_w(desc), metafile);
4375
4376     return NotImplemented;
4377 }
4378
4379 GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR* fileName, HDC hdc, EmfType type,
4380                             GDIPCONST GpRect *pFrameRect, MetafileFrameUnit frameUnit,
4381                             GDIPCONST WCHAR *desc, GpMetafile **metafile)
4382 {
4383     FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
4384                                  frameUnit, debugstr_w(desc), metafile);
4385
4386     return NotImplemented;
4387 }
4388
4389 GpStatus WINGDIPAPI GdipImageForceValidation(GpImage *image)
4390 {
4391     TRACE("%p\n", image);
4392
4393     return Ok;
4394 }
4395
4396 /*****************************************************************************
4397  * GdipGetImageThumbnail [GDIPLUS.@]
4398  */
4399 GpStatus WINGDIPAPI GdipGetImageThumbnail(GpImage *image, UINT width, UINT height,
4400                             GpImage **ret_image, GetThumbnailImageAbort cb,
4401                             VOID * cb_data)
4402 {
4403     GpStatus stat;
4404     GpGraphics *graphics;
4405     UINT srcwidth, srcheight;
4406
4407     TRACE("(%p %u %u %p %p %p)\n",
4408         image, width, height, ret_image, cb, cb_data);
4409
4410     if (!image || !ret_image)
4411         return InvalidParameter;
4412
4413     if (!width) width = 120;
4414     if (!height) height = 120;
4415
4416     GdipGetImageWidth(image, &srcwidth);
4417     GdipGetImageHeight(image, &srcheight);
4418
4419     stat = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppARGB,
4420         NULL, (GpBitmap**)ret_image);
4421
4422     if (stat == Ok)
4423     {
4424         stat = GdipGetImageGraphicsContext(*ret_image, &graphics);
4425
4426         if (stat == Ok)
4427         {
4428             stat = GdipDrawImageRectRectI(graphics, image,
4429                 0, 0, width, height, 0, 0, srcwidth, srcheight, UnitPixel,
4430                 NULL, NULL, NULL);
4431
4432             GdipDeleteGraphics(graphics);
4433         }
4434
4435         if (stat != Ok)
4436         {
4437             GdipDisposeImage(*ret_image);
4438             *ret_image = NULL;
4439         }
4440     }
4441
4442     return stat;
4443 }
4444
4445 /*****************************************************************************
4446  * GdipImageRotateFlip [GDIPLUS.@]
4447  */
4448 GpStatus WINGDIPAPI GdipImageRotateFlip(GpImage *image, RotateFlipType type)
4449 {
4450     GpBitmap *new_bitmap;
4451     GpBitmap *bitmap;
4452     int bpp, bytesperpixel;
4453     int rotate_90, flip_x, flip_y;
4454     int src_x_offset, src_y_offset;
4455     LPBYTE src_origin;
4456     UINT x, y, width, height;
4457     BitmapData src_lock, dst_lock;
4458     GpStatus stat;
4459
4460     TRACE("(%p, %u)\n", image, type);
4461
4462     if (!image)
4463         return InvalidParameter;
4464
4465     rotate_90 = type&1;
4466     flip_x = (type&6) == 2 || (type&6) == 4;
4467     flip_y = (type&3) == 1 || (type&3) == 2;
4468
4469     if (image->type != ImageTypeBitmap)
4470     {
4471         FIXME("Not implemented for type %i\n", image->type);
4472         return NotImplemented;
4473     }
4474
4475     bitmap = (GpBitmap*)image;
4476     bpp = PIXELFORMATBPP(bitmap->format);
4477
4478     if (bpp < 8)
4479     {
4480         FIXME("Not implemented for %i bit images\n", bpp);
4481         return NotImplemented;
4482     }
4483
4484     if (rotate_90)
4485     {
4486         width = bitmap->height;
4487         height = bitmap->width;
4488     }
4489     else
4490     {
4491         width = bitmap->width;
4492         height = bitmap->height;
4493     }
4494
4495     bytesperpixel = bpp/8;
4496
4497     stat = GdipCreateBitmapFromScan0(width, height, 0, bitmap->format, NULL, &new_bitmap);
4498
4499     if (stat != Ok)
4500         return stat;
4501
4502     stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, bitmap->format, &src_lock);
4503
4504     if (stat == Ok)
4505     {
4506         stat = GdipBitmapLockBits(new_bitmap, NULL, ImageLockModeWrite, bitmap->format, &dst_lock);
4507
4508         if (stat == Ok)
4509         {
4510             LPBYTE src_row, src_pixel;
4511             LPBYTE dst_row, dst_pixel;
4512
4513             src_origin = src_lock.Scan0;
4514             if (flip_x) src_origin += bytesperpixel * (bitmap->width - 1);
4515             if (flip_y) src_origin += src_lock.Stride * (bitmap->height - 1);
4516
4517             if (rotate_90)
4518             {
4519                 if (flip_y) src_x_offset = -src_lock.Stride;
4520                 else src_x_offset = src_lock.Stride;
4521                 if (flip_x) src_y_offset = -bytesperpixel;
4522                 else src_y_offset = bytesperpixel;
4523             }
4524             else
4525             {
4526                 if (flip_x) src_x_offset = -bytesperpixel;
4527                 else src_x_offset = bytesperpixel;
4528                 if (flip_y) src_y_offset = -src_lock.Stride;
4529                 else src_y_offset = src_lock.Stride;
4530             }
4531
4532             src_row = src_origin;
4533             dst_row = dst_lock.Scan0;
4534             for (y=0; y<height; y++)
4535             {
4536                 src_pixel = src_row;
4537                 dst_pixel = dst_row;
4538                 for (x=0; x<width; x++)
4539                 {
4540                     /* FIXME: This could probably be faster without memcpy. */
4541                     memcpy(dst_pixel, src_pixel, bytesperpixel);
4542                     dst_pixel += bytesperpixel;
4543                     src_pixel += src_x_offset;
4544                 }
4545                 src_row += src_y_offset;
4546                 dst_row += dst_lock.Stride;
4547             }
4548
4549             GdipBitmapUnlockBits(new_bitmap, &dst_lock);
4550         }
4551
4552         GdipBitmapUnlockBits(bitmap, &src_lock);
4553     }
4554
4555     if (stat == Ok)
4556         move_bitmap(bitmap, new_bitmap, FALSE);
4557     else
4558         GdipDisposeImage((GpImage*)new_bitmap);
4559
4560     return stat;
4561 }
4562
4563 /*****************************************************************************
4564  * GdipConvertToEmfPlusToFile [GDIPLUS.@]
4565  */
4566
4567 GpStatus WINGDIPAPI GdipConvertToEmfPlusToFile(const GpGraphics* refGraphics,
4568                                                GpMetafile* metafile, BOOL* conversionSuccess,
4569                                                const WCHAR* filename, EmfType emfType,
4570                                                const WCHAR* description, GpMetafile** out_metafile)
4571 {
4572     FIXME("stub: %p, %p, %p, %p, %u, %p, %p\n", refGraphics, metafile, conversionSuccess, filename, emfType, description, out_metafile);
4573     return NotImplemented;
4574 }