info.c File Reference

#include "config.h"
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winreg.h"
#include "objbase.h"
#include "wincodecs_private.h"
#include "wine/debug.h"
#include "wine/unicode.h"
#include "wine/list.h"
#include "wine/rbtree.h"
#include "wine/heap.h"

Include dependency graph for info.c:

Go to the source code of this file.

Classes
struct	ComponentInfo
struct	BitmapDecoderInfo
struct	BitmapEncoderInfo
struct	FormatConverterInfo
struct	PixelFormatInfo
struct	metadata_container
struct	MetadataReaderInfo
struct	category
struct	ComponentEnum
struct	ComponentEnumItem

Macros
#define	COBJMACROS

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (wincodecs)
static HRESULT	ComponentInfo_GetStringValue (HKEY classkey, LPCWSTR value, UINT buffer_size, WCHAR *buffer, UINT *actual_size)
static HRESULT	ComponentInfo_GetGUIDValue (HKEY classkey, LPCWSTR value, GUID *result)
static HRESULT	ComponentInfo_GetDWORDValue (HKEY classkey, LPCWSTR value, DWORD *result)
static HRESULT	ComponentInfo_GetGuidList (HKEY classkey, LPCWSTR subkeyname, UINT buffersize, GUID *buffer, UINT *actual_size)
static BitmapDecoderInfo *	impl_from_IWICBitmapDecoderInfo (IWICBitmapDecoderInfo *iface)
static HRESULT WINAPI	BitmapDecoderInfo_QueryInterface (IWICBitmapDecoderInfo *iface, REFIID iid, void **ppv)
static ULONG WINAPI	BitmapDecoderInfo_AddRef (IWICBitmapDecoderInfo *iface)
static ULONG WINAPI	BitmapDecoderInfo_Release (IWICBitmapDecoderInfo *iface)
static HRESULT WINAPI	BitmapDecoderInfo_GetComponentType (IWICBitmapDecoderInfo *iface, WICComponentType *pType)
static HRESULT WINAPI	BitmapDecoderInfo_GetCLSID (IWICBitmapDecoderInfo *iface, CLSID *pclsid)
static HRESULT WINAPI	BitmapDecoderInfo_GetSigningStatus (IWICBitmapDecoderInfo *iface, DWORD *pStatus)
static HRESULT WINAPI	BitmapDecoderInfo_GetAuthor (IWICBitmapDecoderInfo *iface, UINT cchAuthor, WCHAR *wzAuthor, UINT *pcchActual)
static HRESULT WINAPI	BitmapDecoderInfo_GetVendorGUID (IWICBitmapDecoderInfo *iface, GUID *pguidVendor)
static HRESULT WINAPI	BitmapDecoderInfo_GetVersion (IWICBitmapDecoderInfo *iface, UINT cchVersion, WCHAR *wzVersion, UINT *pcchActual)
static HRESULT WINAPI	BitmapDecoderInfo_GetSpecVersion (IWICBitmapDecoderInfo *iface, UINT cchSpecVersion, WCHAR *wzSpecVersion, UINT *pcchActual)
static HRESULT WINAPI	BitmapDecoderInfo_GetFriendlyName (IWICBitmapDecoderInfo *iface, UINT cchFriendlyName, WCHAR *wzFriendlyName, UINT *pcchActual)
static HRESULT WINAPI	BitmapDecoderInfo_GetContainerFormat (IWICBitmapDecoderInfo *iface, GUID *pguidContainerFormat)
static HRESULT WINAPI	BitmapDecoderInfo_GetPixelFormats (IWICBitmapDecoderInfo *iface, UINT cFormats, GUID *pguidPixelFormats, UINT *pcActual)
static HRESULT WINAPI	BitmapDecoderInfo_GetColorManagementVersion (IWICBitmapDecoderInfo *iface, UINT cchColorManagementVersion, WCHAR *wzColorManagementVersion, UINT *pcchActual)
static HRESULT WINAPI	BitmapDecoderInfo_GetDeviceManufacturer (IWICBitmapDecoderInfo *iface, UINT cchDeviceManufacturer, WCHAR *wzDeviceManufacturer, UINT *pcchActual)
static HRESULT WINAPI	BitmapDecoderInfo_GetDeviceModels (IWICBitmapDecoderInfo *iface, UINT cchDeviceModels, WCHAR *wzDeviceModels, UINT *pcchActual)
static HRESULT WINAPI	BitmapDecoderInfo_GetMimeTypes (IWICBitmapDecoderInfo *iface, UINT cchMimeTypes, WCHAR *wzMimeTypes, UINT *pcchActual)
static HRESULT WINAPI	BitmapDecoderInfo_GetFileExtensions (IWICBitmapDecoderInfo *iface, UINT cchFileExtensions, WCHAR *wzFileExtensions, UINT *pcchActual)
static HRESULT WINAPI	BitmapDecoderInfo_DoesSupportAnimation (IWICBitmapDecoderInfo *iface, BOOL *pfSupportAnimation)
static HRESULT WINAPI	BitmapDecoderInfo_DoesSupportChromaKey (IWICBitmapDecoderInfo *iface, BOOL *pfSupportChromaKey)
static HRESULT WINAPI	BitmapDecoderInfo_DoesSupportLossless (IWICBitmapDecoderInfo *iface, BOOL *pfSupportLossless)
static HRESULT WINAPI	BitmapDecoderInfo_DoesSupportMultiframe (IWICBitmapDecoderInfo *iface, BOOL *pfSupportMultiframe)
static HRESULT WINAPI	BitmapDecoderInfo_MatchesMimeType (IWICBitmapDecoderInfo *iface, LPCWSTR wzMimeType, BOOL *pfMatches)
static HRESULT WINAPI	BitmapDecoderInfo_GetPatterns (IWICBitmapDecoderInfo *iface, UINT cbSizePatterns, WICBitmapPattern *pPatterns, UINT *pcPatterns, UINT *pcbPatternsActual)
static HRESULT WINAPI	BitmapDecoderInfo_MatchesPattern (IWICBitmapDecoderInfo *iface, IStream *pIStream, BOOL *pfMatches)
static HRESULT WINAPI	BitmapDecoderInfo_CreateInstance (IWICBitmapDecoderInfo *iface, IWICBitmapDecoder **ppIBitmapDecoder)
static void	read_bitmap_patterns (BitmapDecoderInfo *info)
static HRESULT	BitmapDecoderInfo_Constructor (HKEY classkey, REFCLSID clsid, ComponentInfo **ret)
static BitmapEncoderInfo *	impl_from_IWICBitmapEncoderInfo (IWICBitmapEncoderInfo *iface)
static HRESULT WINAPI	BitmapEncoderInfo_QueryInterface (IWICBitmapEncoderInfo *iface, REFIID iid, void **ppv)
static ULONG WINAPI	BitmapEncoderInfo_AddRef (IWICBitmapEncoderInfo *iface)
static ULONG WINAPI	BitmapEncoderInfo_Release (IWICBitmapEncoderInfo *iface)
static HRESULT WINAPI	BitmapEncoderInfo_GetComponentType (IWICBitmapEncoderInfo *iface, WICComponentType *pType)
static HRESULT WINAPI	BitmapEncoderInfo_GetCLSID (IWICBitmapEncoderInfo *iface, CLSID *pclsid)
static HRESULT WINAPI	BitmapEncoderInfo_GetSigningStatus (IWICBitmapEncoderInfo *iface, DWORD *pStatus)
static HRESULT WINAPI	BitmapEncoderInfo_GetAuthor (IWICBitmapEncoderInfo *iface, UINT cchAuthor, WCHAR *wzAuthor, UINT *pcchActual)
static HRESULT WINAPI	BitmapEncoderInfo_GetVendorGUID (IWICBitmapEncoderInfo *iface, GUID *pguidVendor)
static HRESULT WINAPI	BitmapEncoderInfo_GetVersion (IWICBitmapEncoderInfo *iface, UINT cchVersion, WCHAR *wzVersion, UINT *pcchActual)
static HRESULT WINAPI	BitmapEncoderInfo_GetSpecVersion (IWICBitmapEncoderInfo *iface, UINT cchSpecVersion, WCHAR *wzSpecVersion, UINT *pcchActual)
static HRESULT WINAPI	BitmapEncoderInfo_GetFriendlyName (IWICBitmapEncoderInfo *iface, UINT cchFriendlyName, WCHAR *wzFriendlyName, UINT *pcchActual)
static HRESULT WINAPI	BitmapEncoderInfo_GetContainerFormat (IWICBitmapEncoderInfo *iface, GUID *pguidContainerFormat)
static HRESULT WINAPI	BitmapEncoderInfo_GetPixelFormats (IWICBitmapEncoderInfo *iface, UINT cFormats, GUID *pguidPixelFormats, UINT *pcActual)
static HRESULT WINAPI	BitmapEncoderInfo_GetColorManagementVersion (IWICBitmapEncoderInfo *iface, UINT cchColorManagementVersion, WCHAR *wzColorManagementVersion, UINT *pcchActual)
static HRESULT WINAPI	BitmapEncoderInfo_GetDeviceManufacturer (IWICBitmapEncoderInfo *iface, UINT cchDeviceManufacturer, WCHAR *wzDeviceManufacturer, UINT *pcchActual)
static HRESULT WINAPI	BitmapEncoderInfo_GetDeviceModels (IWICBitmapEncoderInfo *iface, UINT cchDeviceModels, WCHAR *wzDeviceModels, UINT *pcchActual)
static HRESULT WINAPI	BitmapEncoderInfo_GetMimeTypes (IWICBitmapEncoderInfo *iface, UINT cchMimeTypes, WCHAR *wzMimeTypes, UINT *pcchActual)
static HRESULT WINAPI	BitmapEncoderInfo_GetFileExtensions (IWICBitmapEncoderInfo *iface, UINT cchFileExtensions, WCHAR *wzFileExtensions, UINT *pcchActual)
static HRESULT WINAPI	BitmapEncoderInfo_DoesSupportAnimation (IWICBitmapEncoderInfo *iface, BOOL *pfSupportAnimation)
static HRESULT WINAPI	BitmapEncoderInfo_DoesSupportChromaKey (IWICBitmapEncoderInfo *iface, BOOL *pfSupportChromaKey)
static HRESULT WINAPI	BitmapEncoderInfo_DoesSupportLossless (IWICBitmapEncoderInfo *iface, BOOL *pfSupportLossless)
static HRESULT WINAPI	BitmapEncoderInfo_DoesSupportMultiframe (IWICBitmapEncoderInfo *iface, BOOL *pfSupportMultiframe)
static HRESULT WINAPI	BitmapEncoderInfo_MatchesMimeType (IWICBitmapEncoderInfo *iface, LPCWSTR wzMimeType, BOOL *pfMatches)
static HRESULT WINAPI	BitmapEncoderInfo_CreateInstance (IWICBitmapEncoderInfo *iface, IWICBitmapEncoder **ppIBitmapEncoder)
static HRESULT	BitmapEncoderInfo_Constructor (HKEY classkey, REFCLSID clsid, ComponentInfo **ret)
static FormatConverterInfo *	impl_from_IWICFormatConverterInfo (IWICFormatConverterInfo *iface)
static HRESULT WINAPI	FormatConverterInfo_QueryInterface (IWICFormatConverterInfo *iface, REFIID iid, void **ppv)
static ULONG WINAPI	FormatConverterInfo_AddRef (IWICFormatConverterInfo *iface)
static ULONG WINAPI	FormatConverterInfo_Release (IWICFormatConverterInfo *iface)
static HRESULT WINAPI	FormatConverterInfo_GetComponentType (IWICFormatConverterInfo *iface, WICComponentType *pType)
static HRESULT WINAPI	FormatConverterInfo_GetCLSID (IWICFormatConverterInfo *iface, CLSID *pclsid)
static HRESULT WINAPI	FormatConverterInfo_GetSigningStatus (IWICFormatConverterInfo *iface, DWORD *pStatus)
static HRESULT WINAPI	FormatConverterInfo_GetAuthor (IWICFormatConverterInfo *iface, UINT cchAuthor, WCHAR *wzAuthor, UINT *pcchActual)
static HRESULT WINAPI	FormatConverterInfo_GetVendorGUID (IWICFormatConverterInfo *iface, GUID *pguidVendor)
static HRESULT WINAPI	FormatConverterInfo_GetVersion (IWICFormatConverterInfo *iface, UINT cchVersion, WCHAR *wzVersion, UINT *pcchActual)
static HRESULT WINAPI	FormatConverterInfo_GetSpecVersion (IWICFormatConverterInfo *iface, UINT cchSpecVersion, WCHAR *wzSpecVersion, UINT *pcchActual)
static HRESULT WINAPI	FormatConverterInfo_GetFriendlyName (IWICFormatConverterInfo *iface, UINT cchFriendlyName, WCHAR *wzFriendlyName, UINT *pcchActual)
static HRESULT WINAPI	FormatConverterInfo_GetPixelFormats (IWICFormatConverterInfo *iface, UINT cFormats, GUID *pguidPixelFormats, UINT *pcActual)
static HRESULT WINAPI	FormatConverterInfo_CreateInstance (IWICFormatConverterInfo *iface, IWICFormatConverter **ppIFormatConverter)
static BOOL	ConverterSupportsFormat (IWICFormatConverterInfo *iface, const WCHAR *formatguid)
static HRESULT	FormatConverterInfo_Constructor (HKEY classkey, REFCLSID clsid, ComponentInfo **ret)
static PixelFormatInfo *	impl_from_IWICPixelFormatInfo2 (IWICPixelFormatInfo2 *iface)
static HRESULT WINAPI	PixelFormatInfo_QueryInterface (IWICPixelFormatInfo2 *iface, REFIID iid, void **ppv)
static ULONG WINAPI	PixelFormatInfo_AddRef (IWICPixelFormatInfo2 *iface)
static ULONG WINAPI	PixelFormatInfo_Release (IWICPixelFormatInfo2 *iface)
static HRESULT WINAPI	PixelFormatInfo_GetComponentType (IWICPixelFormatInfo2 *iface, WICComponentType *pType)
static HRESULT WINAPI	PixelFormatInfo_GetCLSID (IWICPixelFormatInfo2 *iface, CLSID *pclsid)
static HRESULT WINAPI	PixelFormatInfo_GetSigningStatus (IWICPixelFormatInfo2 *iface, DWORD *pStatus)
static HRESULT WINAPI	PixelFormatInfo_GetAuthor (IWICPixelFormatInfo2 *iface, UINT cchAuthor, WCHAR *wzAuthor, UINT *pcchActual)
static HRESULT WINAPI	PixelFormatInfo_GetVendorGUID (IWICPixelFormatInfo2 *iface, GUID *pguidVendor)
static HRESULT WINAPI	PixelFormatInfo_GetVersion (IWICPixelFormatInfo2 *iface, UINT cchVersion, WCHAR *wzVersion, UINT *pcchActual)
static HRESULT WINAPI	PixelFormatInfo_GetSpecVersion (IWICPixelFormatInfo2 *iface, UINT cchSpecVersion, WCHAR *wzSpecVersion, UINT *pcchActual)
static HRESULT WINAPI	PixelFormatInfo_GetFriendlyName (IWICPixelFormatInfo2 *iface, UINT cchFriendlyName, WCHAR *wzFriendlyName, UINT *pcchActual)
static HRESULT WINAPI	PixelFormatInfo_GetFormatGUID (IWICPixelFormatInfo2 *iface, GUID *pFormat)
static HRESULT WINAPI	PixelFormatInfo_GetColorContext (IWICPixelFormatInfo2 *iface, IWICColorContext **ppIColorContext)
static HRESULT WINAPI	PixelFormatInfo_GetBitsPerPixel (IWICPixelFormatInfo2 *iface, UINT *puiBitsPerPixel)
static HRESULT WINAPI	PixelFormatInfo_GetChannelCount (IWICPixelFormatInfo2 *iface, UINT *puiChannelCount)
static HRESULT WINAPI	PixelFormatInfo_GetChannelMask (IWICPixelFormatInfo2 *iface, UINT uiChannelIndex, UINT cbMaskBuffer, BYTE *pbMaskBuffer, UINT *pcbActual)
static HRESULT WINAPI	PixelFormatInfo_SupportsTransparency (IWICPixelFormatInfo2 *iface, BOOL *pfSupportsTransparency)
static HRESULT WINAPI	PixelFormatInfo_GetNumericRepresentation (IWICPixelFormatInfo2 *iface, WICPixelFormatNumericRepresentation *pNumericRepresentation)
static HRESULT	PixelFormatInfo_Constructor (HKEY classkey, REFCLSID clsid, ComponentInfo **ret)
static struct metadata_container *	get_metadata_container (MetadataReaderInfo *info, const GUID *guid)
static MetadataReaderInfo *	impl_from_IWICMetadataReaderInfo (IWICMetadataReaderInfo *iface)
static HRESULT WINAPI	MetadataReaderInfo_QueryInterface (IWICMetadataReaderInfo *iface, REFIID riid, void **ppv)
static ULONG WINAPI	MetadataReaderInfo_AddRef (IWICMetadataReaderInfo *iface)
static ULONG WINAPI	MetadataReaderInfo_Release (IWICMetadataReaderInfo *iface)
static HRESULT WINAPI	MetadataReaderInfo_GetComponentType (IWICMetadataReaderInfo *iface, WICComponentType *type)
static HRESULT WINAPI	MetadataReaderInfo_GetCLSID (IWICMetadataReaderInfo *iface, CLSID *clsid)
static HRESULT WINAPI	MetadataReaderInfo_GetSigningStatus (IWICMetadataReaderInfo *iface, DWORD *status)
static HRESULT WINAPI	MetadataReaderInfo_GetAuthor (IWICMetadataReaderInfo *iface, UINT length, WCHAR *author, UINT *actual_length)
static HRESULT WINAPI	MetadataReaderInfo_GetVendorGUID (IWICMetadataReaderInfo *iface, GUID *vendor)
static HRESULT WINAPI	MetadataReaderInfo_GetVersion (IWICMetadataReaderInfo *iface, UINT length, WCHAR *version, UINT *actual_length)
static HRESULT WINAPI	MetadataReaderInfo_GetSpecVersion (IWICMetadataReaderInfo *iface, UINT length, WCHAR *version, UINT *actual_length)
static HRESULT WINAPI	MetadataReaderInfo_GetFriendlyName (IWICMetadataReaderInfo *iface, UINT length, WCHAR *name, UINT *actual_length)
static HRESULT WINAPI	MetadataReaderInfo_GetMetadataFormat (IWICMetadataReaderInfo *iface, GUID *format)
static HRESULT WINAPI	MetadataReaderInfo_GetContainerFormats (IWICMetadataReaderInfo *iface, UINT length, GUID *formats, UINT *actual_length)
static HRESULT WINAPI	MetadataReaderInfo_GetDeviceManufacturer (IWICMetadataReaderInfo *iface, UINT length, WCHAR *manufacturer, UINT *actual_length)
static HRESULT WINAPI	MetadataReaderInfo_GetDeviceModels (IWICMetadataReaderInfo *iface, UINT length, WCHAR *models, UINT *actual_length)
static HRESULT WINAPI	MetadataReaderInfo_DoesRequireFullStream (IWICMetadataReaderInfo *iface, BOOL *param)
static HRESULT WINAPI	MetadataReaderInfo_DoesSupportPadding (IWICMetadataReaderInfo *iface, BOOL *param)
static HRESULT WINAPI	MetadataReaderInfo_DoesRequireFixedSize (IWICMetadataReaderInfo *iface, BOOL *param)
static HRESULT WINAPI	MetadataReaderInfo_GetPatterns (IWICMetadataReaderInfo *iface, REFGUID container_guid, UINT length, WICMetadataPattern *patterns, UINT *count, UINT *actual_length)
static HRESULT WINAPI	MetadataReaderInfo_MatchesPattern (IWICMetadataReaderInfo *iface, REFGUID container_guid, IStream *stream, BOOL *matches)
static HRESULT WINAPI	MetadataReaderInfo_CreateInstance (IWICMetadataReaderInfo *iface, IWICMetadataReader **reader)
static void	read_metadata_patterns (MetadataReaderInfo *info, GUID *container_guid, struct metadata_container *container)
static BOOL	read_metadata_info (MetadataReaderInfo *info)
static HRESULT	MetadataReaderInfo_Constructor (HKEY classkey, REFCLSID clsid, ComponentInfo **info)
static int	ComponentInfo_Compare (const void *key, const struct wine_rb_entry *entry)
HRESULT	CreateComponentInfo (REFCLSID clsid, IWICComponentInfo **ppIInfo)
void	ReleaseComponentInfos (void)
HRESULT	get_decoder_info (REFCLSID clsid, IWICBitmapDecoderInfo **info)
static ComponentEnum *	impl_from_IEnumUnknown (IEnumUnknown *iface)
static HRESULT WINAPI	ComponentEnum_QueryInterface (IEnumUnknown *iface, REFIID iid, void **ppv)
static ULONG WINAPI	ComponentEnum_AddRef (IEnumUnknown *iface)
static ULONG WINAPI	ComponentEnum_Release (IEnumUnknown *iface)
static HRESULT WINAPI	ComponentEnum_Next (IEnumUnknown *iface, ULONG celt, IUnknown **rgelt, ULONG *pceltFetched)
static HRESULT WINAPI	ComponentEnum_Skip (IEnumUnknown *iface, ULONG celt)
static HRESULT WINAPI	ComponentEnum_Reset (IEnumUnknown *iface)
static HRESULT WINAPI	ComponentEnum_Clone (IEnumUnknown *iface, IEnumUnknown **ppenum)
HRESULT	CreateComponentEnumerator (DWORD componentTypes, DWORD options, IEnumUnknown **ppIEnumUnknown)
static BOOL	is_1bpp_format (const WICPixelFormatGUID *format)
HRESULT WINAPI	WICConvertBitmapSource (REFWICPixelFormatGUID dstFormat, IWICBitmapSource *pISrc, IWICBitmapSource **ppIDst)

