ReactOS 0.4.15-dev-8131-g4988de4
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 BitmapDecoderInfoimpl_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 BitmapEncoderInfoimpl_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 FormatConverterInfoimpl_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 PixelFormatInfoimpl_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_containerget_metadata_container (MetadataReaderInfo *info, const GUID *guid)
 
static MetadataReaderInfoimpl_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 ComponentEnumimpl_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.

254{
256 ULONG ref = InterlockedIncrement(&This->base.ref);
257
258 TRACE("(%p) refcount=%u\n", iface, ref);
259
260 return ref;
261}
#define InterlockedIncrement
Definition: armddk.h:53
static BitmapDecoderInfo * impl_from_IWICBitmapDecoderInfo(IWICBitmapDecoderInfo *iface)
Definition: info.c:223
#define TRACE(s)
Definition: solgame.cpp:4
Definition: send.c:48
uint32_t ULONG
Definition: typedefs.h:59

◆ BitmapDecoderInfo_Constructor()

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

Definition at line 687 of file info.c.

688{
690
691 This = heap_alloc_zero(sizeof(BitmapDecoderInfo));
692 if (!This)
693 {
694 RegCloseKey(classkey);
695 return E_OUTOFMEMORY;
696 }
697
698 This->base.IWICComponentInfo_iface.lpVtbl = (const IWICComponentInfoVtbl*)&BitmapDecoderInfo_Vtbl;
699 This->base.ref = 1;
700 This->classkey = classkey;
701 This->base.clsid = *clsid;
702
704
705 *ret = &This->base;
706 return S_OK;
707}
#define RegCloseKey(hKey)
Definition: registry.h:49
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
static void read_bitmap_patterns(BitmapDecoderInfo *info)
Definition: info.c:577
static const IWICBitmapDecoderInfoVtbl BitmapDecoderInfo_Vtbl
Definition: info.c:548
#define S_OK
Definition: intsafe.h:52
REFCLSID clsid
Definition: msctf.c:82
int ret

◆ BitmapDecoderInfo_CreateInstance()

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

Definition at line 538 of file info.c.

540{
542
543 TRACE("(%p,%p)\n", iface, ppIBitmapDecoder);
544
545 return create_instance(&This->base.clsid, &IID_IWICBitmapDecoder, (void**)ppIBitmapDecoder);
546}
HRESULT create_instance(CLSID *clsid, const IID *iid, void **ppv)
Definition: clsfactory.c:208

◆ BitmapDecoderInfo_DoesSupportAnimation()

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

Definition at line 419 of file info.c.

421{
422 FIXME("(%p,%p): stub\n", iface, pfSupportAnimation);
423 return E_NOTIMPL;
424}
#define FIXME(fmt,...)
Definition: debug.h:114
#define E_NOTIMPL
Definition: ddrawi.h:99

◆ BitmapDecoderInfo_DoesSupportChromaKey()

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

Definition at line 426 of file info.c.

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

◆ BitmapDecoderInfo_DoesSupportLossless()

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

Definition at line 433 of file info.c.

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

◆ BitmapDecoderInfo_DoesSupportMultiframe()

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

Definition at line 440 of file info.c.

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

◆ BitmapDecoderInfo_GetAuthor()

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

Definition at line 307 of file info.c.

309{
311
312 TRACE("(%p,%u,%p,%p)\n", iface, cchAuthor, wzAuthor, pcchActual);
313
315 cchAuthor, wzAuthor, pcchActual);
316}
static const WCHAR author_valuename[]
Definition: info.c:42
static HRESULT ComponentInfo_GetStringValue(HKEY classkey, LPCWSTR value, UINT buffer_size, WCHAR *buffer, UINT *actual_size)
Definition: info.c:68

◆ BitmapDecoderInfo_GetCLSID()

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

Definition at line 289 of file info.c.

290{
292 TRACE("(%p,%p)\n", iface, pclsid);
293
294 if (!pclsid)
295 return E_INVALIDARG;
296
297 *pclsid = This->base.clsid;
298 return S_OK;
299}
#define E_INVALIDARG
Definition: ddrawi.h:101

◆ BitmapDecoderInfo_GetColorManagementVersion()

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

Definition at line 376 of file info.c.

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

◆ BitmapDecoderInfo_GetComponentType()

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

Definition at line 280 of file info.c.

282{
283 TRACE("(%p,%p)\n", iface, pType);
284 if (!pType) return E_INVALIDARG;
285 *pType = WICDecoder;
286 return S_OK;
287}
@ WICDecoder
Definition: wincodec.idl:125

◆ BitmapDecoderInfo_GetContainerFormat()

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

Definition at line 360 of file info.c.

362{
364 TRACE("(%p,%p)\n", iface, pguidContainerFormat);
365 return ComponentInfo_GetGUIDValue(This->classkey, containerformat_valuename, pguidContainerFormat);
366}
static HRESULT ComponentInfo_GetGUIDValue(HKEY classkey, LPCWSTR value, GUID *result)
Definition: info.c:99
static const WCHAR containerformat_valuename[]
Definition: info.c:46

◆ BitmapDecoderInfo_GetDeviceManufacturer()

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

Definition at line 383 of file info.c.

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

◆ BitmapDecoderInfo_GetDeviceModels()

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

Definition at line 390 of file info.c.

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

◆ BitmapDecoderInfo_GetFileExtensions()

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

Definition at line 408 of file info.c.

410{
412
413 TRACE("(%p,%u,%p,%p)\n", iface, cchFileExtensions, wzFileExtensions, pcchActual);
414
416 cchFileExtensions, wzFileExtensions, pcchActual);
417}
static const WCHAR fileextensions_valuename[]
Definition: info.c:58

◆ BitmapDecoderInfo_GetFriendlyName()

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

Definition at line 349 of file info.c.

351{
353
354 TRACE("(%p,%u,%p,%p)\n", iface, cchFriendlyName, wzFriendlyName, pcchActual);
355
357 cchFriendlyName, wzFriendlyName, pcchActual);
358}
static const WCHAR friendlyname_valuename[]
Definition: info.c:43

◆ BitmapDecoderInfo_GetMimeTypes()

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

Definition at line 397 of file info.c.

399{
401
402 TRACE("(%p,%u,%p,%p)\n", iface, cchMimeTypes, wzMimeTypes, pcchActual);
403
405 cchMimeTypes, wzMimeTypes, pcchActual);
406}
static const WCHAR mimetypes_valuename[]
Definition: info.c:41

◆ 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.

456{
458
459 TRACE("(%p,%i,%p,%p,%p)\n", iface, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActual);
460
461 if (!pcPatterns || !pcbPatternsActual) return E_INVALIDARG;
462
463 *pcPatterns = This->pattern_count;
464 *pcbPatternsActual = This->patterns_size;
465 if (pPatterns)
466 {
467 if (This->patterns_size && cbSizePatterns < This->patterns_size)
469 memcpy(pPatterns, This->patterns, This->patterns_size);
470 }
471 return S_OK;
472}
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define WINCODEC_ERR_INSUFFICIENTBUFFER
Definition: winerror.h:3311

◆ BitmapDecoderInfo_GetPixelFormats()

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

Definition at line 368 of file info.c.

370{
372 TRACE("(%p,%u,%p,%p)\n", iface, cFormats, pguidPixelFormats, pcActual);
373 return ComponentInfo_GetGuidList(This->classkey, formats_keyname, cFormats, pguidPixelFormats, pcActual);
374}
static const WCHAR formats_keyname[]
Definition: info.c:45
static HRESULT ComponentInfo_GetGuidList(HKEY classkey, LPCWSTR subkeyname, UINT buffersize, GUID *buffer, UINT *actual_size)
Definition: info.c:148

◆ BitmapDecoderInfo_GetSigningStatus()

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

Definition at line 301 of file info.c.

302{
303 FIXME("(%p,%p): stub\n", iface, pStatus);
304 return E_NOTIMPL;
305}
__in WDFDMATRANSACTION __out NTSTATUS * pStatus

◆ BitmapDecoderInfo_GetSpecVersion()

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

Definition at line 338 of file info.c.

340{
342
343 TRACE("(%p,%u,%p,%p)\n", iface, cchSpecVersion, wzSpecVersion, pcchActual);
344
346 cchSpecVersion, wzSpecVersion, pcchActual);
347}
static const WCHAR specversion_valuename[]
Definition: info.c:50

◆ BitmapDecoderInfo_GetVendorGUID()

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

Definition at line 318 of file info.c.

319{
321
322 TRACE("(%p,%p)\n", iface, pguidVendor);
323
324 return ComponentInfo_GetGUIDValue(This->classkey, vendor_valuename, pguidVendor);
325}
static const WCHAR vendor_valuename[]
Definition: info.c:48

◆ BitmapDecoderInfo_GetVersion()

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

Definition at line 327 of file info.c.

329{
331
332 TRACE("(%p,%u,%p,%p)\n", iface, cchVersion, wzVersion, pcchActual);
333
335 cchVersion, wzVersion, pcchActual);
336}
static const WCHAR version_valuename[]
Definition: info.c:49

◆ BitmapDecoderInfo_MatchesMimeType()

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

Definition at line 447 of file info.c.

449{
450 FIXME("(%p,%s,%p): stub\n", iface, debugstr_w(wzMimeType), pfMatches);
451 return E_NOTIMPL;
452}
#define debugstr_w
Definition: kernel32.h:32

◆ BitmapDecoderInfo_MatchesPattern()

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

Definition at line 474 of file info.c.

476{
478 HRESULT hr;
479 UINT i;
480 ULONG pos;
481 BYTE *data=NULL;
482 ULONG datasize=0;
483 ULONG bytesread;
484 LARGE_INTEGER seekpos;
485
486 TRACE("(%p,%p,%p)\n", iface, pIStream, pfMatches);
487
488 for (i=0; i < This->pattern_count; i++)
489 {
490 if (datasize < This->patterns[i].Length)
491 {
493 datasize = This->patterns[i].Length;
494 data = HeapAlloc(GetProcessHeap(), 0, This->patterns[i].Length);
495 if (!data)
496 {
498 break;
499 }
500 }
501
502 if (This->patterns[i].EndOfStream)
503 seekpos.QuadPart = -This->patterns[i].Position.QuadPart;
504 else
505 seekpos.QuadPart = This->patterns[i].Position.QuadPart;
506 hr = IStream_Seek(pIStream, seekpos, This->patterns[i].EndOfStream ? STREAM_SEEK_END : STREAM_SEEK_SET, NULL);
507 if (hr == STG_E_INVALIDFUNCTION) continue; /* before start of stream */
508 if (FAILED(hr)) break;
509
510 hr = IStream_Read(pIStream, data, This->patterns[i].Length, &bytesread);
511 if (hr == S_FALSE || (hr == S_OK && bytesread != This->patterns[i].Length)) /* past end of stream */
512 continue;
513 if (FAILED(hr)) break;
514
515 for (pos=0; pos < This->patterns[i].Length; pos++)
516 {
517 if ((data[pos] & This->patterns[i].Mask[pos]) != This->patterns[i].Pattern[pos])
518 break;
519 }
520 if (pos == This->patterns[i].Length) /* matches pattern */
521 {
522 hr = S_OK;
523 *pfMatches = TRUE;
524 break;
525 }
526 }
527
528 if (i == This->pattern_count) /* does not match any pattern */
529 {
530 hr = S_OK;
531 *pfMatches = FALSE;
532 }
533
535 return hr;
536}
static SIZE_T datasize
Definition: asm.c:30
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define FAILED(hr)
Definition: intsafe.h:51
unsigned int UINT
Definition: ndis.h:50
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
HRESULT hr
Definition: shlfolder.c:183
LONGLONG QuadPart
Definition: typedefs.h:114
#define S_FALSE
Definition: winerror.h:2357
#define STG_E_INVALIDFUNCTION
Definition: winerror.h:2564
unsigned char BYTE
Definition: xxhash.c:193

◆ BitmapDecoderInfo_QueryInterface()

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

Definition at line 228 of file info.c.

