#include "config.h"
#include <assert.h>
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winreg.h"
#include "objbase.h"
#include "shellapi.h"
#include "wincodecs_private.h"
#include "wine/debug.h"

Include dependency graph for imgfactory.c:

Classes
struct	ImagingFactory

Macros
#define	COBJMACROS

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (wincodecs)

static ImagingFactory *	impl_from_IWICComponentFactory (IWICComponentFactory *iface)

static ImagingFactory *	impl_from_IWICImagingFactory2 (IWICImagingFactory2 *iface)

static HRESULT WINAPI	ImagingFactory_QueryInterface (IWICImagingFactory2 iface, REFIID iid, void *ppv)

static ULONG WINAPI	ImagingFactory_AddRef (IWICImagingFactory2 *iface)

static ULONG WINAPI	ImagingFactory_Release (IWICImagingFactory2 *iface)

static HRESULT WINAPI	ImagingFactory_CreateDecoderFromFilename (IWICImagingFactory2 iface, LPCWSTR wzFilename, const GUID pguidVendor, DWORD dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder **ppIDecoder)

static HRESULT	find_decoder (IStream pIStream, const GUID pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder **decoder)

static HRESULT WINAPI	ImagingFactory_CreateDecoderFromStream (IWICImagingFactory2 iface, IStream pIStream, const GUID pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder *ppIDecoder)

static HRESULT WINAPI	ImagingFactory_CreateDecoderFromFileHandle (IWICImagingFactory2 iface, ULONG_PTR hFile, const GUID pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder **ppIDecoder)

static HRESULT WINAPI	ImagingFactory_CreateComponentInfo (IWICImagingFactory2 iface, REFCLSID clsidComponent, IWICComponentInfo *ppIInfo)

static HRESULT WINAPI	ImagingFactory_CreateDecoder (IWICImagingFactory2 iface, REFGUID guidContainerFormat, const GUID pguidVendor, IWICBitmapDecoder **ppIDecoder)

static HRESULT WINAPI	ImagingFactory_CreateEncoder (IWICImagingFactory2 iface, REFGUID guidContainerFormat, const GUID pguidVendor, IWICBitmapEncoder **ppIEncoder)

static HRESULT WINAPI	ImagingFactory_CreatePalette (IWICImagingFactory2 iface, IWICPalette *ppIPalette)

static HRESULT WINAPI	ImagingFactory_CreateFormatConverter (IWICImagingFactory2 iface, IWICFormatConverter *ppIFormatConverter)

static HRESULT WINAPI	ImagingFactory_CreateBitmapScaler (IWICImagingFactory2 iface, IWICBitmapScaler *ppIBitmapScaler)

static HRESULT WINAPI	ImagingFactory_CreateBitmapClipper (IWICImagingFactory2 iface, IWICBitmapClipper *ppIBitmapClipper)

static HRESULT WINAPI	ImagingFactory_CreateBitmapFlipRotator (IWICImagingFactory2 iface, IWICBitmapFlipRotator *ppIBitmapFlipRotator)

static HRESULT WINAPI	ImagingFactory_CreateStream (IWICImagingFactory2 iface, IWICStream *ppIWICStream)

static HRESULT WINAPI	ImagingFactory_CreateColorContext (IWICImagingFactory2 iface, IWICColorContext *ppIColorContext)

static HRESULT WINAPI	ImagingFactory_CreateColorTransformer (IWICImagingFactory2 iface, IWICColorTransform *ppIColorTransform)

static HRESULT WINAPI	ImagingFactory_CreateBitmap (IWICImagingFactory2 iface, UINT uiWidth, UINT uiHeight, REFWICPixelFormatGUID pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap *ppIBitmap)

static HRESULT	create_bitmap_from_source_rect (IWICBitmapSource piBitmapSource, const WICRect rect, WICBitmapCreateCacheOption option, IWICBitmap **ppIBitmap)

static HRESULT WINAPI	ImagingFactory_CreateBitmapFromSource (IWICImagingFactory2 iface, IWICBitmapSource piBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap **ppIBitmap)

static HRESULT WINAPI	ImagingFactory_CreateBitmapFromSourceRect (IWICImagingFactory2 iface, IWICBitmapSource piBitmapSource, UINT x, UINT y, UINT width, UINT height, IWICBitmap **ppIBitmap)

static HRESULT WINAPI	ImagingFactory_CreateBitmapFromMemory (IWICImagingFactory2 iface, UINT width, UINT height, REFWICPixelFormatGUID format, UINT stride, UINT size, BYTE buffer, IWICBitmap **bitmap)

static BOOL	get_16bpp_format (HBITMAP hbm, WICPixelFormatGUID *format)

static HRESULT WINAPI	ImagingFactory_CreateBitmapFromHBITMAP (IWICImagingFactory2 iface, HBITMAP hbm, HPALETTE hpal, WICBitmapAlphaChannelOption option, IWICBitmap *bitmap)

static HRESULT WINAPI	ImagingFactory_CreateBitmapFromHICON (IWICImagingFactory2 iface, HICON hicon, IWICBitmap *bitmap)

static HRESULT WINAPI	ImagingFactory_CreateComponentEnumerator (IWICImagingFactory2 iface, DWORD componentTypes, DWORD options, IEnumUnknown *ppIEnumUnknown)

static HRESULT WINAPI	ImagingFactory_CreateFastMetadataEncoderFromDecoder (IWICImagingFactory2 iface, IWICBitmapDecoder pIDecoder, IWICFastMetadataEncoder **ppIFastEncoder)

static HRESULT WINAPI	ImagingFactory_CreateFastMetadataEncoderFromFrameDecode (IWICImagingFactory2 iface, IWICBitmapFrameDecode pIFrameDecoder, IWICFastMetadataEncoder **ppIFastEncoder)

static HRESULT WINAPI	ImagingFactory_CreateQueryWriter (IWICImagingFactory2 iface, REFGUID guidMetadataFormat, const GUID pguidVendor, IWICMetadataQueryWriter **ppIQueryWriter)

static HRESULT WINAPI	ImagingFactory_CreateQueryWriterFromReader (IWICImagingFactory2 iface, IWICMetadataQueryReader pIQueryReader, const GUID pguidVendor, IWICMetadataQueryWriter *ppIQueryWriter)

static HRESULT WINAPI	ImagingFactory_CreateImageEncoder (IWICImagingFactory2 iface, ID2D1Device device, IWICImageEncoder **encoder)

static HRESULT WINAPI	ComponentFactory_QueryInterface (IWICComponentFactory iface, REFIID iid, void *ppv)

static ULONG WINAPI	ComponentFactory_AddRef (IWICComponentFactory *iface)

static ULONG WINAPI	ComponentFactory_Release (IWICComponentFactory *iface)

static HRESULT WINAPI	ComponentFactory_CreateDecoderFromFilename (IWICComponentFactory iface, LPCWSTR filename, const GUID vendor, DWORD desired_access, WICDecodeOptions options, IWICBitmapDecoder **decoder)

static HRESULT WINAPI	ComponentFactory_CreateDecoderFromStream (IWICComponentFactory iface, IStream stream, const GUID vendor, WICDecodeOptions options, IWICBitmapDecoder *decoder)

static HRESULT WINAPI	ComponentFactory_CreateDecoderFromFileHandle (IWICComponentFactory iface, ULONG_PTR hFile, const GUID vendor, WICDecodeOptions options, IWICBitmapDecoder **decoder)

static HRESULT WINAPI	ComponentFactory_CreateComponentInfo (IWICComponentFactory iface, REFCLSID component, IWICComponentInfo *info)

static HRESULT WINAPI	ComponentFactory_CreateDecoder (IWICComponentFactory iface, REFGUID format, const GUID vendor, IWICBitmapDecoder **decoder)

static HRESULT WINAPI	ComponentFactory_CreateEncoder (IWICComponentFactory iface, REFGUID format, const GUID vendor, IWICBitmapEncoder **encoder)

static HRESULT WINAPI	ComponentFactory_CreatePalette (IWICComponentFactory iface, IWICPalette *palette)

static HRESULT WINAPI	ComponentFactory_CreateFormatConverter (IWICComponentFactory iface, IWICFormatConverter *converter)

static HRESULT WINAPI	ComponentFactory_CreateBitmapScaler (IWICComponentFactory iface, IWICBitmapScaler *scaler)

static HRESULT WINAPI	ComponentFactory_CreateBitmapClipper (IWICComponentFactory iface, IWICBitmapClipper *clipper)

static HRESULT WINAPI	ComponentFactory_CreateBitmapFlipRotator (IWICComponentFactory iface, IWICBitmapFlipRotator *fliprotator)

static HRESULT WINAPI	ComponentFactory_CreateStream (IWICComponentFactory iface, IWICStream *stream)

static HRESULT WINAPI	ComponentFactory_CreateColorContext (IWICComponentFactory iface, IWICColorContext *context)

static HRESULT WINAPI	ComponentFactory_CreateColorTransformer (IWICComponentFactory iface, IWICColorTransform *transformer)

static HRESULT WINAPI	ComponentFactory_CreateBitmap (IWICComponentFactory iface, UINT width, UINT height, REFWICPixelFormatGUID pixel_format, WICBitmapCreateCacheOption option, IWICBitmap *bitmap)

static HRESULT WINAPI	ComponentFactory_CreateBitmapFromSource (IWICComponentFactory iface, IWICBitmapSource source, WICBitmapCreateCacheOption option, IWICBitmap **bitmap)

static HRESULT WINAPI	ComponentFactory_CreateBitmapFromSourceRect (IWICComponentFactory iface, IWICBitmapSource source, UINT x, UINT y, UINT width, UINT height, IWICBitmap **bitmap)

static HRESULT WINAPI	ComponentFactory_CreateBitmapFromMemory (IWICComponentFactory iface, UINT width, UINT height, REFWICPixelFormatGUID format, UINT stride, UINT size, BYTE buffer, IWICBitmap **bitmap)