Variables
static const WCHAR	mimetypes_valuename [] = {'M','i','m','e','T','y','p','e','s',0}
static const WCHAR	author_valuename [] = {'A','u','t','h','o','r',0}
static const WCHAR	friendlyname_valuename [] = {'F','r','i','e','n','d','l','y','N','a','m','e',0}
static const WCHAR	pixelformats_keyname [] = {'P','i','x','e','l','F','o','r','m','a','t','s',0}
static const WCHAR	formats_keyname [] = {'F','o','r','m','a','t','s',0}
static const WCHAR	containerformat_valuename [] = {'C','o','n','t','a','i','n','e','r','F','o','r','m','a','t',0}
static const WCHAR	metadataformat_valuename [] = {'M','e','t','a','d','a','t','a','F','o','r','m','a','t',0}
static const WCHAR	vendor_valuename [] = {'V','e','n','d','o','r',0}
static const WCHAR	version_valuename [] = {'V','e','r','s','i','o','n',0}
static const WCHAR	specversion_valuename [] = {'S','p','e','c','V','e','r','s','i','o','n',0}
static const WCHAR	bitsperpixel_valuename [] = {'B','i','t','L','e','n','g','t','h',0}
static const WCHAR	channelcount_valuename [] = {'C','h','a','n','n','e','l','C','o','u','n','t',0}
static const WCHAR	channelmasks_keyname [] = {'C','h','a','n','n','e','l','M','a','s','k','s',0}
static const WCHAR	numericrepresentation_valuename [] = {'N','u','m','e','r','i','c','R','e','p','r','e','s','e','n','t','a','t','i','o','n',0}
static const WCHAR	supportstransparency_valuename [] = {'S','u','p','p','o','r','t','s','T','r','a','n','s','p','a','r','e','n','c','y',0}
static const WCHAR	requiresfullstream_valuename [] = {'R','e','q','u','i','r','e','s','F','u','l','l','S','t','r','e','a','m',0}
static const WCHAR	supportspadding_valuename [] = {'S','u','p','p','o','r','t','s','P','a','d','d','i','n','g',0}
static const WCHAR	fileextensions_valuename [] = {'F','i','l','e','E','x','t','e','n','s','i','o','n','s',0}
static const WCHAR	containers_keyname [] = {'C','o','n','t','a','i','n','e','r','s',0}
static const IWICBitmapDecoderInfoVtbl	BitmapDecoderInfo_Vtbl
static const IWICBitmapEncoderInfoVtbl	BitmapEncoderInfo_Vtbl
static const IWICFormatConverterInfoVtbl	FormatConverterInfo_Vtbl
static const IWICPixelFormatInfo2Vtbl	PixelFormatInfo_Vtbl
static const IWICMetadataReaderInfoVtbl	MetadataReaderInfo_Vtbl
static const WCHAR	clsid_keyname [] = {'C','L','S','I','D',0}
static const WCHAR	instance_keyname [] = {'I','n','s','t','a','n','c','e',0}
static const struct category	categories []
static struct wine_rb_tree	component_info_cache = { ComponentInfo_Compare }
static CRITICAL_SECTION	component_info_cache_cs = { &component_info_cache_cs_dbg, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	component_info_cache_cs_dbg
static const IEnumUnknownVtbl	ComponentEnumVtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 24 of file info.c.

Function Documentation

BitmapDecoderInfo_AddRef()

static ULONG WINAPI BitmapDecoderInfo_AddRef ( IWICBitmapDecoderInfo *  iface )

static

Definition at line 253 of file info.c.

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

BitmapDecoderInfo_Constructor()

static HRESULT BitmapDecoderInfo_Constructor ( HKEY  classkey, REFCLSID  clsid, ComponentInfo **  ret  )

static

Definition at line 687 of file info.c.

{
    BitmapDecoderInfo *This;
 
    This = heap_alloc_zero(sizeof(BitmapDecoderInfo));
    if (!This)
    {
        RegCloseKey(classkey);
        return E_OUTOFMEMORY;
    }
 
    This->base.IWICComponentInfo_iface.lpVtbl = (const IWICComponentInfoVtbl*)&BitmapDecoderInfo_Vtbl;
    This->base.ref = 1;
    This->classkey = classkey;
    This->base.clsid = *clsid;
 
    read_bitmap_patterns(This);
 
    *ret = &This->base;
    return S_OK;
}

BitmapDecoderInfo_CreateInstance()

static HRESULT WINAPI BitmapDecoderInfo_CreateInstance ( IWICBitmapDecoderInfo *  iface, IWICBitmapDecoder **  ppIBitmapDecoder  )

static

Definition at line 538 of file info.c.

{
    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 
    TRACE("(%p,%p)\n", iface, ppIBitmapDecoder);
 
    return create_instance(&This->base.clsid, &IID_IWICBitmapDecoder, (void**)ppIBitmapDecoder);
}

BitmapDecoderInfo_DoesSupportAnimation()

static HRESULT WINAPI BitmapDecoderInfo_DoesSupportAnimation ( IWICBitmapDecoderInfo *  iface, BOOL *  pfSupportAnimation  )

static

Definition at line 419 of file info.c.

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

BitmapDecoderInfo_DoesSupportChromaKey()

static HRESULT WINAPI BitmapDecoderInfo_DoesSupportChromaKey ( IWICBitmapDecoderInfo *  iface, BOOL *  pfSupportChromaKey  )

static

Definition at line 426 of file info.c.

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

BitmapDecoderInfo_DoesSupportLossless()

static HRESULT WINAPI BitmapDecoderInfo_DoesSupportLossless ( IWICBitmapDecoderInfo *  iface, BOOL *  pfSupportLossless  )

static

Definition at line 433 of file info.c.

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

BitmapDecoderInfo_DoesSupportMultiframe()

static HRESULT WINAPI BitmapDecoderInfo_DoesSupportMultiframe ( IWICBitmapDecoderInfo *  iface, BOOL *  pfSupportMultiframe  )

static

Definition at line 440 of file info.c.

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

BitmapDecoderInfo_GetAuthor()

static HRESULT WINAPI BitmapDecoderInfo_GetAuthor ( IWICBitmapDecoderInfo *  iface, UINT  cchAuthor, WCHAR *  wzAuthor, UINT *  pcchActual  )

static

Definition at line 307 of file info.c.

{
    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchAuthor, wzAuthor, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, author_valuename,
        cchAuthor, wzAuthor, pcchActual);
}

BitmapDecoderInfo_GetCLSID()

static HRESULT WINAPI BitmapDecoderInfo_GetCLSID ( IWICBitmapDecoderInfo *  iface, CLSID *  pclsid  )

static

Definition at line 289 of file info.c.

{
    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
    TRACE("(%p,%p)\n", iface, pclsid);
 
    if (!pclsid)
        return E_INVALIDARG;
 
    *pclsid = This->base.clsid;
    return S_OK;
}

BitmapDecoderInfo_GetColorManagementVersion()

static HRESULT WINAPI BitmapDecoderInfo_GetColorManagementVersion ( IWICBitmapDecoderInfo *  iface, UINT  cchColorManagementVersion, WCHAR *  wzColorManagementVersion, UINT *  pcchActual  )

static

Definition at line 376 of file info.c.

{
    FIXME("(%p,%u,%p,%p): stub\n", iface, cchColorManagementVersion, wzColorManagementVersion, pcchActual);
    return E_NOTIMPL;
}

BitmapDecoderInfo_GetComponentType()

static HRESULT WINAPI BitmapDecoderInfo_GetComponentType ( IWICBitmapDecoderInfo *  iface, WICComponentType *  pType  )

static

Definition at line 280 of file info.c.

{
    TRACE("(%p,%p)\n", iface, pType);
    if (!pType) return E_INVALIDARG;
    *pType = WICDecoder;
    return S_OK;
}

BitmapDecoderInfo_GetContainerFormat()

static HRESULT WINAPI BitmapDecoderInfo_GetContainerFormat ( IWICBitmapDecoderInfo *  iface, GUID *  pguidContainerFormat  )

static

Definition at line 360 of file info.c.

{
    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
    TRACE("(%p,%p)\n", iface, pguidContainerFormat);
    return ComponentInfo_GetGUIDValue(This->classkey, containerformat_valuename, pguidContainerFormat);
}

BitmapDecoderInfo_GetDeviceManufacturer()

static HRESULT WINAPI BitmapDecoderInfo_GetDeviceManufacturer ( IWICBitmapDecoderInfo *  iface, UINT  cchDeviceManufacturer, WCHAR *  wzDeviceManufacturer, UINT *  pcchActual  )

static

Definition at line 383 of file info.c.

{
    FIXME("(%p,%u,%p,%p): stub\n", iface, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual);
    return E_NOTIMPL;
}

BitmapDecoderInfo_GetDeviceModels()

static HRESULT WINAPI BitmapDecoderInfo_GetDeviceModels ( IWICBitmapDecoderInfo *  iface, UINT  cchDeviceModels, WCHAR *  wzDeviceModels, UINT *  pcchActual  )

static

Definition at line 390 of file info.c.

{
    FIXME("(%p,%u,%p,%p): stub\n", iface, cchDeviceModels, wzDeviceModels, pcchActual);
    return E_NOTIMPL;
}

BitmapDecoderInfo_GetFileExtensions()

static HRESULT WINAPI BitmapDecoderInfo_GetFileExtensions ( IWICBitmapDecoderInfo *  iface, UINT  cchFileExtensions, WCHAR *  wzFileExtensions, UINT *  pcchActual  )

static

Definition at line 408 of file info.c.

{
    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchFileExtensions, wzFileExtensions, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, fileextensions_valuename,
        cchFileExtensions, wzFileExtensions, pcchActual);
}

BitmapDecoderInfo_GetFriendlyName()

static HRESULT WINAPI BitmapDecoderInfo_GetFriendlyName ( IWICBitmapDecoderInfo *  iface, UINT  cchFriendlyName, WCHAR *  wzFriendlyName, UINT *  pcchActual  )

static

Definition at line 349 of file info.c.

{
    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchFriendlyName, wzFriendlyName, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, friendlyname_valuename,
        cchFriendlyName, wzFriendlyName, pcchActual);
}

BitmapDecoderInfo_GetMimeTypes()

static HRESULT WINAPI BitmapDecoderInfo_GetMimeTypes ( IWICBitmapDecoderInfo *  iface, UINT  cchMimeTypes, WCHAR *  wzMimeTypes, UINT *  pcchActual  )

static

Definition at line 397 of file info.c.

{
    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchMimeTypes, wzMimeTypes, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, mimetypes_valuename,
        cchMimeTypes, wzMimeTypes, pcchActual);
}

BitmapDecoderInfo_GetPatterns()

static HRESULT WINAPI BitmapDecoderInfo_GetPatterns ( IWICBitmapDecoderInfo *  iface, UINT  cbSizePatterns, WICBitmapPattern *  pPatterns, UINT *  pcPatterns, UINT *  pcbPatternsActual  )

static

Definition at line 454 of file info.c.

{
    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 
    TRACE("(%p,%i,%p,%p,%p)\n", iface, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActual);
 
    if (!pcPatterns || !pcbPatternsActual) return E_INVALIDARG;
 
    *pcPatterns = This->pattern_count;
    *pcbPatternsActual = This->patterns_size;
    if (pPatterns)
    {
        if (This->patterns_size && cbSizePatterns < This->patterns_size)
            return WINCODEC_ERR_INSUFFICIENTBUFFER;
        memcpy(pPatterns, This->patterns, This->patterns_size);
    }
    return S_OK;
}

BitmapDecoderInfo_GetPixelFormats()

static HRESULT WINAPI BitmapDecoderInfo_GetPixelFormats ( IWICBitmapDecoderInfo *  iface, UINT  cFormats, GUID *  pguidPixelFormats, UINT *  pcActual  )

