#include "config.h"
#include <stdarg.h>
#include <math.h>
#include "windef.h"
#include "winbase.h"
#include "objbase.h"
#include "wincodecs_private.h"
#include "wine/heap.h"
#include "wine/debug.h"

Include dependency graph for converter.c:

Classes
struct	pixelformatinfo

struct	FormatConverter

Macros
#define	COBJMACROS

Typedefs
typedef HRESULT(*	copyfunc) (struct FormatConverter This, const WICRect prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)

typedef struct FormatConverter	FormatConverter

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (wincodecs)

static float	from_sRGB_component (float f)

static float	to_sRGB_component (float f)

static FormatConverter *	impl_from_IWICFormatConverter (IWICFormatConverter *iface)

static HRESULT	copypixels_to_32bppBGRA (struct FormatConverter This, const WICRect prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)

static HRESULT	copypixels_to_32bppRGBA (struct FormatConverter This, const WICRect prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)

static HRESULT	copypixels_to_32bppBGR (struct FormatConverter This, const WICRect prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)

static HRESULT	copypixels_to_32bppRGB (struct FormatConverter This, const WICRect prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)

static HRESULT	copypixels_to_32bppPBGRA (struct FormatConverter This, const WICRect prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)

static HRESULT	copypixels_to_32bppPRGBA (struct FormatConverter This, const WICRect prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)

static HRESULT	copypixels_to_24bppBGR (struct FormatConverter This, const WICRect prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)

static HRESULT	copypixels_to_24bppRGB (struct FormatConverter This, const WICRect prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)

static HRESULT	copypixels_to_32bppGrayFloat (struct FormatConverter This, const WICRect prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)

static HRESULT	copypixels_to_8bppGray (struct FormatConverter This, const WICRect prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)

static UINT	rgb_to_palette_index (BYTE r, BYTE g, BYTE b, WICColor *colors, UINT count)

static HRESULT	copypixels_to_8bppIndexed (struct FormatConverter This, const WICRect prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)

static const struct pixelformatinfo *	get_formatinfo (const WICPixelFormatGUID *format)

static HRESULT WINAPI	FormatConverter_QueryInterface (IWICFormatConverter iface, REFIID iid, void *ppv)

static ULONG WINAPI	FormatConverter_AddRef (IWICFormatConverter *iface)

static ULONG WINAPI	FormatConverter_Release (IWICFormatConverter *iface)

static HRESULT WINAPI	FormatConverter_GetSize (IWICFormatConverter iface, UINT puiWidth, UINT *puiHeight)

static HRESULT WINAPI	FormatConverter_GetPixelFormat (IWICFormatConverter iface, WICPixelFormatGUID pPixelFormat)

static HRESULT WINAPI	FormatConverter_GetResolution (IWICFormatConverter iface, double pDpiX, double *pDpiY)

static HRESULT WINAPI	FormatConverter_CopyPalette (IWICFormatConverter iface, IWICPalette palette)

static HRESULT WINAPI	FormatConverter_CopyPixels (IWICFormatConverter iface, const WICRect prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)

static HRESULT WINAPI	FormatConverter_Initialize (IWICFormatConverter iface, IWICBitmapSource source, REFWICPixelFormatGUID dstFormat, WICBitmapDitherType dither, IWICPalette *palette, double alpha_threshold, WICBitmapPaletteType palette_type)

static HRESULT WINAPI	FormatConverter_CanConvert (IWICFormatConverter iface, REFWICPixelFormatGUID srcPixelFormat, REFWICPixelFormatGUID dstPixelFormat, BOOL pfCanConvert)

HRESULT	FormatConverter_CreateInstance (REFIID iid, void **ppv)

Variables
static const struct pixelformatinfo	supported_formats []

static const IWICFormatConverterVtbl	FormatConverter_Vtbl

Macro Definition Documentation

◆ COBJMACROS

#define COBJMACROS

Definition at line 25 of file converter.c.

Typedef Documentation

◆ copyfunc

typedef HRESULT(* copyfunc) (struct FormatConverter *This, const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer, enum pixelformat source_format)

Definition at line 67 of file converter.c.

◆ FormatConverter

typedef struct FormatConverter FormatConverter

Enumeration Type Documentation

◆ pixelformat

enum pixelformat

Enumerator
format_1bppIndexed
format_2bppIndexed
format_4bppIndexed
format_8bppIndexed
format_BlackWhite
format_2bppGray
format_4bppGray
format_8bppGray
format_16bppGray
format_16bppBGR555
format_16bppBGR565
format_16bppBGRA5551
format_24bppBGR
format_24bppRGB
format_32bppGrayFloat
format_32bppBGR
format_32bppRGB
format_32bppBGRA
format_32bppRGBA
format_32bppPBGRA
format_32bppPRGBA
format_48bppRGB
format_64bppRGBA
format_32bppCMYK

Definition at line 40 of file converter.c.

                  {
     format_1bppIndexed,
     format_2bppIndexed,
     format_4bppIndexed,
     format_8bppIndexed,
     format_BlackWhite,
     format_2bppGray,
     format_4bppGray,
     format_8bppGray,
     format_16bppGray,
     format_16bppBGR555,
     format_16bppBGR565,
     format_16bppBGRA5551,
     format_24bppBGR,
     format_24bppRGB,
     format_32bppGrayFloat,
     format_32bppBGR,
     format_32bppRGB,
     format_32bppBGRA,
     format_32bppRGBA,
     format_32bppPBGRA,
     format_32bppPRGBA,
     format_48bppRGB,
     format_64bppRGBA,
     format_32bppCMYK,
 };

Function Documentation

◆ copypixels_to_24bppBGR()

static HRESULT copypixels_to_24bppBGR	(	struct FormatConverter *	This,
		const WICRect *	prc,
		UINT	cbStride,
		UINT	cbBufferSize,
		BYTE *	pbBuffer,
		enum pixelformat	source_format
	)

static

Definition at line 986 of file converter.c.

 {
     HRESULT hr;
 
     switch (source_format)
     {
     case format_24bppBGR:
     case format_24bppRGB:
         if (prc)
         {
             hr = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
             if (SUCCEEDED(hr) && source_format == format_24bppRGB)
               reverse_bgr8(3, pbBuffer, prc->Width, prc->Height, cbStride);
             return hr;
         }
         return S_OK;
     case format_32bppBGR:
     case format_32bppBGRA:
     case format_32bppPBGRA:
         if (prc)
         {
             HRESULT res;
             INT x, y;
             BYTE *srcdata;
             UINT srcstride, srcdatasize;
             const BYTE *srcrow;
             const BYTE *srcpixel;
             BYTE *dstrow;
             BYTE *dstpixel;
 
             srcstride = 4 * prc->Width;
             srcdatasize = srcstride * prc->Height;
 
             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
             if (!srcdata) return E_OUTOFMEMORY;
 
             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 
             if (SUCCEEDED(res))
             {
                 srcrow = srcdata;
                 dstrow = pbBuffer;
                 for (y=0; y<prc->Height; y++) {
                     srcpixel=srcrow;
                     dstpixel=dstrow;
                     for (x=0; x<prc->Width; x++) {
                         *dstpixel++=*srcpixel++; /* blue */
                         *dstpixel++=*srcpixel++; /* green */
                         *dstpixel++=*srcpixel++; /* red */
                         srcpixel++; /* alpha */
                     }
                     srcrow += srcstride;
                     dstrow += cbStride;
                 }
             }
 
             HeapFree(GetProcessHeap(), 0, srcdata);
 
             return res;
         }
         return S_OK;
 
     case format_32bppGrayFloat:
         if (prc)
         {
             BYTE *srcdata;
             UINT srcstride, srcdatasize;
 
             srcstride = 4 * prc->Width;
             srcdatasize = srcstride * prc->Height;
 
             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
             if (!srcdata) return E_OUTOFMEMORY;
 
             hr = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 
             if (SUCCEEDED(hr))
             {
                 INT x, y;
                 BYTE *src = srcdata, *dst = pbBuffer;
 
                 for (y = 0; y < prc->Height; y++)
                 {
                     float *gray_float = (float *)src;
                     BYTE *bgr = dst;
 
                     for (x = 0; x < prc->Width; x++)
                     {
                         BYTE gray = (BYTE)floorf(to_sRGB_component(gray_float[x]) * 255.0f + 0.51f);
                         *bgr++ = gray;
                         *bgr++ = gray;
                         *bgr++ = gray;
                     }
                     src += srcstride;
                     dst += cbStride;
                 }
             }
 
             HeapFree(GetProcessHeap(), 0, srcdata);
 
             return hr;
         }
         return S_OK;
 
     case format_32bppCMYK:
         if (prc)
         {
             BYTE *srcdata;
             UINT srcstride, srcdatasize;
 
             srcstride = 4 * prc->Width;
             srcdatasize = srcstride * prc->Height;
 
             srcdata = heap_alloc(srcdatasize);
             if (!srcdata) return E_OUTOFMEMORY;
 
             hr = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
             if (SUCCEEDED(hr))
             {
                 INT x, y;
                 BYTE *src = srcdata, *dst = pbBuffer;
 
                 for (y = 0; y < prc->Height; y++)
                 {
                     BYTE *cmyk = src;
                     BYTE *bgr = dst;
 
                     for (x = 0; x < prc->Width; x++)
                     {
                         BYTE c = cmyk[0], m = cmyk[1], y = cmyk[2], k = cmyk[3];
                         bgr[0] = (255 - y) * (255 - k) / 255; /* B */
                         bgr[1] = (255 - m) * (255 - k) / 255; /* G */
                         bgr[2] = (255 - c) * (255 - k) / 255; /* R */
                         cmyk += 4;
                         bgr += 3;
                     }
                     src += srcstride;
                     dst += cbStride;
                 }
             }
 
             heap_free(srcdata);
             return hr;
         }
         return S_OK;
 
     default:
         FIXME("Unimplemented conversion path!\n");
         return WINCODEC_ERR_UNSUPPORTEDOPERATION;
     }
 }