230{
232 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
233
234 if (!ppv) return E_INVALIDARG;
235
236 if (IsEqualIID(&IID_IUnknown, iid) ||
237 IsEqualIID(&IID_IWICComponentInfo, iid) ||
238 IsEqualIID(&IID_IWICBitmapCodecInfo, iid) ||
239 IsEqualIID(&IID_IWICBitmapDecoderInfo ,iid))
240 {
241 *ppv = &This->base.IWICComponentInfo_iface;
242 }
243 else
244 {
245 *ppv = NULL;
246 return E_NOINTERFACE;
247 }
248
249 IUnknown_AddRef((IUnknown*)*ppv);
250 return S_OK;
251}
const GUID IID_IUnknown
REFIID LPVOID * ppv
Definition: atlbase.h:39
#define debugstr_guid
Definition: kernel32.h:35
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
#define E_NOINTERFACE
Definition: winerror.h:2364

◆ BitmapDecoderInfo_Release()

static ULONG WINAPI BitmapDecoderInfo_Release ( IWICBitmapDecoderInfo iface)
static

Definition at line 263 of file info.c.

264{
266 ULONG ref = InterlockedDecrement(&This->base.ref);
267
268 TRACE("(%p) refcount=%u\n", iface, ref);
269
270 if (ref == 0)
271 {
272 RegCloseKey(This->classkey);
273 heap_free(This->patterns);
275 }
276
277 return ref;
278}
static BOOL heap_free(void *mem)
Definition: appwiz.h:76
#define InterlockedDecrement
Definition: armddk.h:52

◆ BitmapEncoderInfo_AddRef()

static ULONG WINAPI BitmapEncoderInfo_AddRef ( IWICBitmapEncoderInfo iface)
static

Definition at line 744 of file info.c.

745{
747 ULONG ref = InterlockedIncrement(&This->base.ref);
748
749 TRACE("(%p) refcount=%u\n", iface, ref);
750
751 return ref;
752}
static BitmapEncoderInfo * impl_from_IWICBitmapEncoderInfo(IWICBitmapEncoderInfo *iface)
Definition: info.c:714

◆ BitmapEncoderInfo_Constructor()

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

Definition at line 981 of file info.c.

982{
984
986 if (!This)
987 {
988 RegCloseKey(classkey);
989 return E_OUTOFMEMORY;
990 }
991
992 This->base.IWICComponentInfo_iface.lpVtbl = (const IWICComponentInfoVtbl*)&BitmapEncoderInfo_Vtbl;
993 This->base.ref = 1;
994 This->classkey = classkey;
995 This->base.clsid = *clsid;
996
997 *ret = &This->base;
998 return S_OK;
999}
static const IWICBitmapEncoderInfoVtbl BitmapEncoderInfo_Vtbl
Definition: info.c:954

◆ BitmapEncoderInfo_CreateInstance()

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

Definition at line 944 of file info.c.

946{
948
949 TRACE("(%p,%p)\n", iface, ppIBitmapEncoder);
950
951 return create_instance(&This->base.clsid, &IID_IWICBitmapEncoder, (void**)ppIBitmapEncoder);
952}

◆ BitmapEncoderInfo_DoesSupportAnimation()

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

Definition at line 909 of file info.c.

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

◆ BitmapEncoderInfo_DoesSupportChromaKey()

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

Definition at line 916 of file info.c.

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

◆ BitmapEncoderInfo_DoesSupportLossless()

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

Definition at line 923 of file info.c.

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

◆ BitmapEncoderInfo_DoesSupportMultiframe()

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

Definition at line 930 of file info.c.

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

◆ BitmapEncoderInfo_GetAuthor()

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

Definition at line 797 of file info.c.

799{
801
802 TRACE("(%p,%u,%p,%p)\n", iface, cchAuthor, wzAuthor, pcchActual);
803
805 cchAuthor, wzAuthor, pcchActual);
806}

◆ BitmapEncoderInfo_GetCLSID()

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

Definition at line 779 of file info.c.

780{
782 TRACE("(%p,%p)\n", iface, pclsid);
783
784 if (!pclsid)
785 return E_INVALIDARG;
786
787 *pclsid = This->base.clsid;
788 return S_OK;
789}

◆ BitmapEncoderInfo_GetColorManagementVersion()

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

Definition at line 866 of file info.c.

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

◆ BitmapEncoderInfo_GetComponentType()

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

Definition at line 770 of file info.c.

772{
773 TRACE("(%p,%p)\n", iface, pType);
774 if (!pType) return E_INVALIDARG;
775 *pType = WICEncoder;
776 return S_OK;
777}
@ WICEncoder
Definition: wincodec.idl:126

◆ BitmapEncoderInfo_GetContainerFormat()

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

Definition at line 850 of file info.c.

852{
854 TRACE("(%p,%p)\n", iface, pguidContainerFormat);
855 return ComponentInfo_GetGUIDValue(This->classkey, containerformat_valuename, pguidContainerFormat);
856}

◆ BitmapEncoderInfo_GetDeviceManufacturer()

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

Definition at line 873 of file info.c.

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

◆ BitmapEncoderInfo_GetDeviceModels()

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

Definition at line 880 of file info.c.

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

◆ BitmapEncoderInfo_GetFileExtensions()

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

Definition at line 898 of file info.c.

900{
902
903 TRACE("(%p,%u,%p,%p)\n", iface, cchFileExtensions, wzFileExtensions, pcchActual);
904
906 cchFileExtensions, wzFileExtensions, pcchActual);
907}

◆ BitmapEncoderInfo_GetFriendlyName()

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

Definition at line 839 of file info.c.

841{
843
844 TRACE("(%p,%u,%p,%p)\n", iface, cchFriendlyName, wzFriendlyName, pcchActual);
845
847 cchFriendlyName, wzFriendlyName, pcchActual);
848}

◆ BitmapEncoderInfo_GetMimeTypes()

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

Definition at line 887 of file info.c.

889{
891
892 TRACE("(%p,%u,%p,%p)\n", iface, cchMimeTypes, wzMimeTypes, pcchActual);
893
895 cchMimeTypes, wzMimeTypes, pcchActual);
896}

◆ BitmapEncoderInfo_GetPixelFormats()

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

Definition at line 858 of file info.c.

860{
862 TRACE("(%p,%u,%p,%p)\n", iface, cFormats, pguidPixelFormats, pcActual);
863 return ComponentInfo_GetGuidList(This->classkey, formats_keyname, cFormats, pguidPixelFormats, pcActual);
864}

◆ BitmapEncoderInfo_GetSigningStatus()

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

Definition at line 791 of file info.c.

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

◆ BitmapEncoderInfo_GetSpecVersion()

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

Definition at line 828 of file info.c.

830{
832
833 TRACE("(%p,%u,%p,%p)\n", iface, cchSpecVersion, wzSpecVersion, pcchActual);
834
836 cchSpecVersion, wzSpecVersion, pcchActual);
837}

◆ BitmapEncoderInfo_GetVendorGUID()

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

Definition at line 808 of file info.c.

809{
811
812 TRACE("(%p,%p)\n", iface, pguidVendor);
813
814 return ComponentInfo_GetGUIDValue(This->classkey, vendor_valuename, pguidVendor);
815}

◆ BitmapEncoderInfo_GetVersion()

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

Definition at line 817 of file info.c.

819{
821
822 TRACE("(%p,%u,%p,%p)\n", iface, cchVersion, wzVersion, pcchActual);
823
825 cchVersion, wzVersion, pcchActual);
826}

◆ BitmapEncoderInfo_MatchesMimeType()

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

Definition at line 937 of file info.c.

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

◆ BitmapEncoderInfo_QueryInterface()

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

Definition at line 719 of file info.c.

721{
723 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
724
725 if (!ppv) return E_INVALIDARG;
726
727 if (IsEqualIID(&IID_IUnknown, iid) ||
728 IsEqualIID(&IID_IWICComponentInfo, iid) ||
729 IsEqualIID(&IID_IWICBitmapCodecInfo, iid) ||
730 IsEqualIID(&IID_IWICBitmapEncoderInfo ,iid))
731 {
732 *ppv = &This->base.IWICComponentInfo_iface;
733 }
734 else
735 {
736 *ppv = NULL;
737 return E_NOINTERFACE;
738 }
739
740 IUnknown_AddRef((IUnknown*)*ppv);
741 return S_OK;
742}

◆ BitmapEncoderInfo_Release()

static ULONG WINAPI BitmapEncoderInfo_Release ( IWICBitmapEncoderInfo iface)
static

Definition at line 754 of file info.c.

755{
757 ULONG ref = InterlockedDecrement(&This->base.ref);
758
759 TRACE("(%p) refcount=%u\n", iface, ref);
760
761 if (ref == 0)
762 {
763 RegCloseKey(This->classkey);
765 }
766
767 return ref;
768}

◆ ComponentEnum_AddRef()

static ULONG WINAPI ComponentEnum_AddRef ( IEnumUnknown iface)
static

Definition at line 2221 of file info.c.

2222{
2225
2226 TRACE("(%p) refcount=%u\n", iface, ref);
2227
2228 return ref;
2229}
static ComponentEnum * impl_from_IEnumUnknown(IEnumUnknown *iface)
Definition: info.c:2186

◆ ComponentEnum_Clone()

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

Definition at line 2319 of file info.c.

2320{
2322 ComponentEnum *new_enum;
2323 ComponentEnumItem *old_item, *new_item;
2325 struct list *old_cursor;
2326
2327 new_enum = HeapAlloc(GetProcessHeap(), 0, sizeof(ComponentEnum));
2328 if (!new_enum)
2329 {
2330 *ppenum = NULL;
2331 return E_OUTOFMEMORY;
2332 }
2333
2334 new_enum->IEnumUnknown_iface.lpVtbl = &ComponentEnumVtbl;
2335 new_enum->ref = 1;
2336 new_enum->cursor = NULL;
2337 list_init(&new_enum->objects);
2338 InitializeCriticalSection(&new_enum->lock);
2339 new_enum->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": ComponentEnum.lock");
2340
2341 EnterCriticalSection(&This->lock);
2342 old_cursor = This->cursor;
2343 LeaveCriticalSection(&This->lock);
2344
2345 LIST_FOR_EACH_ENTRY(old_item, &This->objects, ComponentEnumItem, entry)
2346 {
2347 new_item = HeapAlloc(GetProcessHeap(), 0, sizeof(ComponentEnumItem));
2348 if (!new_item)
2349 {
2351 break;
2352 }
2353 new_item->unk = old_item->unk;
2354 list_add_tail(&new_enum->objects, &new_item->entry);
2355 IUnknown_AddRef(new_item->unk);
2356 if (&old_item->entry == old_cursor) new_enum->cursor = &new_item->entry;
2357 }
2358
2359 if (FAILED(ret))
2360 {
2361 IEnumUnknown_Release(&new_enum->IEnumUnknown_iface);
2362 *ppenum = NULL;
2363 }
2364 else
2365 *ppenum = &new_enum->IEnumUnknown_iface;
2366
2367 return ret;
2368}
static void list_add_tail(struct list_entry *head, struct list_entry *entry)
Definition: list.h:83
static void list_init(struct list_entry *head)
Definition: list.h:51
Definition: list.h:37
static const IEnumUnknownVtbl ComponentEnumVtbl
Definition: info.c:2196
uint32_t entry
Definition: isohybrid.c:63
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
IUnknown * unk
Definition: info.c:2193
struct list entry
Definition: info.c:2192
IEnumUnknown IEnumUnknown_iface
Definition: info.c:2179
LONG ref
Definition: info.c:2180
CRITICAL_SECTION lock
Definition: info.c:2183
struct list objects
Definition: info.c:2181
struct list * cursor
Definition: info.c:2182
DWORD_PTR Spare[8/sizeof(DWORD_PTR)]
Definition: winbase.h:887
PCRITICAL_SECTION_DEBUG DebugInfo
Definition: winbase.h:894
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
#define DWORD_PTR
Definition: treelist.c:76
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)

◆ ComponentEnum_Next()

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

Definition at line 2255 of file info.c.

