reactos/dll/win32/gdiplus/image.c

   1 /*
   2  * Copyright (C) 2007 Google (Evan Stade)
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20
  21 #define NONAMELESSUNION
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "wingdi.h"
  27
  28 #define COBJMACROS
  29 #include "objbase.h"
  30 #include "olectl.h"
  31 #include "ole2.h"
  32
  33 #include "initguid.h"
  34 #include "wincodec.h"
  35 #include "gdiplus.h"
  36 #include "gdiplus_private.h"
  37 #include "wine/debug.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
  40
  41 #define PIXELFORMATBPP(x) ((x) ? ((x) >> 8) & 255 : 24)
  42
  43 static INT ipicture_pixel_height(IPicture *pic)
  44 {
  45     HDC hdcref;
  46     OLE_YSIZE_HIMETRIC y;
  47
  48     IPicture_get_Height(pic, &y);
  49
  50     hdcref = GetDC(0);
  51
  52     y = MulDiv(y, GetDeviceCaps(hdcref, LOGPIXELSY), INCH_HIMETRIC);
  53     ReleaseDC(0, hdcref);
  54
  55     return y;
  56 }
  57
  58 static INT ipicture_pixel_width(IPicture *pic)
  59 {
  60     HDC hdcref;
  61     OLE_XSIZE_HIMETRIC x;
  62
  63     IPicture_get_Width(pic, &x);
  64
  65     hdcref = GetDC(0);
  66
  67     x = MulDiv(x, GetDeviceCaps(hdcref, LOGPIXELSX), INCH_HIMETRIC);
  68
  69     ReleaseDC(0, hdcref);
  70
  71     return x;
  72 }
  73
  74 GpStatus WINGDIPAPI GdipBitmapApplyEffect(GpBitmap* bitmap, CGpEffect* effect,
  75     RECT* roi, BOOL useAuxData, VOID** auxData, INT* auxDataSize)
  76 {
  77     FIXME("(%p %p %p %d %p %p): stub\n", bitmap, effect, roi, useAuxData, auxData, auxDataSize);
  78     /*
  79      * Note: According to Jose Roca's GDI+ docs, this function is not
  80      * implemented in Windows's GDI+.
  81      */
  82     return NotImplemented;
  83 }
  84
  85 GpStatus WINGDIPAPI GdipBitmapCreateApplyEffect(GpBitmap** inputBitmaps,
  86     INT numInputs, CGpEffect* effect, RECT* roi, RECT* outputRect,
  87     GpBitmap** outputBitmap, BOOL useAuxData, VOID** auxData, INT* auxDataSize)
  88 {
  89     FIXME("(%p %d %p %p %p %p %d %p %p): stub\n", inputBitmaps, numInputs, effect, roi, outputRect, outputBitmap, useAuxData, auxData, auxDataSize);
  90     /*
  91      * Note: According to Jose Roca's GDI+ docs, this function is not
  92      * implemented in Windows's GDI+.
  93      */
  94     return NotImplemented;
  95 }
  96
  97 GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap* bitmap, INT x, INT y,
  98     ARGB *color)
  99 {
 100     static int calls;
 101     TRACE("%p %d %d %p\n", bitmap, x, y, color);
 102
 103     if(!bitmap || !color)
 104         return InvalidParameter;
 105
 106     if(!(calls++))
 107         FIXME("not implemented\n");
 108
 109     *color = 0xdeadbeef;
 110
 111     return NotImplemented;
 112 }
 113
 114 GpStatus WINGDIPAPI GdipBitmapSetPixel(GpBitmap* bitmap, INT x, INT y,
 115     ARGB color)
 116 {
 117     static int calls;
 118     TRACE("bitmap:%p, x:%d, y:%d, color:%08x\n", bitmap, x, y, color);
 119
 120     if(!bitmap)
 121         return InvalidParameter;
 122
 123     if(!(calls++))
 124         FIXME("not implemented\n");
 125
 126     return NotImplemented;
 127 }
 128
 129 /* This function returns a pointer to an array of pixels that represents the
 130  * bitmap. The *entire* bitmap is locked according to the lock mode specified by
 131  * flags.  It is correct behavior that a user who calls this function with write
 132  * privileges can write to the whole bitmap (not just the area in rect).
 133  *
 134  * FIXME: only used portion of format is bits per pixel. */
 135 GpStatus WINGDIPAPI GdipBitmapLockBits(GpBitmap* bitmap, GDIPCONST GpRect* rect,
 136     UINT flags, PixelFormat format, BitmapData* lockeddata)
 137 {
 138     BOOL bm_is_selected;
 139     INT stride, bitspp = PIXELFORMATBPP(format);
 140     HDC hdc;
 141     HBITMAP hbm, old = NULL;
 142     BITMAPINFO *pbmi;
 143     BYTE *buff = NULL;
 144     UINT abs_height;
 145     GpRect act_rect; /* actual rect to be used */
 146
 147     TRACE("%p %p %d %d %p\n", bitmap, rect, flags, format, lockeddata);
 148
 149     if(!lockeddata || !bitmap)
 150         return InvalidParameter;
 151
 152     if(rect){
 153         if(rect->X < 0 || rect->Y < 0 || (rect->X + rect->Width > bitmap->width) ||
 154           (rect->Y + rect->Height > bitmap->height) || !flags)
 155             return InvalidParameter;
 156
 157         act_rect = *rect;
 158     }
 159     else{
 160         act_rect.X = act_rect.Y = 0;
 161         act_rect.Width  = bitmap->width;
 162         act_rect.Height = bitmap->height;
 163     }
 164
 165     if(flags & ImageLockModeUserInputBuf)
 166         return NotImplemented;
 167
 168     if(bitmap->lockmode)
 169         return WrongState;
 170
 171     if (bitmap->bits && bitmap->format == format)
 172     {
 173         /* no conversion is necessary; just use the bits directly */
 174         lockeddata->Width = act_rect.Width;
 175         lockeddata->Height = act_rect.Height;
 176         lockeddata->PixelFormat = format;
 177         lockeddata->Reserved = flags;
 178         lockeddata->Stride = bitmap->stride;
 179         lockeddata->Scan0 = bitmap->bits + (bitspp / 8) * act_rect.X +
 180                             bitmap->stride * act_rect.Y;
 181
 182         bitmap->lockmode = flags;
 183         bitmap->numlocks++;
 184
 185         return Ok;
 186     }
 187
 188     hbm = bitmap->hbitmap;
 189     hdc = bitmap->hdc;
 190     bm_is_selected = (hdc != 0);
 191
 192     pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
 193     if (!pbmi)
 194         return OutOfMemory;
 195     pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 196     pbmi->bmiHeader.biBitCount = 0;
 197
 198     if(!bm_is_selected){
 199         hdc = CreateCompatibleDC(0);
 200         old = SelectObject(hdc, hbm);
 201     }
 202
 203     /* fill out bmi */
 204     GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
 205
 206     abs_height = abs(pbmi->bmiHeader.biHeight);
 207     stride = pbmi->bmiHeader.biWidth * bitspp / 8;
 208     stride = (stride + 3) & ~3;
 209
 210     buff = GdipAlloc(stride * abs_height);
 211
 212     pbmi->bmiHeader.biBitCount = bitspp;
 213
 214     if(buff)
 215         GetDIBits(hdc, hbm, 0, abs_height, buff, pbmi, DIB_RGB_COLORS);
 216
 217     if(!bm_is_selected){
 218         SelectObject(hdc, old);
 219         DeleteDC(hdc);
 220     }
 221
 222     if(!buff){
 223         GdipFree(pbmi);
 224         return OutOfMemory;
 225     }
 226
 227     lockeddata->Width  = act_rect.Width;
 228     lockeddata->Height = act_rect.Height;
 229     lockeddata->PixelFormat = format;
 230     lockeddata->Reserved = flags;
 231
 232     if(pbmi->bmiHeader.biHeight > 0){
 233         lockeddata->Stride = -stride;
 234         lockeddata->Scan0  = buff + (bitspp / 8) * act_rect.X +
 235                              stride * (abs_height - 1 - act_rect.Y);
 236     }
 237     else{
 238         lockeddata->Stride = stride;
 239         lockeddata->Scan0  = buff + (bitspp / 8) * act_rect.X + stride * act_rect.Y;
 240     }
 241
 242     bitmap->lockmode = flags;
 243     bitmap->numlocks++;
 244
 245     bitmap->bitmapbits = buff;
 246
 247     GdipFree(pbmi);
 248     return Ok;
 249 }
 250
 251 GpStatus WINGDIPAPI GdipBitmapSetResolution(GpBitmap* bitmap, REAL xdpi, REAL ydpi)
 252 {
 253     FIXME("(%p, %.2f, %.2f)\n", bitmap, xdpi, ydpi);
 254
 255     return NotImplemented;
 256 }
 257
 258 GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap* bitmap,
 259     BitmapData* lockeddata)
 260 {
 261     HDC hdc;
 262     HBITMAP hbm, old = NULL;
 263     BOOL bm_is_selected;
 264     BITMAPINFO *pbmi;
 265
 266     if(!bitmap || !lockeddata)
 267         return InvalidParameter;
 268
 269     if(!bitmap->lockmode)
 270         return WrongState;
 271
 272     if(lockeddata->Reserved & ImageLockModeUserInputBuf)
 273         return NotImplemented;
 274
 275     if(lockeddata->Reserved & ImageLockModeRead){
 276         if(!(--bitmap->numlocks))
 277             bitmap->lockmode = 0;
 278
 279         GdipFree(bitmap->bitmapbits);
 280         bitmap->bitmapbits = NULL;
 281         return Ok;
 282     }
 283
 284     if (!bitmap->bitmapbits)
 285     {
 286         /* we passed a direct reference; no need to do anything */
 287         bitmap->lockmode = 0;
 288         return Ok;
 289     }
 290
 291     hbm = bitmap->hbitmap;
 292     hdc = bitmap->hdc;
 293     bm_is_selected = (hdc != 0);
 294
 295     pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
 296     pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 297     pbmi->bmiHeader.biBitCount = 0;
 298
 299     if(!bm_is_selected){
 300         hdc = CreateCompatibleDC(0);
 301         old = SelectObject(hdc, hbm);
 302     }
 303
 304     GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
 305     pbmi->bmiHeader.biBitCount = PIXELFORMATBPP(lockeddata->PixelFormat);
 306     SetDIBits(hdc, hbm, 0, abs(pbmi->bmiHeader.biHeight),
 307               bitmap->bitmapbits, pbmi, DIB_RGB_COLORS);
 308
 309     if(!bm_is_selected){
 310         SelectObject(hdc, old);
 311         DeleteDC(hdc);
 312     }
 313
 314     GdipFree(pbmi);
 315     GdipFree(bitmap->bitmapbits);
 316     bitmap->bitmapbits = NULL;
 317     bitmap->lockmode = 0;
 318
 319     return Ok;
 320 }
 321
 322 GpStatus WINGDIPAPI GdipCloneBitmapArea(REAL x, REAL y, REAL width, REAL height,
 323     PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
 324 {
 325     FIXME("(%f,%f,%f,%f,%i,%p,%p): stub\n", x, y, width, height, format, srcBitmap, dstBitmap);
 326
 327     return NotImplemented;
 328 }
 329
 330 GpStatus WINGDIPAPI GdipCloneBitmapAreaI(INT x, INT y, INT width, INT height,
 331     PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
 332 {
 333     FIXME("(%i,%i,%i,%i,%i,%p,%p): stub\n", x, y, width, height, format, srcBitmap, dstBitmap);
 334
 335     return NotImplemented;
 336 }
 337
 338 GpStatus WINGDIPAPI GdipCloneImage(GpImage *image, GpImage **cloneImage)
 339 {
 340     GpStatus stat = GenericError;
 341
 342     TRACE("%p, %p\n", image, cloneImage);
 343
 344     if (!image || !cloneImage)
 345         return InvalidParameter;
 346
 347     if (image->picture)
 348     {
 349         IStream* stream;
 350         HRESULT hr;
 351         INT size;
 352         LARGE_INTEGER move;
 353
 354         hr = CreateStreamOnHGlobal(0, TRUE, &stream);
 355         if (FAILED(hr))
 356             return GenericError;
 357
 358         hr = IPicture_SaveAsFile(image->picture, stream, FALSE, &size);
 359         if(FAILED(hr))
 360         {
 361             WARN("Failed to save image on stream\n");
 362             goto out;
 363         }
 364
 365         /* Set seek pointer back to the beginning of the picture */
 366         move.QuadPart = 0;
 367         hr = IStream_Seek(stream, move, STREAM_SEEK_SET, NULL);
 368         if (FAILED(hr))
 369             goto out;
 370
 371         stat = GdipLoadImageFromStream(stream, cloneImage);
 372         if (stat != Ok) WARN("Failed to load image from stream\n");
 373
 374     out:
 375         IStream_Release(stream);
 376         return stat;
 377     }
 378     else if (image->type == ImageTypeBitmap)
 379     {
 380         GpBitmap *bitmap = (GpBitmap*)image;
 381         BitmapData lockeddata_src, lockeddata_dst;
 382         int i;
 383         UINT row_size;
 384
 385         stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, bitmap->format,
 386             &lockeddata_src);
 387         if (stat != Ok) return stat;
 388
 389         stat = GdipCreateBitmapFromScan0(lockeddata_src.Width, lockeddata_src.Height,
 390             0, lockeddata_src.PixelFormat, NULL, (GpBitmap**)cloneImage);
 391         if (stat == Ok)
 392         {
 393             stat = GdipBitmapLockBits((GpBitmap*)*cloneImage, NULL, ImageLockModeWrite,
 394                 lockeddata_src.PixelFormat, &lockeddata_dst);
 395
 396             if (stat == Ok)
 397             {
 398                 /* copy the image data */
 399                 row_size = (lockeddata_src.Width * PIXELFORMATBPP(lockeddata_src.PixelFormat) +7)/8;
 400                 for (i=0; i<lockeddata_src.Height; i++)
 401                     memcpy((BYTE*)lockeddata_dst.Scan0+lockeddata_dst.Stride*i,
 402                            (BYTE*)lockeddata_src.Scan0+lockeddata_src.Stride*i,
 403                            row_size);
 404
 405                 GdipBitmapUnlockBits((GpBitmap*)*cloneImage, &lockeddata_dst);
 406             }
 407
 408             GdipBitmapUnlockBits(bitmap, &lockeddata_src);
 409         }
 410
 411         if (stat != Ok)
 412         {
 413             GdipDisposeImage(*cloneImage);
 414             *cloneImage = NULL;
 415         }
 416         return stat;
 417     }
 418     else
 419     {
 420         ERR("GpImage with no IPicture or bitmap?!\n");
 421         return NotImplemented;
 422     }
 423 }
 424
 425 GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename,
 426     GpBitmap **bitmap)
 427 {
 428     GpStatus stat;
 429     IStream *stream;
 430
 431     TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
 432
 433     if(!filename || !bitmap)
 434         return InvalidParameter;
 435
 436     stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
 437
 438     if(stat != Ok)
 439         return stat;
 440
 441     stat = GdipCreateBitmapFromStream(stream, bitmap);
 442
 443     IStream_Release(stream);
 444
 445     return stat;
 446 }
 447
 448 GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO* info,
 449                                                VOID *bits, GpBitmap **bitmap)
 450 {
 451     DWORD height, stride;
 452     PixelFormat format;
 453
 454     FIXME("(%p, %p, %p) - partially implemented\n", info, bits, bitmap);
 455
 456     height = abs(info->bmiHeader.biHeight);
 457     stride = ((info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) >> 3) & ~3;
 458
 459     if(info->bmiHeader.biHeight > 0) /* bottom-up */
 460     {
 461         bits = (BYTE*)bits + (height - 1) * stride;
 462         stride = -stride;
 463     }
 464
 465     switch(info->bmiHeader.biBitCount) {
 466     case 1:
 467         format = PixelFormat1bppIndexed;
 468         break;
 469     case 4:
 470         format = PixelFormat4bppIndexed;
 471         break;
 472     case 8:
 473         format = PixelFormat8bppIndexed;
 474         break;
 475     case 24:
 476         format = PixelFormat24bppRGB;
 477         break;
 478     default:
 479         FIXME("don't know how to handle %d bpp\n", info->bmiHeader.biBitCount);
 480         *bitmap = NULL;
 481         return InvalidParameter;
 482     }
 483
 484     return GdipCreateBitmapFromScan0(info->bmiHeader.biWidth, height, stride, format,
 485                                      bits, bitmap);
 486
 487 }
 488
 489 /* FIXME: no icm */
 490 GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename,
 491     GpBitmap **bitmap)
 492 {
 493     TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
 494
 495     return GdipCreateBitmapFromFile(filename, bitmap);
 496 }
 497
 498 GpStatus WINGDIPAPI GdipCreateBitmapFromResource(HINSTANCE hInstance,
 499     GDIPCONST WCHAR* lpBitmapName, GpBitmap** bitmap)
 500 {
 501     HBITMAP hbm;
 502     GpStatus stat = InvalidParameter;
 503
 504     TRACE("%p (%s) %p\n", hInstance, debugstr_w(lpBitmapName), bitmap);
 505
 506     if(!lpBitmapName || !bitmap)
 507         return InvalidParameter;
 508
 509     /* load DIB */
 510     hbm = LoadImageW(hInstance, lpBitmapName, IMAGE_BITMAP, 0, 0,
 511                      LR_CREATEDIBSECTION);
 512
 513     if(hbm){
 514         stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
 515         DeleteObject(hbm);
 516     }
 517
 518     return stat;
 519 }
 520
 521 GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap,
 522     HBITMAP* hbmReturn, ARGB background)
 523 {
 524     GpStatus stat;
 525     HBITMAP result, oldbitmap;
 526     UINT width, height;
 527     HDC hdc;
 528     GpGraphics *graphics;
 529     BITMAPINFOHEADER bih;
 530     void *bits;
 531     TRACE("(%p,%p,%x)\n", bitmap, hbmReturn, background);
 532
 533     if (!bitmap || !hbmReturn) return InvalidParameter;
 534
 535     GdipGetImageWidth((GpImage*)bitmap, &width);
 536     GdipGetImageHeight((GpImage*)bitmap, &height);
 537
 538     bih.biSize = sizeof(bih);
 539     bih.biWidth = width;
 540     bih.biHeight = height;
 541     bih.biPlanes = 1;
 542     bih.biBitCount = 32;
 543     bih.biCompression = BI_RGB;
 544     bih.biSizeImage = 0;
 545     bih.biXPelsPerMeter = 0;
 546     bih.biYPelsPerMeter = 0;
 547     bih.biClrUsed = 0;
 548     bih.biClrImportant = 0;
 549
 550     hdc = CreateCompatibleDC(NULL);
 551     if (!hdc) return GenericError;
 552
 553     result = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS, &bits,
 554         NULL, 0);
 555
 556     if (result)
 557     {
 558         oldbitmap = SelectObject(hdc, result);
 559
 560         stat = GdipCreateFromHDC(hdc, &graphics);
 561         if (stat == Ok)
 562         {
 563             stat = GdipGraphicsClear(graphics, background);
 564
 565             if (stat == Ok)
 566                 stat = GdipDrawImage(graphics, (GpImage*)bitmap, 0, 0);
 567
 568             GdipDeleteGraphics(graphics);
 569         }
 570
 571         SelectObject(hdc, oldbitmap);
 572     }
 573     else
 574         stat = GenericError;
 575
 576     DeleteDC(hdc);
 577
 578     if (stat != Ok && result)
 579     {
 580         DeleteObject(result);
 581         result = NULL;
 582     }
 583
 584     *hbmReturn = result;
 585
 586     return stat;
 587 }
 588
 589 GpStatus WINGDIPAPI GdipConvertToEmfPlus(const GpGraphics* ref,
 590     GpMetafile* metafile, BOOL* succ, EmfType emfType,
 591     const WCHAR* description, GpMetafile** out_metafile)
 592 {
 593     static int calls;
 594
 595     if(!ref || !metafile || !out_metafile)
 596         return InvalidParameter;
 597
 598     *succ = FALSE;
 599     *out_metafile = NULL;
 600
 601     if(!(calls++))
 602         FIXME("not implemented\n");
 603
 604     return NotImplemented;
 605 }
 606
 607 /* FIXME: this should create a bitmap in the given size with the attributes
 608  * (resolution etc.) of the graphics object */
 609 GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics(INT width, INT height,
 610     GpGraphics* target, GpBitmap** bitmap)
 611 {
 612     static int calls;
 613     GpStatus ret;
 614
 615     if(!target || !bitmap)
 616         return InvalidParameter;
 617
 618     if(!(calls++))
 619         FIXME("hacked stub\n");
 620
 621     ret = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat24bppRGB,
 622                                     NULL, bitmap);
 623
 624     return ret;
 625 }
 626
 627 GpStatus WINGDIPAPI GdipCreateBitmapFromHICON(HICON hicon, GpBitmap** bitmap)
 628 {
 629     GpStatus stat;
 630     ICONINFO iinfo;
 631     BITMAP bm;
 632     int ret;
 633     UINT width, height;
 634     GpRect rect;
 635     BitmapData lockeddata;
 636     HDC screendc;
 637     BOOL has_alpha;
 638     int x, y;
 639     BYTE *bits;
 640     BITMAPINFOHEADER bih;
 641     DWORD *src;
 642     BYTE *dst_row;
 643     DWORD *dst;
 644
 645     TRACE("%p, %p\n", hicon, bitmap);
 646
 647     if(!bitmap || !GetIconInfo(hicon, &iinfo))
 648     {
 649         DeleteObject(iinfo.hbmColor);
 650         DeleteObject(iinfo.hbmMask);
 651         return InvalidParameter;
 652     }
 653
 654     /* get the size of the icon */
 655     ret = GetObjectA(iinfo.hbmColor ? iinfo.hbmColor : iinfo.hbmMask, sizeof(bm), &bm);
 656     if (ret == 0) {
 657         DeleteObject(iinfo.hbmColor);
 658         DeleteObject(iinfo.hbmMask);
 659         return GenericError;
 660     }
 661
 662     width = bm.bmWidth;
 663
 664     if (iinfo.hbmColor)
 665         height = abs(bm.bmHeight);
 666     else /* combined bitmap + mask */
 667         height = abs(bm.bmHeight) / 2;
 668
 669     bits = HeapAlloc(GetProcessHeap(), 0, 4*width*height);
 670     if (!bits) {
 671         DeleteObject(iinfo.hbmColor);
 672         DeleteObject(iinfo.hbmMask);
 673         return OutOfMemory;
 674     }
 675
 676     stat = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppARGB, NULL, bitmap);
 677     if (stat != Ok) {
 678         DeleteObject(iinfo.hbmColor);
 679         DeleteObject(iinfo.hbmMask);
 680         HeapFree(GetProcessHeap(), 0, bits);
 681         return stat;
 682     }
 683
 684     rect.X = 0;
 685     rect.Y = 0;
 686     rect.Width = width;
 687     rect.Height = height;
 688
 689     stat = GdipBitmapLockBits(*bitmap, &rect, ImageLockModeWrite, PixelFormat32bppARGB, &lockeddata);
 690     if (stat != Ok) {
 691         DeleteObject(iinfo.hbmColor);
 692         DeleteObject(iinfo.hbmMask);
 693         HeapFree(GetProcessHeap(), 0, bits);
 694         GdipDisposeImage((GpImage*)*bitmap);
 695         return stat;
 696     }
 697
 698     bih.biSize = sizeof(bih);
 699     bih.biWidth = width;
 700     bih.biHeight = -height;
 701     bih.biPlanes = 1;
 702     bih.biBitCount = 32;
 703     bih.biCompression = BI_RGB;
 704     bih.biSizeImage = 0;
 705     bih.biXPelsPerMeter = 0;
 706     bih.biYPelsPerMeter = 0;
 707     bih.biClrUsed = 0;
 708     bih.biClrImportant = 0;
 709
 710     screendc = GetDC(0);
 711     if (iinfo.hbmColor)
 712     {
 713         GetDIBits(screendc, iinfo.hbmColor, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
 714
 715         if (bm.bmBitsPixel == 32)
 716         {
 717             has_alpha = FALSE;
 718
 719             /* If any pixel has a non-zero alpha, ignore hbmMask */
 720             src = (DWORD*)bits;
 721             for (x=0; x<width && !has_alpha; x++)
 722                 for (y=0; y<height && !has_alpha; y++)
 723                     if ((*src++ & 0xff000000) != 0)
 724                         has_alpha = TRUE;
 725         }
 726         else has_alpha = FALSE;
 727     }
 728     else
 729     {
 730         GetDIBits(screendc, iinfo.hbmMask, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
 731         has_alpha = FALSE;
 732     }
 733
 734     /* copy the image data to the Bitmap */
 735     src = (DWORD*)bits;
 736     dst_row = lockeddata.Scan0;
 737     for (y=0; y<height; y++)
 738     {
 739         memcpy(dst_row, src, width*4);
 740         src += width;
 741         dst_row += lockeddata.Stride;
 742     }
 743
 744     if (!has_alpha)
 745     {
 746         if (iinfo.hbmMask)
 747         {
 748             /* read alpha data from the mask */
 749             if (iinfo.hbmColor)
 750                 GetDIBits(screendc, iinfo.hbmMask, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
 751             else
 752                 GetDIBits(screendc, iinfo.hbmMask, height, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
 753
 754             src = (DWORD*)bits;
 755             dst_row = lockeddata.Scan0;
 756             for (y=0; y<height; y++)
 757             {
 758                 dst = (DWORD*)dst_row;
 759                 for (x=0; x<height; x++)
 760                 {
 761                     DWORD src_value = *src++;
 762                     if (src_value)
 763                         *dst++ = 0;
 764                     else
 765                         *dst++ |= 0xff000000;
 766                 }
 767                 dst_row += lockeddata.Stride;
 768             }
 769         }
 770         else
 771         {
 772             /* set constant alpha of 255 */
 773             dst_row = bits;
 774             for (y=0; y<height; y++)
 775             {
 776                 dst = (DWORD*)dst_row;
 777                 for (x=0; x<height; x++)
 778                     *dst++ |= 0xff000000;
 779                 dst_row += lockeddata.Stride;
 780             }
 781         }
 782     }
 783
 784     ReleaseDC(0, screendc);
 785
 786     DeleteObject(iinfo.hbmColor);
 787     DeleteObject(iinfo.hbmMask);
 788
 789     GdipBitmapUnlockBits(*bitmap, &lockeddata);
 790
 791     HeapFree(GetProcessHeap(), 0, bits);
 792
 793     return Ok;
 794 }
 795
 796 GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride,
 797     PixelFormat format, BYTE* scan0, GpBitmap** bitmap)
 798 {
 799     BITMAPINFOHEADER bmih;
 800     HBITMAP hbitmap;
 801     INT row_size, dib_stride;
 802     HDC hdc;
 803     BYTE *bits;
 804     int i;
 805
 806     TRACE("%d %d %d %d %p %p\n", width, height, stride, format, scan0, bitmap);
 807
 808     if (!bitmap) return InvalidParameter;
 809
 810     if(width <= 0 || height <= 0 || (scan0 && (stride % 4))){
 811         *bitmap = NULL;
 812         return InvalidParameter;
 813     }
 814
 815     if(scan0 && !stride)
 816         return InvalidParameter;
 817
 818     row_size = (width * PIXELFORMATBPP(format)+7) / 8;
 819     dib_stride = (row_size + 3) & ~3;
 820
 821     if(stride == 0)
 822         stride = dib_stride;
 823
 824     bmih.biSize = sizeof(BITMAPINFOHEADER);
 825     bmih.biWidth = width;
 826     bmih.biHeight = -height;
 827     bmih.biPlanes = 1;
 828     /* FIXME: use the rest of the data from format */
 829     bmih.biBitCount = PIXELFORMATBPP(format);
 830     bmih.biCompression = BI_RGB;
 831     bmih.biSizeImage = 0;
 832     bmih.biXPelsPerMeter = 0;
 833     bmih.biYPelsPerMeter = 0;
 834     bmih.biClrUsed = 0;
 835     bmih.biClrImportant = 0;
 836
 837     hdc = CreateCompatibleDC(NULL);
 838     if (!hdc) return GenericError;
 839
 840     hbitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bmih, DIB_RGB_COLORS, (void**)&bits,
 841         NULL, 0);
 842
 843     DeleteDC(hdc);
 844
 845     if (!hbitmap) return GenericError;
 846
 847     /* copy bits to the dib if necessary */
 848     /* FIXME: should reference the bits instead of copying them */
 849     if (scan0)
 850         for (i=0; i<height; i++)
 851             memcpy(bits+i*dib_stride, scan0+i*stride, row_size);
 852
 853     *bitmap = GdipAlloc(sizeof(GpBitmap));
 854     if(!*bitmap)
 855     {
 856         DeleteObject(hbitmap);
 857         return OutOfMemory;
 858     }
 859
 860     (*bitmap)->image.type = ImageTypeBitmap;
 861     (*bitmap)->image.flags = ImageFlagsNone;
 862     (*bitmap)->width = width;
 863     (*bitmap)->height = height;
 864     (*bitmap)->format = format;
 865     (*bitmap)->image.picture = NULL;
 866     (*bitmap)->hbitmap = hbitmap;
 867     (*bitmap)->hdc = NULL;
 868     (*bitmap)->bits = bits;
 869     (*bitmap)->stride = dib_stride;
 870
 871     return Ok;
 872 }
 873
 874 GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream* stream,
 875     GpBitmap **bitmap)
 876 {
 877     GpStatus stat;
 878
 879     TRACE("%p %p\n", stream, bitmap);
 880
 881     stat = GdipLoadImageFromStream(stream, (GpImage**) bitmap);
 882
 883     if(stat != Ok)
 884         return stat;
 885
 886     if((*bitmap)->image.type != ImageTypeBitmap){
 887         GdipDisposeImage(&(*bitmap)->image);
 888         *bitmap = NULL;
 889         return GenericError; /* FIXME: what error to return? */
 890     }
 891
 892     return Ok;
 893 }
 894
 895 /* FIXME: no icm */
 896 GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream* stream,
 897     GpBitmap **bitmap)
 898 {
 899     TRACE("%p %p\n", stream, bitmap);
 900
 901     return GdipCreateBitmapFromStream(stream, bitmap);
 902 }
 903
 904 GpStatus WINGDIPAPI GdipCreateCachedBitmap(GpBitmap *bitmap, GpGraphics *graphics,
 905     GpCachedBitmap **cachedbmp)
 906 {
 907     GpStatus stat;
 908
 909     TRACE("%p %p %p\n", bitmap, graphics, cachedbmp);
 910
 911     if(!bitmap || !graphics || !cachedbmp)
 912         return InvalidParameter;
 913
 914     *cachedbmp = GdipAlloc(sizeof(GpCachedBitmap));
 915     if(!*cachedbmp)
 916         return OutOfMemory;
 917
 918     stat = GdipCloneImage(&(bitmap->image), &(*cachedbmp)->image);
 919     if(stat != Ok){
 920         GdipFree(*cachedbmp);
 921         return stat;
 922     }
 923
 924     return Ok;
 925 }
 926
 927 GpStatus WINGDIPAPI GdipCreateHICONFromBitmap(GpBitmap *bitmap, HICON *hicon)
 928 {
 929     FIXME("(%p, %p)\n", bitmap, hicon);
 930
 931     return NotImplemented;
 932 }
 933
 934 GpStatus WINGDIPAPI GdipDeleteCachedBitmap(GpCachedBitmap *cachedbmp)
 935 {
 936     TRACE("%p\n", cachedbmp);
 937
 938     if(!cachedbmp)
 939         return InvalidParameter;
 940
 941     GdipDisposeImage(cachedbmp->image);
 942     GdipFree(cachedbmp);
 943
 944     return Ok;
 945 }
 946
 947 GpStatus WINGDIPAPI GdipDrawCachedBitmap(GpGraphics *graphics,
 948     GpCachedBitmap *cachedbmp, INT x, INT y)
 949 {
 950     TRACE("%p %p %d %d\n", graphics, cachedbmp, x, y);
 951
 952     if(!graphics || !cachedbmp)
 953         return InvalidParameter;
 954
 955     return GdipDrawImage(graphics, cachedbmp->image, (REAL)x, (REAL)y);
 956 }
 957
 958 GpStatus WINGDIPAPI GdipEmfToWmfBits(HENHMETAFILE hemf, UINT cbData16,
 959     LPBYTE pData16, INT iMapMode, INT eFlags)
 960 {
 961     FIXME("(%p, %d, %p, %d, %d): stub\n", hemf, cbData16, pData16, iMapMode, eFlags);
 962     return NotImplemented;
 963 }
 964
 965 GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
 966 {
 967     TRACE("%p\n", image);
 968
 969     if(!image)
 970         return InvalidParameter;
 971
 972     if (image->picture)
 973         IPicture_Release(image->picture);
 974     if (image->type == ImageTypeBitmap)
 975     {
 976         GdipFree(((GpBitmap*)image)->bitmapbits);
 977         DeleteDC(((GpBitmap*)image)->hdc);
 978     }
 979     GdipFree(image);
 980
 981     return Ok;
 982 }
 983
 984 GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage *image, ImageItemData* item)
 985 {
 986     if(!image || !item)
 987         return InvalidParameter;
 988
 989     return NotImplemented;
 990 }
 991
 992 GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect,
 993     GpUnit *srcUnit)
 994 {
 995     TRACE("%p %p %p\n", image, srcRect, srcUnit);
 996
 997     if(!image || !srcRect || !srcUnit)
 998         return InvalidParameter;
 999     if(image->type == ImageTypeMetafile){
1000         *srcRect = ((GpMetafile*)image)->bounds;
1001         *srcUnit = ((GpMetafile*)image)->unit;
1002     }
1003     else if(image->type == ImageTypeBitmap){
1004         srcRect->X = srcRect->Y = 0.0;
1005         srcRect->Width = (REAL) ((GpBitmap*)image)->width;
1006         srcRect->Height = (REAL) ((GpBitmap*)image)->height;
1007         *srcUnit = UnitPixel;
1008     }
1009     else{
1010         srcRect->X = srcRect->Y = 0.0;
1011         srcRect->Width = ipicture_pixel_width(image->picture);
1012         srcRect->Height = ipicture_pixel_height(image->picture);
1013         *srcUnit = UnitPixel;
1014     }
1015
1016     TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
1017           srcRect->Width, srcRect->Height, *srcUnit);
1018
1019     return Ok;
1020 }
1021
1022 GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width,
1023     REAL *height)
1024 {
1025     TRACE("%p %p %p\n", image, width, height);
1026
1027     if(!image || !height || !width)
1028         return InvalidParameter;
1029
1030     if(image->type == ImageTypeMetafile){
1031         HDC hdc = GetDC(0);
1032
1033         *height = convert_unit(hdc, ((GpMetafile*)image)->unit) *
1034                         ((GpMetafile*)image)->bounds.Height;
1035
1036         *width = convert_unit(hdc, ((GpMetafile*)image)->unit) *
1037                         ((GpMetafile*)image)->bounds.Width;
1038
1039         ReleaseDC(0, hdc);
1040     }
1041
1042     else if(image->type == ImageTypeBitmap){
1043         *height = ((GpBitmap*)image)->height;
1044         *width = ((GpBitmap*)image)->width;
1045     }
1046     else{
1047         *height = ipicture_pixel_height(image->picture);
1048         *width = ipicture_pixel_width(image->picture);
1049     }
1050
1051     TRACE("returning (%f, %f)\n", *height, *width);
1052     return Ok;
1053 }
1054
1055 GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image,
1056     GpGraphics **graphics)
1057 {
1058     HDC hdc;
1059
1060     TRACE("%p %p\n", image, graphics);
1061
1062     if(!image || !graphics)
1063         return InvalidParameter;
1064
1065     if(image->type != ImageTypeBitmap){
1066         FIXME("not implemented for image type %d\n", image->type);
1067         return NotImplemented;
1068     }
1069
1070     hdc = ((GpBitmap*)image)->hdc;
1071
1072     if(!hdc){
1073         hdc = CreateCompatibleDC(0);
1074         SelectObject(hdc, ((GpBitmap*)image)->hbitmap);
1075         ((GpBitmap*)image)->hdc = hdc;
1076     }
1077
1078     return GdipCreateFromHDC(hdc, graphics);
1079 }
1080
1081 GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
1082 {
1083     TRACE("%p %p\n", image, height);
1084
1085     if(!image || !height)
1086         return InvalidParameter;
1087
1088     if(image->type == ImageTypeMetafile){
1089         HDC hdc = GetDC(0);
1090
1091         *height = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
1092                         ((GpMetafile*)image)->bounds.Height);
1093
1094         ReleaseDC(0, hdc);
1095     }
1096     else if(image->type == ImageTypeBitmap)
1097         *height = ((GpBitmap*)image)->height;
1098     else
1099         *height = ipicture_pixel_height(image->picture);
1100
1101     TRACE("returning %d\n", *height);
1102
1103     return Ok;
1104 }
1105
1106 GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *res)
1107 {
1108     static int calls;
1109
1110     if(!image || !res)
1111         return InvalidParameter;
1112
1113     if(!(calls++))
1114         FIXME("not implemented\n");
1115
1116     return NotImplemented;
1117 }
1118
1119 GpStatus WINGDIPAPI GdipGetImagePaletteSize(GpImage *image, INT *size)
1120 {
1121     FIXME("%p %p\n", image, size);
1122
1123     if(!image || !size)
1124         return InvalidParameter;
1125
1126     return NotImplemented;
1127 }
1128
1129 /* FIXME: test this function for non-bitmap types */
1130 GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format)
1131 {
1132     TRACE("%p %p\n", image, format);
1133
1134     if(!image || !format)
1135         return InvalidParameter;
1136
1137     if(image->type != ImageTypeBitmap)
1138         *format = PixelFormat24bppRGB;
1139     else
1140         *format = ((GpBitmap*) image)->format;
1141
1142     return Ok;
1143 }
1144
1145 GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
1146 {
1147     static int calls;
1148
1149     if(!image || !format)
1150         return InvalidParameter;
1151
1152     if(!(calls++))
1153         FIXME("stub\n");
1154
1155     /* FIXME: should be detected from embedded picture or stored separately */
1156     switch (image->type)
1157     {
1158     case ImageTypeBitmap:   *format = ImageFormatBMP; break;
1159     case ImageTypeMetafile: *format = ImageFormatEMF; break;
1160     default:
1161         WARN("unknown type %u\n", image->type);
1162         *format = ImageFormatUndefined;
1163     }
1164     return Ok;
1165 }
1166
1167 GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
1168 {
1169     TRACE("%p %p\n", image, type);
1170
1171     if(!image || !type)
1172         return InvalidParameter;
1173
1174     *type = image->type;
1175
1176     return Ok;
1177 }
1178
1179 GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *res)
1180 {
1181     static int calls;
1182
1183     if(!image || !res)
1184         return InvalidParameter;
1185
1186     if(!(calls++))
1187         FIXME("not implemented\n");
1188
1189     return NotImplemented;
1190 }
1191
1192 GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
1193 {
1194     TRACE("%p %p\n", image, width);
1195
1196     if(!image || !width)
1197         return InvalidParameter;
1198
1199     if(image->type == ImageTypeMetafile){
1200         HDC hdc = GetDC(0);
1201
1202         *width = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
1203                         ((GpMetafile*)image)->bounds.Width);
1204
1205         ReleaseDC(0, hdc);
1206     }
1207     else if(image->type == ImageTypeBitmap)
1208         *width = ((GpBitmap*)image)->width;
1209     else
1210         *width = ipicture_pixel_width(image->picture);
1211
1212     TRACE("returning %d\n", *width);
1213
1214     return Ok;
1215 }
1216
1217 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile * metafile,
1218     MetafileHeader * header)
1219 {
1220     static int calls;
1221
1222     if(!metafile || !header)
1223         return InvalidParameter;
1224
1225     if(!(calls++))
1226         FIXME("not implemented\n");
1227
1228     return Ok;
1229 }
1230
1231 GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT size,
1232     UINT num, PropertyItem* items)
1233 {
1234     static int calls;
1235
1236     if(!(calls++))
1237         FIXME("not implemented\n");
1238
1239     return InvalidParameter;
1240 }
1241
1242 GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage *image, UINT* num)
1243 {
1244     static int calls;
1245
1246     if(!(calls++))
1247         FIXME("not implemented\n");
1248
1249     return InvalidParameter;
1250 }
1251
1252 GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT num, PROPID* list)
1253 {
1254     static int calls;
1255
1256     if(!(calls++))
1257         FIXME("not implemented\n");
1258
1259     return InvalidParameter;
1260 }
1261
1262 GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID id, UINT size,
1263     PropertyItem* buffer)
1264 {
1265     static int calls;
1266
1267     if(!(calls++))
1268         FIXME("not implemented\n");
1269
1270     return InvalidParameter;
1271 }
1272
1273 GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID pid,
1274     UINT* size)
1275 {
1276     static int calls;
1277
1278     TRACE("%p %x %p\n", image, pid, size);
1279
1280     if(!size || !image)
1281         return InvalidParameter;
1282
1283     if(!(calls++))
1284         FIXME("not implemented\n");
1285
1286     return NotImplemented;
1287 }
1288
1289 GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT* size, UINT* num)
1290 {
1291     static int calls;
1292
1293     if(!(calls++))
1294         FIXME("not implemented\n");
1295
1296     return InvalidParameter;
1297 }
1298
1299 GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
1300     GDIPCONST GUID* dimensionID, UINT* count)
1301 {
1302     static int calls;
1303
1304     if(!image || !dimensionID || !count)
1305         return InvalidParameter;
1306
1307     if(!(calls++))
1308         FIXME("not implemented\n");
1309
1310     return NotImplemented;
1311 }
1312
1313 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage *image,
1314     UINT* count)
1315 {
1316     if(!image || !count)
1317         return InvalidParameter;
1318
1319     *count = 1;
1320
1321     FIXME("stub\n");
1322
1323     return Ok;
1324 }
1325
1326 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image,
1327     GUID* dimensionIDs, UINT count)
1328 {
1329     static int calls;
1330
1331     if(!image || !dimensionIDs)
1332         return InvalidParameter;
1333
1334     if(!(calls++))
1335         FIXME("not implemented\n");
1336
1337     return Ok;
1338 }
1339
1340 GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage *image,
1341     GDIPCONST GUID* dimensionID, UINT frameidx)
1342 {
1343     static int calls;
1344
1345     if(!image || !dimensionID)
1346         return InvalidParameter;
1347
1348     if(!(calls++))
1349         FIXME("not implemented\n");
1350
1351     return Ok;
1352 }
1353
1354 GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
1355                                           GpImage **image)
1356 {
1357     GpStatus stat;
1358     IStream *stream;
1359
1360     TRACE("(%s) %p\n", debugstr_w(filename), image);
1361
1362     if (!filename || !image)
1363         return InvalidParameter;
1364
1365     stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
1366
1367     if (stat != Ok)
1368         return stat;
1369
1370     stat = GdipLoadImageFromStream(stream, image);
1371
1372     IStream_Release(stream);
1373
1374     return stat;
1375 }
1376
1377 /* FIXME: no icm handling */
1378 GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,GpImage **image)
1379 {
1380     TRACE("(%s) %p\n", debugstr_w(filename), image);
1381
1382     return GdipLoadImageFromFile(filename, image);
1383 }
1384
1385 static const WICPixelFormatGUID *wic_pixel_formats[] = {
1386     &GUID_WICPixelFormat16bppBGR555,
1387     &GUID_WICPixelFormat24bppBGR,
1388     &GUID_WICPixelFormat32bppBGR,
1389     &GUID_WICPixelFormat32bppBGRA,
1390     &GUID_WICPixelFormat32bppPBGRA,
1391     NULL
1392 };
1393
1394 static const PixelFormat wic_gdip_formats[] = {
1395     PixelFormat16bppRGB555,
1396     PixelFormat24bppRGB,
1397     PixelFormat32bppRGB,
1398     PixelFormat32bppARGB,
1399     PixelFormat32bppPARGB,
1400 };
1401
1402 static GpStatus decode_image_wic(IStream* stream, REFCLSID clsid, GpImage **image)
1403 {
1404     GpStatus status=Ok;
1405     GpBitmap *bitmap;
1406     HRESULT hr;
1407     IWICBitmapDecoder *decoder;
1408     IWICBitmapFrameDecode *frame;
1409     IWICBitmapSource *source=NULL;
1410     WICPixelFormatGUID wic_format;
1411     PixelFormat gdip_format=0;
1412     int i;
1413     UINT width, height;
1414     BitmapData lockeddata;
1415     WICRect wrc;
1416     HRESULT initresult;
1417
1418     initresult = CoInitialize(NULL);
1419
1420     hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
1421         &IID_IWICBitmapDecoder, (void**)&decoder);
1422     if (FAILED(hr)) goto end;
1423
1424     hr = IWICBitmapDecoder_Initialize(decoder, (IStream*)stream, WICDecodeMetadataCacheOnLoad);
1425     if (SUCCEEDED(hr))
1426         hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
1427
1428     if (SUCCEEDED(hr)) /* got frame */
1429     {
1430         hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &wic_format);
1431
1432         if (SUCCEEDED(hr))
1433         {
1434             for (i=0; wic_pixel_formats[i]; i++)
1435             {
1436                 if (IsEqualGUID(&wic_format, wic_pixel_formats[i]))
1437                 {
1438                     source = (IWICBitmapSource*)frame;
1439                     IWICBitmapSource_AddRef(source);
1440                     gdip_format = wic_gdip_formats[i];
1441                     break;
1442                 }
1443             }
1444             if (!source)
1445             {
1446                 /* unknown format; fall back on 32bppARGB */
1447                 hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, (IWICBitmapSource*)frame, &source);
1448                 gdip_format = PixelFormat32bppARGB;
1449             }
1450         }
1451
1452         if (SUCCEEDED(hr)) /* got source */
1453         {
1454             hr = IWICBitmapSource_GetSize(source, &width, &height);
1455
1456             if (SUCCEEDED(hr))
1457                 status = GdipCreateBitmapFromScan0(width, height, 0, gdip_format,
1458                     NULL, &bitmap);
1459
1460             if (SUCCEEDED(hr) && status == Ok) /* created bitmap */
1461             {
1462                 status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeWrite,
1463                     gdip_format, &lockeddata);
1464                 if (status == Ok) /* locked bitmap */
1465                 {
1466                     wrc.X = 0;
1467                     wrc.Width = width;
1468                     wrc.Height = 1;
1469                     for (i=0; i<height; i++)
1470                     {
1471                         wrc.Y = i;
1472                         hr = IWICBitmapSource_CopyPixels(source, &wrc, abs(lockeddata.Stride),
1473                             abs(lockeddata.Stride), (BYTE*)lockeddata.Scan0+lockeddata.Stride*i);
1474                         if (FAILED(hr)) break;
1475                     }
1476
1477                     GdipBitmapUnlockBits(bitmap, &lockeddata);
1478                 }
1479
1480                 if (SUCCEEDED(hr) && status == Ok)
1481                     *image = (GpImage*)bitmap;
1482                 else
1483                 {
1484                     *image = NULL;
1485                     GdipDisposeImage((GpImage*)bitmap);
1486                 }
1487             }
1488
1489             IWICBitmapSource_Release(source);
1490         }
1491
1492         IWICBitmapFrameDecode_Release(frame);
1493     }
1494
1495     IWICBitmapDecoder_Release(decoder);
1496
1497 end:
1498     if (SUCCEEDED(initresult)) CoUninitialize();
1499
1500     if (FAILED(hr) && status == Ok) status = hresult_to_status(hr);
1501
1502     return status;
1503 }
1504
1505 static GpStatus decode_image_icon(IStream* stream, REFCLSID clsid, GpImage **image)
1506 {
1507     return decode_image_wic(stream, &CLSID_WICIcoDecoder, image);
1508 }
1509
1510 static GpStatus decode_image_jpeg(IStream* stream, REFCLSID clsid, GpImage **image)
1511 {
1512     return decode_image_wic(stream, &CLSID_WICJpegDecoder, image);
1513 }
1514
1515 static GpStatus decode_image_gif(IStream* stream, REFCLSID clsid, GpImage **image)
1516 {
1517     return decode_image_wic(stream, &CLSID_WICGifDecoder, image);
1518 }
1519
1520 static GpStatus decode_image_olepicture_bitmap(IStream* stream, REFCLSID clsid, GpImage **image)
1521 {
1522     IPicture *pic;
1523     BITMAPINFO *pbmi;
1524     BITMAPCOREHEADER* bmch;
1525     HBITMAP hbm;
1526     HDC hdc;
1527
1528     TRACE("%p %p\n", stream, image);
1529
1530     if(!stream || !image)
1531         return InvalidParameter;
1532
1533     if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
1534         (LPVOID*) &pic) != S_OK){
1535         TRACE("Could not load picture\n");
1536         return GenericError;
1537     }
1538
1539     pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
1540     if (!pbmi)
1541         return OutOfMemory;
1542     *image = GdipAlloc(sizeof(GpBitmap));
1543     if(!*image){
1544         GdipFree(pbmi);
1545         return OutOfMemory;
1546     }
1547     (*image)->type = ImageTypeBitmap;
1548
1549     (*((GpBitmap**) image))->width = ipicture_pixel_width(pic);
1550     (*((GpBitmap**) image))->height = ipicture_pixel_height(pic);
1551
1552     /* get the pixel format */
1553     IPicture_get_Handle(pic, (OLE_HANDLE*)&hbm);
1554     IPicture_get_CurDC(pic, &hdc);
1555
1556     (*((GpBitmap**) image))->hbitmap = hbm;
1557     (*((GpBitmap**) image))->hdc = hdc;
1558     (*((GpBitmap**) image))->bits = NULL;
1559
1560     bmch = (BITMAPCOREHEADER*) (&pbmi->bmiHeader);
1561     bmch->bcSize = sizeof(BITMAPCOREHEADER);
1562
1563     if(!hdc){
1564         HBITMAP old;
1565         hdc = CreateCompatibleDC(0);
1566         old = SelectObject(hdc, hbm);
1567         GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
1568         SelectObject(hdc, old);
1569         DeleteDC(hdc);
1570     }
1571     else
1572         GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
1573
1574     switch(bmch->bcBitCount)
1575     {
1576         case 1:
1577             (*((GpBitmap**) image))->format = PixelFormat1bppIndexed;
1578             break;
1579         case 4:
1580             (*((GpBitmap**) image))->format = PixelFormat4bppIndexed;
1581             break;
1582         case 8:
1583             (*((GpBitmap**) image))->format = PixelFormat8bppIndexed;
1584             break;
1585         case 16:
1586             (*((GpBitmap**) image))->format = PixelFormat16bppRGB565;
1587             break;
1588         case 24:
1589             (*((GpBitmap**) image))->format = PixelFormat24bppRGB;
1590             break;
1591         case 32:
1592             (*((GpBitmap**) image))->format = PixelFormat32bppRGB;
1593             break;
1594         case 48:
1595             (*((GpBitmap**) image))->format = PixelFormat48bppRGB;
1596             break;
1597         default:
1598             FIXME("Bit depth %d is not fully supported yet\n", bmch->bcBitCount);
1599             (*((GpBitmap**) image))->format = (bmch->bcBitCount << 8) | PixelFormatGDI;
1600             break;
1601     }
1602
1603     GdipFree(pbmi);
1604
1605     (*image)->picture = pic;
1606     (*image)->flags   = ImageFlagsNone;
1607
1608     return Ok;
1609 }
1610
1611 static GpStatus decode_image_olepicture_metafile(IStream* stream, REFCLSID clsid, GpImage **image)
1612 {
1613     IPicture *pic;
1614
1615     TRACE("%p %p\n", stream, image);
1616
1617     if(!stream || !image)
1618         return InvalidParameter;
1619
1620     if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
1621         (LPVOID*) &pic) != S_OK){
1622         TRACE("Could not load picture\n");
1623         return GenericError;
1624     }
1625
1626     /* FIXME: missing initialization code */
1627     *image = GdipAlloc(sizeof(GpMetafile));
1628     if(!*image) return OutOfMemory;
1629     (*image)->type = ImageTypeMetafile;
1630     (*image)->picture = pic;
1631     (*image)->flags   = ImageFlagsNone;
1632
1633     return Ok;
1634 }
1635
1636 typedef GpStatus (*encode_image_func)(GpImage *image, IStream* stream,
1637     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params);
1638
1639 typedef GpStatus (*decode_image_func)(IStream *stream, REFCLSID clsid, GpImage** image);
1640
1641 typedef struct image_codec {
1642     ImageCodecInfo info;
1643     encode_image_func encode_func;
1644     decode_image_func decode_func;
1645 } image_codec;
1646
1647 typedef enum {
1648     BMP,
1649     JPEG,
1650     GIF,
1651     EMF,
1652     WMF,
1653     PNG,
1654     ICO,
1655     NUM_CODECS
1656 } ImageFormat;
1657
1658 static const struct image_codec codecs[NUM_CODECS];
1659
1660 static GpStatus get_decoder_info(IStream* stream, const struct image_codec **result)
1661 {
1662     BYTE signature[8];
1663     LARGE_INTEGER seek;
1664     HRESULT hr;
1665     UINT bytesread;
1666     int i, j;
1667
1668     /* seek to the start of the stream */
1669     seek.QuadPart = 0;
1670     hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
1671     if (FAILED(hr)) return hresult_to_status(hr);
1672
1673     /* read the first 8 bytes */
1674     /* FIXME: This assumes all codecs have one signature <= 8 bytes in length */
1675     hr = IStream_Read(stream, signature, 8, &bytesread);
1676     if (FAILED(hr)) return hresult_to_status(hr);
1677     if (hr == S_FALSE || bytesread == 0) return GenericError;
1678
1679     for (i = 0; i < NUM_CODECS; i++) {
1680         if ((codecs[i].info.Flags & ImageCodecFlagsDecoder) &&
1681             bytesread >= codecs[i].info.SigSize)
1682         {
1683             for (j=0; j<codecs[i].info.SigSize; j++)
1684                 if ((signature[j] & codecs[i].info.SigMask[j]) != codecs[i].info.SigPattern[j])
1685                     break;
1686             if (j == codecs[i].info.SigSize)
1687             {
1688                 *result = &codecs[i];
1689                 return Ok;
1690             }
1691         }
1692     }
1693
1694     TRACE("no match for %i byte signature %x %x %x %x %x %x %x %x\n", bytesread,
1695         signature[0],signature[1],signature[2],signature[3],
1696         signature[4],signature[5],signature[6],signature[7]);
1697
1698     return GenericError;
1699 }
1700
1701 GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream* stream, GpImage **image)
1702 {
1703     GpStatus stat;
1704     LARGE_INTEGER seek;
1705     HRESULT hr;
1706     const struct image_codec *codec=NULL;
1707
1708     /* choose an appropriate image decoder */
1709     stat = get_decoder_info(stream, &codec);
1710     if (stat != Ok) return stat;
1711
1712     /* seek to the start of the stream */
1713     seek.QuadPart = 0;
1714     hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
1715     if (FAILED(hr)) return hresult_to_status(hr);
1716
1717     /* call on the image decoder to do the real work */
1718     return codec->decode_func(stream, &codec->info.Clsid, image);
1719 }
1720
1721 /* FIXME: no ICM */
1722 GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image)
1723 {
1724     TRACE("%p %p\n", stream, image);
1725
1726     return GdipLoadImageFromStream(stream, image);
1727 }
1728
1729 GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage *image, PROPID propId)
1730 {
1731     static int calls;
1732
1733     if(!image)
1734         return InvalidParameter;
1735
1736     if(!(calls++))
1737         FIXME("not implemented\n");
1738
1739     return NotImplemented;
1740 }
1741
1742 GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item)
1743 {
1744     static int calls;
1745
1746     if(!(calls++))
1747         FIXME("not implemented\n");
1748
1749     return NotImplemented;
1750 }
1751
1752 GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
1753                                         GDIPCONST CLSID *clsidEncoder,
1754                                         GDIPCONST EncoderParameters *encoderParams)
1755 {
1756     GpStatus stat;
1757     IStream *stream;
1758
1759     TRACE("%p (%s) %p %p\n", image, debugstr_w(filename), clsidEncoder, encoderParams);
1760
1761     if (!image || !filename|| !clsidEncoder)
1762         return InvalidParameter;
1763
1764     stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
1765     if (stat != Ok)
1766         return GenericError;
1767
1768     stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
1769
1770     IStream_Release(stream);
1771     return stat;
1772 }
1773
1774 /*************************************************************************
1775  * Encoding functions -
1776  *   These functions encode an image in different image file formats.
1777  */
1778 #define BITMAP_FORMAT_BMP   0x4d42 /* "BM" */
1779 #define BITMAP_FORMAT_JPEG  0xd8ff
1780 #define BITMAP_FORMAT_GIF   0x4947
1781 #define BITMAP_FORMAT_PNG   0x5089
1782 #define BITMAP_FORMAT_APM   0xcdd7
1783
1784 static GpStatus encode_image_WIC(GpImage *image, IStream* stream,
1785     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
1786 {
1787     GpStatus stat;
1788     GpBitmap *bitmap;
1789     IWICBitmapEncoder *encoder;
1790     IWICBitmapFrameEncode *frameencode;
1791     IPropertyBag2 *encoderoptions;
1792     HRESULT hr;
1793     UINT width, height;
1794     PixelFormat gdipformat=0;
1795     WICPixelFormatGUID wicformat;
1796     GpRect rc;
1797     BitmapData lockeddata;
1798     HRESULT initresult;
1799     UINT i;
1800
1801     if (image->type != ImageTypeBitmap)
1802         return GenericError;
1803
1804     bitmap = (GpBitmap*)image;
1805
1806     GdipGetImageWidth(image, &width);
1807     GdipGetImageHeight(image, &height);
1808
1809     rc.X = 0;
1810     rc.Y = 0;
1811     rc.Width = width;
1812     rc.Height = height;
1813
1814     initresult = CoInitialize(NULL);
1815
1816     hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
1817         &IID_IWICBitmapEncoder, (void**)&encoder);
1818     if (FAILED(hr))
1819     {
1820         if (SUCCEEDED(initresult)) CoUninitialize();
1821         return hresult_to_status(hr);
1822     }
1823
1824     hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
1825
1826     if (SUCCEEDED(hr))
1827     {
1828         hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frameencode, &encoderoptions);
1829     }
1830
1831     if (SUCCEEDED(hr)) /* created frame */
1832     {
1833         hr = IWICBitmapFrameEncode_Initialize(frameencode, encoderoptions);
1834
1835         if (SUCCEEDED(hr))
1836             hr = IWICBitmapFrameEncode_SetSize(frameencode, width, height);
1837
1838         if (SUCCEEDED(hr))
1839             /* FIXME: use the resolution from the image */
1840             hr = IWICBitmapFrameEncode_SetResolution(frameencode, 96.0, 96.0);
1841
1842         if (SUCCEEDED(hr))
1843         {
1844             for (i=0; wic_pixel_formats[i]; i++)
1845             {
1846                 if (wic_gdip_formats[i] == bitmap->format)
1847                     break;
1848             }
1849             if (wic_pixel_formats[i])
1850                 memcpy(&wicformat, wic_pixel_formats[i], sizeof(GUID));
1851             else
1852                 memcpy(&wicformat, &GUID_WICPixelFormat32bppBGRA, sizeof(GUID));
1853
1854             hr = IWICBitmapFrameEncode_SetPixelFormat(frameencode, &wicformat);
1855
1856             for (i=0; wic_pixel_formats[i]; i++)
1857             {
1858                 if (IsEqualGUID(&wicformat, wic_pixel_formats[i]))
1859                     break;
1860             }
1861             if (wic_pixel_formats[i])
1862                 gdipformat = wic_gdip_formats[i];
1863             else
1864             {
1865                 ERR("cannot provide pixel format %s\n", debugstr_guid(&wicformat));
1866                 hr = E_FAIL;
1867             }
1868         }
1869
1870         if (SUCCEEDED(hr))
1871         {
1872             stat = GdipBitmapLockBits(bitmap, &rc, ImageLockModeRead, gdipformat,
1873                 &lockeddata);
1874
1875             if (stat == Ok)
1876             {
1877                 UINT row_size = (lockeddata.Width * PIXELFORMATBPP(gdipformat) + 7)/8;
1878                 BYTE *row;
1879
1880                 /* write one row at a time in case stride is negative */
1881                 row = lockeddata.Scan0;
1882                 for (i=0; i<lockeddata.Height; i++)
1883                 {
1884                     hr = IWICBitmapFrameEncode_WritePixels(frameencode, 1, row_size, row_size, row);
1885                     if (FAILED(hr)) break;
1886                     row += lockeddata.Stride;
1887                 }
1888
1889                 GdipBitmapUnlockBits(bitmap, &lockeddata);
1890             }
1891             else
1892                 hr = E_FAIL;
1893         }
1894
1895         if (SUCCEEDED(hr))
1896             hr = IWICBitmapFrameEncode_Commit(frameencode);
1897
1898         IWICBitmapFrameEncode_Release(frameencode);
1899         IPropertyBag2_Release(encoderoptions);
1900     }
1901
1902     if (SUCCEEDED(hr))
1903         hr = IWICBitmapEncoder_Commit(encoder);
1904
1905     IWICBitmapEncoder_Release(encoder);
1906
1907     if (SUCCEEDED(initresult)) CoUninitialize();
1908
1909     return hresult_to_status(hr);
1910 }
1911
1912 static GpStatus encode_image_BMP(GpImage *image, IStream* stream,
1913     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
1914 {
1915     return encode_image_WIC(image, stream, &CLSID_WICBmpEncoder, params);
1916 }
1917
1918 /*****************************************************************************
1919  * GdipSaveImageToStream [GDIPLUS.@]
1920  */
1921 GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage *image, IStream* stream,
1922     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
1923 {
1924     GpStatus stat;
1925     encode_image_func encode_image;
1926     int i;
1927
1928     TRACE("%p %p %p %p\n", image, stream, clsid, params);
1929
1930     if(!image || !stream)
1931         return InvalidParameter;
1932
1933     /* select correct encoder */
1934     encode_image = NULL;
1935     for (i = 0; i < NUM_CODECS; i++) {
1936         if ((codecs[i].info.Flags & ImageCodecFlagsEncoder) &&
1937             IsEqualCLSID(clsid, &codecs[i].info.Clsid))
1938             encode_image = codecs[i].encode_func;
1939     }
1940     if (encode_image == NULL)
1941         return UnknownImageFormat;
1942
1943     stat = encode_image(image, stream, clsid, params);
1944
1945     return stat;
1946 }
1947
1948 /*****************************************************************************
1949  * GdipGetImagePalette [GDIPLUS.@]
1950  */
1951 GpStatus WINGDIPAPI GdipGetImagePalette(GpImage *image, ColorPalette *palette, INT size)
1952 {
1953     static int calls = 0;
1954
1955     if(!image)
1956         return InvalidParameter;
1957
1958     if(!(calls++))
1959         FIXME("not implemented\n");
1960
1961     return NotImplemented;
1962 }
1963
1964 /*****************************************************************************
1965  * GdipSetImagePalette [GDIPLUS.@]
1966  */
1967 GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image,
1968     GDIPCONST ColorPalette *palette)
1969 {
1970     static int calls;
1971
1972     if(!image || !palette)
1973         return InvalidParameter;
1974
1975     if(!(calls++))
1976         FIXME("not implemented\n");
1977
1978     return NotImplemented;
1979 }
1980
1981 /*************************************************************************
1982  * Encoders -
1983  *   Structures that represent which formats we support for encoding.
1984  */
1985
1986 /* ImageCodecInfo creation routines taken from libgdiplus */
1987 static const WCHAR bmp_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}; /* Built-in BMP */
1988 static const WCHAR bmp_extension[] = {'*','.','B', 'M', 'P',';', '*','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}; /* *.BMP;*.DIB;*.RLE */
1989 static const WCHAR bmp_mimetype[] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}; /* image/bmp */
1990 static const WCHAR bmp_format[] = {'B', 'M', 'P', 0}; /* BMP */
1991 static const BYTE bmp_sig_pattern[] = { 0x42, 0x4D };
1992 static const BYTE bmp_sig_mask[] = { 0xFF, 0xFF };
1993
1994 static const WCHAR jpeg_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'J','P','E','G', 0};
1995 static const WCHAR jpeg_extension[] = {'*','.','J','P','G',';', '*','.','J','P','E','G',';', '*','.','J','P','E',';', '*','.','J','F','I','F',0};
1996 static const WCHAR jpeg_mimetype[] = {'i','m','a','g','e','/','j','p','e','g', 0};
1997 static const WCHAR jpeg_format[] = {'J','P','E','G',0};
1998 static const BYTE jpeg_sig_pattern[] = { 0xFF, 0xD8 };
1999 static const BYTE jpeg_sig_mask[] = { 0xFF, 0xFF };
2000
2001 static const WCHAR gif_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'G','I','F', 0};
2002 static const WCHAR gif_extension[] = {'*','.','G','I','F',0};
2003 static const WCHAR gif_mimetype[] = {'i','m','a','g','e','/','g','i','f', 0};
2004 static const WCHAR gif_format[] = {'G','I','F',0};
2005 static const BYTE gif_sig_pattern[4] = "GIF8";
2006 static const BYTE gif_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
2007
2008 static const WCHAR emf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'E','M','F', 0};
2009 static const WCHAR emf_extension[] = {'*','.','E','M','F',0};
2010 static const WCHAR emf_mimetype[] = {'i','m','a','g','e','/','x','-','e','m','f', 0};
2011 static const WCHAR emf_format[] = {'E','M','F',0};
2012 static const BYTE emf_sig_pattern[] = { 0x01, 0x00, 0x00, 0x00 };
2013 static const BYTE emf_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
2014
2015 static const WCHAR wmf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'W','M','F', 0};
2016 static const WCHAR wmf_extension[] = {'*','.','W','M','F',0};
2017 static const WCHAR wmf_mimetype[] = {'i','m','a','g','e','/','x','-','w','m','f', 0};
2018 static const WCHAR wmf_format[] = {'W','M','F',0};
2019 static const BYTE wmf_sig_pattern[] = { 0xd7, 0xcd };
2020 static const BYTE wmf_sig_mask[] = { 0xFF, 0xFF };
2021
2022 static const WCHAR png_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'P','N','G', 0};
2023 static const WCHAR png_extension[] = {'*','.','P','N','G',0};
2024 static const WCHAR png_mimetype[] = {'i','m','a','g','e','/','p','n','g', 0};
2025 static const WCHAR png_format[] = {'P','N','G',0};
2026 static const BYTE png_sig_pattern[] = { 137, 80, 78, 71, 13, 10, 26, 10, };
2027 static const BYTE png_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
2028
2029 static const WCHAR ico_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'I','C','O', 0};
2030 static const WCHAR ico_extension[] = {'*','.','I','C','O',0};
2031 static const WCHAR ico_mimetype[] = {'i','m','a','g','e','/','x','-','i','c','o','n', 0};
2032 static const WCHAR ico_format[] = {'I','C','O',0};
2033 static const BYTE ico_sig_pattern[] = { 0x00, 0x00, 0x01, 0x00 };
2034 static const BYTE ico_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
2035
2036 static const struct image_codec codecs[NUM_CODECS] = {
2037     {
2038         { /* BMP */
2039             /* Clsid */              { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2040             /* FormatID */           { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2041             /* CodecName */          bmp_codecname,
2042             /* DllName */            NULL,
2043             /* FormatDescription */  bmp_format,
2044             /* FilenameExtension */  bmp_extension,
2045             /* MimeType */           bmp_mimetype,
2046             /* Flags */              ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2047             /* Version */            1,
2048             /* SigCount */           1,
2049             /* SigSize */            2,
2050             /* SigPattern */         bmp_sig_pattern,
2051             /* SigMask */            bmp_sig_mask,
2052         },
2053         encode_image_BMP,
2054         decode_image_olepicture_bitmap
2055     },
2056     {
2057         { /* JPEG */
2058             /* Clsid */              { 0x557cf401, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2059             /* FormatID */           { 0xb96b3caeU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2060             /* CodecName */          jpeg_codecname,
2061             /* DllName */            NULL,
2062             /* FormatDescription */  jpeg_format,
2063             /* FilenameExtension */  jpeg_extension,
2064             /* MimeType */           jpeg_mimetype,
2065             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2066             /* Version */            1,
2067             /* SigCount */           1,
2068             /* SigSize */            2,
2069             /* SigPattern */         jpeg_sig_pattern,
2070             /* SigMask */            jpeg_sig_mask,
2071         },
2072         NULL,
2073         decode_image_jpeg
2074     },
2075     {
2076         { /* GIF */
2077             /* Clsid */              { 0x557cf402, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2078             /* FormatID */           { 0xb96b3cb0U, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2079             /* CodecName */          gif_codecname,
2080             /* DllName */            NULL,
2081             /* FormatDescription */  gif_format,
2082             /* FilenameExtension */  gif_extension,
2083             /* MimeType */           gif_mimetype,
2084             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2085             /* Version */            1,
2086             /* SigCount */           1,
2087             /* SigSize */            4,
2088             /* SigPattern */         gif_sig_pattern,
2089             /* SigMask */            gif_sig_mask,
2090         },
2091         NULL,
2092         decode_image_gif
2093     },
2094     {
2095         { /* EMF */
2096             /* Clsid */              { 0x557cf403, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2097             /* FormatID */           { 0xb96b3cacU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2098             /* CodecName */          emf_codecname,
2099             /* DllName */            NULL,
2100             /* FormatDescription */  emf_format,
2101             /* FilenameExtension */  emf_extension,
2102             /* MimeType */           emf_mimetype,
2103             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
2104             /* Version */            1,
2105             /* SigCount */           1,
2106             /* SigSize */            4,
2107             /* SigPattern */         emf_sig_pattern,
2108             /* SigMask */            emf_sig_mask,
2109         },
2110         NULL,
2111         decode_image_olepicture_metafile
2112     },
2113     {
2114         { /* WMF */
2115             /* Clsid */              { 0x557cf404, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2116             /* FormatID */           { 0xb96b3cadU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2117             /* CodecName */          wmf_codecname,
2118             /* DllName */            NULL,
2119             /* FormatDescription */  wmf_format,
2120             /* FilenameExtension */  wmf_extension,
2121             /* MimeType */           wmf_mimetype,
2122             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
2123             /* Version */            1,
2124             /* SigCount */           1,
2125             /* SigSize */            2,
2126             /* SigPattern */         wmf_sig_pattern,
2127             /* SigMask */            wmf_sig_mask,
2128         },
2129         NULL,
2130         decode_image_olepicture_metafile
2131     },
2132     {
2133         { /* PNG */
2134             /* Clsid */              { 0x557cf406, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2135             /* FormatID */           { 0xb96b3cafU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2136             /* CodecName */          png_codecname,
2137             /* DllName */            NULL,
2138             /* FormatDescription */  png_format,
2139             /* FilenameExtension */  png_extension,
2140             /* MimeType */           png_mimetype,
2141             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2142             /* Version */            1,
2143             /* SigCount */           1,
2144             /* SigSize */            8,
2145             /* SigPattern */         png_sig_pattern,
2146             /* SigMask */            png_sig_mask,
2147         },
2148         NULL,
2149         decode_image_olepicture_bitmap
2150     },
2151     {
2152         { /* ICO */
2153             /* Clsid */              { 0x557cf407, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2154             /* FormatID */           { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2155             /* CodecName */          ico_codecname,
2156             /* DllName */            NULL,
2157             /* FormatDescription */  ico_format,
2158             /* FilenameExtension */  ico_extension,
2159             /* MimeType */           ico_mimetype,
2160             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2161             /* Version */            1,
2162             /* SigCount */           1,
2163             /* SigSize */            4,
2164             /* SigPattern */         ico_sig_pattern,
2165             /* SigMask */            ico_sig_mask,
2166         },
2167         NULL,
2168         decode_image_icon
2169     },
2170 };
2171
2172 /*****************************************************************************
2173  * GdipGetImageDecodersSize [GDIPLUS.@]
2174  */
2175 GpStatus WINGDIPAPI GdipGetImageDecodersSize(UINT *numDecoders, UINT *size)
2176 {
2177     int decoder_count=0;
2178     int i;
2179     TRACE("%p %p\n", numDecoders, size);
2180
2181     if (!numDecoders || !size)
2182         return InvalidParameter;
2183
2184     for (i=0; i<NUM_CODECS; i++)
2185     {
2186         if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
2187             decoder_count++;
2188     }
2189
2190     *numDecoders = decoder_count;
2191     *size = decoder_count * sizeof(ImageCodecInfo);
2192
2193     return Ok;
2194 }
2195
2196 /*****************************************************************************
2197  * GdipGetImageDecoders [GDIPLUS.@]
2198  */
2199 GpStatus WINGDIPAPI GdipGetImageDecoders(UINT numDecoders, UINT size, ImageCodecInfo *decoders)
2200 {
2201     int i, decoder_count=0;
2202     TRACE("%u %u %p\n", numDecoders, size, decoders);
2203
2204     if (!decoders ||
2205         size != numDecoders * sizeof(ImageCodecInfo))
2206         return GenericError;
2207
2208     for (i=0; i<NUM_CODECS; i++)
2209     {
2210         if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
2211         {
2212             if (decoder_count == numDecoders) return GenericError;
2213             memcpy(&decoders[decoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
2214             decoder_count++;
2215         }
2216     }
2217
2218     if (decoder_count < numDecoders) return GenericError;
2219
2220     return Ok;
2221 }
2222
2223 /*****************************************************************************
2224  * GdipGetImageEncodersSize [GDIPLUS.@]
2225  */
2226 GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size)
2227 {
2228     int encoder_count=0;
2229     int i;
2230     TRACE("%p %p\n", numEncoders, size);
2231
2232     if (!numEncoders || !size)
2233         return InvalidParameter;
2234
2235     for (i=0; i<NUM_CODECS; i++)
2236     {
2237         if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
2238             encoder_count++;
2239     }
2240
2241     *numEncoders = encoder_count;
2242     *size = encoder_count * sizeof(ImageCodecInfo);
2243
2244     return Ok;
2245 }
2246
2247 /*****************************************************************************
2248  * GdipGetImageEncoders [GDIPLUS.@]
2249  */
2250 GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
2251 {
2252     int i, encoder_count=0;
2253     TRACE("%u %u %p\n", numEncoders, size, encoders);
2254
2255     if (!encoders ||
2256         size != numEncoders * sizeof(ImageCodecInfo))
2257         return GenericError;
2258
2259     for (i=0; i<NUM_CODECS; i++)
2260     {
2261         if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
2262         {
2263             if (encoder_count == numEncoders) return GenericError;
2264             memcpy(&encoders[encoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
2265             encoder_count++;
2266         }
2267     }
2268
2269     if (encoder_count < numEncoders) return GenericError;
2270
2271     return Ok;
2272 }
2273
2274 /*****************************************************************************
2275  * GdipCreateBitmapFromHBITMAP [GDIPLUS.@]
2276  */
2277 GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap)
2278 {
2279     BITMAP bm;
2280     GpStatus retval;
2281     PixelFormat format;
2282     BYTE* bits;
2283
2284     TRACE("%p %p %p\n", hbm, hpal, bitmap);
2285
2286     if(!hbm || !bitmap)
2287         return InvalidParameter;
2288
2289     /* TODO: Support for device-dependent bitmaps */
2290     if(hpal){
2291         FIXME("no support for device-dependent bitmaps\n");
2292         return NotImplemented;
2293     }
2294
2295     if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
2296             return InvalidParameter;
2297
2298     /* TODO: Figure out the correct format for 16, 32, 64 bpp */
2299     switch(bm.bmBitsPixel) {
2300         case 1:
2301             format = PixelFormat1bppIndexed;
2302             break;
2303         case 4:
2304             format = PixelFormat4bppIndexed;
2305             break;
2306         case 8:
2307             format = PixelFormat8bppIndexed;
2308             break;
2309         case 24:
2310             format = PixelFormat24bppRGB;
2311             break;
2312         case 32:
2313             format = PixelFormat32bppRGB;
2314             break;
2315         case 48:
2316             format = PixelFormat48bppRGB;
2317             break;
2318         default:
2319             FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
2320             return InvalidParameter;
2321     }
2322
2323     if (bm.bmBits)
2324         bits = (BYTE*)bm.bmBits + (bm.bmHeight - 1) * bm.bmWidthBytes;
2325     else
2326     {
2327         FIXME("can only get image data from DIB sections\n");
2328         bits = NULL;
2329     }
2330
2331     retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, -bm.bmWidthBytes,
2332         format, bits, bitmap);
2333
2334     return retval;
2335 }
2336
2337 GpStatus WINGDIPAPI GdipDeleteEffect(CGpEffect *effect)
2338 {
2339     FIXME("(%p): stub\n", effect);
2340     /* note: According to Jose Roca's GDI+ Docs, this is not implemented
2341      * in Windows's gdiplus */
2342     return NotImplemented;
2343 }
2344
2345 /*****************************************************************************
2346  * GdipSetEffectParameters [GDIPLUS.@]
2347  */
2348 GpStatus WINGDIPAPI GdipSetEffectParameters(CGpEffect *effect,
2349     const VOID *params, const UINT size)
2350 {
2351     static int calls;
2352
2353     if(!(calls++))
2354         FIXME("not implemented\n");
2355
2356     return NotImplemented;
2357 }
2358
2359 /*****************************************************************************
2360  * GdipGetImageFlags [GDIPLUS.@]
2361  */
2362 GpStatus WINGDIPAPI GdipGetImageFlags(GpImage *image, UINT *flags)
2363 {
2364     TRACE("%p %p\n", image, flags);
2365
2366     if(!image || !flags)
2367         return InvalidParameter;
2368
2369     *flags = image->flags;
2370
2371     return Ok;
2372 }
2373
2374 GpStatus WINGDIPAPI GdipTestControl(GpTestControlEnum control, void *param)
2375 {
2376     TRACE("(%d, %p)\n", control, param);
2377
2378     switch(control){
2379         case TestControlForceBilinear:
2380             if(param)
2381                 FIXME("TestControlForceBilinear not handled\n");
2382             break;
2383         case TestControlNoICM:
2384             if(param)
2385                 FIXME("TestControlNoICM not handled\n");
2386             break;
2387         case TestControlGetBuildNumber:
2388             *((DWORD*)param) = 3102;
2389             break;
2390     }
2391
2392     return Ok;
2393 }
2394
2395 GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR* fileName,
2396                             HDC hdc, EmfType type, GDIPCONST GpRectF *pFrameRect,
2397                             MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc,
2398                             GpMetafile **metafile)
2399 {
2400     FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
2401                                  frameUnit, debugstr_w(desc), metafile);
2402
2403     return NotImplemented;
2404 }
2405
2406 GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR* fileName, HDC hdc, EmfType type,
2407                             GDIPCONST GpRect *pFrameRect, MetafileFrameUnit frameUnit,
2408                             GDIPCONST WCHAR *desc, GpMetafile **metafile)
2409 {
2410     FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
2411                                  frameUnit, debugstr_w(desc), metafile);
2412
2413     return NotImplemented;
2414 }
2415
2416 GpStatus WINGDIPAPI GdipImageForceValidation(GpImage *image)
2417 {
2418     FIXME("%p\n", image);
2419
2420     return Ok;
2421 }
2422
2423 /*****************************************************************************
2424  * GdipGetImageThumbnail [GDIPLUS.@]
2425  */
2426 GpStatus WINGDIPAPI GdipGetImageThumbnail(GpImage *image, UINT width, UINT height,
2427                             GpImage **ret_image, GetThumbnailImageAbort cb,
2428                             VOID * cb_data)
2429 {
2430     FIXME("(%p %u %u %p %p %p) stub\n",
2431         image, width, height, ret_image, cb, cb_data);
2432     return NotImplemented;
2433 }
2434
2435 /*****************************************************************************
2436  * GdipImageRotateFlip [GDIPLUS.@]
2437  */
2438 GpStatus WINGDIPAPI GdipImageRotateFlip(GpImage *image, RotateFlipType type)
2439 {
2440     FIXME("(%p %u) stub\n", image, type);
2441     return NotImplemented;
2442 }