static HRESULT WINAPI	ComponentFactory_CreateBitmapFromHBITMAP (IWICComponentFactory iface, HBITMAP hbm, HPALETTE hpal, WICBitmapAlphaChannelOption option, IWICBitmap *bitmap)

static HRESULT WINAPI	ComponentFactory_CreateBitmapFromHICON (IWICComponentFactory iface, HICON hicon, IWICBitmap *bitmap)

static HRESULT WINAPI	ComponentFactory_CreateComponentEnumerator (IWICComponentFactory iface, DWORD component_types, DWORD options, IEnumUnknown *enumerator)

static HRESULT WINAPI	ComponentFactory_CreateFastMetadataEncoderFromDecoder (IWICComponentFactory iface, IWICBitmapDecoder decoder, IWICFastMetadataEncoder **encoder)

static HRESULT WINAPI	ComponentFactory_CreateFastMetadataEncoderFromFrameDecode (IWICComponentFactory iface, IWICBitmapFrameDecode frame_decode, IWICFastMetadataEncoder **encoder)

static HRESULT WINAPI	ComponentFactory_CreateQueryWriter (IWICComponentFactory iface, REFGUID format, const GUID vendor, IWICMetadataQueryWriter **writer)

static HRESULT WINAPI	ComponentFactory_CreateQueryWriterFromReader (IWICComponentFactory iface, IWICMetadataQueryReader reader, const GUID vendor, IWICMetadataQueryWriter *writer)

static HRESULT WINAPI	ComponentFactory_CreateMetadataReader (IWICComponentFactory iface, REFGUID format, const GUID vendor, DWORD options, IStream stream, IWICMetadataReader *reader)

static HRESULT WINAPI	ComponentFactory_CreateMetadataReaderFromContainer (IWICComponentFactory iface, REFGUID format, const GUID vendor, DWORD options, IStream stream, IWICMetadataReader *reader)

static HRESULT WINAPI	ComponentFactory_CreateMetadataWriter (IWICComponentFactory iface, REFGUID format, const GUID vendor, DWORD options, IWICMetadataWriter **writer)

static HRESULT WINAPI	ComponentFactory_CreateMetadataWriterFromReader (IWICComponentFactory iface, IWICMetadataReader reader, const GUID vendor, IWICMetadataWriter *writer)

static HRESULT WINAPI	ComponentFactory_CreateQueryReaderFromBlockReader (IWICComponentFactory iface, IWICMetadataBlockReader block_reader, IWICMetadataQueryReader **query_reader)

static HRESULT WINAPI	ComponentFactory_CreateQueryWriterFromBlockWriter (IWICComponentFactory iface, IWICMetadataBlockWriter block_writer, IWICMetadataQueryWriter **query_writer)

static HRESULT WINAPI	ComponentFactory_CreateEncoderPropertyBag (IWICComponentFactory iface, PROPBAG2 options, UINT count, IPropertyBag2 **property)

HRESULT	ImagingFactory_CreateInstance (REFIID iid, void **ppv)

HRESULT WINAPI	WICCreateBitmapFromSectionEx (UINT width, UINT height, REFWICPixelFormatGUID format, HANDLE section, UINT stride, UINT offset, WICSectionAccessLevel wicaccess, IWICBitmap **bitmap)

HRESULT WINAPI	WICCreateBitmapFromSection (UINT width, UINT height, REFWICPixelFormatGUID format, HANDLE section, UINT stride, UINT offset, IWICBitmap **bitmap)

Variables
static const IWICImagingFactory2Vtbl	ImagingFactory_Vtbl

static const IWICComponentFactoryVtbl	ComponentFactory_Vtbl

Macro Definition Documentation

◆ COBJMACROS

#define COBJMACROS

Definition at line 25 of file imgfactory.c.

Function Documentation

◆ ComponentFactory_AddRef()

static ULONG WINAPI ComponentFactory_AddRef ( IWICComponentFactory * iface )

static

Definition at line 1074 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_AddRef(&This->IWICImagingFactory2_iface);
}

◆ ComponentFactory_CreateBitmap()

static HRESULT WINAPI ComponentFactory_CreateBitmap	(	IWICComponentFactory *	iface,
		UINT	width,
		UINT	height,
		REFWICPixelFormatGUID	pixel_format,
		WICBitmapCreateCacheOption	option,
		IWICBitmap **	bitmap
	)

static

Definition at line 1179 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateBitmap(&This->IWICImagingFactory2_iface, width, height, pixel_format, option, bitmap);
}

◆ ComponentFactory_CreateBitmapClipper()

static HRESULT WINAPI ComponentFactory_CreateBitmapClipper	(	IWICComponentFactory *	iface,
		IWICBitmapClipper **	clipper
	)

static

Definition at line 1149 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateBitmapClipper(&This->IWICImagingFactory2_iface, clipper);
}

◆ ComponentFactory_CreateBitmapFlipRotator()

static HRESULT WINAPI ComponentFactory_CreateBitmapFlipRotator	(	IWICComponentFactory *	iface,
		IWICBitmapFlipRotator **	fliprotator
	)

static

Definition at line 1155 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateBitmapFlipRotator(&This->IWICImagingFactory2_iface, fliprotator);
}

◆ ComponentFactory_CreateBitmapFromHBITMAP()

static HRESULT WINAPI ComponentFactory_CreateBitmapFromHBITMAP	(	IWICComponentFactory *	iface,
		HBITMAP	hbm,
		HPALETTE	hpal,
		WICBitmapAlphaChannelOption	option,
		IWICBitmap **	bitmap
	)

static

Definition at line 1208 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateBitmapFromHBITMAP(&This->IWICImagingFactory2_iface, hbm, hpal, option, bitmap);
}

◆ ComponentFactory_CreateBitmapFromHICON()

static HRESULT WINAPI ComponentFactory_CreateBitmapFromHICON	(	IWICComponentFactory *	iface,
		HICON	hicon,
		IWICBitmap **	bitmap
	)

static

Definition at line 1215 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateBitmapFromHICON(&This->IWICImagingFactory2_iface, hicon, bitmap);
}

◆ ComponentFactory_CreateBitmapFromMemory()

static HRESULT WINAPI ComponentFactory_CreateBitmapFromMemory	(	IWICComponentFactory *	iface,
		UINT	width,
		UINT	height,
		REFWICPixelFormatGUID	format,
		UINT	stride,
		UINT	size,
		BYTE *	buffer,
		IWICBitmap **	bitmap
	)

static

Definition at line 1200 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateBitmapFromMemory(&This->IWICImagingFactory2_iface, width, height, format, stride,
        size, buffer, bitmap);
}

◆ ComponentFactory_CreateBitmapFromSource()

static HRESULT WINAPI ComponentFactory_CreateBitmapFromSource	(	IWICComponentFactory *	iface,
		IWICBitmapSource *	source,
		WICBitmapCreateCacheOption	option,
		IWICBitmap **	bitmap
	)

static

Definition at line 1186 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateBitmapFromSource(&This->IWICImagingFactory2_iface, source, option, bitmap);
}

◆ ComponentFactory_CreateBitmapFromSourceRect()

static HRESULT WINAPI ComponentFactory_CreateBitmapFromSourceRect	(	IWICComponentFactory *	iface,
		IWICBitmapSource *	source,
		UINT	x,
		UINT	y,
		UINT	width,
		UINT	height,
		IWICBitmap **	bitmap
	)

static

Definition at line 1193 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateBitmapFromSourceRect(&This->IWICImagingFactory2_iface, source, x, y, width, height, bitmap);
}

◆ ComponentFactory_CreateBitmapScaler()

static HRESULT WINAPI ComponentFactory_CreateBitmapScaler	(	IWICComponentFactory *	iface,
		IWICBitmapScaler **	scaler
	)

static

Definition at line 1143 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateBitmapScaler(&This->IWICImagingFactory2_iface, scaler);
}

◆ ComponentFactory_CreateColorContext()

static HRESULT WINAPI ComponentFactory_CreateColorContext	(	IWICComponentFactory *	iface,
		IWICColorContext **	context
	)

static

Definition at line 1167 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateColorContext(&This->IWICImagingFactory2_iface, context);
}

◆ ComponentFactory_CreateColorTransformer()

static HRESULT WINAPI ComponentFactory_CreateColorTransformer	(	IWICComponentFactory *	iface,
		IWICColorTransform **	transformer
	)

static

Definition at line 1173 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateColorTransformer(&This->IWICImagingFactory2_iface, transformer);
}

◆ ComponentFactory_CreateComponentEnumerator()

static HRESULT WINAPI ComponentFactory_CreateComponentEnumerator	(	IWICComponentFactory *	iface,
		DWORD	component_types,
		DWORD	options,
		IEnumUnknown **	enumerator
	)

static

Definition at line 1221 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateComponentEnumerator(&This->IWICImagingFactory2_iface, component_types,
        options, enumerator);
}

◆ ComponentFactory_CreateComponentInfo()

static HRESULT WINAPI ComponentFactory_CreateComponentInfo	(	IWICComponentFactory *	iface,
		REFCLSID	component,
		IWICComponentInfo **	info
	)

static

Definition at line 1110 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateComponentInfo(&This->IWICImagingFactory2_iface, component, info);
}

◆ ComponentFactory_CreateDecoder()

static HRESULT WINAPI ComponentFactory_CreateDecoder	(	IWICComponentFactory *	iface,
		REFGUID	format,
		const GUID *	vendor,
		IWICBitmapDecoder **	decoder
	)

static

Definition at line 1117 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateDecoder(&This->IWICImagingFactory2_iface, format, vendor, decoder);
}

◆ ComponentFactory_CreateDecoderFromFileHandle()

static HRESULT WINAPI ComponentFactory_CreateDecoderFromFileHandle	(	IWICComponentFactory *	iface,
		ULONG_PTR	hFile,
		const GUID *	vendor,
		WICDecodeOptions	options,
		IWICBitmapDecoder **	decoder
	)

static

Definition at line 1102 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateDecoderFromFileHandle(&This->IWICImagingFactory2_iface, hFile, vendor,
        options, decoder);
}

◆ ComponentFactory_CreateDecoderFromFilename()