static

Definition at line 368 of file info.c.

{
    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
    TRACE("(%p,%u,%p,%p)\n", iface, cFormats, pguidPixelFormats, pcActual);
    return ComponentInfo_GetGuidList(This->classkey, formats_keyname, cFormats, pguidPixelFormats, pcActual);
}

BitmapDecoderInfo_GetSigningStatus()

static HRESULT WINAPI BitmapDecoderInfo_GetSigningStatus ( IWICBitmapDecoderInfo *  iface, DWORD *  pStatus  )

static

Definition at line 301 of file info.c.

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

BitmapDecoderInfo_GetSpecVersion()

static HRESULT WINAPI BitmapDecoderInfo_GetSpecVersion ( IWICBitmapDecoderInfo *  iface, UINT  cchSpecVersion, WCHAR *  wzSpecVersion, UINT *  pcchActual  )

static

Definition at line 338 of file info.c.

{
    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchSpecVersion, wzSpecVersion, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, specversion_valuename,
        cchSpecVersion, wzSpecVersion, pcchActual);
}

BitmapDecoderInfo_GetVendorGUID()

static HRESULT WINAPI BitmapDecoderInfo_GetVendorGUID ( IWICBitmapDecoderInfo *  iface, GUID *  pguidVendor  )

static

Definition at line 318 of file info.c.

{
    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 
    TRACE("(%p,%p)\n", iface, pguidVendor);
 
    return ComponentInfo_GetGUIDValue(This->classkey, vendor_valuename, pguidVendor);
}

BitmapDecoderInfo_GetVersion()

static HRESULT WINAPI BitmapDecoderInfo_GetVersion ( IWICBitmapDecoderInfo *  iface, UINT  cchVersion, WCHAR *  wzVersion, UINT *  pcchActual  )

static

Definition at line 327 of file info.c.

{
    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchVersion, wzVersion, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, version_valuename,
        cchVersion, wzVersion, pcchActual);
}

BitmapDecoderInfo_MatchesMimeType()

static HRESULT WINAPI BitmapDecoderInfo_MatchesMimeType ( IWICBitmapDecoderInfo *  iface, LPCWSTR  wzMimeType, BOOL *  pfMatches  )

static

Definition at line 447 of file info.c.

{
    FIXME("(%p,%s,%p): stub\n", iface, debugstr_w(wzMimeType), pfMatches);
    return E_NOTIMPL;
}

BitmapDecoderInfo_MatchesPattern()

static HRESULT WINAPI BitmapDecoderInfo_MatchesPattern ( IWICBitmapDecoderInfo *  iface, IStream *  pIStream, BOOL *  pfMatches  )

static

Definition at line 474 of file info.c.

{
    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
    HRESULT hr;
    UINT i;
    ULONG pos;
    BYTE *data=NULL;
    ULONG datasize=0;
    ULONG bytesread;
    LARGE_INTEGER seekpos;
 
    TRACE("(%p,%p,%p)\n", iface, pIStream, pfMatches);
 
    for (i=0; i < This->pattern_count; i++)
    {
        if (datasize < This->patterns[i].Length)
        {
            HeapFree(GetProcessHeap(), 0, data);
            datasize = This->patterns[i].Length;
            data = HeapAlloc(GetProcessHeap(), 0, This->patterns[i].Length);
            if (!data)
            {
                hr = E_OUTOFMEMORY;
                break;
            }
        }
 
        if (This->patterns[i].EndOfStream)
            seekpos.QuadPart = -This->patterns[i].Position.QuadPart;
        else
            seekpos.QuadPart = This->patterns[i].Position.QuadPart;
        hr = IStream_Seek(pIStream, seekpos, This->patterns[i].EndOfStream ? STREAM_SEEK_END : STREAM_SEEK_SET, NULL);
        if (hr == STG_E_INVALIDFUNCTION) continue; /* before start of stream */
        if (FAILED(hr)) break;
 
        hr = IStream_Read(pIStream, data, This->patterns[i].Length, &bytesread);
        if (hr == S_FALSE || (hr == S_OK && bytesread != This->patterns[i].Length)) /* past end of stream */
            continue;
        if (FAILED(hr)) break;
 
        for (pos=0; pos < This->patterns[i].Length; pos++)
        {
            if ((data[pos] & This->patterns[i].Mask[pos]) != This->patterns[i].Pattern[pos])
                break;
        }
        if (pos == This->patterns[i].Length) /* matches pattern */
        {
            hr = S_OK;
            *pfMatches = TRUE;
            break;
        }
    }
 
    if (i == This->pattern_count) /* does not match any pattern */
    {
        hr = S_OK;
        *pfMatches = FALSE;
    }
 
    HeapFree(GetProcessHeap(), 0, data);
    return hr;
}

BitmapDecoderInfo_QueryInterface()

static HRESULT WINAPI BitmapDecoderInfo_QueryInterface ( IWICBitmapDecoderInfo *  iface, REFIID  iid, void **  ppv  )

static

Definition at line 228 of file info.c.

{
    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
    TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 
    if (!ppv) return E_INVALIDARG;
 
    if (IsEqualIID(&IID_IUnknown, iid) ||
        IsEqualIID(&IID_IWICComponentInfo, iid) ||
        IsEqualIID(&IID_IWICBitmapCodecInfo, iid) ||
        IsEqualIID(&IID_IWICBitmapDecoderInfo ,iid))
    {
        *ppv = &This->base.IWICComponentInfo_iface;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

BitmapDecoderInfo_Release()

static ULONG WINAPI BitmapDecoderInfo_Release ( IWICBitmapDecoderInfo *  iface )

static

Definition at line 263 of file info.c.

{
    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
    ULONG ref = InterlockedDecrement(&This->base.ref);
 
    TRACE("(%p) refcount=%u\n", iface, ref);
 
    if (ref == 0)
    {
        RegCloseKey(This->classkey);
        heap_free(This->patterns);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}

BitmapEncoderInfo_AddRef()

static ULONG WINAPI BitmapEncoderInfo_AddRef ( IWICBitmapEncoderInfo *  iface )

static

Definition at line 744 of file info.c.

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

BitmapEncoderInfo_Constructor()

static HRESULT BitmapEncoderInfo_Constructor ( HKEY  classkey, REFCLSID  clsid, ComponentInfo **  ret  )

static

Definition at line 981 of file info.c.

{
    BitmapEncoderInfo *This;
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(BitmapEncoderInfo));
    if (!This)
    {
        RegCloseKey(classkey);
        return E_OUTOFMEMORY;
    }
 
    This->base.IWICComponentInfo_iface.lpVtbl = (const IWICComponentInfoVtbl*)&BitmapEncoderInfo_Vtbl;
    This->base.ref = 1;
    This->classkey = classkey;
    This->base.clsid = *clsid;
 
    *ret = &This->base;
    return S_OK;
}

BitmapEncoderInfo_CreateInstance()

static HRESULT WINAPI BitmapEncoderInfo_CreateInstance ( IWICBitmapEncoderInfo *  iface, IWICBitmapEncoder **  ppIBitmapEncoder  )

static

Definition at line 944 of file info.c.

{
    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 
    TRACE("(%p,%p)\n", iface, ppIBitmapEncoder);
 
    return create_instance(&This->base.clsid, &IID_IWICBitmapEncoder, (void**)ppIBitmapEncoder);
}

BitmapEncoderInfo_DoesSupportAnimation()

static HRESULT WINAPI BitmapEncoderInfo_DoesSupportAnimation ( IWICBitmapEncoderInfo *  iface, BOOL *  pfSupportAnimation  )

static

Definition at line 909 of file info.c.

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

BitmapEncoderInfo_DoesSupportChromaKey()

static HRESULT WINAPI BitmapEncoderInfo_DoesSupportChromaKey ( IWICBitmapEncoderInfo *  iface, BOOL *  pfSupportChromaKey  )

static

Definition at line 916 of file info.c.

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

BitmapEncoderInfo_DoesSupportLossless()

static HRESULT WINAPI BitmapEncoderInfo_DoesSupportLossless ( IWICBitmapEncoderInfo *  iface, BOOL *  pfSupportLossless  )

static

Definition at line 923 of file info.c.

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

BitmapEncoderInfo_DoesSupportMultiframe()

static HRESULT WINAPI BitmapEncoderInfo_DoesSupportMultiframe ( IWICBitmapEncoderInfo *  iface, BOOL *  pfSupportMultiframe  )

static

Definition at line 930 of file info.c.

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

BitmapEncoderInfo_GetAuthor()

static HRESULT WINAPI BitmapEncoderInfo_GetAuthor ( IWICBitmapEncoderInfo *  iface, UINT  cchAuthor, WCHAR *  wzAuthor, UINT *  pcchActual  )

static

Definition at line 797 of file info.c.

{
    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchAuthor, wzAuthor, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, author_valuename,
        cchAuthor, wzAuthor, pcchActual);
}

BitmapEncoderInfo_GetCLSID()

static HRESULT WINAPI BitmapEncoderInfo_GetCLSID ( IWICBitmapEncoderInfo *  iface, CLSID *  pclsid  )

static

Definition at line 779 of file info.c.

{
    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
    TRACE("(%p,%p)\n", iface, pclsid);
 
    if (!pclsid)
        return E_INVALIDARG;
 
    *pclsid = This->base.clsid;
    return S_OK;
}

BitmapEncoderInfo_GetColorManagementVersion()

static HRESULT WINAPI BitmapEncoderInfo_GetColorManagementVersion ( IWICBitmapEncoderInfo *  iface, UINT  cchColorManagementVersion, WCHAR *  wzColorManagementVersion, UINT *  pcchActual  )

static

Definition at line 866 of file info.c.

{
    FIXME("(%p,%u,%p,%p): stub\n", iface, cchColorManagementVersion, wzColorManagementVersion, pcchActual);
    return E_NOTIMPL;
}

BitmapEncoderInfo_GetComponentType()

static HRESULT WINAPI BitmapEncoderInfo_GetComponentType ( IWICBitmapEncoderInfo *  iface, WICComponentType *  pType  )

static

Definition at line 770 of file info.c.

{
    TRACE("(%p,%p)\n", iface, pType);
    if (!pType) return E_INVALIDARG;
    *pType = WICEncoder;
    return S_OK;
}

BitmapEncoderInfo_GetContainerFormat()

static HRESULT WINAPI BitmapEncoderInfo_GetContainerFormat ( IWICBitmapEncoderInfo *  iface, GUID *  pguidContainerFormat  )

static

Definition at line 850 of file info.c.

{
    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
    TRACE("(%p,%p)\n", iface, pguidContainerFormat);
    return ComponentInfo_GetGUIDValue(This->classkey, containerformat_valuename, pguidContainerFormat);
}

BitmapEncoderInfo_GetDeviceManufacturer()

static HRESULT WINAPI BitmapEncoderInfo_GetDeviceManufacturer ( IWICBitmapEncoderInfo *  iface, UINT  cchDeviceManufacturer, WCHAR *  wzDeviceManufacturer, UINT *  pcchActual  )

static

Definition at line 873 of file info.c.

{
    FIXME("(%p,%u,%p,%p): stub\n", iface, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual);
    return E_NOTIMPL;
}

BitmapEncoderInfo_GetDeviceModels()

static HRESULT WINAPI BitmapEncoderInfo_GetDeviceModels ( IWICBitmapEncoderInfo *  iface, UINT  cchDeviceModels, WCHAR *  wzDeviceModels, UINT *  pcchActual  )

static

Definition at line 880 of file info.c.

{
    FIXME("(%p,%u,%p,%p): stub\n", iface, cchDeviceModels, wzDeviceModels, pcchActual);
    return E_NOTIMPL;
}

BitmapEncoderInfo_GetFileExtensions()

static HRESULT WINAPI BitmapEncoderInfo_GetFileExtensions ( IWICBitmapEncoderInfo *  iface, UINT  cchFileExtensions, WCHAR *  wzFileExtensions, UINT *  pcchActual  )

static

Definition at line 898 of file info.c.

{
    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchFileExtensions, wzFileExtensions, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, fileextensions_valuename,
        cchFileExtensions, wzFileExtensions, pcchActual);
}

BitmapEncoderInfo_GetFriendlyName()

static HRESULT WINAPI BitmapEncoderInfo_GetFriendlyName ( IWICBitmapEncoderInfo *  iface, UINT  cchFriendlyName, WCHAR *  wzFriendlyName, UINT *  pcchActual  )

static

Definition at line 839 of file info.c.

{
    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchFriendlyName, wzFriendlyName, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, friendlyname_valuename,
        cchFriendlyName, wzFriendlyName, pcchActual);
}

BitmapEncoderInfo_GetMimeTypes()

static HRESULT WINAPI BitmapEncoderInfo_GetMimeTypes ( IWICBitmapEncoderInfo *  iface, UINT  cchMimeTypes, WCHAR *  wzMimeTypes, UINT *  pcchActual  )

static

Definition at line 887 of file info.c.

{
    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchMimeTypes, wzMimeTypes, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, mimetypes_valuename,
        cchMimeTypes, wzMimeTypes, pcchActual);
}

BitmapEncoderInfo_GetPixelFormats()

static HRESULT WINAPI BitmapEncoderInfo_GetPixelFormats ( IWICBitmapEncoderInfo *  iface, UINT  cFormats, GUID *  pguidPixelFormats, UINT *  pcActual  )

static

Definition at line 858 of file info.c.

{
    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
    TRACE("(%p,%u,%p,%p)\n", iface, cFormats, pguidPixelFormats, pcActual);
    return ComponentInfo_GetGuidList(This->classkey, formats_keyname, cFormats, pguidPixelFormats, pcActual);
}

BitmapEncoderInfo_GetSigningStatus()

static HRESULT WINAPI BitmapEncoderInfo_GetSigningStatus ( IWICBitmapEncoderInfo *  iface, DWORD *  pStatus  )

static

Definition at line 791 of file info.c.

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

BitmapEncoderInfo_GetSpecVersion()

static HRESULT WINAPI BitmapEncoderInfo_GetSpecVersion ( IWICBitmapEncoderInfo *  iface, UINT  cchSpecVersion, WCHAR *  wzSpecVersion, UINT *  pcchActual  )

static

Definition at line 828 of file info.c.

{
    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchSpecVersion, wzSpecVersion, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, specversion_valuename,
        cchSpecVersion, wzSpecVersion, pcchActual);
}

BitmapEncoderInfo_GetVendorGUID()

static HRESULT WINAPI BitmapEncoderInfo_GetVendorGUID ( IWICBitmapEncoderInfo *  iface, GUID *  pguidVendor  )

static

Definition at line 808 of file info.c.

{
    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 
    TRACE("(%p,%p)\n", iface, pguidVendor);
 
    return ComponentInfo_GetGUIDValue(This->classkey, vendor_valuename, pguidVendor);
}

BitmapEncoderInfo_GetVersion()

static HRESULT WINAPI BitmapEncoderInfo_GetVersion ( IWICBitmapEncoderInfo *  iface, UINT  cchVersion, WCHAR *  wzVersion, UINT *  pcchActual  )

static

Definition at line 817 of file info.c.

{
    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchVersion, wzVersion, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, version_valuename,
        cchVersion, wzVersion, pcchActual);
}

BitmapEncoderInfo_MatchesMimeType()

static HRESULT WINAPI BitmapEncoderInfo_MatchesMimeType ( IWICBitmapEncoderInfo *  iface, LPCWSTR  wzMimeType, BOOL *  pfMatches  )

static

Definition at line 937 of file info.c.

{
    FIXME("(%p,%s,%p): stub\n", iface, debugstr_w(wzMimeType), pfMatches);
    return E_NOTIMPL;
}

BitmapEncoderInfo_QueryInterface()

static HRESULT WINAPI BitmapEncoderInfo_QueryInterface ( IWICBitmapEncoderInfo *  iface, REFIID  iid, void **  ppv  )

static

Definition at line 719 of file info.c.

