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