static HRESULT WINAPI ComponentFactory_CreateDecoderFromFilename	(	IWICComponentFactory *	iface,
		LPCWSTR	filename,
		const GUID *	vendor,
		DWORD	desired_access,
		WICDecodeOptions	options,
		IWICBitmapDecoder **	decoder
	)

static

Definition at line 1086 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateDecoderFromFilename(&This->IWICImagingFactory2_iface, filename, vendor,
        desired_access, options, decoder);
}

◆ ComponentFactory_CreateDecoderFromStream()

static HRESULT WINAPI ComponentFactory_CreateDecoderFromStream	(	IWICComponentFactory *	iface,
		IStream *	stream,
		const GUID *	vendor,
		WICDecodeOptions	options,
		IWICBitmapDecoder **	decoder
	)

static

Definition at line 1094 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateDecoderFromStream(&This->IWICImagingFactory2_iface, stream, vendor,
        options, decoder);
}

◆ ComponentFactory_CreateEncoder()

static HRESULT WINAPI ComponentFactory_CreateEncoder	(	IWICComponentFactory *	iface,
		REFGUID	format,
		const GUID *	vendor,
		IWICBitmapEncoder **	encoder
	)

static

Definition at line 1124 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateEncoder(&This->IWICImagingFactory2_iface, format, vendor, encoder);
}

◆ ComponentFactory_CreateEncoderPropertyBag()

static HRESULT WINAPI ComponentFactory_CreateEncoderPropertyBag	(	IWICComponentFactory *	iface,
		PROPBAG2 *	options,
		UINT	count,
		IPropertyBag2 **	property
	)

static

Definition at line 1425 of file imgfactory.c.

{
    TRACE("(%p,%p,%u,%p)\n", iface, options, count, property);
    return CreatePropertyBag2(options, count, property);
}

◆ ComponentFactory_CreateFastMetadataEncoderFromDecoder()

static HRESULT WINAPI ComponentFactory_CreateFastMetadataEncoderFromDecoder	(	IWICComponentFactory *	iface,
		IWICBitmapDecoder *	decoder,
		IWICFastMetadataEncoder **	encoder
	)

static

Definition at line 1229 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateFastMetadataEncoderFromDecoder(&This->IWICImagingFactory2_iface, decoder, encoder);
}

◆ ComponentFactory_CreateFastMetadataEncoderFromFrameDecode()

static HRESULT WINAPI ComponentFactory_CreateFastMetadataEncoderFromFrameDecode	(	IWICComponentFactory *	iface,
		IWICBitmapFrameDecode *	frame_decode,
		IWICFastMetadataEncoder **	encoder
	)

static

Definition at line 1236 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateFastMetadataEncoderFromFrameDecode(&This->IWICImagingFactory2_iface, frame_decode, encoder);
}

◆ ComponentFactory_CreateFormatConverter()

static HRESULT WINAPI ComponentFactory_CreateFormatConverter	(	IWICComponentFactory *	iface,
		IWICFormatConverter **	converter
	)

static

Definition at line 1137 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateFormatConverter(&This->IWICImagingFactory2_iface, converter);
}

◆ ComponentFactory_CreateMetadataReader()

static HRESULT WINAPI ComponentFactory_CreateMetadataReader	(	IWICComponentFactory *	iface,
		REFGUID	format,
		const GUID *	vendor,
		DWORD	options,
		IStream *	stream,
		IWICMetadataReader **	reader
	)

static

Definition at line 1257 of file imgfactory.c.

{
    FIXME("%p,%s,%s,%x,%p,%p: stub\n", iface, debugstr_guid(format), debugstr_guid(vendor),
        options, stream, reader);
    return E_NOTIMPL;
}

◆ ComponentFactory_CreateMetadataReaderFromContainer()

static HRESULT WINAPI ComponentFactory_CreateMetadataReaderFromContainer	(	IWICComponentFactory *	iface,
		REFGUID	format,
		const GUID *	vendor,
		DWORD	options,
		IStream *	stream,
		IWICMetadataReader **	reader
	)

static

Definition at line 1265 of file imgfactory.c.

{
    HRESULT hr;
    IEnumUnknown *enumreaders;
    IUnknown *unkreaderinfo;
    IWICMetadataReaderInfo *readerinfo;
    IWICPersistStream *wicpersiststream;
    ULONG num_fetched;
    GUID decoder_vendor;
    BOOL matches;
    LARGE_INTEGER zero;
 
    TRACE("%p,%s,%s,%x,%p,%p\n", iface, debugstr_guid(format), debugstr_guid(vendor),
        options, stream, reader);
 
    if (!format || !stream || !reader)
        return E_INVALIDARG;
 
    zero.QuadPart = 0;
 
    hr = CreateComponentEnumerator(WICMetadataReader, WICComponentEnumerateDefault, &enumreaders);
    if (FAILED(hr)) return hr;
 
    *reader = NULL;
 
start:
    while (!*reader)
    {
        hr = IEnumUnknown_Next(enumreaders, 1, &unkreaderinfo, &num_fetched);
 
        if (hr == S_OK)
        {
            hr = IUnknown_QueryInterface(unkreaderinfo, &IID_IWICMetadataReaderInfo, (void**)&readerinfo);
 
            if (SUCCEEDED(hr))
            {
                if (vendor)
                {
                    hr = IWICMetadataReaderInfo_GetVendorGUID(readerinfo, &decoder_vendor);
 
                    if (FAILED(hr) || !IsEqualIID(vendor, &decoder_vendor))
                    {
                        IWICMetadataReaderInfo_Release(readerinfo);
                        IUnknown_Release(unkreaderinfo);
                        continue;
                    }
                }
 
                hr = IWICMetadataReaderInfo_MatchesPattern(readerinfo, format, stream, &matches);
 
                if (SUCCEEDED(hr) && matches)
                {
                    hr = IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
 
                    if (SUCCEEDED(hr))
                        hr = IWICMetadataReaderInfo_CreateInstance(readerinfo, reader);
 
                    if (SUCCEEDED(hr))
                    {
                        hr = IWICMetadataReader_QueryInterface(*reader, &IID_IWICPersistStream, (void**)&wicpersiststream);
 
                        if (SUCCEEDED(hr))
                        {
                            hr = IWICPersistStream_LoadEx(wicpersiststream,
                                stream, vendor, options & WICPersistOptionMask);
 
                            IWICPersistStream_Release(wicpersiststream);
                        }
 
                        if (FAILED(hr))
                        {
                            IWICMetadataReader_Release(*reader);
                            *reader = NULL;
                        }
                    }
                }
 
                IUnknown_Release(readerinfo);
            }
 
            IUnknown_Release(unkreaderinfo);
        }
        else
            break;
    }
 
    if (!*reader && vendor)
    {
        vendor = NULL;
        IEnumUnknown_Reset(enumreaders);
        goto start;
    }
 
    IEnumUnknown_Release(enumreaders);
 
    if (!*reader && !(options & WICMetadataCreationFailUnknown))
    {
        hr = IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
 
        if (SUCCEEDED(hr))
            hr = UnknownMetadataReader_CreateInstance(&IID_IWICMetadataReader, (void**)reader);
 
        if (SUCCEEDED(hr))
        {
            hr = IWICMetadataReader_QueryInterface(*reader, &IID_IWICPersistStream, (void**)&wicpersiststream);
 
            if (SUCCEEDED(hr))
            {
                hr = IWICPersistStream_LoadEx(wicpersiststream, stream, NULL, options & WICPersistOptionMask);
 
                IWICPersistStream_Release(wicpersiststream);
            }
 
            if (FAILED(hr))
            {
                IWICMetadataReader_Release(*reader);
                *reader = NULL;
            }
        }
    }
 
    if (*reader)
        return S_OK;
    else
        return WINCODEC_ERR_COMPONENTNOTFOUND;
}

◆ ComponentFactory_CreateMetadataWriter()

static HRESULT WINAPI ComponentFactory_CreateMetadataWriter	(	IWICComponentFactory *	iface,
		REFGUID	format,
		const GUID *	vendor,
		DWORD	options,
		IWICMetadataWriter **	writer
	)

static

Definition at line 1393 of file imgfactory.c.

{
    FIXME("%p,%s,%s,%x,%p: stub\n", iface, debugstr_guid(format), debugstr_guid(vendor), options, writer);
    return E_NOTIMPL;
}

◆ ComponentFactory_CreateMetadataWriterFromReader()

static HRESULT WINAPI ComponentFactory_CreateMetadataWriterFromReader	(	IWICComponentFactory *	iface,
		IWICMetadataReader *	reader,
		const GUID *	vendor,
		IWICMetadataWriter **	writer
	)

static

Definition at line 1400 of file imgfactory.c.

{
    FIXME("%p,%p,%s,%p: stub\n", iface, reader, debugstr_guid(vendor), writer);
    return E_NOTIMPL;
}

◆ ComponentFactory_CreatePalette()

static HRESULT WINAPI ComponentFactory_CreatePalette	(	IWICComponentFactory *	iface,
		IWICPalette **	palette
	)

static

Definition at line 1131 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreatePalette(&This->IWICImagingFactory2_iface, palette);
}

◆ ComponentFactory_CreateQueryReaderFromBlockReader()

static HRESULT WINAPI ComponentFactory_CreateQueryReaderFromBlockReader	(	IWICComponentFactory *	iface,
		IWICMetadataBlockReader *	block_reader,
		IWICMetadataQueryReader **	query_reader
	)

static

Definition at line 1407 of file imgfactory.c.

{
    TRACE("%p,%p,%p\n", iface, block_reader, query_reader);
 
    if (!block_reader || !query_reader)
        return E_INVALIDARG;
 
    return MetadataQueryReader_CreateInstance(block_reader, NULL, query_reader);
}

◆ ComponentFactory_CreateQueryWriter()

static HRESULT WINAPI ComponentFactory_CreateQueryWriter	(	IWICComponentFactory *	iface,
		REFGUID	format,
		const GUID *	vendor,
		IWICMetadataQueryWriter **	writer
	)