{
    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
    TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 
    if (!ppv) return E_INVALIDARG;
 
    if (IsEqualIID(&IID_IUnknown, iid) ||
        IsEqualIID(&IID_IWICComponentInfo, iid) ||
        IsEqualIID(&IID_IWICBitmapCodecInfo, iid) ||
        IsEqualIID(&IID_IWICBitmapEncoderInfo ,iid))
    {
        *ppv = &This->base.IWICComponentInfo_iface;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

BitmapEncoderInfo_Release()

static ULONG WINAPI BitmapEncoderInfo_Release ( IWICBitmapEncoderInfo *  iface )

static

Definition at line 754 of file info.c.

{
    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
    ULONG ref = InterlockedDecrement(&This->base.ref);
 
    TRACE("(%p) refcount=%u\n", iface, ref);
 
    if (ref == 0)
    {
        RegCloseKey(This->classkey);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}

ComponentEnum_AddRef()

static ULONG WINAPI ComponentEnum_AddRef ( IEnumUnknown *  iface )

static

Definition at line 2221 of file info.c.

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

ComponentEnum_Clone()

static HRESULT WINAPI ComponentEnum_Clone ( IEnumUnknown *  iface, IEnumUnknown **  ppenum  )

static

Definition at line 2319 of file info.c.

{
    ComponentEnum *This = impl_from_IEnumUnknown(iface);
    ComponentEnum *new_enum;
    ComponentEnumItem *old_item, *new_item;
    HRESULT ret=S_OK;
    struct list *old_cursor;
 
    new_enum = HeapAlloc(GetProcessHeap(), 0, sizeof(ComponentEnum));
    if (!new_enum)
    {
        *ppenum = NULL;
        return E_OUTOFMEMORY;
    }
 
    new_enum->IEnumUnknown_iface.lpVtbl = &ComponentEnumVtbl;
    new_enum->ref = 1;
    new_enum->cursor = NULL;
    list_init(&new_enum->objects);
    InitializeCriticalSection(&new_enum->lock);
    new_enum->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": ComponentEnum.lock");
 
    EnterCriticalSection(&This->lock);
    old_cursor = This->cursor;
    LeaveCriticalSection(&This->lock);
 
    LIST_FOR_EACH_ENTRY(old_item, &This->objects, ComponentEnumItem, entry)
    {
        new_item = HeapAlloc(GetProcessHeap(), 0, sizeof(ComponentEnumItem));
        if (!new_item)
        {
            ret = E_OUTOFMEMORY;
            break;
        }
        new_item->unk = old_item->unk;
        list_add_tail(&new_enum->objects, &new_item->entry);
        IUnknown_AddRef(new_item->unk);
        if (&old_item->entry == old_cursor) new_enum->cursor = &new_item->entry;
    }
 
    if (FAILED(ret))
    {
        IEnumUnknown_Release(&new_enum->IEnumUnknown_iface);
        *ppenum = NULL;
    }
    else
        *ppenum = &new_enum->IEnumUnknown_iface;
 
    return ret;
}

ComponentEnum_Next()

static HRESULT WINAPI ComponentEnum_Next ( IEnumUnknown *  iface, ULONG  celt, IUnknown **  rgelt, ULONG *  pceltFetched  )

static

Definition at line 2255 of file info.c.

{
    ComponentEnum *This = impl_from_IEnumUnknown(iface);
    ULONG num_fetched=0;
    ComponentEnumItem *item;
    HRESULT hr=S_OK;
 
    TRACE("(%p,%u,%p,%p)\n", iface, celt, rgelt, pceltFetched);
 
    EnterCriticalSection(&This->lock);
    while (num_fetched<celt)
    {
        if (!This->cursor)
        {
            hr = S_FALSE;
            break;
        }
        item = LIST_ENTRY(This->cursor, ComponentEnumItem, entry);
        IUnknown_AddRef(item->unk);
        rgelt[num_fetched] = item->unk;
        num_fetched++;
        This->cursor = list_next(&This->objects, This->cursor);
    }
    LeaveCriticalSection(&This->lock);
    if (pceltFetched)
        *pceltFetched = num_fetched;
    return hr;
}

ComponentEnum_QueryInterface()

static HRESULT WINAPI ComponentEnum_QueryInterface ( IEnumUnknown *  iface, REFIID  iid, void **  ppv  )

static

Definition at line 2198 of file info.c.

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

ComponentEnum_Release()

static ULONG WINAPI ComponentEnum_Release ( IEnumUnknown *  iface )

static

Definition at line 2231 of file info.c.

{
    ComponentEnum *This = impl_from_IEnumUnknown(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
    ComponentEnumItem *cursor, *cursor2;
 
    TRACE("(%p) refcount=%u\n", iface, ref);
 
    if (ref == 0)
    {
        LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, &This->objects, ComponentEnumItem, entry)
        {
            IUnknown_Release(cursor->unk);
            list_remove(&cursor->entry);
            HeapFree(GetProcessHeap(), 0, cursor);
        }
        This->lock.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&This->lock);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}

ComponentEnum_Reset()

static HRESULT WINAPI ComponentEnum_Reset ( IEnumUnknown *  iface )

static

Definition at line 2307 of file info.c.

{
    ComponentEnum *This = impl_from_IEnumUnknown(iface);
 
    TRACE("(%p)\n", iface);
 
    EnterCriticalSection(&This->lock);
    This->cursor = list_head(&This->objects);
    LeaveCriticalSection(&This->lock);
    return S_OK;
}

ComponentEnum_Skip()

static HRESULT WINAPI ComponentEnum_Skip ( IEnumUnknown *  iface, ULONG  celt  )

static

Definition at line 2285 of file info.c.

{
    ComponentEnum *This = impl_from_IEnumUnknown(iface);
    ULONG i;
    HRESULT hr=S_OK;
 
    TRACE("(%p,%u)\n", iface, celt);
 
    EnterCriticalSection(&This->lock);
    for (i=0; i<celt; i++)
    {
        if (!This->cursor)
        {
            hr = S_FALSE;
            break;
        }
        This->cursor = list_next(&This->objects, This->cursor);
    }
    LeaveCriticalSection(&This->lock);
    return hr;
}

ComponentInfo_Compare()

static int ComponentInfo_Compare ( const void *  key, const struct wine_rb_entry *  entry  )

static

Definition at line 2058 of file info.c.

{
    ComponentInfo *info = WINE_RB_ENTRY_VALUE(entry, ComponentInfo, entry);
    return memcmp(key, &info->clsid, sizeof(info->clsid));
}

ComponentInfo_GetDWORDValue()

static HRESULT ComponentInfo_GetDWORDValue ( HKEY  classkey, LPCWSTR  value, DWORD *  result  )

static

Definition at line 127 of file info.c.

{
    LONG ret;
    DWORD cbdata = sizeof(DWORD);
 
    if (!result)
        return E_INVALIDARG;
 
    ret = RegGetValueW(classkey, NULL, value, RRF_RT_DWORD, NULL,
        result, &cbdata);
 
    if (ret == ERROR_FILE_NOT_FOUND)
    {
        *result = 0;
        return S_OK;
    }
 
    return HRESULT_FROM_WIN32(ret);
}

Referenced by MetadataReaderInfo_DoesRequireFullStream(), MetadataReaderInfo_DoesSupportPadding(), PixelFormatInfo_GetBitsPerPixel(), PixelFormatInfo_GetChannelCount(), PixelFormatInfo_GetNumericRepresentation(), and PixelFormatInfo_SupportsTransparency().

ComponentInfo_GetGuidList()

static HRESULT ComponentInfo_GetGuidList ( HKEY  classkey, LPCWSTR  subkeyname, UINT  buffersize, GUID *  buffer, UINT *  actual_size  )

static

Definition at line 148 of file info.c.

{
    LONG ret;
    HKEY subkey;
    UINT items_returned;
    WCHAR guid_string[39];
    DWORD guid_string_size;
    HRESULT hr=S_OK;
 
    if (!actual_size)
        return E_INVALIDARG;
 
    ret = RegOpenKeyExW(classkey, subkeyname, 0, KEY_READ, &subkey);
    if (ret == ERROR_FILE_NOT_FOUND)
    {
        *actual_size = 0;
        return S_OK;
    }
    else if (ret != ERROR_SUCCESS) return HRESULT_FROM_WIN32(ret);
 
    if (buffer)
    {
        items_returned = 0;
        guid_string_size = 39;
        while (items_returned < buffersize)
        {
            ret = RegEnumKeyExW(subkey, items_returned, guid_string,
                &guid_string_size, NULL, NULL, NULL, NULL);
 
            if (ret != ERROR_SUCCESS)
            {
                hr = HRESULT_FROM_WIN32(ret);
                break;
            }
 
            if (guid_string_size != 38)
            {
                hr = E_FAIL;
                break;
            }
 
            hr = CLSIDFromString(guid_string, &buffer[items_returned]);
            if (FAILED(hr))
                break;
 
            items_returned++;
            guid_string_size = 39;
        }
 
        if (ret == ERROR_NO_MORE_ITEMS)
            hr = S_OK;
 
        *actual_size = items_returned;
    }
    else
    {
        ret = RegQueryInfoKeyW(subkey, NULL, NULL, NULL, actual_size, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
        if (ret != ERROR_SUCCESS)
            hr = HRESULT_FROM_WIN32(ret);
    }
 
    RegCloseKey(subkey);
 
    return hr;
}

Referenced by BitmapDecoderInfo_GetPixelFormats(), BitmapEncoderInfo_GetPixelFormats(), and read_metadata_info().

ComponentInfo_GetGUIDValue()

static HRESULT ComponentInfo_GetGUIDValue ( HKEY  classkey, LPCWSTR  value, GUID *  result  )

static

Definition at line 99 of file info.c.

{
    LONG ret;
    WCHAR guid_string[39];
    DWORD cbdata = sizeof(guid_string);
    HRESULT hr;
 
    if (!result)
        return E_INVALIDARG;
 
    ret = RegGetValueW(classkey, NULL, value, RRF_RT_REG_SZ|RRF_NOEXPAND, NULL,
        guid_string, &cbdata);
 
    if (ret != ERROR_SUCCESS)
        return HRESULT_FROM_WIN32(ret);
 
    if (cbdata < sizeof(guid_string))
    {
        ERR("incomplete GUID value\n");
        return E_FAIL;
    }
 
    hr = CLSIDFromString(guid_string, result);
 
    return hr;
}

Referenced by BitmapDecoderInfo_GetContainerFormat(), BitmapDecoderInfo_GetVendorGUID(), BitmapEncoderInfo_GetContainerFormat(), BitmapEncoderInfo_GetVendorGUID(), FormatConverterInfo_GetVendorGUID(), MetadataReaderInfo_GetMetadataFormat(), MetadataReaderInfo_GetVendorGUID(), and PixelFormatInfo_GetVendorGUID().

ComponentInfo_GetStringValue()

static HRESULT ComponentInfo_GetStringValue ( HKEY  classkey, LPCWSTR  value, UINT  buffer_size, WCHAR *  buffer, UINT *  actual_size  )

static

Definition at line 68 of file info.c.

{
    LONG ret;
    DWORD cbdata=buffer_size * sizeof(WCHAR);
 
    if (!actual_size)
        return E_INVALIDARG;
 
    ret = RegGetValueW(classkey, NULL, value, RRF_RT_REG_SZ|RRF_NOEXPAND, NULL,
        buffer, &cbdata);
 
    if (ret == ERROR_FILE_NOT_FOUND)
    {
        *actual_size = 0;
        return S_OK;
    }
 
    if (ret == 0 || ret == ERROR_MORE_DATA)
        *actual_size = cbdata/sizeof(WCHAR);
 
    if (!buffer && buffer_size != 0)
        /* Yes, native returns the correct size in this case. */
        return E_INVALIDARG;
 
    if (ret == ERROR_MORE_DATA)
        return WINCODEC_ERR_INSUFFICIENTBUFFER;
 
    return HRESULT_FROM_WIN32(ret);
}

Referenced by BitmapDecoderInfo_GetAuthor(), BitmapDecoderInfo_GetFileExtensions(), BitmapDecoderInfo_GetFriendlyName(), BitmapDecoderInfo_GetMimeTypes(), BitmapDecoderInfo_GetSpecVersion(), BitmapDecoderInfo_GetVersion(), BitmapEncoderInfo_GetAuthor(), BitmapEncoderInfo_GetFileExtensions(), BitmapEncoderInfo_GetFriendlyName(), BitmapEncoderInfo_GetMimeTypes(), BitmapEncoderInfo_GetSpecVersion(), BitmapEncoderInfo_GetVersion(), FormatConverterInfo_GetAuthor(), FormatConverterInfo_GetFriendlyName(), FormatConverterInfo_GetSpecVersion(), FormatConverterInfo_GetVersion(), MetadataReaderInfo_GetAuthor(), MetadataReaderInfo_GetFriendlyName(), MetadataReaderInfo_GetSpecVersion(), MetadataReaderInfo_GetVersion(), PixelFormatInfo_GetAuthor(), PixelFormatInfo_GetFriendlyName(), PixelFormatInfo_GetSpecVersion(), and PixelFormatInfo_GetVersion().

ConverterSupportsFormat()

static BOOL ConverterSupportsFormat ( IWICFormatConverterInfo *  iface, const WCHAR *  formatguid  )

static

Definition at line 1159 of file info.c.

{
    LONG res;
    FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
    HKEY formats_key, guid_key;
 
    /* Avoid testing using IWICFormatConverter_GetPixelFormats because that
        would be O(n). A registry test should do better. */
 
    res = RegOpenKeyExW(This->classkey, pixelformats_keyname, 0, KEY_READ, &formats_key);
    if (res != ERROR_SUCCESS) return FALSE;
 
    res = RegOpenKeyExW(formats_key, formatguid, 0, KEY_READ, &guid_key);
    if (res == ERROR_SUCCESS) RegCloseKey(guid_key);
 
    RegCloseKey(formats_key);
 
    return (res == ERROR_SUCCESS);
}

Referenced by WICConvertBitmapSource().

CreateComponentEnumerator()

HRESULT CreateComponentEnumerator	(	DWORD	componentTypes,
		DWORD	options,
		IEnumUnknown **	ppIEnumUnknown
	)

Definition at line 2380 of file info.c.

{
    ComponentEnum *This;
    ComponentEnumItem *item;
    const struct category *category;
    HKEY clsidkey, catidkey, instancekey;
    WCHAR guidstring[39];
    LONG res;
    int i;
    HRESULT hr=S_OK;
    CLSID clsid;
 
    if (options) FIXME("ignoring flags %x\n", options);
 
    res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, KEY_READ, &clsidkey);
    if (res != ERROR_SUCCESS)
        return HRESULT_FROM_WIN32(res);
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(ComponentEnum));
    if (!This)
    {
        RegCloseKey(clsidkey);
        return E_OUTOFMEMORY;
    }
 
    This->IEnumUnknown_iface.lpVtbl = &ComponentEnumVtbl;
    This->ref = 1;
    list_init(&This->objects);
    InitializeCriticalSection(&This->lock);
    This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": ComponentEnum.lock");
 
    for (category=categories; category->type && hr == S_OK; category++)
    {
        if ((category->type & componentTypes) == 0) continue;
        StringFromGUID2(category->catid, guidstring, 39);
        res = RegOpenKeyExW(clsidkey, guidstring, 0, KEY_READ, &catidkey);
        if (res == ERROR_SUCCESS)
        {
            res = RegOpenKeyExW(catidkey, instance_keyname, 0, KEY_READ, &instancekey);
            if (res == ERROR_SUCCESS)
            {
                i=0;
                for (;;i++)
                {
                    DWORD guidstring_size = 39;
                    res = RegEnumKeyExW(instancekey, i, guidstring, &guidstring_size, NULL, NULL, NULL, NULL);
                    if (res != ERROR_SUCCESS) break;
 
                    item = HeapAlloc(GetProcessHeap(), 0, sizeof(ComponentEnumItem));
                    if (!item) { hr = E_OUTOFMEMORY; break; }
 
                    hr = CLSIDFromString(guidstring, &clsid);
                    if (SUCCEEDED(hr))
                    {
                        hr = CreateComponentInfo(&clsid, (IWICComponentInfo**)&item->unk);
                        if (SUCCEEDED(hr))
                            list_add_tail(&This->objects, &item->entry);
                    }
 
                    if (FAILED(hr))
                    {
                        HeapFree(GetProcessHeap(), 0, item);
                        hr = S_OK;
                    }
                }
                RegCloseKey(instancekey);
            }
            RegCloseKey(catidkey);
        }
        if (res != ERROR_SUCCESS && res != ERROR_NO_MORE_ITEMS)
            hr = HRESULT_FROM_WIN32(res);
    }
    RegCloseKey(clsidkey);
 
    if (SUCCEEDED(hr))
    {
        IEnumUnknown_Reset(&This->IEnumUnknown_iface);
        *ppIEnumUnknown = &This->IEnumUnknown_iface;
    }
    else
    {
        *ppIEnumUnknown = NULL;
        IEnumUnknown_Release(&This->IEnumUnknown_iface);
    }
 
    return hr;
}

Referenced by ComponentFactory_CreateMetadataReaderFromContainer(), find_decoder(), ImagingFactory_CreateComponentEnumerator(), ImagingFactory_CreateDecoder(), ImagingFactory_CreateEncoder(), and WICConvertBitmapSource().

CreateComponentInfo()

HRESULT CreateComponentInfo	(	REFCLSID	clsid,
		IWICComponentInfo **	ppIInfo
	)

Definition at line 2075 of file info.c.