2257{
2259 ULONG num_fetched=0;
2261 HRESULT hr=S_OK;
2262
2263 TRACE("(%p,%u,%p,%p)\n", iface, celt, rgelt, pceltFetched);
2264
2265 EnterCriticalSection(&This->lock);
2266 while (num_fetched<celt)
2267 {
2268 if (!This->cursor)
2269 {
2270 hr = S_FALSE;
2271 break;
2272 }
2274 IUnknown_AddRef(item->unk);
2275 rgelt[num_fetched] = item->unk;
2276 num_fetched++;
2277 This->cursor = list_next(&This->objects, This->cursor);
2278 }
2279 LeaveCriticalSection(&This->lock);
2280 if (pceltFetched)
2281 *pceltFetched = num_fetched;
2282 return hr;
2283}
static ATOM item
Definition: dde.c:856
__WINE_SERVER_LIST_INLINE struct list * list_next(const struct list *list, const struct list *elem)
Definition: list.h:115
#define LIST_ENTRY(type)
Definition: queue.h:175

◆ ComponentEnum_QueryInterface()

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

Definition at line 2198 of file info.c.

2200{
2202 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
2203
2204 if (!ppv) return E_INVALIDARG;
2205
2206 if (IsEqualIID(&IID_IUnknown, iid) ||
2208 {
2209 *ppv = &This->IEnumUnknown_iface;
2210 }
2211 else
2212 {
2213 *ppv = NULL;
2214 return E_NOINTERFACE;
2215 }
2216
2217 IUnknown_AddRef((IUnknown*)*ppv);
2218 return S_OK;
2219}
const GUID IID_IEnumUnknown

◆ ComponentEnum_Release()

static ULONG WINAPI ComponentEnum_Release ( IEnumUnknown iface)
static

Definition at line 2231 of file info.c.

2232{
2235 ComponentEnumItem *cursor, *cursor2;
2236
2237 TRACE("(%p) refcount=%u\n", iface, ref);
2238
2239 if (ref == 0)
2240 {
2242 {
2243 IUnknown_Release(cursor->unk);
2244 list_remove(&cursor->entry);
2246 }
2247 This->lock.DebugInfo->Spare[0] = 0;
2250 }
2251
2252 return ref;
2253}
static void list_remove(struct list_entry *entry)
Definition: list.h:90
const char cursor[]
Definition: icontest.c:13
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:204
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)

◆ ComponentEnum_Reset()

static HRESULT WINAPI ComponentEnum_Reset ( IEnumUnknown iface)
static

Definition at line 2307 of file info.c.

2308{
2310
2311 TRACE("(%p)\n", iface);
2312
2313 EnterCriticalSection(&This->lock);
2314 This->cursor = list_head(&This->objects);
2315 LeaveCriticalSection(&This->lock);
2316 return S_OK;
2317}
Definition: list.h:15

◆ ComponentEnum_Skip()

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

Definition at line 2285 of file info.c.

2286{
2288 ULONG i;
2289 HRESULT hr=S_OK;
2290
2291 TRACE("(%p,%u)\n", iface, celt);
2292
2293 EnterCriticalSection(&This->lock);
2294 for (i=0; i<celt; i++)
2295 {
2296 if (!This->cursor)
2297 {
2298 hr = S_FALSE;
2299 break;
2300 }
2301 This->cursor = list_next(&This->objects, This->cursor);
2302 }
2303 LeaveCriticalSection(&This->lock);
2304 return hr;
2305}

◆ ComponentInfo_Compare()

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

Definition at line 2058 of file info.c.

2059{
2061 return memcmp(key, &info->clsid, sizeof(info->clsid));
2062}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define WINE_RB_ENTRY_VALUE(element, type, field)
Definition: rbtree.h:31
Definition: copy.c:22

◆ ComponentInfo_GetDWORDValue()

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

Definition at line 127 of file info.c.

129{
130 LONG ret;
131 DWORD cbdata = sizeof(DWORD);
132
133 if (!result)
134 return E_INVALIDARG;
135
137 result, &cbdata);
138
140 {
141 *result = 0;
142 return S_OK;
143 }
144
145 return HRESULT_FROM_WIN32(ret);
146}
LSTATUS WINAPI RegGetValueW(HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData)
Definition: reg.c:1931
#define RRF_RT_DWORD
Definition: driver.c:581
unsigned long DWORD
Definition: ntddk_ex.h:95
GLuint64EXT * result
Definition: glext.h:11304
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
#define DWORD
Definition: nt_native.h:44
long LONG
Definition: pedump.c:60
Definition: pdh_main.c:94
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92

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.

150{
151 LONG ret;
152 HKEY subkey;
153 UINT items_returned;
154 WCHAR guid_string[39];
155 DWORD guid_string_size;
157
158 if (!actual_size)
159 return E_INVALIDARG;
160
161 ret = RegOpenKeyExW(classkey, subkeyname, 0, KEY_READ, &subkey);
163 {
164 *actual_size = 0;
165 return S_OK;
166 }
167 else if (ret != ERROR_SUCCESS) return HRESULT_FROM_WIN32(ret);
168
169 if (buffer)
170 {
171 items_returned = 0;
172 guid_string_size = 39;
173 while (items_returned < buffersize)
174 {
175 ret = RegEnumKeyExW(subkey, items_returned, guid_string,
176 &guid_string_size, NULL, NULL, NULL, NULL);
177
178 if (ret != ERROR_SUCCESS)
179 {
181 break;
182 }
183
184 if (guid_string_size != 38)
185 {
186 hr = E_FAIL;
187 break;
188 }
189
190 hr = CLSIDFromString(guid_string, &buffer[items_returned]);
191 if (FAILED(hr))
192 break;
193
194 items_returned++;
195 guid_string_size = 39;
196 }
197
199 hr = S_OK;
200
201 *actual_size = items_returned;
202 }
203 else
204 {
205 ret = RegQueryInfoKeyW(subkey, NULL, NULL, NULL, actual_size, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
206 if (ret != ERROR_SUCCESS)
208 }
209
210 RegCloseKey(subkey);
211
212 return hr;
213}
#define E_FAIL
Definition: ddrawi.h:102
#define ERROR_SUCCESS
Definition: deptool.c:10
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
LONG WINAPI RegEnumKeyExW(_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPWSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPWSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)
Definition: reg.c:2504
LONG WINAPI RegQueryInfoKeyW(HKEY hKey, LPWSTR lpClass, LPDWORD lpcClass, LPDWORD lpReserved, LPDWORD lpcSubKeys, LPDWORD lpcMaxSubKeyLen, LPDWORD lpcMaxClassLen, LPDWORD lpcValues, LPDWORD lpcMaxValueNameLen, LPDWORD lpcMaxValueLen, LPDWORD lpcbSecurityDescriptor, PFILETIME lpftLastWriteTime)
Definition: reg.c:3662
#define ERROR_NO_MORE_ITEMS
Definition: compat.h:105
HRESULT WINAPI CLSIDFromString(LPCOLESTR idstr, LPCLSID id)
Definition: compobj.c:2338
GLuint buffer
Definition: glext.h:5915
#define KEY_READ
Definition: nt_native.h:1023
__wchar_t WCHAR
Definition: xmlstorage.h:180

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.

101{
102 LONG ret;
103 WCHAR guid_string[39];
104 DWORD cbdata = sizeof(guid_string);
105 HRESULT hr;
106
107 if (!result)
108 return E_INVALIDARG;
109
111 guid_string, &cbdata);
112
113 if (ret != ERROR_SUCCESS)
114 return HRESULT_FROM_WIN32(ret);
115
116 if (cbdata < sizeof(guid_string))
117 {
118 ERR("incomplete GUID value\n");
119 return E_FAIL;
120 }
121
122 hr = CLSIDFromString(guid_string, result);
123
124 return hr;
125}
#define ERR(fmt,...)
Definition: debug.h:113
#define RRF_NOEXPAND
Definition: driver.c:583
#define RRF_RT_REG_SZ
Definition: driver.c:575

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.

70{
71 LONG ret;
72 DWORD cbdata=buffer_size * sizeof(WCHAR);
73
74 if (!actual_size)
75 return E_INVALIDARG;
76
78 buffer, &cbdata);
79
81 {
82 *actual_size = 0;
83 return S_OK;
84 }
85
86 if (ret == 0 || ret == ERROR_MORE_DATA)
87 *actual_size = cbdata/sizeof(WCHAR);
88
89 if (!buffer && buffer_size != 0)
90 /* Yes, native returns the correct size in this case. */
91 return E_INVALIDARG;
92
93 if (ret == ERROR_MORE_DATA)
95
96 return HRESULT_FROM_WIN32(ret);
97}
#define ERROR_MORE_DATA
Definition: dderror.h:13
static void buffer_size(GLcontext *ctx, GLuint *width, GLuint *height)
Definition: swimpl.c:888

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.

1160{
1161 LONG res;
1163 HKEY formats_key, guid_key;
1164
1165 /* Avoid testing using IWICFormatConverter_GetPixelFormats because that
1166 would be O(n). A registry test should do better. */
1167
1168 res = RegOpenKeyExW(This->classkey, pixelformats_keyname, 0, KEY_READ, &formats_key);
1169 if (res != ERROR_SUCCESS) return FALSE;
1170
1171 res = RegOpenKeyExW(formats_key, formatguid, 0, KEY_READ, &guid_key);
1172 if (res == ERROR_SUCCESS) RegCloseKey(guid_key);
1173
1174 RegCloseKey(formats_key);
1175
1176 return (res == ERROR_SUCCESS);
1177}
static FormatConverterInfo * impl_from_IWICFormatConverterInfo(IWICFormatConverterInfo *iface)
Definition: info.c:1006
static const WCHAR pixelformats_keyname[]
Definition: info.c:44
GLuint res
Definition: glext.h:9613

Referenced by WICConvertBitmapSource().

◆ CreateComponentEnumerator()

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

Definition at line 2380 of file info.c.

2381{
2384 const struct category *category;
2385 HKEY clsidkey, catidkey, instancekey;
2386 WCHAR guidstring[39];
2387 LONG res;
2388 int i;
2389 HRESULT hr=S_OK;
2390 CLSID clsid;
2391
2392 if (options) FIXME("ignoring flags %x\n", options);
2393
2395 if (res != ERROR_SUCCESS)
2396 return HRESULT_FROM_WIN32(res);
2397
2398 This = HeapAlloc(GetProcessHeap(), 0, sizeof(ComponentEnum));
2399 if (!This)
2400 {
2401 RegCloseKey(clsidkey);
2402 return E_OUTOFMEMORY;
2403 }
2404
2405 This->IEnumUnknown_iface.lpVtbl = &ComponentEnumVtbl;
2406 This->ref = 1;
2407 list_init(&This->objects);
2409 This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": ComponentEnum.lock");
2410
2412 {
2413 if ((category->type & componentTypes) == 0) continue;
2414 StringFromGUID2(category->catid, guidstring, 39);
2415 res = RegOpenKeyExW(clsidkey, guidstring, 0, KEY_READ, &catidkey);
2416 if (res == ERROR_SUCCESS)
2417 {
2418 res = RegOpenKeyExW(catidkey, instance_keyname, 0, KEY_READ, &instancekey);
2419 if (res == ERROR_SUCCESS)
2420 {
2421 i=0;
2422 for (;;i++)
2423 {
2424 DWORD guidstring_size = 39;
2425 res = RegEnumKeyExW(instancekey, i, guidstring, &guidstring_size, NULL, NULL, NULL, NULL);
2426 if (res != ERROR_SUCCESS) break;
2427
2429 if (!item) { hr = E_OUTOFMEMORY; break; }
2430
2431 hr = CLSIDFromString(guidstring, &clsid);
2432 if (SUCCEEDED(hr))
2433 {
2435 if (SUCCEEDED(hr))
2436 list_add_tail(&This->objects, &item->entry);
2437 }
2438
2439 if (FAILED(hr))
2440 {
2442 hr = S_OK;
2443 }
2444 }
2445 RegCloseKey(instancekey);
2446 }
2447 RegCloseKey(catidkey);
2448 }
2451 }
2452 RegCloseKey(clsidkey);
2453
2454 if (SUCCEEDED(hr))
2455 {
2456 IEnumUnknown_Reset(&This->IEnumUnknown_iface);
2457 *ppIEnumUnknown = &This->IEnumUnknown_iface;
2458 }
2459 else
2460 {
2461 *ppIEnumUnknown = NULL;
2462 IEnumUnknown_Release(&This->IEnumUnknown_iface);
2463 }
2464
2465 return hr;
2466}
INT WINAPI StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax)
Definition: compobj.c:2434
static const WCHAR instance_keyname[]
Definition: info.c:2041
HRESULT CreateComponentInfo(REFCLSID clsid, IWICComponentInfo **ppIInfo)
Definition: info.c:2075
static const WCHAR clsid_keyname[]
Definition: info.c:2040
GLsizei GLenum * categories
Definition: glext.h:11561
#define SUCCEEDED(hr)
Definition: intsafe.h:50
WICComponentType type
Definition: info.c:2044
const GUID * catid
Definition: info.c:2045
#define HKEY_CLASSES_ROOT
Definition: winreg.h:10

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.