static

Definition at line 1243 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateQueryWriter(&This->IWICImagingFactory2_iface, format, vendor, writer);
}

◆ ComponentFactory_CreateQueryWriterFromBlockWriter()

static HRESULT WINAPI ComponentFactory_CreateQueryWriterFromBlockWriter	(	IWICComponentFactory *	iface,
		IWICMetadataBlockWriter *	block_writer,
		IWICMetadataQueryWriter **	query_writer
	)

static

Definition at line 1418 of file imgfactory.c.

{
    FIXME("%p,%p,%p: stub\n", iface, block_writer, query_writer);
    return E_NOTIMPL;
}

◆ ComponentFactory_CreateQueryWriterFromReader()

static HRESULT WINAPI ComponentFactory_CreateQueryWriterFromReader	(	IWICComponentFactory *	iface,
		IWICMetadataQueryReader *	reader,
		const GUID *	vendor,
		IWICMetadataQueryWriter **	writer
	)

static

Definition at line 1250 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateQueryWriterFromReader(&This->IWICImagingFactory2_iface, reader, vendor, writer);
}

◆ ComponentFactory_CreateStream()

static HRESULT WINAPI ComponentFactory_CreateStream	(	IWICComponentFactory *	iface,
		IWICStream **	stream
	)

static

Definition at line 1161 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_CreateStream(&This->IWICImagingFactory2_iface, stream);
}

◆ ComponentFactory_QueryInterface()

static HRESULT WINAPI ComponentFactory_QueryInterface	(	IWICComponentFactory *	iface,
		REFIID	iid,
		void **	ppv
	)

static

Definition at line 1068 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_QueryInterface(&This->IWICImagingFactory2_iface, iid, ppv);
}

◆ ComponentFactory_Release()

static ULONG WINAPI ComponentFactory_Release ( IWICComponentFactory * iface )

static

Definition at line 1080 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICComponentFactory(iface);
    return IWICImagingFactory2_Release(&This->IWICImagingFactory2_iface);
}

◆ create_bitmap_from_source_rect()

static HRESULT create_bitmap_from_source_rect	(	IWICBitmapSource *	piBitmapSource,
		const WICRect *	rect,
		WICBitmapCreateCacheOption	option,
		IWICBitmap **	ppIBitmap
	)

static

Definition at line 495 of file imgfactory.c.

{
    IWICBitmap *result;
    IWICBitmapLock *lock;
    IWICPalette *palette;
    UINT width, height;
    WICPixelFormatGUID pixelformat = {0};
    HRESULT hr;
    WICRect rc;
    double dpix, dpiy;
    IWICComponentInfo *info;
    IWICPixelFormatInfo2 *formatinfo;
    WICPixelFormatNumericRepresentation format_type;
 
    assert(!rect || option == WICBitmapCacheOnLoad);
 
    if (!piBitmapSource || !ppIBitmap)
        return E_INVALIDARG;
 
    if (option == WICBitmapNoCache && SUCCEEDED(IWICBitmapSource_QueryInterface(piBitmapSource,
            &IID_IWICBitmap, (void **)&result)))
    {
        *ppIBitmap = result;
        return S_OK;
    }
 
    hr = IWICBitmapSource_GetSize(piBitmapSource, &width, &height);
 
    if (SUCCEEDED(hr) && rect)
    {
        if (rect->X >= width || rect->Y >= height || rect->Width == 0 || rect->Height == 0)
            return E_INVALIDARG;
 
        width = min(width - rect->X, rect->Width);
        height = min(height - rect->Y, rect->Height);
    }
 
    if (SUCCEEDED(hr))
        hr = IWICBitmapSource_GetPixelFormat(piBitmapSource, &pixelformat);
 
    if (SUCCEEDED(hr))
        hr = CreateComponentInfo(&pixelformat, &info);
 
    if (SUCCEEDED(hr))
    {
        hr = IWICComponentInfo_QueryInterface(info, &IID_IWICPixelFormatInfo2, (void**)&formatinfo);
 
        if (SUCCEEDED(hr))
        {
            hr = IWICPixelFormatInfo2_GetNumericRepresentation(formatinfo, &format_type);
 
            IWICPixelFormatInfo2_Release(formatinfo);
        }
 
        IWICComponentInfo_Release(info);
    }
 
    if (SUCCEEDED(hr))
        hr = BitmapImpl_Create(width, height, 0, 0, NULL, 0, &pixelformat, option, &result);
 
    if (SUCCEEDED(hr))
    {
        hr = IWICBitmap_Lock(result, NULL, WICBitmapLockWrite, &lock);
        if (SUCCEEDED(hr))
        {
            UINT stride, buffersize;
            BYTE *buffer;
 
            if (rect)
            {
                rc.X = rect->X;
                rc.Y = rect->Y;
            }
            else
                rc.X = rc.Y = 0;
            rc.Width = width;
            rc.Height = height;
 
            hr = IWICBitmapLock_GetStride(lock, &stride);
 
            if (SUCCEEDED(hr))
                hr = IWICBitmapLock_GetDataPointer(lock, &buffersize, &buffer);
 
            if (SUCCEEDED(hr))
                hr = IWICBitmapSource_CopyPixels(piBitmapSource, &rc, stride,
                    buffersize, buffer);
 
            IWICBitmapLock_Release(lock);
        }
 
        if (SUCCEEDED(hr) && (format_type == WICPixelFormatNumericRepresentationUnspecified ||
                              format_type == WICPixelFormatNumericRepresentationIndexed))
        {
            hr = PaletteImpl_Create(&palette);
 
            if (SUCCEEDED(hr))
            {
                hr = IWICBitmapSource_CopyPalette(piBitmapSource, palette);
 
                if (SUCCEEDED(hr))
                    hr = IWICBitmap_SetPalette(result, palette);
                else
                    hr = S_OK;
 
                IWICPalette_Release(palette);
            }
        }
 
        if (SUCCEEDED(hr))
        {
            hr = IWICBitmapSource_GetResolution(piBitmapSource, &dpix, &dpiy);
 
            if (SUCCEEDED(hr))
                hr = IWICBitmap_SetResolution(result, dpix, dpiy);
            else
                hr = S_OK;
        }
 
        if (SUCCEEDED(hr))
            *ppIBitmap = result;
        else
            IWICBitmap_Release(result);
    }
 
    return hr;
}

Referenced by ImagingFactory_CreateBitmapFromSource(), and ImagingFactory_CreateBitmapFromSourceRect().

◆ find_decoder()

static HRESULT find_decoder	(	IStream *	pIStream,
		const GUID *	pguidVendor,
		WICDecodeOptions	metadataOptions,
		IWICBitmapDecoder **	decoder
	)

static

Definition at line 134 of file imgfactory.c.

{
    IEnumUnknown *enumdecoders;
    IUnknown *unkdecoderinfo;
    IWICBitmapDecoderInfo *decoderinfo;
    GUID vendor;
    HRESULT res;
    ULONG num_fetched;
    BOOL matches;
 
    *decoder = NULL;
 
    res = CreateComponentEnumerator(WICDecoder, WICComponentEnumerateDefault, &enumdecoders);
    if (FAILED(res)) return res;
 
    while (!*decoder)
    {
        res = IEnumUnknown_Next(enumdecoders, 1, &unkdecoderinfo, &num_fetched);
 
        if (res == S_OK)
        {
            res = IUnknown_QueryInterface(unkdecoderinfo, &IID_IWICBitmapDecoderInfo, (void**)&decoderinfo);
 
            if (SUCCEEDED(res))
            {
                if (pguidVendor)
                {
                    res = IWICBitmapDecoderInfo_GetVendorGUID(decoderinfo, &vendor);
                    if (FAILED(res) || !IsEqualIID(&vendor, pguidVendor))
                    {
                        IWICBitmapDecoderInfo_Release(decoderinfo);
                        IUnknown_Release(unkdecoderinfo);
                        continue;
                    }
                }
 
                res = IWICBitmapDecoderInfo_MatchesPattern(decoderinfo, pIStream, &matches);
 
                if (SUCCEEDED(res) && matches)
                {
                    res = IWICBitmapDecoderInfo_CreateInstance(decoderinfo, decoder);
 
                    /* FIXME: should use QueryCapability to choose a decoder */
 
                    if (SUCCEEDED(res))
                    {
                        res = IWICBitmapDecoder_Initialize(*decoder, pIStream, metadataOptions);
 
                        if (FAILED(res))
                        {
                            IWICBitmapDecoder_Release(*decoder);
                            IWICBitmapDecoderInfo_Release(decoderinfo);
                            IUnknown_Release(unkdecoderinfo);
                            IEnumUnknown_Release(enumdecoders);
                            *decoder = NULL;
                            return res;
                        }
                    }
                }
 
                IWICBitmapDecoderInfo_Release(decoderinfo);
            }
 
            IUnknown_Release(unkdecoderinfo);
        }
        else
            break;
    }
 
    IEnumUnknown_Release(enumdecoders);
 
    return WINCODEC_ERR_COMPONENTNOTFOUND;
}

Referenced by ImagingFactory_CreateDecoderFromStream().

◆ get_16bpp_format()

static BOOL get_16bpp_format	(	HBITMAP	hbm,
		WICPixelFormatGUID *	format
	)

static

Definition at line 685 of file imgfactory.c.

{
    BOOL ret = TRUE;
    BITMAPV4HEADER bmh;
    HDC hdc;
 
    hdc = CreateCompatibleDC(0);
 
    memset(&bmh, 0, sizeof(bmh));
    bmh.bV4Size = sizeof(bmh);
    bmh.bV4Width = 1;
    bmh.bV4Height = 1;
    bmh.bV4V4Compression = BI_BITFIELDS;
    bmh.bV4BitCount = 16;
 
    GetDIBits(hdc, hbm, 0, 0, NULL, (BITMAPINFO *)&bmh, DIB_RGB_COLORS);
 
    if (bmh.bV4RedMask == 0x7c00 &&
        bmh.bV4GreenMask == 0x3e0 &&
        bmh.bV4BlueMask == 0x1f)
    {
        *format = GUID_WICPixelFormat16bppBGR555;
    }
    else if (bmh.bV4RedMask == 0xf800 &&
        bmh.bV4GreenMask == 0x7e0 &&
        bmh.bV4BlueMask == 0x1f)
    {
        *format = GUID_WICPixelFormat16bppBGR565;
    }
    else
    {
        FIXME("unrecognized bitfields %x,%x,%x\n", bmh.bV4RedMask,
            bmh.bV4GreenMask, bmh.bV4BlueMask);
        ret = FALSE;
    }
 
    DeleteDC(hdc);
    return ret;
}

