dlls/windowscodecs/converter.c

   1 /*
   2  * Copyright 2009 Vincent Povirk
   3  * Copyright 2016 Dmitry Timoshkov
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "config.h"
  21
  22 #include <stdarg.h>
  23 #include <math.h>
  24
  25 #define COBJMACROS
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "objbase.h"
  30
  31 #include "wincodecs_private.h"
  32
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  36
  37 struct FormatConverter;
  38
  39 enum pixelformat {
  40     format_1bppIndexed,
  41     format_2bppIndexed,
  42     format_4bppIndexed,
  43     format_8bppIndexed,
  44     format_BlackWhite,
  45     format_2bppGray,
  46     format_4bppGray,
  47     format_8bppGray,
  48     format_16bppGray,
  49     format_16bppBGR555,
  50     format_16bppBGR565,
  51     format_16bppBGRA5551,
  52     format_24bppBGR,
  53     format_24bppRGB,
  54     format_32bppGrayFloat,
  55     format_32bppBGR,
  56     format_32bppBGRA,
  57     format_32bppPBGRA,
  58     format_48bppRGB,
  59     format_64bppRGBA,
  60     format_32bppCMYK,
  61 };
  62
  63 typedef HRESULT (*copyfunc)(struct FormatConverter *This, const WICRect *prc,
  64     UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format);
  65
  66 struct pixelformatinfo {
  67     enum pixelformat format;
  68     const WICPixelFormatGUID *guid;
  69     copyfunc copy_function;
  70 };
  71
  72 typedef struct FormatConverter {
  73     IWICFormatConverter IWICFormatConverter_iface;
  74     LONG ref;
  75     IWICBitmapSource *source;
  76     const struct pixelformatinfo *dst_format, *src_format;
  77     WICBitmapDitherType dither;
  78     double alpha_threshold;
  79     WICBitmapPaletteType palette_type;
  80     CRITICAL_SECTION lock; /* must be held when initialized */
  81 } FormatConverter;
  82
  83 /* https://www.w3.org/Graphics/Color/srgb */
  84 static inline float from_sRGB_component(float f)
  85 {
  86     if (f <= 0.04045f) return f / 12.92f;
  87     return powf((f + 0.055f) / 1.055f, 2.4f);
  88 }
  89
  90 static inline float to_sRGB_component(float f)
  91 {
  92     if (f <= 0.0031308f) return 12.92f * f;
  93     return 1.055f * powf(f, 1.0f/2.4f) - 0.055f;
  94 }
  95
  96 #if 0 /* FIXME: enable once needed */
  97 static void from_sRGB(BYTE *bgr)
  98 {
  99     float r, g, b;
 100
 101     r = bgr[2] / 255.0f;
 102     g = bgr[1] / 255.0f;
 103     b = bgr[0] / 255.0f;
 104
 105     r = from_sRGB_component(r);
 106     g = from_sRGB_component(g);
 107     b = from_sRGB_component(b);
 108
 109     bgr[2] = (BYTE)(r * 255.0f);
 110     bgr[1] = (BYTE)(g * 255.0f);
 111     bgr[0] = (BYTE)(b * 255.0f);
 112 }
 113
 114 static void to_sRGB(BYTE *bgr)
 115 {
 116     float r, g, b;
 117
 118     r = bgr[2] / 255.0f;
 119     g = bgr[1] / 255.0f;
 120     b = bgr[0] / 255.0f;
 121
 122     r = to_sRGB_component(r);
 123     g = to_sRGB_component(g);
 124     b = to_sRGB_component(b);
 125
 126     bgr[2] = (BYTE)(r * 255.0f);
 127     bgr[1] = (BYTE)(g * 255.0f);
 128     bgr[0] = (BYTE)(b * 255.0f);
 129 }
 130 #endif
 131
 132 static inline FormatConverter *impl_from_IWICFormatConverter(IWICFormatConverter *iface)
 133 {
 134     return CONTAINING_RECORD(iface, FormatConverter, IWICFormatConverter_iface);
 135 }
 136
 137 static HRESULT copypixels_to_32bppBGRA(struct FormatConverter *This, const WICRect *prc,
 138     UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
 139 {
 140     switch (source_format)
 141     {
 142     case format_1bppIndexed:
 143     case format_BlackWhite:
 144         if (prc)
 145         {
 146             HRESULT res;
 147             INT x, y;
 148             BYTE *srcdata;
 149             UINT srcstride, srcdatasize;
 150             const BYTE *srcrow;
 151             const BYTE *srcbyte;
 152             BYTE *dstrow;
 153             DWORD *dstpixel;
 154             WICColor colors[2];
 155             IWICPalette *palette;
 156             UINT actualcolors;
 157
 158             res = PaletteImpl_Create(&palette);
 159             if (FAILED(res)) return res;
 160
 161             if (source_format == format_1bppIndexed)
 162                 res = IWICBitmapSource_CopyPalette(This->source, palette);
 163             else
 164                 res = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedBW, FALSE);
 165
 166             if (SUCCEEDED(res))
 167                 res = IWICPalette_GetColors(palette, 2, colors, &actualcolors);
 168
 169             IWICPalette_Release(palette);
 170             if (FAILED(res)) return res;
 171
 172             srcstride = (prc->Width+7)/8;
 173             srcdatasize = srcstride * prc->Height;
 174
 175             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
 176             if (!srcdata) return E_OUTOFMEMORY;
 177
 178             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 179
 180             if (SUCCEEDED(res))
 181             {
 182                 srcrow = srcdata;
 183                 dstrow = pbBuffer;
 184                 for (y=0; y<prc->Height; y++) {
 185                     srcbyte = srcrow;
 186                     dstpixel=(DWORD*)dstrow;
 187                     for (x=0; x<prc->Width; x+=8) {
 188                         BYTE srcval;
 189                         srcval=*srcbyte++;
 190                         *dstpixel++ = colors[srcval>>7&1];
 191                         if (x+1 < prc->Width) *dstpixel++ = colors[srcval>>6&1];
 192                         if (x+2 < prc->Width) *dstpixel++ = colors[srcval>>5&1];
 193                         if (x+3 < prc->Width) *dstpixel++ = colors[srcval>>4&1];
 194                         if (x+4 < prc->Width) *dstpixel++ = colors[srcval>>3&1];
 195                         if (x+5 < prc->Width) *dstpixel++ = colors[srcval>>2&1];
 196                         if (x+6 < prc->Width) *dstpixel++ = colors[srcval>>1&1];
 197                         if (x+7 < prc->Width) *dstpixel++ = colors[srcval&1];
 198                     }
 199                     srcrow += srcstride;
 200                     dstrow += cbStride;
 201                 }
 202             }
 203
 204             HeapFree(GetProcessHeap(), 0, srcdata);
 205
 206             return res;
 207         }
 208         return S_OK;
 209     case format_2bppIndexed:
 210     case format_2bppGray:
 211         if (prc)
 212         {
 213             HRESULT res;
 214             INT x, y;
 215             BYTE *srcdata;
 216             UINT srcstride, srcdatasize;
 217             const BYTE *srcrow;
 218             const BYTE *srcbyte;
 219             BYTE *dstrow;
 220             DWORD *dstpixel;
 221             WICColor colors[4];
 222             IWICPalette *palette;
 223             UINT actualcolors;
 224
 225             res = PaletteImpl_Create(&palette);
 226             if (FAILED(res)) return res;
 227
 228             if (source_format == format_2bppIndexed)
 229                 res = IWICBitmapSource_CopyPalette(This->source, palette);
 230             else
 231                 res = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray4, FALSE);
 232
 233             if (SUCCEEDED(res))
 234                 res = IWICPalette_GetColors(palette, 4, colors, &actualcolors);
 235
 236             IWICPalette_Release(palette);
 237             if (FAILED(res)) return res;
 238
 239             srcstride = (prc->Width+3)/4;
 240             srcdatasize = srcstride * prc->Height;
 241
 242             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
 243             if (!srcdata) return E_OUTOFMEMORY;
 244
 245             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 246
 247             if (SUCCEEDED(res))
 248             {
 249                 srcrow = srcdata;
 250                 dstrow = pbBuffer;
 251                 for (y=0; y<prc->Height; y++) {
 252                     srcbyte = srcrow;
 253                     dstpixel=(DWORD*)dstrow;
 254                     for (x=0; x<prc->Width; x+=4) {
 255                         BYTE srcval;
 256                         srcval=*srcbyte++;
 257                         *dstpixel++ = colors[srcval>>6];
 258                         if (x+1 < prc->Width) *dstpixel++ = colors[srcval>>4&0x3];
 259                         if (x+2 < prc->Width) *dstpixel++ = colors[srcval>>2&0x3];
 260                         if (x+3 < prc->Width) *dstpixel++ = colors[srcval&0x3];
 261                     }
 262                     srcrow += srcstride;
 263                     dstrow += cbStride;
 264                 }
 265             }
 266
 267             HeapFree(GetProcessHeap(), 0, srcdata);
 268
 269             return res;
 270         }
 271         return S_OK;
 272     case format_4bppIndexed:
 273     case format_4bppGray:
 274         if (prc)
 275         {
 276             HRESULT res;
 277             INT x, y;
 278             BYTE *srcdata;
 279             UINT srcstride, srcdatasize;
 280             const BYTE *srcrow;
 281             const BYTE *srcbyte;
 282             BYTE *dstrow;
 283             DWORD *dstpixel;
 284             WICColor colors[16];
 285             IWICPalette *palette;
 286             UINT actualcolors;
 287
 288             res = PaletteImpl_Create(&palette);
 289             if (FAILED(res)) return res;
 290
 291             if (source_format == format_4bppIndexed)
 292                 res = IWICBitmapSource_CopyPalette(This->source, palette);
 293             else
 294                 res = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray16, FALSE);
 295
 296             if (SUCCEEDED(res))
 297                 res = IWICPalette_GetColors(palette, 16, colors, &actualcolors);
 298
 299             IWICPalette_Release(palette);
 300             if (FAILED(res)) return res;
 301
 302             srcstride = (prc->Width+1)/2;
 303             srcdatasize = srcstride * prc->Height;
 304
 305             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
 306             if (!srcdata) return E_OUTOFMEMORY;
 307
 308             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 309
 310             if (SUCCEEDED(res))
 311             {
 312                 srcrow = srcdata;
 313                 dstrow = pbBuffer;
 314                 for (y=0; y<prc->Height; y++) {
 315                     srcbyte = srcrow;
 316                     dstpixel=(DWORD*)dstrow;
 317                     for (x=0; x<prc->Width; x+=2) {
 318                         BYTE srcval;
 319                         srcval=*srcbyte++;
 320                         *dstpixel++ = colors[srcval>>4];
 321                         if (x+1 < prc->Width) *dstpixel++ = colors[srcval&0xf];
 322                     }
 323                     srcrow += srcstride;
 324                     dstrow += cbStride;
 325                 }
 326             }
 327
 328             HeapFree(GetProcessHeap(), 0, srcdata);
 329
 330             return res;
 331         }
 332         return S_OK;
 333     case format_8bppGray:
 334         if (prc)
 335         {
 336             HRESULT res;
 337             INT x, y;
 338             BYTE *srcdata;
 339             UINT srcstride, srcdatasize;
 340             const BYTE *srcrow;
 341             const BYTE *srcbyte;
 342             BYTE *dstrow;
 343             DWORD *dstpixel;
 344
 345             srcstride = prc->Width;
 346             srcdatasize = srcstride * prc->Height;
 347
 348             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
 349             if (!srcdata) return E_OUTOFMEMORY;
 350
 351             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 352
 353             if (SUCCEEDED(res))
 354             {
 355                 srcrow = srcdata;
 356                 dstrow = pbBuffer;
 357                 for (y=0; y<prc->Height; y++) {
 358                     srcbyte = srcrow;
 359                     dstpixel=(DWORD*)dstrow;
 360                     for (x=0; x<prc->Width; x++)
 361                     {
 362                         *dstpixel++ = 0xff000000|(*srcbyte<<16)|(*srcbyte<<8)|*srcbyte;
 363                         srcbyte++;
 364                     }
 365                     srcrow += srcstride;
 366                     dstrow += cbStride;
 367                 }
 368             }
 369
 370             HeapFree(GetProcessHeap(), 0, srcdata);
 371
 372             return res;
 373         }
 374         return S_OK;
 375     case format_8bppIndexed:
 376         if (prc)
 377         {
 378             HRESULT res;
 379             INT x, y;
 380             BYTE *srcdata;
 381             UINT srcstride, srcdatasize;
 382             const BYTE *srcrow;
 383             const BYTE *srcbyte;
 384             BYTE *dstrow;
 385             DWORD *dstpixel;
 386             WICColor colors[256];
 387             IWICPalette *palette;
 388             UINT actualcolors;
 389
 390             res = PaletteImpl_Create(&palette);
 391             if (FAILED(res)) return res;
 392
 393             res = IWICBitmapSource_CopyPalette(This->source, palette);
 394             if (SUCCEEDED(res))
 395                 res = IWICPalette_GetColors(palette, 256, colors, &actualcolors);
 396
 397             IWICPalette_Release(palette);
 398
 399             if (FAILED(res)) return res;
 400
 401             srcstride = prc->Width;
 402             srcdatasize = srcstride * prc->Height;
 403
 404             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
 405             if (!srcdata) return E_OUTOFMEMORY;
 406
 407             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 408
 409             if (SUCCEEDED(res))
 410             {
 411                 srcrow = srcdata;
 412                 dstrow = pbBuffer;
 413                 for (y=0; y<prc->Height; y++) {
 414                     srcbyte = srcrow;
 415                     dstpixel=(DWORD*)dstrow;
 416                     for (x=0; x<prc->Width; x++)
 417                         *dstpixel++ = colors[*srcbyte++];
 418                     srcrow += srcstride;
 419                     dstrow += cbStride;
 420                 }
 421             }
 422
 423             HeapFree(GetProcessHeap(), 0, srcdata);
 424
 425             return res;
 426         }
 427         return S_OK;
 428     case format_16bppGray:
 429         if (prc)
 430         {
 431             HRESULT res;
 432             INT x, y;
 433             BYTE *srcdata;
 434             UINT srcstride, srcdatasize;
 435             const BYTE *srcrow;
 436             const BYTE *srcbyte;
 437             BYTE *dstrow;
 438             DWORD *dstpixel;
 439
 440             srcstride = prc->Width * 2;
 441             srcdatasize = srcstride * prc->Height;
 442
 443             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
 444             if (!srcdata) return E_OUTOFMEMORY;
 445
 446             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 447
 448             if (SUCCEEDED(res))
 449             {
 450                 srcrow = srcdata;
 451                 dstrow = pbBuffer;
 452                 for (y=0; y<prc->Height; y++) {
 453                     srcbyte = srcrow;
 454                     dstpixel=(DWORD*)dstrow;
 455                     for (x=0; x<prc->Width; x++)
 456                     {
 457                         *dstpixel++ = 0xff000000|(*srcbyte<<16)|(*srcbyte<<8)|*srcbyte;
 458                         srcbyte+=2;
 459                     }
 460                     srcrow += srcstride;
 461                     dstrow += cbStride;
 462                 }
 463             }
 464
 465             HeapFree(GetProcessHeap(), 0, srcdata);
 466
 467             return res;
 468         }
 469         return S_OK;
 470     case format_16bppBGR555:
 471         if (prc)
 472         {
 473             HRESULT res;
 474             INT x, y;
 475             BYTE *srcdata;
 476             UINT srcstride, srcdatasize;
 477             const BYTE *srcrow;
 478             const WORD *srcpixel;
 479             BYTE *dstrow;
 480             DWORD *dstpixel;
 481
 482             srcstride = 2 * prc->Width;
 483             srcdatasize = srcstride * prc->Height;
 484
 485             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
 486             if (!srcdata) return E_OUTOFMEMORY;
 487
 488             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 489
 490             if (SUCCEEDED(res))
 491             {
 492                 srcrow = srcdata;
 493                 dstrow = pbBuffer;
 494                 for (y=0; y<prc->Height; y++) {
 495                     srcpixel=(const WORD*)srcrow;
 496                     dstpixel=(DWORD*)dstrow;
 497                     for (x=0; x<prc->Width; x++) {
 498                         WORD srcval;
 499                         srcval=*srcpixel++;
 500                         *dstpixel++=0xff000000 | /* constant 255 alpha */
 501                                     ((srcval << 9) & 0xf80000) | /* r */
 502                                     ((srcval << 4) & 0x070000) | /* r - 3 bits */
 503                                     ((srcval << 6) & 0x00f800) | /* g */
 504                                     ((srcval << 1) & 0x000700) | /* g - 3 bits */
 505                                     ((srcval << 3) & 0x0000f8) | /* b */
 506                                     ((srcval >> 2) & 0x000007);  /* b - 3 bits */
 507                     }
 508                     srcrow += srcstride;
 509                     dstrow += cbStride;
 510                 }
 511             }
 512
 513             HeapFree(GetProcessHeap(), 0, srcdata);
 514
 515             return res;
 516         }
 517         return S_OK;
 518     case format_16bppBGR565:
 519         if (prc)
 520         {
 521             HRESULT res;
 522             INT x, y;
 523             BYTE *srcdata;
 524             UINT srcstride, srcdatasize;
 525             const BYTE *srcrow;
 526             const WORD *srcpixel;
 527             BYTE *dstrow;
 528             DWORD *dstpixel;
 529
 530             srcstride = 2 * prc->Width;
 531             srcdatasize = srcstride * prc->Height;
 532
 533             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
 534             if (!srcdata) return E_OUTOFMEMORY;
 535
 536             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 537
 538             if (SUCCEEDED(res))
 539             {
 540                 srcrow = srcdata;
 541                 dstrow = pbBuffer;
 542                 for (y=0; y<prc->Height; y++) {
 543                     srcpixel=(const WORD*)srcrow;
 544                     dstpixel=(DWORD*)dstrow;
 545                     for (x=0; x<prc->Width; x++) {
 546                         WORD srcval;
 547                         srcval=*srcpixel++;
 548                         *dstpixel++=0xff000000 | /* constant 255 alpha */
 549                                     ((srcval << 8) & 0xf80000) | /* r */
 550                                     ((srcval << 3) & 0x070000) | /* r - 3 bits */
 551                                     ((srcval << 5) & 0x00fc00) | /* g */
 552                                     ((srcval >> 1) & 0x000300) | /* g - 2 bits */
 553                                     ((srcval << 3) & 0x0000f8) | /* b */
 554                                     ((srcval >> 2) & 0x000007);  /* b - 3 bits */
 555                     }
 556                     srcrow += srcstride;
 557                     dstrow += cbStride;
 558                 }
 559             }
 560
 561             HeapFree(GetProcessHeap(), 0, srcdata);
 562
 563             return res;
 564         }
 565         return S_OK;
 566     case format_16bppBGRA5551:
 567         if (prc)
 568         {
 569             HRESULT res;
 570             INT x, y;
 571             BYTE *srcdata;
 572             UINT srcstride, srcdatasize;
 573             const BYTE *srcrow;
 574             const WORD *srcpixel;
 575             BYTE *dstrow;
 576             DWORD *dstpixel;
 577
 578             srcstride = 2 * prc->Width;
 579             srcdatasize = srcstride * prc->Height;
 580
 581             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
 582             if (!srcdata) return E_OUTOFMEMORY;
 583
 584             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 585
 586             if (SUCCEEDED(res))
 587             {
 588                 srcrow = srcdata;
 589                 dstrow = pbBuffer;
 590                 for (y=0; y<prc->Height; y++) {
 591                     srcpixel=(const WORD*)srcrow;
 592                     dstpixel=(DWORD*)dstrow;
 593                     for (x=0; x<prc->Width; x++) {
 594                         WORD srcval;
 595                         srcval=*srcpixel++;
 596                         *dstpixel++=((srcval & 0x8000) ? 0xff000000 : 0) | /* alpha */
 597                                     ((srcval << 9) & 0xf80000) | /* r */
 598                                     ((srcval << 4) & 0x070000) | /* r - 3 bits */
 599                                     ((srcval << 6) & 0x00f800) | /* g */
 600                                     ((srcval << 1) & 0x000700) | /* g - 3 bits */
 601                                     ((srcval << 3) & 0x0000f8) | /* b */
 602                                     ((srcval >> 2) & 0x000007);  /* b - 3 bits */
 603                     }
 604                     srcrow += srcstride;
 605                     dstrow += cbStride;
 606                 }
 607             }
 608
 609             HeapFree(GetProcessHeap(), 0, srcdata);
 610
 611             return res;
 612         }
 613         return S_OK;
 614     case format_24bppBGR:
 615         if (prc)
 616         {
 617             HRESULT res;
 618             INT x, y;
 619             BYTE *srcdata;
 620             UINT srcstride, srcdatasize;
 621             const BYTE *srcrow;
 622             const BYTE *srcpixel;
 623             BYTE *dstrow;
 624             BYTE *dstpixel;
 625
 626             srcstride = 3 * prc->Width;
 627             srcdatasize = srcstride * prc->Height;
 628
 629             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
 630             if (!srcdata) return E_OUTOFMEMORY;
 631
 632             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 633
 634             if (SUCCEEDED(res))
 635             {
 636                 srcrow = srcdata;
 637                 dstrow = pbBuffer;
 638                 for (y=0; y<prc->Height; y++) {
 639                     srcpixel=srcrow;
 640                     dstpixel=dstrow;
 641                     for (x=0; x<prc->Width; x++) {
 642                         *dstpixel++=*srcpixel++; /* blue */
 643                         *dstpixel++=*srcpixel++; /* green */
 644                         *dstpixel++=*srcpixel++; /* red */
 645                         *dstpixel++=255; /* alpha */
 646                     }
 647                     srcrow += srcstride;
 648                     dstrow += cbStride;
 649                 }
 650             }
 651
 652             HeapFree(GetProcessHeap(), 0, srcdata);
 653
 654             return res;
 655         }
 656         return S_OK;
 657     case format_24bppRGB:
 658         if (prc)
 659         {
 660             HRESULT res;
 661             INT x, y;
 662             BYTE *srcdata;
 663             UINT srcstride, srcdatasize;
 664             const BYTE *srcrow;
 665             const BYTE *srcpixel;
 666             BYTE *dstrow;
 667             BYTE *dstpixel;
 668             BYTE tmppixel[3];
 669
 670             srcstride = 3 * prc->Width;
 671             srcdatasize = srcstride * prc->Height;
 672
 673             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
 674             if (!srcdata) return E_OUTOFMEMORY;
 675
 676             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 677
 678             if (SUCCEEDED(res))
 679             {
 680                 srcrow = srcdata;
 681                 dstrow = pbBuffer;
 682                 for (y=0; y<prc->Height; y++) {
 683                     srcpixel=srcrow;
 684                     dstpixel=dstrow;
 685                     for (x=0; x<prc->Width; x++) {
 686                         tmppixel[0]=*srcpixel++; /* red */
 687                         tmppixel[1]=*srcpixel++; /* green */
 688                         tmppixel[2]=*srcpixel++; /* blue */
 689
 690                         *dstpixel++=tmppixel[2]; /* blue */
 691                         *dstpixel++=tmppixel[1]; /* green */
 692                         *dstpixel++=tmppixel[0]; /* red */
 693                         *dstpixel++=255; /* alpha */
 694                     }
 695                     srcrow += srcstride;
 696                     dstrow += cbStride;
 697                 }
 698             }
 699
 700             HeapFree(GetProcessHeap(), 0, srcdata);
 701
 702             return res;
 703         }
 704         return S_OK;
 705     case format_32bppBGR:
 706         if (prc)
 707         {
 708             HRESULT res;
 709             INT x, y;
 710
 711             res = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
 712             if (FAILED(res)) return res;
 713
 714             /* set all alpha values to 255 */
 715             for (y=0; y<prc->Height; y++)
 716                 for (x=0; x<prc->Width; x++)
 717                     pbBuffer[cbStride*y+4*x+3] = 0xff;
 718         }
 719         return S_OK;
 720     case format_32bppBGRA:
 721         if (prc)
 722             return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
 723         return S_OK;
 724     case format_32bppPBGRA:
 725         if (prc)
 726         {
 727             HRESULT res;
 728             INT x, y;
 729
 730             res = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
 731             if (FAILED(res)) return res;
 732
 733             for (y=0; y<prc->Height; y++)
 734                 for (x=0; x<prc->Width; x++)
 735                 {
 736                     BYTE alpha = pbBuffer[cbStride*y+4*x+3];
 737                     if (alpha != 0 && alpha != 255)
 738                     {
 739                         pbBuffer[cbStride*y+4*x] = pbBuffer[cbStride*y+4*x] * 255 / alpha;
 740                         pbBuffer[cbStride*y+4*x+1] = pbBuffer[cbStride*y+4*x+1] * 255 / alpha;
 741                         pbBuffer[cbStride*y+4*x+2] = pbBuffer[cbStride*y+4*x+2] * 255 / alpha;
 742                     }
 743                 }
 744         }
 745         return S_OK;
 746     case format_48bppRGB:
 747         if (prc)
 748         {
 749             HRESULT res;
 750             INT x, y;
 751             BYTE *srcdata;
 752             UINT srcstride, srcdatasize;
 753             const BYTE *srcrow;
 754             const BYTE *srcpixel;
 755             BYTE *dstrow;
 756             DWORD *dstpixel;
 757
 758             srcstride = 6 * prc->Width;
 759             srcdatasize = srcstride * prc->Height;
 760
 761             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
 762             if (!srcdata) return E_OUTOFMEMORY;
 763
 764             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 765
 766             if (SUCCEEDED(res))
 767             {
 768                 srcrow = srcdata;
 769                 dstrow = pbBuffer;
 770                 for (y=0; y<prc->Height; y++) {
 771                     srcpixel=srcrow;
 772                     dstpixel=(DWORD*)dstrow;
 773                     for (x=0; x<prc->Width; x++) {
 774                         BYTE red, green, blue;
 775                         red = *srcpixel++; srcpixel++;
 776                         green = *srcpixel++; srcpixel++;
 777                         blue = *srcpixel++; srcpixel++;
 778                         *dstpixel++=0xff000000|red<<16|green<<8|blue;
 779                     }
 780                     srcrow += srcstride;
 781                     dstrow += cbStride;
 782                 }
 783             }
 784
 785             HeapFree(GetProcessHeap(), 0, srcdata);
 786
 787             return res;
 788         }
 789         return S_OK;
 790     case format_64bppRGBA:
 791         if (prc)
 792         {
 793             HRESULT res;
 794             INT x, y;
 795             BYTE *srcdata;
 796             UINT srcstride, srcdatasize;
 797             const BYTE *srcrow;
 798             const BYTE *srcpixel;
 799             BYTE *dstrow;
 800             DWORD *dstpixel;
 801
 802             srcstride = 8 * prc->Width;
 803             srcdatasize = srcstride * prc->Height;
 804
 805             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
 806             if (!srcdata) return E_OUTOFMEMORY;
 807
 808             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 809
 810             if (SUCCEEDED(res))
 811             {
 812                 srcrow = srcdata;
 813                 dstrow = pbBuffer;
 814                 for (y=0; y<prc->Height; y++) {
 815                     srcpixel=srcrow;
 816                     dstpixel=(DWORD*)dstrow;
 817                     for (x=0; x<prc->Width; x++) {
 818                         BYTE red, green, blue, alpha;
 819                         red = *srcpixel++; srcpixel++;
 820                         green = *srcpixel++; srcpixel++;
 821                         blue = *srcpixel++; srcpixel++;
 822                         alpha = *srcpixel++; srcpixel++;
 823                         *dstpixel++=alpha<<24|red<<16|green<<8|blue;
 824                     }
 825                     srcrow += srcstride;
 826                     dstrow += cbStride;
 827                 }
 828             }
 829
 830             HeapFree(GetProcessHeap(), 0, srcdata);
 831
 832             return res;
 833         }
 834         return S_OK;
 835     case format_32bppCMYK:
 836         if (prc)
 837         {
 838             HRESULT res;
 839             UINT x, y;
 840
 841             res = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
 842             if (FAILED(res)) return res;
 843
 844             for (y=0; y<prc->Height; y++)
 845                 for (x=0; x<prc->Width; x++)
 846                 {
 847                     BYTE *pixel = pbBuffer+cbStride*y+4*x;
 848                     BYTE c=pixel[0], m=pixel[1], y=pixel[2], k=pixel[3];
 849                     pixel[0] = (255-y)*(255-k)/255; /* blue */
 850                     pixel[1] = (255-m)*(255-k)/255; /* green */
 851                     pixel[2] = (255-c)*(255-k)/255; /* red */
 852                     pixel[3] = 255; /* alpha */
 853                 }
 854         }
 855         return S_OK;
 856     default:
 857         return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 858     }
 859 }
 860
 861 static HRESULT copypixels_to_32bppBGR(struct FormatConverter *This, const WICRect *prc,
 862     UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
 863 {
 864     switch (source_format)
 865     {
 866     case format_32bppBGR:
 867     case format_32bppBGRA:
 868     case format_32bppPBGRA:
 869         if (prc)
 870             return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
 871         return S_OK;
 872     default:
 873         return copypixels_to_32bppBGRA(This, prc, cbStride, cbBufferSize, pbBuffer, source_format);
 874     }
 875 }
 876
 877 static HRESULT copypixels_to_32bppPBGRA(struct FormatConverter *This, const WICRect *prc,
 878     UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
 879 {
 880     HRESULT hr;
 881
 882     switch (source_format)
 883     {
 884     case format_32bppPBGRA:
 885         if (prc)
 886             return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
 887         return S_OK;
 888     default:
 889         hr = copypixels_to_32bppBGRA(This, prc, cbStride, cbBufferSize, pbBuffer, source_format);
 890         if (SUCCEEDED(hr) && prc)
 891         {
 892             INT x, y;
 893
 894             for (y=0; y<prc->Height; y++)
 895                 for (x=0; x<prc->Width; x++)
 896                 {
 897                     BYTE alpha = pbBuffer[cbStride*y+4*x+3];
 898                     if (alpha != 255)
 899                     {
 900                         pbBuffer[cbStride*y+4*x] = pbBuffer[cbStride*y+4*x] * alpha / 255;
 901                         pbBuffer[cbStride*y+4*x+1] = pbBuffer[cbStride*y+4*x+1] * alpha / 255;
 902                         pbBuffer[cbStride*y+4*x+2] = pbBuffer[cbStride*y+4*x+2] * alpha / 255;
 903                     }
 904                 }
 905         }
 906         return hr;
 907     }
 908 }
 909
 910 static HRESULT copypixels_to_24bppBGR(struct FormatConverter *This, const WICRect *prc,
 911     UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
 912 {
 913     HRESULT hr;
 914
 915     switch (source_format)
 916     {
 917     case format_24bppBGR:
 918     case format_24bppRGB:
 919         if (prc)
 920         {
 921             hr = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
 922             if (SUCCEEDED(hr) && source_format == format_24bppRGB)
 923               reverse_bgr8(3, pbBuffer, prc->Width, prc->Height, cbStride);
 924             return hr;
 925         }
 926         return S_OK;
 927     case format_32bppBGR:
 928     case format_32bppBGRA:
 929     case format_32bppPBGRA:
 930         if (prc)
 931         {
 932             HRESULT res;
 933             INT x, y;
 934             BYTE *srcdata;
 935             UINT srcstride, srcdatasize;
 936             const BYTE *srcrow;
 937             const BYTE *srcpixel;
 938             BYTE *dstrow;
 939             BYTE *dstpixel;
 940
 941             srcstride = 4 * prc->Width;
 942             srcdatasize = srcstride * prc->Height;
 943
 944             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
 945             if (!srcdata) return E_OUTOFMEMORY;
 946
 947             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 948
 949             if (SUCCEEDED(res))
 950             {
 951                 srcrow = srcdata;
 952                 dstrow = pbBuffer;
 953                 for (y=0; y<prc->Height; y++) {
 954                     srcpixel=srcrow;
 955                     dstpixel=dstrow;
 956                     for (x=0; x<prc->Width; x++) {
 957                         *dstpixel++=*srcpixel++; /* blue */
 958                         *dstpixel++=*srcpixel++; /* green */
 959                         *dstpixel++=*srcpixel++; /* red */
 960                         srcpixel++; /* alpha */
 961                     }
 962                     srcrow += srcstride;
 963                     dstrow += cbStride;
 964                 }
 965             }
 966
 967             HeapFree(GetProcessHeap(), 0, srcdata);
 968
 969             return res;
 970         }
 971         return S_OK;
 972
 973     case format_32bppGrayFloat:
 974         if (prc)
 975         {
 976             BYTE *srcdata;
 977             UINT srcstride, srcdatasize;
 978
 979             srcstride = 4 * prc->Width;
 980             srcdatasize = srcstride * prc->Height;
 981
 982             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
 983             if (!srcdata) return E_OUTOFMEMORY;
 984
 985             hr = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 986
 987             if (SUCCEEDED(hr))
 988             {
 989                 INT x, y;
 990                 BYTE *src = srcdata, *dst = pbBuffer;
 991
 992                 for (y = 0; y < prc->Height; y++)
 993                 {
 994                     float *gray_float = (float *)src;
 995                     BYTE *bgr = dst;
 996
 997                     for (x = 0; x < prc->Width; x++)
 998                     {
 999                         BYTE gray = (BYTE)floorf(to_sRGB_component(gray_float[x]) * 255.0f + 0.51f);
1000                         *bgr++ = gray;
1001                         *bgr++ = gray;
1002                         *bgr++ = gray;
1003                     }
1004                     src += srcstride;
1005                     dst += cbStride;
1006                 }
1007             }
1008
1009             HeapFree(GetProcessHeap(), 0, srcdata);
1010
1011             return hr;
1012         }
1013         return S_OK;
1014
1015     default:
1016         FIXME("Unimplemented conversion path!\n");
1017         return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1018     }
1019 }
1020
1021 static HRESULT copypixels_to_24bppRGB(struct FormatConverter *This, const WICRect *prc,
1022     UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
1023 {
1024     HRESULT hr;
1025
1026     switch (source_format)
1027     {
1028     case format_24bppBGR:
1029     case format_24bppRGB:
1030         if (prc)
1031         {
1032             hr = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
1033             if (SUCCEEDED(hr) && source_format == format_24bppBGR)
1034               reverse_bgr8(3, pbBuffer, prc->Width, prc->Height, cbStride);
1035             return hr;
1036         }
1037         return S_OK;
1038     case format_32bppBGR:
1039     case format_32bppBGRA:
1040     case format_32bppPBGRA:
1041         if (prc)
1042         {
1043             HRESULT res;
1044             INT x, y;
1045             BYTE *srcdata;
1046             UINT srcstride, srcdatasize;
1047             const BYTE *srcrow;
1048             const BYTE *srcpixel;
1049             BYTE *dstrow;
1050             BYTE *dstpixel;
1051             BYTE tmppixel[3];
1052
1053             srcstride = 4 * prc->Width;
1054             srcdatasize = srcstride * prc->Height;
1055
1056             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
1057             if (!srcdata) return E_OUTOFMEMORY;
1058
1059             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
1060
1061             if (SUCCEEDED(res))
1062             {
1063                 srcrow = srcdata;
1064                 dstrow = pbBuffer;
1065                 for (y=0; y<prc->Height; y++) {
1066                     srcpixel=srcrow;
1067                     dstpixel=dstrow;
1068                     for (x=0; x<prc->Width; x++) {
1069                         tmppixel[0]=*srcpixel++; /* blue */
1070                         tmppixel[1]=*srcpixel++; /* green */
1071                         tmppixel[2]=*srcpixel++; /* red */
1072                         srcpixel++; /* alpha */
1073
1074                         *dstpixel++=tmppixel[2]; /* red */
1075                         *dstpixel++=tmppixel[1]; /* green */
1076                         *dstpixel++=tmppixel[0]; /* blue */
1077                     }
1078                     srcrow += srcstride;
1079                     dstrow += cbStride;
1080                 }
1081             }
1082
1083             HeapFree(GetProcessHeap(), 0, srcdata);
1084
1085             return res;
1086         }
1087         return S_OK;
1088     default:
1089         FIXME("Unimplemented conversion path!\n");
1090         return WINCODEC_ERR_UNSUPPORTEDOPERATION;
1091     }
1092 }
1093
1094 static HRESULT copypixels_to_32bppGrayFloat(struct FormatConverter *This, const WICRect *prc,
1095     UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
1096 {
1097     HRESULT hr;
1098
1099     switch (source_format)
1100     {
1101     case format_32bppBGR:
1102     case format_32bppBGRA:
1103     case format_32bppPBGRA:
1104     case format_32bppGrayFloat:
1105         if (prc)
1106         {
1107             hr = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
1108             break;
1109         }
1110         return S_OK;
1111
1112     default:
1113         hr = copypixels_to_32bppBGRA(This, prc, cbStride, cbBufferSize, pbBuffer, source_format);
1114         break;
1115     }
1116
1117     if (SUCCEEDED(hr) && prc && source_format != format_32bppGrayFloat)
1118     {
1119         INT x, y;
1120         BYTE *p = pbBuffer;
1121
1122         for (y = 0; y < prc->Height; y++)
1123         {
1124             BYTE *bgr = p;
1125             for (x = 0; x < prc->Width; x++)
1126             {
1127                 float gray = (bgr[2] * 0.2126f + bgr[1] * 0.7152f + bgr[0] * 0.0722f) / 255.0f;
1128                 *(float *)bgr = gray;
1129                 bgr += 4;
1130             }
1131             p += cbStride;
1132         }
1133     }
1134     return hr;
1135 }
1136
1137 static HRESULT copypixels_to_8bppGray(struct FormatConverter *This, const WICRect *prc,
1138     UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)
1139 {
1140     HRESULT hr;
1141     BYTE *srcdata;
1142     UINT srcstride, srcdatasize;
1143
1144     if (source_format == format_8bppGray)
1145     {
1146         if (prc)
1147             return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
1148
1149         return S_OK;
1150     }
1151
1152     srcstride = 3 * prc->Width;
1153     srcdatasize = srcstride * prc->Height;
1154
1155     srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
1156     if (!srcdata) return E_OUTOFMEMORY;
1157
1158     hr = copypixels_to_24bppBGR(This, prc, srcstride, srcdatasize, srcdata, source_format);
1159     if (SUCCEEDED(hr) && prc)
1160     {
1161         INT x, y;
1162         BYTE *src = srcdata, *dst = pbBuffer;
1163
1164         for (y = 0; y < prc->Height; y++)
1165         {
1166             BYTE *bgr = src;
1167
1168             for (x = 0; x < prc->Width; x++)
1169             {
1170                 float gray = (bgr[2] * 0.2126f + bgr[1] * 0.7152f + bgr[0] * 0.0722f) / 255.0f;
1171
1172                 gray = to_sRGB_component(gray) * 255.0f;
1173                 dst[x] = (BYTE)floorf(gray + 0.51f);
1174                 bgr += 3;
1175             }
1176             src += srcstride;
1177             dst += cbStride;
1178         }
1179     }
1180
1181     HeapFree(GetProcessHeap(), 0, srcdata);
1182     return hr;
1183 }
1184
1185 static const struct pixelformatinfo supported_formats[] = {
1186     {format_1bppIndexed, &GUID_WICPixelFormat1bppIndexed, NULL},
1187     {format_2bppIndexed, &GUID_WICPixelFormat2bppIndexed, NULL},
1188     {format_4bppIndexed, &GUID_WICPixelFormat4bppIndexed, NULL},
1189     {format_8bppIndexed, &GUID_WICPixelFormat8bppIndexed, NULL},
1190     {format_BlackWhite, &GUID_WICPixelFormatBlackWhite, NULL},
1191     {format_2bppGray, &GUID_WICPixelFormat2bppGray, NULL},
1192     {format_4bppGray, &GUID_WICPixelFormat4bppGray, NULL},
1193     {format_8bppGray, &GUID_WICPixelFormat8bppGray, copypixels_to_8bppGray},
1194     {format_16bppGray, &GUID_WICPixelFormat16bppGray, NULL},
1195     {format_16bppBGR555, &GUID_WICPixelFormat16bppBGR555, NULL},
1196     {format_16bppBGR565, &GUID_WICPixelFormat16bppBGR565, NULL},
1197     {format_16bppBGRA5551, &GUID_WICPixelFormat16bppBGRA5551, NULL},
1198     {format_24bppBGR, &GUID_WICPixelFormat24bppBGR, copypixels_to_24bppBGR},
1199     {format_24bppRGB, &GUID_WICPixelFormat24bppRGB, copypixels_to_24bppRGB},
1200     {format_32bppGrayFloat, &GUID_WICPixelFormat32bppGrayFloat, copypixels_to_32bppGrayFloat},
1201     {format_32bppBGR, &GUID_WICPixelFormat32bppBGR, copypixels_to_32bppBGR},
1202     {format_32bppBGRA, &GUID_WICPixelFormat32bppBGRA, copypixels_to_32bppBGRA},
1203     {format_32bppPBGRA, &GUID_WICPixelFormat32bppPBGRA, copypixels_to_32bppPBGRA},
1204     {format_48bppRGB, &GUID_WICPixelFormat48bppRGB, NULL},
1205     {format_64bppRGBA, &GUID_WICPixelFormat64bppRGBA, NULL},
1206     {format_32bppCMYK, &GUID_WICPixelFormat32bppCMYK, NULL},
1207     {0}
1208 };
1209
1210 static const struct pixelformatinfo *get_formatinfo(const WICPixelFormatGUID *format)
1211 {
1212     UINT i;
1213
1214     for (i=0; supported_formats[i].guid; i++)
1215         if (IsEqualGUID(supported_formats[i].guid, format)) return &supported_formats[i];
1216
1217     return NULL;
1218 }
1219
1220 static HRESULT WINAPI FormatConverter_QueryInterface(IWICFormatConverter *iface, REFIID iid,
1221     void **ppv)
1222 {
1223     FormatConverter *This = impl_from_IWICFormatConverter(iface);
1224     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
1225
1226     if (!ppv) return E_INVALIDARG;
1227
1228     if (IsEqualIID(&IID_IUnknown, iid) ||
1229         IsEqualIID(&IID_IWICBitmapSource, iid) ||
1230         IsEqualIID(&IID_IWICFormatConverter, iid))
1231     {
1232         *ppv = &This->IWICFormatConverter_iface;
1233     }
1234     else
1235     {
1236         *ppv = NULL;
1237         return E_NOINTERFACE;
1238     }
1239
1240     IUnknown_AddRef((IUnknown*)*ppv);
1241     return S_OK;
1242 }
1243
1244 static ULONG WINAPI FormatConverter_AddRef(IWICFormatConverter *iface)
1245 {
1246     FormatConverter *This = impl_from_IWICFormatConverter(iface);
1247     ULONG ref = InterlockedIncrement(&This->ref);
1248
1249     TRACE("(%p) refcount=%u\n", iface, ref);
1250
1251     return ref;
1252 }
1253
1254 static ULONG WINAPI FormatConverter_Release(IWICFormatConverter *iface)
1255 {
1256     FormatConverter *This = impl_from_IWICFormatConverter(iface);
1257     ULONG ref = InterlockedDecrement(&This->ref);
1258
1259     TRACE("(%p) refcount=%u\n", iface, ref);
1260
1261     if (ref == 0)
1262     {
1263         This->lock.DebugInfo->Spare[0] = 0;
1264         DeleteCriticalSection(&This->lock);
1265         if (This->source) IWICBitmapSource_Release(This->source);
1266         HeapFree(GetProcessHeap(), 0, This);
1267     }
1268
1269     return ref;
1270 }
1271
1272 static HRESULT WINAPI FormatConverter_GetSize(IWICFormatConverter *iface,
1273     UINT *puiWidth, UINT *puiHeight)
1274 {
1275     FormatConverter *This = impl_from_IWICFormatConverter(iface);
1276
1277     TRACE("(%p,%p,%p)\n", iface, puiWidth, puiHeight);
1278
1279     if (This->source)
1280         return IWICBitmapSource_GetSize(This->source, puiWidth, puiHeight);
1281     else
1282         return WINCODEC_ERR_NOTINITIALIZED;
1283 }
1284
1285 static HRESULT WINAPI FormatConverter_GetPixelFormat(IWICFormatConverter *iface,
1286     WICPixelFormatGUID *pPixelFormat)
1287 {
1288     FormatConverter *This = impl_from_IWICFormatConverter(iface);
1289
1290     TRACE("(%p,%p)\n", iface, pPixelFormat);
1291
1292     if (This->source)
1293         memcpy(pPixelFormat, This->dst_format->guid, sizeof(GUID));
1294     else
1295         return WINCODEC_ERR_NOTINITIALIZED;
1296
1297     return S_OK;
1298 }
1299
1300 static HRESULT WINAPI FormatConverter_GetResolution(IWICFormatConverter *iface,
1301     double *pDpiX, double *pDpiY)
1302 {
1303     FormatConverter *This = impl_from_IWICFormatConverter(iface);
1304
1305     TRACE("(%p,%p,%p)\n", iface, pDpiX, pDpiY);
1306
1307     if (This->source)
1308         return IWICBitmapSource_GetResolution(This->source, pDpiX, pDpiY);
1309     else
1310         return WINCODEC_ERR_NOTINITIALIZED;
1311 }
1312
1313 static HRESULT WINAPI FormatConverter_CopyPalette(IWICFormatConverter *iface,
1314     IWICPalette *pIPalette)
1315 {
1316     FIXME("(%p,%p): stub\n", iface, pIPalette);
1317     return E_NOTIMPL;
1318 }
1319
1320 static HRESULT WINAPI FormatConverter_CopyPixels(IWICFormatConverter *iface,
1321     const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
1322 {
1323     FormatConverter *This = impl_from_IWICFormatConverter(iface);
1324     WICRect rc;
1325     HRESULT hr;
1326     TRACE("(%p,%p,%u,%u,%p)\n", iface, prc, cbStride, cbBufferSize, pbBuffer);
1327
1328     if (This->source)
1329     {
1330         if (!prc)
1331         {
1332             UINT width, height;
1333             hr = IWICBitmapSource_GetSize(This->source, &width, &height);
1334             if (FAILED(hr)) return hr;
1335             rc.X = 0;
1336             rc.Y = 0;
1337             rc.Width = width;
1338             rc.Height = height;
1339             prc = &rc;
1340         }
1341
1342         return This->dst_format->copy_function(This, prc, cbStride, cbBufferSize,
1343             pbBuffer, This->src_format->format);
1344     }
1345     else
1346         return WINCODEC_ERR_NOTINITIALIZED;
1347 }
1348
1349 static HRESULT WINAPI FormatConverter_Initialize(IWICFormatConverter *iface,
1350     IWICBitmapSource *pISource, REFWICPixelFormatGUID dstFormat, WICBitmapDitherType dither,
1351     IWICPalette *pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate)
1352 {
1353     FormatConverter *This = impl_from_IWICFormatConverter(iface);
1354     const struct pixelformatinfo *srcinfo, *dstinfo;
1355     static INT fixme=0;
1356     GUID srcFormat;
1357     HRESULT res=S_OK;
1358
1359     TRACE("(%p,%p,%s,%u,%p,%0.1f,%u)\n", iface, pISource, debugstr_guid(dstFormat),
1360         dither, pIPalette, alphaThresholdPercent, paletteTranslate);
1361
1362     if (pIPalette && !fixme++) FIXME("ignoring palette\n");
1363
1364     EnterCriticalSection(&This->lock);
1365
1366     if (This->source)
1367     {
1368         res = WINCODEC_ERR_WRONGSTATE;
1369         goto end;
1370     }
1371
1372     res = IWICBitmapSource_GetPixelFormat(pISource, &srcFormat);
1373     if (FAILED(res)) goto end;
1374
1375     srcinfo = get_formatinfo(&srcFormat);
1376     if (!srcinfo)
1377     {
1378         res = WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
1379         FIXME("Unsupported source format %s\n", debugstr_guid(&srcFormat));
1380         goto end;
1381     }
1382
1383     dstinfo = get_formatinfo(dstFormat);
1384     if (!dstinfo)
1385     {
1386         res = WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
1387         FIXME("Unsupported destination format %s\n", debugstr_guid(dstFormat));
1388         goto end;
1389     }
1390
1391     if (dstinfo->copy_function)
1392     {
1393         IWICBitmapSource_AddRef(pISource);
1394         This->src_format = srcinfo;
1395         This->dst_format = dstinfo;
1396         This->dither = dither;
1397         This->alpha_threshold = alphaThresholdPercent;
1398         This->palette_type = paletteTranslate;
1399         This->source = pISource;
1400     }
1401     else
1402     {
1403         FIXME("Unsupported conversion %s -> %s\n", debugstr_guid(&srcFormat), debugstr_guid(dstFormat));
1404         res = WINCODEC_ERR_UNSUPPORTEDOPERATION;
1405     }
1406
1407 end:
1408
1409     LeaveCriticalSection(&This->lock);
1410
1411     return res;
1412 }
1413
1414 static HRESULT WINAPI FormatConverter_CanConvert(IWICFormatConverter *iface,
1415     REFWICPixelFormatGUID srcPixelFormat, REFWICPixelFormatGUID dstPixelFormat,
1416     BOOL *pfCanConvert)
1417 {
1418     FormatConverter *This = impl_from_IWICFormatConverter(iface);
1419     const struct pixelformatinfo *srcinfo, *dstinfo;
1420
1421     TRACE("(%p,%s,%s,%p)\n", iface, debugstr_guid(srcPixelFormat),
1422         debugstr_guid(dstPixelFormat), pfCanConvert);
1423
1424     srcinfo = get_formatinfo(srcPixelFormat);
1425     if (!srcinfo)
1426     {
1427         FIXME("Unsupported source format %s\n", debugstr_guid(srcPixelFormat));
1428         return WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
1429     }
1430
1431     dstinfo = get_formatinfo(dstPixelFormat);
1432     if (!dstinfo)
1433     {
1434         FIXME("Unsupported destination format %s\n", debugstr_guid(dstPixelFormat));
1435         return WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
1436     }
1437
1438     if (dstinfo->copy_function &&
1439         SUCCEEDED(dstinfo->copy_function(This, NULL, 0, 0, NULL, dstinfo->format)))
1440         *pfCanConvert = TRUE;
1441     else
1442     {
1443         FIXME("Unsupported conversion %s -> %s\n", debugstr_guid(srcPixelFormat), debugstr_guid(dstPixelFormat));
1444         *pfCanConvert = FALSE;
1445     }
1446
1447     return S_OK;
1448 }
1449
1450 static const IWICFormatConverterVtbl FormatConverter_Vtbl = {
1451     FormatConverter_QueryInterface,
1452     FormatConverter_AddRef,
1453     FormatConverter_Release,
1454     FormatConverter_GetSize,
1455     FormatConverter_GetPixelFormat,
1456     FormatConverter_GetResolution,
1457     FormatConverter_CopyPalette,
1458     FormatConverter_CopyPixels,
1459     FormatConverter_Initialize,
1460     FormatConverter_CanConvert
1461 };
1462
1463 HRESULT FormatConverter_CreateInstance(REFIID iid, void** ppv)
1464 {
1465     FormatConverter *This;
1466     HRESULT ret;
1467
1468     TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
1469
1470     *ppv = NULL;
1471
1472     This = HeapAlloc(GetProcessHeap(), 0, sizeof(FormatConverter));
1473     if (!This) return E_OUTOFMEMORY;
1474
1475     This->IWICFormatConverter_iface.lpVtbl = &FormatConverter_Vtbl;
1476     This->ref = 1;
1477     This->source = NULL;
1478     InitializeCriticalSection(&This->lock);
1479     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": FormatConverter.lock");
1480
1481     ret = IWICFormatConverter_QueryInterface(&This->IWICFormatConverter_iface, iid, ppv);
1482     IWICFormatConverter_Release(&This->IWICFormatConverter_iface);
1483
1484     return ret;
1485 }