2076{
2077 struct wine_rb_entry *cache_entry;
2079 HKEY clsidkey;
2080 HKEY classkey;
2081 HKEY catidkey;
2082 HKEY instancekey;
2083 WCHAR guidstring[39];
2084 LONG res;
2085 const struct category *category;
2086 BOOL found = FALSE;
2087 HRESULT hr;
2088
2090
2092 if(cache_entry)
2093 {
2095 IWICComponentInfo_AddRef(*ppIInfo = &info->IWICComponentInfo_iface);
2097 return S_OK;
2098 }
2099
2101 if (res != ERROR_SUCCESS)
2102 {
2104 return HRESULT_FROM_WIN32(res);
2105 }
2106
2108 {
2109 StringFromGUID2(category->catid, guidstring, 39);
2110 res = RegOpenKeyExW(clsidkey, guidstring, 0, KEY_READ, &catidkey);
2111 if (res == ERROR_SUCCESS)
2112 {
2113 res = RegOpenKeyExW(catidkey, instance_keyname, 0, KEY_READ, &instancekey);
2114 if (res == ERROR_SUCCESS)
2115 {
2116 StringFromGUID2(clsid, guidstring, 39);
2117 res = RegOpenKeyExW(instancekey, guidstring, 0, KEY_READ, &classkey);
2118 if (res == ERROR_SUCCESS)
2119 {
2120 RegCloseKey(classkey);
2121 found = TRUE;
2122 }
2123 RegCloseKey(instancekey);
2124 }
2125 RegCloseKey(catidkey);
2126 }
2127 if (found) break;
2128 }
2129
2130 if (found)
2131 {
2132 res = RegOpenKeyExW(clsidkey, guidstring, 0, KEY_READ, &classkey);
2133 if (res == ERROR_SUCCESS)
2134 hr = category->constructor(classkey, clsid, &info);
2135 else
2137 }
2138 else
2139 {
2140 FIXME("%s is not supported\n", wine_dbgstr_guid(clsid));
2141 hr = E_FAIL;
2142 }
2143
2144 RegCloseKey(clsidkey);
2145
2146 if (SUCCEEDED(hr))
2147 {
2149 IWICComponentInfo_AddRef(*ppIInfo = &info->IWICComponentInfo_iface);
2150 }
2152 return hr;
2153}
static struct wine_rb_tree component_info_cache
Definition: info.c:2064
static CRITICAL_SECTION component_info_cache_cs
Definition: info.c:2066
unsigned int BOOL
Definition: ntddk_ex.h:94
static __inline const char * wine_dbgstr_guid(const GUID *id)
Definition: debug.h:197
static struct wine_rb_entry * wine_rb_get(const struct wine_rb_tree *tree, const void *key)
Definition: rbtree.h:203
static int wine_rb_put(struct wine_rb_tree *tree, const void *key, struct wine_rb_entry *entry)
Definition: rbtree.h:215
Definition: svc_auth_des.c:77
HRESULT(* constructor)(HKEY, REFCLSID, ComponentInfo **)
Definition: info.c:2046
Definition: rbtree.h:36

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.

1036{
1038 ULONG ref = InterlockedIncrement(&This->base.ref);
1039
1040 TRACE("(%p) refcount=%u\n", iface, ref);
1041
1042 return ref;
1043}

◆ FormatConverterInfo_Constructor()

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

Definition at line 1195 of file info.c.

1196{
1198
1200 if (!This)
1201 {
1202 RegCloseKey(classkey);
1203 return E_OUTOFMEMORY;
1204 }
1205
1206 This->base.IWICComponentInfo_iface.lpVtbl = (const IWICComponentInfoVtbl*)&FormatConverterInfo_Vtbl;
1207 This->base.ref = 1;
1208 This->classkey = classkey;
1209 This->base.clsid = *clsid;
1210
1211 *ret = &This->base;
1212 return S_OK;
1213}
static const IWICFormatConverterInfoVtbl FormatConverterInfo_Vtbl
Definition: info.c:1179

◆ FormatConverterInfo_CreateInstance()

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

Definition at line 1148 of file info.c.

1150{
1152
1153 TRACE("(%p,%p)\n", iface, ppIFormatConverter);
1154
1155 return create_instance(&This->base.clsid, &IID_IWICFormatConverter,
1156 (void**)ppIFormatConverter);
1157}

◆ FormatConverterInfo_GetAuthor()

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

Definition at line 1088 of file info.c.

1090{
1092
1093 TRACE("(%p,%u,%p,%p)\n", iface, cchAuthor, wzAuthor, pcchActual);
1094
1096 cchAuthor, wzAuthor, pcchActual);
1097}

◆ FormatConverterInfo_GetCLSID()

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

Definition at line 1070 of file info.c.

1071{
1073 TRACE("(%p,%p)\n", iface, pclsid);
1074
1075 if (!pclsid)
1076 return E_INVALIDARG;
1077
1078 *pclsid = This->base.clsid;
1079 return S_OK;
1080}

◆ FormatConverterInfo_GetComponentType()

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

Definition at line 1061 of file info.c.

1063{
1064 TRACE("(%p,%p)\n", iface, pType);
1065 if (!pType) return E_INVALIDARG;
1066 *pType = WICPixelFormatConverter;
1067 return S_OK;
1068}
@ WICPixelFormatConverter
Definition: wincodec.idl:127

◆ FormatConverterInfo_GetFriendlyName()

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

Definition at line 1130 of file info.c.

1132{
1134
1135 TRACE("(%p,%u,%p,%p)\n", iface, cchFriendlyName, wzFriendlyName, pcchActual);
1136
1138 cchFriendlyName, wzFriendlyName, pcchActual);
1139}

◆ FormatConverterInfo_GetPixelFormats()

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

Definition at line 1141 of file info.c.

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

◆ FormatConverterInfo_GetSigningStatus()

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

Definition at line 1082 of file info.c.

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

◆ FormatConverterInfo_GetSpecVersion()

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

Definition at line 1119 of file info.c.

1121{
1123
1124 TRACE("(%p,%u,%p,%p)\n", iface, cchSpecVersion, wzSpecVersion, pcchActual);
1125
1127 cchSpecVersion, wzSpecVersion, pcchActual);
1128}

◆ FormatConverterInfo_GetVendorGUID()

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

Definition at line 1099 of file info.c.

1100{
1102
1103 TRACE("(%p,%p)\n", iface, pguidVendor);
1104
1105 return ComponentInfo_GetGUIDValue(This->classkey, vendor_valuename, pguidVendor);
1106}

◆ FormatConverterInfo_GetVersion()

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

Definition at line 1108 of file info.c.

1110{
1112
1113 TRACE("(%p,%u,%p,%p)\n", iface, cchVersion, wzVersion, pcchActual);
1114
1116 cchVersion, wzVersion, pcchActual);
1117}

◆ FormatConverterInfo_QueryInterface()

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

Definition at line 1011 of file info.c.

1013{
1015 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
1016
1017 if (!ppv) return E_INVALIDARG;
1018
1019 if (IsEqualIID(&IID_IUnknown, iid) ||
1020 IsEqualIID(&IID_IWICComponentInfo, iid) ||
1021 IsEqualIID(&IID_IWICFormatConverterInfo ,iid))
1022 {
1023 *ppv = &This->base.IWICComponentInfo_iface;
1024 }
1025 else
1026 {
1027 *ppv = NULL;
1028 return E_NOINTERFACE;
1029 }
1030
1031 IUnknown_AddRef((IUnknown*)*ppv);
1032 return S_OK;
1033}

◆ FormatConverterInfo_Release()

static ULONG WINAPI FormatConverterInfo_Release ( IWICFormatConverterInfo iface)
static

Definition at line 1045 of file info.c.

1046{
1048 ULONG ref = InterlockedDecrement(&This->base.ref);
1049
1050 TRACE("(%p) refcount=%u\n", iface, ref);
1051
1052 if (ref == 0)
1053 {
1054 RegCloseKey(This->classkey);
1056 }
1057
1058 return ref;
1059}

◆ get_decoder_info()

HRESULT get_decoder_info ( REFCLSID  clsid,
IWICBitmapDecoderInfo **  info 
)

Definition at line 2162 of file info.c.

2163{
2164 IWICComponentInfo *compinfo;
2165 HRESULT hr;
2166
2167 hr = CreateComponentInfo(clsid, &compinfo);
2168 if (FAILED(hr)) return hr;
2169
2170 hr = IWICComponentInfo_QueryInterface(compinfo, &IID_IWICBitmapDecoderInfo,
2171 (void **)info);
2172
2173 IWICComponentInfo_Release(compinfo);
2174
2175 return hr;
2176}

◆ get_metadata_container()

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

Definition at line 1521 of file info.c.

1522{
1523 unsigned i;
1524
1525 for (i = 0; i < info->container_count; i++)
1526 if (IsEqualGUID(info->container_formats + i, guid))
1527 return info->containers + i;
1528
1529 return NULL;
1530}
const GUID * guid
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147

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.

2187{
2188 return CONTAINING_RECORD(iface, ComponentEnum, IEnumUnknown_iface);
2189}
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

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

◆ impl_from_IWICBitmapDecoderInfo()

◆ impl_from_IWICBitmapEncoderInfo()

◆ impl_from_IWICFormatConverterInfo()

◆ impl_from_IWICMetadataReaderInfo()

◆ impl_from_IWICPixelFormatInfo2()

◆ is_1bpp_format()

static BOOL is_1bpp_format ( const WICPixelFormatGUID format)
static

Definition at line 2468 of file info.c.

2469{
2470 return IsEqualGUID(format, &GUID_WICPixelFormatBlackWhite) ||
2471 IsEqualGUID(format, &GUID_WICPixelFormat1bppIndexed);
2472}
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546

Referenced by WICConvertBitmapSource().

◆ MetadataReaderInfo_AddRef()

static ULONG WINAPI MetadataReaderInfo_AddRef ( IWICMetadataReaderInfo iface)
static

Definition at line 1563 of file info.c.

1564{
1566 ULONG ref = InterlockedIncrement(&This->base.ref);
1567
1568 TRACE("(%p) refcount=%u\n", iface, ref);
1569 return ref;
1570}
static MetadataReaderInfo * impl_from_IWICMetadataReaderInfo(IWICMetadataReaderInfo *iface)
Definition: info.c:1532

◆ MetadataReaderInfo_Constructor()

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

Definition at line 2014 of file info.c.

2015{
2017
2018 This = heap_alloc_zero(sizeof(*This));
2019 if (!This)
2020 {
2021 RegCloseKey(classkey);
2022 return E_OUTOFMEMORY;
2023 }
2024
2025 This->base.IWICComponentInfo_iface.lpVtbl = (const IWICComponentInfoVtbl*)&MetadataReaderInfo_Vtbl;
2026 This->base.ref = 1;
2027 This->classkey = classkey;
2028 This->base.clsid = *clsid;
2029
2031 {
2032 IWICComponentInfo_Release(&This->base.IWICComponentInfo_iface);
2034 }
2035
2036 *info = &This->base;
2037 return S_OK;
2038}
static BOOL read_metadata_info(MetadataReaderInfo *info)
Definition: info.c:1977
static const IWICMetadataReaderInfoVtbl MetadataReaderInfo_Vtbl
Definition: info.c:1839
#define WINCODEC_ERR_COMPONENTNOTFOUND
Definition: winerror.h:3296

◆ MetadataReaderInfo_CreateInstance()

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

Definition at line 1829 of file info.c.

1831{
1833
1834 TRACE("(%p,%p)\n", iface, reader);
1835
1836 return create_instance(&This->base.clsid, &IID_IWICMetadataReader, (void **)reader);
1837}
Definition: reader.h:84

◆ MetadataReaderInfo_DoesRequireFixedSize()

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