Referenced by ImagingFactory_CreateBitmapFromHBITMAP().

◆ ImagingFactory_AddRef()

static ULONG WINAPI ImagingFactory_AddRef ( IWICImagingFactory2 * iface )

static

Definition at line 83 of file imgfactory.c.

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

◆ ImagingFactory_CreateBitmap()

static HRESULT WINAPI ImagingFactory_CreateBitmap	(	IWICImagingFactory2 *	iface,
		UINT	uiWidth,
		UINT	uiHeight,
		REFWICPixelFormatGUID	pixelFormat,
		WICBitmapCreateCacheOption	option,
		IWICBitmap **	ppIBitmap
	)

static

Definition at line 486 of file imgfactory.c.

{
    TRACE("(%p,%u,%u,%s,%u,%p)\n", iface, uiWidth, uiHeight,
        debugstr_guid(pixelFormat), option, ppIBitmap);
    return BitmapImpl_Create(uiWidth, uiHeight, 0, 0, NULL, 0, pixelFormat, option, ppIBitmap);
}

◆ ImagingFactory_CreateBitmapClipper()

static HRESULT WINAPI ImagingFactory_CreateBitmapClipper	(	IWICImagingFactory2 *	iface,
		IWICBitmapClipper **	ppIBitmapClipper
	)

static

Definition at line 451 of file imgfactory.c.

{
    TRACE("(%p,%p)\n", iface, ppIBitmapClipper);
    return BitmapClipper_Create(ppIBitmapClipper);
}

◆ ImagingFactory_CreateBitmapFlipRotator()

static HRESULT WINAPI ImagingFactory_CreateBitmapFlipRotator	(	IWICImagingFactory2 *	iface,
		IWICBitmapFlipRotator **	ppIBitmapFlipRotator
	)

static

Definition at line 458 of file imgfactory.c.

{
    TRACE("(%p,%p)\n", iface, ppIBitmapFlipRotator);
    return FlipRotator_Create(ppIBitmapFlipRotator);
}

◆ ImagingFactory_CreateBitmapFromHBITMAP()

static HRESULT WINAPI ImagingFactory_CreateBitmapFromHBITMAP	(	IWICImagingFactory2 *	iface,
		HBITMAP	hbm,
		HPALETTE	hpal,
		WICBitmapAlphaChannelOption	option,
		IWICBitmap **	bitmap
	)

static

Definition at line 725 of file imgfactory.c.

{
    BITMAP bm;
    HRESULT hr;
    WICPixelFormatGUID format;
    IWICBitmapLock *lock;
    UINT size, num_palette_entries = 0;
    PALETTEENTRY entry[256];
 
    TRACE("(%p,%p,%p,%u,%p)\n", iface, hbm, hpal, option, bitmap);
 
    if (!bitmap) return E_INVALIDARG;
 
    if (GetObjectW(hbm, sizeof(bm), &bm) != sizeof(bm))
        return WINCODEC_ERR_WIN32ERROR;
 
    if (hpal)
    {
        num_palette_entries = GetPaletteEntries(hpal, 0, 256, entry);
        if (!num_palette_entries)
            return WINCODEC_ERR_WIN32ERROR;
    }
 
    /* TODO: Figure out the correct format for 16, 32, 64 bpp */
    switch(bm.bmBitsPixel)
    {
    case 1:
        format = GUID_WICPixelFormat1bppIndexed;
        break;
    case 4:
        format = GUID_WICPixelFormat4bppIndexed;
        break;
    case 8:
        format = GUID_WICPixelFormat8bppIndexed;
        break;
    case 16:
        if (!get_16bpp_format(hbm, &format))
            return E_INVALIDARG;
        break;
    case 24:
        format = GUID_WICPixelFormat24bppBGR;
        break;
    case 32:
        switch (option)
        {
        case WICBitmapUseAlpha:
            format = GUID_WICPixelFormat32bppBGRA;
            break;
        case WICBitmapUsePremultipliedAlpha:
            format = GUID_WICPixelFormat32bppPBGRA;
            break;
        case WICBitmapIgnoreAlpha:
            format = GUID_WICPixelFormat32bppBGR;
            break;
        default:
            return E_INVALIDARG;
        }
        break;
    case 48:
        format = GUID_WICPixelFormat48bppRGB;
        break;
    default:
        FIXME("unsupported %d bpp\n", bm.bmBitsPixel);
        return E_INVALIDARG;
    }
 
    hr = BitmapImpl_Create(bm.bmWidth, bm.bmHeight, bm.bmWidthBytes, 0, NULL, 0, &format,
                           WICBitmapCacheOnLoad, bitmap);
    if (hr != S_OK) return hr;
 
    hr = IWICBitmap_Lock(*bitmap, NULL, WICBitmapLockWrite, &lock);
    if (hr == S_OK)
    {
        BYTE *buffer;
        HDC hdc;
        char bmibuf[FIELD_OFFSET(BITMAPINFO, bmiColors) + 256 * sizeof(RGBQUAD)];
        BITMAPINFO *bmi = (BITMAPINFO *)bmibuf;
 
        IWICBitmapLock_GetDataPointer(lock, &size, &buffer);
 
        hdc = CreateCompatibleDC(0);
 
        bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
        bmi->bmiHeader.biBitCount = 0;
        GetDIBits(hdc, hbm, 0, 0, NULL, bmi, DIB_RGB_COLORS);
        bmi->bmiHeader.biHeight = -bm.bmHeight;
        GetDIBits(hdc, hbm, 0, bm.bmHeight, buffer, bmi, DIB_RGB_COLORS);
 
        DeleteDC(hdc);
        IWICBitmapLock_Release(lock);
 
        if (num_palette_entries)
        {
            IWICPalette *palette;
            WICColor colors[256];
            UINT i;
 
            hr = PaletteImpl_Create(&palette);
            if (hr == S_OK)
            {
                for (i = 0; i < num_palette_entries; i++)
                    colors[i] = 0xff000000 | entry[i].peRed << 16 |
                                entry[i].peGreen << 8 | entry[i].peBlue;
 
                hr = IWICPalette_InitializeCustom(palette, colors, num_palette_entries);
                if (hr == S_OK)
                    hr = IWICBitmap_SetPalette(*bitmap, palette);
 
                IWICPalette_Release(palette);
            }
        }
    }
 
    if (hr != S_OK)
    {
        IWICBitmap_Release(*bitmap);
        *bitmap = NULL;
    }
 
    return hr;
}

◆ ImagingFactory_CreateBitmapFromHICON()

static HRESULT WINAPI ImagingFactory_CreateBitmapFromHICON	(	IWICImagingFactory2 *	iface,
		HICON	hicon,
		IWICBitmap **	bitmap
	)

static

Definition at line 848 of file imgfactory.c.

{
    IWICBitmapLock *lock;
    ICONINFO info;
    BITMAP bm;
    int width, height, x, y;
    UINT stride, size;
    BYTE *buffer;
    DWORD *bits;
    BITMAPINFO bi;
    HDC hdc;
    BOOL has_alpha;
    HRESULT hr;
 
    TRACE("(%p,%p,%p)\n", iface, hicon, bitmap);
 
    if (!bitmap) return E_INVALIDARG;
 
    if (!GetIconInfo(hicon, &info))
        return HRESULT_FROM_WIN32(GetLastError());
 
    GetObjectW(info.hbmColor ? info.hbmColor : info.hbmMask, sizeof(bm), &bm);
 
    width = bm.bmWidth;
    height = info.hbmColor ? abs(bm.bmHeight) : abs(bm.bmHeight) / 2;
    stride = width * 4;
    size = stride * height;
 
    hr = BitmapImpl_Create(width, height, stride, size, NULL, 0,
                           &GUID_WICPixelFormat32bppBGRA, WICBitmapCacheOnLoad, bitmap);
    if (hr != S_OK) goto failed;
 
    hr = IWICBitmap_Lock(*bitmap, NULL, WICBitmapLockWrite, &lock);
    if (hr != S_OK)
    {
        IWICBitmap_Release(*bitmap);
        goto failed;
    }
    IWICBitmapLock_GetDataPointer(lock, &size, &buffer);
 
    hdc = CreateCompatibleDC(0);
 
    memset(&bi, 0, sizeof(bi));
    bi.bmiHeader.biSize = sizeof(bi.bmiHeader);
    bi.bmiHeader.biWidth = width;
    bi.bmiHeader.biHeight = info.hbmColor ? -height: -height * 2;
    bi.bmiHeader.biPlanes = 1;
    bi.bmiHeader.biBitCount = 32;
    bi.bmiHeader.biCompression = BI_RGB;
 
    has_alpha = FALSE;
 
    if (info.hbmColor)
    {
        GetDIBits(hdc, info.hbmColor, 0, height, buffer, &bi, DIB_RGB_COLORS);
 
        if (bm.bmBitsPixel == 32)
        {
            /* If any pixel has a non-zero alpha, ignore hbmMask */
            bits = (DWORD *)buffer;
            for (x = 0; x < width && !has_alpha; x++, bits++)
            {
                for (y = 0; y < height; y++)
                {
                    if (*bits & 0xff000000)
                    {
                        has_alpha = TRUE;
                        break;
                    }
                }
            }
        }
    }
    else
        GetDIBits(hdc, info.hbmMask, 0, height, buffer, &bi, DIB_RGB_COLORS);
 
    if (!has_alpha)
    {
        DWORD *rgba;
 
        if (info.hbmMask)
        {
            BYTE *mask;
 
            mask = HeapAlloc(GetProcessHeap(), 0, size);
            if (!mask)
            {
                IWICBitmapLock_Release(lock);
                IWICBitmap_Release(*bitmap);
                DeleteDC(hdc);
                hr = E_OUTOFMEMORY;
                goto failed;
            }
 
            /* read alpha data from the mask */
            GetDIBits(hdc, info.hbmMask, info.hbmColor ? 0 : height, height, mask, &bi, DIB_RGB_COLORS);
 
            for (y = 0; y < height; y++)
            {
                rgba = (DWORD *)(buffer + y * stride);
                bits = (DWORD *)(mask + y * stride);
 
                for (x = 0; x < width; x++, rgba++, bits++)
                {
                    if (*bits)
                        *rgba = 0;
                    else
                        *rgba |= 0xff000000;
                }
            }
 
            HeapFree(GetProcessHeap(), 0, mask);
        }
        else
        {
            /* set constant alpha of 255 */
            for (y = 0; y < height; y++)
            {
                rgba = (DWORD *)(buffer + y * stride);
                for (x = 0; x < width; x++, rgba++)
                    *rgba |= 0xff000000;
            }
        }
 
    }
 
    IWICBitmapLock_Release(lock);
    DeleteDC(hdc);
 
failed:
    DeleteObject(info.hbmColor);
    DeleteObject(info.hbmMask);
 
    return hr;
}

