git.oblomov.eu Git - wine/blob - dlls/gdiplus/image.c

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