Referenced by copypixels_to_8bppGray(), and copypixels_to_8bppIndexed().

◆ copypixels_to_24bppRGB()

static HRESULT copypixels_to_24bppRGB	(	struct FormatConverter *	This,
		const WICRect *	prc,
		UINT	cbStride,
		UINT	cbBufferSize,
		BYTE *	pbBuffer,
		enum pixelformat	source_format
	)

static

Definition at line 1139 of file converter.c.

 {
     HRESULT hr;
 
     switch (source_format)
     {
     case format_24bppBGR:
     case format_24bppRGB:
         if (prc)
         {
             hr = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
             if (SUCCEEDED(hr) && source_format == format_24bppBGR)
               reverse_bgr8(3, pbBuffer, prc->Width, prc->Height, cbStride);
             return hr;
         }
         return S_OK;
     case format_32bppBGR:
     case format_32bppBGRA:
     case format_32bppPBGRA:
         if (prc)
         {
             HRESULT res;
             INT x, y;
             BYTE *srcdata;
             UINT srcstride, srcdatasize;
             const BYTE *srcrow;
             const BYTE *srcpixel;
             BYTE *dstrow;
             BYTE *dstpixel;
             BYTE tmppixel[3];
 
             srcstride = 4 * prc->Width;
             srcdatasize = srcstride * prc->Height;
 
             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
             if (!srcdata) return E_OUTOFMEMORY;
 
             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 
             if (SUCCEEDED(res))
             {
                 srcrow = srcdata;
                 dstrow = pbBuffer;
                 for (y=0; y<prc->Height; y++) {
                     srcpixel=srcrow;
                     dstpixel=dstrow;
                     for (x=0; x<prc->Width; x++) {
                         tmppixel[0]=*srcpixel++; /* blue */
                         tmppixel[1]=*srcpixel++; /* green */
                         tmppixel[2]=*srcpixel++; /* red */
                         srcpixel++; /* alpha */
 
                         *dstpixel++=tmppixel[2]; /* red */
                         *dstpixel++=tmppixel[1]; /* green */
                         *dstpixel++=tmppixel[0]; /* blue */
                     }
                     srcrow += srcstride;
                     dstrow += cbStride;
                 }
             }
 
             HeapFree(GetProcessHeap(), 0, srcdata);
 
             return res;
         }
         return S_OK;
     default:
         FIXME("Unimplemented conversion path!\n");
         return WINCODEC_ERR_UNSUPPORTEDOPERATION;
     }
 }

◆ copypixels_to_32bppBGR()

static HRESULT copypixels_to_32bppBGR	(	struct FormatConverter *	This,
		const WICRect *	prc,
		UINT	cbStride,
		UINT	cbBufferSize,
		BYTE *	pbBuffer,
		enum pixelformat	source_format
	)

static

Definition at line 888 of file converter.c.

 {
     switch (source_format)
     {
     case format_32bppBGR:
     case format_32bppBGRA:
     case format_32bppPBGRA:
         if (prc)
             return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
         return S_OK;
     default:
         return copypixels_to_32bppBGRA(This, prc, cbStride, cbBufferSize, pbBuffer, source_format);
     }
 }

◆ copypixels_to_32bppBGRA()

static HRESULT copypixels_to_32bppBGRA	(	struct FormatConverter *	This,
		const WICRect *	prc,
		UINT	cbStride,
		UINT	cbBufferSize,
		BYTE *	pbBuffer,
		enum pixelformat	source_format
	)

static

