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;
 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;
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     assert(src->image.stream == NULL);
1975     assert(dst->image.stream == NULL);
1976
1977     GdipFree(dst->bitmapbits);
1978     DeleteDC(dst->hdc);
1979     DeleteObject(dst->hbitmap);
1980
1981     if (clobber_palette)
1982     {
1983         GdipFree(dst->image.palette_entries);
1984         dst->image.palette_flags = src->image.palette_flags;
1985         dst->image.palette_count = src->image.palette_count;
1986         dst->image.palette_entries = src->image.palette_entries;
1987     }
1988     else
1989         GdipFree(src->image.palette_entries);
1990
1991     dst->image.xres = src->image.xres;
1992     dst->image.yres = src->image.yres;
1993     dst->width = src->width;
1994     dst->height = src->height;
1995     dst->format = src->format;
1996     dst->hbitmap = src->hbitmap;
1997     dst->hdc = src->hdc;
1998     dst->bits = src->bits;
1999     dst->stride = src->stride;
2000     dst->own_bits = src->own_bits;
2001     if (dst->metadata_reader)
2002         IWICMetadataReader_Release(dst->metadata_reader);
2003     dst->metadata_reader = src->metadata_reader;
2004
2005     src->image.type = ~0;
2006     GdipFree(src);
2007 }
2008
2009 static GpStatus free_image_data(GpImage *image)
2010 {
2011     if(!image)
2012         return InvalidParameter;
2013
2014     if (image->type == ImageTypeBitmap)
2015     {
2016         GdipFree(((GpBitmap*)image)->bitmapbits);
2017         GdipFree(((GpBitmap*)image)->own_bits);
2018         DeleteDC(((GpBitmap*)image)->hdc);
2019         DeleteObject(((GpBitmap*)image)->hbitmap);
2020         if (((GpBitmap*)image)->metadata_reader)
2021             IWICMetadataReader_Release(((GpBitmap*)image)->metadata_reader);
2022     }
2023     else if (image->type == ImageTypeMetafile)
2024     {
2025         GpMetafile *metafile = (GpMetafile*)image;
2026         GdipFree(metafile->comment_data);
2027         DeleteEnhMetaFile(CloseEnhMetaFile(metafile->record_dc));
2028         DeleteEnhMetaFile(metafile->hemf);
2029         if (metafile->record_graphics)
2030         {
2031             WARN("metafile closed while recording\n");
2032             /* not sure what to do here; for now just prevent the graphics from functioning or using this object */
2033             metafile->record_graphics->image = NULL;
2034             metafile->record_graphics->busy = TRUE;
2035         }
2036     }
2037     else
2038     {
2039         WARN("invalid image: %p\n", image);
2040         return ObjectBusy;
2041     }
2042     if (image->picture)
2043         IPicture_Release(image->picture);
2044     if (image->stream)
2045         IStream_Release(image->stream);
2046     GdipFree(image->palette_entries);
2047
2048     return Ok;
2049 }
2050
2051 GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
2052 {
2053     GpStatus status;
2054
2055     TRACE("%p\n", image);
2056
2057     status = free_image_data(image);
2058     if (status != Ok) return status;
2059     image->type = ~0;
2060     GdipFree(image);
2061
2062     return Ok;
2063 }
2064
2065 GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage *image, ImageItemData* item)
2066 {
2067     static int calls;
2068
2069     TRACE("(%p,%p)\n", image, item);
2070
2071     if(!image || !item)
2072         return InvalidParameter;
2073
2074     if (!(calls++))
2075         FIXME("not implemented\n");
2076
2077     return NotImplemented;
2078 }
2079
2080 GpStatus WINGDIPAPI GdipGetImageItemData(GpImage *image, ImageItemData *item)
2081 {
2082     static int calls;
2083
2084     TRACE("(%p,%p)\n", image, item);
2085
2086     if (!(calls++))
2087         FIXME("not implemented\n");
2088
2089     return NotImplemented;
2090 }
2091
2092 GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect,
2093     GpUnit *srcUnit)
2094 {
2095     TRACE("%p %p %p\n", image, srcRect, srcUnit);
2096
2097     if(!image || !srcRect || !srcUnit)
2098         return InvalidParameter;
2099     if(image->type == ImageTypeMetafile){
2100         *srcRect = ((GpMetafile*)image)->bounds;
2101         *srcUnit = ((GpMetafile*)image)->unit;
2102     }
2103     else if(image->type == ImageTypeBitmap){
2104         srcRect->X = srcRect->Y = 0.0;
2105         srcRect->Width = (REAL) ((GpBitmap*)image)->width;
2106         srcRect->Height = (REAL) ((GpBitmap*)image)->height;
2107         *srcUnit = UnitPixel;
2108     }
2109     else{
2110         srcRect->X = srcRect->Y = 0.0;
2111         srcRect->Width = ipicture_pixel_width(image->picture);
2112         srcRect->Height = ipicture_pixel_height(image->picture);
2113         *srcUnit = UnitPixel;
2114     }
2115
2116     TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
2117           srcRect->Width, srcRect->Height, *srcUnit);
2118
2119     return Ok;
2120 }
2121
2122 GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width,
2123     REAL *height)
2124 {
2125     TRACE("%p %p %p\n", image, width, height);
2126
2127     if(!image || !height || !width)
2128         return InvalidParameter;
2129
2130     if(image->type == ImageTypeMetafile){
2131         HDC hdc = GetDC(0);
2132         REAL res = (REAL)GetDeviceCaps(hdc, LOGPIXELSX);
2133
2134         ReleaseDC(0, hdc);
2135
2136         *height = convert_unit(res, ((GpMetafile*)image)->unit) *
2137                         ((GpMetafile*)image)->bounds.Height;
2138
2139         *width = convert_unit(res, ((GpMetafile*)image)->unit) *
2140                         ((GpMetafile*)image)->bounds.Width;
2141     }
2142
2143     else if(image->type == ImageTypeBitmap){
2144         *height = ((GpBitmap*)image)->height;
2145         *width = ((GpBitmap*)image)->width;
2146     }
2147     else{
2148         *height = ipicture_pixel_height(image->picture);
2149         *width = ipicture_pixel_width(image->picture);
2150     }
2151
2152     TRACE("returning (%f, %f)\n", *height, *width);
2153     return Ok;
2154 }
2155
2156 GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image,
2157     GpGraphics **graphics)
2158 {
2159     HDC hdc;
2160     GpStatus stat;
2161
2162     TRACE("%p %p\n", image, graphics);
2163
2164     if(!image || !graphics)
2165         return InvalidParameter;
2166
2167     if (image->type == ImageTypeBitmap && ((GpBitmap*)image)->hbitmap)
2168     {
2169         hdc = ((GpBitmap*)image)->hdc;
2170
2171         if(!hdc){
2172             hdc = CreateCompatibleDC(0);
2173             SelectObject(hdc, ((GpBitmap*)image)->hbitmap);
2174             ((GpBitmap*)image)->hdc = hdc;
2175         }
2176
2177         stat = GdipCreateFromHDC(hdc, graphics);
2178
2179         if (stat == Ok)
2180             (*graphics)->image = image;
2181     }
2182     else if (image->type == ImageTypeMetafile)
2183         stat = METAFILE_GetGraphicsContext((GpMetafile*)image, graphics);
2184     else
2185         stat = graphics_from_image(image, graphics);
2186
2187     return stat;
2188 }
2189
2190 GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
2191 {
2192     TRACE("%p %p\n", image, height);
2193
2194     if(!image || !height)
2195         return InvalidParameter;
2196
2197     if(image->type == ImageTypeMetafile){
2198         HDC hdc = GetDC(0);
2199         REAL res = (REAL)GetDeviceCaps(hdc, LOGPIXELSX);
2200
2201         ReleaseDC(0, hdc);
2202
2203         *height = roundr(convert_unit(res, ((GpMetafile*)image)->unit) *
2204                         ((GpMetafile*)image)->bounds.Height);
2205     }
2206     else if(image->type == ImageTypeBitmap)
2207         *height = ((GpBitmap*)image)->height;
2208     else
2209         *height = ipicture_pixel_height(image->picture);
2210
2211     TRACE("returning %d\n", *height);
2212
2213     return Ok;
2214 }
2215
2216 GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *res)
2217 {
2218     if(!image || !res)
2219         return InvalidParameter;
2220
2221     *res = image->xres;
2222
2223     TRACE("(%p) <-- %0.2f\n", image, *res);
2224
2225     return Ok;
2226 }
2227
2228 GpStatus WINGDIPAPI GdipGetImagePaletteSize(GpImage *image, INT *size)
2229 {
2230     TRACE("%p %p\n", image, size);
2231
2232     if(!image || !size)
2233         return InvalidParameter;
2234
2235     if (image->palette_count == 0)
2236         *size = sizeof(ColorPalette);
2237     else
2238         *size = sizeof(UINT)*2 + sizeof(ARGB)*image->palette_count;
2239
2240     TRACE("<-- %u\n", *size);
2241
2242     return Ok;
2243 }
2244
2245 /* FIXME: test this function for non-bitmap types */
2246 GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format)
2247 {
2248     TRACE("%p %p\n", image, format);
2249
2250     if(!image || !format)
2251         return InvalidParameter;
2252
2253     if(image->type != ImageTypeBitmap)
2254         *format = PixelFormat24bppRGB;
2255     else
2256         *format = ((GpBitmap*) image)->format;
2257
2258     return Ok;
2259 }
2260
2261 GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
2262 {
2263     TRACE("(%p, %p)\n", image, format);
2264
2265     if(!image || !format)
2266         return InvalidParameter;
2267
2268     memcpy(format, &image->format, sizeof(GUID));
2269
2270     return Ok;
2271 }
2272
2273 GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
2274 {
2275     TRACE("%p %p\n", image, type);
2276
2277     if(!image || !type)
2278         return InvalidParameter;
2279
2280     *type = image->type;
2281
2282     return Ok;
2283 }
2284
2285 GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *res)
2286 {
2287     if(!image || !res)
2288         return InvalidParameter;
2289
2290     *res = image->yres;
2291
2292     TRACE("(%p) <-- %0.2f\n", image, *res);
2293
2294     return Ok;
2295 }
2296
2297 GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
2298 {
2299     TRACE("%p %p\n", image, width);
2300
2301     if(!image || !width)
2302         return InvalidParameter;
2303
2304     if(image->type == ImageTypeMetafile){
2305         HDC hdc = GetDC(0);
2306         REAL res = (REAL)GetDeviceCaps(hdc, LOGPIXELSX);
2307
2308         ReleaseDC(0, hdc);
2309
2310         *width = roundr(convert_unit(res, ((GpMetafile*)image)->unit) *
2311                         ((GpMetafile*)image)->bounds.Width);
2312     }
2313     else if(image->type == ImageTypeBitmap)
2314         *width = ((GpBitmap*)image)->width;
2315     else
2316         *width = ipicture_pixel_width(image->picture);
2317
2318     TRACE("returning %d\n", *width);
2319
2320     return Ok;
2321 }
2322
2323 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile * metafile,
2324     MetafileHeader * header)
2325 {
2326     static int calls;
2327
2328     TRACE("(%p, %p)\n", metafile, header);
2329
2330     if(!metafile || !header)
2331         return InvalidParameter;
2332
2333     if(!(calls++))
2334         FIXME("not implemented\n");
2335
2336     memset(header, 0, sizeof(MetafileHeader));
2337
2338     return Ok;
2339 }
2340
2341 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromEmf(HENHMETAFILE hEmf,
2342     MetafileHeader *header)
2343 {
2344     static int calls;
2345
2346     if(!hEmf || !header)
2347         return InvalidParameter;
2348
2349     if(!(calls++))
2350         FIXME("not implemented\n");
2351
2352     memset(header, 0, sizeof(MetafileHeader));
2353
2354     return Ok;
2355 }
2356
2357 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromFile(GDIPCONST WCHAR *filename,
2358     MetafileHeader *header)
2359 {
2360     static int calls;
2361
2362     TRACE("(%s,%p)\n", debugstr_w(filename), header);
2363
2364     if(!filename || !header)
2365         return InvalidParameter;
2366
2367     if(!(calls++))
2368         FIXME("not implemented\n");
2369
2370     memset(header, 0, sizeof(MetafileHeader));
2371
2372     return Ok;
2373 }
2374
2375 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromStream(IStream *stream,
2376     MetafileHeader *header)
2377 {
2378     static int calls;
2379
2380     TRACE("(%p,%p)\n", stream, header);
2381
2382     if(!stream || !header)
2383         return InvalidParameter;
2384
2385     if(!(calls++))
2386         FIXME("not implemented\n");
2387
2388     memset(header, 0, sizeof(MetafileHeader));
2389
2390     return Ok;
2391 }
2392
2393 GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage *image, UINT *num)
2394 {
2395     TRACE("(%p, %p)\n", image, num);
2396
2397     if (!image || !num) return InvalidParameter;
2398
2399     *num = 0;
2400
2401     if (image->type == ImageTypeBitmap)
2402     {
2403         if (((GpBitmap *)image)->metadata_reader)
2404             IWICMetadataReader_GetCount(((GpBitmap *)image)->metadata_reader, num);
2405     }
2406
2407     return Ok;
2408 }
2409
2410 GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT num, PROPID *list)
2411 {
2412     HRESULT hr;
2413     IWICMetadataReader *reader;
2414     IWICEnumMetadataItem *enumerator;
2415     UINT prop_count, i, items_returned;
2416
2417     TRACE("(%p, %u, %p)\n", image, num, list);
2418
2419     if (!image || !list) return InvalidParameter;
2420
2421     if (image->type != ImageTypeBitmap)
2422     {
2423         FIXME("Not implemented for type %d\n", image->type);
2424         return NotImplemented;
2425     }
2426
2427     reader = ((GpBitmap *)image)->metadata_reader;
2428     if (!reader)
2429     {
2430         if (num != 0) return InvalidParameter;
2431         return Ok;
2432     }
2433
2434     hr = IWICMetadataReader_GetCount(reader, &prop_count);
2435     if (FAILED(hr)) return hresult_to_status(hr);
2436
2437     if (num != prop_count) return InvalidParameter;
2438
2439     hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2440     if (FAILED(hr)) return hresult_to_status(hr);
2441
2442     IWICEnumMetadataItem_Reset(enumerator);
2443
2444     for (i = 0; i < num; i++)
2445     {
2446         PROPVARIANT id;
2447
2448         hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, NULL, &items_returned);
2449         if (hr != S_OK) break;
2450
2451         if (id.vt != VT_UI2)
2452         {
2453             FIXME("not supported propvariant type for id: %u\n", id.vt);
2454             list[i] = 0;
2455             continue;
2456         }
2457         list[i] = id.u.uiVal;
2458     }
2459
2460     IWICEnumMetadataItem_Release(enumerator);
2461
2462     return hr == S_OK ? Ok : hresult_to_status(hr);
2463 }
2464
2465 static UINT propvariant_size(PROPVARIANT *value)
2466 {
2467     switch (value->vt & ~VT_VECTOR)
2468     {
2469     case VT_EMPTY:
2470         return 0;
2471     case VT_I1:
2472     case VT_UI1:
2473         if (!(value->vt & VT_VECTOR)) return 1;
2474         return value->u.caub.cElems;
2475     case VT_I2:
2476     case VT_UI2:
2477         if (!(value->vt & VT_VECTOR)) return 2;
2478         return value->u.caui.cElems * 2;
2479     case VT_I4:
2480     case VT_UI4:
2481     case VT_R4:
2482         if (!(value->vt & VT_VECTOR)) return 4;
2483         return value->u.caul.cElems * 4;
2484     case VT_I8:
2485     case VT_UI8:
2486     case VT_R8:
2487         if (!(value->vt & VT_VECTOR)) return 8;
2488         return value->u.cauh.cElems * 8;
2489     case VT_LPSTR:
2490         return value->u.pszVal ? strlen(value->u.pszVal) + 1 : 0;
2491     case VT_BLOB:
2492         return value->u.blob.cbSize;
2493     default:
2494         FIXME("not supported variant type %d\n", value->vt);
2495         return 0;
2496     }
2497 }
2498
2499 GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID propid, UINT *size)
2500 {
2501     HRESULT hr;
2502     IWICMetadataReader *reader;
2503     PROPVARIANT id, value;
2504
2505     TRACE("(%p,%#x,%p)\n", image, propid, size);
2506
2507     if (!size || !image) return InvalidParameter;
2508
2509     if (image->type != ImageTypeBitmap)
2510     {
2511         FIXME("Not implemented for type %d\n", image->type);
2512         return NotImplemented;
2513     }
2514
2515     reader = ((GpBitmap *)image)->metadata_reader;
2516     if (!reader) return PropertyNotFound;
2517
2518     id.vt = VT_UI2;
2519     id.u.uiVal = propid;
2520     hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
2521     if (FAILED(hr)) return PropertyNotFound;
2522
2523     *size = propvariant_size(&value);
2524     if (*size) *size += sizeof(PropertyItem);
2525     PropVariantClear(&value);
2526
2527     return Ok;
2528 }
2529
2530 #ifndef PropertyTagTypeSByte
2531 #define PropertyTagTypeSByte  6
2532 #define PropertyTagTypeSShort 8
2533 #define PropertyTagTypeFloat  11
2534 #define PropertyTagTypeDouble 12
2535 #endif
2536
2537 static UINT vt_to_itemtype(UINT vt)
2538 {
2539     static const struct
2540     {
2541         UINT vt, type;
2542     } vt2type[] =
2543     {
2544         { VT_I1, PropertyTagTypeSByte },
2545         { VT_UI1, PropertyTagTypeByte },
2546         { VT_I2, PropertyTagTypeSShort },
2547         { VT_UI2, PropertyTagTypeShort },
2548         { VT_I4, PropertyTagTypeSLONG },
2549         { VT_UI4, PropertyTagTypeLong },
2550         { VT_I8, PropertyTagTypeSRational },
2551         { VT_UI8, PropertyTagTypeRational },
2552         { VT_R4, PropertyTagTypeFloat },
2553         { VT_R8, PropertyTagTypeDouble },
2554         { VT_LPSTR, PropertyTagTypeASCII },
2555         { VT_BLOB, PropertyTagTypeUndefined }
2556     };
2557     UINT i;
2558     for (i = 0; i < sizeof(vt2type)/sizeof(vt2type[0]); i++)
2559     {
2560         if (vt2type[i].vt == vt) return vt2type[i].type;
2561     }
2562     FIXME("not supported variant type %u\n", vt);
2563     return 0;
2564 }
2565
2566 static GpStatus propvariant_to_item(PROPVARIANT *value, PropertyItem *item,
2567                                     UINT size, PROPID id)
2568 {
2569     UINT item_size, item_type;
2570
2571     item_size = propvariant_size(value);
2572     if (size != item_size + sizeof(PropertyItem)) return InvalidParameter;
2573
2574     item_type = vt_to_itemtype(value->vt & ~VT_VECTOR);
2575     if (!item_type) return InvalidParameter;
2576
2577     item->value = item + 1;
2578
2579     switch (value->vt & ~VT_VECTOR)
2580     {
2581     case VT_I1:
2582     case VT_UI1:
2583         if (!(value->vt & VT_VECTOR))
2584             *(BYTE *)item->value = value->u.bVal;
2585         else
2586             memcpy(item->value, value->u.caub.pElems, item_size);
2587         break;
2588     case VT_I2:
2589     case VT_UI2:
2590         if (!(value->vt & VT_VECTOR))
2591             *(USHORT *)item->value = value->u.uiVal;
2592         else
2593             memcpy(item->value, value->u.caui.pElems, item_size);
2594         break;
2595     case VT_I4:
2596     case VT_UI4:
2597     case VT_R4:
2598         if (!(value->vt & VT_VECTOR))
2599             *(ULONG *)item->value = value->u.ulVal;
2600         else
2601             memcpy(item->value, value->u.caul.pElems, item_size);
2602         break;
2603     case VT_I8:
2604     case VT_UI8:
2605     case VT_R8:
2606         if (!(value->vt & VT_VECTOR))
2607             *(ULONGLONG *)item->value = value->u.uhVal.QuadPart;
2608         else
2609             memcpy(item->value, value->u.cauh.pElems, item_size);
2610         break;
2611     case VT_LPSTR:
2612         memcpy(item->value, value->u.pszVal, item_size);
2613         break;
2614     case VT_BLOB:
2615         memcpy(item->value, value->u.blob.pBlobData, item_size);
2616         break;
2617     default:
2618         FIXME("not supported variant type %d\n", value->vt);
2619         return InvalidParameter;
2620     }
2621
2622     item->length = item_size;
2623     item->type = item_type;
2624     item->id = id;
2625
2626     return Ok;
2627 }
2628
2629 GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID propid, UINT size,
2630                                         PropertyItem *buffer)
2631 {
2632     GpStatus stat;
2633     HRESULT hr;
2634     IWICMetadataReader *reader;
2635     PROPVARIANT id, value;
2636
2637     TRACE("(%p,%#x,%u,%p)\n", image, propid, size, buffer);
2638
2639     if (!image || !buffer) return InvalidParameter;
2640
2641     if (image->type != ImageTypeBitmap)
2642     {
2643         FIXME("Not implemented for type %d\n", image->type);
2644         return NotImplemented;
2645     }
2646
2647     reader = ((GpBitmap *)image)->metadata_reader;
2648     if (!reader) return PropertyNotFound;
2649
2650     id.vt = VT_UI2;
2651     id.u.uiVal = propid;
2652     hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
2653     if (FAILED(hr)) return PropertyNotFound;
2654
2655     stat = propvariant_to_item(&value, buffer, size, propid);
2656     PropVariantClear(&value);
2657
2658     return stat;
2659 }
2660
2661 GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT *size, UINT *count)
2662 {
2663     HRESULT hr;
2664     IWICMetadataReader *reader;
2665     IWICEnumMetadataItem *enumerator;
2666     UINT prop_count, prop_size, i;
2667     PROPVARIANT id, value;
2668
2669     TRACE("(%p,%p,%p)\n", image, size, count);
2670
2671     if (!image || !size || !count) return InvalidParameter;
2672
2673     if (image->type != ImageTypeBitmap)
2674     {
2675         FIXME("Not implemented for type %d\n", image->type);
2676         return NotImplemented;
2677     }
2678
2679     reader = ((GpBitmap *)image)->metadata_reader;
2680     if (!reader) return PropertyNotFound;
2681
2682     hr = IWICMetadataReader_GetCount(reader, &prop_count);
2683     if (FAILED(hr)) return hresult_to_status(hr);
2684
2685     hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2686     if (FAILED(hr)) return hresult_to_status(hr);
2687
2688     IWICEnumMetadataItem_Reset(enumerator);
2689
2690     prop_size = 0;
2691
2692     PropVariantInit(&id);
2693     PropVariantInit(&value);
2694
2695     for (i = 0; i < prop_count; i++)
2696     {
2697         UINT items_returned, item_size;
2698
2699         hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, &value, &items_returned);
2700         if (hr != S_OK) break;
2701
2702         item_size = propvariant_size(&value);
2703         if (item_size) prop_size += sizeof(PropertyItem) + item_size;
2704
2705         PropVariantClear(&id);
2706         PropVariantClear(&value);
2707     }
2708
2709     IWICEnumMetadataItem_Release(enumerator);
2710
2711     if (hr != S_OK) return PropertyNotFound;
2712
2713     *count = prop_count;
2714     *size = prop_size;
2715     return Ok;
2716 }
2717
2718 GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT size,
2719                                             UINT count, PropertyItem *buf)
2720 {
2721     GpStatus status;
2722     HRESULT hr;
2723     IWICMetadataReader *reader;
2724     IWICEnumMetadataItem *enumerator;
2725     UINT prop_count, prop_size, i;
2726     PROPVARIANT id, value;
2727     char *item_value;
2728
2729     TRACE("(%p,%u,%u,%p)\n", image, size, count, buf);
2730
2731     if (!image || !buf) return InvalidParameter;
2732
2733     if (image->type != ImageTypeBitmap)
2734     {
2735         FIXME("Not implemented for type %d\n", image->type);
2736         return NotImplemented;
2737     }
2738
2739     status = GdipGetPropertySize(image, &prop_size, &prop_count);
2740     if (status != Ok) return status;
2741
2742     if (prop_count != count || prop_size != size) return InvalidParameter;
2743
2744     reader = ((GpBitmap *)image)->metadata_reader;
2745     if (!reader) return PropertyNotFound;
2746
2747     hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2748     if (FAILED(hr)) return hresult_to_status(hr);
2749
2750     IWICEnumMetadataItem_Reset(enumerator);
2751
2752     item_value = (char *)(buf + prop_count);
2753
2754     PropVariantInit(&id);
2755     PropVariantInit(&value);
2756
2757     for (i = 0; i < prop_count; i++)
2758     {
2759         PropertyItem *item;
2760         UINT items_returned, item_size;
2761
2762         hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, &value, &items_returned);
2763         if (hr != S_OK) break;
2764
2765         if (id.vt != VT_UI2)
2766         {
2767             FIXME("not supported propvariant type for id: %u\n", id.vt);
2768             continue;
2769         }
2770
2771         item_size = propvariant_size(&value);
2772         if (item_size)
2773         {
2774             item = HeapAlloc(GetProcessHeap(), 0, item_size + sizeof(*item));
2775
2776             propvariant_to_item(&value, item, item_size + sizeof(*item), id.u.uiVal);
2777             buf[i].id = item->id;
2778             buf[i].type = item->type;
2779             buf[i].length = item_size;
2780             buf[i].value = item_value;
2781             memcpy(item_value, item->value, item_size);
2782             item_value += item_size;
2783
2784             HeapFree(GetProcessHeap(), 0, item);
2785         }
2786
2787         PropVariantClear(&id);
2788         PropVariantClear(&value);
2789     }
2790
2791     IWICEnumMetadataItem_Release(enumerator);
2792
2793     if (hr != S_OK) return PropertyNotFound;
2794
2795     return Ok;
2796 }
2797
2798 struct image_format_dimension
2799 {
2800     const GUID *format;
2801     const GUID *dimension;
2802 };
2803
2804 static const struct image_format_dimension image_format_dimensions[] =
2805 {
2806     {&ImageFormatGIF, &FrameDimensionTime},
2807     {&ImageFormatIcon, &FrameDimensionResolution},
2808     {NULL}
2809 };
2810
2811 GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
2812     GDIPCONST GUID* dimensionID, UINT* count)
2813 {
2814     TRACE("(%p,%s,%p)\n", image, debugstr_guid(dimensionID), count);
2815
2816     if(!image || !count)
2817         return InvalidParameter;
2818
2819     if (!dimensionID ||
2820         IsEqualGUID(dimensionID, &image->format) ||
2821         IsEqualGUID(dimensionID, &FrameDimensionPage) ||
2822         IsEqualGUID(dimensionID, &FrameDimensionTime))
2823     {
2824         *count = image->frame_count;
2825         return Ok;
2826     }
2827
2828     return InvalidParameter;
2829 }
2830
2831 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage *image,
2832     UINT* count)
2833 {
2834     TRACE("(%p, %p)\n", image, count);
2835
2836     /* Native gdiplus 1.1 does not yet support multiple frame dimensions. */
2837
2838     if(!image || !count)
2839         return InvalidParameter;
2840
2841     *count = 1;
2842
2843     return Ok;
2844 }
2845
2846 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image,
2847     GUID* dimensionIDs, UINT count)
2848 {
2849     int i;
2850     const GUID *result=NULL;
2851
2852     TRACE("(%p,%p,%u)\n", image, dimensionIDs, count);
2853
2854     if(!image || !dimensionIDs || count != 1)
2855         return InvalidParameter;
2856
2857     for (i=0; image_format_dimensions[i].format; i++)
2858     {
2859         if (IsEqualGUID(&image->format, image_format_dimensions[i].format))
2860         {
2861             result = image_format_dimensions[i].dimension;
2862             break;
2863         }
2864     }
2865
2866     if (!result)
2867         result = &FrameDimensionPage;
2868
2869     memcpy(dimensionIDs, result, sizeof(GUID));
2870
2871     return Ok;
2872 }
2873
2874 GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
2875                                           GpImage **image)
2876 {
2877     GpStatus stat;
2878     IStream *stream;
2879
2880     TRACE("(%s) %p\n", debugstr_w(filename), image);
2881
2882     if (!filename || !image)
2883         return InvalidParameter;
2884
2885     stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
2886
2887     if (stat != Ok)
2888         return stat;
2889
2890     stat = GdipLoadImageFromStream(stream, image);
2891
2892     IStream_Release(stream);
2893
2894     return stat;
2895 }
2896
2897 /* FIXME: no icm handling */
2898 GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,GpImage **image)
2899 {
2900     TRACE("(%s) %p\n", debugstr_w(filename), image);
2901
2902     return GdipLoadImageFromFile(filename, image);
2903 }
2904
2905 static const WICPixelFormatGUID * const wic_pixel_formats[] = {
2906     &GUID_WICPixelFormat16bppBGR555,
2907     &GUID_WICPixelFormat24bppBGR,
2908     &GUID_WICPixelFormat32bppBGR,
2909     &GUID_WICPixelFormat32bppBGRA,
2910     &GUID_WICPixelFormat32bppPBGRA,
2911     NULL
2912 };
2913
2914 static const PixelFormat wic_gdip_formats[] = {
2915     PixelFormat16bppRGB555,
2916     PixelFormat24bppRGB,
2917     PixelFormat32bppRGB,
2918     PixelFormat32bppARGB,
2919     PixelFormat32bppPARGB,
2920 };
2921
2922 static GpStatus decode_image_wic(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
2923 {
2924     GpStatus status=Ok;
2925     GpBitmap *bitmap;
2926     HRESULT hr;
2927     IWICBitmapDecoder *decoder;
2928     IWICBitmapFrameDecode *frame;
2929     IWICBitmapSource *source=NULL;
2930     IWICMetadataBlockReader *block_reader;
2931     WICPixelFormatGUID wic_format;
2932     PixelFormat gdip_format=0;
2933     int i;
2934     UINT width, height, frame_count;
2935     BitmapData lockeddata;
2936     WICRect wrc;
2937     HRESULT initresult;
2938
2939     initresult = CoInitialize(NULL);
2940
2941     hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
2942         &IID_IWICBitmapDecoder, (void**)&decoder);
2943     if (FAILED(hr)) goto end;
2944
2945     hr = IWICBitmapDecoder_Initialize(decoder, stream, WICDecodeMetadataCacheOnLoad);
2946     if (SUCCEEDED(hr))
2947     {
2948         IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
2949         hr = IWICBitmapDecoder_GetFrame(decoder, active_frame, &frame);
2950     }
2951
2952     if (SUCCEEDED(hr)) /* got frame */
2953     {
2954         hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &wic_format);
2955
2956         if (SUCCEEDED(hr))
2957         {
2958             IWICBitmapSource *bmp_source;
2959             IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICBitmapSource, (void **)&bmp_source);
2960
2961             for (i=0; wic_pixel_formats[i]; i++)
2962             {
2963                 if (IsEqualGUID(&wic_format, wic_pixel_formats[i]))
2964                 {
2965                     source = bmp_source;
2966                     gdip_format = wic_gdip_formats[i];
2967                     break;
2968                 }
2969             }
2970             if (!source)
2971             {
2972                 /* unknown format; fall back on 32bppARGB */
2973                 hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, bmp_source, &source);
2974                 gdip_format = PixelFormat32bppARGB;
2975                 IWICBitmapSource_Release(bmp_source);
2976             }
2977         }
2978
2979         if (SUCCEEDED(hr)) /* got source */
2980         {
2981             hr = IWICBitmapSource_GetSize(source, &width, &height);
2982
2983             if (SUCCEEDED(hr))
2984                 status = GdipCreateBitmapFromScan0(width, height, 0, gdip_format,
2985                     NULL, &bitmap);
2986
2987             if (SUCCEEDED(hr) && status == Ok) /* created bitmap */
2988             {
2989                 status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeWrite,
2990                     gdip_format, &lockeddata);
2991                 if (status == Ok) /* locked bitmap */
2992                 {
2993                     wrc.X = 0;
2994                     wrc.Width = width;
2995                     wrc.Height = 1;
2996                     for (i=0; i<height; i++)
2997                     {
2998                         wrc.Y = i;
2999                         hr = IWICBitmapSource_CopyPixels(source, &wrc, abs(lockeddata.Stride),
3000                             abs(lockeddata.Stride), (BYTE*)lockeddata.Scan0+lockeddata.Stride*i);
3001                         if (FAILED(hr)) break;
3002                     }
3003
3004                     GdipBitmapUnlockBits(bitmap, &lockeddata);
3005                 }
3006
3007                 if (SUCCEEDED(hr) && status == Ok)
3008                     *image = (GpImage*)bitmap;
3009                 else
3010                 {
3011                     *image = NULL;
3012                     GdipDisposeImage((GpImage*)bitmap);
3013                 }
3014
3015                 if (SUCCEEDED(hr) && status == Ok)
3016                 {
3017                     double dpix, dpiy;
3018                     hr = IWICBitmapSource_GetResolution(source, &dpix, &dpiy);
3019                     if (SUCCEEDED(hr))
3020                     {
3021                         bitmap->image.xres = dpix;
3022                         bitmap->image.yres = dpiy;
3023                     }
3024                     hr = S_OK;
3025                 }
3026             }
3027
3028             IWICBitmapSource_Release(source);
3029         }
3030
3031         bitmap->metadata_reader = NULL;
3032         if (IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader) == S_OK)
3033         {
3034             UINT block_count = 0;
3035             if (IWICMetadataBlockReader_GetCount(block_reader, &block_count) == S_OK && block_count)
3036                 IWICMetadataBlockReader_GetReaderByIndex(block_reader, 0, &bitmap->metadata_reader);
3037             IWICMetadataBlockReader_Release(block_reader);
3038         }
3039
3040         IWICBitmapFrameDecode_Release(frame);
3041     }
3042
3043     IWICBitmapDecoder_Release(decoder);
3044
3045 end:
3046     if (SUCCEEDED(initresult)) CoUninitialize();
3047
3048     if (FAILED(hr) && status == Ok) status = hresult_to_status(hr);
3049
3050     if (status == Ok)
3051     {
3052         /* Native GDI+ used to be smarter, but since Win7 it just sets these flags. */
3053         bitmap->image.flags |= ImageFlagsReadOnly|ImageFlagsHasRealPixelSize|ImageFlagsHasRealDPI|ImageFlagsColorSpaceRGB;
3054         bitmap->image.frame_count = frame_count;
3055         bitmap->image.current_frame = active_frame;
3056         bitmap->image.stream = stream;
3057         /* Pin the source stream */
3058         IStream_AddRef(stream);
3059     }
3060
3061     return status;
3062 }
3063
3064 static GpStatus decode_image_icon(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3065 {
3066     return decode_image_wic(stream, &CLSID_WICIcoDecoder, active_frame, image);
3067 }
3068
3069 static GpStatus decode_image_bmp(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3070 {
3071     GpStatus status;
3072     GpBitmap* bitmap;
3073
3074     status = decode_image_wic(stream, &CLSID_WICBmpDecoder, active_frame, image);
3075
3076     bitmap = (GpBitmap*)*image;
3077
3078     if (status == Ok && bitmap->format == PixelFormat32bppARGB)
3079     {
3080         /* WIC supports bmp files with alpha, but gdiplus does not */
3081         bitmap->format = PixelFormat32bppRGB;
3082     }
3083
3084     return status;
3085 }
3086
3087 static GpStatus decode_image_jpeg(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3088 {
3089     return decode_image_wic(stream, &CLSID_WICJpegDecoder, active_frame, image);
3090 }
3091
3092 static GpStatus decode_image_png(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3093 {
3094     return decode_image_wic(stream, &CLSID_WICPngDecoder, active_frame, image);
3095 }
3096
3097 static GpStatus decode_image_gif(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3098 {
3099     return decode_image_wic(stream, &CLSID_WICGifDecoder, active_frame, image);
3100 }
3101
3102 static GpStatus decode_image_tiff(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3103 {
3104     return decode_image_wic(stream, &CLSID_WICTiffDecoder, active_frame, image);
3105 }
3106
3107 static GpStatus decode_image_olepicture_metafile(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3108 {
3109     IPicture *pic;
3110
3111     TRACE("%p %p\n", stream, image);
3112
3113     if(!stream || !image)
3114         return InvalidParameter;
3115
3116     if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
3117         (LPVOID*) &pic) != S_OK){
3118         TRACE("Could not load picture\n");
3119         return GenericError;
3120     }
3121
3122     /* FIXME: missing initialization code */
3123     *image = GdipAlloc(sizeof(GpMetafile));
3124     if(!*image) return OutOfMemory;
3125     (*image)->type = ImageTypeMetafile;
3126     (*image)->stream = NULL;
3127     (*image)->picture = pic;
3128     (*image)->flags   = ImageFlagsNone;
3129     (*image)->frame_count = 1;
3130     (*image)->current_frame = 0;
3131     (*image)->palette_flags = 0;
3132     (*image)->palette_count = 0;
3133     (*image)->palette_size = 0;
3134     (*image)->palette_entries = NULL;
3135
3136     TRACE("<-- %p\n", *image);
3137
3138     return Ok;
3139 }
3140
3141 typedef GpStatus (*encode_image_func)(GpImage *image, IStream* stream,
3142     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params);
3143
3144 typedef GpStatus (*decode_image_func)(IStream *stream, REFCLSID clsid, UINT active_frame, GpImage **image);
3145
3146 typedef struct image_codec {
3147     ImageCodecInfo info;
3148     encode_image_func encode_func;
3149     decode_image_func decode_func;
3150 } image_codec;
3151
3152 typedef enum {
3153     BMP,
3154     JPEG,
3155     GIF,
3156     TIFF,
3157     EMF,
3158     WMF,
3159     PNG,
3160     ICO,
3161     NUM_CODECS
3162 } ImageFormat;
3163
3164 static const struct image_codec codecs[NUM_CODECS];
3165
3166 static GpStatus get_decoder_info(IStream* stream, const struct image_codec **result)
3167 {
3168     BYTE signature[8];
3169     const BYTE *pattern, *mask;
3170     LARGE_INTEGER seek;
3171     HRESULT hr;
3172     UINT bytesread;
3173     int i, j, sig;
3174
3175     /* seek to the start of the stream */
3176     seek.QuadPart = 0;
3177     hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
3178     if (FAILED(hr)) return hresult_to_status(hr);
3179
3180     /* read the first 8 bytes */
3181     /* FIXME: This assumes all codecs have signatures <= 8 bytes in length */
3182     hr = IStream_Read(stream, signature, 8, &bytesread);
3183     if (FAILED(hr)) return hresult_to_status(hr);
3184     if (hr == S_FALSE || bytesread == 0) return GenericError;
3185
3186     for (i = 0; i < NUM_CODECS; i++) {
3187         if ((codecs[i].info.Flags & ImageCodecFlagsDecoder) &&
3188             bytesread >= codecs[i].info.SigSize)
3189         {
3190             for (sig=0; sig<codecs[i].info.SigCount; sig++)
3191             {
3192                 pattern = &codecs[i].info.SigPattern[codecs[i].info.SigSize*sig];
3193                 mask = &codecs[i].info.SigMask[codecs[i].info.SigSize*sig];
3194                 for (j=0; j<codecs[i].info.SigSize; j++)
3195                     if ((signature[j] & mask[j]) != pattern[j])
3196                         break;
3197                 if (j == codecs[i].info.SigSize)
3198                 {
3199                     *result = &codecs[i];
3200                     return Ok;
3201                 }
3202             }
3203         }
3204     }
3205
3206     TRACE("no match for %i byte signature %x %x %x %x %x %x %x %x\n", bytesread,
3207         signature[0],signature[1],signature[2],signature[3],
3208         signature[4],signature[5],signature[6],signature[7]);
3209
3210     return GenericError;
3211 }
3212
3213 GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage *image, GDIPCONST GUID *dimensionID,
3214                                                UINT frame)
3215 {
3216     GpStatus stat;
3217     LARGE_INTEGER seek;
3218     HRESULT hr;
3219     const struct image_codec *codec = NULL;
3220     IStream *stream;
3221     GpImage *new_image;
3222
3223     TRACE("(%p,%s,%u)\n", image, debugstr_guid(dimensionID), frame);
3224
3225     if (!image || !dimensionID)
3226         return InvalidParameter;
3227
3228     if (frame >= image->frame_count)
3229         return InvalidParameter;
3230
3231     if (image->type != ImageTypeBitmap && image->type != ImageTypeMetafile)
3232     {
3233         WARN("invalid image type %d\n", image->type);
3234         return InvalidParameter;
3235     }
3236
3237     if (image->current_frame == frame)
3238         return Ok;
3239
3240     if (!image->stream)
3241     {
3242         TRACE("image doesn't have an associated stream\n");
3243         return Ok;
3244     }
3245
3246     hr = IStream_Clone(image->stream, &stream);
3247     if (FAILED(hr))
3248     {
3249         STATSTG statstg;
3250
3251         hr = IStream_Stat(image->stream, &statstg, STATFLAG_NOOPEN);
3252         if (FAILED(hr)) return hresult_to_status(hr);
3253
3254         stat = GdipCreateStreamOnFile(statstg.pwcsName, GENERIC_READ, &stream);
3255         if (stat != Ok) return stat;
3256     }
3257
3258     /* choose an appropriate image decoder */
3259     stat = get_decoder_info(stream, &codec);
3260     if (stat != Ok)
3261     {
3262         IStream_Release(stream);
3263         return stat;
3264     }
3265
3266     /* seek to the start of the stream */
3267     seek.QuadPart = 0;
3268     hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
3269     if (FAILED(hr))
3270     {
3271         IStream_Release(stream);
3272         return hresult_to_status(hr);
3273     }
3274
3275     /* call on the image decoder to do the real work */
3276     stat = codec->decode_func(stream, &codec->info.Clsid, frame, &new_image);
3277
3278     if (stat == Ok)
3279     {
3280         memcpy(&new_image->format, &codec->info.FormatID, sizeof(GUID));
3281         free_image_data(image);
3282         if (image->type == ImageTypeBitmap)
3283             *(GpBitmap *)image = *(GpBitmap *)new_image;
3284         else if (image->type == ImageTypeMetafile)
3285             *(GpMetafile *)image = *(GpMetafile *)new_image;
3286         new_image->type = ~0;
3287         GdipFree(new_image);
3288         return Ok;
3289     }
3290
3291     IStream_Release(stream);
3292     return stat;
3293 }
3294
3295 GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream *stream, GpImage **image)
3296 {
3297     GpStatus stat;
3298     LARGE_INTEGER seek;
3299     HRESULT hr;
3300     const struct image_codec *codec=NULL;
3301
3302     /* choose an appropriate image decoder */
3303     stat = get_decoder_info(stream, &codec);
3304     if (stat != Ok) return stat;
3305
3306     /* seek to the start of the stream */
3307     seek.QuadPart = 0;
3308     hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
3309     if (FAILED(hr)) return hresult_to_status(hr);
3310
3311     /* call on the image decoder to do the real work */
3312     stat = codec->decode_func(stream, &codec->info.Clsid, 0, image);
3313
3314     /* take note of the original data format */
3315     if (stat == Ok)
3316     {
3317         memcpy(&(*image)->format, &codec->info.FormatID, sizeof(GUID));
3318         return Ok;
3319     }
3320
3321     return stat;
3322 }
3323
3324 /* FIXME: no ICM */
3325 GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image)
3326 {
3327     TRACE("%p %p\n", stream, image);
3328
3329     return GdipLoadImageFromStream(stream, image);
3330 }
3331
3332 GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage *image, PROPID propId)
3333 {
3334     static int calls;
3335
3336     TRACE("(%p,%u)\n", image, propId);
3337
3338     if(!image)
3339         return InvalidParameter;
3340
3341     if(!(calls++))
3342         FIXME("not implemented\n");
3343
3344     return NotImplemented;
3345 }
3346
3347 GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item)
3348 {
3349     static int calls;
3350
3351     if (!image || !item) return InvalidParameter;
3352
3353     TRACE("(%p,%p:%#x,%u,%u,%p)\n", image, item, item->id, item->type, item->length, item->value);
3354
3355     if(!(calls++))
3356         FIXME("not implemented\n");
3357
3358     return NotImplemented;
3359 }
3360
3361 GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
3362                                         GDIPCONST CLSID *clsidEncoder,
3363                                         GDIPCONST EncoderParameters *encoderParams)
3364 {
3365     GpStatus stat;
3366     IStream *stream;
3367
3368     TRACE("%p (%s) %p %p\n", image, debugstr_w(filename), clsidEncoder, encoderParams);
3369
3370     if (!image || !filename|| !clsidEncoder)
3371         return InvalidParameter;
3372
3373     stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
3374     if (stat != Ok)
3375         return GenericError;
3376
3377     stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
3378
3379     IStream_Release(stream);
3380     return stat;
3381 }
3382
3383 /*************************************************************************
3384  * Encoding functions -
3385  *   These functions encode an image in different image file formats.
3386  */
3387 #define BITMAP_FORMAT_BMP   0x4d42 /* "BM" */
3388 #define BITMAP_FORMAT_JPEG  0xd8ff
3389 #define BITMAP_FORMAT_GIF   0x4947
3390 #define BITMAP_FORMAT_PNG   0x5089
3391 #define BITMAP_FORMAT_APM   0xcdd7
3392
3393 static GpStatus encode_image_WIC(GpImage *image, IStream* stream,
3394     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3395 {
3396     GpStatus stat;
3397     GpBitmap *bitmap;
3398     IWICBitmapEncoder *encoder;
3399     IWICBitmapFrameEncode *frameencode;
3400     IPropertyBag2 *encoderoptions;
3401     HRESULT hr;
3402     UINT width, height;
3403     PixelFormat gdipformat=0;
3404     WICPixelFormatGUID wicformat;
3405     GpRect rc;
3406     BitmapData lockeddata;
3407     HRESULT initresult;
3408     UINT i;
3409
3410     if (image->type != ImageTypeBitmap)
3411         return GenericError;
3412
3413     bitmap = (GpBitmap*)image;
3414
3415     GdipGetImageWidth(image, &width);
3416     GdipGetImageHeight(image, &height);
3417
3418     rc.X = 0;
3419     rc.Y = 0;
3420     rc.Width = width;
3421     rc.Height = height;
3422
3423     initresult = CoInitialize(NULL);
3424
3425     hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
3426         &IID_IWICBitmapEncoder, (void**)&encoder);
3427     if (FAILED(hr))
3428     {
3429         if (SUCCEEDED(initresult)) CoUninitialize();
3430         return hresult_to_status(hr);
3431     }
3432
3433     hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
3434
3435     if (SUCCEEDED(hr))
3436     {
3437         hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frameencode, &encoderoptions);
3438     }
3439
3440     if (SUCCEEDED(hr)) /* created frame */
3441     {
3442         hr = IWICBitmapFrameEncode_Initialize(frameencode, encoderoptions);
3443
3444         if (SUCCEEDED(hr))
3445             hr = IWICBitmapFrameEncode_SetSize(frameencode, width, height);
3446
3447         if (SUCCEEDED(hr))
3448             /* FIXME: use the resolution from the image */
3449             hr = IWICBitmapFrameEncode_SetResolution(frameencode, 96.0, 96.0);
3450
3451         if (SUCCEEDED(hr))
3452         {
3453             for (i=0; wic_pixel_formats[i]; i++)
3454             {
3455                 if (wic_gdip_formats[i] == bitmap->format)
3456                     break;
3457             }
3458             if (wic_pixel_formats[i])
3459                 memcpy(&wicformat, wic_pixel_formats[i], sizeof(GUID));
3460             else
3461                 memcpy(&wicformat, &GUID_WICPixelFormat32bppBGRA, sizeof(GUID));
3462
3463             hr = IWICBitmapFrameEncode_SetPixelFormat(frameencode, &wicformat);
3464
3465             for (i=0; wic_pixel_formats[i]; i++)
3466             {
3467                 if (IsEqualGUID(&wicformat, wic_pixel_formats[i]))
3468                     break;
3469             }
3470             if (wic_pixel_formats[i])
3471                 gdipformat = wic_gdip_formats[i];
3472             else
3473             {
3474                 ERR("cannot provide pixel format %s\n", debugstr_guid(&wicformat));
3475                 hr = E_FAIL;
3476             }
3477         }
3478
3479         if (SUCCEEDED(hr))
3480         {
3481             stat = GdipBitmapLockBits(bitmap, &rc, ImageLockModeRead, gdipformat,
3482                 &lockeddata);
3483
3484             if (stat == Ok)
3485             {
3486                 UINT row_size = (lockeddata.Width * PIXELFORMATBPP(gdipformat) + 7)/8;
3487                 BYTE *row;
3488
3489                 /* write one row at a time in case stride is negative */
3490                 row = lockeddata.Scan0;
3491                 for (i=0; i<lockeddata.Height; i++)
3492                 {
3493                     hr = IWICBitmapFrameEncode_WritePixels(frameencode, 1, row_size, row_size, row);
3494                     if (FAILED(hr)) break;
3495                     row += lockeddata.Stride;
3496                 }
3497
3498                 GdipBitmapUnlockBits(bitmap, &lockeddata);
3499             }
3500             else
3501                 hr = E_FAIL;
3502         }
3503
3504         if (SUCCEEDED(hr))
3505             hr = IWICBitmapFrameEncode_Commit(frameencode);
3506
3507         IWICBitmapFrameEncode_Release(frameencode);
3508         IPropertyBag2_Release(encoderoptions);
3509     }
3510
3511     if (SUCCEEDED(hr))
3512         hr = IWICBitmapEncoder_Commit(encoder);
3513
3514     IWICBitmapEncoder_Release(encoder);
3515
3516     if (SUCCEEDED(initresult)) CoUninitialize();
3517
3518     return hresult_to_status(hr);
3519 }
3520
3521 static GpStatus encode_image_BMP(GpImage *image, IStream* stream,
3522     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3523 {
3524     return encode_image_WIC(image, stream, &CLSID_WICBmpEncoder, params);
3525 }
3526
3527 static GpStatus encode_image_tiff(GpImage *image, IStream* stream,
3528     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3529 {
3530     return encode_image_WIC(image, stream, &CLSID_WICTiffEncoder, params);
3531 }
3532
3533 static GpStatus encode_image_png(GpImage *image, IStream* stream,
3534     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3535 {
3536     return encode_image_WIC(image, stream, &CLSID_WICPngEncoder, params);
3537 }
3538
3539 static GpStatus encode_image_jpeg(GpImage *image, IStream* stream,
3540     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3541 {
3542     return encode_image_WIC(image, stream, &CLSID_WICJpegEncoder, params);
3543 }
3544
3545 /*****************************************************************************
3546  * GdipSaveImageToStream [GDIPLUS.@]
3547  */
3548 GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage *image, IStream* stream,
3549     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3550 {
3551     GpStatus stat;
3552     encode_image_func encode_image;
3553     int i;
3554
3555     TRACE("%p %p %p %p\n", image, stream, clsid, params);
3556
3557     if(!image || !stream)
3558         return InvalidParameter;
3559
3560     /* select correct encoder */
3561     encode_image = NULL;
3562     for (i = 0; i < NUM_CODECS; i++) {
3563         if ((codecs[i].info.Flags & ImageCodecFlagsEncoder) &&
3564             IsEqualCLSID(clsid, &codecs[i].info.Clsid))
3565             encode_image = codecs[i].encode_func;
3566     }
3567     if (encode_image == NULL)
3568         return UnknownImageFormat;
3569
3570     stat = encode_image(image, stream, clsid, params);
3571
3572     return stat;
3573 }
3574
3575 /*****************************************************************************
3576  * GdipSaveAdd [GDIPLUS.@]
3577  */
3578 GpStatus WINGDIPAPI GdipSaveAdd(GpImage *image, GDIPCONST EncoderParameters *params)
3579 {
3580     FIXME("(%p,%p): stub\n", image, params);
3581     return Ok;
3582 }
3583
3584 /*****************************************************************************
3585  * GdipGetImagePalette [GDIPLUS.@]
3586  */
3587 GpStatus WINGDIPAPI GdipGetImagePalette(GpImage *image, ColorPalette *palette, INT size)
3588 {
3589     TRACE("(%p,%p,%i)\n", image, palette, size);
3590
3591     if (!image || !palette)
3592         return InvalidParameter;
3593
3594     if (size < (sizeof(UINT)*2+sizeof(ARGB)*image->palette_count))
3595     {
3596         TRACE("<-- InsufficientBuffer\n");
3597         return InsufficientBuffer;
3598     }
3599
3600     palette->Flags = image->palette_flags;
3601     palette->Count = image->palette_count;
3602     memcpy(palette->Entries, image->palette_entries, sizeof(ARGB)*image->palette_count);
3603
3604     return Ok;
3605 }
3606
3607 /*****************************************************************************
3608  * GdipSetImagePalette [GDIPLUS.@]
3609  */
3610 GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image,
3611     GDIPCONST ColorPalette *palette)
3612 {
3613     TRACE("(%p,%p)\n", image, palette);
3614
3615     if(!image || !palette || palette->Count > 256)
3616         return InvalidParameter;
3617
3618     if (palette->Count > image->palette_size)
3619     {
3620         ARGB *new_palette;
3621
3622         new_palette = GdipAlloc(sizeof(ARGB) * palette->Count);
3623         if (!new_palette) return OutOfMemory;
3624
3625         GdipFree(image->palette_entries);
3626         image->palette_entries = new_palette;
3627         image->palette_size = palette->Count;
3628     }
3629
3630     image->palette_flags = palette->Flags;
3631     image->palette_count = palette->Count;
3632     memcpy(image->palette_entries, palette->Entries, sizeof(ARGB)*palette->Count);
3633
3634     return Ok;
3635 }
3636
3637 /*************************************************************************
3638  * Encoders -
3639  *   Structures that represent which formats we support for encoding.
3640  */
3641
3642 /* ImageCodecInfo creation routines taken from libgdiplus */
3643 static const WCHAR bmp_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}; /* Built-in BMP */
3644 static const WCHAR bmp_extension[] = {'*','.','B', 'M', 'P',';', '*','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}; /* *.BMP;*.DIB;*.RLE */
3645 static const WCHAR bmp_mimetype[] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}; /* image/bmp */
3646 static const WCHAR bmp_format[] = {'B', 'M', 'P', 0}; /* BMP */
3647 static const BYTE bmp_sig_pattern[] = { 0x42, 0x4D };
3648 static const BYTE bmp_sig_mask[] = { 0xFF, 0xFF };
3649
3650 static const WCHAR jpeg_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'J','P','E','G', 0};
3651 static const WCHAR jpeg_extension[] = {'*','.','J','P','G',';', '*','.','J','P','E','G',';', '*','.','J','P','E',';', '*','.','J','F','I','F',0};
3652 static const WCHAR jpeg_mimetype[] = {'i','m','a','g','e','/','j','p','e','g', 0};
3653 static const WCHAR jpeg_format[] = {'J','P','E','G',0};
3654 static const BYTE jpeg_sig_pattern[] = { 0xFF, 0xD8 };
3655 static const BYTE jpeg_sig_mask[] = { 0xFF, 0xFF };
3656
3657 static const WCHAR gif_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'G','I','F', 0};
3658 static const WCHAR gif_extension[] = {'*','.','G','I','F',0};
3659 static const WCHAR gif_mimetype[] = {'i','m','a','g','e','/','g','i','f', 0};
3660 static const WCHAR gif_format[] = {'G','I','F',0};
3661 static const BYTE gif_sig_pattern[4] = "GIF8";
3662 static const BYTE gif_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
3663
3664 static const WCHAR tiff_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'T','I','F','F', 0};
3665 static const WCHAR tiff_extension[] = {'*','.','T','I','F','F',';','*','.','T','I','F',0};
3666 static const WCHAR tiff_mimetype[] = {'i','m','a','g','e','/','t','i','f','f', 0};
3667 static const WCHAR tiff_format[] = {'T','I','F','F',0};
3668 static const BYTE tiff_sig_pattern[] = {0x49,0x49,42,0,0x4d,0x4d,0,42};
3669 static const BYTE tiff_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
3670
3671 static const WCHAR emf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'E','M','F', 0};
3672 static const WCHAR emf_extension[] = {'*','.','E','M','F',0};
3673 static const WCHAR emf_mimetype[] = {'i','m','a','g','e','/','x','-','e','m','f', 0};
3674 static const WCHAR emf_format[] = {'E','M','F',0};
3675 static const BYTE emf_sig_pattern[] = { 0x01, 0x00, 0x00, 0x00 };
3676 static const BYTE emf_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
3677
3678 static const WCHAR wmf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'W','M','F', 0};
3679 static const WCHAR wmf_extension[] = {'*','.','W','M','F',0};
3680 static const WCHAR wmf_mimetype[] = {'i','m','a','g','e','/','x','-','w','m','f', 0};
3681 static const WCHAR wmf_format[] = {'W','M','F',0};
3682 static const BYTE wmf_sig_pattern[] = { 0xd7, 0xcd };
3683 static const BYTE wmf_sig_mask[] = { 0xFF, 0xFF };
3684
3685 static const WCHAR png_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'P','N','G', 0};
3686 static const WCHAR png_extension[] = {'*','.','P','N','G',0};
3687 static const WCHAR png_mimetype[] = {'i','m','a','g','e','/','p','n','g', 0};
3688 static const WCHAR png_format[] = {'P','N','G',0};
3689 static const BYTE png_sig_pattern[] = { 137, 80, 78, 71, 13, 10, 26, 10, };
3690 static const BYTE png_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
3691
3692 static const WCHAR ico_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'I','C','O', 0};
3693 static const WCHAR ico_extension[] = {'*','.','I','C','O',0};
3694 static const WCHAR ico_mimetype[] = {'i','m','a','g','e','/','x','-','i','c','o','n', 0};
3695 static const WCHAR ico_format[] = {'I','C','O',0};
3696 static const BYTE ico_sig_pattern[] = { 0x00, 0x00, 0x01, 0x00 };
3697 static const BYTE ico_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
3698
3699 static const struct image_codec codecs[NUM_CODECS] = {
3700     {
3701         { /* BMP */
3702             /* Clsid */              { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3703             /* FormatID */           { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3704             /* CodecName */          bmp_codecname,
3705             /* DllName */            NULL,
3706             /* FormatDescription */  bmp_format,
3707             /* FilenameExtension */  bmp_extension,
3708             /* MimeType */           bmp_mimetype,
3709             /* Flags */              ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3710             /* Version */            1,
3711             /* SigCount */           1,
3712             /* SigSize */            2,
3713             /* SigPattern */         bmp_sig_pattern,
3714             /* SigMask */            bmp_sig_mask,
3715         },
3716         encode_image_BMP,
3717         decode_image_bmp
3718     },
3719     {
3720         { /* JPEG */
3721             /* Clsid */              { 0x557cf401, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3722             /* FormatID */           { 0xb96b3caeU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3723             /* CodecName */          jpeg_codecname,
3724             /* DllName */            NULL,
3725             /* FormatDescription */  jpeg_format,
3726             /* FilenameExtension */  jpeg_extension,
3727             /* MimeType */           jpeg_mimetype,
3728             /* Flags */              ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3729             /* Version */            1,
3730             /* SigCount */           1,
3731             /* SigSize */            2,
3732             /* SigPattern */         jpeg_sig_pattern,
3733             /* SigMask */            jpeg_sig_mask,
3734         },
3735         encode_image_jpeg,
3736         decode_image_jpeg
3737     },
3738     {
3739         { /* GIF */
3740             /* Clsid */              { 0x557cf402, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3741             /* FormatID */           { 0xb96b3cb0U, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3742             /* CodecName */          gif_codecname,
3743             /* DllName */            NULL,
3744             /* FormatDescription */  gif_format,
3745             /* FilenameExtension */  gif_extension,
3746             /* MimeType */           gif_mimetype,
3747             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3748             /* Version */            1,
3749             /* SigCount */           1,
3750             /* SigSize */            4,
3751             /* SigPattern */         gif_sig_pattern,
3752             /* SigMask */            gif_sig_mask,
3753         },
3754         NULL,
3755         decode_image_gif
3756     },
3757     {
3758         { /* TIFF */
3759             /* Clsid */              { 0x557cf405, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3760             /* FormatID */           { 0xb96b3cb1U, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3761             /* CodecName */          tiff_codecname,
3762             /* DllName */            NULL,
3763             /* FormatDescription */  tiff_format,
3764             /* FilenameExtension */  tiff_extension,
3765             /* MimeType */           tiff_mimetype,
3766             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsEncoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3767             /* Version */            1,
3768             /* SigCount */           2,
3769             /* SigSize */            4,
3770             /* SigPattern */         tiff_sig_pattern,
3771             /* SigMask */            tiff_sig_mask,
3772         },
3773         encode_image_tiff,
3774         decode_image_tiff
3775     },
3776     {
3777         { /* EMF */
3778             /* Clsid */              { 0x557cf403, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3779             /* FormatID */           { 0xb96b3cacU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3780             /* CodecName */          emf_codecname,
3781             /* DllName */            NULL,
3782             /* FormatDescription */  emf_format,
3783             /* FilenameExtension */  emf_extension,
3784             /* MimeType */           emf_mimetype,
3785             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
3786             /* Version */            1,
3787             /* SigCount */           1,
3788             /* SigSize */            4,
3789             /* SigPattern */         emf_sig_pattern,
3790             /* SigMask */            emf_sig_mask,
3791         },
3792         NULL,
3793         decode_image_olepicture_metafile
3794     },
3795     {
3796         { /* WMF */
3797             /* Clsid */              { 0x557cf404, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3798             /* FormatID */           { 0xb96b3cadU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3799             /* CodecName */          wmf_codecname,
3800             /* DllName */            NULL,
3801             /* FormatDescription */  wmf_format,
3802             /* FilenameExtension */  wmf_extension,
3803             /* MimeType */           wmf_mimetype,
3804             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
3805             /* Version */            1,
3806             /* SigCount */           1,
3807             /* SigSize */            2,
3808             /* SigPattern */         wmf_sig_pattern,
3809             /* SigMask */            wmf_sig_mask,
3810         },
3811         NULL,
3812         decode_image_olepicture_metafile
3813     },
3814     {
3815         { /* PNG */
3816             /* Clsid */              { 0x557cf406, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3817             /* FormatID */           { 0xb96b3cafU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3818             /* CodecName */          png_codecname,
3819             /* DllName */            NULL,
3820             /* FormatDescription */  png_format,
3821             /* FilenameExtension */  png_extension,
3822             /* MimeType */           png_mimetype,
3823             /* Flags */              ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3824             /* Version */            1,
3825             /* SigCount */           1,
3826             /* SigSize */            8,
3827             /* SigPattern */         png_sig_pattern,
3828             /* SigMask */            png_sig_mask,
3829         },
3830         encode_image_png,
3831         decode_image_png
3832     },
3833     {
3834         { /* ICO */
3835             /* Clsid */              { 0x557cf407, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3836             /* FormatID */           { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3837             /* CodecName */          ico_codecname,
3838             /* DllName */            NULL,
3839             /* FormatDescription */  ico_format,
3840             /* FilenameExtension */  ico_extension,
3841             /* MimeType */           ico_mimetype,
3842             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3843             /* Version */            1,
3844             /* SigCount */           1,
3845             /* SigSize */            4,
3846             /* SigPattern */         ico_sig_pattern,
3847             /* SigMask */            ico_sig_mask,
3848         },
3849         NULL,
3850         decode_image_icon
3851     },
3852 };
3853
3854 /*****************************************************************************
3855  * GdipGetImageDecodersSize [GDIPLUS.@]
3856  */
3857 GpStatus WINGDIPAPI GdipGetImageDecodersSize(UINT *numDecoders, UINT *size)
3858 {
3859     int decoder_count=0;
3860     int i;
3861     TRACE("%p %p\n", numDecoders, size);
3862
3863     if (!numDecoders || !size)
3864         return InvalidParameter;
3865
3866     for (i=0; i<NUM_CODECS; i++)
3867     {
3868         if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
3869             decoder_count++;
3870     }
3871
3872     *numDecoders = decoder_count;
3873     *size = decoder_count * sizeof(ImageCodecInfo);
3874
3875     return Ok;
3876 }
3877
3878 /*****************************************************************************
3879  * GdipGetImageDecoders [GDIPLUS.@]
3880  */
3881 GpStatus WINGDIPAPI GdipGetImageDecoders(UINT numDecoders, UINT size, ImageCodecInfo *decoders)
3882 {
3883     int i, decoder_count=0;
3884     TRACE("%u %u %p\n", numDecoders, size, decoders);
3885
3886     if (!decoders ||
3887         size != numDecoders * sizeof(ImageCodecInfo))
3888         return GenericError;
3889
3890     for (i=0; i<NUM_CODECS; i++)
3891     {
3892         if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
3893         {
3894             if (decoder_count == numDecoders) return GenericError;
3895             memcpy(&decoders[decoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
3896             decoder_count++;
3897         }
3898     }
3899
3900     if (decoder_count < numDecoders) return GenericError;
3901
3902     return Ok;
3903 }
3904
3905 /*****************************************************************************
3906  * GdipGetImageEncodersSize [GDIPLUS.@]
3907  */
3908 GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size)
3909 {
3910     int encoder_count=0;
3911     int i;
3912     TRACE("%p %p\n", numEncoders, size);
3913
3914     if (!numEncoders || !size)
3915         return InvalidParameter;
3916
3917     for (i=0; i<NUM_CODECS; i++)
3918     {
3919         if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
3920             encoder_count++;
3921     }
3922
3923     *numEncoders = encoder_count;
3924     *size = encoder_count * sizeof(ImageCodecInfo);
3925
3926     return Ok;
3927 }
3928
3929 /*****************************************************************************
3930  * GdipGetImageEncoders [GDIPLUS.@]
3931  */
3932 GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
3933 {
3934     int i, encoder_count=0;
3935     TRACE("%u %u %p\n", numEncoders, size, encoders);
3936
3937     if (!encoders ||
3938         size != numEncoders * sizeof(ImageCodecInfo))
3939         return GenericError;
3940
3941     for (i=0; i<NUM_CODECS; i++)
3942     {
3943         if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
3944         {
3945             if (encoder_count == numEncoders) return GenericError;
3946             memcpy(&encoders[encoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
3947             encoder_count++;
3948         }
3949     }
3950
3951     if (encoder_count < numEncoders) return GenericError;
3952
3953     return Ok;
3954 }
3955
3956 GpStatus WINGDIPAPI GdipGetEncoderParameterListSize(GpImage *image,
3957     GDIPCONST CLSID* clsidEncoder, UINT *size)
3958 {
3959     static int calls;
3960
3961     TRACE("(%p,%s,%p)\n", image, debugstr_guid(clsidEncoder), size);
3962
3963     if(!(calls++))
3964         FIXME("not implemented\n");
3965
3966     *size = 0;
3967
3968     return NotImplemented;
3969 }
3970
3971 static PixelFormat get_16bpp_format(HBITMAP hbm)
3972 {
3973     BITMAPV4HEADER bmh;
3974     HDC hdc;
3975     PixelFormat result;
3976
3977     hdc = CreateCompatibleDC(NULL);
3978
3979     memset(&bmh, 0, sizeof(bmh));
3980     bmh.bV4Size = sizeof(bmh);
3981     bmh.bV4Width = 1;
3982     bmh.bV4Height = 1;
3983     bmh.bV4V4Compression = BI_BITFIELDS;
3984     bmh.bV4BitCount = 16;
3985
3986     GetDIBits(hdc, hbm, 0, 0, NULL, (BITMAPINFO*)&bmh, DIB_RGB_COLORS);
3987
3988     if (bmh.bV4RedMask == 0x7c00 &&
3989         bmh.bV4GreenMask == 0x3e0 &&
3990         bmh.bV4BlueMask == 0x1f)
3991     {
3992         result = PixelFormat16bppRGB555;
3993     }
3994     else if (bmh.bV4RedMask == 0xf800 &&
3995         bmh.bV4GreenMask == 0x7e0 &&
3996         bmh.bV4BlueMask == 0x1f)
3997     {
3998         result = PixelFormat16bppRGB565;
3999     }
4000     else
4001     {
4002         FIXME("unrecognized bitfields %x,%x,%x\n", bmh.bV4RedMask,
4003             bmh.bV4GreenMask, bmh.bV4BlueMask);
4004         result = PixelFormatUndefined;
4005     }
4006
4007     DeleteDC(hdc);
4008
4009     return result;
4010 }
4011
4012 /*****************************************************************************
4013  * GdipCreateBitmapFromHBITMAP [GDIPLUS.@]
4014  */
4015 GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap)
4016 {
4017     BITMAP bm;
4018     GpStatus retval;
4019     PixelFormat format;
4020     BitmapData lockeddata;
4021     INT y;
4022
4023     TRACE("%p %p %p\n", hbm, hpal, bitmap);
4024
4025     if(!hbm || !bitmap)
4026         return InvalidParameter;
4027
4028     if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
4029             return InvalidParameter;
4030
4031     /* TODO: Figure out the correct format for 16, 32, 64 bpp */
4032     switch(bm.bmBitsPixel) {
4033         case 1:
4034             format = PixelFormat1bppIndexed;
4035             break;
4036         case 4:
4037             format = PixelFormat4bppIndexed;
4038             break;
4039         case 8:
4040             format = PixelFormat8bppIndexed;
4041             break;
4042         case 16:
4043             format = get_16bpp_format(hbm);
4044             if (format == PixelFormatUndefined)
4045                 return InvalidParameter;
4046             break;
4047         case 24:
4048             format = PixelFormat24bppRGB;
4049             break;
4050         case 32:
4051             format = PixelFormat32bppRGB;
4052             break;
4053         case 48:
4054             format = PixelFormat48bppRGB;
4055             break;
4056         default:
4057             FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
4058             return InvalidParameter;
4059     }
4060
4061     retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, 0,
4062         format, NULL, bitmap);
4063
4064     if (retval == Ok)
4065     {
4066         retval = GdipBitmapLockBits(*bitmap, NULL, ImageLockModeWrite,
4067             format, &lockeddata);
4068         if (retval == Ok)
4069         {
4070             if (bm.bmBits)
4071             {
4072                 for (y=0; y<bm.bmHeight; y++)
4073                 {
4074                     memcpy((BYTE*)lockeddata.Scan0+lockeddata.Stride*y,
4075                            (BYTE*)bm.bmBits+bm.bmWidthBytes*(bm.bmHeight-1-y),
4076                            bm.bmWidthBytes);
4077                 }
4078             }
4079             else
4080             {
4081                 HDC hdc;
4082                 HBITMAP oldhbm;
4083                 BITMAPINFO *pbmi;
4084                 INT src_height, dst_stride;
4085                 BYTE *dst_bits;
4086
4087                 hdc = CreateCompatibleDC(NULL);
4088                 oldhbm = SelectObject(hdc, hbm);
4089
4090                 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
4091
4092                 if (pbmi)
4093                 {
4094                     pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
4095                     pbmi->bmiHeader.biBitCount = 0;
4096
4097                     GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
4098
4099                     src_height = abs(pbmi->bmiHeader.biHeight);
4100
4101                     if (pbmi->bmiHeader.biHeight > 0)
4102                     {
4103                         dst_bits = (BYTE*)lockeddata.Scan0+lockeddata.Stride*(src_height-1);
4104                         dst_stride = -lockeddata.Stride;
4105                     }
4106                     else
4107                     {
4108                         dst_bits = lockeddata.Scan0;
4109                         dst_stride = lockeddata.Stride;
4110                     }
4111
4112                     for (y=0; y<src_height; y++)
4113                     {
4114                         GetDIBits(hdc, hbm, y, 1, dst_bits+dst_stride*y,
4115                             pbmi, DIB_RGB_COLORS);
4116                     }
4117
4118                     GdipFree(pbmi);
4119                 }
4120                 else
4121                     retval = OutOfMemory;
4122
4123                 SelectObject(hdc, oldhbm);
4124                 DeleteDC(hdc);
4125             }
4126
4127             GdipBitmapUnlockBits(*bitmap, &lockeddata);
4128         }
4129
4130         if (retval == Ok && hpal)
4131         {
4132             WORD num_palette_entries;
4133             PALETTEENTRY *palette_entries=NULL;
4134             ColorPalette *palette=NULL;
4135             int i;
4136
4137             if (!GetObjectW(hpal, sizeof(num_palette_entries), &num_palette_entries))
4138                 retval = GenericError;
4139
4140             if (retval == Ok)
4141             {
4142                 palette_entries = GdipAlloc(sizeof(PALETTEENTRY) * num_palette_entries);
4143                 palette = GdipAlloc(sizeof(ColorPalette) + sizeof(ARGB) * (num_palette_entries-1));
4144
4145                 if (!palette_entries || !palette)
4146                     retval = OutOfMemory;
4147             }
4148
4149             if (retval == Ok)
4150             {
4151                 if (!GetPaletteEntries(hpal, 0, num_palette_entries, palette_entries))
4152                     retval = GenericError;
4153             }
4154
4155             if (retval == Ok)
4156             {
4157                 palette->Flags = 0;
4158                 palette->Count = num_palette_entries;
4159
4160                 for (i=0; i<num_palette_entries; i++)
4161                 {
4162                     PALETTEENTRY * entry = &palette_entries[i];
4163                     palette->Entries[i] = 0xff000000 | entry->peRed << 16 |
4164                         entry->peGreen << 8 | entry->peBlue;
4165                 }
4166
4167                 retval = GdipSetImagePalette((GpImage*)*bitmap, palette);
4168             }
4169
4170             GdipFree(palette_entries);
4171             GdipFree(palette);
4172         }
4173
4174         if (retval != Ok)
4175         {
4176             GdipDisposeImage((GpImage*)*bitmap);
4177             *bitmap = NULL;
4178         }
4179     }
4180
4181     return retval;
4182 }
4183
4184 GpStatus WINGDIPAPI GdipDeleteEffect(CGpEffect *effect)
4185 {
4186     FIXME("(%p): stub\n", effect);
4187     /* note: According to Jose Roca's GDI+ Docs, this is not implemented
4188      * in Windows's gdiplus */
4189     return NotImplemented;
4190 }
4191
4192 /*****************************************************************************
4193  * GdipSetEffectParameters [GDIPLUS.@]
4194  */
4195 GpStatus WINGDIPAPI GdipSetEffectParameters(CGpEffect *effect,
4196     const VOID *params, const UINT size)
4197 {
4198     static int calls;
4199
4200     TRACE("(%p,%p,%u)\n", effect, params, size);
4201
4202     if(!(calls++))
4203         FIXME("not implemented\n");
4204
4205     return NotImplemented;
4206 }
4207
4208 /*****************************************************************************
4209  * GdipGetImageFlags [GDIPLUS.@]
4210  */
4211 GpStatus WINGDIPAPI GdipGetImageFlags(GpImage *image, UINT *flags)
4212 {
4213     TRACE("%p %p\n", image, flags);
4214
4215     if(!image || !flags)
4216         return InvalidParameter;
4217
4218     *flags = image->flags;
4219
4220     return Ok;
4221 }
4222
4223 GpStatus WINGDIPAPI GdipTestControl(GpTestControlEnum control, void *param)
4224 {
4225     TRACE("(%d, %p)\n", control, param);
4226
4227     switch(control){
4228         case TestControlForceBilinear:
4229             if(param)
4230                 FIXME("TestControlForceBilinear not handled\n");
4231             break;
4232         case TestControlNoICM:
4233             if(param)
4234                 FIXME("TestControlNoICM not handled\n");
4235             break;
4236         case TestControlGetBuildNumber:
4237             *((DWORD*)param) = 3102;
4238             break;
4239     }
4240
4241     return Ok;
4242 }
4243
4244 GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR* fileName,
4245                             HDC hdc, EmfType type, GDIPCONST GpRectF *pFrameRect,
4246                             MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc,
4247                             GpMetafile **metafile)
4248 {
4249     FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
4250                                  frameUnit, debugstr_w(desc), metafile);
4251
4252     return NotImplemented;
4253 }
4254
4255 GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR* fileName, HDC hdc, EmfType type,
4256                             GDIPCONST GpRect *pFrameRect, MetafileFrameUnit frameUnit,
4257                             GDIPCONST WCHAR *desc, GpMetafile **metafile)
4258 {
4259     FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
4260                                  frameUnit, debugstr_w(desc), metafile);
4261
4262     return NotImplemented;
4263 }
4264
4265 GpStatus WINGDIPAPI GdipImageForceValidation(GpImage *image)
4266 {
4267     TRACE("%p\n", image);
4268
4269     return Ok;
4270 }
4271
4272 /*****************************************************************************
4273  * GdipGetImageThumbnail [GDIPLUS.@]
4274  */
4275 GpStatus WINGDIPAPI GdipGetImageThumbnail(GpImage *image, UINT width, UINT height,
4276                             GpImage **ret_image, GetThumbnailImageAbort cb,
4277                             VOID * cb_data)
4278 {
4279     GpStatus stat;
4280     GpGraphics *graphics;
4281     UINT srcwidth, srcheight;
4282
4283     TRACE("(%p %u %u %p %p %p)\n",
4284         image, width, height, ret_image, cb, cb_data);
4285
4286     if (!image || !ret_image)
4287         return InvalidParameter;
4288
4289     if (!width) width = 120;
4290     if (!height) height = 120;
4291
4292     GdipGetImageWidth(image, &srcwidth);
4293     GdipGetImageHeight(image, &srcheight);
4294
4295     stat = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppARGB,
4296         NULL, (GpBitmap**)ret_image);
4297
4298     if (stat == Ok)
4299     {
4300         stat = GdipGetImageGraphicsContext(*ret_image, &graphics);
4301
4302         if (stat == Ok)
4303         {
4304             stat = GdipDrawImageRectRectI(graphics, image,
4305                 0, 0, width, height, 0, 0, srcwidth, srcheight, UnitPixel,
4306                 NULL, NULL, NULL);
4307
4308             GdipDeleteGraphics(graphics);
4309         }
4310
4311         if (stat != Ok)
4312         {
4313             GdipDisposeImage(*ret_image);
4314             *ret_image = NULL;
4315         }
4316     }
4317
4318     return stat;
4319 }
4320
4321 /*****************************************************************************
4322  * GdipImageRotateFlip [GDIPLUS.@]
4323  */
4324 GpStatus WINGDIPAPI GdipImageRotateFlip(GpImage *image, RotateFlipType type)
4325 {
4326     GpBitmap *new_bitmap;
4327     GpBitmap *bitmap;
4328     int bpp, bytesperpixel;
4329     int rotate_90, flip_x, flip_y;
4330     int src_x_offset, src_y_offset;
4331     LPBYTE src_origin;
4332     UINT x, y, width, height;
4333     BitmapData src_lock, dst_lock;
4334     GpStatus stat;
4335
4336     TRACE("(%p, %u)\n", image, type);
4337
4338     if (!image)
4339         return InvalidParameter;
4340
4341     rotate_90 = type&1;
4342     flip_x = (type&6) == 2 || (type&6) == 4;
4343     flip_y = (type&3) == 1 || (type&3) == 2;
4344
4345     if (image->type != ImageTypeBitmap)
4346     {
4347         FIXME("Not implemented for type %i\n", image->type);
4348         return NotImplemented;
4349     }
4350
4351     bitmap = (GpBitmap*)image;
4352     bpp = PIXELFORMATBPP(bitmap->format);
4353
4354     if (bpp < 8)
4355     {
4356         FIXME("Not implemented for %i bit images\n", bpp);
4357         return NotImplemented;
4358     }
4359
4360     if (rotate_90)
4361     {
4362         width = bitmap->height;
4363         height = bitmap->width;
4364     }
4365     else
4366     {
4367         width = bitmap->width;
4368         height = bitmap->height;
4369     }
4370
4371     bytesperpixel = bpp/8;
4372
4373     stat = GdipCreateBitmapFromScan0(width, height, 0, bitmap->format, NULL, &new_bitmap);
4374
4375     if (stat != Ok)
4376         return stat;
4377
4378     stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, bitmap->format, &src_lock);
4379
4380     if (stat == Ok)
4381     {
4382         stat = GdipBitmapLockBits(new_bitmap, NULL, ImageLockModeWrite, bitmap->format, &dst_lock);
4383
4384         if (stat == Ok)
4385         {
4386             LPBYTE src_row, src_pixel;
4387             LPBYTE dst_row, dst_pixel;
4388
4389             src_origin = src_lock.Scan0;
4390             if (flip_x) src_origin += bytesperpixel * (bitmap->width - 1);
4391             if (flip_y) src_origin += src_lock.Stride * (bitmap->height - 1);
4392
4393             if (rotate_90)
4394             {
4395                 if (flip_y) src_x_offset = -src_lock.Stride;
4396                 else src_x_offset = src_lock.Stride;
4397                 if (flip_x) src_y_offset = -bytesperpixel;
4398                 else src_y_offset = bytesperpixel;
4399             }
4400             else
4401             {
4402                 if (flip_x) src_x_offset = -bytesperpixel;
4403                 else src_x_offset = bytesperpixel;
4404                 if (flip_y) src_y_offset = -src_lock.Stride;
4405                 else src_y_offset = src_lock.Stride;
4406             }
4407
4408             src_row = src_origin;
4409             dst_row = dst_lock.Scan0;
4410             for (y=0; y<height; y++)
4411             {
4412                 src_pixel = src_row;
4413                 dst_pixel = dst_row;
4414                 for (x=0; x<width; x++)
4415                 {
4416                     /* FIXME: This could probably be faster without memcpy. */
4417                     memcpy(dst_pixel, src_pixel, bytesperpixel);
4418                     dst_pixel += bytesperpixel;
4419                     src_pixel += src_x_offset;
4420                 }
4421                 src_row += src_y_offset;
4422                 dst_row += dst_lock.Stride;
4423             }
4424
4425             GdipBitmapUnlockBits(new_bitmap, &dst_lock);
4426         }
4427
4428         GdipBitmapUnlockBits(bitmap, &src_lock);
4429     }
4430
4431     if (stat == Ok)
4432         move_bitmap(bitmap, new_bitmap, FALSE);
4433     else
4434         GdipDisposeImage((GpImage*)new_bitmap);
4435
4436     return stat;
4437 }
4438
4439 /*****************************************************************************
4440  * GdipConvertToEmfPlusToFile [GDIPLUS.@]
4441  */
4442
4443 GpStatus WINGDIPAPI GdipConvertToEmfPlusToFile(const GpGraphics* refGraphics,
4444                                                GpMetafile* metafile, BOOL* conversionSuccess,
4445                                                const WCHAR* filename, EmfType emfType,
4446                                                const WCHAR* description, GpMetafile** out_metafile)
4447 {
4448     FIXME("stub: %p, %p, %p, %p, %u, %p, %p\n", refGraphics, metafile, conversionSuccess, filename, emfType, description, out_metafile);
4449     return NotImplemented;
4450 }