git.oblomov.eu Git - wine/blob - dlls/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 #include "windef.h"
  22 #include "winbase.h"
  23 #include "winuser.h"
  24 #include "wingdi.h"
  25
  26 #define COBJMACROS
  27 #include "objbase.h"
  28 #include "olectl.h"
  29 #include "ole2.h"
  30
  31 #include "initguid.h"
  32 #include "gdiplus.h"
  33 #include "gdiplus_private.h"
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
  37
  38 #define PIXELFORMATBPP(x) ((x) ? ((x) >> 8) & 255 : 24)
  39
  40 static INT ipicture_pixel_height(IPicture *pic)
  41 {
  42     HDC hdcref;
  43     OLE_YSIZE_HIMETRIC y;
  44
  45     IPicture_get_Height(pic, &y);
  46
  47     hdcref = GetDC(0);
  48
  49     y = MulDiv(y, GetDeviceCaps(hdcref, LOGPIXELSY), INCH_HIMETRIC);
  50     ReleaseDC(0, hdcref);
  51
  52     return y;
  53 }
  54
  55 static INT ipicture_pixel_width(IPicture *pic)
  56 {
  57     HDC hdcref;
  58     OLE_XSIZE_HIMETRIC x;
  59
  60     IPicture_get_Width(pic, &x);
  61
  62     hdcref = GetDC(0);
  63
  64     x = MulDiv(x, GetDeviceCaps(hdcref, LOGPIXELSX), INCH_HIMETRIC);
  65
  66     ReleaseDC(0, hdcref);
  67
  68     return x;
  69 }
  70
  71 GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap* bitmap, INT x, INT y,
  72     ARGB *color)
  73 {
  74     static int calls;
  75     TRACE("%p %d %d %p\n", bitmap, x, y, color);
  76
  77     if(!bitmap || !color)
  78         return InvalidParameter;
  79
  80     if(!(calls++))
  81         FIXME("not implemented\n");
  82
  83     *color = 0xdeadbeef;
  84
  85     return NotImplemented;
  86 }
  87
  88 /* This function returns a pointer to an array of pixels that represents the
  89  * bitmap. The *entire* bitmap is locked according to the lock mode specified by
  90  * flags.  It is correct behavior that a user who calls this function with write
  91  * privileges can write to the whole bitmap (not just the area in rect).
  92  *
  93  * FIXME: only used portion of format is bits per pixel. */
  94 GpStatus WINGDIPAPI GdipBitmapLockBits(GpBitmap* bitmap, GDIPCONST GpRect* rect,
  95     UINT flags, PixelFormat format, BitmapData* lockeddata)
  96 {
  97     BOOL bm_is_selected;
  98     INT stride, bitspp = PIXELFORMATBPP(format);
  99     OLE_HANDLE hbm;
 100     HDC hdc;
 101     HBITMAP old = NULL;
 102     BITMAPINFO *pbmi;
 103     BYTE *buff = NULL;
 104     UINT abs_height;
 105     GpRect act_rect; /* actual rect to be used */
 106
 107     TRACE("%p %p %d %d %p\n", bitmap, rect, flags, format, lockeddata);
 108
 109     if(!lockeddata || !bitmap)
 110         return InvalidParameter;
 111
 112     if(rect){
 113         if(rect->X < 0 || rect->Y < 0 || (rect->X + rect->Width > bitmap->width) ||
 114           (rect->Y + rect->Height > bitmap->height) || !flags)
 115             return InvalidParameter;
 116
 117         act_rect = *rect;
 118     }
 119     else{
 120         act_rect.X = act_rect.Y = 0;
 121         act_rect.Width  = bitmap->width;
 122         act_rect.Height = bitmap->height;
 123     }
 124
 125     if(flags & ImageLockModeUserInputBuf)
 126         return NotImplemented;
 127
 128     if(bitmap->lockmode)
 129         return WrongState;
 130
 131     IPicture_get_Handle(bitmap->image.picture, &hbm);
 132     IPicture_get_CurDC(bitmap->image.picture, &hdc);
 133     bm_is_selected = (hdc != 0);
 134
 135     pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
 136     if (!pbmi)
 137         return OutOfMemory;
 138     pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 139     pbmi->bmiHeader.biBitCount = 0;
 140
 141     if(!bm_is_selected){
 142         hdc = CreateCompatibleDC(0);
 143         old = SelectObject(hdc, (HBITMAP)hbm);
 144     }
 145
 146     /* fill out bmi */
 147     GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
 148
 149     abs_height = abs(pbmi->bmiHeader.biHeight);
 150     stride = pbmi->bmiHeader.biWidth * bitspp / 8;
 151     stride = (stride + 3) & ~3;
 152
 153     buff = GdipAlloc(stride * abs_height);
 154
 155     pbmi->bmiHeader.biBitCount = bitspp;
 156
 157     if(buff)
 158         GetDIBits(hdc, (HBITMAP)hbm, 0, abs_height, buff, pbmi, DIB_RGB_COLORS);
 159
 160     if(!bm_is_selected){
 161         SelectObject(hdc, old);
 162         DeleteDC(hdc);
 163     }
 164
 165     if(!buff){
 166         GdipFree(pbmi);
 167         return OutOfMemory;
 168     }
 169
 170     lockeddata->Width  = act_rect.Width;
 171     lockeddata->Height = act_rect.Height;
 172     lockeddata->PixelFormat = format;
 173     lockeddata->Reserved = flags;
 174
 175     if(pbmi->bmiHeader.biHeight > 0){
 176         lockeddata->Stride = -stride;
 177         lockeddata->Scan0  = buff + (bitspp / 8) * act_rect.X +
 178                              stride * (abs_height - 1 - act_rect.Y);
 179     }
 180     else{
 181         lockeddata->Stride = stride;
 182         lockeddata->Scan0  = buff + (bitspp / 8) * act_rect.X + stride * act_rect.Y;
 183     }
 184
 185     bitmap->lockmode = flags;
 186     bitmap->numlocks++;
 187
 188     bitmap->bitmapbits = buff;
 189
 190     GdipFree(pbmi);
 191     return Ok;
 192 }
 193
 194 GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap* bitmap,
 195     BitmapData* lockeddata)
 196 {
 197     OLE_HANDLE hbm;
 198     HDC hdc;
 199     HBITMAP old = NULL;
 200     BOOL bm_is_selected;
 201     BITMAPINFO *pbmi;
 202
 203     if(!bitmap || !lockeddata)
 204         return InvalidParameter;
 205
 206     if(!bitmap->lockmode)
 207         return WrongState;
 208
 209     if(lockeddata->Reserved & ImageLockModeUserInputBuf)
 210         return NotImplemented;
 211
 212     if(lockeddata->Reserved & ImageLockModeRead){
 213         if(!(--bitmap->numlocks))
 214             bitmap->lockmode = 0;
 215
 216         GdipFree(bitmap->bitmapbits);
 217         bitmap->bitmapbits = NULL;
 218         return Ok;
 219     }
 220
 221     IPicture_get_Handle(bitmap->image.picture, &hbm);
 222     IPicture_get_CurDC(bitmap->image.picture, &hdc);
 223     bm_is_selected = (hdc != 0);
 224
 225     pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
 226     pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 227     pbmi->bmiHeader.biBitCount = 0;
 228
 229     if(!bm_is_selected){
 230         hdc = CreateCompatibleDC(0);
 231         old = SelectObject(hdc, (HBITMAP)hbm);
 232     }
 233
 234     GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
 235     pbmi->bmiHeader.biBitCount = PIXELFORMATBPP(lockeddata->PixelFormat);
 236     SetDIBits(hdc, (HBITMAP)hbm, 0, abs(pbmi->bmiHeader.biHeight),
 237               bitmap->bitmapbits, pbmi, DIB_RGB_COLORS);
 238
 239     if(!bm_is_selected){
 240         SelectObject(hdc, old);
 241         DeleteDC(hdc);
 242     }
 243
 244     GdipFree(pbmi);
 245     GdipFree(bitmap->bitmapbits);
 246     bitmap->bitmapbits = NULL;
 247     bitmap->lockmode = 0;
 248
 249     return Ok;
 250 }
 251
 252 GpStatus WINGDIPAPI GdipCloneImage(GpImage *image, GpImage **cloneImage)
 253 {
 254     IStream* stream;
 255     HRESULT hr;
 256     INT size;
 257     LARGE_INTEGER move;
 258     GpStatus stat = GenericError;
 259
 260     TRACE("%p, %p\n", image, cloneImage);
 261
 262     if (!image || !cloneImage)
 263         return InvalidParameter;
 264
 265     hr = CreateStreamOnHGlobal(0, TRUE, &stream);
 266     if (FAILED(hr))
 267         return GenericError;
 268
 269     hr = IPicture_SaveAsFile(image->picture, stream, FALSE, &size);
 270     if(FAILED(hr))
 271     {
 272         WARN("Failed to save image on stream\n");
 273         goto out;
 274     }
 275
 276     /* Set seek pointer back to the beginning of the picture */
 277     move.QuadPart = 0;
 278     hr = IStream_Seek(stream, move, STREAM_SEEK_SET, NULL);
 279     if (FAILED(hr))
 280         goto out;
 281
 282     stat = GdipLoadImageFromStream(stream, cloneImage);
 283     if (stat != Ok) WARN("Failed to load image from stream\n");
 284
 285 out:
 286     IStream_Release(stream);
 287     return stat;
 288 }
 289
 290 GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename,
 291     GpBitmap **bitmap)
 292 {
 293     GpStatus stat;
 294     IStream *stream;
 295
 296     TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
 297
 298     if(!filename || !bitmap)
 299         return InvalidParameter;
 300
 301     stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
 302
 303     if(stat != Ok)
 304         return stat;
 305
 306     stat = GdipCreateBitmapFromStream(stream, bitmap);
 307
 308     IStream_Release(stream);
 309
 310     return stat;
 311 }
 312
 313 GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO* info,
 314                                                VOID *bits, GpBitmap **bitmap)
 315 {
 316     DWORD height, stride;
 317     PixelFormat format;
 318
 319     FIXME("(%p, %p, %p) - partially implemented\n", info, bits, bitmap);
 320
 321     height = abs(info->bmiHeader.biHeight);
 322     stride = ((info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) >> 3) & ~3;
 323
 324     if(info->bmiHeader.biHeight > 0) /* bottom-up */
 325     {
 326         bits = (BYTE*)bits + (height - 1) * stride;
 327         stride = -stride;
 328     }
 329
 330     switch(info->bmiHeader.biBitCount) {
 331     case 1:
 332         format = PixelFormat1bppIndexed;
 333         break;
 334     case 4:
 335         format = PixelFormat4bppIndexed;
 336         break;
 337     case 8:
 338         format = PixelFormat8bppIndexed;
 339         break;
 340     case 24:
 341         format = PixelFormat24bppRGB;
 342         break;
 343     default:
 344         FIXME("don't know how to handle %d bpp\n", info->bmiHeader.biBitCount);
 345         *bitmap = NULL;
 346         return InvalidParameter;
 347     }
 348
 349     return GdipCreateBitmapFromScan0(info->bmiHeader.biWidth, height, stride, format,
 350                                      bits, bitmap);
 351
 352 }
 353
 354 /* FIXME: no icm */
 355 GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename,
 356     GpBitmap **bitmap)
 357 {
 358     TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
 359
 360     return GdipCreateBitmapFromFile(filename, bitmap);
 361 }
 362
 363 GpStatus WINGDIPAPI GdipCreateBitmapFromResource(HINSTANCE hInstance,
 364     GDIPCONST WCHAR* lpBitmapName, GpBitmap** bitmap)
 365 {
 366     HBITMAP hbm;
 367     GpStatus stat = InvalidParameter;
 368
 369     TRACE("%p (%s) %p\n", hInstance, debugstr_w(lpBitmapName), bitmap);
 370
 371     if(!lpBitmapName || !bitmap)
 372         return InvalidParameter;
 373
 374     /* load DIB */
 375     hbm = (HBITMAP)LoadImageW(hInstance,lpBitmapName,IMAGE_BITMAP,0,0,LR_CREATEDIBSECTION);
 376
 377     if(hbm){
 378         stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
 379         DeleteObject(hbm);
 380     }
 381
 382     return stat;
 383 }
 384
 385 GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap,
 386     HBITMAP* hbmReturn, ARGB background)
 387 {
 388     FIXME("stub\n");
 389
 390     hbmReturn = NULL;
 391
 392     return NotImplemented;
 393 }
 394
 395 GpStatus WINGDIPAPI GdipConvertToEmfPlus(const GpGraphics* ref,
 396     GpMetafile* metafile, BOOL* succ, EmfType emfType,
 397     const WCHAR* description, GpMetafile** out_metafile)
 398 {
 399     static int calls;
 400
 401     if(!ref || !metafile || !out_metafile)
 402         return InvalidParameter;
 403
 404     *succ = FALSE;
 405     *out_metafile = NULL;
 406
 407     if(!(calls++))
 408         FIXME("not implemented\n");
 409
 410     return NotImplemented;
 411 }
 412
 413 /* FIXME: this should create a bitmap in the given size with the attributes
 414  * (resolution etc.) of the graphics object */
 415 GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics(INT width, INT height,
 416     GpGraphics* target, GpBitmap** bitmap)
 417 {
 418     static int calls;
 419     GpStatus ret;
 420
 421     if(!target || !bitmap)
 422         return InvalidParameter;
 423
 424     if(!(calls++))
 425         FIXME("hacked stub\n");
 426
 427     ret = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat24bppRGB,
 428                                     NULL, bitmap);
 429
 430     return ret;
 431 }
 432
 433 GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride,
 434     PixelFormat format, BYTE* scan0, GpBitmap** bitmap)
 435 {
 436     BITMAPFILEHEADER *bmfh;
 437     BITMAPINFOHEADER *bmih;
 438     BYTE *buff;
 439     INT datalen, size;
 440     IStream *stream;
 441
 442     TRACE("%d %d %d %d %p %p\n", width, height, stride, format, scan0, bitmap);
 443
 444     if (!bitmap) return InvalidParameter;
 445
 446     if(width <= 0 || height <= 0 || (scan0 && (stride % 4))){
 447         *bitmap = NULL;
 448         return InvalidParameter;
 449     }
 450
 451     if(scan0 && !stride)
 452         return InvalidParameter;
 453
 454     /* FIXME: windows allows negative stride (reads backwards from scan0) */
 455     if(stride < 0){
 456         FIXME("negative stride\n");
 457         return InvalidParameter;
 458     }
 459
 460     *bitmap = GdipAlloc(sizeof(GpBitmap));
 461     if(!*bitmap)    return OutOfMemory;
 462
 463     if(stride == 0){
 464         stride = width * (PIXELFORMATBPP(format) / 8);
 465         stride = (stride + 3) & ~3;
 466     }
 467
 468     datalen = abs(stride * height);
 469     size = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + datalen;
 470     buff = GdipAlloc(size);
 471     if(!buff){
 472         GdipFree(*bitmap);
 473         return OutOfMemory;
 474     }
 475
 476     bmfh = (BITMAPFILEHEADER*) buff;
 477     bmih = (BITMAPINFOHEADER*) (bmfh + 1);
 478
 479     bmfh->bfType    = (((WORD)'M') << 8) + (WORD)'B';
 480     bmfh->bfSize    = size;
 481     bmfh->bfOffBits = size - datalen;
 482
 483     bmih->biSize            = sizeof(BITMAPINFOHEADER);
 484     bmih->biWidth           = width;
 485     bmih->biHeight          = -height;
 486     /* FIXME: use the rest of the data from format */
 487     bmih->biBitCount        = PIXELFORMATBPP(format);
 488     bmih->biCompression     = BI_RGB;
 489     bmih->biSizeImage       = datalen;
 490
 491     if(scan0)
 492         memcpy(bmih + 1, scan0, datalen);
 493     else
 494         memset(bmih + 1, 0, datalen);
 495
 496     if(CreateStreamOnHGlobal(buff, TRUE, &stream) != S_OK){
 497         ERR("could not make stream\n");
 498         GdipFree(*bitmap);
 499         GdipFree(buff);
 500         return GenericError;
 501     }
 502
 503     if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
 504         (LPVOID*) &((*bitmap)->image.picture)) != S_OK){
 505         TRACE("Could not load picture\n");
 506         IStream_Release(stream);
 507         GdipFree(*bitmap);
 508         GdipFree(buff);
 509         return GenericError;
 510     }
 511
 512     (*bitmap)->image.type = ImageTypeBitmap;
 513     (*bitmap)->image.flags = ImageFlagsNone;
 514     (*bitmap)->width = width;
 515     (*bitmap)->height = height;
 516     (*bitmap)->format = format;
 517
 518     return Ok;
 519 }
 520
 521 GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream* stream,
 522     GpBitmap **bitmap)
 523 {
 524     GpStatus stat;
 525
 526     TRACE("%p %p\n", stream, bitmap);
 527
 528     stat = GdipLoadImageFromStream(stream, (GpImage**) bitmap);
 529
 530     if(stat != Ok)
 531         return stat;
 532
 533     if((*bitmap)->image.type != ImageTypeBitmap){
 534         IPicture_Release((*bitmap)->image.picture);
 535         GdipFree(bitmap);
 536         return GenericError; /* FIXME: what error to return? */
 537     }
 538
 539     return Ok;
 540 }
 541
 542 /* FIXME: no icm */
 543 GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream* stream,
 544     GpBitmap **bitmap)
 545 {
 546     TRACE("%p %p\n", stream, bitmap);
 547
 548     return GdipCreateBitmapFromStream(stream, bitmap);
 549 }
 550
 551 GpStatus WINGDIPAPI GdipCreateCachedBitmap(GpBitmap *bitmap, GpGraphics *graphics,
 552     GpCachedBitmap **cachedbmp)
 553 {
 554     GpStatus stat;
 555
 556     TRACE("%p %p %p\n", bitmap, graphics, cachedbmp);
 557
 558     if(!bitmap || !graphics || !cachedbmp)
 559         return InvalidParameter;
 560
 561     *cachedbmp = GdipAlloc(sizeof(GpCachedBitmap));
 562     if(!*cachedbmp)
 563         return OutOfMemory;
 564
 565     stat = GdipCloneImage(&(bitmap->image), &(*cachedbmp)->image);
 566     if(stat != Ok){
 567         GdipFree(*cachedbmp);
 568         return stat;
 569     }
 570
 571     return Ok;
 572 }
 573
 574 GpStatus WINGDIPAPI GdipDeleteCachedBitmap(GpCachedBitmap *cachedbmp)
 575 {
 576     TRACE("%p\n", cachedbmp);
 577
 578     if(!cachedbmp)
 579         return InvalidParameter;
 580
 581     GdipDisposeImage(cachedbmp->image);
 582     GdipFree(cachedbmp);
 583
 584     return Ok;
 585 }
 586
 587 GpStatus WINGDIPAPI GdipDrawCachedBitmap(GpGraphics *graphics,
 588     GpCachedBitmap *cachedbmp, INT x, INT y)
 589 {
 590     TRACE("%p %p %d %d\n", graphics, cachedbmp, x, y);
 591
 592     if(!graphics || !cachedbmp)
 593         return InvalidParameter;
 594
 595     return GdipDrawImage(graphics, cachedbmp->image, (REAL)x, (REAL)y);
 596 }
 597
 598 GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
 599 {
 600     HDC hdc;
 601
 602     TRACE("%p\n", image);
 603
 604     if(!image)
 605         return InvalidParameter;
 606
 607     IPicture_get_CurDC(image->picture, &hdc);
 608     DeleteDC(hdc);
 609     IPicture_Release(image->picture);
 610     if (image->type == ImageTypeBitmap)
 611         GdipFree(((GpBitmap*)image)->bitmapbits);
 612     GdipFree(image);
 613
 614     return Ok;
 615 }
 616
 617 GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage *image, ImageItemData* item)
 618 {
 619     if(!image || !item)
 620         return InvalidParameter;
 621
 622     return NotImplemented;
 623 }
 624
 625 GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect,
 626     GpUnit *srcUnit)
 627 {
 628     TRACE("%p %p %p\n", image, srcRect, srcUnit);
 629
 630     if(!image || !srcRect || !srcUnit)
 631         return InvalidParameter;
 632     if(image->type == ImageTypeMetafile){
 633         *srcRect = ((GpMetafile*)image)->bounds;
 634         *srcUnit = ((GpMetafile*)image)->unit;
 635     }
 636     else if(image->type == ImageTypeBitmap){
 637         srcRect->X = srcRect->Y = 0.0;
 638         srcRect->Width = (REAL) ((GpBitmap*)image)->width;
 639         srcRect->Height = (REAL) ((GpBitmap*)image)->height;
 640         *srcUnit = UnitPixel;
 641     }
 642     else{
 643         srcRect->X = srcRect->Y = 0.0;
 644         srcRect->Width = ipicture_pixel_width(image->picture);
 645         srcRect->Height = ipicture_pixel_height(image->picture);
 646         *srcUnit = UnitPixel;
 647     }
 648
 649     TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
 650           srcRect->Width, srcRect->Height, *srcUnit);
 651
 652     return Ok;
 653 }
 654
 655 GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width,
 656     REAL *height)
 657 {
 658     TRACE("%p %p %p\n", image, width, height);
 659
 660     if(!image || !height || !width)
 661         return InvalidParameter;
 662
 663     if(image->type == ImageTypeMetafile){
 664         HDC hdc = GetDC(0);
 665
 666         *height = convert_unit(hdc, ((GpMetafile*)image)->unit) *
 667                         ((GpMetafile*)image)->bounds.Height;
 668
 669         *width = convert_unit(hdc, ((GpMetafile*)image)->unit) *
 670                         ((GpMetafile*)image)->bounds.Width;
 671
 672         ReleaseDC(0, hdc);
 673     }
 674
 675     else if(image->type == ImageTypeBitmap){
 676         *height = ((GpBitmap*)image)->height;
 677         *width = ((GpBitmap*)image)->width;
 678     }
 679     else{
 680         *height = ipicture_pixel_height(image->picture);
 681         *width = ipicture_pixel_width(image->picture);
 682     }
 683
 684     TRACE("returning (%f, %f)\n", *height, *width);
 685     return Ok;
 686 }
 687
 688 GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image,
 689     GpGraphics **graphics)
 690 {
 691     HDC hdc;
 692
 693     TRACE("%p %p\n", image, graphics);
 694
 695     if(!image || !graphics)
 696         return InvalidParameter;
 697
 698     if(image->type != ImageTypeBitmap){
 699         FIXME("not implemented for image type %d\n", image->type);
 700         return NotImplemented;
 701     }
 702
 703     IPicture_get_CurDC(image->picture, &hdc);
 704
 705     if(!hdc){
 706         hdc = CreateCompatibleDC(0);
 707         IPicture_SelectPicture(image->picture, hdc, NULL, NULL);
 708     }
 709
 710     return GdipCreateFromHDC(hdc, graphics);
 711 }
 712
 713 GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
 714 {
 715     TRACE("%p %p\n", image, height);
 716
 717     if(!image || !height)
 718         return InvalidParameter;
 719
 720     if(image->type == ImageTypeMetafile){
 721         HDC hdc = GetDC(0);
 722
 723         *height = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
 724                         ((GpMetafile*)image)->bounds.Height);
 725
 726         ReleaseDC(0, hdc);
 727     }
 728     else if(image->type == ImageTypeBitmap)
 729         *height = ((GpBitmap*)image)->height;
 730     else
 731         *height = ipicture_pixel_height(image->picture);
 732
 733     TRACE("returning %d\n", *height);
 734
 735     return Ok;
 736 }
 737
 738 GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *res)
 739 {
 740     static int calls;
 741
 742     if(!image || !res)
 743         return InvalidParameter;
 744
 745     if(!(calls++))
 746         FIXME("not implemented\n");
 747
 748     return NotImplemented;
 749 }
 750
 751 GpStatus WINGDIPAPI GdipGetImagePaletteSize(GpImage *image, INT *size)
 752 {
 753     FIXME("%p %p\n", image, size);
 754
 755     if(!image || !size)
 756         return InvalidParameter;
 757
 758     return NotImplemented;
 759 }
 760
 761 /* FIXME: test this function for non-bitmap types */
 762 GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format)
 763 {
 764     TRACE("%p %p\n", image, format);
 765
 766     if(!image || !format)
 767         return InvalidParameter;
 768
 769     if(image->type != ImageTypeBitmap)
 770         *format = PixelFormat24bppRGB;
 771     else
 772         *format = ((GpBitmap*) image)->format;
 773
 774     return Ok;
 775 }
 776
 777 GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
 778 {
 779     static int calls;
 780
 781     if(!image || !format)
 782         return InvalidParameter;
 783
 784     if(!(calls++))
 785         FIXME("stub\n");
 786
 787     /* FIXME: should be detected from embedded picture or stored separately */
 788     switch (image->type)
 789     {
 790     case ImageTypeBitmap:   *format = ImageFormatBMP; break;
 791     case ImageTypeMetafile: *format = ImageFormatEMF; break;
 792     default:
 793         WARN("unknown type %u\n", image->type);
 794         *format = ImageFormatUndefined;
 795     }
 796     return Ok;
 797 }
 798
 799 GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
 800 {
 801     TRACE("%p %p\n", image, type);
 802
 803     if(!image || !type)
 804         return InvalidParameter;
 805
 806     *type = image->type;
 807
 808     return Ok;
 809 }
 810
 811 GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *res)
 812 {
 813     static int calls;
 814
 815     if(!image || !res)
 816         return InvalidParameter;
 817
 818     if(!(calls++))
 819         FIXME("not implemented\n");
 820
 821     return NotImplemented;
 822 }
 823
 824 GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
 825 {
 826     TRACE("%p %p\n", image, width);
 827
 828     if(!image || !width)
 829         return InvalidParameter;
 830
 831     if(image->type == ImageTypeMetafile){
 832         HDC hdc = GetDC(0);
 833
 834         *width = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
 835                         ((GpMetafile*)image)->bounds.Width);
 836
 837         ReleaseDC(0, hdc);
 838     }
 839     else if(image->type == ImageTypeBitmap)
 840         *width = ((GpBitmap*)image)->width;
 841     else
 842         *width = ipicture_pixel_width(image->picture);
 843
 844     TRACE("returning %d\n", *width);
 845
 846     return Ok;
 847 }
 848
 849 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile * metafile,
 850     MetafileHeader * header)
 851 {
 852     static int calls;
 853
 854     if(!metafile || !header)
 855         return InvalidParameter;
 856
 857     if(!(calls++))
 858         FIXME("not implemented\n");
 859
 860     return Ok;
 861 }
 862
 863 GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT size,
 864     UINT num, PropertyItem* items)
 865 {
 866     static int calls;
 867
 868     if(!(calls++))
 869         FIXME("not implemented\n");
 870
 871     return InvalidParameter;
 872 }
 873
 874 GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage *image, UINT* num)
 875 {
 876     static int calls;
 877
 878     if(!(calls++))
 879         FIXME("not implemented\n");
 880
 881     return InvalidParameter;
 882 }
 883
 884 GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT num, PROPID* list)
 885 {
 886     static int calls;
 887
 888     if(!(calls++))
 889         FIXME("not implemented\n");
 890
 891     return InvalidParameter;
 892 }
 893
 894 GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID id, UINT size,
 895     PropertyItem* buffer)
 896 {
 897     static int calls;
 898
 899     if(!(calls++))
 900         FIXME("not implemented\n");
 901
 902     return InvalidParameter;
 903 }
 904
 905 GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID pid,
 906     UINT* size)
 907 {
 908     static int calls;
 909
 910     TRACE("%p %x %p\n", image, pid, size);
 911
 912     if(!size || !image)
 913         return InvalidParameter;
 914
 915     if(!(calls++))
 916         FIXME("not implemented\n");
 917
 918     return NotImplemented;
 919 }
 920
 921 GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT* size, UINT* num)
 922 {
 923     static int calls;
 924
 925     if(!(calls++))
 926         FIXME("not implemented\n");
 927
 928     return InvalidParameter;
 929 }
 930
 931 GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
 932     GDIPCONST GUID* dimensionID, UINT* count)
 933 {
 934     static int calls;
 935
 936     if(!image || !dimensionID || !count)
 937         return InvalidParameter;
 938
 939     if(!(calls++))
 940         FIXME("not implemented\n");
 941
 942     return NotImplemented;
 943 }
 944
 945 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage *image,
 946     UINT* count)
 947 {
 948     if(!image || !count)
 949         return InvalidParameter;
 950
 951     *count = 1;
 952
 953     FIXME("stub\n");
 954
 955     return Ok;
 956 }
 957
 958 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image,
 959     GUID* dimensionIDs, UINT count)
 960 {
 961     static int calls;
 962
 963     if(!image || !dimensionIDs)
 964         return InvalidParameter;
 965
 966     if(!(calls++))
 967         FIXME("not implemented\n");
 968
 969     return Ok;
 970 }
 971
 972 GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage *image,
 973     GDIPCONST GUID* dimensionID, UINT frameidx)
 974 {
 975     static int calls;
 976
 977     if(!image || !dimensionID)
 978         return InvalidParameter;
 979
 980     if(!(calls++))
 981         FIXME("not implemented\n");
 982
 983     return Ok;
 984 }
 985
 986 GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
 987                                           GpImage **image)
 988 {
 989     GpStatus stat;
 990     IStream *stream;
 991
 992     TRACE("(%s) %p\n", debugstr_w(filename), image);
 993
 994     if (!filename || !image)
 995         return InvalidParameter;
 996
 997     stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
 998
 999     if (stat != Ok)
1000         return stat;
1001
1002     stat = GdipLoadImageFromStream(stream, image);
1003
1004     IStream_Release(stream);
1005
1006     return stat;
1007 }
1008
1009 /* FIXME: no icm handling */
1010 GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,GpImage **image)
1011 {
1012     TRACE("(%s) %p\n", debugstr_w(filename), image);
1013
1014     return GdipLoadImageFromFile(filename, image);
1015 }
1016
1017 GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream* stream, GpImage **image)
1018 {
1019     IPicture *pic;
1020     short type;
1021
1022     TRACE("%p %p\n", stream, image);
1023
1024     if(!stream || !image)
1025         return InvalidParameter;
1026
1027     if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
1028         (LPVOID*) &pic) != S_OK){
1029         TRACE("Could not load picture\n");
1030         return GenericError;
1031     }
1032
1033     IPicture_get_Type(pic, &type);
1034
1035     if(type == PICTYPE_BITMAP){
1036         BITMAPINFO *pbmi;
1037         BITMAPCOREHEADER* bmch;
1038         OLE_HANDLE hbm;
1039         HDC hdc;
1040
1041         pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
1042         if (!pbmi)
1043             return OutOfMemory;
1044         *image = GdipAlloc(sizeof(GpBitmap));
1045         if(!*image){
1046             GdipFree(pbmi);
1047             return OutOfMemory;
1048         }
1049         (*image)->type = ImageTypeBitmap;
1050
1051         (*((GpBitmap**) image))->width = ipicture_pixel_width(pic);
1052         (*((GpBitmap**) image))->height = ipicture_pixel_height(pic);
1053
1054         /* get the pixel format */
1055         IPicture_get_Handle(pic, &hbm);
1056         IPicture_get_CurDC(pic, &hdc);
1057
1058         bmch = (BITMAPCOREHEADER*) (&pbmi->bmiHeader);
1059         bmch->bcSize = sizeof(BITMAPCOREHEADER);
1060
1061         if(!hdc){
1062             HBITMAP old;
1063             hdc = CreateCompatibleDC(0);
1064             old = SelectObject(hdc, (HBITMAP)hbm);
1065             GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
1066             SelectObject(hdc, old);
1067             DeleteDC(hdc);
1068         }
1069         else
1070             GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
1071
1072         (*((GpBitmap**) image))->format = (bmch->bcBitCount << 8) | PixelFormatGDI;
1073         GdipFree(pbmi);
1074     }
1075     else if(type == PICTYPE_METAFILE || type == PICTYPE_ENHMETAFILE){
1076         /* FIXME: missing initialization code */
1077         *image = GdipAlloc(sizeof(GpMetafile));
1078         if(!*image) return OutOfMemory;
1079         (*image)->type = ImageTypeMetafile;
1080     }
1081     else{
1082         *image = GdipAlloc(sizeof(GpImage));
1083         if(!*image) return OutOfMemory;
1084         (*image)->type = ImageTypeUnknown;
1085     }
1086
1087     (*image)->picture = pic;
1088     (*image)->flags   = ImageFlagsNone;
1089
1090     return Ok;
1091 }
1092
1093 /* FIXME: no ICM */
1094 GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image)
1095 {
1096     TRACE("%p %p\n", stream, image);
1097
1098     return GdipLoadImageFromStream(stream, image);
1099 }
1100
1101 GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage *image, PROPID propId)
1102 {
1103     static int calls;
1104
1105     if(!image)
1106         return InvalidParameter;
1107
1108     if(!(calls++))
1109         FIXME("not implemented\n");
1110
1111     return NotImplemented;
1112 }
1113
1114 GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item)
1115 {
1116     static int calls;
1117
1118     if(!(calls++))
1119         FIXME("not implemented\n");
1120
1121     return NotImplemented;
1122 }
1123
1124 GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
1125                                         GDIPCONST CLSID *clsidEncoder,
1126                                         GDIPCONST EncoderParameters *encoderParams)
1127 {
1128     GpStatus stat;
1129     IStream *stream;
1130
1131     TRACE("%p (%s) %p %p\n", image, debugstr_w(filename), clsidEncoder, encoderParams);
1132
1133     if (!image || !filename|| !clsidEncoder)
1134         return InvalidParameter;
1135
1136     if (!(image->picture))
1137         return InvalidParameter;
1138
1139     stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
1140     if (stat != Ok)
1141         return GenericError;
1142
1143     stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
1144
1145     IStream_Release(stream);
1146     return stat;
1147 }
1148
1149 /*************************************************************************
1150  * Encoding functions -
1151  *   These functions encode an image in different image file formats.
1152  */
1153 #define BITMAP_FORMAT_BMP   0x4d42 /* "BM" */
1154 #define BITMAP_FORMAT_JPEG  0xd8ff
1155 #define BITMAP_FORMAT_GIF   0x4947
1156 #define BITMAP_FORMAT_PNG   0x5089
1157 #define BITMAP_FORMAT_APM   0xcdd7
1158
1159 static GpStatus encode_image_BMP(LPVOID bitmap_bits, LPBITMAPINFO bitmap_info,
1160                                  void **output, unsigned int *output_size)
1161 {
1162     int num_palette_entries;
1163     BITMAPFILEHEADER *bmp_file_hdr;
1164     BITMAPINFO *bmp_info_hdr;
1165
1166     if (bitmap_info->bmiHeader.biClrUsed) {
1167         num_palette_entries = bitmap_info->bmiHeader.biClrUsed;
1168         if (num_palette_entries > 256) num_palette_entries = 256;
1169     } else {
1170         if (bitmap_info->bmiHeader.biBitCount <= 8)
1171             num_palette_entries = 1 << bitmap_info->bmiHeader.biBitCount;
1172         else
1173             num_palette_entries = 0;
1174     }
1175
1176     *output_size =
1177         sizeof(BITMAPFILEHEADER) +
1178         sizeof(BITMAPINFOHEADER) +
1179         num_palette_entries * sizeof(RGBQUAD) +
1180         bitmap_info->bmiHeader.biSizeImage;
1181
1182     *output = GdipAlloc(*output_size);
1183
1184     bmp_file_hdr = (BITMAPFILEHEADER*) *output;
1185     bmp_file_hdr->bfType = BITMAP_FORMAT_BMP;
1186     bmp_file_hdr->bfSize = *output_size;
1187     bmp_file_hdr->bfOffBits =
1188         sizeof(BITMAPFILEHEADER) +
1189         sizeof(BITMAPINFOHEADER) +
1190         num_palette_entries * sizeof (RGBQUAD);
1191
1192     bmp_info_hdr = (BITMAPINFO*) ((unsigned char*)(*output) + sizeof(BITMAPFILEHEADER));
1193     memcpy(bmp_info_hdr, bitmap_info, sizeof(BITMAPINFOHEADER) + num_palette_entries * sizeof(RGBQUAD));
1194     memcpy((unsigned char *)(*output) +
1195            sizeof(BITMAPFILEHEADER) +
1196            sizeof(BITMAPINFOHEADER) +
1197            num_palette_entries * sizeof(RGBQUAD),
1198            bitmap_bits, bitmap_info->bmiHeader.biSizeImage);
1199
1200     return Ok;
1201 }
1202
1203 typedef GpStatus encode_image_func(LPVOID bitmap_bits, LPBITMAPINFO bitmap_info,
1204                                    void **output, unsigned int *output_size);
1205
1206 typedef enum {
1207     BMP,
1208     NUM_ENCODERS_SUPPORTED
1209 } ImageFormat;
1210
1211 static const ImageCodecInfo codecs[NUM_ENCODERS_SUPPORTED];
1212 static encode_image_func *const encode_image_funcs[NUM_ENCODERS_SUPPORTED] = {
1213     encode_image_BMP,
1214 };
1215
1216 /*****************************************************************************
1217  * GdipSaveImageToStream [GDIPLUS.@]
1218  */
1219 GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage *image, IStream* stream,
1220     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
1221 {
1222     GpStatus stat;
1223     HRESULT hr;
1224     short type;
1225     HBITMAP hbmp;
1226     HBITMAP old_hbmp;
1227     HDC hdc;
1228     int bm_is_selected;
1229     BITMAPINFO bmp_info;
1230     LPVOID bmp_bits;
1231     encode_image_func* encode_image;
1232     LPVOID output;
1233     unsigned int output_size;
1234     unsigned int dummy;
1235     int i;
1236
1237     old_hbmp = 0;
1238     output = NULL;
1239     output_size = 0;
1240
1241     TRACE("%p %p %p %p\n", image, stream, clsid, params);
1242
1243     if(!image || !stream)
1244         return InvalidParameter;
1245
1246     if (!image->picture)
1247         return GenericError;
1248
1249     hr = IPicture_get_Type(image->picture, &type);
1250     if (FAILED(hr) || type != PICTYPE_BITMAP)
1251         return GenericError;
1252
1253     /* select correct encoder */
1254     encode_image = NULL;
1255     for (i = 0; i < NUM_ENCODERS_SUPPORTED; i++) {
1256         if (IsEqualCLSID(clsid, &codecs[i].Clsid))
1257             encode_image = encode_image_funcs[i];
1258     }
1259     if (encode_image == NULL)
1260         return UnknownImageFormat;
1261
1262     /* extract underlying hbitmap representation from the IPicture */
1263     hr = IPicture_get_Handle(image->picture, (OLE_HANDLE*)&hbmp);
1264     if (FAILED(hr) || !hbmp)
1265         return GenericError;
1266     hr = IPicture_get_CurDC(image->picture, &hdc);
1267     if (FAILED(hr))
1268         return GenericError;
1269     bm_is_selected = (hdc != 0);
1270     if (!bm_is_selected) {
1271         hdc = CreateCompatibleDC(0);
1272         old_hbmp = SelectObject(hdc, hbmp);
1273     }
1274
1275     /* get bits from HBITMAP */
1276     bmp_info.bmiHeader.biSize = sizeof(bmp_info.bmiHeader);
1277     bmp_info.bmiHeader.biBitCount = 0;
1278     GetDIBits(hdc, hbmp, 0, 0, NULL, &bmp_info, DIB_RGB_COLORS);
1279
1280     bmp_bits = GdipAlloc(bmp_info.bmiHeader.biSizeImage);
1281
1282     if (bmp_bits)
1283         GetDIBits(hdc, hbmp, 0, abs(bmp_info.bmiHeader.biHeight), bmp_bits, &bmp_info, DIB_RGB_COLORS);
1284
1285     if (!bm_is_selected) {
1286         SelectObject(hdc, old_hbmp);
1287         DeleteDC(hdc);
1288     }
1289
1290     if (!bmp_bits)
1291         return OutOfMemory;
1292
1293     stat = encode_image(bmp_bits, &bmp_info, &output, &output_size);
1294     if (stat == Ok)
1295         IStream_Write(stream, output, output_size, &dummy);
1296
1297     GdipFree(output);
1298     GdipFree(bmp_bits);
1299
1300     return stat;
1301 }
1302
1303 /*****************************************************************************
1304  * GdipSetImagePalette [GDIPLUS.@]
1305  */
1306 GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image,
1307     GDIPCONST ColorPalette *palette)
1308 {
1309     static int calls;
1310
1311     if(!image || !palette)
1312         return InvalidParameter;
1313
1314     if(!(calls++))
1315         FIXME("not implemented\n");
1316
1317     return NotImplemented;
1318 }
1319
1320 /*************************************************************************
1321  * Encoders -
1322  *   Structures that represent which formats we support for encoding.
1323  */
1324
1325 /* ImageCodecInfo creation routines taken from libgdiplus */
1326 static const WCHAR bmp_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}; /* Built-in BMP */
1327 static const WCHAR bmp_extension[] = {'*','.','B', 'M', 'P',';', '*','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}; /* *.BMP;*.DIB;*.RLE */
1328 static const WCHAR bmp_mimetype[] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}; /* image/bmp */
1329 static const WCHAR bmp_format[] = {'B', 'M', 'P', 0}; /* BMP */
1330 static const BYTE bmp_sig_pattern[] = { 0x42, 0x4D };
1331 static const BYTE bmp_sig_mask[] = { 0xFF, 0xFF };
1332
1333 static const ImageCodecInfo codecs[NUM_ENCODERS_SUPPORTED] =
1334     {
1335         { /* BMP */
1336             /* Clsid */              { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
1337             /* FormatID */           { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
1338             /* CodecName */          bmp_codecname,
1339             /* DllName */            NULL,
1340             /* FormatDescription */  bmp_format,
1341             /* FilenameExtension */  bmp_extension,
1342             /* MimeType */           bmp_mimetype,
1343             /* Flags */              ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
1344             /* Version */            1,
1345             /* SigCount */           1,
1346             /* SigSize */            2,
1347             /* SigPattern */         bmp_sig_pattern,
1348             /* SigMask */            bmp_sig_mask,
1349         },
1350     };
1351
1352 /*****************************************************************************
1353  * GdipGetImageDecodersSize [GDIPLUS.@]
1354  */
1355 GpStatus WINGDIPAPI GdipGetImageDecodersSize(UINT *numDecoders, UINT *size)
1356 {
1357     FIXME("%p %p stub!\n", numDecoders, size);
1358
1359     if (!numDecoders || !size)
1360         return InvalidParameter;
1361
1362     *numDecoders = 0;
1363     *size = 0;
1364
1365     return Ok;
1366 }
1367
1368 /*****************************************************************************
1369  * GdipGetImageDecoders [GDIPLUS.@]
1370  */
1371 GpStatus WINGDIPAPI GdipGetImageDecoders(UINT numDecoders, UINT size, ImageCodecInfo *decoders)
1372 {
1373     FIXME("%u %u %p stub!\n", numDecoders, size, decoders);
1374
1375     if (!decoders)
1376         return GenericError;
1377
1378     return NotImplemented;
1379 }
1380
1381 /*****************************************************************************
1382  * GdipGetImageEncodersSize [GDIPLUS.@]
1383  */
1384 GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size)
1385 {
1386     TRACE("%p %p\n", numEncoders, size);
1387
1388     if (!numEncoders || !size)
1389         return InvalidParameter;
1390
1391     *numEncoders = NUM_ENCODERS_SUPPORTED;
1392     *size = sizeof (codecs);
1393
1394     return Ok;
1395 }
1396
1397 /*****************************************************************************
1398  * GdipGetImageEncoders [GDIPLUS.@]
1399  */
1400 GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
1401 {
1402     TRACE("%u %u %p\n", numEncoders, size, encoders);
1403
1404     if (!encoders ||
1405         (numEncoders != NUM_ENCODERS_SUPPORTED) ||
1406         (size != sizeof (codecs)))
1407         return GenericError;
1408
1409     memcpy(encoders, codecs, sizeof (codecs));
1410
1411     return Ok;
1412 }
1413
1414 /*****************************************************************************
1415  * GdipCreateBitmapFromHBITMAP [GDIPLUS.@]
1416  */
1417 GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap)
1418 {
1419     BITMAP bm;
1420     GpStatus retval;
1421     PixelFormat format;
1422
1423     TRACE("%p %p %p\n", hbm, hpal, bitmap);
1424
1425     if(!hbm || !bitmap)
1426         return InvalidParameter;
1427
1428     /* TODO: Support for device-dependent bitmaps */
1429     if(hpal){
1430         FIXME("no support for device-dependent bitmaps\n");
1431         return NotImplemented;
1432     }
1433
1434     if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
1435             return InvalidParameter;
1436
1437     /* TODO: Figure out the correct format for 16, 32, 64 bpp */
1438     switch(bm.bmBitsPixel) {
1439         case 1:
1440             format = PixelFormat1bppIndexed;
1441             break;
1442         case 4:
1443             format = PixelFormat4bppIndexed;
1444             break;
1445         case 8:
1446             format = PixelFormat8bppIndexed;
1447             break;
1448         case 24:
1449             format = PixelFormat24bppRGB;
1450             break;
1451         case 32:
1452             format = PixelFormat32bppRGB;
1453             break;
1454         case 48:
1455             format = PixelFormat48bppRGB;
1456             break;
1457         default:
1458             FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
1459             return InvalidParameter;
1460     }
1461
1462     retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, bm.bmWidthBytes,
1463         format, bm.bmBits, bitmap);
1464
1465     return retval;
1466 }
1467
1468 /*****************************************************************************
1469  * GdipSetEffectParameters [GDIPLUS.@]
1470  */
1471 GpStatus WINGDIPAPI GdipSetEffectParameters(CGpEffect *effect,
1472     const VOID *params, const UINT size)
1473 {
1474     static int calls;
1475
1476     if(!(calls++))
1477         FIXME("not implemented\n");
1478
1479     return NotImplemented;
1480 }
1481
1482 /*****************************************************************************
1483  * GdipGetImageFlags [GDIPLUS.@]
1484  */
1485 GpStatus WINGDIPAPI GdipGetImageFlags(GpImage *image, UINT *flags)
1486 {
1487     TRACE("%p %p\n", image, flags);
1488
1489     if(!image || !flags)
1490         return InvalidParameter;
1491
1492     *flags = image->flags;
1493
1494     return Ok;
1495 }
1496
1497 GpStatus WINGDIPAPI GdipTestControl(GpTestControlEnum control, void *param)
1498 {
1499     TRACE("(%d, %p)\n", control, param);
1500
1501     switch(control){
1502         case TestControlForceBilinear:
1503             if(param)
1504                 FIXME("TestControlForceBilinear not handled\n");
1505             break;
1506         case TestControlNoICM:
1507             if(param)
1508                 FIXME("TestControlNoICM not handled\n");
1509             break;
1510         case TestControlGetBuildNumber:
1511             *((DWORD*)param) = 3102;
1512             break;
1513     }
1514
1515     return Ok;
1516 }
1517
1518 GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR* fileName,
1519                             HDC hdc, EmfType type, GDIPCONST GpRectF *pFrameRect,
1520                             MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc,
1521                             GpMetafile **metafile)
1522 {
1523     FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
1524                                  frameUnit, debugstr_w(desc), metafile);
1525
1526     return NotImplemented;
1527 }
1528
1529 GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR* fileName, HDC hdc, EmfType type,
1530                             GDIPCONST GpRect *pFrameRect, MetafileFrameUnit frameUnit,
1531                             GDIPCONST WCHAR *desc, GpMetafile **metafile)
1532 {
1533     FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
1534                                  frameUnit, debugstr_w(desc), metafile);
1535
1536     return NotImplemented;
1537 }
1538
1539 GpStatus WINGDIPAPI GdipImageForceValidation(GpImage *image)
1540 {
1541     FIXME("%p\n", image);
1542
1543     return Ok;
1544 }