Definition at line 143 of file converter.c.

 {
     switch (source_format)
     {
     case format_1bppIndexed:
     case format_BlackWhite:
         if (prc)
         {
             HRESULT res;
             INT x, y;
             BYTE *srcdata;
             UINT srcstride, srcdatasize;
             const BYTE *srcrow;
             const BYTE *srcbyte;
             BYTE *dstrow;
             DWORD *dstpixel;
             WICColor colors[2];
             IWICPalette *palette;
             UINT actualcolors;
 
             res = PaletteImpl_Create(&palette);
             if (FAILED(res)) return res;
 
             if (source_format == format_1bppIndexed)
                 res = IWICBitmapSource_CopyPalette(This->source, palette);
             else
                 res = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedBW, FALSE);
 
             if (SUCCEEDED(res))
                 res = IWICPalette_GetColors(palette, 2, colors, &actualcolors);
 
             IWICPalette_Release(palette);
             if (FAILED(res)) return res;
 
             srcstride = (prc->Width+7)/8;
             srcdatasize = srcstride * prc->Height;
 
             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
             if (!srcdata) return E_OUTOFMEMORY;
 
             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 
             if (SUCCEEDED(res))
             {
                 srcrow = srcdata;
                 dstrow = pbBuffer;
                 for (y=0; y<prc->Height; y++) {
                     srcbyte = srcrow;
                     dstpixel=(DWORD*)dstrow;
                     for (x=0; x<prc->Width; x+=8) {
                         BYTE srcval;
                         srcval=*srcbyte++;
                         *dstpixel++ = colors[srcval>>7&1];
                         if (x+1 < prc->Width) *dstpixel++ = colors[srcval>>6&1];
                         if (x+2 < prc->Width) *dstpixel++ = colors[srcval>>5&1];
                         if (x+3 < prc->Width) *dstpixel++ = colors[srcval>>4&1];
                         if (x+4 < prc->Width) *dstpixel++ = colors[srcval>>3&1];
                         if (x+5 < prc->Width) *dstpixel++ = colors[srcval>>2&1];
                         if (x+6 < prc->Width) *dstpixel++ = colors[srcval>>1&1];
                         if (x+7 < prc->Width) *dstpixel++ = colors[srcval&1];
                     }
                     srcrow += srcstride;
                     dstrow += cbStride;
                 }
             }
 
             HeapFree(GetProcessHeap(), 0, srcdata);
 
             return res;
         }
         return S_OK;
     case format_2bppIndexed:
     case format_2bppGray:
         if (prc)
         {
             HRESULT res;
             INT x, y;
             BYTE *srcdata;
             UINT srcstride, srcdatasize;
             const BYTE *srcrow;
             const BYTE *srcbyte;
             BYTE *dstrow;
             DWORD *dstpixel;
             WICColor colors[4];
             IWICPalette *palette;
             UINT actualcolors;
 
             res = PaletteImpl_Create(&palette);
             if (FAILED(res)) return res;
 
             if (source_format == format_2bppIndexed)
                 res = IWICBitmapSource_CopyPalette(This->source, palette);
             else
                 res = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray4, FALSE);
 
             if (SUCCEEDED(res))
                 res = IWICPalette_GetColors(palette, 4, colors, &actualcolors);
 
             IWICPalette_Release(palette);
             if (FAILED(res)) return res;
 
             srcstride = (prc->Width+3)/4;
             srcdatasize = srcstride * prc->Height;
 
             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
             if (!srcdata) return E_OUTOFMEMORY;
 
             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 
             if (SUCCEEDED(res))
             {
                 srcrow = srcdata;
                 dstrow = pbBuffer;
                 for (y=0; y<prc->Height; y++) {
                     srcbyte = srcrow;
                     dstpixel=(DWORD*)dstrow;
                     for (x=0; x<prc->Width; x+=4) {
                         BYTE srcval;
                         srcval=*srcbyte++;
                         *dstpixel++ = colors[srcval>>6];
                         if (x+1 < prc->Width) *dstpixel++ = colors[srcval>>4&0x3];
                         if (x+2 < prc->Width) *dstpixel++ = colors[srcval>>2&0x3];
                         if (x+3 < prc->Width) *dstpixel++ = colors[srcval&0x3];
                     }
                     srcrow += srcstride;
                     dstrow += cbStride;
                 }
             }
 
             HeapFree(GetProcessHeap(), 0, srcdata);
 
             return res;
         }
         return S_OK;
     case format_4bppIndexed:
     case format_4bppGray:
         if (prc)
         {
             HRESULT res;
             INT x, y;
             BYTE *srcdata;
             UINT srcstride, srcdatasize;
             const BYTE *srcrow;
             const BYTE *srcbyte;
             BYTE *dstrow;
             DWORD *dstpixel;
             WICColor colors[16];
             IWICPalette *palette;
             UINT actualcolors;
 
             res = PaletteImpl_Create(&palette);
             if (FAILED(res)) return res;
 
             if (source_format == format_4bppIndexed)
                 res = IWICBitmapSource_CopyPalette(This->source, palette);
             else
                 res = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray16, FALSE);
 
             if (SUCCEEDED(res))
                 res = IWICPalette_GetColors(palette, 16, colors, &actualcolors);
 
             IWICPalette_Release(palette);
             if (FAILED(res)) return res;
 
             srcstride = (prc->Width+1)/2;
             srcdatasize = srcstride * prc->Height;
 
             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
             if (!srcdata) return E_OUTOFMEMORY;
 
             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 
             if (SUCCEEDED(res))
             {
                 srcrow = srcdata;
                 dstrow = pbBuffer;
                 for (y=0; y<prc->Height; y++) {
                     srcbyte = srcrow;
                     dstpixel=(DWORD*)dstrow;
                     for (x=0; x<prc->Width; x+=2) {
                         BYTE srcval;
                         srcval=*srcbyte++;
                         *dstpixel++ = colors[srcval>>4];
                         if (x+1 < prc->Width) *dstpixel++ = colors[srcval&0xf];
                     }
                     srcrow += srcstride;
                     dstrow += cbStride;
                 }
             }
 
             HeapFree(GetProcessHeap(), 0, srcdata);
 
             return res;
         }
         return S_OK;
     case format_8bppGray:
         if (prc)
         {
             HRESULT res;
             INT x, y;
             BYTE *srcdata;
             UINT srcstride, srcdatasize;
             const BYTE *srcrow;
             const BYTE *srcbyte;
             BYTE *dstrow;
             DWORD *dstpixel;
 
             srcstride = prc->Width;
             srcdatasize = srcstride * prc->Height;
 
             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
             if (!srcdata) return E_OUTOFMEMORY;
 
             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 
             if (SUCCEEDED(res))
             {
                 srcrow = srcdata;
                 dstrow = pbBuffer;
                 for (y=0; y<prc->Height; y++) {
                     srcbyte = srcrow;
                     dstpixel=(DWORD*)dstrow;
                     for (x=0; x<prc->Width; x++)
                     {
                         *dstpixel++ = 0xff000000|(*srcbyte<<16)|(*srcbyte<<8)|*srcbyte;
                         srcbyte++;
                     }
                     srcrow += srcstride;
                     dstrow += cbStride;
                 }
             }
 
             HeapFree(GetProcessHeap(), 0, srcdata);
 
             return res;
         }
         return S_OK;
     case format_8bppIndexed:
         if (prc)
         {
             HRESULT res;
             INT x, y;
             BYTE *srcdata;
             UINT srcstride, srcdatasize;
             const BYTE *srcrow;
             const BYTE *srcbyte;
             BYTE *dstrow;
             DWORD *dstpixel;
             WICColor colors[256];
             IWICPalette *palette;
             UINT actualcolors;
 
             res = PaletteImpl_Create(&palette);
             if (FAILED(res)) return res;
 
             res = IWICBitmapSource_CopyPalette(This->source, palette);
             if (SUCCEEDED(res))
                 res = IWICPalette_GetColors(palette, 256, colors, &actualcolors);
 
             IWICPalette_Release(palette);
 
             if (FAILED(res)) return res;
 
             srcstride = prc->Width;
             srcdatasize = srcstride * prc->Height;
 
             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
             if (!srcdata) return E_OUTOFMEMORY;
 
             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 
             if (SUCCEEDED(res))
             {
                 srcrow = srcdata;
                 dstrow = pbBuffer;
                 for (y=0; y<prc->Height; y++) {
                     srcbyte = srcrow;
                     dstpixel=(DWORD*)dstrow;
                     for (x=0; x<prc->Width; x++)
                         *dstpixel++ = colors[*srcbyte++];
                     srcrow += srcstride;
                     dstrow += cbStride;
                 }
             }
 
             HeapFree(GetProcessHeap(), 0, srcdata);
 
             return res;
         }
         return S_OK;
     case format_16bppGray:
         if (prc)
         {
             HRESULT res;
             INT x, y;
             BYTE *srcdata;
             UINT srcstride, srcdatasize;
             const BYTE *srcrow;
             const BYTE *srcbyte;
             BYTE *dstrow;
             DWORD *dstpixel;
 
             srcstride = prc->Width * 2;
             srcdatasize = srcstride * prc->Height;
 
             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
             if (!srcdata) return E_OUTOFMEMORY;
 
             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 
             if (SUCCEEDED(res))
             {
                 srcrow = srcdata;
                 dstrow = pbBuffer;
                 for (y=0; y<prc->Height; y++) {
                     srcbyte = srcrow;
                     dstpixel=(DWORD*)dstrow;
                     for (x=0; x<prc->Width; x++)
                     {
                         *dstpixel++ = 0xff000000|(*srcbyte<<16)|(*srcbyte<<8)|*srcbyte;
                         srcbyte+=2;
                     }
                     srcrow += srcstride;
                     dstrow += cbStride;
                 }
             }
 
             HeapFree(GetProcessHeap(), 0, srcdata);
 
             return res;
         }
         return S_OK;
     case format_16bppBGR555:
         if (prc)
         {
             HRESULT res;
             INT x, y;
             BYTE *srcdata;
             UINT srcstride, srcdatasize;
             const BYTE *srcrow;
             const WORD *srcpixel;
             BYTE *dstrow;
             DWORD *dstpixel;
 
             srcstride = 2 * prc->Width;
             srcdatasize = srcstride * prc->Height;
 
             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
             if (!srcdata) return E_OUTOFMEMORY;
 
             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 
             if (SUCCEEDED(res))
             {
                 srcrow = srcdata;
                 dstrow = pbBuffer;
                 for (y=0; y<prc->Height; y++) {
                     srcpixel=(const WORD*)srcrow;
                     dstpixel=(DWORD*)dstrow;
                     for (x=0; x<prc->Width; x++) {
                         WORD srcval;
                         srcval=*srcpixel++;
                         *dstpixel++=0xff000000 | /* constant 255 alpha */
                                     ((srcval << 9) & 0xf80000) | /* r */
                                     ((srcval << 4) & 0x070000) | /* r - 3 bits */
                                     ((srcval << 6) & 0x00f800) | /* g */
                                     ((srcval << 1) & 0x000700) | /* g - 3 bits */
                                     ((srcval << 3) & 0x0000f8) | /* b */
                                     ((srcval >> 2) & 0x000007);  /* b - 3 bits */
                     }
                     srcrow += srcstride;
                     dstrow += cbStride;
                 }
             }
 
             HeapFree(GetProcessHeap(), 0, srcdata);
 
             return res;
         }
         return S_OK;
     case format_16bppBGR565:
         if (prc)
         {
             HRESULT res;
             INT x, y;
             BYTE *srcdata;
             UINT srcstride, srcdatasize;
             const BYTE *srcrow;
             const WORD *srcpixel;
             BYTE *dstrow;
             DWORD *dstpixel;
 
             srcstride = 2 * prc->Width;
             srcdatasize = srcstride * prc->Height;
 
             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
             if (!srcdata) return E_OUTOFMEMORY;
 
             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 
             if (SUCCEEDED(res))
             {
                 srcrow = srcdata;
                 dstrow = pbBuffer;
                 for (y=0; y<prc->Height; y++) {
                     srcpixel=(const WORD*)srcrow;
                     dstpixel=(DWORD*)dstrow;
                     for (x=0; x<prc->Width; x++) {
                         WORD srcval;
                         srcval=*srcpixel++;
                         *dstpixel++=0xff000000 | /* constant 255 alpha */
                                     ((srcval << 8) & 0xf80000) | /* r */
                                     ((srcval << 3) & 0x070000) | /* r - 3 bits */
                                     ((srcval << 5) & 0x00fc00) | /* g */
                                     ((srcval >> 1) & 0x000300) | /* g - 2 bits */
                                     ((srcval << 3) & 0x0000f8) | /* b */
                                     ((srcval >> 2) & 0x000007);  /* b - 3 bits */
                     }
                     srcrow += srcstride;
                     dstrow += cbStride;
                 }
             }
 
             HeapFree(GetProcessHeap(), 0, srcdata);
 
             return res;
         }
         return S_OK;
     case format_16bppBGRA5551:
         if (prc)
         {
             HRESULT res;
             INT x, y;
             BYTE *srcdata;
             UINT srcstride, srcdatasize;
             const BYTE *srcrow;
             const WORD *srcpixel;
             BYTE *dstrow;
             DWORD *dstpixel;
 
             srcstride = 2 * prc->Width;
             srcdatasize = srcstride * prc->Height;
 
             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
             if (!srcdata) return E_OUTOFMEMORY;
 
             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 
             if (SUCCEEDED(res))
             {
                 srcrow = srcdata;
                 dstrow = pbBuffer;
                 for (y=0; y<prc->Height; y++) {
                     srcpixel=(const WORD*)srcrow;
                     dstpixel=(DWORD*)dstrow;
                     for (x=0; x<prc->Width; x++) {
                         WORD srcval;
                         srcval=*srcpixel++;
                         *dstpixel++=((srcval & 0x8000) ? 0xff000000 : 0) | /* alpha */
                                     ((srcval << 9) & 0xf80000) | /* r */
                                     ((srcval << 4) & 0x070000) | /* r - 3 bits */
                                     ((srcval << 6) & 0x00f800) | /* g */
                                     ((srcval << 1) & 0x000700) | /* g - 3 bits */
                                     ((srcval << 3) & 0x0000f8) | /* b */
                                     ((srcval >> 2) & 0x000007);  /* b - 3 bits */
                     }
                     srcrow += srcstride;
                     dstrow += cbStride;
                 }
             }
 
             HeapFree(GetProcessHeap(), 0, srcdata);
 
             return res;
         }
         return S_OK;
     case format_24bppBGR:
         if (prc)
         {
             HRESULT res;
             INT x, y;
             BYTE *srcdata;
             UINT srcstride, srcdatasize;
             const BYTE *srcrow;
             const BYTE *srcpixel;
             BYTE *dstrow;
             BYTE *dstpixel;
 
             srcstride = 3 * prc->Width;
             srcdatasize = srcstride * prc->Height;
 
             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
             if (!srcdata) return E_OUTOFMEMORY;
 
             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 
             if (SUCCEEDED(res))
             {
                 srcrow = srcdata;
                 dstrow = pbBuffer;
                 for (y=0; y<prc->Height; y++) {
                     srcpixel=srcrow;
                     dstpixel=dstrow;
                     for (x=0; x<prc->Width; x++) {
                         *dstpixel++=*srcpixel++; /* blue */
                         *dstpixel++=*srcpixel++; /* green */
                         *dstpixel++=*srcpixel++; /* red */
                         *dstpixel++=255; /* alpha */
                     }
                     srcrow += srcstride;
                     dstrow += cbStride;
                 }
             }
 
             HeapFree(GetProcessHeap(), 0, srcdata);
 
             return res;
         }
         return S_OK;
     case format_24bppRGB:
         if (prc)
         {
             HRESULT res;
             INT x, y;
             BYTE *srcdata;
             UINT srcstride, srcdatasize;
             const BYTE *srcrow;
             const BYTE *srcpixel;
             BYTE *dstrow;
             BYTE *dstpixel;
             BYTE tmppixel[3];
 
             srcstride = 3 * prc->Width;
             srcdatasize = srcstride * prc->Height;
 
             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
             if (!srcdata) return E_OUTOFMEMORY;
 
             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 
             if (SUCCEEDED(res))
             {
                 srcrow = srcdata;
                 dstrow = pbBuffer;
                 for (y=0; y<prc->Height; y++) {
                     srcpixel=srcrow;
                     dstpixel=dstrow;
                     for (x=0; x<prc->Width; x++) {
                         tmppixel[0]=*srcpixel++; /* red */
                         tmppixel[1]=*srcpixel++; /* green */
                         tmppixel[2]=*srcpixel++; /* blue */
 
                         *dstpixel++=tmppixel[2]; /* blue */
                         *dstpixel++=tmppixel[1]; /* green */
                         *dstpixel++=tmppixel[0]; /* red */
                         *dstpixel++=255; /* alpha */
                     }
                     srcrow += srcstride;
                     dstrow += cbStride;
                 }
             }
 
             HeapFree(GetProcessHeap(), 0, srcdata);
 
             return res;
         }
         return S_OK;
     case format_32bppBGR:
         if (prc)
         {
             HRESULT res;
             INT x, y;
 
             res = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
             if (FAILED(res)) return res;
 
             /* set all alpha values to 255 */
             for (y=0; y<prc->Height; y++)
                 for (x=0; x<prc->Width; x++)
                     pbBuffer[cbStride*y+4*x+3] = 0xff;
         }
         return S_OK;
     case format_32bppBGRA:
         if (prc)
             return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
         return S_OK;
     case format_32bppPBGRA:
         if (prc)
         {
             HRESULT res;
             INT x, y;
 
             res = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
             if (FAILED(res)) return res;
 
             for (y=0; y<prc->Height; y++)
                 for (x=0; x<prc->Width; x++)
                 {
                     BYTE alpha = pbBuffer[cbStride*y+4*x+3];
                     if (alpha != 0 && alpha != 255)
                     {
                         pbBuffer[cbStride*y+4*x] = pbBuffer[cbStride*y+4*x] * 255 / alpha;
                         pbBuffer[cbStride*y+4*x+1] = pbBuffer[cbStride*y+4*x+1] * 255 / alpha;
                         pbBuffer[cbStride*y+4*x+2] = pbBuffer[cbStride*y+4*x+2] * 255 / alpha;
                     }
                 }
         }
         return S_OK;
     case format_48bppRGB:
         if (prc)
         {
             HRESULT res;
             INT x, y;
             BYTE *srcdata;
             UINT srcstride, srcdatasize;
             const BYTE *srcrow;
             const BYTE *srcpixel;
             BYTE *dstrow;
             DWORD *dstpixel;
 
             srcstride = 6 * prc->Width;
             srcdatasize = srcstride * prc->Height;
 
             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
             if (!srcdata) return E_OUTOFMEMORY;
 
             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 
             if (SUCCEEDED(res))
             {
                 srcrow = srcdata;
                 dstrow = pbBuffer;
                 for (y=0; y<prc->Height; y++) {
                     srcpixel=srcrow;
                     dstpixel=(DWORD*)dstrow;
                     for (x=0; x<prc->Width; x++) {
                         BYTE red, green, blue;
                         red = *srcpixel++; srcpixel++;
                         green = *srcpixel++; srcpixel++;
                         blue = *srcpixel++; srcpixel++;
                         *dstpixel++=0xff000000|red<<16|green<<8|blue;
                     }
                     srcrow += srcstride;
                     dstrow += cbStride;
                 }
             }
 
             HeapFree(GetProcessHeap(), 0, srcdata);
 
             return res;
         }
         return S_OK;
     case format_64bppRGBA:
         if (prc)
         {
             HRESULT res;
             INT x, y;
             BYTE *srcdata;
             UINT srcstride, srcdatasize;
             const BYTE *srcrow;
             const BYTE *srcpixel;
             BYTE *dstrow;
             DWORD *dstpixel;
 
             srcstride = 8 * prc->Width;
             srcdatasize = srcstride * prc->Height;
 
             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
             if (!srcdata) return E_OUTOFMEMORY;
 
             res = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
 
             if (SUCCEEDED(res))
             {
                 srcrow = srcdata;
                 dstrow = pbBuffer;
                 for (y=0; y<prc->Height; y++) {
                     srcpixel=srcrow;
                     dstpixel=(DWORD*)dstrow;
                     for (x=0; x<prc->Width; x++) {
                         BYTE red, green, blue, alpha;
                         red = *srcpixel++; srcpixel++;
                         green = *srcpixel++; srcpixel++;
                         blue = *srcpixel++; srcpixel++;
                         alpha = *srcpixel++; srcpixel++;
                         *dstpixel++=alpha<<24|red<<16|green<<8|blue;
                     }
                     srcrow += srcstride;
                     dstrow += cbStride;
                 }
             }
 
             HeapFree(GetProcessHeap(), 0, srcdata);
 
             return res;
         }
         return S_OK;
     case format_32bppCMYK:
         if (prc)
         {
             HRESULT res;
             UINT x, y;
 
             res = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
             if (FAILED(res)) return res;
 
             for (y=0; y<prc->Height; y++)
                 for (x=0; x<prc->Width; x++)
                 {
                     BYTE *pixel = pbBuffer+cbStride*y+4*x;
                     BYTE c=pixel[0], m=pixel[1], y=pixel[2], k=pixel[3];
                     pixel[0] = (255-y)*(255-k)/255; /* blue */
                     pixel[1] = (255-m)*(255-k)/255; /* green */
                     pixel[2] = (255-c)*(255-k)/255; /* red */
                     pixel[3] = 255; /* alpha */
                 }
         }
         return S_OK;
     default:
         return WINCODEC_ERR_UNSUPPORTEDOPERATION;
     }
 }