◆ ImagingFactory_CreateBitmapFromMemory()

static HRESULT WINAPI ImagingFactory_CreateBitmapFromMemory	(	IWICImagingFactory2 *	iface,
		UINT	width,
		UINT	height,
		REFWICPixelFormatGUID	format,
		UINT	stride,
		UINT	size,
		BYTE *	buffer,
		IWICBitmap **	bitmap
	)

static

Definition at line 649 of file imgfactory.c.

{
    HRESULT hr;
 
    TRACE("(%p,%u,%u,%s,%u,%u,%p,%p\n", iface, width, height,
        debugstr_guid(format), stride, size, buffer, bitmap);
 
    if (!stride || !size || !buffer || !bitmap) return E_INVALIDARG;
 
    hr = BitmapImpl_Create(width, height, stride, size, NULL, 0, format, WICBitmapCacheOnLoad, bitmap);
    if (SUCCEEDED(hr))
    {
        IWICBitmapLock *lock;
 
        hr = IWICBitmap_Lock(*bitmap, NULL, WICBitmapLockWrite, &lock);
        if (SUCCEEDED(hr))
        {
            UINT buffersize;
            BYTE *data;
 
            IWICBitmapLock_GetDataPointer(lock, &buffersize, &data);
            memcpy(data, buffer, buffersize);
 
            IWICBitmapLock_Release(lock);
        }
        else
        {
            IWICBitmap_Release(*bitmap);
            *bitmap = NULL;
        }
    }
    return hr;
}

◆ ImagingFactory_CreateBitmapFromSource()

static HRESULT WINAPI ImagingFactory_CreateBitmapFromSource	(	IWICImagingFactory2 *	iface,
		IWICBitmapSource *	piBitmapSource,
		WICBitmapCreateCacheOption	option,
		IWICBitmap **	ppIBitmap
	)

static

Definition at line 623 of file imgfactory.c.

{
    TRACE("(%p,%p,%u,%p)\n", iface, piBitmapSource, option, ppIBitmap);
 
    return create_bitmap_from_source_rect(piBitmapSource, NULL, option, ppIBitmap);
}

◆ ImagingFactory_CreateBitmapFromSourceRect()

static HRESULT WINAPI ImagingFactory_CreateBitmapFromSourceRect	(	IWICImagingFactory2 *	iface,
		IWICBitmapSource *	piBitmapSource,
		UINT	x,
		UINT	y,
		UINT	width,
		UINT	height,
		IWICBitmap **	ppIBitmap
	)

static

Definition at line 632 of file imgfactory.c.

{
    WICRect rect;
 
    TRACE("(%p,%p,%u,%u,%u,%u,%p)\n", iface, piBitmapSource, x, y, width,
        height, ppIBitmap);
 
    rect.X = x;
    rect.Y = y;
    rect.Width = width;
    rect.Height = height;
 
    return create_bitmap_from_source_rect(piBitmapSource, &rect, WICBitmapCacheOnLoad, ppIBitmap);
}

◆ ImagingFactory_CreateBitmapScaler()

static HRESULT WINAPI ImagingFactory_CreateBitmapScaler	(	IWICImagingFactory2 *	iface,
		IWICBitmapScaler **	ppIBitmapScaler
	)

static

Definition at line 443 of file imgfactory.c.

{
    TRACE("(%p,%p)\n", iface, ppIBitmapScaler);
 
    return BitmapScaler_Create(ppIBitmapScaler);
}

◆ ImagingFactory_CreateColorContext()

static HRESULT WINAPI ImagingFactory_CreateColorContext	(	IWICImagingFactory2 *	iface,
		IWICColorContext **	ppIColorContext
	)

static

Definition at line 472 of file imgfactory.c.

{
    TRACE("(%p,%p)\n", iface, ppIColorContext);
    return ColorContext_Create(ppIColorContext);
}

◆ ImagingFactory_CreateColorTransformer()

static HRESULT WINAPI ImagingFactory_CreateColorTransformer	(	IWICImagingFactory2 *	iface,
		IWICColorTransform **	ppIColorTransform
	)

static

Definition at line 479 of file imgfactory.c.

{
    TRACE("(%p,%p)\n", iface, ppIColorTransform);
    return ColorTransform_Create(ppIColorTransform);
}

◆ ImagingFactory_CreateComponentEnumerator()

static HRESULT WINAPI ImagingFactory_CreateComponentEnumerator	(	IWICImagingFactory2 *	iface,
		DWORD	componentTypes,
		DWORD	options,
		IEnumUnknown **	ppIEnumUnknown
	)

static

Definition at line 985 of file imgfactory.c.

{
    TRACE("(%p,%u,%u,%p)\n", iface, componentTypes, options, ppIEnumUnknown);
    return CreateComponentEnumerator(componentTypes, options, ppIEnumUnknown);
}

◆ ImagingFactory_CreateComponentInfo()

static HRESULT WINAPI ImagingFactory_CreateComponentInfo	(	IWICImagingFactory2 *	iface,
		REFCLSID	clsidComponent,
		IWICComponentInfo **	ppIInfo
	)

static

Definition at line 275 of file imgfactory.c.

{
    TRACE("(%p,%s,%p)\n", iface, debugstr_guid(clsidComponent), ppIInfo);
    return CreateComponentInfo(clsidComponent, ppIInfo);
}

◆ ImagingFactory_CreateDecoder()

static HRESULT WINAPI ImagingFactory_CreateDecoder	(	IWICImagingFactory2 *	iface,
		REFGUID	guidContainerFormat,
		const GUID *	pguidVendor,
		IWICBitmapDecoder **	ppIDecoder
	)

static

Definition at line 282 of file imgfactory.c.

{
    IEnumUnknown *enumdecoders;
    IUnknown *unkdecoderinfo;
    IWICBitmapDecoderInfo *decoderinfo;
    IWICBitmapDecoder *decoder = NULL, *preferred_decoder = NULL;
    GUID vendor;
    HRESULT res;
    ULONG num_fetched;
 
    TRACE("(%p,%s,%s,%p)\n", iface, debugstr_guid(guidContainerFormat),
        debugstr_guid(pguidVendor), ppIDecoder);
 
    if (!guidContainerFormat || !ppIDecoder) return E_INVALIDARG;
 
    res = CreateComponentEnumerator(WICDecoder, WICComponentEnumerateDefault, &enumdecoders);
    if (FAILED(res)) return res;
 
    while (!preferred_decoder)
    {
        res = IEnumUnknown_Next(enumdecoders, 1, &unkdecoderinfo, &num_fetched);
        if (res != S_OK) break;
 
        res = IUnknown_QueryInterface(unkdecoderinfo, &IID_IWICBitmapDecoderInfo, (void **)&decoderinfo);
        if (SUCCEEDED(res))
        {
            GUID container_guid;
 
            res = IWICBitmapDecoderInfo_GetContainerFormat(decoderinfo, &container_guid);
            if (SUCCEEDED(res) && IsEqualIID(&container_guid, guidContainerFormat))
            {
                IWICBitmapDecoder *new_decoder;
 
                res = IWICBitmapDecoderInfo_CreateInstance(decoderinfo, &new_decoder);
                if (SUCCEEDED(res))
                {
                    if (pguidVendor)
                    {
                        res = IWICBitmapDecoderInfo_GetVendorGUID(decoderinfo, &vendor);
                        if (SUCCEEDED(res) && IsEqualIID(&vendor, pguidVendor))
                        {
                            preferred_decoder = new_decoder;
                            new_decoder = NULL;
                        }
                    }
 
                    if (new_decoder && !decoder)
                    {
                        decoder = new_decoder;
                        new_decoder = NULL;
                    }
 
                    if (new_decoder) IWICBitmapDecoder_Release(new_decoder);
                }
            }
 
            IWICBitmapDecoderInfo_Release(decoderinfo);
        }
 
        IUnknown_Release(unkdecoderinfo);
    }
 
    IEnumUnknown_Release(enumdecoders);
 
    if (preferred_decoder)
    {
        *ppIDecoder = preferred_decoder;
        if (decoder) IWICBitmapDecoder_Release(decoder);
        return S_OK;
    }
 
    if (decoder)
    {
        *ppIDecoder = decoder;
        return S_OK;
    }
 
    *ppIDecoder = NULL;
    return WINCODEC_ERR_COMPONENTNOTFOUND;
}

◆ ImagingFactory_CreateDecoderFromFileHandle()

static HRESULT WINAPI ImagingFactory_CreateDecoderFromFileHandle	(	IWICImagingFactory2 *	iface,
		ULONG_PTR	hFile,
		const GUID *	pguidVendor,
		WICDecodeOptions	metadataOptions,
		IWICBitmapDecoder **	ppIDecoder
	)