{
    struct wine_rb_entry *cache_entry;
    ComponentInfo *info;
    HKEY clsidkey;
    HKEY classkey;
    HKEY catidkey;
    HKEY instancekey;
    WCHAR guidstring[39];
    LONG res;
    const struct category *category;
    BOOL found = FALSE;
    HRESULT hr;
 
    EnterCriticalSection(&component_info_cache_cs);
 
    cache_entry = wine_rb_get(&component_info_cache, clsid);
    if(cache_entry)
    {
        info = WINE_RB_ENTRY_VALUE(cache_entry, ComponentInfo, entry);
        IWICComponentInfo_AddRef(*ppIInfo = &info->IWICComponentInfo_iface);
        LeaveCriticalSection(&component_info_cache_cs);
        return S_OK;
    }
 
    res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, KEY_READ, &clsidkey);
    if (res != ERROR_SUCCESS)
    {
        LeaveCriticalSection(&component_info_cache_cs);
        return HRESULT_FROM_WIN32(res);
    }
 
    for (category=categories; category->type; category++)
    {
        StringFromGUID2(category->catid, guidstring, 39);
        res = RegOpenKeyExW(clsidkey, guidstring, 0, KEY_READ, &catidkey);
        if (res == ERROR_SUCCESS)
        {
            res = RegOpenKeyExW(catidkey, instance_keyname, 0, KEY_READ, &instancekey);
            if (res == ERROR_SUCCESS)
            {
                StringFromGUID2(clsid, guidstring, 39);
                res = RegOpenKeyExW(instancekey, guidstring, 0, KEY_READ, &classkey);
                if (res == ERROR_SUCCESS)
                {
                    RegCloseKey(classkey);
                    found = TRUE;
                }
                RegCloseKey(instancekey);
            }
            RegCloseKey(catidkey);
        }
        if (found) break;
    }
 
    if (found)
    {
        res = RegOpenKeyExW(clsidkey, guidstring, 0, KEY_READ, &classkey);
        if (res == ERROR_SUCCESS)
            hr = category->constructor(classkey, clsid, &info);
        else
            hr = HRESULT_FROM_WIN32(res);
    }
    else
    {
        FIXME("%s is not supported\n", wine_dbgstr_guid(clsid));
        hr = E_FAIL;
    }
 
    RegCloseKey(clsidkey);
 
    if (SUCCEEDED(hr))
    {
        wine_rb_put(&component_info_cache, clsid, &info->entry);
        IWICComponentInfo_AddRef(*ppIInfo = &info->IWICComponentInfo_iface);
    }
    LeaveCriticalSection(&component_info_cache_cs);
    return hr;
}

Referenced by BmpEncoder_GetEncoderInfo(), create_bitmap_from_source_rect(), CreateComponentEnumerator(), get_decoder_info(), get_pixelformat_bpp(), GifEncoder_GetEncoderInfo(), ImagingFactory_CreateComponentInfo(), and MetadataHandler_GetMetadataHandlerInfo().

FormatConverterInfo_AddRef()

static ULONG WINAPI FormatConverterInfo_AddRef ( IWICFormatConverterInfo *  iface )

static

Definition at line 1035 of file info.c.

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

FormatConverterInfo_Constructor()

static HRESULT FormatConverterInfo_Constructor ( HKEY  classkey, REFCLSID  clsid, ComponentInfo **  ret  )

static

Definition at line 1195 of file info.c.

{
    FormatConverterInfo *This;
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(FormatConverterInfo));
    if (!This)
    {
        RegCloseKey(classkey);
        return E_OUTOFMEMORY;
    }
 
    This->base.IWICComponentInfo_iface.lpVtbl = (const IWICComponentInfoVtbl*)&FormatConverterInfo_Vtbl;
    This->base.ref = 1;
    This->classkey = classkey;
    This->base.clsid = *clsid;
 
    *ret = &This->base;
    return S_OK;
}

FormatConverterInfo_CreateInstance()

static HRESULT WINAPI FormatConverterInfo_CreateInstance ( IWICFormatConverterInfo *  iface, IWICFormatConverter **  ppIFormatConverter  )

static

Definition at line 1148 of file info.c.

{
    FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
 
    TRACE("(%p,%p)\n", iface, ppIFormatConverter);
 
    return create_instance(&This->base.clsid, &IID_IWICFormatConverter,
            (void**)ppIFormatConverter);
}

FormatConverterInfo_GetAuthor()

static HRESULT WINAPI FormatConverterInfo_GetAuthor ( IWICFormatConverterInfo *  iface, UINT  cchAuthor, WCHAR *  wzAuthor, UINT *  pcchActual  )

static

Definition at line 1088 of file info.c.

{
    FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchAuthor, wzAuthor, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, author_valuename,
        cchAuthor, wzAuthor, pcchActual);
}

FormatConverterInfo_GetCLSID()

static HRESULT WINAPI FormatConverterInfo_GetCLSID ( IWICFormatConverterInfo *  iface, CLSID *  pclsid  )

static

Definition at line 1070 of file info.c.

{
    FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
    TRACE("(%p,%p)\n", iface, pclsid);
 
    if (!pclsid)
        return E_INVALIDARG;
 
    *pclsid = This->base.clsid;
    return S_OK;
}

FormatConverterInfo_GetComponentType()

static HRESULT WINAPI FormatConverterInfo_GetComponentType ( IWICFormatConverterInfo *  iface, WICComponentType *  pType  )

static

Definition at line 1061 of file info.c.

{
    TRACE("(%p,%p)\n", iface, pType);
    if (!pType) return E_INVALIDARG;
    *pType = WICPixelFormatConverter;
    return S_OK;
}

FormatConverterInfo_GetFriendlyName()

static HRESULT WINAPI FormatConverterInfo_GetFriendlyName ( IWICFormatConverterInfo *  iface, UINT  cchFriendlyName, WCHAR *  wzFriendlyName, UINT *  pcchActual  )

static

Definition at line 1130 of file info.c.

{
    FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchFriendlyName, wzFriendlyName, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, friendlyname_valuename,
        cchFriendlyName, wzFriendlyName, pcchActual);
}

FormatConverterInfo_GetPixelFormats()

static HRESULT WINAPI FormatConverterInfo_GetPixelFormats ( IWICFormatConverterInfo *  iface, UINT  cFormats, GUID *  pguidPixelFormats, UINT *  pcActual  )

static

Definition at line 1141 of file info.c.

{
    FIXME("(%p,%u,%p,%p): stub\n", iface, cFormats, pguidPixelFormats, pcActual);
    return E_NOTIMPL;
}

FormatConverterInfo_GetSigningStatus()

static HRESULT WINAPI FormatConverterInfo_GetSigningStatus ( IWICFormatConverterInfo *  iface, DWORD *  pStatus  )

static

Definition at line 1082 of file info.c.

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

FormatConverterInfo_GetSpecVersion()

static HRESULT WINAPI FormatConverterInfo_GetSpecVersion ( IWICFormatConverterInfo *  iface, UINT  cchSpecVersion, WCHAR *  wzSpecVersion, UINT *  pcchActual  )

static

Definition at line 1119 of file info.c.

{
    FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchSpecVersion, wzSpecVersion, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, specversion_valuename,
        cchSpecVersion, wzSpecVersion, pcchActual);
}

FormatConverterInfo_GetVendorGUID()

static HRESULT WINAPI FormatConverterInfo_GetVendorGUID ( IWICFormatConverterInfo *  iface, GUID *  pguidVendor  )

static

Definition at line 1099 of file info.c.

{
    FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
 
    TRACE("(%p,%p)\n", iface, pguidVendor);
 
    return ComponentInfo_GetGUIDValue(This->classkey, vendor_valuename, pguidVendor);
}

FormatConverterInfo_GetVersion()

static HRESULT WINAPI FormatConverterInfo_GetVersion ( IWICFormatConverterInfo *  iface, UINT  cchVersion, WCHAR *  wzVersion, UINT *  pcchActual  )

static

Definition at line 1108 of file info.c.

{
    FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchVersion, wzVersion, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, version_valuename,
        cchVersion, wzVersion, pcchActual);
}

FormatConverterInfo_QueryInterface()

static HRESULT WINAPI FormatConverterInfo_QueryInterface ( IWICFormatConverterInfo *  iface, REFIID  iid, void **  ppv  )

static

Definition at line 1011 of file info.c.

{
    FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
    TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 
    if (!ppv) return E_INVALIDARG;
 
    if (IsEqualIID(&IID_IUnknown, iid) ||
        IsEqualIID(&IID_IWICComponentInfo, iid) ||
        IsEqualIID(&IID_IWICFormatConverterInfo ,iid))
    {
        *ppv = &This->base.IWICComponentInfo_iface;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

FormatConverterInfo_Release()

static ULONG WINAPI FormatConverterInfo_Release ( IWICFormatConverterInfo *  iface )

static

Definition at line 1045 of file info.c.

{
    FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
    ULONG ref = InterlockedDecrement(&This->base.ref);
 
    TRACE("(%p) refcount=%u\n", iface, ref);
 
    if (ref == 0)
    {
        RegCloseKey(This->classkey);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}

get_decoder_info()

HRESULT get_decoder_info	(	REFCLSID	clsid,
		IWICBitmapDecoderInfo **	info
	)

Definition at line 2162 of file info.c.

{
    IWICComponentInfo *compinfo;
    HRESULT hr;
 
    hr = CreateComponentInfo(clsid, &compinfo);
    if (FAILED(hr)) return hr;
 
    hr = IWICComponentInfo_QueryInterface(compinfo, &IID_IWICBitmapDecoderInfo,
        (void **)info);
 
    IWICComponentInfo_Release(compinfo);
 
    return hr;
}

get_metadata_container()

static struct metadata_container * get_metadata_container ( MetadataReaderInfo *  info, const GUID *  guid  )

static

Definition at line 1521 of file info.c.

{
    unsigned i;
 
    for (i = 0; i < info->container_count; i++)
        if (IsEqualGUID(info->container_formats + i, guid))
            return info->containers + i;
 
    return NULL;
}

Referenced by MetadataReaderInfo_GetPatterns(), and MetadataReaderInfo_MatchesPattern().

impl_from_IEnumUnknown()

static ComponentEnum * impl_from_IEnumUnknown ( IEnumUnknown *  iface )

inlinestatic

Definition at line 2186 of file info.c.

{
    return CONTAINING_RECORD(iface, ComponentEnum, IEnumUnknown_iface);
}

Referenced by ComponentEnum_AddRef(), ComponentEnum_Clone(), ComponentEnum_Next(), ComponentEnum_QueryInterface(), ComponentEnum_Release(), ComponentEnum_Reset(), and ComponentEnum_Skip().

impl_from_IWICBitmapDecoderInfo()

static BitmapDecoderInfo * impl_from_IWICBitmapDecoderInfo ( IWICBitmapDecoderInfo *  iface )

inlinestatic

Definition at line 223 of file info.c.

{
    return CONTAINING_RECORD((IWICComponentInfo*)iface, BitmapDecoderInfo, base.IWICComponentInfo_iface);
}

Referenced by BitmapDecoderInfo_AddRef(), BitmapDecoderInfo_CreateInstance(), BitmapDecoderInfo_GetAuthor(), BitmapDecoderInfo_GetCLSID(), BitmapDecoderInfo_GetContainerFormat(), BitmapDecoderInfo_GetFileExtensions(), BitmapDecoderInfo_GetFriendlyName(), BitmapDecoderInfo_GetMimeTypes(), BitmapDecoderInfo_GetPatterns(), BitmapDecoderInfo_GetPixelFormats(), BitmapDecoderInfo_GetSpecVersion(), BitmapDecoderInfo_GetVendorGUID(), BitmapDecoderInfo_GetVersion(), BitmapDecoderInfo_MatchesPattern(), BitmapDecoderInfo_QueryInterface(), and BitmapDecoderInfo_Release().

impl_from_IWICBitmapEncoderInfo()

static BitmapEncoderInfo * impl_from_IWICBitmapEncoderInfo ( IWICBitmapEncoderInfo *  iface )

inlinestatic

Definition at line 714 of file info.c.

{
    return CONTAINING_RECORD((IWICComponentInfo*)iface, BitmapEncoderInfo, base.IWICComponentInfo_iface);
}

Referenced by BitmapEncoderInfo_AddRef(), BitmapEncoderInfo_CreateInstance(), BitmapEncoderInfo_GetAuthor(), BitmapEncoderInfo_GetCLSID(), BitmapEncoderInfo_GetContainerFormat(), BitmapEncoderInfo_GetFileExtensions(), BitmapEncoderInfo_GetFriendlyName(), BitmapEncoderInfo_GetMimeTypes(), BitmapEncoderInfo_GetPixelFormats(), BitmapEncoderInfo_GetSpecVersion(), BitmapEncoderInfo_GetVendorGUID(), BitmapEncoderInfo_GetVersion(), BitmapEncoderInfo_QueryInterface(), and BitmapEncoderInfo_Release().

impl_from_IWICFormatConverterInfo()

static FormatConverterInfo * impl_from_IWICFormatConverterInfo ( IWICFormatConverterInfo *  iface )

inlinestatic

Definition at line 1006 of file info.c.

{
    return CONTAINING_RECORD((IWICComponentInfo*)iface, FormatConverterInfo, base.IWICComponentInfo_iface);
}

Referenced by ConverterSupportsFormat(), FormatConverterInfo_AddRef(), FormatConverterInfo_CreateInstance(), FormatConverterInfo_GetAuthor(), FormatConverterInfo_GetCLSID(), FormatConverterInfo_GetFriendlyName(), FormatConverterInfo_GetSpecVersion(), FormatConverterInfo_GetVendorGUID(), FormatConverterInfo_GetVersion(), FormatConverterInfo_QueryInterface(), and FormatConverterInfo_Release().

impl_from_IWICMetadataReaderInfo()

static MetadataReaderInfo * impl_from_IWICMetadataReaderInfo ( IWICMetadataReaderInfo *  iface )

inlinestatic

Definition at line 1532 of file info.c.

{
    return CONTAINING_RECORD((IWICComponentInfo*)iface, MetadataReaderInfo, base.IWICComponentInfo_iface);
}

Referenced by MetadataReaderInfo_AddRef(), MetadataReaderInfo_CreateInstance(), MetadataReaderInfo_DoesRequireFullStream(), MetadataReaderInfo_DoesSupportPadding(), MetadataReaderInfo_GetAuthor(), MetadataReaderInfo_GetCLSID(), MetadataReaderInfo_GetContainerFormats(), MetadataReaderInfo_GetFriendlyName(), MetadataReaderInfo_GetMetadataFormat(), MetadataReaderInfo_GetPatterns(), MetadataReaderInfo_GetSpecVersion(), MetadataReaderInfo_GetVendorGUID(), MetadataReaderInfo_GetVersion(), MetadataReaderInfo_MatchesPattern(), MetadataReaderInfo_QueryInterface(), and MetadataReaderInfo_Release().

impl_from_IWICPixelFormatInfo2()

static PixelFormatInfo * impl_from_IWICPixelFormatInfo2 ( IWICPixelFormatInfo2 *  iface )

inlinestatic

Definition at line 1220 of file info.c.

{
    return CONTAINING_RECORD((IWICComponentInfo*)iface, PixelFormatInfo, base.IWICComponentInfo_iface);
}

Referenced by PixelFormatInfo_AddRef(), PixelFormatInfo_GetAuthor(), PixelFormatInfo_GetBitsPerPixel(), PixelFormatInfo_GetChannelCount(), PixelFormatInfo_GetChannelMask(), PixelFormatInfo_GetCLSID(), PixelFormatInfo_GetFormatGUID(), PixelFormatInfo_GetFriendlyName(), PixelFormatInfo_GetNumericRepresentation(), PixelFormatInfo_GetSpecVersion(), PixelFormatInfo_GetVendorGUID(), PixelFormatInfo_GetVersion(), PixelFormatInfo_QueryInterface(), PixelFormatInfo_Release(), and PixelFormatInfo_SupportsTransparency().

is_1bpp_format()

static BOOL is_1bpp_format ( const WICPixelFormatGUID *  format )

static

Definition at line 2468 of file info.c.

{
    return IsEqualGUID(format, &GUID_WICPixelFormatBlackWhite) ||
           IsEqualGUID(format, &GUID_WICPixelFormat1bppIndexed);
}

Referenced by WICConvertBitmapSource().

MetadataReaderInfo_AddRef()

static ULONG WINAPI MetadataReaderInfo_AddRef ( IWICMetadataReaderInfo *  iface )

static

Definition at line 1563 of file info.c.

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

MetadataReaderInfo_Constructor()

static HRESULT MetadataReaderInfo_Constructor ( HKEY  classkey, REFCLSID  clsid, ComponentInfo **  info  )

static

Definition at line 2014 of file info.c.

{
    MetadataReaderInfo *This;
 
    This = heap_alloc_zero(sizeof(*This));
    if (!This)
    {
        RegCloseKey(classkey);
        return E_OUTOFMEMORY;
    }
 
    This->base.IWICComponentInfo_iface.lpVtbl = (const IWICComponentInfoVtbl*)&MetadataReaderInfo_Vtbl;
    This->base.ref = 1;
    This->classkey = classkey;
    This->base.clsid = *clsid;
 
    if (!read_metadata_info(This))
    {
        IWICComponentInfo_Release(&This->base.IWICComponentInfo_iface);
        return WINCODEC_ERR_COMPONENTNOTFOUND;
    }
 
    *info = &This->base;
    return S_OK;
}

MetadataReaderInfo_CreateInstance()

static HRESULT WINAPI MetadataReaderInfo_CreateInstance ( IWICMetadataReaderInfo *  iface, IWICMetadataReader **  reader  )

static

Definition at line 1829 of file info.c.

{
    MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
 
    TRACE("(%p,%p)\n", iface, reader);
 
    return create_instance(&This->base.clsid, &IID_IWICMetadataReader, (void **)reader);
}

MetadataReaderInfo_DoesRequireFixedSize()

static HRESULT WINAPI MetadataReaderInfo_DoesRequireFixedSize ( IWICMetadataReaderInfo *  iface, BOOL *  param  )

static

Definition at line 1733 of file info.c.

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

MetadataReaderInfo_DoesRequireFullStream()

static HRESULT WINAPI MetadataReaderInfo_DoesRequireFullStream ( IWICMetadataReaderInfo *  iface, BOOL *  param  )

static

Definition at line 1717 of file info.c.

{
    MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
    TRACE("(%p,%p)\n", iface, param);
    return ComponentInfo_GetDWORDValue(This->classkey, requiresfullstream_valuename, (DWORD *)param);
}

MetadataReaderInfo_DoesSupportPadding()

static HRESULT WINAPI MetadataReaderInfo_DoesSupportPadding ( IWICMetadataReaderInfo *  iface, BOOL *  param  )

static

Definition at line 1725 of file info.c.

{
    MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
    TRACE("(%p,%p)\n", iface, param);
    return ComponentInfo_GetDWORDValue(This->classkey, supportspadding_valuename, (DWORD *)param);
}

MetadataReaderInfo_GetAuthor()

static HRESULT WINAPI MetadataReaderInfo_GetAuthor ( IWICMetadataReaderInfo *  iface, UINT  length, WCHAR *  author, UINT *  actual_length  )

static

Definition at line 1621 of file info.c.

{
    MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, length, author, actual_length);
 
    return ComponentInfo_GetStringValue(This->classkey, author_valuename,
                                        length, author, actual_length);
}

MetadataReaderInfo_GetCLSID()

static HRESULT WINAPI MetadataReaderInfo_GetCLSID ( IWICMetadataReaderInfo *  iface, CLSID *  clsid  )

static

Definition at line 1602 of file info.c.

{
    MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
 
    TRACE("(%p,%p)\n", iface, clsid);
 
    if (!clsid) return E_INVALIDARG;
    *clsid = This->base.clsid;
    return S_OK;
}

MetadataReaderInfo_GetComponentType()

static HRESULT WINAPI MetadataReaderInfo_GetComponentType ( IWICMetadataReaderInfo *  iface, WICComponentType *  type  )

static

Definition at line 1592 of file info.c.

{
    TRACE("(%p,%p)\n", iface, type);
 
    if (!type) return E_INVALIDARG;
    *type = WICMetadataReader;
    return S_OK;
}

MetadataReaderInfo_GetContainerFormats()

static HRESULT WINAPI MetadataReaderInfo_GetContainerFormats ( IWICMetadataReaderInfo *  iface, UINT  length, GUID *  formats, UINT *  actual_length  )

static

Definition at line 1683 of file info.c.

{
    MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, length, formats, actual_length);
 
    if (!actual_length)
        return E_INVALIDARG;
 
    *actual_length = This->container_count;
    if (formats)
    {
        if (This->container_count && length < This->container_count)
            return WINCODEC_ERR_INSUFFICIENTBUFFER;
        memcpy(formats, This->container_formats, This->container_count);
    }
    return S_OK;
}

MetadataReaderInfo_GetDeviceManufacturer()

static HRESULT WINAPI MetadataReaderInfo_GetDeviceManufacturer ( IWICMetadataReaderInfo *  iface, UINT  length, WCHAR *  manufacturer, UINT *  actual_length  )

static

Definition at line 1703 of file info.c.

{
    FIXME("(%p,%u,%p,%p): stub\n", iface, length, manufacturer, actual_length);
    return E_NOTIMPL;
}

MetadataReaderInfo_GetDeviceModels()

static HRESULT WINAPI MetadataReaderInfo_GetDeviceModels ( IWICMetadataReaderInfo *  iface, UINT  length, WCHAR *  models, UINT *  actual_length  )

static

Definition at line 1710 of file info.c.

{
    FIXME("(%p,%u,%p,%p): stub\n", iface, length, models, actual_length);
    return E_NOTIMPL;
}

MetadataReaderInfo_GetFriendlyName()

static HRESULT WINAPI MetadataReaderInfo_GetFriendlyName ( IWICMetadataReaderInfo *  iface, UINT  length, WCHAR *  name, UINT *  actual_length  )

static

Definition at line 1664 of file info.c.

{
    MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, length, name, actual_length);
 
    return ComponentInfo_GetStringValue(This->classkey, friendlyname_valuename,
                                        length, name, actual_length);
}