Referenced by copypixels_to_32bppBGR(), copypixels_to_32bppGrayFloat(), copypixels_to_32bppPBGRA(), and copypixels_to_32bppRGBA().

◆ copypixels_to_32bppGrayFloat()

static HRESULT copypixels_to_32bppGrayFloat	(	struct FormatConverter *	This,
		const WICRect *	prc,
		UINT	cbStride,
		UINT	cbBufferSize,
		BYTE *	pbBuffer,
		enum pixelformat	source_format
	)

static

Definition at line 1212 of file converter.c.

 {
     HRESULT hr;
 
     switch (source_format)
     {
     case format_32bppBGR:
     case format_32bppBGRA:
     case format_32bppPBGRA:
     case format_32bppGrayFloat:
         if (prc)
         {
             hr = IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
             break;
         }
         return S_OK;
 
     default:
         hr = copypixels_to_32bppBGRA(This, prc, cbStride, cbBufferSize, pbBuffer, source_format);
         break;
     }
 
     if (SUCCEEDED(hr) && prc && source_format != format_32bppGrayFloat)
     {
         INT x, y;
         BYTE *p = pbBuffer;
 
         for (y = 0; y < prc->Height; y++)
         {
             BYTE *bgr = p;
             for (x = 0; x < prc->Width; x++)
             {
                 float gray = (bgr[2] * 0.2126f + bgr[1] * 0.7152f + bgr[0] * 0.0722f) / 255.0f;
                 *(float *)bgr = gray;
                 bgr += 4;
             }
             p += cbStride;
         }
     }
     return hr;
 }

