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