Definition at line 1733 of file info.c.

1735{
1736 FIXME("(%p,%p): stub\n", iface, param);
1737 return E_NOTIMPL;
1738}
GLfloat param
Definition: glext.h:5796

◆ MetadataReaderInfo_DoesRequireFullStream()

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

Definition at line 1717 of file info.c.

1719{
1721 TRACE("(%p,%p)\n", iface, param);
1723}
static HRESULT ComponentInfo_GetDWORDValue(HKEY classkey, LPCWSTR value, DWORD *result)
Definition: info.c:127
static const WCHAR requiresfullstream_valuename[]
Definition: info.c:56

◆ MetadataReaderInfo_DoesSupportPadding()

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

Definition at line 1725 of file info.c.

1727{
1729 TRACE("(%p,%p)\n", iface, param);
1731}
static const WCHAR supportspadding_valuename[]
Definition: info.c:57

◆ 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.

1623{
1625
1626 TRACE("(%p,%u,%p,%p)\n", iface, length, author, actual_length);
1627
1629 length, author, actual_length);
1630}
GLuint GLsizei GLsizei * length
Definition: glext.h:6040

◆ MetadataReaderInfo_GetCLSID()

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

Definition at line 1602 of file info.c.

1604{
1606
1607 TRACE("(%p,%p)\n", iface, clsid);
1608
1609 if (!clsid) return E_INVALIDARG;
1610 *clsid = This->base.clsid;
1611 return S_OK;
1612}

◆ MetadataReaderInfo_GetComponentType()

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

Definition at line 1592 of file info.c.

1594{
1595 TRACE("(%p,%p)\n", iface, type);
1596
1597 if (!type) return E_INVALIDARG;
1599 return S_OK;
1600}
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
@ WICMetadataReader
Definition: wincodec.idl:128

◆ 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.

1685{
1687
1688 TRACE("(%p,%u,%p,%p)\n", iface, length, formats, actual_length);
1689
1690 if (!actual_length)
1691 return E_INVALIDARG;
1692
1693 *actual_length = This->container_count;
1694 if (formats)
1695 {
1696 if (This->container_count && length < This->container_count)
1698 memcpy(formats, This->container_formats, This->container_count);
1699 }
1700 return S_OK;
1701}
static const struct pixel_format_desc formats[]
Definition: util.c:59

◆ 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.

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

◆ 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.

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

◆ 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.

1666{
1668
1669 TRACE("(%p,%u,%p,%p)\n", iface, length, name, actual_length);
1670
1672 length, name, actual_length);
1673}
Definition: name.c:39

◆ MetadataReaderInfo_GetMetadataFormat()

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

Definition at line 1675 of file info.c.

1677{
1679 TRACE("(%p,%p)\n", iface, format);
1681}
static const WCHAR metadataformat_valuename[]
Definition: info.c:47

◆ 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.

1742{
1745
1746 TRACE("(%p,%s,%u,%p,%p,%p)\n", iface, debugstr_guid(container_guid), length, patterns, count, actual_length);
1747
1748 if (!actual_length || !container_guid) return E_INVALIDARG;
1749
1750 if (!(container = get_metadata_container(This, container_guid)))
1752
1753 *count = container->pattern_count;
1754 *actual_length = container->patterns_size;
1755 if (patterns)
1756 {
1757 if (container->patterns_size && length < container->patterns_size)
1759 memcpy(patterns, container->patterns, container->patterns_size);
1760 }
1761 return S_OK;
1762}
static struct metadata_container * get_metadata_container(MetadataReaderInfo *info, const GUID *guid)
Definition: info.c:1521
GLuint GLuint GLsizei count
Definition: gl.h:1545
UINT patterns_size
Definition: info.c:1509
WICMetadataPattern * patterns
Definition: info.c:1507

◆ MetadataReaderInfo_GetSigningStatus()

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

Definition at line 1614 of file info.c.

1616{
1617 FIXME("(%p,%p): stub\n", iface, status);
1618 return E_NOTIMPL;
1619}
Definition: ps.c:97

◆ 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.

1655{
1657
1658 TRACE("(%p,%u,%p,%p)\n", iface, length, version, actual_length);
1659
1661 length, version, actual_length);
1662}
static const WCHAR version[]
Definition: asmname.c:66

◆ MetadataReaderInfo_GetVendorGUID()

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

Definition at line 1632 of file info.c.

1634{
1636
1637 TRACE("(%p,%p)\n", iface, vendor);
1638
1640}
const WCHAR * vendor
Definition: db.cpp:872

◆ 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.

1644{
1646
1647 TRACE("(%p,%u,%p,%p)\n", iface, length, version, actual_length);
1648
1650 length, version, actual_length);
1651}

◆ 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.

1766{
1769 HRESULT hr;
1770 ULONG datasize=0;
1771 BYTE *data=NULL;
1772 ULONG bytesread;
1773 UINT i;
1774 LARGE_INTEGER seekpos;
1775 ULONG pos;
1776
1777 TRACE("(%p,%s,%p,%p)\n", iface, debugstr_guid(container_guid), stream, matches);
1778
1779 if (!(container = get_metadata_container(This, container_guid)))
1781
1782 for (i=0; i < container->pattern_count; i++)
1783 {
1784 if (datasize < container->patterns[i].Length)
1785 {
1787 datasize = container->patterns[i].Length;
1788 data = HeapAlloc(GetProcessHeap(), 0, container->patterns[i].Length);
1789 if (!data)
1790 {
1791 hr = E_OUTOFMEMORY;
1792 break;
1793 }
1794 }
1795
1796 seekpos.QuadPart = container->patterns[i].Position.QuadPart;
1797 hr = IStream_Seek(stream, seekpos, STREAM_SEEK_SET, NULL);
1798 if (FAILED(hr)) break;
1799
1800 hr = IStream_Read(stream, data, container->patterns[i].Length, &bytesread);
1801 if (hr == S_FALSE || (hr == S_OK && bytesread != container->patterns[i].Length)) /* past end of stream */
1802 continue;
1803 if (FAILED(hr)) break;
1804
1805 for (pos=0; pos < container->patterns[i].Length; pos++)
1806 {
1807 if ((data[pos] & container->patterns[i].Mask[pos]) != container->patterns[i].Pattern[pos])
1808 break;
1809 }
1810 if (pos == container->patterns[i].Length) /* matches pattern */
1811 {
1812 hr = S_OK;
1813 *matches = TRUE;
1814 break;
1815 }
1816 }
1817
1818 if (i == container->pattern_count) /* does not match any pattern */
1819 {
1820 hr = S_OK;
1821 *matches = FALSE;
1822 }
1823
1825
1826 return hr;
1827}
#define matches(FN)
Definition: match.h:70
Definition: parse.h:23

◆ MetadataReaderInfo_QueryInterface()

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

Definition at line 1537 of file info.c.

1539{
1541
1542 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(riid), ppv);
1543
1544 if (!ppv) return E_INVALIDARG;
1545
1546 if (IsEqualIID(&IID_IUnknown, riid) ||
1547 IsEqualIID(&IID_IWICComponentInfo, riid) ||
1548 IsEqualIID(&IID_IWICMetadataHandlerInfo, riid) ||
1549 IsEqualIID(&IID_IWICMetadataReaderInfo, riid))
1550 {
1551 *ppv = &This->base.IWICComponentInfo_iface;
1552 }
1553 else
1554 {
1555 *ppv = NULL;
1556 return E_NOINTERFACE;
1557 }
1558
1559 IUnknown_AddRef((IUnknown *)*ppv);
1560 return S_OK;
1561}
REFIID riid
Definition: atlbase.h:39

◆ MetadataReaderInfo_Release()

static ULONG WINAPI MetadataReaderInfo_Release ( IWICMetadataReaderInfo iface)
static

Definition at line 1572 of file info.c.

1573{
1575 ULONG ref = InterlockedDecrement(&This->base.ref);
1576
1577 TRACE("(%p) refcount=%u\n", iface, ref);
1578
1579 if (!ref)
1580 {
1581 unsigned i;
1582 RegCloseKey(This->classkey);
1583 for (i = 0; i < This->container_count; i++)
1584 heap_free(This->containers[i].patterns);
1585 heap_free(This->containers);
1586 heap_free(This->container_formats);
1588 }
1589 return ref;
1590}

◆ PixelFormatInfo_AddRef()

static ULONG WINAPI PixelFormatInfo_AddRef ( IWICPixelFormatInfo2 iface)
static

Definition at line 1250 of file info.c.

1251{
1253 ULONG ref = InterlockedIncrement(&This->base.ref);
1254
1255 TRACE("(%p) refcount=%u\n", iface, ref);
1256
1257 return ref;
1258}
static PixelFormatInfo * impl_from_IWICPixelFormatInfo2(IWICPixelFormatInfo2 *iface)
Definition: info.c:1220

◆ PixelFormatInfo_Constructor()

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

Definition at line 1485 of file info.c.

1486{
1488
1490 if (!This)
1491 {
1492 RegCloseKey(classkey);
1493 return E_OUTOFMEMORY;
1494 }
1495
1496 This->base.IWICComponentInfo_iface.lpVtbl = (const IWICComponentInfoVtbl*)&PixelFormatInfo_Vtbl;
1497 This->base.ref = 1;
1498 This->classkey = classkey;
1499 This->base.clsid = *clsid;
1500
1501 *ret = &This->base;
1502 return S_OK;
1503}
static const IWICPixelFormatInfo2Vtbl PixelFormatInfo_Vtbl
Definition: info.c:1464

◆ PixelFormatInfo_GetAuthor()

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

Definition at line 1310 of file info.c.

1312{
1314
1315 TRACE("(%p,%u,%p,%p)\n", iface, cchAuthor, wzAuthor, pcchActual);
1316
1318 cchAuthor, wzAuthor, pcchActual);
1319}

◆ PixelFormatInfo_GetBitsPerPixel()

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

Definition at line 1383 of file info.c.

1385{
1387
1388 TRACE("(%p,%p)\n", iface, puiBitsPerPixel);
1389
1390 return ComponentInfo_GetDWORDValue(This->classkey, bitsperpixel_valuename, puiBitsPerPixel);
1391}
static const WCHAR bitsperpixel_valuename[]
Definition: info.c:51

◆ PixelFormatInfo_GetChannelCount()

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

Definition at line 1393 of file info.c.

1395{
1397
1398 TRACE("(%p,%p)\n", iface, puiChannelCount);
1399
1400 return ComponentInfo_GetDWORDValue(This->classkey, channelcount_valuename, puiChannelCount);
1401}
static const WCHAR channelcount_valuename[]
Definition: info.c:52

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.

1405{
1406 static const WCHAR uintformatW[] = {'%','u',0};
1408 UINT channel_count;
1409 HRESULT hr;
1410 LONG ret;
1411 WCHAR valuename[11];
1412 DWORD cbData;
1413
1414 TRACE("(%p,%u,%u,%p,%p)\n", iface, uiChannelIndex, cbMaskBuffer, pbMaskBuffer, pcbActual);
1415
1416 if (!pcbActual)
1417 return E_INVALIDARG;
1418
1419 hr = PixelFormatInfo_GetChannelCount(iface, &channel_count);
1420
1421 if (SUCCEEDED(hr) && uiChannelIndex >= channel_count)
1422 hr = E_INVALIDARG;
1423
1424 if (SUCCEEDED(hr))
1425 {
1426 snprintfW(valuename, 11, uintformatW, uiChannelIndex);
1427
1428 cbData = cbMaskBuffer;
1429
1430 ret = RegGetValueW(This->classkey, channelmasks_keyname, valuename, RRF_RT_REG_BINARY, NULL, pbMaskBuffer, &cbData);
1431
1432 if (ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA)
1433 *pcbActual = cbData;
1434
1435 if (ret == ERROR_MORE_DATA)
1436 hr = E_INVALIDARG;
1437 else
1439 }
1440
1441 return hr;
1442}
#define RRF_RT_REG_BINARY
Definition: driver.c:577
static HRESULT WINAPI PixelFormatInfo_GetChannelCount(IWICPixelFormatInfo2 *iface, UINT *puiChannelCount)
Definition: info.c:1393
static const WCHAR channelmasks_keyname[]
Definition: info.c:53
#define snprintfW
Definition: unicode.h:66

