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 "gdiplus.h"
  32 #include "gdiplus_private.h"
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
  36
  37 #define PIXELFORMATBPP(x) ((x) ? ((x) >> 8) & 255 : 24)
  38
  39 static INT ipicture_pixel_height(IPicture *pic)
  40 {
  41     HDC hdcref;
  42     OLE_YSIZE_HIMETRIC y;
  43
  44     IPicture_get_Height(pic, &y);
  45
  46     hdcref = GetDC(0);
  47
  48     y = MulDiv(y, GetDeviceCaps(hdcref, LOGPIXELSY), INCH_HIMETRIC);
  49     ReleaseDC(0, hdcref);
  50
  51     return y;
  52 }
  53
  54 static INT ipicture_pixel_width(IPicture *pic)
  55 {
  56     HDC hdcref;
  57     OLE_XSIZE_HIMETRIC x;
  58
  59     IPicture_get_Width(pic, &x);
  60
  61     hdcref = GetDC(0);
  62
  63     x = MulDiv(x, GetDeviceCaps(hdcref, LOGPIXELSX), INCH_HIMETRIC);
  64
  65     ReleaseDC(0, hdcref);
  66
  67     return x;
  68 }
  69
  70 GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap* bitmap, INT x, INT y,
  71     ARGB *color)
  72 {
  73     static int calls;
  74     TRACE("%p %d %d %p\n", bitmap, x, y, color);
  75
  76     if(!bitmap || !color)
  77         return InvalidParameter;
  78
  79     if(!(calls++))
  80         FIXME("not implemented\n");
  81
  82     *color = 0xdeadbeef;
  83
  84     return NotImplemented;
  85 }
  86
  87 /* This function returns a pointer to an array of pixels that represents the
  88  * bitmap. The *entire* bitmap is locked according to the lock mode specified by
  89  * flags.  It is correct behavior that a user who calls this function with write
  90  * privileges can write to the whole bitmap (not just the area in rect).
  91  *
  92  * FIXME: only used portion of format is bits per pixel. */
  93 GpStatus WINGDIPAPI GdipBitmapLockBits(GpBitmap* bitmap, GDIPCONST GpRect* rect,
  94     UINT flags, PixelFormat format, BitmapData* lockeddata)
  95 {
  96     BOOL bm_is_selected;
  97     INT stride, bitspp = PIXELFORMATBPP(format);
  98     OLE_HANDLE hbm;
  99     HDC hdc;
 100     HBITMAP old = NULL;
 101     BITMAPINFO bmi;
 102     BYTE *buff = NULL;
 103     UINT abs_height;
 104
 105     TRACE("%p %p %d %d %p\n", bitmap, rect, flags, format, lockeddata);
 106
 107     if(!lockeddata || !bitmap || !rect)
 108         return InvalidParameter;
 109
 110     if(rect->X < 0 || rect->Y < 0 || (rect->X + rect->Width > bitmap->width) ||
 111        (rect->Y + rect->Height > bitmap->height) || !flags)
 112         return InvalidParameter;
 113
 114     if(flags & ImageLockModeUserInputBuf)
 115         return NotImplemented;
 116
 117     if(bitmap->lockmode)
 118         return WrongState;
 119
 120     IPicture_get_Handle(bitmap->image.picture, &hbm);
 121     IPicture_get_CurDC(bitmap->image.picture, &hdc);
 122     bm_is_selected = (hdc != 0);
 123
 124     bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 125     bmi.bmiHeader.biBitCount = 0;
 126
 127     if(!bm_is_selected){
 128         hdc = CreateCompatibleDC(0);
 129         old = SelectObject(hdc, (HBITMAP)hbm);
 130     }
 131
 132     /* fill out bmi */
 133     GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
 134
 135     abs_height = abs(bmi.bmiHeader.biHeight);
 136     stride = bmi.bmiHeader.biWidth * bitspp / 8;
 137     stride = (stride + 3) & ~3;
 138
 139     buff = GdipAlloc(stride * abs_height);
 140
 141     bmi.bmiHeader.biBitCount = bitspp;
 142
 143     if(buff)
 144         GetDIBits(hdc, (HBITMAP)hbm, 0, abs_height, buff, &bmi, DIB_RGB_COLORS);
 145
 146     if(!bm_is_selected){
 147         SelectObject(hdc, old);
 148         DeleteDC(hdc);
 149     }
 150
 151     if(!buff)
 152         return OutOfMemory;
 153
 154     lockeddata->Width = rect->Width;
 155     lockeddata->Height = rect->Height;
 156     lockeddata->PixelFormat = format;
 157     lockeddata->Reserved = flags;
 158
 159     if(bmi.bmiHeader.biHeight > 0){
 160         lockeddata->Stride = -stride;
 161         lockeddata->Scan0 = buff + (bitspp / 8) * rect->X +
 162                             stride * (abs_height - 1 - rect->Y);
 163     }
 164     else{
 165         lockeddata->Stride = stride;
 166         lockeddata->Scan0 = buff + (bitspp / 8) * rect->X + stride * rect->Y;
 167     }
 168
 169     bitmap->lockmode = flags;
 170     bitmap->numlocks++;
 171
 172     bitmap->bitmapbits = buff;
 173
 174     return Ok;
 175 }
 176
 177 GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap* bitmap,
 178     BitmapData* lockeddata)
 179 {
 180     OLE_HANDLE hbm;
 181     HDC hdc;
 182     HBITMAP old = NULL;
 183     BOOL bm_is_selected;
 184     BITMAPINFO bmi;
 185
 186     if(!bitmap || !lockeddata)
 187         return InvalidParameter;
 188
 189     if(!bitmap->lockmode)
 190         return WrongState;
 191
 192     if(lockeddata->Reserved & ImageLockModeUserInputBuf)
 193         return NotImplemented;
 194
 195     if(lockeddata->Reserved & ImageLockModeRead){
 196         if(!(--bitmap->numlocks))
 197             bitmap->lockmode = 0;
 198
 199         GdipFree(bitmap->bitmapbits);
 200         bitmap->bitmapbits = NULL;
 201         return Ok;
 202     }
 203
 204     IPicture_get_Handle(bitmap->image.picture, &hbm);
 205     IPicture_get_CurDC(bitmap->image.picture, &hdc);
 206     bm_is_selected = (hdc != 0);
 207
 208     bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 209     bmi.bmiHeader.biBitCount = 0;
 210
 211     if(!bm_is_selected){
 212         hdc = CreateCompatibleDC(0);
 213         old = SelectObject(hdc, (HBITMAP)hbm);
 214     }
 215
 216     GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
 217     bmi.bmiHeader.biBitCount = PIXELFORMATBPP(lockeddata->PixelFormat);
 218     SetDIBits(hdc, (HBITMAP)hbm, 0, abs(bmi.bmiHeader.biHeight),
 219               bitmap->bitmapbits, &bmi, DIB_RGB_COLORS);
 220
 221     if(!bm_is_selected){
 222         SelectObject(hdc, old);
 223         DeleteDC(hdc);
 224     }
 225
 226     GdipFree(bitmap->bitmapbits);
 227     bitmap->bitmapbits = NULL;
 228     bitmap->lockmode = 0;
 229
 230     return Ok;
 231 }
 232
 233 GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename,
 234     GpBitmap **bitmap)
 235 {
 236     GpStatus stat;
 237     IStream *stream;
 238
 239     if(!filename || !bitmap)
 240         return InvalidParameter;
 241
 242     stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
 243
 244     if(stat != Ok)
 245         return stat;
 246
 247     stat = GdipCreateBitmapFromStream(stream, bitmap);
 248
 249     IStream_Release(stream);
 250
 251     return stat;
 252 }
 253
 254 /* FIXME: no icm */
 255 GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename,
 256     GpBitmap **bitmap)
 257 {
 258     return GdipCreateBitmapFromFile(filename, bitmap);
 259 }
 260
 261 GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap,
 262     HBITMAP* hbmReturn, ARGB background)
 263 {
 264     FIXME("stub\n");
 265
 266     hbmReturn = NULL;
 267
 268     return NotImplemented;
 269 }
 270
 271 GpStatus WINGDIPAPI GdipConvertToEmfPlus(const GpGraphics* ref,
 272     GpMetafile* metafile, BOOL* succ, EmfType emfType,
 273     const WCHAR* description, GpMetafile** out_metafile)
 274 {
 275     static int calls;
 276
 277     if(!ref || !metafile || !out_metafile)
 278         return InvalidParameter;
 279
 280     *succ = FALSE;
 281     *out_metafile = NULL;
 282
 283     if(!(calls++))
 284         FIXME("not implemented\n");
 285
 286     return NotImplemented;
 287 }
 288
 289 /* FIXME: this should create a bitmap in the given size with the attributes
 290  * (resolution etc.) of the graphics object */
 291 GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics(INT width, INT height,
 292     GpGraphics* target, GpBitmap** bitmap)
 293 {
 294     static int calls;
 295     GpStatus ret;
 296
 297     if(!target || !bitmap)
 298         return InvalidParameter;
 299
 300     if(!(calls++))
 301         FIXME("hacked stub\n");
 302
 303     ret = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat24bppRGB,
 304                                     NULL, bitmap);
 305
 306     return ret;
 307 }
 308
 309 GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride,
 310     PixelFormat format, BYTE* scan0, GpBitmap** bitmap)
 311 {
 312     BITMAPFILEHEADER *bmfh;
 313     BITMAPINFOHEADER *bmih;
 314     BYTE *buff;
 315     INT datalen, size;
 316     IStream *stream;
 317
 318     TRACE("%d %d %d %d %p %p\n", width, height, stride, format, scan0, bitmap);
 319
 320     if(!bitmap || width <= 0 || height <= 0 || (scan0 && (stride % 4))){
 321         *bitmap = NULL;
 322         return InvalidParameter;
 323     }
 324
 325     if(scan0 && !stride)
 326         return InvalidParameter;
 327
 328     /* FIXME: windows allows negative stride (reads backwards from scan0) */
 329     if(stride < 0){
 330         FIXME("negative stride\n");
 331         return InvalidParameter;
 332     }
 333
 334     *bitmap = GdipAlloc(sizeof(GpBitmap));
 335     if(!*bitmap)    return OutOfMemory;
 336
 337     if(stride == 0){
 338         stride = width * (PIXELFORMATBPP(format) / 8);
 339         stride = (stride + 3) & ~3;
 340     }
 341
 342     datalen = abs(stride * height);
 343     size = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + datalen;
 344     buff = GdipAlloc(size);
 345     if(!buff){
 346         GdipFree(*bitmap);
 347         return OutOfMemory;
 348     }
 349
 350     bmfh = (BITMAPFILEHEADER*) buff;
 351     bmih = (BITMAPINFOHEADER*) (bmfh + 1);
 352
 353     bmfh->bfType    = (((WORD)'M') << 8) + (WORD)'B';
 354     bmfh->bfSize    = size;
 355     bmfh->bfOffBits = size - datalen;
 356
 357     bmih->biSize            = sizeof(BITMAPINFOHEADER);
 358     bmih->biWidth           = width;
 359     bmih->biHeight          = -height;
 360     /* FIXME: use the rest of the data from format */
 361     bmih->biBitCount        = PIXELFORMATBPP(format);
 362     bmih->biCompression     = BI_RGB;
 363     bmih->biSizeImage       = datalen;
 364
 365     if(scan0)
 366         memcpy(bmih + 1, scan0, datalen);
 367     else
 368         memset(bmih + 1, 0, datalen);
 369
 370     if(CreateStreamOnHGlobal(buff, TRUE, &stream) != S_OK){
 371         ERR("could not make stream\n");
 372         GdipFree(*bitmap);
 373         GdipFree(buff);
 374         return GenericError;
 375     }
 376
 377     if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
 378         (LPVOID*) &((*bitmap)->image.picture)) != S_OK){
 379         TRACE("Could not load picture\n");
 380         IStream_Release(stream);
 381         GdipFree(*bitmap);
 382         GdipFree(buff);
 383         return GenericError;
 384     }
 385
 386     (*bitmap)->image.type = ImageTypeBitmap;
 387     (*bitmap)->image.flags = ImageFlagsNone;
 388     (*bitmap)->width = width;
 389     (*bitmap)->height = height;
 390     (*bitmap)->format = format;
 391
 392     return Ok;
 393 }
 394
 395 GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream* stream,
 396     GpBitmap **bitmap)
 397 {
 398     GpStatus stat;
 399
 400     stat = GdipLoadImageFromStream(stream, (GpImage**) bitmap);
 401
 402     if(stat != Ok)
 403         return stat;
 404
 405     if((*bitmap)->image.type != ImageTypeBitmap){
 406         IPicture_Release((*bitmap)->image.picture);
 407         GdipFree(bitmap);
 408         return GenericError; /* FIXME: what error to return? */
 409     }
 410
 411     return Ok;
 412 }
 413
 414 /* FIXME: no icm */
 415 GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream* stream,
 416     GpBitmap **bitmap)
 417 {
 418     return GdipCreateBitmapFromStream(stream, bitmap);
 419 }
 420
 421 GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
 422 {
 423     HDC hdc;
 424
 425     if(!image)
 426         return InvalidParameter;
 427
 428     IPicture_get_CurDC(image->picture, &hdc);
 429     DeleteDC(hdc);
 430     IPicture_Release(image->picture);
 431     if (image->type == ImageTypeBitmap)
 432         GdipFree(((GpBitmap*)image)->bitmapbits);
 433     GdipFree(image);
 434
 435     return Ok;
 436 }
 437
 438 GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage *image, ImageItemData* item)
 439 {
 440     if(!image || !item)
 441         return InvalidParameter;
 442
 443     return NotImplemented;
 444 }
 445
 446 GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect,
 447     GpUnit *srcUnit)
 448 {
 449     if(!image || !srcRect || !srcUnit)
 450         return InvalidParameter;
 451     if(image->type == ImageTypeMetafile){
 452         *srcRect = ((GpMetafile*)image)->bounds;
 453         *srcUnit = ((GpMetafile*)image)->unit;
 454     }
 455     else if(image->type == ImageTypeBitmap){
 456         srcRect->X = srcRect->Y = 0.0;
 457         srcRect->Width = (REAL) ((GpBitmap*)image)->width;
 458         srcRect->Height = (REAL) ((GpBitmap*)image)->height;
 459         *srcUnit = UnitPixel;
 460     }
 461     else{
 462         srcRect->X = srcRect->Y = 0.0;
 463         srcRect->Width = ipicture_pixel_width(image->picture);
 464         srcRect->Height = ipicture_pixel_height(image->picture);
 465         *srcUnit = UnitPixel;
 466     }
 467
 468     TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
 469           srcRect->Width, srcRect->Height, *srcUnit);
 470
 471     return Ok;
 472 }
 473
 474 GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width,
 475     REAL *height)
 476 {
 477     if(!image || !height || !width)
 478         return InvalidParameter;
 479
 480     if(image->type == ImageTypeMetafile){
 481         HDC hdc = GetDC(0);
 482
 483         *height = convert_unit(hdc, ((GpMetafile*)image)->unit) *
 484                         ((GpMetafile*)image)->bounds.Height;
 485
 486         *width = convert_unit(hdc, ((GpMetafile*)image)->unit) *
 487                         ((GpMetafile*)image)->bounds.Width;
 488
 489         ReleaseDC(0, hdc);
 490     }
 491
 492     else if(image->type == ImageTypeBitmap){
 493         *height = ((GpBitmap*)image)->height;
 494         *width = ((GpBitmap*)image)->width;
 495     }
 496     else{
 497         *height = ipicture_pixel_height(image->picture);
 498         *width = ipicture_pixel_width(image->picture);
 499     }
 500
 501     TRACE("returning (%f, %f)\n", *height, *width);
 502     return Ok;
 503 }
 504
 505 GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image,
 506     GpGraphics **graphics)
 507 {
 508     HDC hdc;
 509
 510     if(!image || !graphics)
 511         return InvalidParameter;
 512
 513     if(image->type != ImageTypeBitmap){
 514         FIXME("not implemented for image type %d\n", image->type);
 515         return NotImplemented;
 516     }
 517
 518     IPicture_get_CurDC(image->picture, &hdc);
 519
 520     if(!hdc){
 521         hdc = CreateCompatibleDC(0);
 522         IPicture_SelectPicture(image->picture, hdc, NULL, NULL);
 523     }
 524
 525     return GdipCreateFromHDC(hdc, graphics);
 526 }
 527
 528 GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
 529 {
 530     if(!image || !height)
 531         return InvalidParameter;
 532
 533     if(image->type == ImageTypeMetafile){
 534         HDC hdc = GetDC(0);
 535
 536         *height = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
 537                         ((GpMetafile*)image)->bounds.Height);
 538
 539         ReleaseDC(0, hdc);
 540     }
 541     else if(image->type == ImageTypeBitmap)
 542         *height = ((GpBitmap*)image)->height;
 543     else
 544         *height = ipicture_pixel_height(image->picture);
 545
 546     TRACE("returning %d\n", *height);
 547
 548     return Ok;
 549 }
 550
 551 GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *res)
 552 {
 553     static int calls;
 554
 555     if(!image || !res)
 556         return InvalidParameter;
 557
 558     if(!(calls++))
 559         FIXME("not implemented\n");
 560
 561     return NotImplemented;
 562 }
 563
 564 /* FIXME: test this function for non-bitmap types */
 565 GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format)
 566 {
 567     if(!image || !format)
 568         return InvalidParameter;
 569
 570     if(image->type != ImageTypeBitmap)
 571         *format = PixelFormat24bppRGB;
 572     else
 573         *format = ((GpBitmap*) image)->format;
 574
 575     return Ok;
 576 }
 577
 578 GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
 579 {
 580     static int calls;
 581
 582     if(!image || !format)
 583         return InvalidParameter;
 584
 585     if(!(calls++))
 586         FIXME("not implemented\n");
 587
 588     return NotImplemented;
 589 }
 590
 591 GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
 592 {
 593     if(!image || !type)
 594         return InvalidParameter;
 595
 596     *type = image->type;
 597
 598     return Ok;
 599 }
 600
 601 GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *res)
 602 {
 603     static int calls;
 604
 605     if(!image || !res)
 606         return InvalidParameter;
 607
 608     if(!(calls++))
 609         FIXME("not implemented\n");
 610
 611     return NotImplemented;
 612 }
 613
 614 GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
 615 {
 616     if(!image || !width)
 617         return InvalidParameter;
 618
 619     if(image->type == ImageTypeMetafile){
 620         HDC hdc = GetDC(0);
 621
 622         *width = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
 623                         ((GpMetafile*)image)->bounds.Width);
 624
 625         ReleaseDC(0, hdc);
 626     }
 627     else if(image->type == ImageTypeBitmap)
 628         *width = ((GpBitmap*)image)->width;
 629     else
 630         *width = ipicture_pixel_width(image->picture);
 631
 632     TRACE("returning %d\n", *width);
 633
 634     return Ok;
 635 }
 636
 637 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile * metafile,
 638     MetafileHeader * header)
 639 {
 640     static int calls;
 641
 642     if(!metafile || !header)
 643         return InvalidParameter;
 644
 645     if(!(calls++))
 646         FIXME("not implemented\n");
 647
 648     return Ok;
 649 }
 650
 651 GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID pid,
 652     UINT* size)
 653 {
 654     static int calls;
 655
 656     TRACE("%p %x %p\n", image, pid, size);
 657
 658     if(!size || !image)
 659         return InvalidParameter;
 660
 661     if(!(calls++))
 662         FIXME("not implemented\n");
 663
 664     return NotImplemented;
 665 }
 666
 667 GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
 668     GDIPCONST GUID* dimensionID, UINT* count)
 669 {
 670     static int calls;
 671
 672     if(!image || !dimensionID || !count)
 673         return InvalidParameter;
 674
 675     if(!(calls++))
 676         FIXME("not implemented\n");
 677
 678     return NotImplemented;
 679 }
 680
 681 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image,
 682     GUID* dimensionIDs, UINT count)
 683 {
 684     static int calls;
 685
 686     if(!image || !dimensionIDs)
 687         return InvalidParameter;
 688
 689     if(!(calls++))
 690         FIXME("not implemented\n");
 691
 692     return Ok;
 693 }
 694
 695 GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage *image,
 696     GDIPCONST GUID* dimensionID, UINT frameidx)
 697 {
 698     static int calls;
 699
 700     if(!image || !dimensionID)
 701         return InvalidParameter;
 702
 703     if(!(calls++))
 704         FIXME("not implemented\n");
 705
 706     return Ok;
 707 }
 708
 709 GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
 710                                           GpImage **image)
 711 {
 712     GpStatus stat;
 713     IStream *stream;
 714
 715     if (!filename || !image)
 716         return InvalidParameter;
 717
 718     stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
 719
 720     if (stat != Ok)
 721         return stat;
 722
 723     stat = GdipLoadImageFromStream(stream, image);
 724
 725     IStream_Release(stream);
 726
 727     return stat;
 728 }
 729
 730 /* FIXME: no icm handling */
 731 GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,GpImage **image)
 732 {
 733     return GdipLoadImageFromFile(filename, image);
 734 }
 735
 736 GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream* stream, GpImage **image)
 737 {
 738     IPicture *pic;
 739     short type;
 740
 741     if(!stream || !image)
 742         return InvalidParameter;
 743
 744     if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
 745         (LPVOID*) &pic) != S_OK){
 746         TRACE("Could not load picture\n");
 747         return GenericError;
 748     }
 749
 750     IPicture_get_Type(pic, &type);
 751
 752     if(type == PICTYPE_BITMAP){
 753         BITMAPINFO bmi;
 754         BITMAPCOREHEADER* bmch;
 755         OLE_HANDLE hbm;
 756         HDC hdc;
 757
 758         *image = GdipAlloc(sizeof(GpBitmap));
 759         if(!*image) return OutOfMemory;
 760         (*image)->type = ImageTypeBitmap;
 761
 762         (*((GpBitmap**) image))->width = ipicture_pixel_width(pic);
 763         (*((GpBitmap**) image))->height = ipicture_pixel_height(pic);
 764
 765         /* get the pixel format */
 766         IPicture_get_Handle(pic, &hbm);
 767         IPicture_get_CurDC(pic, &hdc);
 768
 769         ZeroMemory(&bmi, sizeof(bmi));
 770         bmch = (BITMAPCOREHEADER*) (&bmi.bmiHeader);
 771         bmch->bcSize = sizeof(BITMAPCOREHEADER);
 772
 773         if(!hdc){
 774             HBITMAP old;
 775             hdc = CreateCompatibleDC(0);
 776             old = SelectObject(hdc, (HBITMAP)hbm);
 777             GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
 778             SelectObject(hdc, old);
 779             DeleteDC(hdc);
 780         }
 781         else
 782             GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
 783
 784         (*((GpBitmap**) image))->format = (bmch->bcBitCount << 8) | PixelFormatGDI;
 785     }
 786     else if(type == PICTYPE_METAFILE || type == PICTYPE_ENHMETAFILE){
 787         /* FIXME: missing initialization code */
 788         *image = GdipAlloc(sizeof(GpMetafile));
 789         if(!*image) return OutOfMemory;
 790         (*image)->type = ImageTypeMetafile;
 791     }
 792     else{
 793         *image = GdipAlloc(sizeof(GpImage));
 794         if(!*image) return OutOfMemory;
 795         (*image)->type = ImageTypeUnknown;
 796     }
 797
 798     (*image)->picture = pic;
 799     (*image)->flags   = ImageFlagsNone;
 800
 801     return Ok;
 802 }
 803
 804 /* FIXME: no ICM */
 805 GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image)
 806 {
 807     return GdipLoadImageFromStream(stream, image);
 808 }
 809
 810 GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage *image, PROPID propId)
 811 {
 812     static int calls;
 813
 814     if(!image)
 815         return InvalidParameter;
 816
 817     if(!(calls++))
 818         FIXME("not implemented\n");
 819
 820     return NotImplemented;
 821 }
 822
 823 GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
 824                                         GDIPCONST CLSID *clsidEncoder,
 825                                         GDIPCONST EncoderParameters *encoderParams)
 826 {
 827     GpStatus stat;
 828     IStream *stream;
 829
 830     if (!image || !filename|| !clsidEncoder)
 831         return InvalidParameter;
 832
 833     if (!(image->picture))
 834         return InvalidParameter;
 835
 836     stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
 837     if (stat != Ok)
 838         return GenericError;
 839
 840     stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
 841
 842     IStream_Release(stream);
 843     return stat;
 844 }
 845
 846 /*************************************************************************
 847  * Encoding functions -
 848  *   These functions encode an image in different image file formats.
 849  */
 850 #define BITMAP_FORMAT_BMP   0x4d42 /* "BM" */
 851 #define BITMAP_FORMAT_JPEG  0xd8ff
 852 #define BITMAP_FORMAT_GIF   0x4947
 853 #define BITMAP_FORMAT_PNG   0x5089
 854 #define BITMAP_FORMAT_APM   0xcdd7
 855
 856 static GpStatus encode_image_BMP(LPVOID bitmap_bits, LPBITMAPINFO bitmap_info,
 857                                  void **output, unsigned int *output_size)
 858 {
 859     int num_palette_entries;
 860     BITMAPFILEHEADER *bmp_file_hdr;
 861     BITMAPINFO *bmp_info_hdr;
 862
 863     if (bitmap_info->bmiHeader.biClrUsed) {
 864         num_palette_entries = bitmap_info->bmiHeader.biClrUsed;
 865         if (num_palette_entries > 256) num_palette_entries = 256;
 866     } else {
 867         if (bitmap_info->bmiHeader.biBitCount <= 8)
 868             num_palette_entries = 1 << bitmap_info->bmiHeader.biBitCount;
 869         else
 870             num_palette_entries = 0;
 871     }
 872
 873     *output_size =
 874         sizeof(BITMAPFILEHEADER) +
 875         sizeof(BITMAPINFOHEADER) +
 876         num_palette_entries * sizeof(RGBQUAD) +
 877         bitmap_info->bmiHeader.biSizeImage;
 878
 879     *output = GdipAlloc(*output_size);
 880
 881     bmp_file_hdr = (BITMAPFILEHEADER*) *output;
 882     bmp_file_hdr->bfType = BITMAP_FORMAT_BMP;
 883     bmp_file_hdr->bfSize = *output_size;
 884     bmp_file_hdr->bfOffBits =
 885         sizeof(BITMAPFILEHEADER) +
 886         sizeof(BITMAPINFOHEADER) +
 887         num_palette_entries * sizeof (RGBQUAD);
 888
 889     bmp_info_hdr = (BITMAPINFO*) ((unsigned char*)(*output) + sizeof(BITMAPFILEHEADER));
 890     memcpy(bmp_info_hdr, bitmap_info, sizeof(BITMAPINFOHEADER) + num_palette_entries * sizeof(RGBQUAD));
 891     memcpy((unsigned char *)(*output) +
 892            sizeof(BITMAPFILEHEADER) +
 893            sizeof(BITMAPINFOHEADER) +
 894            num_palette_entries * sizeof(RGBQUAD),
 895            bitmap_bits, bitmap_info->bmiHeader.biSizeImage);
 896
 897     return Ok;
 898 }
 899
 900 typedef GpStatus encode_image_func(LPVOID bitmap_bits, LPBITMAPINFO bitmap_info,
 901                                    void **output, unsigned int *output_size);
 902
 903 typedef enum {
 904     BMP,
 905     NUM_ENCODERS_SUPPORTED
 906 } ImageFormat;
 907
 908 static const ImageCodecInfo codecs[NUM_ENCODERS_SUPPORTED];
 909 static encode_image_func *const encode_image_funcs[NUM_ENCODERS_SUPPORTED] = {
 910     encode_image_BMP,
 911 };
 912
 913 GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage *image, IStream* stream,
 914     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
 915 {
 916     GpStatus stat;
 917     HRESULT hr;
 918     short type;
 919     HBITMAP hbmp;
 920     HBITMAP old_hbmp;
 921     HDC hdc;
 922     int bm_is_selected;
 923     BITMAPINFO bmp_info;
 924     LPVOID bmp_bits;
 925     encode_image_func* encode_image;
 926     LPVOID output;
 927     unsigned int output_size;
 928     unsigned int dummy;
 929     int i;
 930
 931     old_hbmp = 0;
 932     output = NULL;
 933     output_size = 0;
 934
 935     if(!image || !stream)
 936         return InvalidParameter;
 937
 938     if (!image->picture)
 939         return GenericError;
 940
 941     hr = IPicture_get_Type(image->picture, &type);
 942     if (FAILED(hr) || type != PICTYPE_BITMAP)
 943         return GenericError;
 944
 945     /* select correct encoder */
 946     encode_image = NULL;
 947     for (i = 0; i < NUM_ENCODERS_SUPPORTED; i++) {
 948         if (IsEqualCLSID(clsid, &codecs[i].Clsid))
 949             encode_image = encode_image_funcs[i];
 950     }
 951     if (encode_image == NULL)
 952         return UnknownImageFormat;
 953
 954     /* extract underlying hbitmap representation from the IPicture */
 955     hr = IPicture_get_Handle(image->picture, (OLE_HANDLE*)&hbmp);
 956     if (FAILED(hr) || !hbmp)
 957         return GenericError;
 958     hr = IPicture_get_CurDC(image->picture, &hdc);
 959     if (FAILED(hr))
 960         return GenericError;
 961     bm_is_selected = (hdc != 0);
 962     if (!bm_is_selected) {
 963         hdc = CreateCompatibleDC(0);
 964         old_hbmp = SelectObject(hdc, hbmp);
 965     }
 966
 967     /* get bits from HBITMAP */
 968     bmp_info.bmiHeader.biSize = sizeof(bmp_info.bmiHeader);
 969     bmp_info.bmiHeader.biBitCount = 0;
 970     GetDIBits(hdc, hbmp, 0, 0, NULL, &bmp_info, DIB_RGB_COLORS);
 971
 972     bmp_bits = GdipAlloc(bmp_info.bmiHeader.biSizeImage);
 973
 974     if (bmp_bits)
 975         GetDIBits(hdc, hbmp, 0, abs(bmp_info.bmiHeader.biHeight), bmp_bits, &bmp_info, DIB_RGB_COLORS);
 976
 977     if (!bm_is_selected) {
 978         SelectObject(hdc, old_hbmp);
 979         DeleteDC(hdc);
 980     }
 981
 982     if (!bmp_bits)
 983         return OutOfMemory;
 984
 985     stat = encode_image(bmp_bits, &bmp_info, &output, &output_size);
 986     if (stat == Ok)
 987         IStream_Write(stream, output, output_size, &dummy);
 988
 989     GdipFree(output);
 990     GdipFree(bmp_bits);
 991
 992     return stat;
 993 }
 994
 995 GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image,
 996     GDIPCONST ColorPalette *palette)
 997 {
 998     static int calls;
 999
1000     if(!image || !palette)
1001         return InvalidParameter;
1002
1003     if(!(calls++))
1004         FIXME("not implemented\n");
1005
1006     return NotImplemented;
1007 }
1008
1009 /*************************************************************************
1010  * Encoders -
1011  *   Structures that represent which formats we support for encoding.
1012  */
1013
1014 /* ImageCodecInfo creation routines taken from libgdiplus */
1015 static const WCHAR bmp_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}; /* Built-in BMP */
1016 static const WCHAR bmp_extension[] = {'*','.','B', 'M', 'P',';', '*','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}; /* *.BMP;*.DIB;*.RLE */
1017 static const WCHAR bmp_mimetype[] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}; /* image/bmp */
1018 static const WCHAR bmp_format[] = {'B', 'M', 'P', 0}; /* BMP */
1019 static const BYTE bmp_sig_pattern[] = { 0x42, 0x4D };
1020 static const BYTE bmp_sig_mask[] = { 0xFF, 0xFF };
1021
1022 static const ImageCodecInfo codecs[NUM_ENCODERS_SUPPORTED] =
1023     {
1024         { /* BMP */
1025             /* Clsid */              { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
1026             /* FormatID */           { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
1027             /* CodecName */          bmp_codecname,
1028             /* DllName */            NULL,
1029             /* FormatDescription */  bmp_format,
1030             /* FilenameExtension */  bmp_extension,
1031             /* MimeType */           bmp_mimetype,
1032             /* Flags */              ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
1033             /* Version */            1,
1034             /* SigCount */           1,
1035             /* SigSize */            2,
1036             /* SigPattern */         bmp_sig_pattern,
1037             /* SigMask */            bmp_sig_mask,
1038         },
1039     };
1040
1041 GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size)
1042 {
1043     if (!numEncoders || !size)
1044         return InvalidParameter;
1045
1046     *numEncoders = NUM_ENCODERS_SUPPORTED;
1047     *size = sizeof (codecs);
1048
1049     return Ok;
1050 }
1051
1052 GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
1053 {
1054     if (!encoders ||
1055         (numEncoders != NUM_ENCODERS_SUPPORTED) ||
1056         (size != sizeof (codecs)))
1057         return GenericError;
1058
1059     memcpy(encoders, codecs, sizeof (codecs));
1060
1061     return Ok;
1062 }
1063 GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap)
1064 {
1065     BITMAP bm;
1066     GpStatus retval;
1067     PixelFormat format;
1068
1069     if(!hbm || !bitmap)
1070         return InvalidParameter;
1071
1072     /* TODO: Support for device-dependent bitmaps */
1073     if(hpal){
1074         FIXME("no support for device-dependent bitmaps\n");
1075         return NotImplemented;
1076     }
1077
1078     if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
1079             return InvalidParameter;
1080
1081     /* TODO: Figure out the correct format for 16, 32, 64 bpp */
1082     switch(bm.bmBitsPixel) {
1083         case 1:
1084             format = PixelFormat1bppIndexed;
1085             break;
1086         case 4:
1087             format = PixelFormat4bppIndexed;
1088             break;
1089         case 8:
1090             format = PixelFormat8bppIndexed;
1091             break;
1092         case 24:
1093             format = PixelFormat24bppRGB;
1094             break;
1095         case 48:
1096             format = PixelFormat48bppRGB;
1097             break;
1098         default:
1099             FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
1100             return InvalidParameter;
1101     }
1102
1103     retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, bm.bmWidthBytes,
1104         format, bm.bmBits, bitmap);
1105
1106     return retval;
1107 }
1108
1109 GpStatus WINGDIPAPI GdipSetEffectParameters(CGpEffect *effect,
1110     const VOID *params, const UINT size)
1111 {
1112     static int calls;
1113
1114     if(!(calls++))
1115         FIXME("not implemented\n");
1116
1117     return NotImplemented;
1118 }
1119
1120 GpStatus WINGDIPAPI GdipGetImageFlags(GpImage *image, UINT *flags)
1121 {
1122     if(!image || !flags)
1123         return InvalidParameter;
1124
1125     *flags = image->flags;
1126
1127     return Ok;
1128 }