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