◆ PixelFormatInfo_GetCLSID()

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

Definition at line 1285 of file info.c.

1286{
1288 TRACE("(%p,%p)\n", iface, pclsid);
1289
1290 if (!pclsid)
1291 return E_INVALIDARG;
1292
1293 *pclsid = This->base.clsid;
1294 return S_OK;
1295}

◆ PixelFormatInfo_GetColorContext()

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

Definition at line 1376 of file info.c.

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

◆ PixelFormatInfo_GetComponentType()

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

Definition at line 1276 of file info.c.

1278{
1279 TRACE("(%p,%p)\n", iface, pType);
1280 if (!pType) return E_INVALIDARG;
1281 *pType = WICPixelFormat;
1282 return S_OK;
1283}
@ WICPixelFormat
Definition: wincodec.idl:130

◆ PixelFormatInfo_GetFormatGUID()

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

Definition at line 1363 of file info.c.

1365{
1367 TRACE("(%p,%p)\n", iface, pFormat);
1368
1369 if (!pFormat)
1370 return E_INVALIDARG;
1371
1372 *pFormat = This->base.clsid;
1373 return S_OK;
1374}

◆ PixelFormatInfo_GetFriendlyName()

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

Definition at line 1352 of file info.c.

1354{
1356
1357 TRACE("(%p,%u,%p,%p)\n", iface, cchFriendlyName, wzFriendlyName, pcchActual);
1358
1360 cchFriendlyName, wzFriendlyName, pcchActual);
1361}

◆ PixelFormatInfo_GetNumericRepresentation()

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

Definition at line 1454 of file info.c.

1456{
1458
1459 TRACE("(%p,%p)\n", iface, pNumericRepresentation);
1460
1461 return ComponentInfo_GetDWORDValue(This->classkey, numericrepresentation_valuename, pNumericRepresentation);
1462}
static const WCHAR numericrepresentation_valuename[]
Definition: info.c:54

◆ PixelFormatInfo_GetSigningStatus()

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

Definition at line 1297 of file info.c.

1298{
1299 TRACE("(%p,%p)\n", iface, pStatus);
1300
1301 if (!pStatus)
1302 return E_INVALIDARG;
1303
1304 /* Pixel formats don't require code, so they are considered signed. */
1306
1307 return S_OK;
1308}
@ WICComponentSigned
Definition: wincodec.idl:135

◆ PixelFormatInfo_GetSpecVersion()

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

Definition at line 1341 of file info.c.

1343{
1345
1346 TRACE("(%p,%u,%p,%p)\n", iface, cchSpecVersion, wzSpecVersion, pcchActual);
1347
1349 cchSpecVersion, wzSpecVersion, pcchActual);
1350}

◆ PixelFormatInfo_GetVendorGUID()

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

Definition at line 1321 of file info.c.

1322{
1324
1325 TRACE("(%p,%p)\n", iface, pguidVendor);
1326
1327 return ComponentInfo_GetGUIDValue(This->classkey, vendor_valuename, pguidVendor);
1328}

◆ PixelFormatInfo_GetVersion()

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

Definition at line 1330 of file info.c.

1332{
1334
1335 TRACE("(%p,%u,%p,%p)\n", iface, cchVersion, wzVersion, pcchActual);
1336
1338 cchVersion, wzVersion, pcchActual);
1339}

◆ PixelFormatInfo_QueryInterface()

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

Definition at line 1225 of file info.c.

1227{
1229 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
1230
1231 if (!ppv) return E_INVALIDARG;
1232
1233 if (IsEqualIID(&IID_IUnknown, iid) ||
1234 IsEqualIID(&IID_IWICComponentInfo, iid) ||
1235 IsEqualIID(&IID_IWICPixelFormatInfo, iid) ||
1236 IsEqualIID(&IID_IWICPixelFormatInfo2 ,iid))
1237 {
1238 *ppv = &This->base.IWICComponentInfo_iface;
1239 }
1240 else
1241 {
1242 *ppv = NULL;
1243 return E_NOINTERFACE;
1244 }
1245
1246 IUnknown_AddRef((IUnknown*)*ppv);
1247 return S_OK;
1248}

◆ PixelFormatInfo_Release()

static ULONG WINAPI PixelFormatInfo_Release ( IWICPixelFormatInfo2 iface)
static

Definition at line 1260 of file info.c.

1261{
1263 ULONG ref = InterlockedDecrement(&This->base.ref);
1264
1265 TRACE("(%p) refcount=%u\n", iface, ref);
1266
1267 if (ref == 0)
1268 {
1269 RegCloseKey(This->classkey);
1271 }
1272
1273 return ref;
1274}

◆ PixelFormatInfo_SupportsTransparency()

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

Definition at line 1444 of file info.c.

1446{
1448
1449 TRACE("(%p,%p)\n", iface, pfSupportsTransparency);
1450
1451 return ComponentInfo_GetDWORDValue(This->classkey, supportstransparency_valuename, (DWORD*)pfSupportsTransparency);
1452}
static const WCHAR supportstransparency_valuename[]
Definition: info.c:55

◆ read_bitmap_patterns()

static void read_bitmap_patterns ( BitmapDecoderInfo info)
static

Definition at line 577 of file info.c.