◆ copypixels_to_32bppPBGRA()

static HRESULT copypixels_to_32bppPBGRA	(	struct FormatConverter *	This,
		const WICRect *	prc,
		UINT	cbStride,
		UINT	cbBufferSize,
		BYTE *	pbBuffer,
		enum pixelformat	source_format
	)

static

Definition at line 920 of file converter.c.

 {
     HRESULT hr;
 
     switch (source_format)
     {
     case format_32bppPBGRA:
         if (prc)
             return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
         return S_OK;
     default:
         hr = copypixels_to_32bppBGRA(This, prc, cbStride, cbBufferSize, pbBuffer, source_format);
         if (SUCCEEDED(hr) && prc)
         {
             INT x, y;
 
             for (y=0; y<prc->Height; y++)
                 for (x=0; x<prc->Width; x++)
                 {
                     BYTE alpha = pbBuffer[cbStride*y+4*x+3];
                     if (alpha != 255)
                     {
                         pbBuffer[cbStride*y+4*x] = pbBuffer[cbStride*y+4*x] * alpha / 255;
                         pbBuffer[cbStride*y+4*x+1] = pbBuffer[cbStride*y+4*x+1] * alpha / 255;
                         pbBuffer[cbStride*y+4*x+2] = pbBuffer[cbStride*y+4*x+2] * alpha / 255;
                     }
                 }
         }
         return hr;
     }
 }

◆ copypixels_to_32bppPRGBA()

static HRESULT copypixels_to_32bppPRGBA	(	struct FormatConverter *	This,
		const WICRect *	prc,
		UINT	cbStride,
		UINT	cbBufferSize,
		BYTE *	pbBuffer,
		enum pixelformat	source_format
	)

static

Definition at line 953 of file converter.c.

 {
     HRESULT hr;
 
     switch (source_format)
     {
     case format_32bppPRGBA:
         if (prc)
             return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
         return S_OK;
     default:
         hr = copypixels_to_32bppRGBA(This, prc, cbStride, cbBufferSize, pbBuffer, source_format);
         if (SUCCEEDED(hr) && prc)
         {
             INT x, y;
 
             for (y=0; y<prc->Height; y++)
                 for (x=0; x<prc->Width; x++)
                 {
                     BYTE alpha = pbBuffer[cbStride*y+4*x+3];
                     if (alpha != 255)
                     {
                         pbBuffer[cbStride*y+4*x] = pbBuffer[cbStride*y+4*x] * alpha / 255;
                         pbBuffer[cbStride*y+4*x+1] = pbBuffer[cbStride*y+4*x+1] * alpha / 255;
                         pbBuffer[cbStride*y+4*x+2] = pbBuffer[cbStride*y+4*x+2] * alpha / 255;
                     }
                 }
         }
         return hr;
     }
 }

◆ copypixels_to_32bppRGB()

static HRESULT copypixels_to_32bppRGB	(	struct FormatConverter *	This,
		const WICRect *	prc,
		UINT	cbStride,
		UINT	cbBufferSize,
		BYTE *	pbBuffer,
		enum pixelformat	source_format
	)

static

Definition at line 904 of file converter.c.

 {
     switch (source_format)
     {
     case format_32bppRGB:
     case format_32bppRGBA:
     case format_32bppPRGBA:
         if (prc)
             return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
         return S_OK;
     default:
         return copypixels_to_32bppRGBA(This, prc, cbStride, cbBufferSize, pbBuffer, source_format);
     }
 }

◆ copypixels_to_32bppRGBA()

static HRESULT copypixels_to_32bppRGBA	(	struct FormatConverter *	This,
		const WICRect *	prc,
		UINT	cbStride,
		UINT	cbBufferSize,
		BYTE *	pbBuffer,
		enum pixelformat	source_format
	)

static

Definition at line 867 of file converter.c.

 {
     HRESULT hr;
 
     switch (source_format)
     {
     case format_32bppRGB:
     case format_32bppRGBA:
     case format_32bppPRGBA:
         if (prc)
             return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
         return S_OK;
     default:
         hr = copypixels_to_32bppBGRA(This, prc, cbStride, cbBufferSize, pbBuffer, source_format);
         if (SUCCEEDED(hr) && prc)
               reverse_bgr8(4, pbBuffer, prc->Width, prc->Height, cbStride);
         return hr;
     }
 }