static

Definition at line 251 of file imgfactory.c.

{
    IWICStream *stream;
    HRESULT hr;
 
    TRACE("(%p,%lx,%s,%u,%p)\n", iface, hFile, debugstr_guid(pguidVendor),
        metadataOptions, ppIDecoder);
 
    hr = StreamImpl_Create(&stream);
    if (SUCCEEDED(hr))
    {
        hr = stream_initialize_from_filehandle(stream, (HANDLE)hFile);
        if (SUCCEEDED(hr))
        {
            hr = IWICImagingFactory2_CreateDecoderFromStream(iface, (IStream*)stream,
                pguidVendor, metadataOptions, ppIDecoder);
        }
        IWICStream_Release(stream);
    }
    return hr;
}

◆ ImagingFactory_CreateDecoderFromFilename()

static HRESULT WINAPI ImagingFactory_CreateDecoderFromFilename	(	IWICImagingFactory2 *	iface,
		LPCWSTR	wzFilename,
		const GUID *	pguidVendor,
		DWORD	dwDesiredAccess,
		WICDecodeOptions	metadataOptions,
		IWICBitmapDecoder **	ppIDecoder
	)

static

Definition at line 106 of file imgfactory.c.

{
    IWICStream *stream;
    HRESULT hr;
 
    TRACE("(%p,%s,%s,%u,%u,%p)\n", iface, debugstr_w(wzFilename),
        debugstr_guid(pguidVendor), dwDesiredAccess, metadataOptions, ppIDecoder);
 
    hr = StreamImpl_Create(&stream);
    if (SUCCEEDED(hr))
    {
        hr = IWICStream_InitializeFromFilename(stream, wzFilename, dwDesiredAccess);
 
        if (SUCCEEDED(hr))
        {
            hr = IWICImagingFactory2_CreateDecoderFromStream(iface, (IStream*)stream,
                pguidVendor, metadataOptions, ppIDecoder);
        }
 
        IWICStream_Release(stream);
    }
 
    return hr;
}

◆ ImagingFactory_CreateDecoderFromStream()

static HRESULT WINAPI ImagingFactory_CreateDecoderFromStream	(	IWICImagingFactory2 *	iface,
		IStream *	pIStream,
		const GUID *	pguidVendor,
		WICDecodeOptions	metadataOptions,
		IWICBitmapDecoder **	ppIDecoder
	)

static

Definition at line 209 of file imgfactory.c.

{
    HRESULT res;
    IWICBitmapDecoder *decoder = NULL;
 
    TRACE("(%p,%p,%s,%u,%p)\n", iface, pIStream, debugstr_guid(pguidVendor),
        metadataOptions, ppIDecoder);
 
    if (pguidVendor)
        res = find_decoder(pIStream, pguidVendor, metadataOptions, &decoder);
    if (!decoder)
        res = find_decoder(pIStream, NULL, metadataOptions, &decoder);
 
    if (decoder)
    {
        *ppIDecoder = decoder;
        return S_OK;
    }
    else
    {
        if (WARN_ON(wincodecs))
        {
            LARGE_INTEGER seek;
            BYTE data[4];
            ULONG bytesread;
 
            WARN("failed to load from a stream %#x\n", res);
 
            seek.QuadPart = 0;
            if (IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL) == S_OK)
            {
                if (IStream_Read(pIStream, data, 4, &bytesread) == S_OK)
                    WARN("first %i bytes of stream=%x %x %x %x\n", bytesread, data[0], data[1], data[2], data[3]);
            }
        }
        *ppIDecoder = NULL;
        return res;
    }
}

◆ ImagingFactory_CreateEncoder()

static HRESULT WINAPI ImagingFactory_CreateEncoder	(	IWICImagingFactory2 *	iface,
		REFGUID	guidContainerFormat,
		const GUID *	pguidVendor,
		IWICBitmapEncoder **	ppIEncoder
	)

static

Definition at line 365 of file imgfactory.c.

{
    static int fixme=0;
    IEnumUnknown *enumencoders;
    IUnknown *unkencoderinfo;
    IWICBitmapEncoderInfo *encoderinfo;
    IWICBitmapEncoder *encoder=NULL;
    HRESULT res=S_OK;
    ULONG num_fetched;
    GUID actual_containerformat;
 
    TRACE("(%p,%s,%s,%p)\n", iface, debugstr_guid(guidContainerFormat),
        debugstr_guid(pguidVendor), ppIEncoder);
 
    if (pguidVendor && !fixme++)
        FIXME("ignoring vendor GUID\n");
 
    res = CreateComponentEnumerator(WICEncoder, WICComponentEnumerateDefault, &enumencoders);
    if (FAILED(res)) return res;
 
    while (!encoder)
    {
        res = IEnumUnknown_Next(enumencoders, 1, &unkencoderinfo, &num_fetched);
 
        if (res == S_OK)
        {
            res = IUnknown_QueryInterface(unkencoderinfo, &IID_IWICBitmapEncoderInfo, (void**)&encoderinfo);
 
            if (SUCCEEDED(res))
            {
                res = IWICBitmapEncoderInfo_GetContainerFormat(encoderinfo, &actual_containerformat);
 
                if (SUCCEEDED(res) && IsEqualGUID(guidContainerFormat, &actual_containerformat))
                {
                    res = IWICBitmapEncoderInfo_CreateInstance(encoderinfo, &encoder);
                    if (FAILED(res))
                        encoder = NULL;
                }
 
                IWICBitmapEncoderInfo_Release(encoderinfo);
            }
 
            IUnknown_Release(unkencoderinfo);
        }
        else
            break;
    }
 
    IEnumUnknown_Release(enumencoders);
 
    if (encoder)
    {
        *ppIEncoder = encoder;
        return S_OK;
    }
    else
    {
        WARN("failed to create encoder\n");
        *ppIEncoder = NULL;
        return WINCODEC_ERR_COMPONENTNOTFOUND;
    }
}

◆ ImagingFactory_CreateFastMetadataEncoderFromDecoder()

static HRESULT WINAPI ImagingFactory_CreateFastMetadataEncoderFromDecoder	(	IWICImagingFactory2 *	iface,
		IWICBitmapDecoder *	pIDecoder,
		IWICFastMetadataEncoder **	ppIFastEncoder
	)

static

Definition at line 992 of file imgfactory.c.

{
    FIXME("(%p,%p,%p): stub\n", iface, pIDecoder, ppIFastEncoder);
    return E_NOTIMPL;
}

◆ ImagingFactory_CreateFastMetadataEncoderFromFrameDecode()

static HRESULT WINAPI ImagingFactory_CreateFastMetadataEncoderFromFrameDecode	(	IWICImagingFactory2 *	iface,
		IWICBitmapFrameDecode *	pIFrameDecoder,
		IWICFastMetadataEncoder **	ppIFastEncoder
	)

static

Definition at line 1000 of file imgfactory.c.

{
    FIXME("(%p,%p,%p): stub\n", iface, pIFrameDecoder, ppIFastEncoder);
    return E_NOTIMPL;
}

◆ ImagingFactory_CreateFormatConverter()

static HRESULT WINAPI ImagingFactory_CreateFormatConverter	(	IWICImagingFactory2 *	iface,
		IWICFormatConverter **	ppIFormatConverter
	)

static

Definition at line 437 of file imgfactory.c.

{
    return FormatConverter_CreateInstance(&IID_IWICFormatConverter, (void**)ppIFormatConverter);
}

◆ ImagingFactory_CreateImageEncoder()

static HRESULT WINAPI ImagingFactory_CreateImageEncoder	(	IWICImagingFactory2 *	iface,
		ID2D1Device *	device,
		IWICImageEncoder **	encoder
	)

static

Definition at line 1027 of file imgfactory.c.

{
    FIXME("%p,%p,%p stub.\n", iface, device, encoder);
    return E_NOTIMPL;
}

◆ ImagingFactory_CreateInstance()

HRESULT ImagingFactory_CreateInstance	(	REFIID	iid,
		void **	ppv
	)

Definition at line 1470 of file imgfactory.c.

{
    ImagingFactory *This;
    HRESULT ret;
 
    TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
 
    *ppv = NULL;
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
    if (!This) return E_OUTOFMEMORY;
 
    This->IWICImagingFactory2_iface.lpVtbl = &ImagingFactory_Vtbl;
    This->IWICComponentFactory_iface.lpVtbl = &ComponentFactory_Vtbl;
    This->ref = 1;
 
    ret = IWICImagingFactory2_QueryInterface(&This->IWICImagingFactory2_iface, iid, ppv);
    IWICImagingFactory2_Release(&This->IWICImagingFactory2_iface);
 
    return ret;
}

Referenced by PaletteImpl_InitializeFromBitmap(), and WICCreateImagingFactory_Proxy().

◆ ImagingFactory_CreatePalette()

static HRESULT WINAPI ImagingFactory_CreatePalette	(	IWICImagingFactory2 *	iface,
		IWICPalette **	ppIPalette
	)

static

Definition at line 430 of file imgfactory.c.

{
    TRACE("(%p,%p)\n", iface, ppIPalette);
    return PaletteImpl_Create(ppIPalette);
}

◆ ImagingFactory_CreateQueryWriter()

static HRESULT WINAPI ImagingFactory_CreateQueryWriter	(	IWICImagingFactory2 *	iface,
		REFGUID	guidMetadataFormat,
		const GUID *	pguidVendor,
		IWICMetadataQueryWriter **	ppIQueryWriter
	)

static

Definition at line 1008 of file imgfactory.c.

{
    FIXME("(%p,%s,%s,%p): stub\n", iface, debugstr_guid(guidMetadataFormat),
        debugstr_guid(pguidVendor), ppIQueryWriter);
    return E_NOTIMPL;
}

◆ ImagingFactory_CreateQueryWriterFromReader()

static HRESULT WINAPI ImagingFactory_CreateQueryWriterFromReader	(	IWICImagingFactory2 *	iface,
		IWICMetadataQueryReader *	pIQueryReader,
		const GUID *	pguidVendor,
		IWICMetadataQueryWriter **	ppIQueryWriter
	)