578{
579 UINT pattern_count=0, patterns_size=0;
580 WCHAR subkeyname[11];
581 LONG res;
582 HKEY patternskey, patternkey;
583 static const WCHAR uintformatW[] = {'%','u',0};
584 static const WCHAR patternsW[] = {'P','a','t','t','e','r','n','s',0};
585 static const WCHAR positionW[] = {'P','o','s','i','t','i','o','n',0};
586 static const WCHAR lengthW[] = {'L','e','n','g','t','h',0};
587 static const WCHAR patternW[] = {'P','a','t','t','e','r','n',0};
588 static const WCHAR maskW[] = {'M','a','s','k',0};
589 static const WCHAR endofstreamW[] = {'E','n','d','O','f','S','t','r','e','a','m',0};
590 UINT i;
591 WICBitmapPattern *patterns;
592 BYTE *patterns_ptr;
593 DWORD length, valuesize;
594
595 res = RegOpenKeyExW(info->classkey, patternsW, 0, KEY_READ, &patternskey);
596 if (res != ERROR_SUCCESS) return;
597
598 res = RegQueryInfoKeyW(patternskey, NULL, NULL, NULL, &pattern_count, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
599 if (res != ERROR_SUCCESS)
600 {
601 RegCloseKey(patternskey);
602 return;
603 }
604
605 patterns_size = pattern_count * sizeof(WICBitmapPattern);
606 patterns = heap_alloc(patterns_size);
607 if (!patterns)
608 {
609 RegCloseKey(patternskey);
610 return;
611 }
612
613 for (i=0; res == ERROR_SUCCESS && i < pattern_count; i++)
614 {
615 snprintfW(subkeyname, 11, uintformatW, i);
616 res = RegOpenKeyExW(patternskey, subkeyname, 0, KEY_READ, &patternkey);
617 if (res != ERROR_SUCCESS) break;
618
619 valuesize = sizeof(ULONG);
620 res = RegGetValueW(patternkey, NULL, lengthW, RRF_RT_DWORD, NULL, &length, &valuesize);
621 if (res == ERROR_SUCCESS)
622 {
623 patterns_size += length*2;
624 patterns[i].Length = length;
625
626 valuesize = sizeof(BOOL);
627 res = RegGetValueW(patternkey, NULL, endofstreamW, RRF_RT_DWORD, NULL,
628 &patterns[i].EndOfStream, &valuesize);
629 if (res) patterns[i].EndOfStream = 0;
630
631 patterns[i].Position.QuadPart = 0;
632 valuesize = sizeof(ULARGE_INTEGER);
633 res = RegGetValueW(patternkey, NULL, positionW, RRF_RT_DWORD|RRF_RT_QWORD, NULL,
634 &patterns[i].Position, &valuesize);
635 }
636
637 RegCloseKey(patternkey);
638 }
639
640 if (res != ERROR_SUCCESS || !(patterns_ptr = heap_realloc(patterns, patterns_size)))
641 {
642 heap_free(patterns);
643 RegCloseKey(patternskey);
644 return;
645 }
646 patterns = (WICBitmapPattern*)patterns_ptr;
647 patterns_ptr += pattern_count * sizeof(*patterns);
648
649 for (i=0; res == ERROR_SUCCESS && i < pattern_count; i++)
650 {
651 snprintfW(subkeyname, 11, uintformatW, i);
652 res = RegOpenKeyExW(patternskey, subkeyname, 0, KEY_READ, &patternkey);
653 if (res != ERROR_SUCCESS) break;
654
655 length = patterns[i].Length;
656 patterns[i].Pattern = patterns_ptr;
657 valuesize = length;
658 res = RegGetValueW(patternkey, NULL, patternW, RRF_RT_REG_BINARY, NULL,
659 patterns[i].Pattern, &valuesize);
660 patterns_ptr += length;
661
662 if (res == ERROR_SUCCESS)
663 {
664 patterns[i].Mask = patterns_ptr;
665 valuesize = length;
666 res = RegGetValueW(patternkey, NULL, maskW, RRF_RT_REG_BINARY, NULL,
667 patterns[i].Mask, &valuesize);
668 patterns_ptr += length;
669 }
670
671 RegCloseKey(patternkey);
672 }
673
674 RegCloseKey(patternskey);
675
676 if (res != ERROR_SUCCESS)
677 {
678 heap_free(patterns);
679 return;
680 }
681
682 info->pattern_count = pattern_count;
683 info->patterns_size = patterns_size;
684 info->patterns = patterns;
685}
static void * heap_alloc(size_t len)
Definition: appwiz.h:66
static void * heap_realloc(void *mem, size_t len)
Definition: appwiz.h:71
static const WCHAR lengthW[]
Definition: array.c:39
#define RRF_RT_QWORD
Definition: driver.c:582
unsigned int Mask
Definition: fpcontrol.c:82
struct _ULARGE_INTEGER ULARGE_INTEGER
#define BOOL
Definition: nt_native.h:43
static COORD Position
Definition: mouse.c:34

Referenced by BitmapDecoderInfo_Constructor().

◆ read_metadata_info()

static BOOL read_metadata_info ( MetadataReaderInfo info)
static

Definition at line 1977 of file info.c.

1978{
1979 UINT format_count;
1980 GUID *formats;
1981 HRESULT hr;
1982
1983 hr = ComponentInfo_GetGuidList(info->classkey, containers_keyname, 0, NULL, &format_count);
1984 if (FAILED(hr)) return TRUE;
1985
1986 formats = heap_calloc(format_count, sizeof(*formats));
1987 if (!formats) return FALSE;
1988
1989 hr = ComponentInfo_GetGuidList(info->classkey, containers_keyname, format_count, formats,
1990 &format_count);
1991 if (FAILED(hr))
1992 {
1994 return FALSE;
1995 }
1996
1997 info->container_formats = formats;
1998 info->container_count = format_count;
1999
2000 if (format_count)
2001 {
2002 unsigned i;
2003
2004 info->containers = heap_calloc(format_count, sizeof(*info->containers));
2005 if (!info->containers) return FALSE;
2006
2007 for (i = 0; i < format_count; i++)
2008 read_metadata_patterns(info, info->container_formats + i, info->containers + i);
2009 }
2010
2011 return TRUE;
2012}
static void read_metadata_patterns(MetadataReaderInfo *info, GUID *container_guid, struct metadata_container *container)
Definition: info.c:1863
static const WCHAR containers_keyname[]
Definition: info.c:59
static void * heap_calloc(SIZE_T count, SIZE_T size)
Definition: heap.h:49

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.

1865{
1866 UINT pattern_count=0, patterns_size=0;
1867 WCHAR subkeyname[11], guidkeyname[39];
1868 LONG res;
1869 HKEY containers_key, guid_key, patternkey;
1870 static const WCHAR uintformatW[] = {'%','u',0};
1871 static const WCHAR patternW[] = {'P','a','t','t','e','r','n',0};
1872 static const WCHAR positionW[] = {'P','o','s','i','t','i','o','n',0};
1873 static const WCHAR maskW[] = {'M','a','s','k',0};
1874 static const WCHAR dataoffsetW[] = {'D','a','t','a','O','f','f','s','e','t',0};
1875 UINT i;
1876 WICMetadataPattern *patterns;
1877 BYTE *patterns_ptr;
1878 DWORD length, valuesize;
1879
1880 res = RegOpenKeyExW(info->classkey, containers_keyname, 0, KEY_READ, &containers_key);
1881 if (res != ERROR_SUCCESS) return;
1882
1883 StringFromGUID2(container_guid, guidkeyname, 39);
1884 res = RegOpenKeyExW(containers_key, guidkeyname, 0, KEY_READ, &guid_key);
1885 RegCloseKey(containers_key);
1886 if (res != ERROR_SUCCESS) return;
1887
1888 res = RegQueryInfoKeyW(guid_key, NULL, NULL, NULL, &pattern_count,
1889 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1890 if (res != ERROR_SUCCESS)
1891 {
1892 RegCloseKey(guid_key);
1893 return;
1894 }
1895
1896 patterns_size = pattern_count * sizeof(WICMetadataPattern);
1897 patterns = heap_alloc(patterns_size);
1898 if (!patterns)
1899 {
1900 RegCloseKey(guid_key);
1901 return;
1902 }
1903
1904 for (i=0; res == ERROR_SUCCESS && i < pattern_count; i++)
1905 {
1906 snprintfW(subkeyname, 11, uintformatW, i);
1907 res = RegOpenKeyExW(guid_key, subkeyname, 0, KEY_READ, &patternkey);
1908 if (res != ERROR_SUCCESS) break;
1909
1910 res = RegGetValueW(patternkey, NULL, patternW, RRF_RT_REG_BINARY, NULL, NULL, &length);
1911 if (res == ERROR_SUCCESS)
1912 {
1913 patterns_size += length*2;
1914 patterns[i].Length = length;
1915
1916 valuesize = sizeof(DWORD64);
1917 res = RegGetValueW(patternkey, NULL, dataoffsetW, RRF_RT_DWORD|RRF_RT_QWORD, NULL,
1918 &patterns[i].DataOffset, &valuesize);
1919 if (res) patterns[i].DataOffset.QuadPart = 0;
1920
1921 patterns[i].Position.QuadPart = 0;
1922 valuesize = sizeof(DWORD64);
1923 res = RegGetValueW(patternkey, NULL, positionW, RRF_RT_DWORD|RRF_RT_QWORD, NULL,
1924 &patterns[i].Position, &valuesize);
1925 }
1926
1927 RegCloseKey(patternkey);
1928 }
1929
1930 if (res != ERROR_SUCCESS || !(patterns_ptr = heap_realloc(patterns, patterns_size)))
1931 {
1932 heap_free(patterns);
1933 RegCloseKey(guid_key);
1934 return;
1935 }
1936 patterns = (WICMetadataPattern*)patterns_ptr;
1937 patterns_ptr += pattern_count * sizeof(*patterns);
1938
1939 for (i=0; res == ERROR_SUCCESS && i < pattern_count; i++)
1940 {
1941 snprintfW(subkeyname, 11, uintformatW, i);
1942 res = RegOpenKeyExW(guid_key, subkeyname, 0, KEY_READ, &patternkey);
1943 if (res != ERROR_SUCCESS) break;
1944
1945 length = patterns[i].Length;
1946 patterns[i].Pattern = patterns_ptr;
1947 valuesize = length;
1948 res = RegGetValueW(patternkey, NULL, patternW, RRF_RT_REG_BINARY, NULL,
1949 patterns[i].Pattern, &valuesize);
1950 patterns_ptr += length;
1951
1952 if (res == ERROR_SUCCESS)
1953 {
1954 patterns[i].Mask = patterns_ptr;
1955 valuesize = length;
1956 res = RegGetValueW(patternkey, NULL, maskW, RRF_RT_REG_BINARY, NULL,
1957 patterns[i].Mask, &valuesize);
1958 patterns_ptr += length;
1959 }
1960
1961 RegCloseKey(patternkey);
1962 }
1963
1964 RegCloseKey(guid_key);
1965
1966 if (res != ERROR_SUCCESS)
1967 {
1968 heap_free(patterns);
1969 return;
1970 }
1971
1972 container->pattern_count = pattern_count;
1973 container->patterns_size = patterns_size;
1974 container->patterns = patterns;
1975}
uint64_t DWORD64
Definition: typedefs.h:67

Referenced by read_metadata_info().

◆ ReleaseComponentInfos()

void ReleaseComponentInfos ( void  )

Definition at line 2155 of file info.c.

2156{
2157 ComponentInfo *info, *next_info;
2159 IWICComponentInfo_Release(&info->IWICComponentInfo_iface);
2160}
#define WINE_RB_FOR_EACH_ENTRY_DESTRUCTOR(elem, elem2, tree, type, field)
Definition: rbtree.h:166

Referenced by WIC_DllMain().

◆ WICConvertBitmapSource()

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

Definition at line 2474 of file info.c.

2475{
2476 HRESULT res;
2477 IEnumUnknown *enumconverters;
2478 IUnknown *unkconverterinfo;
2479 IWICFormatConverterInfo *converterinfo=NULL;
2480 IWICFormatConverter *converter=NULL;
2481 GUID srcFormat;
2482 WCHAR srcformatstr[39], dstformatstr[39];
2483 BOOL canconvert;
2484 ULONG num_fetched;
2485
2486 TRACE("%s,%p,%p\n", debugstr_guid(dstFormat), pISrc, ppIDst);
2487
2488 res = IWICBitmapSource_GetPixelFormat(pISrc, &srcFormat);
2489 if (FAILED(res)) return res;
2490
2491 if (IsEqualGUID(&srcFormat, dstFormat) || (is_1bpp_format(&srcFormat) && is_1bpp_format(dstFormat)))
2492 {
2493 IWICBitmapSource_AddRef(pISrc);
2494 *ppIDst = pISrc;
2495 return S_OK;
2496 }
2497
2498 StringFromGUID2(&srcFormat, srcformatstr, 39);
2499 StringFromGUID2(dstFormat, dstformatstr, 39);
2500
2502 if (FAILED(res)) return res;
2503
2504 while (!converter)
2505 {
2506 res = IEnumUnknown_Next(enumconverters, 1, &unkconverterinfo, &num_fetched);
2507
2508 if (res == S_OK)
2509 {
2510 res = IUnknown_QueryInterface(unkconverterinfo, &IID_IWICFormatConverterInfo, (void**)&converterinfo);
2511
2512 if (SUCCEEDED(res))
2513 {
2514 canconvert = ConverterSupportsFormat(converterinfo, srcformatstr);
2515
2516 if (canconvert)
2517 canconvert = ConverterSupportsFormat(converterinfo, dstformatstr);
2518
2519 if (canconvert)
2520 {
2521 res = IWICFormatConverterInfo_CreateInstance(converterinfo, &converter);
2522
2523 if (SUCCEEDED(res))
2524 res = IWICFormatConverter_CanConvert(converter, &srcFormat, dstFormat, &canconvert);
2525
2526 if (SUCCEEDED(res) && canconvert)
2527 res = IWICFormatConverter_Initialize(converter, pISrc, dstFormat, WICBitmapDitherTypeNone,
2529
2530 if (FAILED(res) || !canconvert)
2531 {
2532 if (converter)
2533 {
2534 IWICFormatConverter_Release(converter);
2535 converter = NULL;
2536 }
2537 }
2538 }
2539
2540 IWICFormatConverterInfo_Release(converterinfo);
2541 }
2542
2543 IUnknown_Release(unkconverterinfo);
2544 }
2545 else
2546 break;
2547 }
2548
2549 IEnumUnknown_Release(enumconverters);
2550
2551 if (converter)
2552 {
2553 res = IWICFormatConverter_QueryInterface(converter, &IID_IWICBitmapSource, (void **)ppIDst);
2554 IWICFormatConverter_Release(converter);
2555 return res;
2556 }
2557 else
2558 {
2559 FIXME("cannot convert %s to %s\n", debugstr_guid(&srcFormat), debugstr_guid(dstFormat));
2560 *ppIDst = NULL;
2562 }
2563}
static BOOL ConverterSupportsFormat(IWICFormatConverterInfo *iface, const WCHAR *formatguid)
Definition: info.c:1159
static BOOL is_1bpp_format(const WICPixelFormatGUID *format)
Definition: info.c:2468
HRESULT CreateComponentEnumerator(DWORD componentTypes, DWORD options, IEnumUnknown **ppIEnumUnknown)
Definition: info.c:2380
@ WICBitmapDitherTypeNone
Definition: wincodec.idl:56
@ WICBitmapPaletteTypeMedianCut
Definition: wincodec.idl:92

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

◆ BitmapDecoderInfo_Vtbl

const IWICBitmapDecoderInfoVtbl BitmapDecoderInfo_Vtbl
static
Initial value:
= {
}
static HRESULT WINAPI BitmapDecoderInfo_DoesSupportLossless(IWICBitmapDecoderInfo *iface, BOOL *pfSupportLossless)
Definition: info.c:433
static HRESULT WINAPI BitmapDecoderInfo_GetFriendlyName(IWICBitmapDecoderInfo *iface, UINT cchFriendlyName, WCHAR *wzFriendlyName, UINT *pcchActual)
Definition: info.c:349
static HRESULT WINAPI BitmapDecoderInfo_QueryInterface(IWICBitmapDecoderInfo *iface, REFIID iid, void **ppv)
Definition: info.c:228
static HRESULT WINAPI BitmapDecoderInfo_GetFileExtensions(IWICBitmapDecoderInfo *iface, UINT cchFileExtensions, WCHAR *wzFileExtensions, UINT *pcchActual)
Definition: info.c:408
static HRESULT WINAPI BitmapDecoderInfo_GetDeviceModels(IWICBitmapDecoderInfo *iface, UINT cchDeviceModels, WCHAR *wzDeviceModels, UINT *pcchActual)
Definition: info.c:390
static HRESULT WINAPI BitmapDecoderInfo_GetColorManagementVersion(IWICBitmapDecoderInfo *iface, UINT cchColorManagementVersion, WCHAR *wzColorManagementVersion, UINT *pcchActual)
Definition: info.c:376
static HRESULT WINAPI BitmapDecoderInfo_GetAuthor(IWICBitmapDecoderInfo *iface, UINT cchAuthor, WCHAR *wzAuthor, UINT *pcchActual)
Definition: info.c:307
static HRESULT WINAPI BitmapDecoderInfo_GetCLSID(IWICBitmapDecoderInfo *iface, CLSID *pclsid)
Definition: info.c:289
static HRESULT WINAPI BitmapDecoderInfo_GetSpecVersion(IWICBitmapDecoderInfo *iface, UINT cchSpecVersion, WCHAR *wzSpecVersion, UINT *pcchActual)
Definition: info.c:338
static HRESULT WINAPI BitmapDecoderInfo_GetVendorGUID(IWICBitmapDecoderInfo *iface, GUID *pguidVendor)
Definition: info.c:318
static ULONG WINAPI BitmapDecoderInfo_AddRef(IWICBitmapDecoderInfo *iface)
Definition: info.c:253
static HRESULT WINAPI BitmapDecoderInfo_GetComponentType(IWICBitmapDecoderInfo *iface, WICComponentType *pType)
Definition: info.c:280
static ULONG WINAPI BitmapDecoderInfo_Release(IWICBitmapDecoderInfo *iface)
Definition: info.c:263
static HRESULT WINAPI BitmapDecoderInfo_GetMimeTypes(IWICBitmapDecoderInfo *iface, UINT cchMimeTypes, WCHAR *wzMimeTypes, UINT *pcchActual)
Definition: info.c:397
static HRESULT WINAPI BitmapDecoderInfo_DoesSupportAnimation(IWICBitmapDecoderInfo *iface, BOOL *pfSupportAnimation)
Definition: info.c:419
static HRESULT WINAPI BitmapDecoderInfo_MatchesPattern(IWICBitmapDecoderInfo *iface, IStream *pIStream, BOOL *pfMatches)
Definition: info.c:474
static HRESULT WINAPI BitmapDecoderInfo_GetPixelFormats(IWICBitmapDecoderInfo *iface, UINT cFormats, GUID *pguidPixelFormats, UINT *pcActual)
Definition: info.c:368
static HRESULT WINAPI BitmapDecoderInfo_CreateInstance(IWICBitmapDecoderInfo *iface, IWICBitmapDecoder **ppIBitmapDecoder)
Definition: info.c:538
static HRESULT WINAPI BitmapDecoderInfo_DoesSupportMultiframe(IWICBitmapDecoderInfo *iface, BOOL *pfSupportMultiframe)
Definition: info.c:440
static HRESULT WINAPI BitmapDecoderInfo_DoesSupportChromaKey(IWICBitmapDecoderInfo *iface, BOOL *pfSupportChromaKey)
Definition: info.c:426
static HRESULT WINAPI BitmapDecoderInfo_GetPatterns(IWICBitmapDecoderInfo *iface, UINT cbSizePatterns, WICBitmapPattern *pPatterns, UINT *pcPatterns, UINT *pcbPatternsActual)
Definition: info.c:454
static HRESULT WINAPI BitmapDecoderInfo_GetDeviceManufacturer(IWICBitmapDecoderInfo *iface, UINT cchDeviceManufacturer, WCHAR *wzDeviceManufacturer, UINT *pcchActual)
Definition: info.c:383
static HRESULT WINAPI BitmapDecoderInfo_MatchesMimeType(IWICBitmapDecoderInfo *iface, LPCWSTR wzMimeType, BOOL *pfMatches)
Definition: info.c:447
static HRESULT WINAPI BitmapDecoderInfo_GetContainerFormat(IWICBitmapDecoderInfo *iface, GUID *pguidContainerFormat)
Definition: info.c:360
static HRESULT WINAPI BitmapDecoderInfo_GetVersion(IWICBitmapDecoderInfo *iface, UINT cchVersion, WCHAR *wzVersion, UINT *pcchActual)
Definition: info.c:327
static HRESULT WINAPI BitmapDecoderInfo_GetSigningStatus(IWICBitmapDecoderInfo *iface, DWORD *pStatus)
Definition: info.c:301

Definition at line 548 of file info.c.

Referenced by BitmapDecoderInfo_Constructor().

◆ BitmapEncoderInfo_Vtbl

const IWICBitmapEncoderInfoVtbl BitmapEncoderInfo_Vtbl
static
Initial value:
= {
}
static HRESULT WINAPI BitmapEncoderInfo_GetAuthor(IWICBitmapEncoderInfo *iface, UINT cchAuthor, WCHAR *wzAuthor, UINT *pcchActual)
Definition: info.c:797
static HRESULT WINAPI BitmapEncoderInfo_GetDeviceManufacturer(IWICBitmapEncoderInfo *iface, UINT cchDeviceManufacturer, WCHAR *wzDeviceManufacturer, UINT *pcchActual)
Definition: info.c:873
static HRESULT WINAPI BitmapEncoderInfo_DoesSupportLossless(IWICBitmapEncoderInfo *iface, BOOL *pfSupportLossless)
Definition: info.c:923
static HRESULT WINAPI BitmapEncoderInfo_GetFileExtensions(IWICBitmapEncoderInfo *iface, UINT cchFileExtensions, WCHAR *wzFileExtensions, UINT *pcchActual)
Definition: info.c:898
static ULONG WINAPI BitmapEncoderInfo_Release(IWICBitmapEncoderInfo *iface)
Definition: info.c:754
static HRESULT WINAPI BitmapEncoderInfo_DoesSupportAnimation(IWICBitmapEncoderInfo *iface, BOOL *pfSupportAnimation)
Definition: info.c:909
static HRESULT WINAPI BitmapEncoderInfo_GetFriendlyName(IWICBitmapEncoderInfo *iface, UINT cchFriendlyName, WCHAR *wzFriendlyName, UINT *pcchActual)
Definition: info.c:839
static HRESULT WINAPI BitmapEncoderInfo_CreateInstance(IWICBitmapEncoderInfo *iface, IWICBitmapEncoder **ppIBitmapEncoder)
Definition: info.c:944
static HRESULT WINAPI BitmapEncoderInfo_DoesSupportChromaKey(IWICBitmapEncoderInfo *iface, BOOL *pfSupportChromaKey)
Definition: info.c:916
static HRESULT WINAPI BitmapEncoderInfo_GetSpecVersion(IWICBitmapEncoderInfo *iface, UINT cchSpecVersion, WCHAR *wzSpecVersion, UINT *pcchActual)
Definition: info.c:828
static HRESULT WINAPI BitmapEncoderInfo_DoesSupportMultiframe(IWICBitmapEncoderInfo *iface, BOOL *pfSupportMultiframe)
Definition: info.c:930
static HRESULT WINAPI BitmapEncoderInfo_GetColorManagementVersion(IWICBitmapEncoderInfo *iface, UINT cchColorManagementVersion, WCHAR *wzColorManagementVersion, UINT *pcchActual)
Definition: info.c:866
static ULONG WINAPI BitmapEncoderInfo_AddRef(IWICBitmapEncoderInfo *iface)
Definition: info.c:744
static HRESULT WINAPI BitmapEncoderInfo_GetPixelFormats(IWICBitmapEncoderInfo *iface, UINT cFormats, GUID *pguidPixelFormats, UINT *pcActual)
Definition: info.c:858
static HRESULT WINAPI BitmapEncoderInfo_GetDeviceModels(IWICBitmapEncoderInfo *iface, UINT cchDeviceModels, WCHAR *wzDeviceModels, UINT *pcchActual)
Definition: info.c:880
static HRESULT WINAPI BitmapEncoderInfo_QueryInterface(IWICBitmapEncoderInfo *iface, REFIID iid, void **ppv)
Definition: info.c:719
static HRESULT WINAPI BitmapEncoderInfo_GetMimeTypes(IWICBitmapEncoderInfo *iface, UINT cchMimeTypes, WCHAR *wzMimeTypes, UINT *pcchActual)
Definition: info.c:887
static HRESULT WINAPI BitmapEncoderInfo_GetSigningStatus(IWICBitmapEncoderInfo *iface, DWORD *pStatus)
Definition: info.c:791
static HRESULT WINAPI BitmapEncoderInfo_GetCLSID(IWICBitmapEncoderInfo *iface, CLSID *pclsid)
Definition: info.c:779
static HRESULT WINAPI BitmapEncoderInfo_MatchesMimeType(IWICBitmapEncoderInfo *iface, LPCWSTR wzMimeType, BOOL *pfMatches)
Definition: info.c:937
static HRESULT WINAPI BitmapEncoderInfo_GetComponentType(IWICBitmapEncoderInfo *iface, WICComponentType *pType)
Definition: info.c:770
static HRESULT WINAPI BitmapEncoderInfo_GetVendorGUID(IWICBitmapEncoderInfo *iface, GUID *pguidVendor)
Definition: info.c:808
static HRESULT WINAPI BitmapEncoderInfo_GetVersion(IWICBitmapEncoderInfo *iface, UINT cchVersion, WCHAR *wzVersion, UINT *pcchActual)
Definition: info.c:817
static HRESULT WINAPI BitmapEncoderInfo_GetContainerFormat(IWICBitmapEncoderInfo *iface, GUID *pguidContainerFormat)
Definition: info.c:850

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

Initial value:
= {
{WICDecoder, &CATID_WICBitmapDecoders, BitmapDecoderInfo_Constructor},
{WICEncoder, &CATID_WICBitmapEncoders, BitmapEncoderInfo_Constructor},
{WICPixelFormat, &CATID_WICPixelFormats, PixelFormatInfo_Constructor},
{WICMetadataReader, &CATID_WICMetadataReader, MetadataReaderInfo_Constructor},
{0}
}
static HRESULT PixelFormatInfo_Constructor(HKEY classkey, REFCLSID clsid, ComponentInfo **ret)
Definition: info.c:1485
static HRESULT MetadataReaderInfo_Constructor(HKEY classkey, REFCLSID clsid, ComponentInfo **info)
Definition: info.c:2014
static HRESULT BitmapEncoderInfo_Constructor(HKEY classkey, REFCLSID clsid, ComponentInfo **ret)
Definition: info.c:981
static HRESULT FormatConverterInfo_Constructor(HKEY classkey, REFCLSID clsid, ComponentInfo **ret)
Definition: info.c:1195
static HRESULT BitmapDecoderInfo_Constructor(HKEY classkey, REFCLSID clsid, ComponentInfo **ret)
Definition: info.c:687

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, { (DWORD_PTR)(__FILE__ ": component_info_cache") }
}
static CRITICAL_SECTION_DEBUG component_info_cache_cs_dbg
Definition: info.c:2067
LIST_ENTRY ProcessLocksList
Definition: winbase.h:883

Definition at line 2067 of file info.c.

◆ ComponentEnumVtbl

static const IEnumUnknownVtbl ComponentEnumVtbl
static
Initial value:
= {
}
static HRESULT WINAPI ComponentEnum_Skip(IEnumUnknown *iface, ULONG celt)
Definition: info.c:2285
static HRESULT WINAPI ComponentEnum_QueryInterface(IEnumUnknown *iface, REFIID iid, void **ppv)
Definition: info.c:2198
static ULONG WINAPI ComponentEnum_AddRef(IEnumUnknown *iface)
Definition: info.c:2221
static HRESULT WINAPI ComponentEnum_Reset(IEnumUnknown *iface)
Definition: info.c:2307
static ULONG WINAPI ComponentEnum_Release(IEnumUnknown *iface)
Definition: info.c:2231
static HRESULT WINAPI ComponentEnum_Next(IEnumUnknown *iface, ULONG celt, IUnknown **rgelt, ULONG *pceltFetched)
Definition: info.c:2255
static HRESULT WINAPI ComponentEnum_Clone(IEnumUnknown *iface, IEnumUnknown **ppenum)
Definition: info.c:2319

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

◆ 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

◆ FormatConverterInfo_Vtbl

const IWICFormatConverterInfoVtbl FormatConverterInfo_Vtbl
static
Initial value:
= {
}
static HRESULT WINAPI FormatConverterInfo_GetComponentType(IWICFormatConverterInfo *iface, WICComponentType *pType)
Definition: info.c:1061
static HRESULT WINAPI FormatConverterInfo_GetVendorGUID(IWICFormatConverterInfo *iface, GUID *pguidVendor)
Definition: info.c:1099
static HRESULT WINAPI FormatConverterInfo_GetFriendlyName(IWICFormatConverterInfo *iface, UINT cchFriendlyName, WCHAR *wzFriendlyName, UINT *pcchActual)
Definition: info.c:1130
static ULONG WINAPI FormatConverterInfo_Release(IWICFormatConverterInfo *iface)
Definition: info.c:1045
static ULONG WINAPI FormatConverterInfo_AddRef(IWICFormatConverterInfo *iface)
Definition: info.c:1035
static HRESULT WINAPI FormatConverterInfo_GetSigningStatus(IWICFormatConverterInfo *iface, DWORD *pStatus)
Definition: info.c:1082
static HRESULT WINAPI FormatConverterInfo_GetCLSID(IWICFormatConverterInfo *iface, CLSID *pclsid)
Definition: info.c:1070
static HRESULT WINAPI FormatConverterInfo_GetAuthor(IWICFormatConverterInfo *iface, UINT cchAuthor, WCHAR *wzAuthor, UINT *pcchActual)
Definition: info.c:1088
static HRESULT WINAPI FormatConverterInfo_QueryInterface(IWICFormatConverterInfo *iface, REFIID iid, void **ppv)
Definition: info.c:1011
static HRESULT WINAPI FormatConverterInfo_GetVersion(IWICFormatConverterInfo *iface, UINT cchVersion, WCHAR *wzVersion, UINT *pcchActual)
Definition: info.c:1108
static HRESULT WINAPI FormatConverterInfo_GetSpecVersion(IWICFormatConverterInfo *iface, UINT cchSpecVersion, WCHAR *wzSpecVersion, UINT *pcchActual)
Definition: info.c:1119
static HRESULT WINAPI FormatConverterInfo_CreateInstance(IWICFormatConverterInfo *iface, IWICFormatConverter **ppIFormatConverter)
Definition: info.c:1148
static HRESULT WINAPI FormatConverterInfo_GetPixelFormats(IWICFormatConverterInfo *iface, UINT cFormats, GUID *pguidPixelFormats, UINT *pcActual)
Definition: info.c:1141

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

◆ 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