Referenced by copypixels_to_32bppPRGBA(), and copypixels_to_32bppRGB().

◆ copypixels_to_8bppGray()

static HRESULT copypixels_to_8bppGray	(	struct FormatConverter *	This,
		const WICRect *	prc,
		UINT	cbStride,
		UINT	cbBufferSize,
		BYTE *	pbBuffer,
		enum pixelformat	source_format
	)

static

Definition at line 1255 of file converter.c.

 {
     HRESULT hr;
     BYTE *srcdata;
     UINT srcstride, srcdatasize;
 
     if (source_format == format_8bppGray)
     {
         if (prc)
             return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
 
         return S_OK;
     }
 
     if (source_format == format_32bppGrayFloat)
     {
         hr = S_OK;
 
         if (prc)
         {
             srcstride = 4 * prc->Width;
             srcdatasize = srcstride * prc->Height;
 
             srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
             if (!srcdata) return E_OUTOFMEMORY;
 
             hr = IWICBitmapSource_CopyPixels(This->source, prc, srcstride, srcdatasize, srcdata);
             if (SUCCEEDED(hr))
             {
                 INT x, y;
                 BYTE *src = srcdata, *dst = pbBuffer;
 
                 for (y=0; y < prc->Height; y++)
                 {
                     float *srcpixel = (float*)src;
                     BYTE *dstpixel = dst;
 
                     for (x=0; x < prc->Width; x++)
                         *dstpixel++ = (BYTE)floorf(to_sRGB_component(*srcpixel++) * 255.0f + 0.51f);
 
                     src += srcstride;
                     dst += cbStride;
                 }
             }
 
             HeapFree(GetProcessHeap(), 0, srcdata);
         }
 
         return hr;
     }
 
     srcstride = 3 * prc->Width;
     srcdatasize = srcstride * prc->Height;
 
     srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
     if (!srcdata) return E_OUTOFMEMORY;
 
     hr = copypixels_to_24bppBGR(This, prc, srcstride, srcdatasize, srcdata, source_format);
     if (SUCCEEDED(hr) && prc)
     {
         INT x, y;
         BYTE *src = srcdata, *dst = pbBuffer;
 
         for (y = 0; y < prc->Height; y++)
         {
             BYTE *bgr = src;
 
             for (x = 0; x < prc->Width; x++)
             {
                 float gray = (bgr[2] * 0.2126f + bgr[1] * 0.7152f + bgr[0] * 0.0722f) / 255.0f;
 
                 gray = to_sRGB_component(gray) * 255.0f;
                 dst[x] = (BYTE)floorf(gray + 0.51f);
                 bgr += 3;
             }
             src += srcstride;
             dst += cbStride;
         }
     }
 
     HeapFree(GetProcessHeap(), 0, srcdata);
     return hr;
 }

◆ copypixels_to_8bppIndexed()

static HRESULT copypixels_to_8bppIndexed	(	struct FormatConverter *	This,
		const WICRect *	prc,
		UINT	cbStride,
		UINT	cbBufferSize,
		BYTE *	pbBuffer,
		enum pixelformat	source_format
	)

static

Definition at line 1373 of file converter.c.

 {
     HRESULT hr;
     BYTE *srcdata;
     WICColor colors[256];
     UINT srcstride, srcdatasize, count;
 
     if (source_format == format_8bppIndexed)
     {
         if (prc)
             return IWICBitmapSource_CopyPixels(This->source, prc, cbStride, cbBufferSize, pbBuffer);
 
         return S_OK;
     }
 
     if (!This->palette) return WINCODEC_ERR_WRONGSTATE;
 
     hr = IWICPalette_GetColors(This->palette, 256, colors, &count);
     if (hr != S_OK) return hr;
 
     srcstride = 3 * prc->Width;
     srcdatasize = srcstride * prc->Height;
 
     srcdata = HeapAlloc(GetProcessHeap(), 0, srcdatasize);
     if (!srcdata) return E_OUTOFMEMORY;
 
     hr = copypixels_to_24bppBGR(This, prc, srcstride, srcdatasize, srcdata, source_format);
     if (SUCCEEDED(hr) && prc)
     {
         INT x, y;
         BYTE *src = srcdata, *dst = pbBuffer;
 
         for (y = 0; y < prc->Height; y++)
         {
             BYTE *bgr = src;
 
             for (x = 0; x < prc->Width; x++)
             {
                 dst[x] = rgb_to_palette_index(bgr[2], bgr[1], bgr[0], colors, count);
                 bgr += 3;
             }
             src += srcstride;
             dst += cbStride;
         }
     }
 
     HeapFree(GetProcessHeap(), 0, srcdata);
     return hr;
 }

◆ FormatConverter_AddRef()

static ULONG WINAPI FormatConverter_AddRef ( IWICFormatConverter * iface )

static

Definition at line 1486 of file converter.c.

 {
     FormatConverter *This = impl_from_IWICFormatConverter(iface);
     ULONG ref = InterlockedIncrement(&This->ref);
 
     TRACE("(%p) refcount=%u\n", iface, ref);
 
     return ref;
 }

◆ FormatConverter_CanConvert()

static HRESULT WINAPI FormatConverter_CanConvert	(	IWICFormatConverter *	iface,
		REFWICPixelFormatGUID	srcPixelFormat,
		REFWICPixelFormatGUID	dstPixelFormat,
		BOOL *	pfCanConvert
	)

static

Definition at line 1713 of file converter.c.

 {
     FormatConverter *This = impl_from_IWICFormatConverter(iface);
     const struct pixelformatinfo *srcinfo, *dstinfo;
 
     TRACE("(%p,%s,%s,%p)\n", iface, debugstr_guid(srcPixelFormat),
         debugstr_guid(dstPixelFormat), pfCanConvert);
 
     srcinfo = get_formatinfo(srcPixelFormat);
     if (!srcinfo)
     {
         FIXME("Unsupported source format %s\n", debugstr_guid(srcPixelFormat));
         return WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
     }
 
     dstinfo = get_formatinfo(dstPixelFormat);
     if (!dstinfo)
     {
         FIXME("Unsupported destination format %s\n", debugstr_guid(dstPixelFormat));
         return WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
     }
 
     if (dstinfo->copy_function &&
         SUCCEEDED(dstinfo->copy_function(This, NULL, 0, 0, NULL, dstinfo->format)))
         *pfCanConvert = TRUE;
     else
     {
         FIXME("Unsupported conversion %s -> %s\n", debugstr_guid(srcPixelFormat), debugstr_guid(dstPixelFormat));
         *pfCanConvert = FALSE;
     }
 
     return S_OK;
 }

◆ FormatConverter_CopyPalette()

static HRESULT WINAPI FormatConverter_CopyPalette	(	IWICFormatConverter *	iface,
		IWICPalette *	palette
	)

static

Definition at line 1556 of file converter.c.

 {
     FormatConverter *This = impl_from_IWICFormatConverter(iface);
 
     TRACE("(%p,%p)\n", iface, palette);
 
     if (!palette) return E_INVALIDARG;
     if (!This->source) return WINCODEC_ERR_WRONGSTATE;
 
     if (!This->palette)
     {
         HRESULT hr;
         UINT bpp;
 
         hr = get_pixelformat_bpp(This->dst_format->guid, &bpp);
         if (hr != S_OK) return hr;
         if (bpp <= 8) return WINCODEC_ERR_WRONGSTATE;
         return IWICBitmapSource_CopyPalette(This->source, palette);
     }
 
     return IWICPalette_InitializeFromPalette(palette, This->palette);
 }

◆ FormatConverter_CopyPixels()

static HRESULT WINAPI FormatConverter_CopyPixels	(	IWICFormatConverter *	iface,
		const WICRect *	prc,
		UINT	cbStride,
		UINT	cbBufferSize,
		BYTE *	pbBuffer
	)

static