MetadataReaderInfo_GetMetadataFormat()

static HRESULT WINAPI MetadataReaderInfo_GetMetadataFormat ( IWICMetadataReaderInfo *  iface, GUID *  format  )

static

Definition at line 1675 of file info.c.

{
    MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
    TRACE("(%p,%p)\n", iface, format);
    return ComponentInfo_GetGUIDValue(This->classkey, metadataformat_valuename, format);
}

MetadataReaderInfo_GetPatterns()

static HRESULT WINAPI MetadataReaderInfo_GetPatterns ( IWICMetadataReaderInfo *  iface, REFGUID  container_guid, UINT  length, WICMetadataPattern *  patterns, UINT *  count, UINT *  actual_length  )

static

Definition at line 1740 of file info.c.

{
    MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
    struct metadata_container *container;
 
    TRACE("(%p,%s,%u,%p,%p,%p)\n", iface, debugstr_guid(container_guid), length, patterns, count, actual_length);
 
    if (!actual_length || !container_guid) return E_INVALIDARG;
 
    if (!(container = get_metadata_container(This, container_guid)))
        return WINCODEC_ERR_COMPONENTNOTFOUND;
 
    *count = container->pattern_count;
    *actual_length = container->patterns_size;
    if (patterns)
    {
        if (container->patterns_size && length < container->patterns_size)
            return WINCODEC_ERR_INSUFFICIENTBUFFER;
        memcpy(patterns, container->patterns, container->patterns_size);
    }
    return S_OK;
}

MetadataReaderInfo_GetSigningStatus()

static HRESULT WINAPI MetadataReaderInfo_GetSigningStatus ( IWICMetadataReaderInfo *  iface, DWORD *  status  )

static

Definition at line 1614 of file info.c.

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

MetadataReaderInfo_GetSpecVersion()

static HRESULT WINAPI MetadataReaderInfo_GetSpecVersion ( IWICMetadataReaderInfo *  iface, UINT  length, WCHAR *  version, UINT *  actual_length  )

static

Definition at line 1653 of file info.c.

{
    MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, length, version, actual_length);
 
    return ComponentInfo_GetStringValue(This->classkey, specversion_valuename,
                                        length, version, actual_length);
}

MetadataReaderInfo_GetVendorGUID()

static HRESULT WINAPI MetadataReaderInfo_GetVendorGUID ( IWICMetadataReaderInfo *  iface, GUID *  vendor  )

static

Definition at line 1632 of file info.c.

{
    MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
 
    TRACE("(%p,%p)\n", iface, vendor);
 
    return ComponentInfo_GetGUIDValue(This->classkey, vendor_valuename, vendor);
}

MetadataReaderInfo_GetVersion()

static HRESULT WINAPI MetadataReaderInfo_GetVersion ( IWICMetadataReaderInfo *  iface, UINT  length, WCHAR *  version, UINT *  actual_length  )

static

Definition at line 1642 of file info.c.

{
    MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, length, version, actual_length);
 
    return ComponentInfo_GetStringValue(This->classkey, version_valuename,
                                        length, version, actual_length);
}

MetadataReaderInfo_MatchesPattern()

static HRESULT WINAPI MetadataReaderInfo_MatchesPattern ( IWICMetadataReaderInfo *  iface, REFGUID  container_guid, IStream *  stream, BOOL *  matches  )

static

Definition at line 1764 of file info.c.

{
    MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
    struct metadata_container *container;
    HRESULT hr;
    ULONG datasize=0;
    BYTE *data=NULL;
    ULONG bytesread;
    UINT i;
    LARGE_INTEGER seekpos;
    ULONG pos;
 
    TRACE("(%p,%s,%p,%p)\n", iface, debugstr_guid(container_guid), stream, matches);
 
    if (!(container = get_metadata_container(This, container_guid)))
        return WINCODEC_ERR_COMPONENTNOTFOUND;
 
    for (i=0; i < container->pattern_count; i++)
    {
        if (datasize < container->patterns[i].Length)
        {
            HeapFree(GetProcessHeap(), 0, data);
            datasize = container->patterns[i].Length;
            data = HeapAlloc(GetProcessHeap(), 0, container->patterns[i].Length);
            if (!data)
            {
                hr = E_OUTOFMEMORY;
                break;
            }
        }
 
        seekpos.QuadPart = container->patterns[i].Position.QuadPart;
        hr = IStream_Seek(stream, seekpos, STREAM_SEEK_SET, NULL);
        if (FAILED(hr)) break;
 
        hr = IStream_Read(stream, data, container->patterns[i].Length, &bytesread);
        if (hr == S_FALSE || (hr == S_OK && bytesread != container->patterns[i].Length)) /* past end of stream */
            continue;
        if (FAILED(hr)) break;
 
        for (pos=0; pos < container->patterns[i].Length; pos++)
        {
            if ((data[pos] & container->patterns[i].Mask[pos]) != container->patterns[i].Pattern[pos])
                break;
        }
        if (pos == container->patterns[i].Length) /* matches pattern */
        {
            hr = S_OK;
            *matches = TRUE;
            break;
        }
    }
 
    if (i == container->pattern_count) /* does not match any pattern */
    {
        hr = S_OK;
        *matches = FALSE;
    }
 
    HeapFree(GetProcessHeap(), 0, data);
 
    return hr;
}

MetadataReaderInfo_QueryInterface()

static HRESULT WINAPI MetadataReaderInfo_QueryInterface ( IWICMetadataReaderInfo *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 1537 of file info.c.

{
    MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
 
    TRACE("(%p,%s,%p)\n", iface, debugstr_guid(riid), ppv);
 
    if (!ppv) return E_INVALIDARG;
 
    if (IsEqualIID(&IID_IUnknown, riid) ||
        IsEqualIID(&IID_IWICComponentInfo, riid) ||
        IsEqualIID(&IID_IWICMetadataHandlerInfo, riid) ||
        IsEqualIID(&IID_IWICMetadataReaderInfo, riid))
    {
        *ppv = &This->base.IWICComponentInfo_iface;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown *)*ppv);
    return S_OK;
}

MetadataReaderInfo_Release()

static ULONG WINAPI MetadataReaderInfo_Release ( IWICMetadataReaderInfo *  iface )

static

Definition at line 1572 of file info.c.

{
    MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
    ULONG ref = InterlockedDecrement(&This->base.ref);
 
    TRACE("(%p) refcount=%u\n", iface, ref);
 
    if (!ref)
    {
        unsigned i;
        RegCloseKey(This->classkey);
        for (i = 0; i < This->container_count; i++)
            heap_free(This->containers[i].patterns);
        heap_free(This->containers);
        heap_free(This->container_formats);
        HeapFree(GetProcessHeap(), 0, This);
    }
    return ref;
}

PixelFormatInfo_AddRef()

static ULONG WINAPI PixelFormatInfo_AddRef ( IWICPixelFormatInfo2 *  iface )

static

Definition at line 1250 of file info.c.

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

PixelFormatInfo_Constructor()

static HRESULT PixelFormatInfo_Constructor ( HKEY  classkey, REFCLSID  clsid, ComponentInfo **  ret  )

static

Definition at line 1485 of file info.c.

{
    PixelFormatInfo *This;
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(PixelFormatInfo));
    if (!This)
    {
        RegCloseKey(classkey);
        return E_OUTOFMEMORY;
    }
 
    This->base.IWICComponentInfo_iface.lpVtbl = (const IWICComponentInfoVtbl*)&PixelFormatInfo_Vtbl;
    This->base.ref = 1;
    This->classkey = classkey;
    This->base.clsid = *clsid;
 
    *ret = &This->base;
    return S_OK;
}

PixelFormatInfo_GetAuthor()

static HRESULT WINAPI PixelFormatInfo_GetAuthor ( IWICPixelFormatInfo2 *  iface, UINT  cchAuthor, WCHAR *  wzAuthor, UINT *  pcchActual  )

static

Definition at line 1310 of file info.c.

{
    PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchAuthor, wzAuthor, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, author_valuename,
        cchAuthor, wzAuthor, pcchActual);
}

PixelFormatInfo_GetBitsPerPixel()

static HRESULT WINAPI PixelFormatInfo_GetBitsPerPixel ( IWICPixelFormatInfo2 *  iface, UINT *  puiBitsPerPixel  )

static

Definition at line 1383 of file info.c.

{
    PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
 
    TRACE("(%p,%p)\n", iface, puiBitsPerPixel);
 
    return ComponentInfo_GetDWORDValue(This->classkey, bitsperpixel_valuename, puiBitsPerPixel);
}

PixelFormatInfo_GetChannelCount()

static HRESULT WINAPI PixelFormatInfo_GetChannelCount ( IWICPixelFormatInfo2 *  iface, UINT *  puiChannelCount  )

static

Definition at line 1393 of file info.c.

{
    PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
 
    TRACE("(%p,%p)\n", iface, puiChannelCount);
 
    return ComponentInfo_GetDWORDValue(This->classkey, channelcount_valuename, puiChannelCount);
}

Referenced by PixelFormatInfo_GetChannelMask().

PixelFormatInfo_GetChannelMask()

static HRESULT WINAPI PixelFormatInfo_GetChannelMask ( IWICPixelFormatInfo2 *  iface, UINT  uiChannelIndex, UINT  cbMaskBuffer, BYTE *  pbMaskBuffer, UINT *  pcbActual  )

static

Definition at line 1403 of file info.c.

{
    static const WCHAR uintformatW[] = {'%','u',0};
    PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
    UINT channel_count;
    HRESULT hr;
    LONG ret;
    WCHAR valuename[11];
    DWORD cbData;
 
    TRACE("(%p,%u,%u,%p,%p)\n", iface, uiChannelIndex, cbMaskBuffer, pbMaskBuffer, pcbActual);
 
    if (!pcbActual)
        return E_INVALIDARG;
 
    hr = PixelFormatInfo_GetChannelCount(iface, &channel_count);
 
    if (SUCCEEDED(hr) && uiChannelIndex >= channel_count)
        hr = E_INVALIDARG;
 
    if (SUCCEEDED(hr))
    {
        snprintfW(valuename, 11, uintformatW, uiChannelIndex);
 
        cbData = cbMaskBuffer;
 
        ret = RegGetValueW(This->classkey, channelmasks_keyname, valuename, RRF_RT_REG_BINARY, NULL, pbMaskBuffer, &cbData);
 
        if (ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA)
            *pcbActual = cbData;
 
        if (ret == ERROR_MORE_DATA)
            hr = E_INVALIDARG;
        else
            hr = HRESULT_FROM_WIN32(ret);
    }
 
    return hr;
}

PixelFormatInfo_GetCLSID()

static HRESULT WINAPI PixelFormatInfo_GetCLSID ( IWICPixelFormatInfo2 *  iface, CLSID *  pclsid  )

static

Definition at line 1285 of file info.c.

{
    PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
    TRACE("(%p,%p)\n", iface, pclsid);
 
    if (!pclsid)
        return E_INVALIDARG;
 
    *pclsid = This->base.clsid;
    return S_OK;
}

PixelFormatInfo_GetColorContext()

static HRESULT WINAPI PixelFormatInfo_GetColorContext ( IWICPixelFormatInfo2 *  iface, IWICColorContext **  ppIColorContext  )

static

Definition at line 1376 of file info.c.

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

PixelFormatInfo_GetComponentType()

static HRESULT WINAPI PixelFormatInfo_GetComponentType ( IWICPixelFormatInfo2 *  iface, WICComponentType *  pType  )

static

Definition at line 1276 of file info.c.

{
    TRACE("(%p,%p)\n", iface, pType);
    if (!pType) return E_INVALIDARG;
    *pType = WICPixelFormat;
    return S_OK;
}

PixelFormatInfo_GetFormatGUID()

static HRESULT WINAPI PixelFormatInfo_GetFormatGUID ( IWICPixelFormatInfo2 *  iface, GUID *  pFormat  )