static

Definition at line 1017 of file imgfactory.c.

{
    FIXME("(%p,%p,%s,%p): stub\n", iface, pIQueryReader, debugstr_guid(pguidVendor),
        ppIQueryWriter);
    return E_NOTIMPL;
}

◆ ImagingFactory_CreateStream()

static HRESULT WINAPI ImagingFactory_CreateStream	(	IWICImagingFactory2 *	iface,
		IWICStream **	ppIWICStream
	)

static

Definition at line 465 of file imgfactory.c.

{
    TRACE("(%p,%p)\n", iface, ppIWICStream);
    return StreamImpl_Create(ppIWICStream);
}

◆ ImagingFactory_QueryInterface()

static HRESULT WINAPI ImagingFactory_QueryInterface	(	IWICImagingFactory2 *	iface,
		REFIID	iid,
		void **	ppv
	)

static

Definition at line 55 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICImagingFactory2(iface);
    TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 
    if (!ppv) return E_INVALIDARG;
 
    if (IsEqualIID(&IID_IUnknown, iid) ||
        IsEqualIID(&IID_IWICImagingFactory, iid) ||
        IsEqualIID(&IID_IWICComponentFactory, iid))
    {
        *ppv = &This->IWICComponentFactory_iface;
    }
    else if (IsEqualIID(&IID_IWICImagingFactory2, iid))
    {
        *ppv = &This->IWICImagingFactory2_iface;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

◆ ImagingFactory_Release()

static ULONG WINAPI ImagingFactory_Release ( IWICImagingFactory2 * iface )

static

Definition at line 93 of file imgfactory.c.

{
    ImagingFactory *This = impl_from_IWICImagingFactory2(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p) refcount=%u\n", iface, ref);
 
    if (ref == 0)
        HeapFree(GetProcessHeap(), 0, This);
 
    return ref;
}

◆ impl_from_IWICComponentFactory()

static ImagingFactory * impl_from_IWICComponentFactory ( IWICComponentFactory * iface )

inlinestatic

Definition at line 45 of file imgfactory.c.

{
    return CONTAINING_RECORD(iface, ImagingFactory, IWICComponentFactory_iface);
}

◆ impl_from_IWICImagingFactory2()

static ImagingFactory * impl_from_IWICImagingFactory2 ( IWICImagingFactory2 * iface )

inlinestatic

Definition at line 50 of file imgfactory.c.

{
    return CONTAINING_RECORD(iface, ImagingFactory, IWICImagingFactory2_iface);
}

Referenced by ImagingFactory_AddRef(), ImagingFactory_QueryInterface(), and ImagingFactory_Release().

◆ WICCreateBitmapFromSection()

HRESULT WINAPI WICCreateBitmapFromSection	(	UINT	width,
		UINT	height,
		REFWICPixelFormatGUID	format,
		HANDLE	section,
		UINT	stride,
		UINT	offset,
		IWICBitmap **	bitmap
	)

Definition at line 1541 of file imgfactory.c.

{
    TRACE("%u,%u,%s,%p,%u,%u,%p\n", width, height, debugstr_guid(format),
        section, stride, offset, bitmap);
 
    return WICCreateBitmapFromSectionEx(width, height, format, section,
        stride, offset, WICSectionAccessLevelRead, bitmap);
}

◆ WICCreateBitmapFromSectionEx()

HRESULT WINAPI WICCreateBitmapFromSectionEx	(	UINT	width,
		UINT	height,
		REFWICPixelFormatGUID	format,
		HANDLE	section,
		UINT	stride,
		UINT	offset,
		WICSectionAccessLevel	wicaccess,
		IWICBitmap **	bitmap
	)

Definition at line 1492 of file imgfactory.c.

{
    SYSTEM_INFO sysinfo;
    UINT bpp, access, size, view_offset, view_size;
    void *view;
    HRESULT hr;
 
    TRACE("%u,%u,%s,%p,%u,%u,%#x,%p\n", width, height, debugstr_guid(format),
          section, stride, offset, wicaccess, bitmap);
 
    if (!width || !height || !section || !bitmap) return E_INVALIDARG;
 
    hr = get_pixelformat_bpp(format, &bpp);
    if (FAILED(hr)) return hr;
 
    switch (wicaccess)
    {
    case WICSectionAccessLevelReadWrite:
        access = FILE_MAP_READ | FILE_MAP_WRITE;
        break;
 
    case WICSectionAccessLevelRead:
        access = FILE_MAP_READ;
        break;
 
    default:
        FIXME("unsupported access %#x\n", wicaccess);
        return E_INVALIDARG;
    }
 
    if (!stride) stride = (((bpp * width) + 31) / 32) * 4;
    size = stride * height;
    if (size / height != stride) return E_INVALIDARG;
 
    GetSystemInfo(&sysinfo);
    view_offset = offset - (offset % sysinfo.dwAllocationGranularity);
    view_size = size + (offset - view_offset);
 
    view = MapViewOfFile(section, access, 0, view_offset, view_size);
    if (!view) return HRESULT_FROM_WIN32(GetLastError());
 
    offset -= view_offset;
    hr = BitmapImpl_Create(width, height, stride, 0, view, offset, format, WICBitmapCacheOnLoad, bitmap);
    if (FAILED(hr)) UnmapViewOfFile(view);
    return hr;
}

Referenced by WICCreateBitmapFromSection().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( wincodecs )

Variable Documentation

◆ ComponentFactory_Vtbl

const IWICComponentFactoryVtbl ComponentFactory_Vtbl

static

Definition at line 1432 of file imgfactory.c.

Referenced by ImagingFactory_CreateInstance().

◆ ImagingFactory_Vtbl

const IWICImagingFactory2Vtbl ImagingFactory_Vtbl

static

Definition at line 1034 of file imgfactory.c.

Referenced by ImagingFactory_CreateInstance().

Classes

Macros

Functions

Variables

Macro Definition Documentation

◆ COBJMACROS

Function Documentation

◆ ComponentFactory_AddRef()

◆ ComponentFactory_CreateBitmap()

◆ ComponentFactory_CreateBitmapClipper()

◆ ComponentFactory_CreateBitmapFlipRotator()

◆ ComponentFactory_CreateBitmapFromHBITMAP()

◆ ComponentFactory_CreateBitmapFromHICON()

◆ ComponentFactory_CreateBitmapFromMemory()

◆ ComponentFactory_CreateBitmapFromSource()

◆ ComponentFactory_CreateBitmapFromSourceRect()

◆ ComponentFactory_CreateBitmapScaler()

◆ ComponentFactory_CreateColorContext()

◆ ComponentFactory_CreateColorTransformer()

◆ ComponentFactory_CreateComponentEnumerator()

◆ ComponentFactory_CreateComponentInfo()

◆ ComponentFactory_CreateDecoder()

◆ ComponentFactory_CreateDecoderFromFileHandle()

◆ ComponentFactory_CreateDecoderFromFilename()

◆ ComponentFactory_CreateDecoderFromStream()

◆ ComponentFactory_CreateEncoder()

◆ ComponentFactory_CreateEncoderPropertyBag()

◆ ComponentFactory_CreateFastMetadataEncoderFromDecoder()

◆ ComponentFactory_CreateFastMetadataEncoderFromFrameDecode()

◆ ComponentFactory_CreateFormatConverter()

◆ ComponentFactory_CreateMetadataReader()

◆ ComponentFactory_CreateMetadataReaderFromContainer()

◆ ComponentFactory_CreateMetadataWriter()

◆ ComponentFactory_CreateMetadataWriterFromReader()

◆ ComponentFactory_CreatePalette()

◆ ComponentFactory_CreateQueryReaderFromBlockReader()

◆ ComponentFactory_CreateQueryWriter()

◆ ComponentFactory_CreateQueryWriterFromBlockWriter()

◆ ComponentFactory_CreateQueryWriterFromReader()

◆ ComponentFactory_CreateStream()

◆ ComponentFactory_QueryInterface()

◆ ComponentFactory_Release()

◆ create_bitmap_from_source_rect()

◆ find_decoder()

◆ get_16bpp_format()

◆ ImagingFactory_AddRef()

◆ ImagingFactory_CreateBitmap()

◆ ImagingFactory_CreateBitmapClipper()

◆ ImagingFactory_CreateBitmapFlipRotator()

◆ ImagingFactory_CreateBitmapFromHBITMAP()

◆ ImagingFactory_CreateBitmapFromHICON()

◆ ImagingFactory_CreateBitmapFromMemory()

◆ ImagingFactory_CreateBitmapFromSource()

◆ ImagingFactory_CreateBitmapFromSourceRect()

◆ ImagingFactory_CreateBitmapScaler()

◆ ImagingFactory_CreateColorContext()

◆ ImagingFactory_CreateColorTransformer()

◆ ImagingFactory_CreateComponentEnumerator()

◆ ImagingFactory_CreateComponentInfo()

◆ ImagingFactory_CreateDecoder()

◆ ImagingFactory_CreateDecoderFromFileHandle()

◆ ImagingFactory_CreateDecoderFromFilename()

◆ ImagingFactory_CreateDecoderFromStream()

◆ ImagingFactory_CreateEncoder()

◆ ImagingFactory_CreateFastMetadataEncoderFromDecoder()

◆ ImagingFactory_CreateFastMetadataEncoderFromFrameDecode()

◆ ImagingFactory_CreateFormatConverter()

◆ ImagingFactory_CreateImageEncoder()

◆ ImagingFactory_CreateInstance()

◆ ImagingFactory_CreatePalette()

◆ ImagingFactory_CreateQueryWriter()

◆ ImagingFactory_CreateQueryWriterFromReader()

◆ ImagingFactory_CreateStream()

◆ ImagingFactory_QueryInterface()

◆ ImagingFactory_Release()

◆ impl_from_IWICComponentFactory()

◆ impl_from_IWICImagingFactory2()

◆ WICCreateBitmapFromSection()

◆ WICCreateBitmapFromSectionEx()

◆ WINE_DEFAULT_DEBUG_CHANNEL()