Definition at line 1580 of file converter.c.

 {
     FormatConverter *This = impl_from_IWICFormatConverter(iface);
     WICRect rc;
     HRESULT hr;
     TRACE("(%p,%s,%u,%u,%p)\n", iface, debug_wic_rect(prc), cbStride, cbBufferSize, pbBuffer);
 
     if (This->source)
     {
         if (!prc)
         {
             UINT width, height;
             hr = IWICBitmapSource_GetSize(This->source, &width, &height);
             if (FAILED(hr)) return hr;
             rc.X = 0;
             rc.Y = 0;
             rc.Width = width;
             rc.Height = height;
             prc = &rc;
         }
 
         return This->dst_format->copy_function(This, prc, cbStride, cbBufferSize,
             pbBuffer, This->src_format->format);
     }
     else
         return WINCODEC_ERR_WRONGSTATE;
 }

◆ FormatConverter_CreateInstance()

HRESULT FormatConverter_CreateInstance	(	REFIID	iid,
		void **	ppv
	)

Definition at line 1762 of file converter.c.

 {
     FormatConverter *This;
     HRESULT ret;
 
     TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
 
     *ppv = NULL;
 
     This = HeapAlloc(GetProcessHeap(), 0, sizeof(FormatConverter));
     if (!This) return E_OUTOFMEMORY;
 
     This->IWICFormatConverter_iface.lpVtbl = &FormatConverter_Vtbl;
     This->ref = 1;
     This->source = NULL;
     This->palette = NULL;
     InitializeCriticalSection(&This->lock);
     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": FormatConverter.lock");
 
     ret = IWICFormatConverter_QueryInterface(&This->IWICFormatConverter_iface, iid, ppv);
     IWICFormatConverter_Release(&This->IWICFormatConverter_iface);
 
     return ret;
 }

Referenced by ImagingFactory_CreateFormatConverter().

◆ FormatConverter_GetPixelFormat()

static HRESULT WINAPI FormatConverter_GetPixelFormat	(	IWICFormatConverter *	iface,
		WICPixelFormatGUID *	pPixelFormat
	)

static

Definition at line 1528 of file converter.c.

 {
     FormatConverter *This = impl_from_IWICFormatConverter(iface);
 
     TRACE("(%p,%p)\n", iface, pPixelFormat);
 
     if (This->source)
         memcpy(pPixelFormat, This->dst_format->guid, sizeof(GUID));
     else
         return WINCODEC_ERR_NOTINITIALIZED;
 
     return S_OK;
 }

◆ FormatConverter_GetResolution()

static HRESULT WINAPI FormatConverter_GetResolution	(	IWICFormatConverter *	iface,
		double *	pDpiX,
		double *	pDpiY
	)

static

Definition at line 1543 of file converter.c.

 {
     FormatConverter *This = impl_from_IWICFormatConverter(iface);
 
     TRACE("(%p,%p,%p)\n", iface, pDpiX, pDpiY);
 
     if (This->source)
         return IWICBitmapSource_GetResolution(This->source, pDpiX, pDpiY);
     else
         return WINCODEC_ERR_NOTINITIALIZED;
 }

◆ FormatConverter_GetSize()

static HRESULT WINAPI FormatConverter_GetSize	(	IWICFormatConverter *	iface,
		UINT *	puiWidth,
		UINT *	puiHeight
	)

static

Definition at line 1515 of file converter.c.

 {
     FormatConverter *This = impl_from_IWICFormatConverter(iface);
 
     TRACE("(%p,%p,%p)\n", iface, puiWidth, puiHeight);
 
     if (This->source)
         return IWICBitmapSource_GetSize(This->source, puiWidth, puiHeight);
     else
         return WINCODEC_ERR_NOTINITIALIZED;
 }

◆ FormatConverter_Initialize()

static HRESULT WINAPI FormatConverter_Initialize	(	IWICFormatConverter *	iface,
		IWICBitmapSource *	source,
		REFWICPixelFormatGUID	dstFormat,
		WICBitmapDitherType	dither,
		IWICPalette *	palette,
		double	alpha_threshold,
		WICBitmapPaletteType	palette_type
	)

static

Definition at line 1609 of file converter.c.

 {
     FormatConverter *This = impl_from_IWICFormatConverter(iface);
     const struct pixelformatinfo *srcinfo, *dstinfo;
     GUID srcFormat;
     HRESULT res;
 
     TRACE("(%p,%p,%s,%u,%p,%0.3f,%u)\n", iface, source, debugstr_guid(dstFormat),
         dither, palette, alpha_threshold, palette_type);
 
     if (!palette)
     {
         UINT bpp;
         res = get_pixelformat_bpp(dstFormat, &bpp);
         if (res != S_OK) return res;
 
         res = PaletteImpl_Create(&palette);
         if (res != S_OK) return res;
 
         switch (palette_type)
         {
         case WICBitmapPaletteTypeCustom:
             IWICPalette_Release(palette);
             palette = NULL;
             if (bpp <= 8) return E_INVALIDARG;
             break;
 
         case WICBitmapPaletteTypeMedianCut:
         {
             if (bpp <= 8)
                 res = IWICPalette_InitializeFromBitmap(palette, source, 1 << bpp, FALSE);
             break;
         }
 
         default:
             if (bpp <= 8)
                 res = IWICPalette_InitializePredefined(palette, palette_type, FALSE);
             break;
         }
 
         if (res != S_OK)
         {
             IWICPalette_Release(palette);
             return res;
         }
     }
     else
         IWICPalette_AddRef(palette);
 
     EnterCriticalSection(&This->lock);
 
     if (This->source)
     {
         res = WINCODEC_ERR_WRONGSTATE;
         goto end;
     }
 
     res = IWICBitmapSource_GetPixelFormat(source, &srcFormat);
     if (FAILED(res)) goto end;
 
     srcinfo = get_formatinfo(&srcFormat);
     if (!srcinfo)
     {
         res = WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
         FIXME("Unsupported source format %s\n", debugstr_guid(&srcFormat));
         goto end;
     }
 
     dstinfo = get_formatinfo(dstFormat);
     if (!dstinfo)
     {
         res = WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT;
         FIXME("Unsupported destination format %s\n", debugstr_guid(dstFormat));
         goto end;
     }
 
     if (dstinfo->copy_function)
     {
         IWICBitmapSource_AddRef(source);
         This->src_format = srcinfo;
         This->dst_format = dstinfo;
         This->dither = dither;
         This->alpha_threshold = alpha_threshold;
         This->palette = palette;
         This->source = source;
     }
     else
     {
         FIXME("Unsupported conversion %s -> %s\n", debugstr_guid(&srcFormat), debugstr_guid(dstFormat));
         res = WINCODEC_ERR_UNSUPPORTEDOPERATION;
     }
 
 end:
 
     LeaveCriticalSection(&This->lock);
 
     if (res != S_OK && palette)
         IWICPalette_Release(palette);
 
     return res;
 }

◆ FormatConverter_QueryInterface()

static HRESULT WINAPI FormatConverter_QueryInterface	(	IWICFormatConverter *	iface,
		REFIID	iid,
		void **	ppv
	)

static

Definition at line 1462 of file converter.c.

 {
     FormatConverter *This = impl_from_IWICFormatConverter(iface);
     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 
     if (!ppv) return E_INVALIDARG;
 
     if (IsEqualIID(&IID_IUnknown, iid) ||
         IsEqualIID(&IID_IWICBitmapSource, iid) ||
         IsEqualIID(&IID_IWICFormatConverter, iid))
     {
         *ppv = &This->IWICFormatConverter_iface;
     }
     else
     {
         *ppv = NULL;
         return E_NOINTERFACE;
     }
 
     IUnknown_AddRef((IUnknown*)*ppv);
     return S_OK;
 }

◆ FormatConverter_Release()

static ULONG WINAPI FormatConverter_Release ( IWICFormatConverter * iface )

static

Definition at line 1496 of file converter.c.

 {
     FormatConverter *This = impl_from_IWICFormatConverter(iface);
     ULONG ref = InterlockedDecrement(&This->ref);
 
     TRACE("(%p) refcount=%u\n", iface, ref);
 
     if (ref == 0)
     {
         This->lock.DebugInfo->Spare[0] = 0;
         DeleteCriticalSection(&This->lock);
         if (This->source) IWICBitmapSource_Release(This->source);
         if (This->palette) IWICPalette_Release(This->palette);
         HeapFree(GetProcessHeap(), 0, This);
     }
 
     return ref;
 }