static

Definition at line 1363 of file info.c.

{
    PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
    TRACE("(%p,%p)\n", iface, pFormat);
 
    if (!pFormat)
        return E_INVALIDARG;
 
    *pFormat = This->base.clsid;
    return S_OK;
}

PixelFormatInfo_GetFriendlyName()

static HRESULT WINAPI PixelFormatInfo_GetFriendlyName ( IWICPixelFormatInfo2 *  iface, UINT  cchFriendlyName, WCHAR *  wzFriendlyName, UINT *  pcchActual  )

static

Definition at line 1352 of file info.c.

{
    PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchFriendlyName, wzFriendlyName, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, friendlyname_valuename,
        cchFriendlyName, wzFriendlyName, pcchActual);
}

PixelFormatInfo_GetNumericRepresentation()

static HRESULT WINAPI PixelFormatInfo_GetNumericRepresentation ( IWICPixelFormatInfo2 *  iface, WICPixelFormatNumericRepresentation *  pNumericRepresentation  )

static

Definition at line 1454 of file info.c.

{
    PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
 
    TRACE("(%p,%p)\n", iface, pNumericRepresentation);
 
    return ComponentInfo_GetDWORDValue(This->classkey, numericrepresentation_valuename, pNumericRepresentation);
}

PixelFormatInfo_GetSigningStatus()

static HRESULT WINAPI PixelFormatInfo_GetSigningStatus ( IWICPixelFormatInfo2 *  iface, DWORD *  pStatus  )

static

Definition at line 1297 of file info.c.

{
    TRACE("(%p,%p)\n", iface, pStatus);
 
    if (!pStatus)
        return E_INVALIDARG;
 
    /* Pixel formats don't require code, so they are considered signed. */
    *pStatus = WICComponentSigned;
 
    return S_OK;
}

PixelFormatInfo_GetSpecVersion()

static HRESULT WINAPI PixelFormatInfo_GetSpecVersion ( IWICPixelFormatInfo2 *  iface, UINT  cchSpecVersion, WCHAR *  wzSpecVersion, UINT *  pcchActual  )

static

Definition at line 1341 of file info.c.

{
    PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchSpecVersion, wzSpecVersion, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, specversion_valuename,
        cchSpecVersion, wzSpecVersion, pcchActual);
}

PixelFormatInfo_GetVendorGUID()

static HRESULT WINAPI PixelFormatInfo_GetVendorGUID ( IWICPixelFormatInfo2 *  iface, GUID *  pguidVendor  )

static

Definition at line 1321 of file info.c.

{
    PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
 
    TRACE("(%p,%p)\n", iface, pguidVendor);
 
    return ComponentInfo_GetGUIDValue(This->classkey, vendor_valuename, pguidVendor);
}

PixelFormatInfo_GetVersion()

static HRESULT WINAPI PixelFormatInfo_GetVersion ( IWICPixelFormatInfo2 *  iface, UINT  cchVersion, WCHAR *  wzVersion, UINT *  pcchActual  )

static

Definition at line 1330 of file info.c.

{
    PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
 
    TRACE("(%p,%u,%p,%p)\n", iface, cchVersion, wzVersion, pcchActual);
 
    return ComponentInfo_GetStringValue(This->classkey, version_valuename,
        cchVersion, wzVersion, pcchActual);
}

PixelFormatInfo_QueryInterface()

static HRESULT WINAPI PixelFormatInfo_QueryInterface ( IWICPixelFormatInfo2 *  iface, REFIID  iid, void **  ppv  )

static

Definition at line 1225 of file info.c.

{
    PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
    TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 
    if (!ppv) return E_INVALIDARG;
 
    if (IsEqualIID(&IID_IUnknown, iid) ||
        IsEqualIID(&IID_IWICComponentInfo, iid) ||
        IsEqualIID(&IID_IWICPixelFormatInfo, iid) ||
        IsEqualIID(&IID_IWICPixelFormatInfo2 ,iid))
    {
        *ppv = &This->base.IWICComponentInfo_iface;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

PixelFormatInfo_Release()

static ULONG WINAPI PixelFormatInfo_Release ( IWICPixelFormatInfo2 *  iface )

static

Definition at line 1260 of file info.c.

{
    PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
    ULONG ref = InterlockedDecrement(&This->base.ref);
 
    TRACE("(%p) refcount=%u\n", iface, ref);
 
    if (ref == 0)
    {
        RegCloseKey(This->classkey);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}

PixelFormatInfo_SupportsTransparency()

static HRESULT WINAPI PixelFormatInfo_SupportsTransparency ( IWICPixelFormatInfo2 *  iface, BOOL *  pfSupportsTransparency  )

static

Definition at line 1444 of file info.c.

{
    PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
 
    TRACE("(%p,%p)\n", iface, pfSupportsTransparency);
 
    return ComponentInfo_GetDWORDValue(This->classkey, supportstransparency_valuename, (DWORD*)pfSupportsTransparency);
}

read_bitmap_patterns()

static void read_bitmap_patterns ( BitmapDecoderInfo *  info )

static

Definition at line 577 of file info.c.

{
    UINT pattern_count=0, patterns_size=0;
    WCHAR subkeyname[11];
    LONG res;
    HKEY patternskey, patternkey;
    static const WCHAR uintformatW[] = {'%','u',0};
    static const WCHAR patternsW[] = {'P','a','t','t','e','r','n','s',0};
    static const WCHAR positionW[] = {'P','o','s','i','t','i','o','n',0};
    static const WCHAR lengthW[] = {'L','e','n','g','t','h',0};
    static const WCHAR patternW[] = {'P','a','t','t','e','r','n',0};
    static const WCHAR maskW[] = {'M','a','s','k',0};
    static const WCHAR endofstreamW[] = {'E','n','d','O','f','S','t','r','e','a','m',0};
    UINT i;
    WICBitmapPattern *patterns;
    BYTE *patterns_ptr;
    DWORD length, valuesize;
 
    res = RegOpenKeyExW(info->classkey, patternsW, 0, KEY_READ, &patternskey);
    if (res != ERROR_SUCCESS) return;
 
    res = RegQueryInfoKeyW(patternskey, NULL, NULL, NULL, &pattern_count, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
    if (res != ERROR_SUCCESS)
    {
        RegCloseKey(patternskey);
        return;
    }
 
    patterns_size = pattern_count * sizeof(WICBitmapPattern);
    patterns = heap_alloc(patterns_size);
    if (!patterns)
    {
        RegCloseKey(patternskey);
        return;
    }
 
    for (i=0; res == ERROR_SUCCESS && i < pattern_count; i++)
    {
        snprintfW(subkeyname, 11, uintformatW, i);
        res = RegOpenKeyExW(patternskey, subkeyname, 0, KEY_READ, &patternkey);
        if (res != ERROR_SUCCESS) break;
 
        valuesize = sizeof(ULONG);
        res = RegGetValueW(patternkey, NULL, lengthW, RRF_RT_DWORD, NULL, &length, &valuesize);
        if (res == ERROR_SUCCESS)
        {
            patterns_size += length*2;
            patterns[i].Length = length;
 
            valuesize = sizeof(BOOL);
            res = RegGetValueW(patternkey, NULL, endofstreamW, RRF_RT_DWORD, NULL,
                               &patterns[i].EndOfStream, &valuesize);
            if (res) patterns[i].EndOfStream = 0;
 
            patterns[i].Position.QuadPart = 0;
            valuesize = sizeof(ULARGE_INTEGER);
            res = RegGetValueW(patternkey, NULL, positionW, RRF_RT_DWORD|RRF_RT_QWORD, NULL,
                               &patterns[i].Position, &valuesize);
        }
 
        RegCloseKey(patternkey);
    }
 
    if (res != ERROR_SUCCESS || !(patterns_ptr = heap_realloc(patterns, patterns_size)))
    {
        heap_free(patterns);
        RegCloseKey(patternskey);
        return;
    }
    patterns = (WICBitmapPattern*)patterns_ptr;
    patterns_ptr += pattern_count * sizeof(*patterns);
 
    for (i=0; res == ERROR_SUCCESS && i < pattern_count; i++)
    {
        snprintfW(subkeyname, 11, uintformatW, i);
        res = RegOpenKeyExW(patternskey, subkeyname, 0, KEY_READ, &patternkey);
        if (res != ERROR_SUCCESS) break;
 
        length = patterns[i].Length;
        patterns[i].Pattern = patterns_ptr;
        valuesize = length;
        res = RegGetValueW(patternkey, NULL, patternW, RRF_RT_REG_BINARY, NULL,
                           patterns[i].Pattern, &valuesize);
        patterns_ptr += length;
 
        if (res == ERROR_SUCCESS)
        {
            patterns[i].Mask = patterns_ptr;
            valuesize = length;
            res = RegGetValueW(patternkey, NULL, maskW, RRF_RT_REG_BINARY, NULL,
                               patterns[i].Mask, &valuesize);
            patterns_ptr += length;
        }
 
        RegCloseKey(patternkey);
    }
 
    RegCloseKey(patternskey);
 
    if (res != ERROR_SUCCESS)
    {
        heap_free(patterns);
        return;
    }
 
    info->pattern_count = pattern_count;
    info->patterns_size = patterns_size;
    info->patterns = patterns;
}

Referenced by BitmapDecoderInfo_Constructor().

read_metadata_info()

static BOOL read_metadata_info ( MetadataReaderInfo *  info )

static

Definition at line 1977 of file info.c.

{
    UINT format_count;
    GUID *formats;
    HRESULT hr;
 
    hr = ComponentInfo_GetGuidList(info->classkey, containers_keyname, 0, NULL, &format_count);
    if (FAILED(hr)) return TRUE;
 
    formats = heap_calloc(format_count, sizeof(*formats));
    if (!formats) return FALSE;
 
    hr = ComponentInfo_GetGuidList(info->classkey, containers_keyname, format_count, formats,
                                   &format_count);
    if (FAILED(hr))
    {
        heap_free(formats);
        return FALSE;
    }
 
    info->container_formats = formats;
    info->container_count = format_count;
 
    if (format_count)
    {
        unsigned i;
 
        info->containers = heap_calloc(format_count, sizeof(*info->containers));
        if (!info->containers) return FALSE;
 
        for (i = 0; i < format_count; i++)
            read_metadata_patterns(info, info->container_formats + i, info->containers + i);
    }
 
    return TRUE;
}

Referenced by MetadataReaderInfo_Constructor().

read_metadata_patterns()

static void read_metadata_patterns ( MetadataReaderInfo *  info, GUID *  container_guid, struct metadata_container *  container  )

static

Definition at line 1863 of file info.c.

{
    UINT pattern_count=0, patterns_size=0;
    WCHAR subkeyname[11], guidkeyname[39];
    LONG res;
    HKEY containers_key, guid_key, patternkey;
    static const WCHAR uintformatW[] = {'%','u',0};
    static const WCHAR patternW[] = {'P','a','t','t','e','r','n',0};
    static const WCHAR positionW[] = {'P','o','s','i','t','i','o','n',0};
    static const WCHAR maskW[] = {'M','a','s','k',0};
    static const WCHAR dataoffsetW[] = {'D','a','t','a','O','f','f','s','e','t',0};
    UINT i;
    WICMetadataPattern *patterns;
    BYTE *patterns_ptr;
    DWORD length, valuesize;
 
    res = RegOpenKeyExW(info->classkey, containers_keyname, 0, KEY_READ, &containers_key);
    if (res != ERROR_SUCCESS) return;
 
    StringFromGUID2(container_guid, guidkeyname, 39);
    res = RegOpenKeyExW(containers_key, guidkeyname, 0, KEY_READ, &guid_key);
    RegCloseKey(containers_key);
    if (res != ERROR_SUCCESS) return;
 
    res = RegQueryInfoKeyW(guid_key, NULL, NULL, NULL, &pattern_count,
                           NULL, NULL, NULL, NULL, NULL, NULL, NULL);
    if (res != ERROR_SUCCESS)
    {
        RegCloseKey(guid_key);
        return;
    }
 
    patterns_size = pattern_count * sizeof(WICMetadataPattern);
    patterns = heap_alloc(patterns_size);
    if (!patterns)
    {
        RegCloseKey(guid_key);
        return;
    }
 
    for (i=0; res == ERROR_SUCCESS && i < pattern_count; i++)
    {
        snprintfW(subkeyname, 11, uintformatW, i);
        res = RegOpenKeyExW(guid_key, subkeyname, 0, KEY_READ, &patternkey);
        if (res != ERROR_SUCCESS) break;
 
        res = RegGetValueW(patternkey, NULL, patternW, RRF_RT_REG_BINARY, NULL, NULL, &length);
        if (res == ERROR_SUCCESS)
        {
            patterns_size += length*2;
            patterns[i].Length = length;
 
            valuesize = sizeof(DWORD64);
            res = RegGetValueW(patternkey, NULL, dataoffsetW, RRF_RT_DWORD|RRF_RT_QWORD, NULL,
                               &patterns[i].DataOffset, &valuesize);
            if (res) patterns[i].DataOffset.QuadPart = 0;
 
            patterns[i].Position.QuadPart = 0;
            valuesize = sizeof(DWORD64);
            res = RegGetValueW(patternkey, NULL, positionW, RRF_RT_DWORD|RRF_RT_QWORD, NULL,
                               &patterns[i].Position, &valuesize);
        }
 
        RegCloseKey(patternkey);
    }
 
    if (res != ERROR_SUCCESS || !(patterns_ptr = heap_realloc(patterns, patterns_size)))
    {
        heap_free(patterns);
        RegCloseKey(guid_key);
        return;
    }
    patterns = (WICMetadataPattern*)patterns_ptr;
    patterns_ptr += pattern_count * sizeof(*patterns);
 
    for (i=0; res == ERROR_SUCCESS && i < pattern_count; i++)
    {
        snprintfW(subkeyname, 11, uintformatW, i);
        res = RegOpenKeyExW(guid_key, subkeyname, 0, KEY_READ, &patternkey);
        if (res != ERROR_SUCCESS) break;
 
        length = patterns[i].Length;
        patterns[i].Pattern = patterns_ptr;
        valuesize = length;
        res = RegGetValueW(patternkey, NULL, patternW, RRF_RT_REG_BINARY, NULL,
                           patterns[i].Pattern, &valuesize);
        patterns_ptr += length;
 
        if (res == ERROR_SUCCESS)
        {
            patterns[i].Mask = patterns_ptr;
            valuesize = length;
            res = RegGetValueW(patternkey, NULL, maskW, RRF_RT_REG_BINARY, NULL,
                               patterns[i].Mask, &valuesize);
            patterns_ptr += length;
        }
 
        RegCloseKey(patternkey);
    }
 
    RegCloseKey(guid_key);
 
    if (res != ERROR_SUCCESS)
    {
        heap_free(patterns);
        return;
    }
 
    container->pattern_count = pattern_count;
    container->patterns_size = patterns_size;
    container->patterns = patterns;
}

Referenced by read_metadata_info().

ReleaseComponentInfos()

void ReleaseComponentInfos

(

void

)

Definition at line 2155 of file info.c.

{
    ComponentInfo *info, *next_info;
    WINE_RB_FOR_EACH_ENTRY_DESTRUCTOR(info, next_info, &component_info_cache, ComponentInfo, entry)
        IWICComponentInfo_Release(&info->IWICComponentInfo_iface);
}

Referenced by WIC_DllMain().

WICConvertBitmapSource()

HRESULT WINAPI WICConvertBitmapSource	(	REFWICPixelFormatGUID	dstFormat,
		IWICBitmapSource *	pISrc,
		IWICBitmapSource **	ppIDst
	)

Definition at line 2474 of file info.c.

{
    HRESULT res;
    IEnumUnknown *enumconverters;
    IUnknown *unkconverterinfo;
    IWICFormatConverterInfo *converterinfo=NULL;
    IWICFormatConverter *converter=NULL;
    GUID srcFormat;
    WCHAR srcformatstr[39], dstformatstr[39];
    BOOL canconvert;
    ULONG num_fetched;
 
    TRACE("%s,%p,%p\n", debugstr_guid(dstFormat), pISrc, ppIDst);
 
    res = IWICBitmapSource_GetPixelFormat(pISrc, &srcFormat);
    if (FAILED(res)) return res;
 
    if (IsEqualGUID(&srcFormat, dstFormat) || (is_1bpp_format(&srcFormat) && is_1bpp_format(dstFormat)))
    {
        IWICBitmapSource_AddRef(pISrc);
        *ppIDst = pISrc;
        return S_OK;
    }
 
    StringFromGUID2(&srcFormat, srcformatstr, 39);
    StringFromGUID2(dstFormat, dstformatstr, 39);
 
    res = CreateComponentEnumerator(WICPixelFormatConverter, 0, &enumconverters);
    if (FAILED(res)) return res;
 
    while (!converter)
    {
        res = IEnumUnknown_Next(enumconverters, 1, &unkconverterinfo, &num_fetched);
 
        if (res == S_OK)
        {
            res = IUnknown_QueryInterface(unkconverterinfo, &IID_IWICFormatConverterInfo, (void**)&converterinfo);
 
            if (SUCCEEDED(res))
            {
                canconvert = ConverterSupportsFormat(converterinfo, srcformatstr);
 
                if (canconvert)
                    canconvert = ConverterSupportsFormat(converterinfo, dstformatstr);
 
                if (canconvert)
                {
                    res = IWICFormatConverterInfo_CreateInstance(converterinfo, &converter);
 
                    if (SUCCEEDED(res))
                        res = IWICFormatConverter_CanConvert(converter, &srcFormat, dstFormat, &canconvert);
 
                    if (SUCCEEDED(res) && canconvert)
                        res = IWICFormatConverter_Initialize(converter, pISrc, dstFormat, WICBitmapDitherTypeNone,
                            NULL, 0.0, WICBitmapPaletteTypeMedianCut);
 
                    if (FAILED(res) || !canconvert)
                    {
                        if (converter)
                        {
                            IWICFormatConverter_Release(converter);
                            converter = NULL;
                        }
                    }
                }
 
                IWICFormatConverterInfo_Release(converterinfo);
            }
 
            IUnknown_Release(unkconverterinfo);
        }
        else
            break;
    }
 
    IEnumUnknown_Release(enumconverters);
 
    if (converter)
    {
        res = IWICFormatConverter_QueryInterface(converter, &IID_IWICBitmapSource, (void **)ppIDst);
        IWICFormatConverter_Release(converter);
        return res;
    }
    else
    {
        FIXME("cannot convert %s to %s\n", debugstr_guid(&srcFormat), debugstr_guid(dstFormat));
        *ppIDst = NULL;
        return WINCODEC_ERR_COMPONENTNOTFOUND;
    }
}

Referenced by BitmapScaler_Initialize(), blit_gif_frame(), ColorTransform_Initialize(), decode_frame_wic(), OLEPictureImpl_LoadWICSource(), PaletteImpl_InitializeFromBitmap(), ReadIcoDib(), ReadIcoPng(), test_conversion(), test_invalid_conversion(), WICSetEncoderFormat_Proxy(), and write_source().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

wincodecs

)

Variable Documentation

author_valuename

const WCHAR author_valuename[] = {'A','u','t','h','o','r',0}

static

Definition at line 42 of file info.c.

Referenced by BitmapDecoderInfo_GetAuthor(), BitmapEncoderInfo_GetAuthor(), FormatConverterInfo_GetAuthor(), MetadataReaderInfo_GetAuthor(), and PixelFormatInfo_GetAuthor().

BitmapDecoderInfo_Vtbl

const IWICBitmapDecoderInfoVtbl BitmapDecoderInfo_Vtbl

static

Initial value:

= {
    BitmapDecoderInfo_QueryInterface,
    BitmapDecoderInfo_AddRef,
    BitmapDecoderInfo_Release,
    BitmapDecoderInfo_GetComponentType,
    BitmapDecoderInfo_GetCLSID,
    BitmapDecoderInfo_GetSigningStatus,
    BitmapDecoderInfo_GetAuthor,
    BitmapDecoderInfo_GetVendorGUID,
    BitmapDecoderInfo_GetVersion,
    BitmapDecoderInfo_GetSpecVersion,
    BitmapDecoderInfo_GetFriendlyName,
    BitmapDecoderInfo_GetContainerFormat,
    BitmapDecoderInfo_GetPixelFormats,
    BitmapDecoderInfo_GetColorManagementVersion,
    BitmapDecoderInfo_GetDeviceManufacturer,
    BitmapDecoderInfo_GetDeviceModels,
    BitmapDecoderInfo_GetMimeTypes,
    BitmapDecoderInfo_GetFileExtensions,
    BitmapDecoderInfo_DoesSupportAnimation,
    BitmapDecoderInfo_DoesSupportChromaKey,
    BitmapDecoderInfo_DoesSupportLossless,
    BitmapDecoderInfo_DoesSupportMultiframe,
    BitmapDecoderInfo_MatchesMimeType,
    BitmapDecoderInfo_GetPatterns,
    BitmapDecoderInfo_MatchesPattern,
    BitmapDecoderInfo_CreateInstance
}

Definition at line 548 of file info.c.

Referenced by BitmapDecoderInfo_Constructor().

BitmapEncoderInfo_Vtbl

const IWICBitmapEncoderInfoVtbl BitmapEncoderInfo_Vtbl

static

Initial value:

= {
    BitmapEncoderInfo_QueryInterface,
    BitmapEncoderInfo_AddRef,
    BitmapEncoderInfo_Release,
    BitmapEncoderInfo_GetComponentType,
    BitmapEncoderInfo_GetCLSID,
    BitmapEncoderInfo_GetSigningStatus,
    BitmapEncoderInfo_GetAuthor,
    BitmapEncoderInfo_GetVendorGUID,
    BitmapEncoderInfo_GetVersion,
    BitmapEncoderInfo_GetSpecVersion,
    BitmapEncoderInfo_GetFriendlyName,
    BitmapEncoderInfo_GetContainerFormat,
    BitmapEncoderInfo_GetPixelFormats,
    BitmapEncoderInfo_GetColorManagementVersion,
    BitmapEncoderInfo_GetDeviceManufacturer,
    BitmapEncoderInfo_GetDeviceModels,
    BitmapEncoderInfo_GetMimeTypes,
    BitmapEncoderInfo_GetFileExtensions,
    BitmapEncoderInfo_DoesSupportAnimation,
    BitmapEncoderInfo_DoesSupportChromaKey,
    BitmapEncoderInfo_DoesSupportLossless,
    BitmapEncoderInfo_DoesSupportMultiframe,
    BitmapEncoderInfo_MatchesMimeType,
    BitmapEncoderInfo_CreateInstance
}

Definition at line 954 of file info.c.

Referenced by BitmapEncoderInfo_Constructor().

bitsperpixel_valuename

const WCHAR bitsperpixel_valuename[] = {'B','i','t','L','e','n','g','t','h',0}

static

Definition at line 51 of file info.c.

Referenced by PixelFormatInfo_GetBitsPerPixel().

categories

const struct category categories[]

static

Initial value:

= {
    {WICDecoder, &CATID_WICBitmapDecoders, BitmapDecoderInfo_Constructor},
    {WICEncoder, &CATID_WICBitmapEncoders, BitmapEncoderInfo_Constructor},
    {WICPixelFormatConverter, &CATID_WICFormatConverters, FormatConverterInfo_Constructor},
    {WICPixelFormat, &CATID_WICPixelFormats, PixelFormatInfo_Constructor},
    {WICMetadataReader, &CATID_WICMetadataReader, MetadataReaderInfo_Constructor},
    {0}
}

Definition at line 2049 of file info.c.

channelcount_valuename

const WCHAR channelcount_valuename[] = {'C','h','a','n','n','e','l','C','o','u','n','t',0}

static

Definition at line 52 of file info.c.

Referenced by PixelFormatInfo_GetChannelCount().

channelmasks_keyname

const WCHAR channelmasks_keyname[] = {'C','h','a','n','n','e','l','M','a','s','k','s',0}

static

Definition at line 53 of file info.c.

Referenced by PixelFormatInfo_GetChannelMask().

clsid_keyname

const WCHAR clsid_keyname[] = {'C','L','S','I','D',0}

static

Definition at line 2040 of file info.c.

Referenced by CreateComponentEnumerator(), and CreateComponentInfo().

component_info_cache

struct wine_rb_tree component_info_cache = { ComponentInfo_Compare }

static

Definition at line 2064 of file info.c.

Referenced by CreateComponentInfo(), and ReleaseComponentInfos().

component_info_cache_cs

static CRITICAL_SECTION component_info_cache_cs = { &component_info_cache_cs_dbg, -1, 0, 0, 0, 0 }

static

Definition at line 2066 of file info.c.

Referenced by CreateComponentInfo().

component_info_cache_cs_dbg

CRITICAL_SECTION_DEBUG component_info_cache_cs_dbg

static

Initial value:

=
{
    0, 0, &component_info_cache_cs,
    { &component_info_cache_cs_dbg.ProcessLocksList, &component_info_cache_cs_dbg.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": component_info_cache") }
}

Definition at line 2067 of file info.c.

ComponentEnumVtbl

static const IEnumUnknownVtbl ComponentEnumVtbl

static

Initial value:

= {
    ComponentEnum_QueryInterface,
    ComponentEnum_AddRef,
    ComponentEnum_Release,
    ComponentEnum_Next,
    ComponentEnum_Skip,
    ComponentEnum_Reset,
    ComponentEnum_Clone
}

Definition at line 2196 of file info.c.

Referenced by ComponentEnum_Clone(), and CreateComponentEnumerator().

containerformat_valuename

const WCHAR containerformat_valuename[] = {'C','o','n','t','a','i','n','e','r','F','o','r','m','a','t',0}

static

Definition at line 46 of file info.c.

Referenced by BitmapDecoderInfo_GetContainerFormat(), and BitmapEncoderInfo_GetContainerFormat().

containers_keyname

const WCHAR containers_keyname[] = {'C','o','n','t','a','i','n','e','r','s',0}

static

Definition at line 59 of file info.c.

Referenced by read_metadata_info(), and read_metadata_patterns().

fileextensions_valuename

const WCHAR fileextensions_valuename[] = {'F','i','l','e','E','x','t','e','n','s','i','o','n','s',0}

static

Definition at line 58 of file info.c.

Referenced by BitmapDecoderInfo_GetFileExtensions(), and BitmapEncoderInfo_GetFileExtensions().

FormatConverterInfo_Vtbl

const IWICFormatConverterInfoVtbl FormatConverterInfo_Vtbl

static

Initial value:

= {
    FormatConverterInfo_QueryInterface,
    FormatConverterInfo_AddRef,
    FormatConverterInfo_Release,
    FormatConverterInfo_GetComponentType,
    FormatConverterInfo_GetCLSID,
    FormatConverterInfo_GetSigningStatus,
    FormatConverterInfo_GetAuthor,
    FormatConverterInfo_GetVendorGUID,
    FormatConverterInfo_GetVersion,
    FormatConverterInfo_GetSpecVersion,
    FormatConverterInfo_GetFriendlyName,
    FormatConverterInfo_GetPixelFormats,
    FormatConverterInfo_CreateInstance
}

Definition at line 1179 of file info.c.

Referenced by FormatConverterInfo_Constructor().

formats_keyname

const WCHAR formats_keyname[] = {'F','o','r','m','a','t','s',0}

static

Definition at line 45 of file info.c.

Referenced by BitmapDecoderInfo_GetPixelFormats(), and BitmapEncoderInfo_GetPixelFormats().

friendlyname_valuename

const WCHAR friendlyname_valuename[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0}

static

Definition at line 43 of file info.c.

Referenced by BitmapDecoderInfo_GetFriendlyName(), BitmapEncoderInfo_GetFriendlyName(), FormatConverterInfo_GetFriendlyName(), MetadataReaderInfo_GetFriendlyName(), and PixelFormatInfo_GetFriendlyName().

instance_keyname

const WCHAR instance_keyname[] = {'I','n','s','t','a','n','c','e',0}

static

Definition at line 2041 of file info.c.

Referenced by CreateComponentEnumerator(), and CreateComponentInfo().

metadataformat_valuename

const WCHAR metadataformat_valuename[] = {'M','e','t','a','d','a','t','a','F','o','r','m','a','t',0}

static

Definition at line 47 of file info.c.

Referenced by MetadataReaderInfo_GetMetadataFormat().

MetadataReaderInfo_Vtbl

const IWICMetadataReaderInfoVtbl MetadataReaderInfo_Vtbl

static

Initial value:

= {
    MetadataReaderInfo_QueryInterface,
    MetadataReaderInfo_AddRef,
    MetadataReaderInfo_Release,
    MetadataReaderInfo_GetComponentType,
    MetadataReaderInfo_GetCLSID,
    MetadataReaderInfo_GetSigningStatus,
    MetadataReaderInfo_GetAuthor,
    MetadataReaderInfo_GetVendorGUID,
    MetadataReaderInfo_GetVersion,
    MetadataReaderInfo_GetSpecVersion,
    MetadataReaderInfo_GetFriendlyName,
    MetadataReaderInfo_GetMetadataFormat,
    MetadataReaderInfo_GetContainerFormats,
    MetadataReaderInfo_GetDeviceManufacturer,
    MetadataReaderInfo_GetDeviceModels,
    MetadataReaderInfo_DoesRequireFullStream,
    MetadataReaderInfo_DoesSupportPadding,
    MetadataReaderInfo_DoesRequireFixedSize,
    MetadataReaderInfo_GetPatterns,
    MetadataReaderInfo_MatchesPattern,
    MetadataReaderInfo_CreateInstance
}

Definition at line 1839 of file info.c.

Referenced by MetadataReaderInfo_Constructor().

mimetypes_valuename

const WCHAR mimetypes_valuename[] = {'M','i','m','e','T','y','p','e','s',0}

static

Definition at line 41 of file info.c.

Referenced by BitmapDecoderInfo_GetMimeTypes(), and BitmapEncoderInfo_GetMimeTypes().

numericrepresentation_valuename

const WCHAR numericrepresentation_valuename[] = {'N','u','m','e','r','i','c','R','e','p','r','e','s','e','n','t','a','t','i','o','n',0}

static

Definition at line 54 of file info.c.

Referenced by PixelFormatInfo_GetNumericRepresentation().

PixelFormatInfo_Vtbl

const IWICPixelFormatInfo2Vtbl PixelFormatInfo_Vtbl

static

Initial value:

= {
    PixelFormatInfo_QueryInterface,
    PixelFormatInfo_AddRef,
    PixelFormatInfo_Release,
    PixelFormatInfo_GetComponentType,
    PixelFormatInfo_GetCLSID,
    PixelFormatInfo_GetSigningStatus,
    PixelFormatInfo_GetAuthor,
    PixelFormatInfo_GetVendorGUID,
    PixelFormatInfo_GetVersion,
    PixelFormatInfo_GetSpecVersion,
    PixelFormatInfo_GetFriendlyName,
    PixelFormatInfo_GetFormatGUID,
    PixelFormatInfo_GetColorContext,
    PixelFormatInfo_GetBitsPerPixel,
    PixelFormatInfo_GetChannelCount,
    PixelFormatInfo_GetChannelMask,
    PixelFormatInfo_SupportsTransparency,
    PixelFormatInfo_GetNumericRepresentation
}

Definition at line 1464 of file info.c.

Referenced by PixelFormatInfo_Constructor().

pixelformats_keyname

const WCHAR pixelformats_keyname[] = {'P','i','x','e','l','F','o','r','m','a','t','s',0}

static

Definition at line 44 of file info.c.

Referenced by ConverterSupportsFormat().

requiresfullstream_valuename

const WCHAR requiresfullstream_valuename[] = {'R','e','q','u','i','r','e','s','F','u','l','l','S','t','r','e','a','m',0}

static

Definition at line 56 of file info.c.

Referenced by MetadataReaderInfo_DoesRequireFullStream().

specversion_valuename

const WCHAR specversion_valuename[] = {'S','p','e','c','V','e','r','s','i','o','n',0}

static

Definition at line 50 of file info.c.

Referenced by BitmapDecoderInfo_GetSpecVersion(), BitmapEncoderInfo_GetSpecVersion(), FormatConverterInfo_GetSpecVersion(), MetadataReaderInfo_GetSpecVersion(), and PixelFormatInfo_GetSpecVersion().

supportspadding_valuename

const WCHAR supportspadding_valuename[] = {'S','u','p','p','o','r','t','s','P','a','d','d','i','n','g',0}

static

Definition at line 57 of file info.c.

Referenced by MetadataReaderInfo_DoesSupportPadding().

supportstransparency_valuename

const WCHAR supportstransparency_valuename[] = {'S','u','p','p','o','r','t','s','T','r','a','n','s','p','a','r','e','n','c','y',0}

static

Definition at line 55 of file info.c.

Referenced by PixelFormatInfo_SupportsTransparency().

vendor_valuename

const WCHAR vendor_valuename[] = {'V','e','n','d','o','r',0}

static

Definition at line 48 of file info.c.

Referenced by BitmapDecoderInfo_GetVendorGUID(), BitmapEncoderInfo_GetVendorGUID(), FormatConverterInfo_GetVendorGUID(), MetadataReaderInfo_GetVendorGUID(), and PixelFormatInfo_GetVendorGUID().

version_valuename

const WCHAR version_valuename[] = {'V','e','r','s','i','o','n',0}

static

Definition at line 49 of file info.c.

Referenced by BitmapDecoderInfo_GetVersion(), BitmapEncoderInfo_GetVersion(), FormatConverterInfo_GetVersion(), MetadataReaderInfo_GetVersion(), and PixelFormatInfo_GetVersion().