◆ from_sRGB_component()

static float from_sRGB_component ( float f )

inlinestatic

Definition at line 89 of file converter.c.

 {
     if (f <= 0.04045f) return f / 12.92f;
     return powf((f + 0.055f) / 1.055f, 2.4f);
 }

◆ get_formatinfo()

static const struct pixelformatinfo* get_formatinfo ( const WICPixelFormatGUID * format )

static

Definition at line 1452 of file converter.c.

 {
     UINT i;
 
     for (i=0; supported_formats[i].guid; i++)
         if (IsEqualGUID(supported_formats[i].guid, format)) return &supported_formats[i];
 
     return NULL;
 }

Referenced by FormatConverter_CanConvert(), and FormatConverter_Initialize().

◆ impl_from_IWICFormatConverter()

static FormatConverter* impl_from_IWICFormatConverter ( IWICFormatConverter * iface )

inlinestatic

Definition at line 138 of file converter.c.

 {
     return CONTAINING_RECORD(iface, FormatConverter, IWICFormatConverter_iface);
 }

Referenced by FormatConverter_AddRef(), FormatConverter_CanConvert(), FormatConverter_CopyPalette(), FormatConverter_CopyPixels(), FormatConverter_GetPixelFormat(), FormatConverter_GetResolution(), FormatConverter_GetSize(), FormatConverter_Initialize(), FormatConverter_QueryInterface(), and FormatConverter_Release().

◆ rgb_to_palette_index()

static UINT rgb_to_palette_index	(	BYTE	r,
		BYTE	g,
		BYTE	b,
		WICColor *	colors,
		UINT	count
	)

static

Definition at line 1340 of file converter.c.

 {
     UINT best_diff, best_index, i;
 
     best_diff = ~0;
     best_index = 0;
 
     for (i = 0; i < count; i++)
     {
         BYTE pal_r, pal_g, pal_b;
         DWORD diff_r, diff_g, diff_b, diff;
 
         pal_r = colors[i] >> 16;
         pal_g = colors[i] >> 8;
         pal_b = colors[i];
 
         diff_r = r - pal_r;
         diff_g = g - pal_g;
         diff_b = b - pal_b;
 
         diff = diff_r * diff_r + diff_g * diff_g + diff_b * diff_b;
         if (diff == 0) return i;
 
         if (diff < best_diff)
         {
             best_diff = diff;
             best_index = i;
         }
     }
 
     return best_index;
 }

Referenced by copypixels_to_8bppIndexed().

◆ to_sRGB_component()

static float to_sRGB_component ( float f )

inlinestatic

Definition at line 96 of file converter.c.

 {
     if (f <= 0.0031308f) return 12.92f * f;
     return 1.055f * powf(f, 1.0f/2.4f) - 0.055f;
 }

Referenced by copypixels_to_24bppBGR(), and copypixels_to_8bppGray().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( wincodecs )

Variable Documentation

◆ FormatConverter_Vtbl

const IWICFormatConverterVtbl FormatConverter_Vtbl

static

Initial value:

= {
    FormatConverter_QueryInterface,
    FormatConverter_AddRef,
    FormatConverter_Release,
    FormatConverter_GetSize,
    FormatConverter_GetPixelFormat,
    FormatConverter_GetResolution,
    FormatConverter_CopyPalette,
    FormatConverter_CopyPixels,
    FormatConverter_Initialize,
    FormatConverter_CanConvert
}

Definition at line 1749 of file converter.c.

Referenced by FormatConverter_CreateInstance().

◆ supported_formats

const struct pixelformatinfo supported_formats[]

static

Initial value:

= {
    {format_1bppIndexed, &GUID_WICPixelFormat1bppIndexed, NULL},
    {format_2bppIndexed, &GUID_WICPixelFormat2bppIndexed, NULL},
    {format_4bppIndexed, &GUID_WICPixelFormat4bppIndexed, NULL},
    {format_8bppIndexed, &GUID_WICPixelFormat8bppIndexed, copypixels_to_8bppIndexed},
    {format_BlackWhite, &GUID_WICPixelFormatBlackWhite, NULL},
    {format_2bppGray, &GUID_WICPixelFormat2bppGray, NULL},
    {format_4bppGray, &GUID_WICPixelFormat4bppGray, NULL},
    {format_8bppGray, &GUID_WICPixelFormat8bppGray, copypixels_to_8bppGray},
    {format_16bppGray, &GUID_WICPixelFormat16bppGray, NULL},
    {format_16bppBGR555, &GUID_WICPixelFormat16bppBGR555, NULL},
    {format_16bppBGR565, &GUID_WICPixelFormat16bppBGR565, NULL},
    {format_16bppBGRA5551, &GUID_WICPixelFormat16bppBGRA5551, NULL},
    {format_24bppBGR, &GUID_WICPixelFormat24bppBGR, copypixels_to_24bppBGR},
    {format_24bppRGB, &GUID_WICPixelFormat24bppRGB, copypixels_to_24bppRGB},
    {format_32bppGrayFloat, &GUID_WICPixelFormat32bppGrayFloat, copypixels_to_32bppGrayFloat},
    {format_32bppBGR, &GUID_WICPixelFormat32bppBGR, copypixels_to_32bppBGR},
    {format_32bppRGB, &GUID_WICPixelFormat32bppRGB, copypixels_to_32bppRGB},
    {format_32bppBGRA, &GUID_WICPixelFormat32bppBGRA, copypixels_to_32bppBGRA},
    {format_32bppRGBA, &GUID_WICPixelFormat32bppRGBA, copypixels_to_32bppRGBA},
    {format_32bppPBGRA, &GUID_WICPixelFormat32bppPBGRA, copypixels_to_32bppPBGRA},
    {format_32bppPRGBA, &GUID_WICPixelFormat32bppPRGBA, copypixels_to_32bppPRGBA},
    {format_48bppRGB, &GUID_WICPixelFormat48bppRGB, NULL},
    {format_64bppRGBA, &GUID_WICPixelFormat64bppRGBA, NULL},
    {format_32bppCMYK, &GUID_WICPixelFormat32bppCMYK, NULL},
    {0}
}

Definition at line 1424 of file converter.c.

Referenced by get_formatinfo().

Enumerations
enum	pixelformat { format_1bppIndexed, format_2bppIndexed, format_4bppIndexed, format_8bppIndexed, format_BlackWhite, format_2bppGray, format_4bppGray, format_8bppGray, format_16bppGray, format_16bppBGR555, format_16bppBGR565, format_16bppBGRA5551, format_24bppBGR, format_24bppRGB, format_32bppGrayFloat, format_32bppBGR, format_32bppRGB, format_32bppBGRA, format_32bppRGBA, format_32bppPBGRA, format_32bppPRGBA, format_48bppRGB, format_64bppRGBA, format_32bppCMYK }

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ COBJMACROS

Typedef Documentation

◆ copyfunc

◆ FormatConverter

Enumeration Type Documentation

◆ pixelformat

Function Documentation

◆ copypixels_to_24bppBGR()

◆ copypixels_to_24bppRGB()

◆ copypixels_to_32bppBGR()

◆ copypixels_to_32bppBGRA()

◆ copypixels_to_32bppGrayFloat()

◆ copypixels_to_32bppPBGRA()

◆ copypixels_to_32bppPRGBA()

◆ copypixels_to_32bppRGB()

◆ copypixels_to_32bppRGBA()

◆ copypixels_to_8bppGray()

◆ copypixels_to_8bppIndexed()

◆ FormatConverter_AddRef()

◆ FormatConverter_CanConvert()

◆ FormatConverter_CopyPalette()

◆ FormatConverter_CopyPixels()

◆ FormatConverter_CreateInstance()

◆ FormatConverter_GetPixelFormat()

◆ FormatConverter_GetResolution()

◆ FormatConverter_GetSize()

◆ FormatConverter_Initialize()

◆ FormatConverter_QueryInterface()

◆ FormatConverter_Release()

◆ from_sRGB_component()

◆ get_formatinfo()

◆ impl_from_IWICFormatConverter()

◆ rgb_to_palette_index()

◆ to_sRGB_component()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

Variable Documentation

◆ FormatConverter_Vtbl

◆ supported_formats