#include <stdarg.h>
#include <assert.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "wingdi.h"
#include "objbase.h"
#include "olectl.h"
#include "ole2.h"
#include "initguid.h"
#include "wincodec.h"
#include "gdiplus.h"
#include "gdiplus_private.h"
#include "wine/debug.h"

Include dependency graph for image.c:

Classes
struct	image_format_dimension

struct	image_codec

Macros
#define	NONAMELESSUNION

#define	COBJMACROS

#define	PIXELFORMATBPP(x) ((x) ? ((x) >> 8) & 255 : 24)

#define	WMF_PLACEABLE_KEY 0x9ac6cdd7

#define	convert_indexed_to_rgb(getpixel_function, setpixel_function)

#define	convert_rgb_to_rgb(getpixel_function, setpixel_function)

#define	convert_rgb_to_indexed(getpixel_function, setpixel_function)

#define	PropertyTagTypeSByte 6

#define	PropertyTagTypeSShort 8

#define	PropertyTagTypeFloat 11

#define	PropertyTagTypeDouble 12

Typedefs
typedef void(*	metadata_reader_func) (GpBitmap bitmap, IWICBitmapDecoder decoder, UINT frame)

typedef GpStatus(*	encode_image_func) (GpImage image, IStream stream, GDIPCONST EncoderParameters *params)

typedef GpStatus(*	decode_image_func) (IStream stream, GpImage *image)

typedef GpStatus(*	select_image_func) (GpImage *image, UINT active_frame)

typedef struct image_codec	image_codec

Enumerations
enum	ImageFormat { BMP , JPEG , GIF , TIFF , EMF , WMF , PNG , ICO , NUM_CODECS }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (gdiplus)

HRESULT WINAPI	WICCreateImagingFactory_Proxy (UINT, IWICImagingFactory **)

static ColorPalette *	get_palette (IWICBitmapFrameDecode *frame, WICBitmapPaletteType palette_type)

GpStatus WINGDIPAPI	GdipBitmapApplyEffect (GpBitmap bitmap, CGpEffect effect, RECT roi, BOOL useAuxData, VOID auxData, INT auxDataSize)

GpStatus WINGDIPAPI	GdipBitmapCreateApplyEffect (GpBitmap *inputBitmaps, INT numInputs, CGpEffect effect, RECT roi, RECT outputRect, GpBitmap outputBitmap, BOOL useAuxData, VOID auxData, INT *auxDataSize)

static void	getpixel_1bppIndexed (BYTE index, const BYTE row, UINT x)

static void	getpixel_4bppIndexed (BYTE index, const BYTE row, UINT x)

static void	getpixel_8bppIndexed (BYTE index, const BYTE row, UINT x)

static void	getpixel_16bppGrayScale (BYTE r, BYTE g, BYTE b, BYTE a, const BYTE *row, UINT x)

static void	getpixel_16bppRGB555 (BYTE r, BYTE g, BYTE b, BYTE a, const BYTE *row, UINT x)

static void	getpixel_16bppRGB565 (BYTE r, BYTE g, BYTE b, BYTE a, const BYTE *row, UINT x)

static void	getpixel_16bppARGB1555 (BYTE r, BYTE g, BYTE b, BYTE a, const BYTE *row, UINT x)

static void	getpixel_24bppRGB (BYTE r, BYTE g, BYTE b, BYTE a, const BYTE *row, UINT x)

static void	getpixel_32bppRGB (BYTE r, BYTE g, BYTE b, BYTE a, const BYTE *row, UINT x)

static void	getpixel_32bppARGB (BYTE r, BYTE g, BYTE b, BYTE a, const BYTE *row, UINT x)

static void	getpixel_32bppPARGB (BYTE r, BYTE g, BYTE b, BYTE a, const BYTE *row, UINT x)

static void	getpixel_48bppRGB (BYTE r, BYTE g, BYTE b, BYTE a, const BYTE *row, UINT x)

static void	getpixel_64bppARGB (BYTE r, BYTE g, BYTE b, BYTE a, const BYTE *row, UINT x)

static void	getpixel_64bppPARGB (BYTE r, BYTE g, BYTE b, BYTE a, const BYTE *row, UINT x)

GpStatus WINGDIPAPI	GdipBitmapGetPixel (GpBitmap bitmap, INT x, INT y, ARGB color)

static UINT	get_palette_index (BYTE r, BYTE g, BYTE b, BYTE a, ColorPalette *palette)

static void	setpixel_8bppIndexed (BYTE r, BYTE g, BYTE b, BYTE a, BYTE row, UINT x, ColorPalette palette)

static void	setpixel_1bppIndexed (BYTE r, BYTE g, BYTE b, BYTE a, BYTE row, UINT x, ColorPalette palette)

static void	setpixel_4bppIndexed (BYTE r, BYTE g, BYTE b, BYTE a, BYTE row, UINT x, ColorPalette palette)

static void	setpixel_16bppGrayScale (BYTE r, BYTE g, BYTE b, BYTE a, BYTE *row, UINT x)

static void	setpixel_16bppRGB555 (BYTE r, BYTE g, BYTE b, BYTE a, BYTE *row, UINT x)

static void	setpixel_16bppRGB565 (BYTE r, BYTE g, BYTE b, BYTE a, BYTE *row, UINT x)

static void	setpixel_16bppARGB1555 (BYTE r, BYTE g, BYTE b, BYTE a, BYTE *row, UINT x)

static void	setpixel_24bppRGB (BYTE r, BYTE g, BYTE b, BYTE a, BYTE *row, UINT x)

static void	setpixel_32bppRGB (BYTE r, BYTE g, BYTE b, BYTE a, BYTE *row, UINT x)

static void	setpixel_32bppARGB (BYTE r, BYTE g, BYTE b, BYTE a, BYTE *row, UINT x)

static void	setpixel_32bppPARGB (BYTE r, BYTE g, BYTE b, BYTE a, BYTE *row, UINT x)

static void	setpixel_48bppRGB (BYTE r, BYTE g, BYTE b, BYTE a, BYTE *row, UINT x)

static void	setpixel_64bppARGB (BYTE r, BYTE g, BYTE b, BYTE a, BYTE *row, UINT x)

static void	setpixel_64bppPARGB (BYTE r, BYTE g, BYTE b, BYTE a, BYTE *row, UINT x)

GpStatus WINGDIPAPI	GdipBitmapSetPixel (GpBitmap *bitmap, INT x, INT y, ARGB color)

GpStatus	convert_pixels (INT width, INT height, INT dst_stride, BYTE dst_bits, PixelFormat dst_format, INT src_stride, const BYTE src_bits, PixelFormat src_format, ColorPalette *palette)

GpStatus WINGDIPAPI	GdipBitmapLockBits (GpBitmap bitmap, GDIPCONST GpRect rect, UINT flags, PixelFormat format, BitmapData *lockeddata)

GpStatus WINGDIPAPI	GdipBitmapSetResolution (GpBitmap *bitmap, REAL xdpi, REAL ydpi)

GpStatus WINGDIPAPI	GdipBitmapUnlockBits (GpBitmap bitmap, BitmapData lockeddata)

GpStatus WINGDIPAPI	GdipCloneBitmapArea (REAL x, REAL y, REAL width, REAL height, PixelFormat format, GpBitmap srcBitmap, GpBitmap *dstBitmap)

GpStatus WINGDIPAPI	GdipCloneBitmapAreaI (INT x, INT y, INT width, INT height, PixelFormat format, GpBitmap srcBitmap, GpBitmap *dstBitmap)

GpStatus WINGDIPAPI	GdipCloneImage (GpImage image, GpImage *cloneImage)

GpStatus WINGDIPAPI	GdipCreateBitmapFromFile (GDIPCONST WCHAR filename, GpBitmap *bitmap)

GpStatus WINGDIPAPI	GdipCreateBitmapFromGdiDib (GDIPCONST BITMAPINFO info, VOID bits, GpBitmap **bitmap)

GpStatus WINGDIPAPI	GdipCreateBitmapFromFileICM (GDIPCONST WCHAR filename, GpBitmap *bitmap)

GpStatus WINGDIPAPI	GdipCreateBitmapFromResource (HINSTANCE hInstance, GDIPCONST WCHAR lpBitmapName, GpBitmap *bitmap)

static DWORD	blend_argb_no_bkgnd_alpha (DWORD src, DWORD bkgnd)

GpStatus WINGDIPAPI	GdipCreateHBITMAPFromBitmap (GpBitmap bitmap, HBITMAP hbmReturn, ARGB background)

GpStatus WINGDIPAPI	GdipCreateBitmapFromGraphics (INT width, INT height, GpGraphics target, GpBitmap *bitmap)

GpStatus WINGDIPAPI	GdipCreateBitmapFromHICON (HICON hicon, GpBitmap **bitmap)

static void	generate_halftone_palette (ARGB *entries, UINT count)

static GpStatus	get_screen_resolution (REAL xres, REAL yres)

GpStatus WINGDIPAPI	GdipCreateBitmapFromScan0 (INT width, INT height, INT stride, PixelFormat format, BYTE scan0, GpBitmap *bitmap)

GpStatus WINGDIPAPI	GdipCreateBitmapFromStream (IStream stream, GpBitmap *bitmap)

GpStatus WINGDIPAPI	GdipCreateBitmapFromStreamICM (IStream stream, GpBitmap *bitmap)

GpStatus WINGDIPAPI	GdipCreateCachedBitmap (GpBitmap bitmap, GpGraphics graphics, GpCachedBitmap **cachedbmp)

GpStatus WINGDIPAPI	GdipCreateHICONFromBitmap (GpBitmap bitmap, HICON hicon)

GpStatus WINGDIPAPI	GdipDeleteCachedBitmap (GpCachedBitmap *cachedbmp)

GpStatus WINGDIPAPI	GdipDrawCachedBitmap (GpGraphics graphics, GpCachedBitmap cachedbmp, INT x, INT y)

static void	move_bitmap (GpBitmap dst, GpBitmap src, BOOL clobber_palette)

static GpStatus	free_image_data (GpImage *image)

GpStatus WINGDIPAPI	GdipDisposeImage (GpImage *image)

GpStatus WINGDIPAPI	GdipFindFirstImageItem (GpImage image, ImageItemData item)

GpStatus WINGDIPAPI	GdipGetImageItemData (GpImage image, ImageItemData item)

GpStatus WINGDIPAPI	GdipGetImageBounds (GpImage image, GpRectF srcRect, GpUnit *srcUnit)

GpStatus WINGDIPAPI	GdipGetImageDimension (GpImage image, REAL width, REAL *height)

GpStatus WINGDIPAPI	GdipGetImageGraphicsContext (GpImage image, GpGraphics *graphics)

GpStatus WINGDIPAPI	GdipGetImageHeight (GpImage image, UINT height)

GpStatus WINGDIPAPI	GdipGetImageHorizontalResolution (GpImage image, REAL res)

GpStatus WINGDIPAPI	GdipGetImagePaletteSize (GpImage image, INT size)

GpStatus WINGDIPAPI	GdipGetImagePixelFormat (GpImage image, PixelFormat format)

GpStatus WINGDIPAPI	GdipGetImageRawFormat (GpImage image, GUID format)

GpStatus WINGDIPAPI	GdipGetImageType (GpImage image, ImageType type)

GpStatus WINGDIPAPI	GdipGetImageVerticalResolution (GpImage image, REAL res)

GpStatus WINGDIPAPI	GdipGetImageWidth (GpImage image, UINT width)

GpStatus WINGDIPAPI	GdipGetPropertyCount (GpImage image, UINT num)

GpStatus WINGDIPAPI	GdipGetPropertyIdList (GpImage image, UINT num, PROPID list)

static UINT	propvariant_size (PROPVARIANT *value)

GpStatus WINGDIPAPI	GdipGetPropertyItemSize (GpImage image, PROPID propid, UINT size)

static UINT	vt_to_itemtype (UINT vt)

static GpStatus	propvariant_to_item (PROPVARIANT value, PropertyItem item, UINT size, PROPID id)

GpStatus WINGDIPAPI	GdipGetPropertyItem (GpImage image, PROPID propid, UINT size, PropertyItem buffer)

GpStatus WINGDIPAPI	GdipGetPropertySize (GpImage image, UINT size, UINT *count)

GpStatus WINGDIPAPI	GdipGetAllPropertyItems (GpImage image, UINT size, UINT count, PropertyItem buf)

GpStatus WINGDIPAPI	GdipImageGetFrameCount (GpImage image, GDIPCONST GUID dimensionID, UINT *count)

GpStatus WINGDIPAPI	GdipImageGetFrameDimensionsCount (GpImage image, UINT count)

GpStatus WINGDIPAPI	GdipImageGetFrameDimensionsList (GpImage image, GUID dimensionIDs, UINT count)

GpStatus WINGDIPAPI	GdipLoadImageFromFile (GDIPCONST WCHAR filename, GpImage *image)

GpStatus WINGDIPAPI	GdipLoadImageFromFileICM (GDIPCONST WCHAR filename, GpImage *image)

static void	add_property (GpBitmap bitmap, PropertyItem item)

static BOOL	get_bool_property (IWICMetadataReader reader, const GUID guid, const WCHAR *prop_name)

static PropertyItem *	get_property (IWICMetadataReader reader, const GUID guid, const WCHAR *prop_name)

static PropertyItem *	get_gif_comment (IWICMetadataReader *reader)

static PropertyItem *	get_gif_loopcount (IWICMetadataReader *reader)

static PropertyItem *	get_gif_background (IWICMetadataReader *reader)

static PropertyItem *	get_gif_palette (IWICBitmapDecoder decoder, IWICMetadataReader reader)

static PropertyItem *	get_gif_transparent_idx (IWICMetadataReader *reader)

static LONG	get_gif_frame_property (IWICBitmapFrameDecode frame, const GUID format, const WCHAR *property)

static void	gif_metadata_reader (GpBitmap bitmap, IWICBitmapDecoder decoder, UINT active_frame)

static PropertyItem *	create_prop (PROPID propid, PROPVARIANT *value)

static ULONG	get_ulong_by_index (IWICMetadataReader *reader, ULONG index)

static void	png_metadata_reader (GpBitmap bitmap, IWICBitmapDecoder decoder, UINT active_frame)

static GpStatus	initialize_decoder_wic (IStream stream, REFGUID container, IWICBitmapDecoder *decoder)

static GpStatus	decode_frame_wic (IWICBitmapDecoder decoder, BOOL force_conversion, UINT active_frame, metadata_reader_func metadata_reader, GpImage *image)

static GpStatus	decode_image_wic (IStream stream, REFGUID container, metadata_reader_func metadata_reader, GpImage *image)

static GpStatus	select_frame_wic (GpImage *image, UINT active_frame)

static HRESULT	get_gif_frame_rect (IWICBitmapFrameDecode frame, UINT left, UINT top, UINT width, UINT *height)

static HRESULT	blit_gif_frame (GpBitmap bitmap, IWICBitmapFrameDecode frame, BOOL first_frame)

static DWORD	get_gif_background_color (GpBitmap *bitmap)

static GpStatus	select_frame_gif (GpImage *image, UINT active_frame)

static GpStatus	decode_image_icon (IStream stream, GpImage *image)

static GpStatus	decode_image_bmp (IStream stream, GpImage *image)

static GpStatus	decode_image_jpeg (IStream stream, GpImage *image)

static BOOL	has_png_transparency_chunk (IStream *pIStream)

static GpStatus	decode_image_png (IStream stream, GpImage *image)

static GpStatus	decode_image_gif (IStream stream, GpImage *image)

static GpStatus	decode_image_tiff (IStream stream, GpImage *image)

static GpStatus	load_wmf (IStream stream, GpMetafile *metafile)

static GpStatus	decode_image_wmf (IStream stream, GpImage *image)

static GpStatus	load_emf (IStream stream, GpMetafile *metafile)

static GpStatus	decode_image_emf (IStream stream, GpImage *image)

static GpStatus	get_decoder_info (IStream stream, const struct image_codec *result)

static GpStatus	get_decoder_info_from_image (GpImage image, const struct image_codec *result)

GpStatus WINGDIPAPI	GdipImageSelectActiveFrame (GpImage image, GDIPCONST GUID dimensionID, UINT frame)

GpStatus WINGDIPAPI	GdipLoadImageFromStream (IStream stream, GpImage *image)

GpStatus WINGDIPAPI	GdipLoadImageFromStreamICM (IStream stream, GpImage *image)

GpStatus WINGDIPAPI	GdipRemovePropertyItem (GpImage *image, PROPID propId)

GpStatus WINGDIPAPI	GdipSetPropertyItem (GpImage image, GDIPCONST PropertyItem item)

GpStatus WINGDIPAPI	GdipSaveImageToFile (GpImage image, GDIPCONST WCHAR filename, GDIPCONST CLSID clsidEncoder, GDIPCONST EncoderParameters encoderParams)

static GpStatus	encode_image_wic (GpImage image, IStream stream, REFGUID container, GDIPCONST EncoderParameters *params)

static GpStatus	encode_image_BMP (GpImage image, IStream stream, GDIPCONST EncoderParameters *params)

static GpStatus	encode_image_tiff (GpImage image, IStream stream, GDIPCONST EncoderParameters *params)

GpStatus	encode_image_png (GpImage image, IStream stream, GDIPCONST EncoderParameters *params)

static GpStatus	encode_image_jpeg (GpImage image, IStream stream, GDIPCONST EncoderParameters *params)

static GpStatus	encode_image_gif (GpImage image, IStream stream, GDIPCONST EncoderParameters *params)

GpStatus WINGDIPAPI	GdipSaveImageToStream (GpImage image, IStream stream, GDIPCONST CLSID clsid, GDIPCONST EncoderParameters params)

GpStatus WINGDIPAPI	GdipSaveAdd (GpImage image, GDIPCONST EncoderParameters params)

GpStatus WINGDIPAPI	GdipGetImagePalette (GpImage image, ColorPalette palette, INT size)

GpStatus WINGDIPAPI	GdipSetImagePalette (GpImage image, GDIPCONST ColorPalette palette)

GpStatus WINGDIPAPI	GdipGetImageDecodersSize (UINT numDecoders, UINT size)

GpStatus WINGDIPAPI	GdipGetImageDecoders (UINT numDecoders, UINT size, ImageCodecInfo *decoders)

GpStatus WINGDIPAPI	GdipGetImageEncodersSize (UINT numEncoders, UINT size)

GpStatus WINGDIPAPI	GdipGetImageEncoders (UINT numEncoders, UINT size, ImageCodecInfo *encoders)

GpStatus WINGDIPAPI	GdipGetEncoderParameterListSize (GpImage image, GDIPCONST CLSID clsidEncoder, UINT *size)

static PixelFormat	get_16bpp_format (HBITMAP hbm)

GpStatus WINGDIPAPI	GdipCreateBitmapFromHBITMAP (HBITMAP hbm, HPALETTE hpal, GpBitmap **bitmap)

GpStatus WINGDIPAPI	GdipCreateEffect (const GUID guid, CGpEffect **effect)

GpStatus WINGDIPAPI	GdipDeleteEffect (CGpEffect *effect)

GpStatus WINGDIPAPI	GdipSetEffectParameters (CGpEffect effect, const VOID params, const UINT size)

GpStatus WINGDIPAPI	GdipGetImageFlags (GpImage image, UINT flags)

GpStatus WINGDIPAPI	GdipTestControl (GpTestControlEnum control, void *param)

GpStatus WINGDIPAPI	GdipImageForceValidation (GpImage *image)

GpStatus WINGDIPAPI	GdipGetImageThumbnail (GpImage image, UINT width, UINT height, GpImage ret_image, GetThumbnailImageAbort cb, VOID cb_data)

GpStatus WINGDIPAPI	GdipImageRotateFlip (GpImage *image, RotateFlipType type)

GpStatus WINGDIPAPI	GdipImageSetAbort (GpImage image, GdiplusAbort pabort)

GpStatus WINGDIPAPI	GdipBitmapConvertFormat (GpBitmap bitmap, PixelFormat format, DitherType dithertype, PaletteType palettetype, ColorPalette palette, REAL alphathreshold)

static void	set_histogram_point_argb (ARGB color, UINT ch0, UINT ch1, UINT ch2, UINT ch3)

static void	set_histogram_point_pargb (ARGB color, UINT ch0, UINT ch1, UINT ch2, UINT ch3)

static void	set_histogram_point_rgb (ARGB color, UINT ch0, UINT ch1, UINT ch2, UINT ch3)

static void	set_histogram_point_gray (ARGB color, UINT ch0, UINT ch1, UINT ch2, UINT ch3)

static void	set_histogram_point_b (ARGB color, UINT ch0, UINT ch1, UINT ch2, UINT ch3)

static void	set_histogram_point_g (ARGB color, UINT ch0, UINT ch1, UINT ch2, UINT ch3)

static void	set_histogram_point_r (ARGB color, UINT ch0, UINT ch1, UINT ch2, UINT ch3)

static void	set_histogram_point_a (ARGB color, UINT ch0, UINT ch1, UINT ch2, UINT ch3)

GpStatus WINGDIPAPI	GdipBitmapGetHistogram (GpBitmap bitmap, HistogramFormat format, UINT num_of_entries, UINT ch0, UINT ch1, UINT ch2, UINT *ch3)

GpStatus WINGDIPAPI	GdipBitmapGetHistogramSize (HistogramFormat format, UINT *num_of_entries)

static GpStatus	create_optimal_palette (ColorPalette palette, INT desired, BOOL transparent, GpBitmap bitmap)

GpStatus WINGDIPAPI	GdipInitializePalette (ColorPalette palette, PaletteType type, INT desired, BOOL transparent, GpBitmap bitmap)

Variables
struct {
const WICPixelFormatGUID * wic_format

PixelFormat gdip_format

WICBitmapPaletteType palette_type

}	pixel_formats []

static const struct image_format_dimension	image_format_dimensions []

static const struct image_codec	codecs [NUM_CODECS]

static const WCHAR	bmp_codecname [] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}

static const WCHAR	bmp_extension [] = {'','.','B', 'M', 'P',';', '','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}

static const WCHAR	bmp_mimetype [] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}

static const WCHAR	bmp_format [] = {'B', 'M', 'P', 0}

static const BYTE	bmp_sig_pattern [] = { 0x42, 0x4D }

static const BYTE	bmp_sig_mask [] = { 0xFF, 0xFF }

static const WCHAR	jpeg_codecname [] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'J','P','E','G', 0}

static const WCHAR	jpeg_extension [] = {'','.','J','P','G',';', '','.','J','P','E','G',';', '','.','J','P','E',';', '','.','J','F','I','F',0}

static const WCHAR	jpeg_mimetype [] = {'i','m','a','g','e','/','j','p','e','g', 0}

static const WCHAR	jpeg_format [] = {'J','P','E','G',0}

static const BYTE	jpeg_sig_pattern [] = { 0xFF, 0xD8 }

static const BYTE	jpeg_sig_mask [] = { 0xFF, 0xFF }

static const WCHAR	gif_codecname [] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'G','I','F', 0}

static const WCHAR	gif_extension [] = {'*','.','G','I','F',0}

static const WCHAR	gif_mimetype [] = {'i','m','a','g','e','/','g','i','f', 0}

static const WCHAR	gif_format [] = {'G','I','F',0}

static const BYTE	gif_sig_pattern [12] = "GIF87aGIF89a"

static const BYTE	gif_sig_mask [] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }

static const WCHAR	tiff_codecname [] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'T','I','F','F', 0}

static const WCHAR	tiff_extension [] = {'','.','T','I','F','F',';','','.','T','I','F',0}

static const WCHAR	tiff_mimetype [] = {'i','m','a','g','e','/','t','i','f','f', 0}

static const WCHAR	tiff_format [] = {'T','I','F','F',0}

static const BYTE	tiff_sig_pattern [] = {0x49,0x49,42,0,0x4d,0x4d,0,42}

static const BYTE	tiff_sig_mask [] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }

static const WCHAR	emf_codecname [] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'E','M','F', 0}

static const WCHAR	emf_extension [] = {'*','.','E','M','F',0}

static const WCHAR	emf_mimetype [] = {'i','m','a','g','e','/','x','-','e','m','f', 0}

static const WCHAR	emf_format [] = {'E','M','F',0}

static const BYTE	emf_sig_pattern [] = { 0x01, 0x00, 0x00, 0x00 }

static const BYTE	emf_sig_mask [] = { 0xFF, 0xFF, 0xFF, 0xFF }

static const WCHAR	wmf_codecname [] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'W','M','F', 0}

static const WCHAR	wmf_extension [] = {'*','.','W','M','F',0}

static const WCHAR	wmf_mimetype [] = {'i','m','a','g','e','/','x','-','w','m','f', 0}

static const WCHAR	wmf_format [] = {'W','M','F',0}

static const BYTE	wmf_sig_pattern [] = { 0xd7, 0xcd }

static const BYTE	wmf_sig_mask [] = { 0xFF, 0xFF }

static const WCHAR	png_codecname [] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'P','N','G', 0}

static const WCHAR	png_extension [] = {'*','.','P','N','G',0}

static const WCHAR	png_mimetype [] = {'i','m','a','g','e','/','p','n','g', 0}

static const WCHAR	png_format [] = {'P','N','G',0}

static const BYTE	png_sig_pattern [] = { 137, 80, 78, 71, 13, 10, 26, 10, }

static const BYTE	png_sig_mask [] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }

static const WCHAR	ico_codecname [] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'I','C','O', 0}

static const WCHAR	ico_extension [] = {'*','.','I','C','O',0}

static const WCHAR	ico_mimetype [] = {'i','m','a','g','e','/','x','-','i','c','o','n', 0}

static const WCHAR	ico_format [] = {'I','C','O',0}

static const BYTE	ico_sig_pattern [] = { 0x00, 0x00, 0x01, 0x00 }

static const BYTE	ico_sig_mask [] = { 0xFF, 0xFF, 0xFF, 0xFF }

Macro Definition Documentation

◆ COBJMACROS

#define COBJMACROS

Definition at line 30 of file image.c.

◆ convert_indexed_to_rgb

#define convert_indexed_to_rgb	(	getpixel_function,
		setpixel_function
	)

Value:

    do { \
    for (y=0; y<height; y++) \
        for (x=0; x<width; x++) { \
            BYTE index; \
            ARGB argb; \
            BYTE *color = (BYTE *)&argb; \
            getpixel_function(&index, src_bits+src_stride*y, x); \
            argb = (palette && index < palette->Count) ? palette->Entries[index] : 0; \
            setpixel_function(color[2], color[1], color[0], color[3], dst_bits+dst_stride*y, x); \
        } \
    return Ok; \
} while (0);

◆ convert_rgb_to_indexed

#define convert_rgb_to_indexed	(	getpixel_function,
		setpixel_function
	)

Value:

    do { \
    for (y=0; y<height; y++) \
        for (x=0; x<width; x++) { \
            BYTE r, g, b, a; \
            getpixel_function(&r, &g, &b, &a, src_bits+src_stride*y, x); \
            setpixel_function(r, g, b, a, dst_bits+dst_stride*y, x, palette); \
        } \
    return Ok; \
} while (0);

◆ convert_rgb_to_rgb

#define convert_rgb_to_rgb	(	getpixel_function,
		setpixel_function
	)

Value:

    do { \
    for (y=0; y<height; y++) \
        for (x=0; x<width; x++) { \
            BYTE r, g, b, a; \
            getpixel_function(&r, &g, &b, &a, src_bits+src_stride*y, x); \
            setpixel_function(r, g, b, a, dst_bits+dst_stride*y, x); \
        } \
    return Ok; \
} while (0);

◆ NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 23 of file image.c.

◆ PIXELFORMATBPP

#define PIXELFORMATBPP ( x ) ((x) ? ((x) >> 8) & 255 : 24)

Definition at line 45 of file image.c.

◆ PropertyTagTypeDouble

#define PropertyTagTypeDouble 12

Definition at line 2587 of file image.c.

◆ PropertyTagTypeFloat

#define PropertyTagTypeFloat 11

Definition at line 2586 of file image.c.

◆ PropertyTagTypeSByte

#define PropertyTagTypeSByte 6

Definition at line 2584 of file image.c.

◆ PropertyTagTypeSShort

#define PropertyTagTypeSShort 8

Definition at line 2585 of file image.c.

◆ WMF_PLACEABLE_KEY

#define WMF_PLACEABLE_KEY 0x9ac6cdd7

Definition at line 46 of file image.c.

Typedef Documentation

◆ decode_image_func

typedef GpStatus(* decode_image_func) (IStream *stream, GpImage **image)

Definition at line 4260 of file image.c.

◆ encode_image_func

typedef GpStatus(* encode_image_func) (GpImage *image, IStream *stream, GDIPCONST EncoderParameters *params)

Definition at line 4257 of file image.c.

◆ image_codec

typedef struct image_codec image_codec

◆ metadata_reader_func

typedef void(* metadata_reader_func) (GpBitmap *bitmap, IWICBitmapDecoder *decoder, UINT frame)

Definition at line 3630 of file image.c.

◆ select_image_func

typedef GpStatus(* select_image_func) (GpImage *image, UINT active_frame)

Definition at line 4262 of file image.c.

Enumeration Type Documentation

◆ ImageFormat

enum ImageFormat

Enumerator
BMP
JPEG
GIF
TIFF
EMF
WMF
PNG
ICO
NUM_CODECS

Definition at line 4271 of file image.c.

             {
    BMP,
    JPEG,
    GIF,
    TIFF,
    EMF,
    WMF,
    PNG,
    ICO,
    NUM_CODECS
} ImageFormat;

Function Documentation

◆ add_property()

static void add_property	(	GpBitmap *	bitmap,
		PropertyItem *	item
	)

static

Definition at line 3009 of file image.c.

{
    UINT prop_size, prop_count;
    PropertyItem *prop_item;
 
    if (bitmap->prop_item == NULL)
    {
        prop_size = prop_count = 0;
        prop_item = heap_alloc_zero(item->length + sizeof(PropertyItem));
        if (!prop_item) return;
    }
    else
    {
        UINT i;
        char *item_value;
 
        GdipGetPropertySize(&bitmap->image, &prop_size, &prop_count);
 
        prop_item = heap_alloc_zero(prop_size + item->length + sizeof(PropertyItem));
        if (!prop_item) return;
        memcpy(prop_item, bitmap->prop_item, sizeof(PropertyItem) * bitmap->prop_count);
        prop_size -= sizeof(PropertyItem) * bitmap->prop_count;
        memcpy(prop_item + prop_count + 1, bitmap->prop_item + prop_count, prop_size);
 
        item_value = (char *)(prop_item + prop_count + 1);
 
        for (i = 0; i < prop_count; i++)
        {
            prop_item[i].value = item_value;
            item_value += prop_item[i].length;
        }
    }
 
    prop_item[prop_count].id = item->id;
    prop_item[prop_count].type = item->type;
    prop_item[prop_count].length = item->length;
    prop_item[prop_count].value = (char *)(prop_item + prop_count + 1) + prop_size;
    memcpy(prop_item[prop_count].value, item->value, item->length);
 
    heap_free(bitmap->prop_item);
    bitmap->prop_item = prop_item;
    bitmap->prop_count++;
}

Referenced by gif_metadata_reader(), and png_metadata_reader().

◆ blend_argb_no_bkgnd_alpha()

static DWORD blend_argb_no_bkgnd_alpha	(	DWORD	src,
		DWORD	bkgnd
	)

inlinestatic

Definition at line 1467 of file image.c.

{
    BYTE b = (BYTE)src;
    BYTE g = (BYTE)(src >> 8);
    BYTE r = (BYTE)(src >> 16);
    DWORD alpha  = (BYTE)(src >> 24);
    return ((b     + ((BYTE)bkgnd         * (255 - alpha) + 127) / 255) |
            (g     + ((BYTE)(bkgnd >> 8)  * (255 - alpha) + 127) / 255) << 8 |
            (r     + ((BYTE)(bkgnd >> 16) * (255 - alpha) + 127) / 255) << 16 |
            (alpha << 24));
}

Referenced by GdipCreateHBITMAPFromBitmap().

◆ blit_gif_frame()

static HRESULT blit_gif_frame	(	GpBitmap *	bitmap,
		IWICBitmapFrameDecode *	frame,
		BOOL	first_frame
	)

static

Definition at line 3834 of file image.c.

{
    UINT i, j, left, top, width, height;
    IWICBitmapSource *source;
    BYTE *new_bits;
    HRESULT hr;
 
    hr = get_gif_frame_rect(frame, &left, &top, &width, &height);
    if(FAILED(hr))
        return hr;
 
    hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, (IWICBitmapSource*)frame, &source);
    if(FAILED(hr))
        return hr;
 
    new_bits = heap_alloc_zero(width*height*4);
    if(!new_bits)
        return E_OUTOFMEMORY;
 
    hr = IWICBitmapSource_CopyPixels(source, NULL, width*4, width*height*4, new_bits);
    IWICBitmapSource_Release(source);
    if(FAILED(hr)) {
        heap_free(new_bits);
        return hr;
    }
 
    for(i=0; i<height && i+top<bitmap->height; i++) {
        for(j=0; j<width && j+left<bitmap->width; j++) {
            DWORD *src = (DWORD*)(new_bits+i*width*4+j*4);
            DWORD *dst = (DWORD*)(bitmap->bits+(i+top)*bitmap->stride+(j+left)*4);
 
            if(first_frame || *src>>24 != 0)
                *dst = *src;
        }
    }
    heap_free(new_bits);
    return hr;
}

Referenced by select_frame_gif().

◆ convert_pixels()

GpStatus convert_pixels	(	INT	width,
		INT	height,
		INT	dst_stride,
		BYTE *	dst_bits,
		PixelFormat	dst_format,
		INT	src_stride,
		const BYTE *	src_bits,
		PixelFormat	src_format,
		ColorPalette *	palette
	)

Definition at line 562 of file image.c.

{
    INT x, y;
 
    if (src_format == dst_format ||
        (dst_format == PixelFormat32bppRGB && PIXELFORMATBPP(src_format) == 32))
    {
        UINT widthbytes = PIXELFORMATBPP(src_format) * width / 8;
        for (y=0; y<height; y++)
            memcpy(dst_bits+dst_stride*y, src_bits+src_stride*y, widthbytes);
        return Ok;
    }
 
#define convert_indexed_to_rgb(getpixel_function, setpixel_function) do { \
    for (y=0; y<height; y++) \
        for (x=0; x<width; x++) { \
            BYTE index; \
            ARGB argb; \
            BYTE *color = (BYTE *)&argb; \
            getpixel_function(&index, src_bits+src_stride*y, x); \
            argb = (palette && index < palette->Count) ? palette->Entries[index] : 0; \
            setpixel_function(color[2], color[1], color[0], color[3], dst_bits+dst_stride*y, x); \
        } \
    return Ok; \
} while (0);
 
#define convert_rgb_to_rgb(getpixel_function, setpixel_function) do { \
    for (y=0; y<height; y++) \
        for (x=0; x<width; x++) { \
            BYTE r, g, b, a; \
            getpixel_function(&r, &g, &b, &a, src_bits+src_stride*y, x); \
            setpixel_function(r, g, b, a, dst_bits+dst_stride*y, x); \
        } \
    return Ok; \
} while (0);
 
#define convert_rgb_to_indexed(getpixel_function, setpixel_function) do { \
    for (y=0; y<height; y++) \
        for (x=0; x<width; x++) { \
            BYTE r, g, b, a; \
            getpixel_function(&r, &g, &b, &a, src_bits+src_stride*y, x); \
            setpixel_function(r, g, b, a, dst_bits+dst_stride*y, x, palette); \
        } \
    return Ok; \
} while (0);
 
    switch (src_format)
    {
    case PixelFormat1bppIndexed:
        switch (dst_format)
        {
        case PixelFormat16bppGrayScale:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat4bppIndexed:
        switch (dst_format)
        {
        case PixelFormat16bppGrayScale:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat8bppIndexed:
        switch (dst_format)
        {
        case PixelFormat16bppGrayScale:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat16bppGrayScale:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppGrayScale, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppGrayScale, setpixel_8bppIndexed);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat16bppRGB555:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppRGB555, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppRGB555, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat16bppRGB565:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppRGB565, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppRGB565, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppRGB555);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat16bppARGB1555:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppARGB1555, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_16bppARGB1555, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppRGB565);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat24bppRGB:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_24bppRGB, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_24bppRGB, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppARGB1555);
        case PixelFormat32bppRGB:
            convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat32bppRGB:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_32bppRGB, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_32bppRGB, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_24bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat32bppARGB:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_32bppARGB, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_32bppARGB, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_24bppRGB);
        case PixelFormat32bppPARGB:
            convert_32bppARGB_to_32bppPARGB(width, height, dst_bits, dst_stride, src_bits, src_stride);
            return Ok;
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat32bppPARGB:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_32bppPARGB, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_32bppPARGB, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_32bppARGB);
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat48bppRGB:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_48bppRGB, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_48bppRGB, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppPARGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    case PixelFormat64bppARGB:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_64bppARGB, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_64bppARGB, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_48bppRGB);
        default:
            break;
        }
        break;
    case PixelFormat64bppPARGB:
        switch (dst_format)
        {
        case PixelFormat1bppIndexed:
            convert_rgb_to_indexed(getpixel_64bppPARGB, setpixel_1bppIndexed);
        case PixelFormat8bppIndexed:
            convert_rgb_to_indexed(getpixel_64bppPARGB, setpixel_8bppIndexed);
        case PixelFormat16bppGrayScale:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppGrayScale);
        case PixelFormat16bppRGB555:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppRGB555);
        case PixelFormat16bppRGB565:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppRGB565);
        case PixelFormat16bppARGB1555:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppARGB1555);
        case PixelFormat24bppRGB:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_24bppRGB);
        case PixelFormat32bppRGB:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppRGB);
        case PixelFormat32bppARGB:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppARGB);
        case PixelFormat32bppPARGB:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppPARGB);
        case PixelFormat48bppRGB:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_48bppRGB);
        case PixelFormat64bppARGB:
            convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_64bppARGB);
        default:
            break;
        }
        break;
    default:
        break;
    }
 
#undef convert_indexed_to_rgb
#undef convert_rgb_to_rgb
 
    return NotImplemented;
}

Referenced by GdipBitmapLockBits(), GdipBitmapUnlockBits(), GdipCloneBitmapArea(), GdipCreateHBITMAPFromBitmap(), and GdipDrawImagePointsRect().

◆ create_optimal_palette()

static GpStatus create_optimal_palette	(	ColorPalette *	palette,
		INT	desired,
		BOOL	transparent,
		GpBitmap *	bitmap
	)

static

Definition at line 5693 of file image.c.

{
    GpStatus status;
    BitmapData data;
    HRESULT hr;
    IWICImagingFactory *factory;
    IWICPalette *wic_palette;
 
    if (!bitmap) return InvalidParameter;
    if (palette->Count < desired) return GenericError;
 
    status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat24bppRGB, &data);
    if (status != Ok) return status;
 
    hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
    if (hr != S_OK)
    {
        GdipBitmapUnlockBits(bitmap, &data);
        return hresult_to_status(hr);
    }
 
    hr = IWICImagingFactory_CreatePalette(factory, &wic_palette);
    if (hr == S_OK)
    {
        IWICBitmap *bitmap;
 
        /* PixelFormat24bppRGB actually stores the bitmap bits as BGR. */
        hr = IWICImagingFactory_CreateBitmapFromMemory(factory, data.Width, data.Height,
                &GUID_WICPixelFormat24bppBGR, data.Stride, data.Stride * data.Width, data.Scan0, &bitmap);
        if (hr == S_OK)
        {
            hr = IWICPalette_InitializeFromBitmap(wic_palette, (IWICBitmapSource *)bitmap, desired, transparent);
            if (hr == S_OK)
            {
                palette->Flags = 0;
                IWICPalette_GetColorCount(wic_palette, &palette->Count);
                IWICPalette_GetColors(wic_palette, palette->Count, palette->Entries, &palette->Count);
            }
 
            IWICBitmap_Release(bitmap);
        }
 
        IWICPalette_Release(wic_palette);
    }
 
    IWICImagingFactory_Release(factory);
    GdipBitmapUnlockBits(bitmap, &data);
 
    return hresult_to_status(hr);
}

Referenced by GdipInitializePalette().

◆ create_prop()

static PropertyItem * create_prop	(	PROPID	propid,
		PROPVARIANT *	value
	)

static

Definition at line 3419 of file image.c.

{
    PropertyItem *item = NULL;
    UINT item_size = propvariant_size(value);
 
    if (item_size)
    {
        item_size += sizeof(*item);
        item = heap_alloc_zero(item_size);
        if (propvariant_to_item(value, item, item_size, propid) != Ok)
        {
            heap_free(item);
            item = NULL;
        }
    }
 
    return item;
}

Referenced by png_metadata_reader().

◆ decode_frame_wic()

static GpStatus decode_frame_wic	(	IWICBitmapDecoder *	decoder,
		BOOL	force_conversion,
		UINT	active_frame,
		metadata_reader_func	metadata_reader,
		GpImage **	image
	)

static

Definition at line 3632 of file image.c.

{
    GpStatus status=Ok;
    GpBitmap *bitmap;
    HRESULT hr;
    IWICBitmapFrameDecode *frame;
    IWICBitmapSource *source=NULL;
    IWICMetadataBlockReader *block_reader;
    WICPixelFormatGUID wic_format;
    PixelFormat gdip_format=0;
    ColorPalette *palette = NULL;
    WICBitmapPaletteType palette_type = WICBitmapPaletteTypeFixedHalftone256;
    int i;
    UINT width, height, frame_count;
    BitmapData lockeddata;
    WICRect wrc;
 
    TRACE("%p,%u,%p\n", decoder, active_frame, image);
 
    IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
    hr = IWICBitmapDecoder_GetFrame(decoder, active_frame, &frame);
    if (SUCCEEDED(hr)) /* got frame */
    {
        hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &wic_format);
 
        if (SUCCEEDED(hr))
        {
            if (!force_conversion)
            {
                for (i=0; pixel_formats[i].wic_format; i++)
                {
                    if (IsEqualGUID(&wic_format, pixel_formats[i].wic_format))
                    {
                        source = (IWICBitmapSource*)frame;
                        IWICBitmapSource_AddRef(source);
                        gdip_format = pixel_formats[i].gdip_format;
                        palette_type = pixel_formats[i].palette_type;
                        break;
                    }
                }
            }
            if (!source)
            {
                /* unknown format; fall back on 32bppARGB */
                hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, (IWICBitmapSource*)frame, &source);
                gdip_format = PixelFormat32bppARGB;
            }
            TRACE("%s => %#x\n", wine_dbgstr_guid(&wic_format), gdip_format);
        }
 
        if (SUCCEEDED(hr)) /* got source */
        {
            hr = IWICBitmapSource_GetSize(source, &width, &height);
 
            if (SUCCEEDED(hr))
                status = GdipCreateBitmapFromScan0(width, height, 0, gdip_format,
                    NULL, &bitmap);
 
            if (SUCCEEDED(hr) && status == Ok) /* created bitmap */
            {
                status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeWrite,
                    gdip_format, &lockeddata);
                if (status == Ok) /* locked bitmap */
                {
                    wrc.X = 0;
                    wrc.Width = width;
                    wrc.Height = 1;
                    for (i=0; i<height; i++)
                    {
                        wrc.Y = i;
                        hr = IWICBitmapSource_CopyPixels(source, &wrc, abs(lockeddata.Stride),
                            abs(lockeddata.Stride), (BYTE*)lockeddata.Scan0+lockeddata.Stride*i);
                        if (FAILED(hr)) break;
                    }
 
                    GdipBitmapUnlockBits(bitmap, &lockeddata);
                }
 
                if (SUCCEEDED(hr) && status == Ok)
                    *image = &bitmap->image;
                else
                {
                    *image = NULL;
                    GdipDisposeImage(&bitmap->image);
                }
 
                if (SUCCEEDED(hr) && status == Ok)
                {
                    double dpix, dpiy;
                    hr = IWICBitmapSource_GetResolution(source, &dpix, &dpiy);
                    if (SUCCEEDED(hr))
                    {
                        bitmap->image.xres = dpix;
                        bitmap->image.yres = dpiy;
                    }
                    hr = S_OK;
                }
            }
 
            IWICBitmapSource_Release(source);
        }
 
        if (SUCCEEDED(hr)) {
            bitmap->metadata_reader = NULL;
 
            if (metadata_reader)
                metadata_reader(bitmap, decoder, active_frame);
            else if (IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader) == S_OK)
            {
                UINT block_count = 0;
                if (IWICMetadataBlockReader_GetCount(block_reader, &block_count) == S_OK && block_count)
                    IWICMetadataBlockReader_GetReaderByIndex(block_reader, 0, &bitmap->metadata_reader);
                IWICMetadataBlockReader_Release(block_reader);
            }
 
            palette = get_palette(frame, palette_type);
            IWICBitmapFrameDecode_Release(frame);
        }
    }
 
    if (FAILED(hr) && status == Ok) status = hresult_to_status(hr);
 
    if (status == Ok)
    {
        /* Native GDI+ used to be smarter, but since Win7 it just sets these flags. */
        bitmap->image.flags |= ImageFlagsReadOnly|ImageFlagsHasRealPixelSize|ImageFlagsHasRealDPI;
        if (IsEqualGUID(&wic_format, &GUID_WICPixelFormat2bppGray) ||
            IsEqualGUID(&wic_format, &GUID_WICPixelFormat4bppGray) ||
            IsEqualGUID(&wic_format, &GUID_WICPixelFormat8bppGray) ||
            IsEqualGUID(&wic_format, &GUID_WICPixelFormat16bppGray))
            bitmap->image.flags |= ImageFlagsColorSpaceGRAY;
        else
            bitmap->image.flags |= ImageFlagsColorSpaceRGB;
        bitmap->image.frame_count = frame_count;
        bitmap->image.current_frame = active_frame;
        bitmap->image.decoder = decoder;
        IWICBitmapDecoder_AddRef(decoder);
        if (palette)
        {
            heap_free(bitmap->image.palette);
            bitmap->image.palette = palette;
        }
        else
        {
            if (IsEqualGUID(&wic_format, &GUID_WICPixelFormatBlackWhite))
                bitmap->image.palette->Flags = 0;
        }
        TRACE("=> %p\n", *image);
    }
 
    return status;
}

Referenced by decode_image_gif(), decode_image_png(), decode_image_wic(), and select_frame_wic().

◆ decode_image_bmp()

static GpStatus decode_image_bmp	(	IStream *	stream,
		GpImage **	image
	)

static

Definition at line 3983 of file image.c.

{
    GpStatus status;
    GpBitmap* bitmap;
 
    status = decode_image_wic(stream, &GUID_ContainerFormatBmp, NULL, image);
 
    bitmap = (GpBitmap*)*image;
 
    if (status == Ok && bitmap->format == PixelFormat32bppARGB)
    {
        /* WIC supports bmp files with alpha, but gdiplus does not */
        bitmap->format = PixelFormat32bppRGB;
    }
 
    return status;
}

◆ decode_image_emf()

static GpStatus decode_image_emf	(	IStream *	stream,
		GpImage **	image
	)

static

Definition at line 4234 of file image.c.

{
    GpMetafile *metafile;
    GpStatus status;
 
    TRACE("%p %p\n", stream, image);
 
    if (!stream || !image)
        return InvalidParameter;
 
    status = load_emf(stream, &metafile);
    if (status != Ok)
    {
        TRACE("Could not load metafile\n");
        return status;
    }
 
    *image = (GpImage *)metafile;
    TRACE("<-- %p\n", *image);
 
    return Ok;
}

◆ decode_image_gif()

static GpStatus decode_image_gif	(	IStream *	stream,
		GpImage **	image
	)

static

Definition at line 4082 of file image.c.

{
    IWICBitmapDecoder *decoder;
    UINT frame_count;
    GpStatus status;
    HRESULT hr;
 
    status = initialize_decoder_wic(stream, &GUID_ContainerFormatGif, &decoder);
    if(status != Ok)
        return status;
 
    hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
    if(FAILED(hr))
        return hresult_to_status(hr);
 
    status = decode_frame_wic(decoder, frame_count > 1, 0, gif_metadata_reader, image);
    IWICBitmapDecoder_Release(decoder);
    if(status != Ok)
        return status;
 
    if(frame_count > 1) {
        heap_free((*image)->palette);
        (*image)->palette = NULL;
    }
    return Ok;
}

◆ decode_image_icon()

static GpStatus decode_image_icon	(	IStream *	stream,
		GpImage **	image
	)

static

Definition at line 3978 of file image.c.

{
    return decode_image_wic(stream, &GUID_ContainerFormatIco, NULL, image);
}

◆ decode_image_jpeg()

static GpStatus decode_image_jpeg	(	IStream *	stream,
		GpImage **	image
	)

static

Definition at line 4001 of file image.c.

{
    return decode_image_wic(stream, &GUID_ContainerFormatJpeg, NULL, image);
}

◆ decode_image_png()

static GpStatus decode_image_png	(	IStream *	stream,
		GpImage **	image
	)

static

Definition at line 4039 of file image.c.

{
    IWICBitmapDecoder *decoder;
    IWICBitmapFrameDecode *frame;
    GpStatus status;
    HRESULT hr;
    GUID format;
    BOOL force_conversion = FALSE;
 
    status = initialize_decoder_wic(stream, &GUID_ContainerFormatPng, &decoder);
    if (status != Ok)
        return status;
 
    hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
    if (hr == S_OK)
    {
        hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
        if (hr == S_OK)
        {
            if (IsEqualGUID(&format, &GUID_WICPixelFormat8bppGray))
                force_conversion = TRUE;
            else if ((IsEqualGUID(&format, &GUID_WICPixelFormat8bppIndexed) ||
                      IsEqualGUID(&format, &GUID_WICPixelFormat4bppIndexed) ||
                      IsEqualGUID(&format, &GUID_WICPixelFormat2bppIndexed) ||
                      IsEqualGUID(&format, &GUID_WICPixelFormat1bppIndexed) ||
                      IsEqualGUID(&format, &GUID_WICPixelFormat24bppBGR)) &&
                     has_png_transparency_chunk(stream))
                force_conversion = TRUE;
 
            status = decode_frame_wic(decoder, force_conversion, 0, png_metadata_reader, image);
        }
        else
            status = hresult_to_status(hr);
 
        IWICBitmapFrameDecode_Release(frame);
    }
    else
        status = hresult_to_status(hr);
 
    IWICBitmapDecoder_Release(decoder);
    return status;
}

◆ decode_image_tiff()

static GpStatus decode_image_tiff	(	IStream *	stream,
		GpImage **	image
	)

static

Definition at line 4109 of file image.c.

{
    return decode_image_wic(stream, &GUID_ContainerFormatTiff, NULL, image);
}

◆ decode_image_wic()

static GpStatus decode_image_wic	(	IStream *	stream,
		REFGUID	container,
		metadata_reader_func	metadata_reader,
		GpImage **	image
	)

static

Definition at line 3786 of file image.c.

{
    IWICBitmapDecoder *decoder;
    GpStatus status;
 
    status = initialize_decoder_wic(stream, container, &decoder);
    if(status != Ok)
        return status;
 
    status = decode_frame_wic(decoder, FALSE, 0, metadata_reader, image);
    IWICBitmapDecoder_Release(decoder);
    return status;
}

Referenced by decode_image_bmp(), decode_image_icon(), decode_image_jpeg(), and decode_image_tiff().

◆ decode_image_wmf()

static GpStatus decode_image_wmf	(	IStream *	stream,
		GpImage **	image
	)

static

Definition at line 4172 of file image.c.

{
    GpMetafile *metafile;
    GpStatus status;
 
    TRACE("%p %p\n", stream, image);
 
    if (!stream || !image)
        return InvalidParameter;
 
    status = load_wmf(stream, &metafile);
    if (status != Ok)
    {
        TRACE("Could not load metafile\n");
        return status;
    }
 
    *image = (GpImage *)metafile;
    TRACE("<-- %p\n", *image);
 
    return Ok;
}

◆ encode_image_BMP()

static GpStatus encode_image_BMP	(	GpImage *	image,
		IStream *	stream,
		GDIPCONST EncoderParameters *	params
	)

static

Definition at line 4638 of file image.c.

{
    return encode_image_wic(image, stream, &GUID_ContainerFormatBmp, params);
}

◆ encode_image_gif()

static GpStatus encode_image_gif	(	GpImage *	image,
		IStream *	stream,
		GDIPCONST EncoderParameters *	params
	)

static

Definition at line 4662 of file image.c.

{
    return encode_image_wic(image, stream, &GUID_ContainerFormatGif, params);
}

◆ encode_image_jpeg()

static GpStatus encode_image_jpeg	(	GpImage *	image,
		IStream *	stream,
		GDIPCONST EncoderParameters *	params
	)

static

Definition at line 4656 of file image.c.

{
    return encode_image_wic(image, stream, &GUID_ContainerFormatJpeg, params);
}

◆ encode_image_png()

GpStatus encode_image_png	(	GpImage *	image,
		IStream *	stream,
		GDIPCONST EncoderParameters *	params
	)

Definition at line 4650 of file image.c.

{
    return encode_image_wic(image, stream, &GUID_ContainerFormatPng, params);
}

Referenced by METAFILE_CreateCompressedImageStream().

◆ encode_image_tiff()

static GpStatus encode_image_tiff	(	GpImage *	image,
		IStream *	stream,
		GDIPCONST EncoderParameters *	params
	)

static

Definition at line 4644 of file image.c.

{
    return encode_image_wic(image, stream, &GUID_ContainerFormatTiff, params);
}

◆ encode_image_wic()

static GpStatus encode_image_wic	(	GpImage *	image,
		IStream *	stream,
		REFGUID	container,
		GDIPCONST EncoderParameters *	params
	)

static

Definition at line 4503 of file image.c.

{
    GpStatus stat;
    GpBitmap *bitmap;
    IWICImagingFactory *factory;
    IWICBitmapEncoder *encoder;
    IWICBitmapFrameEncode *frameencode;
    IPropertyBag2 *encoderoptions;
    HRESULT hr;
    UINT width, height;
    PixelFormat gdipformat=0;
    const WICPixelFormatGUID *desired_wicformat;
    WICPixelFormatGUID wicformat;
    GpRect rc;
    BitmapData lockeddata;
    UINT i;
 
    if (image->type != ImageTypeBitmap)
        return GenericError;
 
    bitmap = (GpBitmap*)image;
 
    GdipGetImageWidth(image, &width);
    GdipGetImageHeight(image, &height);
 
    rc.X = 0;
    rc.Y = 0;
    rc.Width = width;
    rc.Height = height;
 
    hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
    if (FAILED(hr))
        return hresult_to_status(hr);
    hr = IWICImagingFactory_CreateEncoder(factory, container, NULL, &encoder);
    IWICImagingFactory_Release(factory);
    if (FAILED(hr))
        return hresult_to_status(hr);
 
    hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
 
    if (SUCCEEDED(hr))
    {
        hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frameencode, &encoderoptions);
    }
 
    if (SUCCEEDED(hr)) /* created frame */
    {
        hr = IWICBitmapFrameEncode_Initialize(frameencode, encoderoptions);
 
        if (SUCCEEDED(hr))
            hr = IWICBitmapFrameEncode_SetSize(frameencode, width, height);
 
        if (SUCCEEDED(hr))
            hr = IWICBitmapFrameEncode_SetResolution(frameencode, image->xres, image->yres);
 
        if (SUCCEEDED(hr))
        {
            for (i=0; pixel_formats[i].wic_format; i++)
            {
                if (pixel_formats[i].gdip_format == bitmap->format)
                {
                    desired_wicformat = pixel_formats[i].wic_format;
                    gdipformat = bitmap->format;
                    break;
                }
            }
            if (!gdipformat)
            {
                desired_wicformat = &GUID_WICPixelFormat32bppBGRA;
                gdipformat = PixelFormat32bppARGB;
            }
 
            memcpy(&wicformat, desired_wicformat, sizeof(GUID));
            hr = IWICBitmapFrameEncode_SetPixelFormat(frameencode, &wicformat);
        }
 
        if (SUCCEEDED(hr) && !IsEqualGUID(desired_wicformat, &wicformat))
        {
            /* Encoder doesn't support this bitmap's format. */
            gdipformat = 0;
            for (i=0; pixel_formats[i].wic_format; i++)
            {
                if (IsEqualGUID(&wicformat, pixel_formats[i].wic_format))
                {
                    gdipformat = pixel_formats[i].gdip_format;
                    break;
                }
            }
            if (!gdipformat)
            {
                ERR("Cannot support encoder format %s\n", debugstr_guid(&wicformat));
                hr = E_FAIL;
            }
        }
 
        if (SUCCEEDED(hr))
        {
            stat = GdipBitmapLockBits(bitmap, &rc, ImageLockModeRead, gdipformat,
                &lockeddata);
 
            if (stat == Ok)
            {
                UINT row_size = (lockeddata.Width * PIXELFORMATBPP(gdipformat) + 7)/8;
                BYTE *row;
 
                /* write one row at a time in case stride is negative */
                row = lockeddata.Scan0;
                for (i=0; i<lockeddata.Height; i++)
                {
                    hr = IWICBitmapFrameEncode_WritePixels(frameencode, 1, row_size, row_size, row);
                    if (FAILED(hr)) break;
                    row += lockeddata.Stride;
                }
 
                GdipBitmapUnlockBits(bitmap, &lockeddata);
            }
            else
                hr = E_FAIL;
        }
 
        if (SUCCEEDED(hr))
            hr = IWICBitmapFrameEncode_Commit(frameencode);
 
        IWICBitmapFrameEncode_Release(frameencode);
        IPropertyBag2_Release(encoderoptions);
    }
 
    if (SUCCEEDED(hr))
        hr = IWICBitmapEncoder_Commit(encoder);
 
    IWICBitmapEncoder_Release(encoder);
    return hresult_to_status(hr);
}

Referenced by encode_image_BMP(), encode_image_gif(), encode_image_jpeg(), encode_image_png(), and encode_image_tiff().

◆ free_image_data()

static GpStatus free_image_data ( GpImage * image )

static

Definition at line 2126 of file image.c.

{
    if(!image)
        return InvalidParameter;
 
    if (image->type == ImageTypeBitmap)
    {
        heap_free(((GpBitmap*)image)->bitmapbits);
        heap_free(((GpBitmap*)image)->own_bits);
        DeleteDC(((GpBitmap*)image)->hdc);
        DeleteObject(((GpBitmap*)image)->hbitmap);
        if (((GpBitmap*)image)->metadata_reader)
            IWICMetadataReader_Release(((GpBitmap*)image)->metadata_reader);
        heap_free(((GpBitmap*)image)->prop_item);
    }
    else if (image->type == ImageTypeMetafile)
        METAFILE_Free((GpMetafile *)image);
    else
    {
        WARN("invalid image: %p\n", image);
        return ObjectBusy;
    }
    if (image->decoder)
        IWICBitmapDecoder_Release(image->decoder);
    heap_free(image->palette);
 
    return Ok;
}

Referenced by GdipDisposeImage(), and select_frame_wic().

◆ GdipBitmapApplyEffect()

GpStatus WINGDIPAPI GdipBitmapApplyEffect	(	GpBitmap *	bitmap,
		CGpEffect *	effect,
		RECT *	roi,
		BOOL	useAuxData,
		VOID **	auxData,
		INT *	auxDataSize
	)

Definition at line 134 of file image.c.

{
    FIXME("(%p %p %p %d %p %p): stub\n", bitmap, effect, roi, useAuxData, auxData, auxDataSize);
    /*
     * Note: According to Jose Roca's GDI+ docs, this function is not
     * implemented in Windows's GDI+.
     */
    return NotImplemented;
}

◆ GdipBitmapConvertFormat()

GpStatus WINGDIPAPI GdipBitmapConvertFormat	(	GpBitmap *	bitmap,
		PixelFormat	format,
		DitherType	dithertype,
		PaletteType	palettetype,
		ColorPalette *	palette,
		REAL	alphathreshold
	)

Definition at line 5549 of file image.c.

{
    FIXME("(%p, 0x%08x, %d, %d, %p, %f): stub\n", bitmap, format, dithertype, palettetype, palette, alphathreshold);
    return NotImplemented;
}

◆ GdipBitmapCreateApplyEffect()

GpStatus WINGDIPAPI GdipBitmapCreateApplyEffect	(	GpBitmap **	inputBitmaps,
		INT	numInputs,
		CGpEffect *	effect,
		RECT *	roi,
		RECT *	outputRect,
		GpBitmap **	outputBitmap,
		BOOL	useAuxData,
		VOID **	auxData,
		INT *	auxDataSize
	)

Definition at line 145 of file image.c.

{
    FIXME("(%p %d %p %p %p %p %d %p %p): stub\n", inputBitmaps, numInputs, effect, roi, outputRect, outputBitmap, useAuxData, auxData, auxDataSize);
    /*
     * Note: According to Jose Roca's GDI+ docs, this function is not
     * implemented in Windows's GDI+.
     */
    return NotImplemented;
}

◆ GdipBitmapGetHistogram()

GpStatus WINGDIPAPI GdipBitmapGetHistogram	(	GpBitmap *	bitmap,
		HistogramFormat	format,
		UINT	num_of_entries,
		UINT *	ch0,
		UINT *	ch1,
		UINT *	ch2,
		UINT *	ch3
	)

Definition at line 5609 of file image.c.

{
    static void (* const set_histogram_point[])(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3) =
    {
        set_histogram_point_argb,
        set_histogram_point_pargb,
        set_histogram_point_rgb,
        set_histogram_point_gray,
        set_histogram_point_b,
        set_histogram_point_g,
        set_histogram_point_r,
        set_histogram_point_a,
    };
    UINT width, height, x, y;
 
    TRACE("(%p, %d, %u, %p, %p, %p, %p)\n", bitmap, format, num_of_entries,
        ch0, ch1, ch2, ch3);
 
    if (!bitmap || num_of_entries != 256)
        return InvalidParameter;
 
    /* Make sure passed channel pointers match requested format */
    switch (format)
    {
    case HistogramFormatARGB:
    case HistogramFormatPARGB:
        if (!ch0 || !ch1 || !ch2 || !ch3)
            return InvalidParameter;
        memset(ch0, 0, num_of_entries * sizeof(UINT));
        memset(ch1, 0, num_of_entries * sizeof(UINT));
        memset(ch2, 0, num_of_entries * sizeof(UINT));
        memset(ch3, 0, num_of_entries * sizeof(UINT));
        break;
    case HistogramFormatRGB:
        if (!ch0 || !ch1 || !ch2 || ch3)
            return InvalidParameter;
        memset(ch0, 0, num_of_entries * sizeof(UINT));
        memset(ch1, 0, num_of_entries * sizeof(UINT));
        memset(ch2, 0, num_of_entries * sizeof(UINT));
        break;
    case HistogramFormatGray:
    case HistogramFormatB:
    case HistogramFormatG:
    case HistogramFormatR:
    case HistogramFormatA:
        if (!ch0 || ch1 || ch2 || ch3)
            return InvalidParameter;
        memset(ch0, 0, num_of_entries * sizeof(UINT));
        break;
    default:
        WARN("Invalid histogram format requested, %d\n", format);
        return InvalidParameter;
    }
 
    GdipGetImageWidth(&bitmap->image, &width);
    GdipGetImageHeight(&bitmap->image, &height);
 
    for (y = 0; y < height; y++)
        for (x = 0; x < width; x++)
        {
            ARGB color;
 
            GdipBitmapGetPixel(bitmap, x, y, &color);
            set_histogram_point[format](color, ch0, ch1, ch2, ch3);
        }
 
    return Ok;
}

◆ GdipBitmapGetHistogramSize()

GpStatus WINGDIPAPI GdipBitmapGetHistogramSize	(	HistogramFormat	format,
		UINT *	num_of_entries
	)

Definition at line 5682 of file image.c.

{
    TRACE("(%d, %p)\n", format, num_of_entries);
 
    if (!num_of_entries)
        return InvalidParameter;
 
    *num_of_entries = 256;
    return Ok;
}

◆ GdipBitmapGetPixel()

GpStatus WINGDIPAPI GdipBitmapGetPixel	(	GpBitmap *	bitmap,
		INT	x,
		INT	y,
		ARGB *	color
	)

Definition at line 288 of file image.c.

{
    BYTE r, g, b, a;
    BYTE index;
    BYTE *row;
 
    if(!bitmap || !color ||
       x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
        return InvalidParameter;
 
    row = bitmap->bits+bitmap->stride*y;
 
    switch (bitmap->format)
    {
        case PixelFormat1bppIndexed:
            getpixel_1bppIndexed(&index,row,x);
            break;
        case PixelFormat4bppIndexed:
            getpixel_4bppIndexed(&index,row,x);
            break;
        case PixelFormat8bppIndexed:
            getpixel_8bppIndexed(&index,row,x);
            break;
        case PixelFormat16bppGrayScale:
            getpixel_16bppGrayScale(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat16bppRGB555:
            getpixel_16bppRGB555(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat16bppRGB565:
            getpixel_16bppRGB565(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat16bppARGB1555:
            getpixel_16bppARGB1555(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat24bppRGB:
            getpixel_24bppRGB(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat32bppRGB:
            getpixel_32bppRGB(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat32bppARGB:
            getpixel_32bppARGB(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat32bppPARGB:
            getpixel_32bppPARGB(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat48bppRGB:
            getpixel_48bppRGB(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat64bppARGB:
            getpixel_64bppARGB(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat64bppPARGB:
            getpixel_64bppPARGB(&r,&g,&b,&a,row,x);
            break;
        default:
            FIXME("not implemented for format 0x%x\n", bitmap->format);
            return NotImplemented;
    }
 
    if (bitmap->format & PixelFormatIndexed)
        *color = bitmap->image.palette->Entries[index];
    else
        *color = a<<24|r<<16|g<<8|b;
 
    return Ok;
}

Referenced by alpha_blend_bmp_pixels(), GdipBitmapGetHistogram(), test_clear(), test_clipping(), test_colorkey(), test_colormatrix(), test_containers(), test_emfonly(), test_fillrect(), test_gamma(), test_GdipFillRectanglesOnBitmapTextureBrush(), test_GdipImageGetFrameDimensionsCount(), test_gditransform(), test_getdc(), test_getdc_scaled(), test_getsetpixel(), test_LockBits(), test_LockBits_UserBuf(), test_multiframegif(), test_pagetransform(), test_palette(), test_remaptable(), test_rotateflip(), and test_worldtransform().

◆ GdipBitmapLockBits()

GpStatus WINGDIPAPI GdipBitmapLockBits	(	GpBitmap *	bitmap,
		GDIPCONST GpRect *	rect,
		UINT	flags,
		PixelFormat	format,
		BitmapData *	lockeddata
	)

Definition at line 1030 of file image.c.

{
    INT bitspp = PIXELFORMATBPP(format);
    GpRect act_rect; /* actual rect to be used */
    GpStatus stat;
    BOOL unlock;
 
    TRACE("%p %p %d 0x%x %p\n", bitmap, rect, flags, format, lockeddata);
 
    if(!lockeddata || !bitmap)
        return InvalidParameter;
    if(!image_lock(&bitmap->image, &unlock))
        return ObjectBusy;
 
    if(rect){
        if(rect->X < 0 || rect->Y < 0 || (rect->X + rect->Width > bitmap->width) ||
          (rect->Y + rect->Height > bitmap->height) || !flags)
        {
            image_unlock(&bitmap->image, unlock);
            return InvalidParameter;
        }
 
        act_rect = *rect;
    }
    else{
        act_rect.X = act_rect.Y = 0;
        act_rect.Width  = bitmap->width;
        act_rect.Height = bitmap->height;
    }
 
    if(bitmap->lockmode)
    {
        WARN("bitmap is already locked and cannot be locked again\n");
        image_unlock(&bitmap->image, unlock);
        return WrongState;
    }
 
    if (bitmap->bits && bitmap->format == format && !(flags & ImageLockModeUserInputBuf))
    {
        /* no conversion is necessary; just use the bits directly */
        lockeddata->Width = act_rect.Width;
        lockeddata->Height = act_rect.Height;
        lockeddata->PixelFormat = format;
        lockeddata->Reserved = flags;
        lockeddata->Stride = bitmap->stride;
        lockeddata->Scan0 = bitmap->bits + (bitspp / 8) * act_rect.X +
                            bitmap->stride * act_rect.Y;
 
        bitmap->lockmode = flags | ImageLockModeRead;
 
        image_unlock(&bitmap->image, unlock);
        return Ok;
    }
 
    /* Make sure we can convert to the requested format. */
    if (flags & ImageLockModeRead)
    {
        stat = convert_pixels(0, 0, 0, NULL, format, 0, NULL, bitmap->format, NULL);
        if (stat == NotImplemented)
        {
            FIXME("cannot read bitmap from %x to %x\n", bitmap->format, format);
            image_unlock(&bitmap->image, unlock);
            return NotImplemented;
        }
    }
 
    /* If we're opening for writing, make sure we'll be able to write back in
     * the original format. */
    if (flags & ImageLockModeWrite)
    {
        stat = convert_pixels(0, 0, 0, NULL, bitmap->format, 0, NULL, format, NULL);
        if (stat == NotImplemented)
        {
            FIXME("cannot write bitmap from %x to %x\n", format, bitmap->format);
            image_unlock(&bitmap->image, unlock);
            return NotImplemented;
        }
    }
 
    lockeddata->Width  = act_rect.Width;
    lockeddata->Height = act_rect.Height;
    lockeddata->PixelFormat = format;
    lockeddata->Reserved = flags;
 
    if(!(flags & ImageLockModeUserInputBuf))
    {
        lockeddata->Stride = (((act_rect.Width * bitspp + 7) / 8) + 3) & ~3;
 
        bitmap->bitmapbits = heap_alloc_zero(lockeddata->Stride * act_rect.Height);
 
        if (!bitmap->bitmapbits)
        {
            image_unlock(&bitmap->image, unlock);
            return OutOfMemory;
        }
 
        lockeddata->Scan0  = bitmap->bitmapbits;
    }
 
    if (flags & ImageLockModeRead)
    {
        static BOOL fixme = FALSE;
 
        if (!fixme && (PIXELFORMATBPP(bitmap->format) * act_rect.X) % 8 != 0)
        {
            FIXME("Cannot copy rows that don't start at a whole byte.\n");
            fixme = TRUE;
        }
 
        stat = convert_pixels(act_rect.Width, act_rect.Height,
            lockeddata->Stride, lockeddata->Scan0, format,
            bitmap->stride,
            bitmap->bits + bitmap->stride * act_rect.Y + PIXELFORMATBPP(bitmap->format) * act_rect.X / 8,
            bitmap->format, bitmap->image.palette);
 
        if (stat != Ok)
        {
            heap_free(bitmap->bitmapbits);
            bitmap->bitmapbits = NULL;
            image_unlock(&bitmap->image, unlock);
            return stat;
        }
    }
 
    bitmap->lockmode = flags | ImageLockModeRead;
    bitmap->lockx = act_rect.X;
    bitmap->locky = act_rect.Y;
 
    image_unlock(&bitmap->image, unlock);
    return Ok;
}

Referenced by brush_fill_pixels(), create_optimal_palette(), decode_frame_wic(), DibLoadImage(), encode_image_wic(), GdipCreateBitmapFromHBITMAP(), GdipCreateBitmapFromHICON(), GdipCreateHICONFromBitmap(), GdipDrawImagePointsRect(), GdipImageRotateFlip(), test_ARGB_conversion(), test_bitmapbits(), test_CloneBitmapArea(), test_createhbitmap(), test_image_format(), test_LockBits(), test_LockBits_UserBuf(), and test_pen_thickness().

◆ GdipBitmapSetPixel()

GpStatus WINGDIPAPI GdipBitmapSetPixel	(	GpBitmap *	bitmap,
		INT	x,
		INT	y,
		ARGB	color
	)

Definition at line 494 of file image.c.

{
    BYTE a, r, g, b;
    BYTE *row;
 
    if(!bitmap || x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
        return InvalidParameter;
 
    a = color>>24;
    r = color>>16;
    g = color>>8;
    b = color;
 
    row = bitmap->bits + bitmap->stride * y;
 
    switch (bitmap->format)
    {
        case PixelFormat16bppGrayScale:
            setpixel_16bppGrayScale(r,g,b,a,row,x);
            break;
        case PixelFormat16bppRGB555:
            setpixel_16bppRGB555(r,g,b,a,row,x);
            break;
        case PixelFormat16bppRGB565:
            setpixel_16bppRGB565(r,g,b,a,row,x);
            break;
        case PixelFormat16bppARGB1555:
            setpixel_16bppARGB1555(r,g,b,a,row,x);
            break;
        case PixelFormat24bppRGB:
            setpixel_24bppRGB(r,g,b,a,row,x);
            break;
        case PixelFormat32bppRGB:
            setpixel_32bppRGB(r,g,b,a,row,x);
            break;
        case PixelFormat32bppARGB:
            setpixel_32bppARGB(r,g,b,a,row,x);
            break;
        case PixelFormat32bppPARGB:
            setpixel_32bppPARGB(r,g,b,a,row,x);
            break;
        case PixelFormat48bppRGB:
            setpixel_48bppRGB(r,g,b,a,row,x);
            break;
        case PixelFormat64bppARGB:
            setpixel_64bppARGB(r,g,b,a,row,x);
            break;
        case PixelFormat64bppPARGB:
            setpixel_64bppPARGB(r,g,b,a,row,x);
            break;
        case PixelFormat8bppIndexed:
            setpixel_8bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
            break;
        case PixelFormat4bppIndexed:
            setpixel_4bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
            break;
        case PixelFormat1bppIndexed:
            setpixel_1bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
            break;
        default:
            FIXME("not implemented for format 0x%x\n", bitmap->format);
            return NotImplemented;
    }
 
    return Ok;
}

Referenced by alpha_blend_bmp_pixels(), test_colorkey(), test_colormatrix(), test_emfonly(), test_fillrect(), test_gamma(), test_GdipCreateBitmapFromHBITMAP(), test_GdipImageGetFrameDimensionsCount(), test_getdc(), test_getsetpixel(), test_histogram(), test_LockBits(), test_multiframegif(), test_palette(), and test_remaptable().

◆ GdipBitmapSetResolution()

GpStatus WINGDIPAPI GdipBitmapSetResolution	(	GpBitmap *	bitmap,
		REAL	xdpi,
		REAL	ydpi
	)

Definition at line 1163 of file image.c.

{
    TRACE("(%p, %.2f, %.2f)\n", bitmap, xdpi, ydpi);
 
    if (!bitmap || xdpi == 0.0 || ydpi == 0.0)
        return InvalidParameter;
 
    bitmap->image.xres = xdpi;
    bitmap->image.yres = ydpi;
 
    return Ok;
}

Referenced by create_graphics(), test_DrawImage(), test_DrawImage_scale(), test_GdipDrawImagePointRect(), test_pen_thickness(), and test_resolution().

◆ GdipBitmapUnlockBits()

GpStatus WINGDIPAPI GdipBitmapUnlockBits	(	GpBitmap *	bitmap,
		BitmapData *	lockeddata
	)

Definition at line 1176 of file image.c.

{
    GpStatus stat;
    static BOOL fixme = FALSE;
    BOOL unlock;
 
    TRACE("(%p,%p)\n", bitmap, lockeddata);
 
    if(!bitmap || !lockeddata)
        return InvalidParameter;
    if(!image_lock(&bitmap->image, &unlock))
        return ObjectBusy;
 
    if(!bitmap->lockmode)
    {
        image_unlock(&bitmap->image, unlock);
        return WrongState;
    }
 
    if(!(lockeddata->Reserved & ImageLockModeWrite)){
        bitmap->lockmode = 0;
        heap_free(bitmap->bitmapbits);
        bitmap->bitmapbits = NULL;
        image_unlock(&bitmap->image, unlock);
        return Ok;
    }
 
    if (!bitmap->bitmapbits && !(lockeddata->Reserved & ImageLockModeUserInputBuf))
    {
        /* we passed a direct reference; no need to do anything */
        bitmap->lockmode = 0;
        image_unlock(&bitmap->image, unlock);
        return Ok;
    }
 
    if (!fixme && (PIXELFORMATBPP(bitmap->format) * bitmap->lockx) % 8 != 0)
    {
        FIXME("Cannot copy rows that don't start at a whole byte.\n");
        fixme = TRUE;
    }
 
    stat = convert_pixels(lockeddata->Width, lockeddata->Height,
        bitmap->stride,
        bitmap->bits + bitmap->stride * bitmap->locky + PIXELFORMATBPP(bitmap->format) * bitmap->lockx / 8,
        bitmap->format,
        lockeddata->Stride, lockeddata->Scan0, lockeddata->PixelFormat, NULL);
 
    if (stat != Ok)
    {
        ERR("failed to convert pixels; this should never happen\n");
    }
 
    heap_free(bitmap->bitmapbits);
    bitmap->bitmapbits = NULL;
    bitmap->lockmode = 0;
 
    image_unlock(&bitmap->image, unlock);
    return stat;
}

Referenced by brush_fill_pixels(), create_optimal_palette(), decode_frame_wic(), DibLoadImage(), encode_image_wic(), GdipCreateBitmapFromHBITMAP(), GdipCreateBitmapFromHICON(), GdipCreateHICONFromBitmap(), GdipDrawImagePointsRect(), GdipImageRotateFlip(), test_ARGB_conversion(), test_bitmapbits(), test_CloneBitmapArea(), test_createhbitmap(), test_image_format(), test_LockBits(), test_LockBits_UserBuf(), and test_pen_thickness().

◆ GdipCloneBitmapArea()

GpStatus WINGDIPAPI GdipCloneBitmapArea	(	REAL	x,
		REAL	y,
		REAL	width,
		REAL	height,
		PixelFormat	format,
		GpBitmap *	srcBitmap,
		GpBitmap **	dstBitmap
	)

Definition at line 1237 of file image.c.

{
    Rect area;
    GpStatus stat;
 
    TRACE("(%f,%f,%f,%f,0x%x,%p,%p)\n", x, y, width, height, format, srcBitmap, dstBitmap);
 
    if (!srcBitmap || !dstBitmap || srcBitmap->image.type != ImageTypeBitmap ||
        x < 0 || y < 0 ||
        x + width > srcBitmap->width || y + height > srcBitmap->height)
    {
        TRACE("<-- InvalidParameter\n");
        return InvalidParameter;
    }
 
    if (format == PixelFormatDontCare)
        format = srcBitmap->format;
 
    area.X = gdip_round(x);
    area.Y = gdip_round(y);
    area.Width = gdip_round(width);
    area.Height = gdip_round(height);
 
    stat = GdipCreateBitmapFromScan0(area.Width, area.Height, 0, format, NULL, dstBitmap);
    if (stat == Ok)
    {
        stat = convert_pixels(area.Width, area.Height, (*dstBitmap)->stride, (*dstBitmap)->bits, (*dstBitmap)->format,
                              srcBitmap->stride,
                              srcBitmap->bits + srcBitmap->stride * area.Y + PIXELFORMATBPP(srcBitmap->format) * area.X / 8,
                              srcBitmap->format, srcBitmap->image.palette);
 
        if (stat == Ok && srcBitmap->image.palette)
        {
            ColorPalette *src_palette, *dst_palette;
 
            src_palette = srcBitmap->image.palette;
 
            dst_palette = heap_alloc_zero(sizeof(UINT) * 2 + sizeof(ARGB) * src_palette->Count);
 
            if (dst_palette)
            {
                dst_palette->Flags = src_palette->Flags;
                dst_palette->Count = src_palette->Count;
                memcpy(dst_palette->Entries, src_palette->Entries, sizeof(ARGB) * src_palette->Count);
 
                heap_free((*dstBitmap)->image.palette);
                (*dstBitmap)->image.palette = dst_palette;
            }
            else
                stat = OutOfMemory;
        }
 
        if (stat != Ok)
            GdipDisposeImage(&(*dstBitmap)->image);
    }
 
    if (stat != Ok)
        *dstBitmap = NULL;
 
    return stat;
}

Referenced by GdipCloneBitmapAreaI(), and GdipCreateTextureIA().

◆ GdipCloneBitmapAreaI()

GpStatus WINGDIPAPI GdipCloneBitmapAreaI	(	INT	x,
		INT	y,
		INT	width,
		INT	height,
		PixelFormat	format,
		GpBitmap *	srcBitmap,
		GpBitmap **	dstBitmap
	)

Definition at line 1300 of file image.c.

{
    TRACE("(%i,%i,%i,%i,0x%x,%p,%p)\n", x, y, width, height, format, srcBitmap, dstBitmap);
 
    return GdipCloneBitmapArea(x, y, width, height, format, srcBitmap, dstBitmap);
}

Referenced by GdipCloneImage(), and test_CloneBitmapArea().

◆ GdipCloneImage()

GpStatus WINGDIPAPI GdipCloneImage	(	GpImage *	image,
		GpImage **	cloneImage
	)

Definition at line 1308 of file image.c.

{
    TRACE("%p, %p\n", image, cloneImage);
 
    if (!image || !cloneImage)
        return InvalidParameter;
 
    if (image->type == ImageTypeBitmap)
    {
        GpBitmap *bitmap = (GpBitmap *)image;
 
        return GdipCloneBitmapAreaI(0, 0, bitmap->width, bitmap->height,
                                    bitmap->format, bitmap, (GpBitmap **)cloneImage);
    }
    else if (image->type == ImageTypeMetafile && ((GpMetafile*)image)->hemf)
    {
        GpMetafile *result, *metafile;
 
        metafile = (GpMetafile*)image;
 
        result = heap_alloc_zero(sizeof(*result));
        if (!result)
            return OutOfMemory;
 
        result->image.type = ImageTypeMetafile;
        result->image.format = image->format;
        result->image.flags = image->flags;
        result->image.frame_count = 1;
        result->image.xres = image->xres;
        result->image.yres = image->yres;
        result->bounds = metafile->bounds;
        result->unit = metafile->unit;
        result->metafile_type = metafile->metafile_type;
        result->hemf = CopyEnhMetaFileW(metafile->hemf, NULL);
        list_init(&result->containers);
 
        if (!result->hemf)
        {
            heap_free(result);
            return OutOfMemory;
        }
 
        *cloneImage = &result->image;
        return Ok;
    }
    else
    {
        WARN("GpImage with no image data (metafile in wrong state?)\n");
        return InvalidParameter;
    }
}

Referenced by GdipCreateCachedBitmap(), GdipGetTextureImage(), load_image(), sync_metafile(), test_emfonly(), and test_GdipCloneImage().

◆ GdipCreateBitmapFromFile()

GpStatus WINGDIPAPI GdipCreateBitmapFromFile	(	GDIPCONST WCHAR *	filename,
		GpBitmap **	bitmap
	)

Definition at line 1360 of file image.c.

{
    GpStatus stat;
    IStream *stream;
 
    TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
 
    if(!filename || !bitmap)
        return InvalidParameter;
 
    *bitmap = NULL;
 
    stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
 
    if(stat != Ok)
        return stat;
 
    stat = GdipCreateBitmapFromStream(stream, bitmap);
 
    IStream_Release(stream);
 
    return stat;
}

Referenced by DibLoadImage(), GdipCreateBitmapFromFileICM(), and test_LoadingImages().

◆ GdipCreateBitmapFromFileICM()

GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM	(	GDIPCONST WCHAR *	filename,
		GpBitmap **	bitmap
	)

Definition at line 1436 of file image.c.

{
    TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
 
    return GdipCreateBitmapFromFile(filename, bitmap);
}

◆ GdipCreateBitmapFromGdiDib()

GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib	(	GDIPCONST BITMAPINFO *	info,
		VOID *	bits,
		GpBitmap **	bitmap
	)

Definition at line 1385 of file image.c.

{
    DWORD height, stride;
    PixelFormat format;
 
    FIXME("(%p, %p, %p) - partially implemented\n", info, bits, bitmap);
 
    if (!info || !bits || !bitmap)
        return InvalidParameter;
 
    height = abs(info->bmiHeader.biHeight);
    stride = ((info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) >> 3) & ~3;
 
    if(info->bmiHeader.biHeight > 0) /* bottom-up */
    {
        bits = (BYTE*)bits + (height - 1) * stride;
        stride = -stride;
    }
 
    switch(info->bmiHeader.biBitCount) {
    case 1:
        format = PixelFormat1bppIndexed;
        break;
    case 4:
        format = PixelFormat4bppIndexed;
        break;
    case 8:
        format = PixelFormat8bppIndexed;
        break;
    case 16:
        format = PixelFormat16bppRGB555;
        break;
    case 24:
        format = PixelFormat24bppRGB;
        break;
    case 32:
        format = PixelFormat32bppRGB;
        break;
    default:
        FIXME("don't know how to handle %d bpp\n", info->bmiHeader.biBitCount);
        *bitmap = NULL;
        return InvalidParameter;
    }
 
    return GdipCreateBitmapFromScan0(info->bmiHeader.biWidth, height, stride, format,
                                     bits, bitmap);
 
}

Referenced by test_drawimage(), test_FromGdiDib(), and test_GdipDrawImagePointsRect().

◆ GdipCreateBitmapFromGraphics()

GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics	(	INT	width,
		INT	height,
		GpGraphics *	target,
		GpBitmap **	bitmap
	)

Definition at line 1542 of file image.c.

{
    GpStatus ret;
 
    TRACE("(%d, %d, %p, %p)\n", width, height, target, bitmap);
 
    if(!target || !bitmap)
        return InvalidParameter;
 
    ret = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppPARGB,
                                    NULL, bitmap);
 
    if (ret == Ok)
    {
        GdipGetDpiX(target, &(*bitmap)->image.xres);
        GdipGetDpiY(target, &(*bitmap)->image.yres);
    }
 
    return ret;
}

Referenced by test_bitmapfromgraphics(), test_texturewrap(), and test_transform().

◆ GdipCreateBitmapFromHBITMAP()

GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP	(	HBITMAP	hbm,
		HPALETTE	hpal,
		GpBitmap **	bitmap
	)

Definition at line 5152 of file image.c.

{
    BITMAP bm;
    GpStatus retval;
    PixelFormat format;
    BitmapData lockeddata;
 
    TRACE("%p %p %p\n", hbm, hpal, bitmap);
 
    if(!hbm || !bitmap)
        return InvalidParameter;
 
    if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
            return InvalidParameter;
 
    /* TODO: Figure out the correct format for 16, 32, 64 bpp */
    switch(bm.bmBitsPixel) {
        case 1:
            format = PixelFormat1bppIndexed;
            break;
        case 4:
            format = PixelFormat4bppIndexed;
            break;
        case 8:
            format = PixelFormat8bppIndexed;
            break;
        case 16:
            format = get_16bpp_format(hbm);
            if (format == PixelFormatUndefined)
                return InvalidParameter;
            break;
        case 24:
            format = PixelFormat24bppRGB;
            break;
        case 32:
            format = PixelFormat32bppRGB;
            break;
        case 48:
            format = PixelFormat48bppRGB;
            break;
        default:
            FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
            return InvalidParameter;
    }
 
    retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, 0,
        format, NULL, bitmap);
 
    if (retval == Ok)
    {
        retval = GdipBitmapLockBits(*bitmap, NULL, ImageLockModeWrite,
            format, &lockeddata);
        if (retval == Ok)
        {
            HDC hdc;
            char bmibuf[FIELD_OFFSET(BITMAPINFO, bmiColors) + 256 * sizeof(RGBQUAD)];
            BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
            INT src_height;
 
            hdc = CreateCompatibleDC(NULL);
 
            pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
            pbmi->bmiHeader.biBitCount = 0;
 
            GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
 
            src_height = abs(pbmi->bmiHeader.biHeight);
            pbmi->bmiHeader.biHeight = -src_height;
 
            GetDIBits(hdc, hbm, 0, src_height, lockeddata.Scan0, pbmi, DIB_RGB_COLORS);
 
            DeleteDC(hdc);
 
            GdipBitmapUnlockBits(*bitmap, &lockeddata);
        }
 
        if (retval == Ok && hpal)
        {
            PALETTEENTRY entry[256];
            ColorPalette *palette=NULL;
            int i, num_palette_entries;
 
            num_palette_entries = GetPaletteEntries(hpal, 0, 256, entry);
            if (!num_palette_entries)
                retval = GenericError;
 
            palette = heap_alloc_zero(sizeof(ColorPalette) + sizeof(ARGB) * (num_palette_entries-1));
            if (!palette)
                retval = OutOfMemory;
 
            if (retval == Ok)
            {
                palette->Flags = 0;
                palette->Count = num_palette_entries;
 
                for (i=0; i<num_palette_entries; i++)
                {
                    palette->Entries[i] = 0xff000000 | entry[i].peRed << 16 |
                                          entry[i].peGreen << 8 | entry[i].peBlue;
                }
 
                retval = GdipSetImagePalette(&(*bitmap)->image, palette);
            }
 
            heap_free(palette);
        }
 
        if (retval != Ok)
        {
            GdipDisposeImage(&(*bitmap)->image);
            *bitmap = NULL;
        }
    }
 
    return retval;
}

Referenced by GdipCreateBitmapFromResource(), GdipCreateBitmapFromStream(), and test_GdipCreateBitmapFromHBITMAP().

◆ GdipCreateBitmapFromHICON()

GpStatus WINGDIPAPI GdipCreateBitmapFromHICON	(	HICON	hicon,
		GpBitmap **	bitmap
	)

Definition at line 1564 of file image.c.

{
    GpStatus stat;
    ICONINFO iinfo;
    BITMAP bm;
    int ret;
    UINT width, height, stride;
    GpRect rect;
    BitmapData lockeddata;
    HDC screendc;
    BOOL has_alpha;
    int x, y;
    BITMAPINFOHEADER bih;
    DWORD *src;
    BYTE *dst_row;
    DWORD *dst;
 
    TRACE("%p, %p\n", hicon, bitmap);
 
    if(!bitmap || !GetIconInfo(hicon, &iinfo))
        return InvalidParameter;
 
    /* get the size of the icon */
    ret = GetObjectA(iinfo.hbmColor ? iinfo.hbmColor : iinfo.hbmMask, sizeof(bm), &bm);
    if (ret == 0) {
        DeleteObject(iinfo.hbmColor);
        DeleteObject(iinfo.hbmMask);
        return GenericError;
    }
 
    width = bm.bmWidth;
    height = iinfo.hbmColor ? abs(bm.bmHeight) : abs(bm.bmHeight) / 2;
    stride = width * 4;
 
    stat = GdipCreateBitmapFromScan0(width, height, stride, PixelFormat32bppARGB, NULL, bitmap);
    if (stat != Ok) {
        DeleteObject(iinfo.hbmColor);
        DeleteObject(iinfo.hbmMask);
        return stat;
    }
 
    rect.X = 0;
    rect.Y = 0;
    rect.Width = width;
    rect.Height = height;
 
    stat = GdipBitmapLockBits(*bitmap, &rect, ImageLockModeWrite, PixelFormat32bppARGB, &lockeddata);
    if (stat != Ok) {
        DeleteObject(iinfo.hbmColor);
        DeleteObject(iinfo.hbmMask);
        GdipDisposeImage(&(*bitmap)->image);
        return stat;
    }
 
    bih.biSize = sizeof(bih);
    bih.biWidth = width;
    bih.biHeight = iinfo.hbmColor ? -height: -height * 2;
    bih.biPlanes = 1;
    bih.biBitCount = 32;
    bih.biCompression = BI_RGB;
    bih.biSizeImage = 0;
    bih.biXPelsPerMeter = 0;
    bih.biYPelsPerMeter = 0;
    bih.biClrUsed = 0;
    bih.biClrImportant = 0;
 
    screendc = CreateCompatibleDC(0);
    if (iinfo.hbmColor)
    {
        GetDIBits(screendc, iinfo.hbmColor, 0, height, lockeddata.Scan0, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
 
        if (bm.bmBitsPixel == 32)
        {
            has_alpha = FALSE;
 
            /* If any pixel has a non-zero alpha, ignore hbmMask */
            src = (DWORD*)lockeddata.Scan0;
            for (x=0; x<width && !has_alpha; x++)
                for (y=0; y<height && !has_alpha; y++)
                    if ((*src++ & 0xff000000) != 0)
                        has_alpha = TRUE;
        }
        else has_alpha = FALSE;
    }
    else
    {
        GetDIBits(screendc, iinfo.hbmMask, 0, height, lockeddata.Scan0, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
        has_alpha = FALSE;
    }
 
    if (!has_alpha)
    {
        if (iinfo.hbmMask)
        {
            BYTE *bits = heap_alloc(height * stride);
 
            /* read alpha data from the mask */
            if (iinfo.hbmColor)
                GetDIBits(screendc, iinfo.hbmMask, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
            else
                GetDIBits(screendc, iinfo.hbmMask, height, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
 
            src = (DWORD*)bits;
            dst_row = lockeddata.Scan0;
            for (y=0; y<height; y++)
            {
                dst = (DWORD*)dst_row;
                for (x=0; x<height; x++)
                {
                    DWORD src_value = *src++;
                    if (src_value)
                        *dst++ = 0;
                    else
                        *dst++ |= 0xff000000;
                }
                dst_row += lockeddata.Stride;
            }
 
            heap_free(bits);
        }
        else
        {
            /* set constant alpha of 255 */
            dst_row = lockeddata.Scan0;
            for (y=0; y<height; y++)
            {
                dst = (DWORD*)dst_row;
                for (x=0; x<height; x++)
                    *dst++ |= 0xff000000;
                dst_row += lockeddata.Stride;
            }
        }
    }
 
    DeleteDC(screendc);
 
    DeleteObject(iinfo.hbmColor);
    DeleteObject(iinfo.hbmMask);
 
    GdipBitmapUnlockBits(*bitmap, &lockeddata);
 
    return Ok;
}

Referenced by test_fromhicon().

◆ GdipCreateBitmapFromResource()

GpStatus WINGDIPAPI GdipCreateBitmapFromResource	(	HINSTANCE	hInstance,
		GDIPCONST WCHAR *	lpBitmapName,
		GpBitmap **	bitmap
	)

Definition at line 1444 of file image.c.

{
    HBITMAP hbm;
    GpStatus stat = InvalidParameter;
 
    TRACE("%p (%s) %p\n", hInstance, debugstr_w(lpBitmapName), bitmap);
 
    if(!lpBitmapName || !bitmap)
        return InvalidParameter;
 
    /* load DIB */
    hbm = LoadImageW(hInstance, lpBitmapName, IMAGE_BITMAP, 0, 0,
                     LR_CREATEDIBSECTION);
 
    if(hbm){
        stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
        DeleteObject(hbm);
    }
 
    return stat;
}

◆ GdipCreateBitmapFromScan0()

GpStatus WINGDIPAPI GdipCreateBitmapFromScan0	(	INT	width,
		INT	height,
		INT	stride,
		PixelFormat	format,
		BYTE *	scan0,
		GpBitmap **	bitmap
	)

Definition at line 1760 of file image.c.

{
    HBITMAP hbitmap=NULL;
    INT row_size, dib_stride;
    BYTE *bits=NULL, *own_bits=NULL;
    REAL xres, yres;
    GpStatus stat;
 
    TRACE("%d %d %d 0x%x %p %p\n", width, height, stride, format, scan0, bitmap);
 
    if (!bitmap) return InvalidParameter;
 
    if(width <= 0 || height <= 0 || (scan0 && (stride % 4))){
        *bitmap = NULL;
        return InvalidParameter;
    }
 
    if(scan0 && !stride)
        return InvalidParameter;
 
    stat = get_screen_resolution(&xres, &yres);
    if (stat != Ok) return stat;
 
    row_size = (width * PIXELFORMATBPP(format)+7) / 8;
    dib_stride = (row_size + 3) & ~3;
 
    if(stride == 0)
        stride = dib_stride;
 
    if (format & PixelFormatGDI && !(format & (PixelFormatAlpha|PixelFormatIndexed)) && !scan0)
    {
        char bmibuf[FIELD_OFFSET(BITMAPINFO, bmiColors) + 256 * sizeof(RGBQUAD)];
        BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
 
        pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
        pbmi->bmiHeader.biWidth = width;
        pbmi->bmiHeader.biHeight = -height;
        pbmi->bmiHeader.biPlanes = 1;
        /* FIXME: use the rest of the data from format */
        pbmi->bmiHeader.biBitCount = PIXELFORMATBPP(format);
        pbmi->bmiHeader.biCompression = BI_RGB;
        pbmi->bmiHeader.biSizeImage = 0;
        pbmi->bmiHeader.biXPelsPerMeter = 0;
        pbmi->bmiHeader.biYPelsPerMeter = 0;
        pbmi->bmiHeader.biClrUsed = 0;
        pbmi->bmiHeader.biClrImportant = 0;
 
        hbitmap = CreateDIBSection(0, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
 
        if (!hbitmap) return GenericError;
 
        stride = dib_stride;
    }
    else
    {
        /* Not a GDI format; don't try to make an HBITMAP. */
        if (scan0)
            bits = scan0;
        else
        {
            INT size = abs(stride) * height;
 
            own_bits = bits = heap_alloc_zero(size);
            if (!own_bits) return OutOfMemory;
 
            if (stride < 0)
                bits += stride * (1 - height);
        }
    }
 
    *bitmap = heap_alloc_zero(sizeof(GpBitmap));
    if(!*bitmap)
    {
        DeleteObject(hbitmap);
        heap_free(own_bits);
        return OutOfMemory;
    }
 
    (*bitmap)->image.type = ImageTypeBitmap;
    memcpy(&(*bitmap)->image.format, &ImageFormatMemoryBMP, sizeof(GUID));
    (*bitmap)->image.flags = ImageFlagsNone;
    (*bitmap)->image.frame_count = 1;
    (*bitmap)->image.current_frame = 0;
    (*bitmap)->image.palette = NULL;
    (*bitmap)->image.xres = xres;
    (*bitmap)->image.yres = yres;
    (*bitmap)->width = width;
    (*bitmap)->height = height;
    (*bitmap)->format = format;
    (*bitmap)->image.decoder = NULL;
    (*bitmap)->hbitmap = hbitmap;
    (*bitmap)->hdc = NULL;
    (*bitmap)->bits = bits;
    (*bitmap)->stride = stride;
    (*bitmap)->own_bits = own_bits;
    (*bitmap)->metadata_reader = NULL;
    (*bitmap)->prop_count = 0;
    (*bitmap)->prop_item = NULL;
 
    /* set format-related flags */
    if (format & (PixelFormatAlpha|PixelFormatPAlpha|PixelFormatIndexed))
        (*bitmap)->image.flags |= ImageFlagsHasAlpha;
 
    if (format == PixelFormat1bppIndexed ||
        format == PixelFormat4bppIndexed ||
        format == PixelFormat8bppIndexed)
    {
        (*bitmap)->image.palette = heap_alloc_zero(sizeof(UINT) * 2 + sizeof(ARGB) * (1 << PIXELFORMATBPP(format)));
 
        if (!(*bitmap)->image.palette)
        {
            GdipDisposeImage(&(*bitmap)->image);
            *bitmap = NULL;
            return OutOfMemory;
        }
 
        (*bitmap)->image.palette->Count = 1 << PIXELFORMATBPP(format);
 
        if (format == PixelFormat1bppIndexed)
        {
            (*bitmap)->image.palette->Flags = PaletteFlagsGrayScale;
            (*bitmap)->image.palette->Entries[0] = 0xff000000;
            (*bitmap)->image.palette->Entries[1] = 0xffffffff;
        }
        else
        {
            if (format == PixelFormat8bppIndexed)
                (*bitmap)->image.palette->Flags = PaletteFlagsHalftone;
 
            generate_halftone_palette((*bitmap)->image.palette->Entries,
                (*bitmap)->image.palette->Count);
        }
    }
 
    TRACE("<-- %p\n", *bitmap);
 
    return Ok;
}

Referenced by create_graphics(), decode_frame_wic(), GdipCloneBitmapArea(), GdipCreateBitmapFromGdiDib(), GdipCreateBitmapFromGraphics(), GdipCreateBitmapFromHBITMAP(), GdipCreateBitmapFromHICON(), GdipGetImageThumbnail(), GdipImageRotateFlip(), metafile_deserialize_image(), METAFILE_DrawImagePointsRect(), test_ARGB_conversion(), test_bitmapbits(), test_clear(), test_clipping(), test_CloneBitmapArea(), test_colorkey(), test_colormatrix(), test_containers(), test_createhbitmap(), test_dispose(), test_DrawImage(), test_DrawImage_scale(), test_DrawImage_SourceCopy(), test_emfonly(), test_fillrect(), test_fromMemoryBitmap(), test_gamma(), test_GdipCloneImage(), test_GdipDrawImagePointRect(), test_GdipDrawImagePointsRectOnMemoryDC(), test_GdipFillRectanglesOnBitmapTextureBrush(), test_GdipFillRectanglesOnMemoryDCTextureBrush(), test_GdipGetImageFlags(), test_GdipGetNearestColor(), test_GdipImageGetFrameDimensionsCount(), test_GdipInitializePalette(), test_gditransform(), test_getdc(), test_getdc_scaled(), test_GetImageDimension(), test_getsetpixel(), test_getthumbnail(), test_histogram(), test_image_format(), test_imageabort(), test_LockBits(), test_LockBits_UserBuf(), test_pagetransform(), test_palette(), test_pen_thickness(), test_remaptable(), test_resolution(), test_rotateflip(), test_SavingImages(), test_Scan0(), test_supported_encoders(), and test_worldtransform().

◆ GdipCreateBitmapFromStream()

GpStatus WINGDIPAPI GdipCreateBitmapFromStream	(	IStream *	stream,
		GpBitmap **	bitmap
	)

Definition at line 1935 of file image.c.

{
    GpStatus stat;
 
    TRACE("%p %p\n", stream, bitmap);
 
    stat = GdipLoadImageFromStream(stream, (GpImage**) bitmap);
 
    if(stat != Ok)
        return stat;
 
#ifdef __REACTOS__
    if ((*bitmap)->image.type == ImageTypeMetafile)
    {
        HBITMAP hbm = hbitmap_from_emf(((GpMetafile*)*bitmap)->hemf);
        GdipDisposeImage(&(*bitmap)->image);
        if (!hbm)
            return GenericError; /* FIXME: what error to return? */
 
        GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
        DeleteObject(hbm);
    }
    else
#endif
    if((*bitmap)->image.type != ImageTypeBitmap){
        GdipDisposeImage(&(*bitmap)->image);
        *bitmap = NULL;
        return GenericError; /* FIXME: what error to return? */
    }
 
    return Ok;
}

Referenced by GdipCreateBitmapFromFile(), GdipCreateBitmapFromStreamICM(), metafile_deserialize_image(), and test_multiframegif().

◆ GdipCreateBitmapFromStreamICM()

GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM	(	IStream *	stream,
		GpBitmap **	bitmap
	)

Definition at line 1970 of file image.c.

{
    TRACE("%p %p\n", stream, bitmap);
 
    return GdipCreateBitmapFromStream(stream, bitmap);
}

◆ GdipCreateCachedBitmap()

GpStatus WINGDIPAPI GdipCreateCachedBitmap	(	GpBitmap *	bitmap,
		GpGraphics *	graphics,
		GpCachedBitmap **	cachedbmp
	)

Definition at line 1978 of file image.c.

{
    GpStatus stat;
 
    TRACE("%p %p %p\n", bitmap, graphics, cachedbmp);
 
    if(!bitmap || !graphics || !cachedbmp)
        return InvalidParameter;
 
    *cachedbmp = heap_alloc_zero(sizeof(GpCachedBitmap));
    if(!*cachedbmp)
        return OutOfMemory;
 
    stat = GdipCloneImage(&(bitmap->image), &(*cachedbmp)->image);
    if(stat != Ok){
        heap_free(*cachedbmp);
        return stat;
    }
 
    return Ok;
}

◆ GdipCreateEffect()

GpStatus WINGDIPAPI GdipCreateEffect	(	const GUID	guid,
		CGpEffect **	effect
	)

Definition at line 5272 of file image.c.

{
    FIXME("(%s, %p): stub\n", debugstr_guid(&guid), effect);
 
    if(!effect)
        return InvalidParameter;
 
    *effect = NULL;
 
    return NotImplemented;
}

◆ GdipCreateHBITMAPFromBitmap()

GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap	(	GpBitmap *	bitmap,
		HBITMAP *	hbmReturn,
		ARGB	background
	)

Definition at line 1479 of file image.c.

{
    GpStatus stat;
    HBITMAP result;
    UINT width, height;
    BITMAPINFOHEADER bih;
    LPBYTE bits;
    BOOL unlock;
 
    TRACE("(%p,%p,%x)\n", bitmap, hbmReturn, background);
 
    if (!bitmap || !hbmReturn) return InvalidParameter;
    if (!image_lock(&bitmap->image, &unlock)) return ObjectBusy;
 
    GdipGetImageWidth(&bitmap->image, &width);
    GdipGetImageHeight(&bitmap->image, &height);
 
    bih.biSize = sizeof(bih);
    bih.biWidth = width;
    bih.biHeight = height;
    bih.biPlanes = 1;
    bih.biBitCount = 32;
    bih.biCompression = BI_RGB;
    bih.biSizeImage = 0;
    bih.biXPelsPerMeter = 0;
    bih.biYPelsPerMeter = 0;
    bih.biClrUsed = 0;
    bih.biClrImportant = 0;
 
    result = CreateDIBSection(0, (BITMAPINFO*)&bih, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    if (!result)
    {
        image_unlock(&bitmap->image, unlock);
        return GenericError;
    }
 
    stat = convert_pixels(width, height, -width*4,
            bits + (width * 4 * (height - 1)), PixelFormat32bppPARGB,
            bitmap->stride, bitmap->bits, bitmap->format, bitmap->image.palette);
    if (stat != Ok)
    {
        DeleteObject(result);
        image_unlock(&bitmap->image, unlock);
        return stat;
    }
 
    if (background & 0xffffff)
    {
        DWORD *ptr;
        UINT i;
        for (ptr = (DWORD*)bits, i = 0; i < width * height; ptr++, i++)
        {
            if ((*ptr & 0xff000000) == 0xff000000) continue;
            *ptr = blend_argb_no_bkgnd_alpha(*ptr, background);
        }
    }
 
    *hbmReturn = result;
    image_unlock(&bitmap->image, unlock);
    return Ok;
}

Referenced by GdipDrawImagePointsRect(), test_createhbitmap(), and test_image_format().

◆ GdipCreateHICONFromBitmap()

GpStatus WINGDIPAPI GdipCreateHICONFromBitmap	(	GpBitmap *	bitmap,
		HICON *	hicon
	)

Definition at line 2001 of file image.c.

{
    GpStatus stat;
    BitmapData lockeddata;
    ULONG andstride, xorstride, bitssize;
    LPBYTE andbits, xorbits, androw, xorrow, srcrow;
    UINT x, y;
 
    TRACE("(%p, %p)\n", bitmap, hicon);
 
    if (!bitmap || !hicon)
        return InvalidParameter;
 
    stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead,
        PixelFormat32bppPARGB, &lockeddata);
    if (stat == Ok)
    {
        andstride = ((lockeddata.Width+31)/32)*4;
        xorstride = lockeddata.Width*4;
        bitssize = (andstride + xorstride) * lockeddata.Height;
 
        andbits = heap_alloc_zero(bitssize);
 
        if (andbits)
        {
            xorbits = andbits + andstride * lockeddata.Height;
 
            for (y=0; y<lockeddata.Height; y++)
            {
                srcrow = ((LPBYTE)lockeddata.Scan0) + lockeddata.Stride * y;
 
                androw = andbits + andstride * y;
                for (x=0; x<lockeddata.Width; x++)
                    if (srcrow[3+4*x] >= 128)
                        androw[x/8] |= 1 << (7-x%8);
 
                xorrow = xorbits + xorstride * y;
                memcpy(xorrow, srcrow, xorstride);
            }
 
            *hicon = CreateIcon(NULL, lockeddata.Width, lockeddata.Height, 1, 32,
                andbits, xorbits);
 
            heap_free(andbits);
        }
        else
            stat = OutOfMemory;
 
        GdipBitmapUnlockBits(bitmap, &lockeddata);
    }
 
    return stat;
}

◆ GdipDeleteCachedBitmap()

GpStatus WINGDIPAPI GdipDeleteCachedBitmap ( GpCachedBitmap * cachedbmp )

Definition at line 2055 of file image.c.

{
    TRACE("%p\n", cachedbmp);
 
    if(!cachedbmp)
        return InvalidParameter;
 
    GdipDisposeImage(cachedbmp->image);
    heap_free(cachedbmp);
 
    return Ok;
}

◆ GdipDeleteEffect()

GpStatus WINGDIPAPI GdipDeleteEffect ( CGpEffect * effect )

Definition at line 5287 of file image.c.

{
    FIXME("(%p): stub\n", effect);
    /* note: According to Jose Roca's GDI+ Docs, this is not implemented
     * in Windows's gdiplus */
    return NotImplemented;
}

◆ GdipDisposeImage()

GpStatus WINGDIPAPI GdipDisposeImage ( GpImage * image )

Definition at line 2155 of file image.c.

{
    GpStatus status;
 
    TRACE("%p\n", image);
 
    status = free_image_data(image);
    if (status != Ok) return status;
    image->type = ~0;
    heap_free(image);
 
    return Ok;
}

Referenced by decode_frame_wic(), DibLoadImage(), GdipCloneBitmapArea(), GdipCreateBitmapFromHBITMAP(), GdipCreateBitmapFromHICON(), GdipCreateBitmapFromScan0(), GdipCreateBitmapFromStream(), GdipCreateMetafileFromStream(), GdipCreateTextureIA(), GdipDeleteBrush(), GdipDeleteCachedBitmap(), GdipGetImageThumbnail(), GdipGetMetafileHeaderFromFile(), GdipGetMetafileHeaderFromStream(), GdipGetMetafileHeaderFromWmf(), GdipImageRotateFlip(), load_image(), metafile_deserialize_brush(), metafile_deserialize_image(), METAFILE_DrawImagePointsRect(), metafile_free_object_table_entry(), Preview_pFreeImage(), SetWallpaper(), sync_metafile(), test_ARGB_conversion(), test_bitmapbits(), test_bitmapfromgraphics(), test_bufferrawformat(), test_clear(), test_clipping(), test_CloneBitmapArea(), test_colorkey(), test_colormatrix(), test_containers(), test_converttoemfplus(), test_createfromwmf(), test_createfromwmf_noplaceable(), test_createhbitmap(), test_dispose(), test_DrawImage(), test_drawimage(), test_DrawImage_scale(), test_DrawImage_SourceCopy(), test_drawpath(), test_emfonly(), test_empty(), test_fillpath(), test_fillrect(), test_frameunit(), test_FromGdiDib(), test_fromhicon(), test_fromMemoryBitmap(), test_gamma(), test_GdipCloneImage(), test_GdipCreateBitmapFromHBITMAP(), test_GdipDrawImagePointRect(), test_GdipDrawImagePointsRect(), test_GdipDrawImagePointsRectOnMemoryDC(), test_GdipFillRectanglesOnBitmapTextureBrush(), test_GdipFillRectanglesOnMemoryDCTextureBrush(), test_GdipGetAllPropertyItems(), test_GdipGetImageFlags(), test_GdipGetNearestColor(), test_GdipImageGetFrameDimensionsCount(), test_GdipInitializePalette(), test_GdipMeasureString(), test_gditransform(), test_getdc(), test_getdc_scaled(), test_GetImageDimension(), test_getsetpixel(), test_getthumbnail(), test_gif_properties(), test_histogram(), test_image_format(), test_image_properties(), test_imageabort(), test_loadwmf(), test_LockBits(), test_LockBits_UserBuf(), test_multiframegif(), test_nullframerect(), test_pagetransform(), test_palette(), test_pen_thickness(), test_png_color_formats(), test_properties(), test_remaptable(), test_resolution(), test_rotateflip(), test_SavingImages(), test_Scan0(), test_supported_encoders(), test_texturewrap(), test_tiff_color_formats(), test_tiff_palette(), test_tiff_properties(), test_transform(), and test_worldtransform().

◆ GdipDrawCachedBitmap()

GpStatus WINGDIPAPI GdipDrawCachedBitmap	(	GpGraphics *	graphics,
		GpCachedBitmap *	cachedbmp,
		INT	x,
		INT	y
	)

Definition at line 2068 of file image.c.

{
    TRACE("%p %p %d %d\n", graphics, cachedbmp, x, y);
 
    if(!graphics || !cachedbmp)
        return InvalidParameter;
 
    return GdipDrawImage(graphics, cachedbmp->image, (REAL)x, (REAL)y);
}

◆ GdipFindFirstImageItem()

GpStatus WINGDIPAPI GdipFindFirstImageItem	(	GpImage *	image,
		ImageItemData *	item
	)

Definition at line 2169 of file image.c.

{
    static int calls;
 
    TRACE("(%p,%p)\n", image, item);
 
    if(!image || !item)
        return InvalidParameter;
 
    if (!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

◆ GdipGetAllPropertyItems()

GpStatus WINGDIPAPI GdipGetAllPropertyItems	(	GpImage *	image,
		UINT	size,
		UINT	count,
		PropertyItem *	buf
	)

Definition at line 2805 of file image.c.

{
    GpStatus status;
    HRESULT hr;
    IWICMetadataReader *reader;
    IWICEnumMetadataItem *enumerator;
    UINT prop_count, prop_size, i;
    PROPVARIANT id, value;
    char *item_value;
 
    TRACE("(%p,%u,%u,%p)\n", image, size, count, buf);
 
    if (!image || !buf) return InvalidParameter;
 
    if (image->type != ImageTypeBitmap)
    {
        FIXME("Not implemented for type %d\n", image->type);
        return NotImplemented;
    }
 
    status = GdipGetPropertySize(image, &prop_size, &prop_count);
    if (status != Ok) return status;
 
    if (prop_count != count || prop_size != size) return InvalidParameter;
 
    if (((GpBitmap *)image)->prop_item)
    {
        memcpy(buf, ((GpBitmap *)image)->prop_item, prop_size);
 
        item_value = (char *)(buf + prop_count);
 
        for (i = 0; i < prop_count; i++)
        {
            buf[i].value = item_value;
            item_value += buf[i].length;
        }
 
        return Ok;
    }
 
    reader = ((GpBitmap *)image)->metadata_reader;
    if (!reader) return PropertyNotFound;
 
    hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
    if (FAILED(hr)) return hresult_to_status(hr);
 
    IWICEnumMetadataItem_Reset(enumerator);
 
    item_value = (char *)(buf + prop_count);
 
    PropVariantInit(&id);
    PropVariantInit(&value);
 
    for (i = 0; i < prop_count; i++)
    {
        PropertyItem *item;
        UINT items_returned, item_size;
 
        hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, &value, &items_returned);
        if (hr != S_OK) break;
 
        if (id.vt != VT_UI2)
        {
            FIXME("not supported propvariant type for id: %u\n", id.vt);
            continue;
        }
 
        item_size = propvariant_size(&value);
        if (item_size)
        {
            item = heap_alloc(item_size + sizeof(*item));
 
            propvariant_to_item(&value, item, item_size + sizeof(*item), id.u.uiVal);
            buf[i].id = item->id;
            buf[i].type = item->type;
            buf[i].length = item_size;
            buf[i].value = item_value;
            memcpy(item_value, item->value, item_size);
            item_value += item_size;
 
            heap_free(item);
        }
 
        PropVariantClear(&id);
        PropVariantClear(&value);
    }
 
    IWICEnumMetadataItem_Release(enumerator);
 
    if (hr != S_OK) return PropertyNotFound;
 
    return Ok;
}

Referenced by test_GdipGetAllPropertyItems(), and test_gif_properties().

◆ GdipGetEncoderParameterListSize()

GpStatus WINGDIPAPI GdipGetEncoderParameterListSize	(	GpImage *	image,
		GDIPCONST CLSID *	clsidEncoder,
		UINT *	size
	)

Definition at line 5093 of file image.c.

{
    static int calls;
 
    TRACE("(%p,%s,%p)\n", image, debugstr_guid(clsidEncoder), size);
 
    if(!(calls++))
        FIXME("not implemented\n");
 
    *size = 0;
 
    return NotImplemented;
}

◆ GdipGetImageBounds()

GpStatus WINGDIPAPI GdipGetImageBounds	(	GpImage *	image,
		GpRectF *	srcRect,
		GpUnit *	srcUnit
	)

Definition at line 2196 of file image.c.

{
    TRACE("%p %p %p\n", image, srcRect, srcUnit);
 
    if(!image || !srcRect || !srcUnit)
        return InvalidParameter;
    if(image->type == ImageTypeMetafile){
        *srcRect = ((GpMetafile*)image)->bounds;
        *srcUnit = ((GpMetafile*)image)->unit;
    }
    else if(image->type == ImageTypeBitmap){
        srcRect->X = srcRect->Y = 0.0;
        srcRect->Width = (REAL) ((GpBitmap*)image)->width;
        srcRect->Height = (REAL) ((GpBitmap*)image)->height;
        *srcUnit = UnitPixel;
    }
    else{
        WARN("GpImage with no image data\n");
        return InvalidParameter;
    }
 
    TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
          srcRect->Width, srcRect->Height, *srcUnit);
 
    return Ok;
}

Referenced by GdipDrawImageRect(), get_graphics_device_bounds(), test_createfromwmf(), test_emfonly(), test_empty(), test_frameunit(), test_GdipCloneImage(), test_loadwmf(), and test_nullframerect().

◆ GdipGetImageDecoders()

GpStatus WINGDIPAPI GdipGetImageDecoders	(	UINT	numDecoders,
		UINT	size,
		ImageCodecInfo *	decoders
	)

Definition at line 5018 of file image.c.

{
    int i, decoder_count=0;
    TRACE("%u %u %p\n", numDecoders, size, decoders);
 
    if (!decoders ||
        size != numDecoders * sizeof(ImageCodecInfo))
        return GenericError;
 
    for (i=0; i<NUM_CODECS; i++)
    {
        if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
        {
            if (decoder_count == numDecoders) return GenericError;
            memcpy(&decoders[decoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
            decoder_count++;
        }
    }
 
    if (decoder_count < numDecoders) return GenericError;
 
    return Ok;
}

Referenced by GdipGetSupportedFileExtensions(), and pBuildFileList().

◆ GdipGetImageDecodersSize()

GpStatus WINGDIPAPI GdipGetImageDecodersSize	(	UINT *	numDecoders,
		UINT *	size
	)

Definition at line 4994 of file image.c.

{
    int decoder_count=0;
    int i;
    TRACE("%p %p\n", numDecoders, size);
 
    if (!numDecoders || !size)
        return InvalidParameter;
 
    for (i=0; i<NUM_CODECS; i++)
    {
        if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
            decoder_count++;
    }
 
    *numDecoders = decoder_count;
    *size = decoder_count * sizeof(ImageCodecInfo);
 
    return Ok;
}

Referenced by GdipGetSupportedFileExtensions(), and pBuildFileList().

◆ GdipGetImageDimension()

GpStatus WINGDIPAPI GdipGetImageDimension	(	GpImage *	image,
		REAL *	width,
		REAL *	height
	)

Definition at line 2224 of file image.c.

{
    TRACE("%p %p %p\n", image, width, height);
 
    if(!image || !height || !width)
        return InvalidParameter;
 
    if(image->type == ImageTypeMetafile){
        *height = units_to_pixels(((GpMetafile*)image)->bounds.Height, ((GpMetafile*)image)->unit, image->yres);
        *width = units_to_pixels(((GpMetafile*)image)->bounds.Width, ((GpMetafile*)image)->unit, image->xres);
    }
    else if(image->type == ImageTypeBitmap){
        *height = ((GpBitmap*)image)->height;
        *width = ((GpBitmap*)image)->width;
    }
    else{
        WARN("GpImage with no image data\n");
        return InvalidParameter;
    }
 
    TRACE("returning (%f, %f)\n", *height, *width);
    return Ok;
}

Referenced by test_GdipCreateBitmapFromHBITMAP(), test_GetImageDimension(), and test_SavingImages().

◆ GdipGetImageEncoders()

GpStatus WINGDIPAPI GdipGetImageEncoders	(	UINT	numEncoders,
		UINT	size,
		ImageCodecInfo *	encoders
	)

Definition at line 5069 of file image.c.

{
    int i, encoder_count=0;
    TRACE("%u %u %p\n", numEncoders, size, encoders);
 
    if (!encoders ||
        size != numEncoders * sizeof(ImageCodecInfo))
        return GenericError;
 
    for (i=0; i<NUM_CODECS; i++)
    {
        if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
        {
            if (encoder_count == numEncoders) return GenericError;
            memcpy(&encoders[encoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
            encoder_count++;
        }
    }
 
    if (encoder_count < numEncoders) return GenericError;
 
    return Ok;
}

Referenced by GdipGetEncoderClsid(), get_encoder_clsid(), Preview_pSaveImage(), Preview_pSaveImageAs(), test_encoders(), and test_SavingImages().

◆ GdipGetImageEncodersSize()

GpStatus WINGDIPAPI GdipGetImageEncodersSize	(	UINT *	numEncoders,
		UINT *	size
	)

Definition at line 5045 of file image.c.

{
    int encoder_count=0;
    int i;
    TRACE("%p %p\n", numEncoders, size);
 
    if (!numEncoders || !size)
        return InvalidParameter;
 
    for (i=0; i<NUM_CODECS; i++)
    {
        if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
            encoder_count++;
    }
 
    *numEncoders = encoder_count;
    *size = encoder_count * sizeof(ImageCodecInfo);
 
    return Ok;
}

Referenced by GdipGetEncoderClsid(), get_encoder_clsid(), Preview_pSaveImage(), Preview_pSaveImageAs(), test_encoders(), and test_SavingImages().

◆ GdipGetImageFlags()

GpStatus WINGDIPAPI GdipGetImageFlags	(	GpImage *	image,
		UINT *	flags
	)

Definition at line 5314 of file image.c.

{
    TRACE("%p %p\n", image, flags);
 
    if(!image || !flags)
        return InvalidParameter;
 
    *flags = image->flags;
 
    return Ok;
}

Referenced by test_GdipGetImageFlags(), test_png_color_formats(), and ZoomWnd_OnDraw().

◆ GdipGetImageGraphicsContext()

GpStatus WINGDIPAPI GdipGetImageGraphicsContext	(	GpImage *	image,
		GpGraphics **	graphics
	)

Definition at line 2249 of file image.c.

{
    HDC hdc;
    GpStatus stat;
 
    TRACE("%p %p\n", image, graphics);
 
    if(!image || !graphics)
        return InvalidParameter;
 
    if (image->type == ImageTypeBitmap && ((GpBitmap*)image)->hbitmap)
    {
        hdc = ((GpBitmap*)image)->hdc;
 
        if(!hdc){
            hdc = CreateCompatibleDC(0);
            SelectObject(hdc, ((GpBitmap*)image)->hbitmap);
            ((GpBitmap*)image)->hdc = hdc;
        }
 
        stat = GdipCreateFromHDC(hdc, graphics);
 
        if (stat == Ok)
        {
            (*graphics)->image = image;
            (*graphics)->xres = image->xres;
            (*graphics)->yres = image->yres;
        }
    }
    else if (image->type == ImageTypeMetafile)
        stat = METAFILE_GetGraphicsContext((GpMetafile*)image, graphics);
    else
        stat = graphics_from_image(image, graphics);
 
    return stat;
}

Referenced by create_graphics(), GdipGetImageThumbnail(), METAFILE_DrawImagePointsRect(), test_clear(), test_clipping(), test_colorkey(), test_colormatrix(), test_containers(), test_converttoemfplus(), test_DrawImage(), test_drawimage(), test_DrawImage_scale(), test_DrawImage_SourceCopy(), test_drawpath(), test_emfonly(), test_empty(), test_fillpath(), test_fillrect(), test_frameunit(), test_fromMemoryBitmap(), test_gamma(), test_GdipDrawImagePointRect(), test_GdipFillRectanglesOnBitmapTextureBrush(), test_GdipGetNearestColor(), test_gditransform(), test_getdc(), test_getdc_scaled(), test_nullframerect(), test_pagetransform(), test_pen_thickness(), test_properties(), test_remaptable(), test_resolution(), and test_worldtransform().

◆ GdipGetImageHeight()

GpStatus WINGDIPAPI GdipGetImageHeight	(	GpImage *	image,
		UINT *	height
	)

Definition at line 2287 of file image.c.

{
    TRACE("%p %p\n", image, height);
 
    if(!image || !height)
        return InvalidParameter;
 
    if(image->type == ImageTypeMetafile)
        *height = units_to_pixels(((GpMetafile*)image)->bounds.Height, ((GpMetafile*)image)->unit, image->yres);
    else if(image->type == ImageTypeBitmap)
        *height = ((GpBitmap*)image)->height;
    else
    {
        WARN("GpImage with no image data\n");
        return InvalidParameter;
    }
 
    TRACE("returning %d\n", *height);
 
    return Ok;
}

Referenced by DibLoadImage(), encode_image_wic(), GdipBitmapGetHistogram(), GdipCloneBrush(), GdipCreateHBITMAPFromBitmap(), GdipCreateTexture(), GdipDrawImage(), GdipDrawImagePoints(), GdipGetImageThumbnail(), Preview_ResetZoom(), test_bitmapfromgraphics(), test_fromhicon(), test_getthumbnail(), test_pagetransform(), test_rotateflip(), ZoomWnd_OnDraw(), ZoomWnd_OnHVScroll(), and ZoomWnd_UpdateScroll().

◆ GdipGetImageHorizontalResolution()

GpStatus WINGDIPAPI GdipGetImageHorizontalResolution	(	GpImage *	image,
		REAL *	res
	)

Definition at line 2309 of file image.c.

{
    if(!image || !res)
        return InvalidParameter;
 
    *res = image->xres;
 
    TRACE("(%p) <-- %0.2f\n", image, *res);
 
    return Ok;
}

Referenced by create_graphics(), test_bitmapfromgraphics(), test_createfromwmf(), test_emfonly(), test_empty(), test_frameunit(), test_loadwmf(), test_pagetransform(), and test_resolution().

◆ GdipGetImageItemData()

GpStatus WINGDIPAPI GdipGetImageItemData	(	GpImage *	image,
		ImageItemData *	item
	)

Definition at line 2184 of file image.c.

{
    static int calls;
 
    TRACE("(%p,%p)\n", image, item);
 
    if (!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

◆ GdipGetImagePalette()

GpStatus WINGDIPAPI GdipGetImagePalette	(	GpImage *	image,
		ColorPalette *	palette,
		INT	size
	)

Definition at line 4710 of file image.c.

{
    INT count;
 
    TRACE("(%p,%p,%i)\n", image, palette, size);
 
    if (!image || !palette)
        return InvalidParameter;
 
    count = image->palette ? image->palette->Count : 0;
 
    if (size < (sizeof(UINT)*2+sizeof(ARGB)*count))
    {
        TRACE("<-- InsufficientBuffer\n");
        return InsufficientBuffer;
    }
 
    if (image->palette)
    {
        palette->Flags = image->palette->Flags;
        palette->Count = image->palette->Count;
        memcpy(palette->Entries, image->palette->Entries, sizeof(ARGB)*image->palette->Count);
    }
    else
    {
        palette->Flags = 0;
        palette->Count = 0;
    }
    return Ok;
}

Referenced by test_multiframegif(), test_palette(), and test_tiff_palette().

◆ GdipGetImagePaletteSize()

GpStatus WINGDIPAPI GdipGetImagePaletteSize	(	GpImage *	image,
		INT *	size
	)

Definition at line 2321 of file image.c.

{
    TRACE("%p %p\n", image, size);
 
    if(!image || !size)
        return InvalidParameter;
 
    if (!image->palette || image->palette->Count == 0)
        *size = sizeof(ColorPalette);
    else
        *size = sizeof(UINT)*2 + sizeof(ARGB)*image->palette->Count;
 
    TRACE("<-- %u\n", *size);
 
    return Ok;
}

Referenced by test_multiframegif(), test_palette(), and test_tiff_palette().

◆ GdipGetImagePixelFormat()

GpStatus WINGDIPAPI GdipGetImagePixelFormat	(	GpImage *	image,
		PixelFormat *	format
	)

Definition at line 2339 of file image.c.

{
    TRACE("%p %p\n", image, format);
 
    if(!image || !format)
        return InvalidParameter;
 
    if(image->type != ImageTypeBitmap)
        *format = PixelFormat24bppRGB;
    else
        *format = ((GpBitmap*) image)->format;
 
    return Ok;
}

Referenced by test_bitmapfromgraphics(), test_FromGdiDib(), test_fromhicon(), test_GdipCreateBitmapFromHBITMAP(), test_image_format(), test_multiframegif(), test_png_color_formats(), test_tiff_color_formats(), and test_tiff_palette().

◆ GdipGetImageRawFormat()

GpStatus WINGDIPAPI GdipGetImageRawFormat	(	GpImage *	image,
		GUID *	format
	)

Definition at line 2354 of file image.c.

{
    TRACE("(%p, %p)\n", image, format);
 
    if(!image || !format)
        return InvalidParameter;
 
    memcpy(format, &image->format, sizeof(GUID));
 
    return Ok;
}

Referenced by expect_rawformat(), Preview_pSaveImage(), Preview_pSaveImageAs(), and SetWallpaper().

◆ GdipGetImageThumbnail()

GpStatus WINGDIPAPI GdipGetImageThumbnail	(	GpImage *	image,
		UINT	width,
		UINT	height,
		GpImage **	ret_image,
		GetThumbnailImageAbort	cb,
		VOID *	cb_data
	)

Definition at line 5357 of file image.c.

{
    GpStatus stat;
    GpGraphics *graphics;
    UINT srcwidth, srcheight;
 
    TRACE("(%p %u %u %p %p %p)\n",
        image, width, height, ret_image, cb, cb_data);
 
    if (!image || !ret_image)
        return InvalidParameter;
 
    if (!width) width = 120;
    if (!height) height = 120;
 
    GdipGetImageWidth(image, &srcwidth);
    GdipGetImageHeight(image, &srcheight);
 
    stat = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppPARGB,
        NULL, (GpBitmap**)ret_image);
 
    if (stat == Ok)
    {
        stat = GdipGetImageGraphicsContext(*ret_image, &graphics);
 
        if (stat == Ok)
        {
            stat = GdipDrawImageRectRectI(graphics, image,
                0, 0, width, height, 0, 0, srcwidth, srcheight, UnitPixel,
                NULL, NULL, NULL);
 
            GdipDeleteGraphics(graphics);
        }
 
        if (stat != Ok)
        {
            GdipDisposeImage(*ret_image);
            *ret_image = NULL;
        }
    }
 
    return stat;
}

Referenced by test_getthumbnail(), and test_image_format().

◆ GdipGetImageType()

GpStatus WINGDIPAPI GdipGetImageType	(	GpImage *	image,
		ImageType *	type
	)

Definition at line 2366 of file image.c.

{
    TRACE("%p %p\n", image, type);
 
    if(!image || !type)
        return InvalidParameter;
 
    *type = image->type;
 
    return Ok;
}

Referenced by load_image(), test_fromhicon(), test_image_properties(), test_png_color_formats(), and test_tiff_color_formats().

◆ GdipGetImageVerticalResolution()

GpStatus WINGDIPAPI GdipGetImageVerticalResolution	(	GpImage *	image,
		REAL *	res
	)

Definition at line 2378 of file image.c.

{
    if(!image || !res)
        return InvalidParameter;
 
    *res = image->yres;
 
    TRACE("(%p) <-- %0.2f\n", image, *res);
 
    return Ok;
}

Referenced by create_graphics(), test_bitmapfromgraphics(), test_createfromwmf(), test_emfonly(), test_empty(), test_frameunit(), test_loadwmf(), test_pagetransform(), and test_resolution().

◆ GdipGetImageWidth()

GpStatus WINGDIPAPI GdipGetImageWidth	(	GpImage *	image,
		UINT *	width
	)

Definition at line 2390 of file image.c.

{
    TRACE("%p %p\n", image, width);
 
    if(!image || !width)
        return InvalidParameter;
 
    if(image->type == ImageTypeMetafile)
        *width = units_to_pixels(((GpMetafile*)image)->bounds.Width, ((GpMetafile*)image)->unit, image->xres);
    else if(image->type == ImageTypeBitmap)
        *width = ((GpBitmap*)image)->width;
    else
    {
        WARN("GpImage with no image data\n");
        return InvalidParameter;
    }
 
    TRACE("returning %d\n", *width);
 
    return Ok;
}

Referenced by DibLoadImage(), encode_image_wic(), GdipBitmapGetHistogram(), GdipCloneBrush(), GdipCreateHBITMAPFromBitmap(), GdipCreateTexture(), GdipDrawImage(), GdipDrawImagePoints(), GdipGetImageThumbnail(), Preview_ResetZoom(), test_bitmapfromgraphics(), test_fromhicon(), test_getthumbnail(), test_pagetransform(), test_rotateflip(), ZoomWnd_OnDraw(), ZoomWnd_OnHVScroll(), and ZoomWnd_UpdateScroll().

◆ GdipGetPropertyCount()

GpStatus WINGDIPAPI GdipGetPropertyCount	(	GpImage *	image,
		UINT *	num
	)

Definition at line 2412 of file image.c.

{
    TRACE("(%p, %p)\n", image, num);
 
    if (!image || !num) return InvalidParameter;
 
    *num = 0;
 
    if (image->type == ImageTypeBitmap)
    {
        if (((GpBitmap *)image)->prop_item)
        {
            *num = ((GpBitmap *)image)->prop_count;
            return Ok;
        }
 
        if (((GpBitmap *)image)->metadata_reader)
            IWICMetadataReader_GetCount(((GpBitmap *)image)->metadata_reader, num);
    }
 
    return Ok;
}

Referenced by test_GdipGetAllPropertyItems(), test_gif_properties(), test_image_properties(), and test_tiff_properties().

◆ GdipGetPropertyIdList()

GpStatus WINGDIPAPI GdipGetPropertyIdList	(	GpImage *	image,
		UINT	num,
		PROPID *	list
	)

Definition at line 2435 of file image.c.

{
    HRESULT hr;
    IWICMetadataReader *reader;
    IWICEnumMetadataItem *enumerator;
    UINT prop_count, i, items_returned;
 
    TRACE("(%p, %u, %p)\n", image, num, list);
 
    if (!image || !list) return InvalidParameter;
 
    if (image->type != ImageTypeBitmap)
    {
        FIXME("Not implemented for type %d\n", image->type);
        return NotImplemented;
    }
 
    if (((GpBitmap *)image)->prop_item)
    {
        if (num != ((GpBitmap *)image)->prop_count) return InvalidParameter;
 
        for (i = 0; i < num; i++)
        {
            list[i] = ((GpBitmap *)image)->prop_item[i].id;
        }
 
        return Ok;
    }
 
    reader = ((GpBitmap *)image)->metadata_reader;
    if (!reader)
    {
        if (num != 0) return InvalidParameter;
        return Ok;
    }
 
    hr = IWICMetadataReader_GetCount(reader, &prop_count);
    if (FAILED(hr)) return hresult_to_status(hr);
 
    if (num != prop_count) return InvalidParameter;
 
    hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
    if (FAILED(hr)) return hresult_to_status(hr);
 
    IWICEnumMetadataItem_Reset(enumerator);
 
    for (i = 0; i < num; i++)
    {
        PROPVARIANT id;
 
        hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, NULL, &items_returned);
        if (hr != S_OK) break;
 
        if (id.vt != VT_UI2)
        {
            FIXME("not supported propvariant type for id: %u\n", id.vt);
            list[i] = 0;
            continue;
        }
        list[i] = id.u.uiVal;
    }
 
    IWICEnumMetadataItem_Release(enumerator);
 
    return hr == S_OK ? Ok : hresult_to_status(hr);
}

Referenced by test_GdipGetAllPropertyItems(), test_gif_properties(), test_image_properties(), and test_tiff_properties().

◆ GdipGetPropertyItem()

GpStatus WINGDIPAPI GdipGetPropertyItem	(	GpImage *	image,
		PROPID	propid,
		UINT	size,
		PropertyItem *	buffer
	)

Definition at line 2682 of file image.c.

{
    GpStatus stat;
    HRESULT hr;
    IWICMetadataReader *reader;
    PROPVARIANT id, value;
 
    TRACE("(%p,%#x,%u,%p)\n", image, propid, size, buffer);
 
    if (!image || !buffer) return InvalidParameter;
 
    if (image->type != ImageTypeBitmap)
    {
        FIXME("Not implemented for type %d\n", image->type);
        return NotImplemented;
    }
 
    if (((GpBitmap *)image)->prop_item)
    {
        UINT i;
 
        for (i = 0; i < ((GpBitmap *)image)->prop_count; i++)
        {
            if (propid == ((GpBitmap *)image)->prop_item[i].id)
            {
                if (size != sizeof(PropertyItem) + ((GpBitmap *)image)->prop_item[i].length)
                    return InvalidParameter;
 
                *buffer = ((GpBitmap *)image)->prop_item[i];
                buffer->value = buffer + 1;
                memcpy(buffer->value, ((GpBitmap *)image)->prop_item[i].value, buffer->length);
                return Ok;
            }
        }
 
        return PropertyNotFound;
    }
 
    reader = ((GpBitmap *)image)->metadata_reader;
    if (!reader) return PropertyNotFound;
 
    id.vt = VT_UI2;
    id.u.uiVal = propid;
    hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
    if (FAILED(hr)) return PropertyNotFound;
 
    stat = propvariant_to_item(&value, buffer, size, propid);
    PropVariantClear(&value);
 
    return stat;
}

Referenced by Anime_LoadInfo(), test_GdipGetAllPropertyItems(), test_gif_properties(), test_image_properties(), and test_tiff_properties().

◆ GdipGetPropertyItemSize()

GpStatus WINGDIPAPI GdipGetPropertyItemSize	(	GpImage *	image,
		PROPID	propid,
		UINT *	size
	)

Definition at line 2536 of file image.c.

{
    HRESULT hr;
    IWICMetadataReader *reader;
    PROPVARIANT id, value;
 
    TRACE("(%p,%#x,%p)\n", image, propid, size);
 
    if (!size || !image) return InvalidParameter;
 
    if (image->type != ImageTypeBitmap)
    {
        FIXME("Not implemented for type %d\n", image->type);
        return NotImplemented;
    }
 
    if (((GpBitmap *)image)->prop_item)
    {
        UINT i;
 
        for (i = 0; i < ((GpBitmap *)image)->prop_count; i++)
        {
            if (propid == ((GpBitmap *)image)->prop_item[i].id)
            {
                *size = sizeof(PropertyItem) + ((GpBitmap *)image)->prop_item[i].length;
                return Ok;
            }
        }
 
        return PropertyNotFound;
    }
 
    reader = ((GpBitmap *)image)->metadata_reader;
    if (!reader) return PropertyNotFound;
 
    id.vt = VT_UI2;
    id.u.uiVal = propid;
    hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
    if (FAILED(hr)) return PropertyNotFound;
 
    *size = propvariant_size(&value);
    if (*size) *size += sizeof(PropertyItem);
    PropVariantClear(&value);
 
    return Ok;
}

Referenced by Anime_LoadInfo(), test_GdipGetAllPropertyItems(), test_gif_properties(), test_image_properties(), and test_tiff_properties().

◆ GdipGetPropertySize()

GpStatus WINGDIPAPI GdipGetPropertySize	(	GpImage *	image,
		UINT *	size,
		UINT *	count
	)

Definition at line 2735 of file image.c.

{
    HRESULT hr;
    IWICMetadataReader *reader;
    IWICEnumMetadataItem *enumerator;
    UINT prop_count, prop_size, i;
    PROPVARIANT id, value;
 
    TRACE("(%p,%p,%p)\n", image, size, count);
 
    if (!image || !size || !count) return InvalidParameter;
 
    if (image->type != ImageTypeBitmap)
    {
        FIXME("Not implemented for type %d\n", image->type);
        return NotImplemented;
    }
 
    if (((GpBitmap *)image)->prop_item)
    {
        *count = ((GpBitmap *)image)->prop_count;
        *size = 0;
 
        for (i = 0; i < ((GpBitmap *)image)->prop_count; i++)
        {
            *size += sizeof(PropertyItem) + ((GpBitmap *)image)->prop_item[i].length;
        }
 
        return Ok;
    }
 
    reader = ((GpBitmap *)image)->metadata_reader;
    if (!reader) return PropertyNotFound;
 
    hr = IWICMetadataReader_GetCount(reader, &prop_count);
    if (FAILED(hr)) return hresult_to_status(hr);
 
    hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
    if (FAILED(hr)) return hresult_to_status(hr);
 
    IWICEnumMetadataItem_Reset(enumerator);
 
    prop_size = 0;
 
    PropVariantInit(&id);
    PropVariantInit(&value);
 
    for (i = 0; i < prop_count; i++)
    {
        UINT items_returned, item_size;
 
        hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, &value, &items_returned);
        if (hr != S_OK) break;
 
        item_size = propvariant_size(&value);
        if (item_size) prop_size += sizeof(PropertyItem) + item_size;
 
        PropVariantClear(&id);
        PropVariantClear(&value);
    }
 
    IWICEnumMetadataItem_Release(enumerator);
 
    if (hr != S_OK) return PropertyNotFound;
 
    *count = prop_count;
    *size = prop_size;
    return Ok;
}

Referenced by add_property(), GdipGetAllPropertyItems(), test_GdipGetAllPropertyItems(), and test_gif_properties().

◆ GdipImageForceValidation()

GpStatus WINGDIPAPI GdipImageForceValidation ( GpImage * image )

Definition at line 5347 of file image.c.

{
    TRACE("%p\n", image);
 
    return Ok;
}

◆ GdipImageGetFrameCount()

GpStatus WINGDIPAPI GdipImageGetFrameCount	(	GpImage *	image,
		GDIPCONST GUID *	dimensionID,
		UINT *	count
	)

Definition at line 2913 of file image.c.

{
    TRACE("(%p,%s,%p)\n", image, debugstr_guid(dimensionID), count);
 
    if(!image || !count)
        return InvalidParameter;
 
    if (!dimensionID ||
        IsEqualGUID(dimensionID, &image->format) ||
        IsEqualGUID(dimensionID, &FrameDimensionPage) ||
        IsEqualGUID(dimensionID, &FrameDimensionTime))
    {
        *count = image->frame_count;
        return Ok;
    }
 
    return InvalidParameter;
}

Referenced by Anime_LoadInfo(), test_GdipGetAllPropertyItems(), test_GdipImageGetFrameDimensionsCount(), test_gif_properties(), test_multiframegif(), and test_tiff_properties().

◆ GdipImageGetFrameDimensionsCount()

GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount	(	GpImage *	image,
		UINT *	count
	)

Definition at line 2933 of file image.c.

{
    TRACE("(%p, %p)\n", image, count);
 
    /* Native gdiplus 1.1 does not yet support multiple frame dimensions. */
 
    if(!image || !count)
        return InvalidParameter;
 
    *count = 1;
 
    return Ok;
}

Referenced by Anime_LoadInfo(), test_GdipGetAllPropertyItems(), test_GdipImageGetFrameDimensionsCount(), test_gif_properties(), test_multiframegif(), and test_tiff_properties().

◆ GdipImageGetFrameDimensionsList()

GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList	(	GpImage *	image,
		GUID *	dimensionIDs,
		UINT	count
	)

Definition at line 2948 of file image.c.

{
    int i;
    const GUID *result=NULL;
 
    TRACE("(%p,%p,%u)\n", image, dimensionIDs, count);
 
    if(!image || !dimensionIDs || count != 1)
        return InvalidParameter;
 
    for (i=0; image_format_dimensions[i].format; i++)
    {
        if (IsEqualGUID(&image->format, image_format_dimensions[i].format))
        {
            result = image_format_dimensions[i].dimension;
            break;
        }
    }
 
    if (!result)
        result = &FrameDimensionPage;
 
    memcpy(dimensionIDs, result, sizeof(GUID));
 
    return Ok;
}

Referenced by Anime_LoadInfo(), test_GdipGetAllPropertyItems(), test_GdipImageGetFrameDimensionsCount(), test_gif_properties(), test_multiframegif(), and test_tiff_properties().

◆ GdipImageRotateFlip()

GpStatus WINGDIPAPI GdipImageRotateFlip	(	GpImage *	image,
		RotateFlipType	type
	)

Definition at line 5406 of file image.c.

{
    GpBitmap *new_bitmap;
    GpBitmap *bitmap;
    int bpp, bytesperpixel;
    BOOL rotate_90, flip_x, flip_y;
    int src_x_offset, src_y_offset;
    LPBYTE src_origin;
    UINT x, y, width, height;
    BitmapData src_lock, dst_lock;
    GpStatus stat;
    BOOL unlock;
 
    TRACE("(%p, %u)\n", image, type);
 
    if (!image)
        return InvalidParameter;
    if (!image_lock(image, &unlock))
        return ObjectBusy;
 
    rotate_90 = type&1;
    flip_x = (type&6) == 2 || (type&6) == 4;
    flip_y = (type&3) == 1 || (type&3) == 2;
 
    if (image->type != ImageTypeBitmap)
    {
        FIXME("Not implemented for type %i\n", image->type);
        image_unlock(image, unlock);
        return NotImplemented;
    }
 
    bitmap = (GpBitmap*)image;
    bpp = PIXELFORMATBPP(bitmap->format);
 
    if (bpp < 8)
    {
        FIXME("Not implemented for %i bit images\n", bpp);
        image_unlock(image, unlock);
        return NotImplemented;
    }
 
    if (rotate_90)
    {
        width = bitmap->height;
        height = bitmap->width;
    }
    else
    {
        width = bitmap->width;
        height = bitmap->height;
    }
 
    bytesperpixel = bpp/8;
 
    stat = GdipCreateBitmapFromScan0(width, height, 0, bitmap->format, NULL, &new_bitmap);
 
    if (stat != Ok)
    {
        image_unlock(image, unlock);
        return stat;
    }
 
    stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, bitmap->format, &src_lock);
 
    if (stat == Ok)
    {
        stat = GdipBitmapLockBits(new_bitmap, NULL, ImageLockModeWrite, bitmap->format, &dst_lock);
 
        if (stat == Ok)
        {
            LPBYTE src_row, src_pixel;
            LPBYTE dst_row, dst_pixel;
 
            src_origin = src_lock.Scan0;
            if (flip_x) src_origin += bytesperpixel * (bitmap->width - 1);
            if (flip_y) src_origin += src_lock.Stride * (bitmap->height - 1);
 
            if (rotate_90)
            {
                if (flip_y) src_x_offset = -src_lock.Stride;
                else src_x_offset = src_lock.Stride;
                if (flip_x) src_y_offset = -bytesperpixel;
                else src_y_offset = bytesperpixel;
            }
            else
            {
                if (flip_x) src_x_offset = -bytesperpixel;
                else src_x_offset = bytesperpixel;
                if (flip_y) src_y_offset = -src_lock.Stride;
                else src_y_offset = src_lock.Stride;
            }
 
            src_row = src_origin;
            dst_row = dst_lock.Scan0;
            for (y=0; y<height; y++)
            {
                src_pixel = src_row;
                dst_pixel = dst_row;
                for (x=0; x<width; x++)
                {
                    /* FIXME: This could probably be faster without memcpy. */
                    memcpy(dst_pixel, src_pixel, bytesperpixel);
                    dst_pixel += bytesperpixel;
                    src_pixel += src_x_offset;
                }
                src_row += src_y_offset;
                dst_row += dst_lock.Stride;
            }
 
            GdipBitmapUnlockBits(new_bitmap, &dst_lock);
        }
 
        GdipBitmapUnlockBits(bitmap, &src_lock);
    }
 
    if (stat == Ok)
        move_bitmap(bitmap, new_bitmap, FALSE);
    else
        GdipDisposeImage(&new_bitmap->image);
 
    image_unlock(image, unlock);
    return stat;
}

Referenced by Preview_OnCommand(), test_multiframegif(), and test_rotateflip().

◆ GdipImageSelectActiveFrame()

GpStatus WINGDIPAPI GdipImageSelectActiveFrame	(	GpImage *	image,
		GDIPCONST GUID *	dimensionID,
		UINT	frame
	)

Definition at line 4350 of file image.c.

{
    GpStatus stat;
    const struct image_codec *codec = NULL;
    BOOL unlock;
 
    TRACE("(%p,%s,%u)\n", image, debugstr_guid(dimensionID), frame);
 
    if (!image || !dimensionID)
        return InvalidParameter;
    if(!image_lock(image, &unlock))
        return ObjectBusy;
 
    if (frame >= image->frame_count)
    {
        WARN("requested frame %u, but image has only %u\n", frame, image->frame_count);
        image_unlock(image, unlock);
        return InvalidParameter;
    }
 
    if (image->type != ImageTypeBitmap && image->type != ImageTypeMetafile)
    {
        WARN("invalid image type %d\n", image->type);
        image_unlock(image, unlock);
        return InvalidParameter;
    }
 
    if (image->current_frame == frame)
    {
        image_unlock(image, unlock);
        return Ok;
    }
 
    if (!image->decoder)
    {
        TRACE("image doesn't have an associated decoder\n");
        image_unlock(image, unlock);
        return Ok;
    }
 
    /* choose an appropriate image decoder */
    stat = get_decoder_info_from_image(image, &codec);
    if (stat != Ok)
    {
        WARN("can't find decoder info\n");
        image_unlock(image, unlock);
        return stat;
    }
 
    stat = codec->select_func(image, frame);
    image_unlock(image, unlock);
    return stat;
}

Referenced by Anime_SetFrameIndex(), test_GdipImageGetFrameDimensionsCount(), test_gif_properties(), and test_multiframegif().

◆ GdipImageSetAbort()

GpStatus WINGDIPAPI GdipImageSetAbort	(	GpImage *	image,
		GdiplusAbort *	pabort
	)

Definition at line 5533 of file image.c.

{
    TRACE("(%p, %p)\n", image, pabort);
 
    if (!image)
        return InvalidParameter;
 
    if (pabort)
        FIXME("Abort callback is not supported.\n");
 
    return Ok;
}

◆ GdipInitializePalette()

GpStatus WINGDIPAPI GdipInitializePalette	(	ColorPalette *	palette,
		PaletteType	type,
		INT	desired,
		BOOL	transparent,
		GpBitmap *	bitmap
	)

Definition at line 5748 of file image.c.

{
    TRACE("(%p,%d,%d,%d,%p)\n", palette, type, desired, transparent, bitmap);
 
    if (!palette) return InvalidParameter;
 
    switch (type)
    {
    case PaletteTypeCustom:
        return Ok;
 
    case PaletteTypeOptimal:
        return create_optimal_palette(palette, desired, transparent, bitmap);
 
    /* WIC palette type enumeration matches these gdiplus enums */
    case PaletteTypeFixedBW:
    case PaletteTypeFixedHalftone8:
    case PaletteTypeFixedHalftone27:
    case PaletteTypeFixedHalftone64:
    case PaletteTypeFixedHalftone125:
    case PaletteTypeFixedHalftone216:
    case PaletteTypeFixedHalftone252:
    case PaletteTypeFixedHalftone256:
    {
        ColorPalette *wic_palette;
        GpStatus status = Ok;
 
        wic_palette = get_palette(NULL, type);
        if (!wic_palette) return OutOfMemory;
 
        if (palette->Count >= wic_palette->Count)
        {
            palette->Flags = wic_palette->Flags;
            palette->Count = wic_palette->Count;
            memcpy(palette->Entries, wic_palette->Entries, wic_palette->Count * sizeof(wic_palette->Entries[0]));
        }
        else
            status = GenericError;
 
        heap_free(wic_palette);
 
        return status;
    }
 
    default:
        FIXME("unknown palette type %d\n", type);
        break;
    }
 
    return InvalidParameter;
}

◆ GdipLoadImageFromFile()

GpStatus WINGDIPAPI GdipLoadImageFromFile	(	GDIPCONST WCHAR *	filename,
		GpImage **	image
	)

Definition at line 2976 of file image.c.

{
    GpStatus stat;
    IStream *stream;
 
    TRACE("(%s) %p\n", debugstr_w(filename), image);
 
    if (!filename || !image)
        return InvalidParameter;
 
    *image = NULL;
 
    stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
 
    if (stat != Ok)
        return stat;
 
    stat = GdipLoadImageFromStream(stream, image);
 
    IStream_Release(stream);
 
    return stat;
}

Referenced by GdipLoadImageFromFileICM(), SetWallpaper(), test_LoadingImages(), and test_SavingImages().

◆ GdipLoadImageFromFileICM()

GpStatus WINGDIPAPI GdipLoadImageFromFileICM	(	GDIPCONST WCHAR *	filename,
		GpImage **	image
	)

Definition at line 3002 of file image.c.

{
    TRACE("(%s) %p\n", debugstr_w(filename), image);
 
    return GdipLoadImageFromFile(filename, image);
}

Referenced by test_LoadingImages().

◆ GdipLoadImageFromStream()

GpStatus WINGDIPAPI GdipLoadImageFromStream	(	IStream *	stream,
		GpImage **	image
	)

Definition at line 4405 of file image.c.

{
    GpStatus stat;
    LARGE_INTEGER seek;
    HRESULT hr;
    const struct image_codec *codec=NULL;
 
    TRACE("%p %p\n", stream, image);
 
    if (!stream || !image)
        return InvalidParameter;
 
    /* choose an appropriate image decoder */
    stat = get_decoder_info(stream, &codec);
    if (stat != Ok) return stat;
 
    /* seek to the start of the stream */
    seek.QuadPart = 0;
    hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
    if (FAILED(hr)) return hresult_to_status(hr);
 
    /* call on the image decoder to do the real work */
    stat = codec->decode_func(stream, image);
 
    /* take note of the original data format */
    if (stat == Ok)
    {
        memcpy(&(*image)->format, &codec->info.FormatID, sizeof(GUID));
        return Ok;
    }
 
    return stat;
}

Referenced by GdipCreateBitmapFromStream(), GdipCreateMetafileFromStream(), GdipLoadImageFromFile(), GdipLoadImageFromStreamICM(), load_image(), Preview_pLoadImage(), test_bufferrawformat(), test_GdipLoadImageFromStream(), and test_loadwmf().

◆ GdipLoadImageFromStreamICM()

GpStatus WINGDIPAPI GdipLoadImageFromStreamICM	(	IStream *	stream,
		GpImage **	image
	)

Definition at line 4440 of file image.c.

{
    TRACE("%p %p\n", stream, image);
 
    return GdipLoadImageFromStream(stream, image);
}

◆ GdipRemovePropertyItem()

GpStatus WINGDIPAPI GdipRemovePropertyItem	(	GpImage *	image,
		PROPID	propId
	)

Definition at line 4447 of file image.c.

{
    static int calls;
 
    TRACE("(%p,%u)\n", image, propId);
 
    if(!image)
        return InvalidParameter;
 
    if(!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

◆ GdipSaveAdd()

GpStatus WINGDIPAPI GdipSaveAdd	(	GpImage *	image,
		GDIPCONST EncoderParameters *	params
	)

Definition at line 4701 of file image.c.

{
    FIXME("(%p,%p): stub\n", image, params);
    return Ok;
}

◆ GdipSaveImageToFile()

GpStatus WINGDIPAPI GdipSaveImageToFile	(	GpImage *	image,
		GDIPCONST WCHAR *	filename,
		GDIPCONST CLSID *	clsidEncoder,
		GDIPCONST EncoderParameters *	encoderParams
	)

Definition at line 4476 of file image.c.

{
    GpStatus stat;
    IStream *stream;
 
    TRACE("%p (%s) %p %p\n", image, debugstr_w(filename), clsidEncoder, encoderParams);
 
    if (!image || !filename|| !clsidEncoder)
        return InvalidParameter;
 
    stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
    if (stat != Ok)
        return GenericError;
 
    stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
 
    IStream_Release(stream);
    return stat;
}

Referenced by Preview_pSaveImage(), Preview_pSaveImageAs(), SetWallpaper(), and test_SavingImages().

◆ GdipSaveImageToStream()

GpStatus WINGDIPAPI GdipSaveImageToStream	(	GpImage *	image,
		IStream *	stream,
		GDIPCONST CLSID *	clsid,
		GDIPCONST EncoderParameters *	params
	)

Definition at line 4671 of file image.c.

{
    GpStatus stat;
    encode_image_func encode_image;
    int i;
 
    TRACE("%p, %p, %s, %p\n", image, stream, wine_dbgstr_guid(clsid), params);
 
    if(!image || !stream)
        return InvalidParameter;
 
    /* select correct encoder */
    encode_image = NULL;
    for (i = 0; i < NUM_CODECS; i++) {
        if ((codecs[i].info.Flags & ImageCodecFlagsEncoder) &&
            IsEqualCLSID(clsid, &codecs[i].info.Clsid))
            encode_image = codecs[i].encode_func;
    }
    if (encode_image == NULL)
        return UnknownImageFormat;
 
    stat = encode_image(image, stream, params);
 
    return stat;
}

Referenced by GdipSaveImageToFile(), and test_supported_encoders().

◆ GdipSetEffectParameters()

GpStatus WINGDIPAPI GdipSetEffectParameters	(	CGpEffect *	effect,
		const VOID *	params,
		const UINT	size
	)

Definition at line 5298 of file image.c.

{
    static int calls;
 
    TRACE("(%p,%p,%u)\n", effect, params, size);
 
    if(!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

◆ GdipSetImagePalette()

GpStatus WINGDIPAPI GdipSetImagePalette	(	GpImage *	image,
		GDIPCONST ColorPalette *	palette
	)

Definition at line 4744 of file image.c.

{
    ColorPalette *new_palette;
 
    TRACE("(%p,%p)\n", image, palette);
 
    if(!image || !palette || palette->Count > 256)
        return InvalidParameter;
 
    new_palette = heap_alloc_zero(2 * sizeof(UINT) + palette->Count * sizeof(ARGB));
    if (!new_palette) return OutOfMemory;
 
    heap_free(image->palette);
    image->palette = new_palette;
    image->palette->Flags = palette->Flags;
    image->palette->Count = palette->Count;
    memcpy(image->palette->Entries, palette->Entries, sizeof(ARGB)*palette->Count);
 
    return Ok;
}

Referenced by GdipCreateBitmapFromHBITMAP(), metafile_deserialize_image(), test_bitmapbits(), and test_palette().

◆ GdipSetPropertyItem()

GpStatus WINGDIPAPI GdipSetPropertyItem	(	GpImage *	image,
		GDIPCONST PropertyItem *	item
	)

Definition at line 4462 of file image.c.

{
    static int calls;
 
    if (!image || !item) return InvalidParameter;
 
    TRACE("(%p,%p:%#x,%u,%u,%p)\n", image, item, item->id, item->type, item->length, item->value);
 
    if(!(calls++))
        FIXME("not implemented\n");
 
    return Ok;
}

◆ GdipTestControl()

GpStatus WINGDIPAPI GdipTestControl	(	GpTestControlEnum	control,
		void *	param
	)

Definition at line 5326 of file image.c.

{
    TRACE("(%d, %p)\n", control, param);
 
    switch(control){
        case TestControlForceBilinear:
            if(param)
                FIXME("TestControlForceBilinear not handled\n");
            break;
        case TestControlNoICM:
            if(param)
                FIXME("TestControlNoICM not handled\n");
            break;
        case TestControlGetBuildNumber:
            *((DWORD*)param) = 3102;
            break;
    }
 
    return Ok;
}

Referenced by test_testcontrol().

◆ generate_halftone_palette()

static void generate_halftone_palette	(	ARGB *	entries,
		UINT	count
	)

static

Definition at line 1708 of file image.c.

{
    static const BYTE halftone_values[6]={0x00,0x33,0x66,0x99,0xcc,0xff};
    UINT i;
 
    for (i=0; i<8 && i<count; i++)
    {
        entries[i] = 0xff000000;
        if (i&1) entries[i] |= 0x800000;
        if (i&2) entries[i] |= 0x8000;
        if (i&4) entries[i] |= 0x80;
    }
 
    if (8 < count)
        entries[i] = 0xffc0c0c0;
 
    for (i=9; i<16 && i<count; i++)
    {
        entries[i] = 0xff000000;
        if (i&1) entries[i] |= 0xff0000;
        if (i&2) entries[i] |= 0xff00;
        if (i&4) entries[i] |= 0xff;
    }
 
    for (i=16; i<40 && i<count; i++)
    {
        entries[i] = 0;
    }
 
    for (i=40; i<256 && i<count; i++)
    {
        entries[i] = 0xff000000;
        entries[i] |= halftone_values[(i-40)%6];
        entries[i] |= halftone_values[((i-40)/6)%6] << 8;
        entries[i] |= halftone_values[((i-40)/36)%6] << 16;
    }
}

Referenced by GdipCreateBitmapFromScan0().

◆ get_16bpp_format()

static PixelFormat get_16bpp_format ( HBITMAP hbm )

static

Definition at line 5108 of file image.c.

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

Referenced by GdipCreateBitmapFromHBITMAP().

◆ get_bool_property()

static BOOL get_bool_property	(	IWICMetadataReader *	reader,
		const GUID *	guid,
		const WCHAR *	prop_name
	)

static

Definition at line 3053 of file image.c.

{
    HRESULT hr;
    GUID format;
    PROPVARIANT id, value;
    BOOL ret = FALSE;
 
    hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
    if (FAILED(hr) || !IsEqualGUID(&format, guid)) return FALSE;
 
    PropVariantInit(&id);
    PropVariantInit(&value);
 
    id.vt = VT_LPWSTR;
    id.u.pwszVal = CoTaskMemAlloc((lstrlenW(prop_name) + 1) * sizeof(WCHAR));
    if (!id.u.pwszVal) return FALSE;
    lstrcpyW(id.u.pwszVal, prop_name);
    hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
    if (hr == S_OK && value.vt == VT_BOOL)
        ret = value.u.boolVal;
 
    PropVariantClear(&id);
    PropVariantClear(&value);
 
    return ret;
}

Referenced by get_gif_palette(), and get_gif_transparent_idx().

◆ get_decoder_info()

static GpStatus get_decoder_info	(	IStream *	stream,
		const struct image_codec **	result
	)

static

Definition at line 4285 of file image.c.

{
    BYTE signature[8];
    const BYTE *pattern, *mask;
    LARGE_INTEGER seek;
    HRESULT hr;
    UINT bytesread;
    int i;
    DWORD j, sig;
 
    /* seek to the start of the stream */
    seek.QuadPart = 0;
    hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
    if (FAILED(hr)) return hresult_to_status(hr);
 
    /* read the first 8 bytes */
    /* FIXME: This assumes all codecs have signatures <= 8 bytes in length */
    hr = IStream_Read(stream, signature, 8, &bytesread);
    if (FAILED(hr)) return hresult_to_status(hr);
    if (hr == S_FALSE || bytesread == 0) return GenericError;
 
    for (i = 0; i < NUM_CODECS; i++) {
        if ((codecs[i].info.Flags & ImageCodecFlagsDecoder) &&
            bytesread >= codecs[i].info.SigSize)
        {
            for (sig=0; sig<codecs[i].info.SigCount; sig++)
            {
                pattern = &codecs[i].info.SigPattern[codecs[i].info.SigSize*sig];
                mask = &codecs[i].info.SigMask[codecs[i].info.SigSize*sig];
                for (j=0; j<codecs[i].info.SigSize; j++)
                    if ((signature[j] & mask[j]) != pattern[j])
                        break;
                if (j == codecs[i].info.SigSize)
                {
                    *result = &codecs[i];
                    return Ok;
                }
            }
        }
    }
 
    TRACE("no match for %i byte signature %x %x %x %x %x %x %x %x\n", bytesread,
        signature[0],signature[1],signature[2],signature[3],
        signature[4],signature[5],signature[6],signature[7]);
 
    return GenericError;
}

Referenced by BmpDecoder_GetDecoderInfo(), GdipLoadImageFromStream(), GifDecoder_GetDecoderInfo(), IcoDecoder_GetDecoderInfo(), and TgaDecoder_GetDecoderInfo().

◆ get_decoder_info_from_image()

static GpStatus get_decoder_info_from_image	(	GpImage *	image,
		const struct image_codec **	result
	)

static

Definition at line 4333 of file image.c.

{
    int i;
 
    for (i = 0; i < NUM_CODECS; i++) {
        if ((codecs[i].info.Flags & ImageCodecFlagsDecoder) &&
                IsEqualIID(&codecs[i].info.FormatID, &image->format))
        {
            *result = &codecs[i];
            return Ok;
        }
    }
 
    TRACE("no match for format: %s\n", wine_dbgstr_guid(&image->format));
    return GenericError;
}

Referenced by GdipImageSelectActiveFrame().

◆ get_gif_background()

static PropertyItem * get_gif_background ( IWICMetadataReader * reader )

static

Definition at line 3172 of file image.c.

{
    static const WCHAR backgroundW[] = { 'B','a','c','k','g','r','o','u','n','d','C','o','l','o','r','I','n','d','e','x',0 };
    PropertyItem *background;
 
    background = get_property(reader, &GUID_MetadataFormatLSD, backgroundW);
    if (background)
        background->id = PropertyTagIndexBackground;
 
    return background;
}

Referenced by gif_metadata_reader().

◆ get_gif_background_color()

static DWORD get_gif_background_color ( GpBitmap * bitmap )

static

Definition at line 3873 of file image.c.

{
    BYTE bgcolor_idx = 0;
    UINT i;
 
    for(i=0; i<bitmap->prop_count; i++) {
        if(bitmap->prop_item[i].id == PropertyTagIndexBackground) {
            bgcolor_idx = *(BYTE*)bitmap->prop_item[i].value;
            break;
        }
    }
 
    for(i=0; i<bitmap->prop_count; i++) {
        if(bitmap->prop_item[i].id == PropertyTagIndexTransparent) {
            BYTE transparent_idx;
            transparent_idx = *(BYTE*)bitmap->prop_item[i].value;
 
            if(transparent_idx == bgcolor_idx)
                return 0;
        }
    }
 
    for(i=0; i<bitmap->prop_count; i++) {
        if(bitmap->prop_item[i].id == PropertyTagGlobalPalette) {
            if(bitmap->prop_item[i].length/3 > bgcolor_idx) {
                BYTE *color = ((BYTE*)bitmap->prop_item[i].value)+bgcolor_idx*3;
                return color[2] + (color[1]<<8) + (color[0]<<16) + (0xffu<<24);
            }
            break;
        }
    }
 
    FIXME("can't get gif background color\n");
    return 0xffffffff;
}

Referenced by select_frame_gif().

◆ get_gif_comment()

static PropertyItem * get_gif_comment ( IWICMetadataReader * reader )

static

Definition at line 3119 of file image.c.

{
    static const WCHAR textentryW[] = { 'T','e','x','t','E','n','t','r','y',0 };
    PropertyItem *comment;
 
    comment = get_property(reader, &GUID_MetadataFormatGifComment, textentryW);
    if (comment)
        comment->id = PropertyTagExifUserComment;
 
    return comment;
}

Referenced by gif_metadata_reader().

◆ get_gif_frame_property()

static LONG get_gif_frame_property	(	IWICBitmapFrameDecode *	frame,
		const GUID *	format,
		const WCHAR *	property
	)

static

Definition at line 3254 of file image.c.

{
    HRESULT hr;
    IWICMetadataBlockReader *block_reader;
    IWICMetadataReader *reader;
    UINT block_count, i;
    PropertyItem *prop;
    LONG value = 0;
 
    hr = IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader);
    if (hr == S_OK)
    {
        hr = IWICMetadataBlockReader_GetCount(block_reader, &block_count);
        if (hr == S_OK)
        {
            for (i = 0; i < block_count; i++)
            {
                hr = IWICMetadataBlockReader_GetReaderByIndex(block_reader, i, &reader);
                if (hr == S_OK)
                {
                    prop = get_property(reader, format, property);
                    if (prop)
                    {
                        if (prop->type == PropertyTagTypeByte && prop->length == 1)
                            value = *(BYTE *)prop->value;
                        else if (prop->type == PropertyTagTypeShort && prop->length == 2)
                            value = *(SHORT *)prop->value;
 
                        heap_free(prop);
                    }
                    IWICMetadataReader_Release(reader);
                }
            }
        }
        IWICMetadataBlockReader_Release(block_reader);
    }
 
    return value;
}

Referenced by get_gif_frame_rect(), gif_metadata_reader(), and select_frame_gif().

◆ get_gif_frame_rect()

static HRESULT get_gif_frame_rect	(	IWICBitmapFrameDecode *	frame,
		UINT *	left,
		UINT *	top,
		UINT *	width,
		UINT *	height
	)

static

Definition at line 3822 of file image.c.

{
    static const WCHAR leftW[] = {'L','e','f','t',0};
    static const WCHAR topW[] = {'T','o','p',0};
 
    *left = get_gif_frame_property(frame, &GUID_MetadataFormatIMD, leftW);
    *top = get_gif_frame_property(frame, &GUID_MetadataFormatIMD, topW);
 
    return IWICBitmapFrameDecode_GetSize(frame, width, height);
}

Referenced by blit_gif_frame(), and select_frame_gif().

◆ get_gif_loopcount()

static PropertyItem * get_gif_loopcount ( IWICMetadataReader * reader )

static

Definition at line 3131 of file image.c.

{
    static const WCHAR applicationW[] = { 'A','p','p','l','i','c','a','t','i','o','n',0 };
    static const WCHAR dataW[] = { 'D','a','t','a',0 };
    PropertyItem *appext = NULL, *appdata = NULL, *loop = NULL;
 
    appext = get_property(reader, &GUID_MetadataFormatAPE, applicationW);
    if (appext)
    {
        if (appext->type == PropertyTagTypeByte && appext->length == 11 &&
            (!memcmp(appext->value, "NETSCAPE2.0", 11) || !memcmp(appext->value, "ANIMEXTS1.0", 11)))
        {
            appdata = get_property(reader, &GUID_MetadataFormatAPE, dataW);
            if (appdata)
            {
                if (appdata->type == PropertyTagTypeByte && appdata->length == 4)
                {
                    BYTE *data = appdata->value;
                    if (data[0] == 3 && data[1] == 1)
                    {
                        loop = heap_alloc_zero(sizeof(*loop) + sizeof(SHORT));
                        if (loop)
                        {
                            loop->type = PropertyTagTypeShort;
                            loop->id = PropertyTagLoopCount;
                            loop->length = sizeof(SHORT);
                            loop->value = loop + 1;
                            *(SHORT *)loop->value = data[2] | (data[3] << 8);
                        }
                    }
                }
            }
        }
    }
 
    heap_free(appext);
    heap_free(appdata);
 
    return loop;
}

Referenced by gif_metadata_reader().

◆ get_gif_palette()

static PropertyItem * get_gif_palette	(	IWICBitmapDecoder *	decoder,
		IWICMetadataReader *	reader
	)

static

Definition at line 3184 of file image.c.

{
    static const WCHAR global_flagW[] = { 'G','l','o','b','a','l','C','o','l','o','r','T','a','b','l','e','F','l','a','g',0 };
    HRESULT hr;
    IWICImagingFactory *factory;
    IWICPalette *palette;
    UINT count = 0;
    WICColor colors[256];
 
    if (!get_bool_property(reader, &GUID_MetadataFormatLSD, global_flagW))
        return NULL;
 
    hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
    if (hr != S_OK) return NULL;
 
    hr = IWICImagingFactory_CreatePalette(factory, &palette);
    if (hr == S_OK)
    {
        hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
        if (hr == S_OK)
            IWICPalette_GetColors(palette, 256, colors, &count);
 
        IWICPalette_Release(palette);
    }
 
    IWICImagingFactory_Release(factory);
 
    if (count)
    {
        PropertyItem *pal;
        UINT i;
        BYTE *rgb;
 
        pal = heap_alloc_zero(sizeof(*pal) + count * 3);
        if (!pal) return NULL;
        pal->type = PropertyTagTypeByte;
        pal->id = PropertyTagGlobalPalette;
        pal->value = pal + 1;
        pal->length = count * 3;
 
        rgb = pal->value;
 
        for (i = 0; i < count; i++)
        {
            rgb[i*3] = (colors[i] >> 16) & 0xff;
            rgb[i*3 + 1] = (colors[i] >> 8) & 0xff;
            rgb[i*3 + 2] = colors[i] & 0xff;
        }
 
        return pal;
    }
 
    return NULL;
}

Referenced by gif_metadata_reader().

◆ get_gif_transparent_idx()

static PropertyItem * get_gif_transparent_idx ( IWICMetadataReader * reader )

static

Definition at line 3239 of file image.c.

{
    static const WCHAR transparency_flagW[] = { 'T','r','a','n','s','p','a','r','e','n','c','y','F','l','a','g',0 };
    static const WCHAR colorW[] = { 'T','r','a','n','s','p','a','r','e','n','t','C','o','l','o','r','I','n','d','e','x',0 };
    PropertyItem *index = NULL;
 
    if (get_bool_property(reader, &GUID_MetadataFormatGCE, transparency_flagW))
    {
        index = get_property(reader, &GUID_MetadataFormatGCE, colorW);
        if (index)
            index->id = PropertyTagIndexTransparent;
    }
    return index;
}

Referenced by gif_metadata_reader().

◆ get_palette()

static ColorPalette * get_palette	(	IWICBitmapFrameDecode *	frame,
		WICBitmapPaletteType	palette_type
	)

static

Definition at line 74 of file image.c.

{
    HRESULT hr;
    IWICImagingFactory *factory;
    IWICPalette *wic_palette;
    ColorPalette *palette = NULL;
 
    hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
    if (hr != S_OK) return NULL;
 
    hr = IWICImagingFactory_CreatePalette(factory, &wic_palette);
    if (hr == S_OK)
    {
        hr = WINCODEC_ERR_PALETTEUNAVAILABLE;
        if (frame)
            hr = IWICBitmapFrameDecode_CopyPalette(frame, wic_palette);
        if (hr != S_OK)
        {
            TRACE("using predefined palette %#x\n", palette_type);
            hr = IWICPalette_InitializePredefined(wic_palette, palette_type, FALSE);
        }
        if (hr == S_OK)
        {
            WICBitmapPaletteType type;
            BOOL alpha;
            UINT count;
 
            IWICPalette_GetColorCount(wic_palette, &count);
            palette = heap_alloc(2 * sizeof(UINT) + count * sizeof(ARGB));
            IWICPalette_GetColors(wic_palette, count, palette->Entries, &palette->Count);
 
            IWICPalette_GetType(wic_palette, &type);
            switch(type) {
                case WICBitmapPaletteTypeFixedGray4:
                case WICBitmapPaletteTypeFixedGray16:
                case WICBitmapPaletteTypeFixedGray256:
                    palette->Flags = PaletteFlagsGrayScale;
                    break;
                case WICBitmapPaletteTypeFixedHalftone8:
                case WICBitmapPaletteTypeFixedHalftone27:
                case WICBitmapPaletteTypeFixedHalftone64:
                case WICBitmapPaletteTypeFixedHalftone125:
                case WICBitmapPaletteTypeFixedHalftone216:
                case WICBitmapPaletteTypeFixedHalftone252:
                case WICBitmapPaletteTypeFixedHalftone256:
                    palette->Flags = PaletteFlagsHalftone;
                    break;
                default:
                    palette->Flags = 0;
            }
            IWICPalette_HasAlpha(wic_palette, &alpha);
            if(alpha)
                palette->Flags |= PaletteFlagsHasAlpha;
        }
        IWICPalette_Release(wic_palette);
    }
    IWICImagingFactory_Release(factory);
    return palette;
}

Referenced by decode_frame_wic(), and GdipInitializePalette().

◆ get_palette_index()

static UINT get_palette_index	(	BYTE	r,
		BYTE	g,
		BYTE	b,
		BYTE	a,
		ColorPalette *	palette
	)

inlinestatic

Definition at line 358 of file image.c.

{
    BYTE index = 0;
    int best_distance = 0x7fff;
    int distance;
    UINT i;
 
    if (!palette) return 0;
    /* This algorithm scans entire palette,
       computes difference from desired color (all color components have equal weight)
       and returns the index of color with least difference.
 
       Note: Maybe it could be replaced with a better algorithm for better image quality
       and performance, though better algorithm would probably need some pre-built lookup
       tables and thus may actually be slower if this method is called only few times per
       every image.
    */
    for(i=0;i<palette->Count;i++) {
        ARGB color=palette->Entries[i];
        distance=abs(b-(color & 0xff)) + abs(g-(color>>8 & 0xff)) + abs(r-(color>>16 & 0xff)) + abs(a-(color>>24 & 0xff));
        if (distance<best_distance) {
            best_distance=distance;
            index=i;
        }
    }
    return index;
}

Referenced by setpixel_1bppIndexed(), setpixel_4bppIndexed(), and setpixel_8bppIndexed().

◆ get_property()

static PropertyItem * get_property	(	IWICMetadataReader *	reader,
		const GUID *	guid,
		const WCHAR *	prop_name
	)

static

Definition at line 3080 of file image.c.

{
    HRESULT hr;
    GUID format;
    PROPVARIANT id, value;
    PropertyItem *item = NULL;
 
    hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
    if (FAILED(hr) || !IsEqualGUID(&format, guid)) return NULL;
 
    PropVariantInit(&id);
    PropVariantInit(&value);
 
    id.vt = VT_LPWSTR;
    id.u.pwszVal = CoTaskMemAlloc((lstrlenW(prop_name) + 1) * sizeof(WCHAR));
    if (!id.u.pwszVal) return NULL;
    lstrcpyW(id.u.pwszVal, prop_name);
    hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
    if (hr == S_OK)
    {
        UINT item_size = propvariant_size(&value);
        if (item_size)
        {
            item_size += sizeof(*item);
            item = heap_alloc_zero(item_size);
            if (propvariant_to_item(&value, item, item_size, 0) != Ok)
            {
                heap_free(item);
                item = NULL;
            }
        }
    }
 
    PropVariantClear(&id);
    PropVariantClear(&value);
 
    return item;
}

Referenced by FT_DEFINE_SERVICE(), get_gif_background(), get_gif_comment(), get_gif_frame_property(), get_gif_loopcount(), and get_gif_transparent_idx().

◆ get_screen_resolution()

static GpStatus get_screen_resolution	(	REAL *	xres,
		REAL *	yres
	)

static

Definition at line 1746 of file image.c.

{
    HDC screendc = CreateCompatibleDC(0);
 
    if (!screendc) return GenericError;
 
    *xres = (REAL)GetDeviceCaps(screendc, LOGPIXELSX);
    *yres = (REAL)GetDeviceCaps(screendc, LOGPIXELSY);
 
    DeleteDC(screendc);
 
    return Ok;
}

Referenced by GdipCreateBitmapFromScan0().

◆ get_ulong_by_index()

static ULONG get_ulong_by_index	(	IWICMetadataReader *	reader,
		ULONG	index
	)

static

Definition at line 3438 of file image.c.

{
    PROPVARIANT value;
    HRESULT hr;
    ULONG result=0;
 
    hr = IWICMetadataReader_GetValueByIndex(reader, index, NULL, NULL, &value);
    if (SUCCEEDED(hr))
    {
        switch (value.vt)
        {
        case VT_UI4:
            result = value.u.ulVal;
            break;
        default:
            ERR("unhandled case %u\n", value.vt);
            break;
        }
        PropVariantClear(&value);
    }
    return result;
}

Referenced by png_metadata_reader().

◆ getpixel_16bppARGB1555()

static void getpixel_16bppARGB1555	(	BYTE *	r,
		BYTE *	g,
		BYTE *	b,
		BYTE *	a,
		const BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 202 of file image.c.

{
    WORD pixel = *((const WORD*)(row)+x);
    *r = (pixel>>7&0xf8)|(pixel>>12&0x7);
    *g = (pixel>>2&0xf8)|(pixel>>6&0x7);
    *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
    if ((pixel&0x8000) == 0x8000)
        *a = 255;
    else
        *a = 0;
}

Referenced by convert_pixels(), and GdipBitmapGetPixel().

◆ getpixel_16bppGrayScale()

static void getpixel_16bppGrayScale	(	BYTE *	r,
		BYTE *	g,
		BYTE *	b,
		BYTE *	a,
		const BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 175 of file image.c.

{
    *r = *g = *b = row[x*2+1];
    *a = 255;
}

Referenced by convert_pixels(), and GdipBitmapGetPixel().

◆ getpixel_16bppRGB555()

static void getpixel_16bppRGB555	(	BYTE *	r,
		BYTE *	g,
		BYTE *	b,
		BYTE *	a,
		const BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 182 of file image.c.

{
    WORD pixel = *((const WORD*)(row)+x);
    *r = (pixel>>7&0xf8)|(pixel>>12&0x7);
    *g = (pixel>>2&0xf8)|(pixel>>6&0x7);
    *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
    *a = 255;
}

Referenced by convert_pixels(), and GdipBitmapGetPixel().

◆ getpixel_16bppRGB565()

static void getpixel_16bppRGB565	(	BYTE *	r,
		BYTE *	g,
		BYTE *	b,
		BYTE *	a,
		const BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 192 of file image.c.

{
    WORD pixel = *((const WORD*)(row)+x);
    *r = (pixel>>8&0xf8)|(pixel>>13&0x7);
    *g = (pixel>>3&0xfc)|(pixel>>9&0x3);
    *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
    *a = 255;
}

Referenced by convert_pixels(), and GdipBitmapGetPixel().

◆ getpixel_1bppIndexed()

static void getpixel_1bppIndexed	(	BYTE *	index,
		const BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 157 of file image.c.

{
    *index = (row[x/8]>>(7-x%8)) & 1;
}

Referenced by convert_pixels(), and GdipBitmapGetPixel().

◆ getpixel_24bppRGB()

static void getpixel_24bppRGB	(	BYTE *	r,
		BYTE *	g,
		BYTE *	b,
		BYTE *	a,
		const BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 215 of file image.c.

{
    *r = row[x*3+2];
    *g = row[x*3+1];
    *b = row[x*3];
    *a = 255;
}

Referenced by convert_pixels(), and GdipBitmapGetPixel().

◆ getpixel_32bppARGB()

static void getpixel_32bppARGB	(	BYTE *	r,
		BYTE *	g,
		BYTE *	b,
		BYTE *	a,
		const BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 233 of file image.c.

{
    *r = row[x*4+2];
    *g = row[x*4+1];
    *b = row[x*4];
    *a = row[x*4+3];
}

Referenced by convert_pixels(), and GdipBitmapGetPixel().

◆ getpixel_32bppPARGB()

static void getpixel_32bppPARGB	(	BYTE *	r,
		BYTE *	g,
		BYTE *	b,
		BYTE *	a,
		const BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 242 of file image.c.

{
    *a = row[x*4+3];
    if (*a == 0)
        *r = *g = *b = 0;
    else
    {
        *r = row[x*4+2] * 255 / *a;
        *g = row[x*4+1] * 255 / *a;
        *b = row[x*4] * 255 / *a;
    }
}

Referenced by convert_pixels(), and GdipBitmapGetPixel().

◆ getpixel_32bppRGB()

static void getpixel_32bppRGB	(	BYTE *	r,
		BYTE *	g,
		BYTE *	b,
		BYTE *	a,
		const BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 224 of file image.c.

{
    *r = row[x*4+2];
    *g = row[x*4+1];
    *b = row[x*4];
    *a = 255;
}

Referenced by convert_pixels(), and GdipBitmapGetPixel().

◆ getpixel_48bppRGB()

static void getpixel_48bppRGB	(	BYTE *	r,
		BYTE *	g,
		BYTE *	b,
		BYTE *	a,
		const BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 256 of file image.c.

{
    *r = row[x*6+5];
    *g = row[x*6+3];
    *b = row[x*6+1];
    *a = 255;
}

Referenced by convert_pixels(), and GdipBitmapGetPixel().

◆ getpixel_4bppIndexed()

static void getpixel_4bppIndexed	(	BYTE *	index,
		const BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 162 of file image.c.

{
    if (x & 1)
        *index = row[x/2]&0xf;
    else
        *index = row[x/2]>>4;
}

Referenced by convert_pixels(), and GdipBitmapGetPixel().

◆ getpixel_64bppARGB()

static void getpixel_64bppARGB	(	BYTE *	r,
		BYTE *	g,
		BYTE *	b,
		BYTE *	a,
		const BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 265 of file image.c.

{
    *r = row[x*8+5];
    *g = row[x*8+3];
    *b = row[x*8+1];
    *a = row[x*8+7];
}

Referenced by convert_pixels(), and GdipBitmapGetPixel().

◆ getpixel_64bppPARGB()

static void getpixel_64bppPARGB	(	BYTE *	r,
		BYTE *	g,
		BYTE *	b,
		BYTE *	a,
		const BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 274 of file image.c.

{
    *a = row[x*8+7];
    if (*a == 0)
        *r = *g = *b = 0;
    else
    {
        *r = row[x*8+5] * 255 / *a;
        *g = row[x*8+3] * 255 / *a;
        *b = row[x*8+1] * 255 / *a;
    }
}

Referenced by convert_pixels(), and GdipBitmapGetPixel().

◆ getpixel_8bppIndexed()

static void getpixel_8bppIndexed	(	BYTE *	index,
		const BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 170 of file image.c.

{
    *index = row[x];
}

Referenced by convert_pixels(), and GdipBitmapGetPixel().

◆ gif_metadata_reader()

static void gif_metadata_reader	(	GpBitmap *	bitmap,
		IWICBitmapDecoder *	decoder,
		UINT	active_frame
	)

static

Definition at line 3294 of file image.c.

{
    static const WCHAR delayW[] = { 'D','e','l','a','y',0 };
    HRESULT hr;
    IWICBitmapFrameDecode *frame;
    IWICMetadataBlockReader *block_reader;
    IWICMetadataReader *reader;
    UINT frame_count, block_count, i;
    PropertyItem *delay = NULL, *comment = NULL, *background = NULL;
    PropertyItem *transparent_idx = NULL, *loop = NULL, *palette = NULL;
 
    IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
    if (frame_count > 1)
    {
        delay = heap_alloc_zero(sizeof(*delay) + frame_count * sizeof(LONG));
        if (delay)
        {
            LONG *value;
 
            delay->type = PropertyTagTypeLong;
            delay->id = PropertyTagFrameDelay;
            delay->length = frame_count * sizeof(LONG);
            delay->value = delay + 1;
 
            value = delay->value;
 
            for (i = 0; i < frame_count; i++)
            {
                hr = IWICBitmapDecoder_GetFrame(decoder, i, &frame);
                if (hr == S_OK)
                {
                    value[i] = get_gif_frame_property(frame, &GUID_MetadataFormatGCE, delayW);
                    IWICBitmapFrameDecode_Release(frame);
                }
                else value[i] = 0;
            }
        }
    }
 
    hr = IWICBitmapDecoder_QueryInterface(decoder, &IID_IWICMetadataBlockReader, (void **)&block_reader);
    if (hr == S_OK)
    {
        hr = IWICMetadataBlockReader_GetCount(block_reader, &block_count);
        if (hr == S_OK)
        {
            for (i = 0; i < block_count; i++)
            {
                hr = IWICMetadataBlockReader_GetReaderByIndex(block_reader, i, &reader);
                if (hr == S_OK)
                {
                    if (!comment)
                        comment = get_gif_comment(reader);
 
                    if (frame_count > 1 && !loop)
                        loop = get_gif_loopcount(reader);
 
                    if (!background)
                        background = get_gif_background(reader);
 
                    if (!palette)
                        palette = get_gif_palette(decoder, reader);
 
                    IWICMetadataReader_Release(reader);
                }
            }
        }
        IWICMetadataBlockReader_Release(block_reader);
    }
 
    if (frame_count > 1 && !loop)
    {
        loop = heap_alloc_zero(sizeof(*loop) + sizeof(SHORT));
        if (loop)
        {
            loop->type = PropertyTagTypeShort;
            loop->id = PropertyTagLoopCount;
            loop->length = sizeof(SHORT);
            loop->value = loop + 1;
            *(SHORT *)loop->value = 1;
        }
    }
 
    if (delay) add_property(bitmap, delay);
    if (comment) add_property(bitmap, comment);
    if (loop) add_property(bitmap, loop);
    if (palette) add_property(bitmap, palette);
    if (background) add_property(bitmap, background);
 
    heap_free(delay);
    heap_free(comment);
    heap_free(loop);
    heap_free(palette);
    heap_free(background);
 
    /* Win7 gdiplus always returns transparent color index from frame 0 */
    hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
    if (hr != S_OK) return;
 
    hr = IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader);
    if (hr == S_OK)
    {
        hr = IWICMetadataBlockReader_GetCount(block_reader, &block_count);
        if (hr == S_OK)
        {
            for (i = 0; i < block_count; i++)
            {
                hr = IWICMetadataBlockReader_GetReaderByIndex(block_reader, i, &reader);
                if (hr == S_OK)
                {
                    if (!transparent_idx)
                        transparent_idx = get_gif_transparent_idx(reader);
 
                    IWICMetadataReader_Release(reader);
                }
            }
        }
        IWICMetadataBlockReader_Release(block_reader);
    }
 
    if (transparent_idx) add_property(bitmap, transparent_idx);
    heap_free(transparent_idx);
 
    IWICBitmapFrameDecode_Release(frame);
}

Referenced by decode_image_gif().

◆ has_png_transparency_chunk()

static BOOL has_png_transparency_chunk ( IStream * pIStream )

static

Definition at line 4006 of file image.c.

{
    LARGE_INTEGER seek;
    BOOL has_tRNS = FALSE;
    HRESULT hr;
    BYTE header[8];
 
    seek.QuadPart = 8;
    do
    {
        ULARGE_INTEGER chunk_start;
        ULONG bytesread, chunk_size;
 
        hr = IStream_Seek(pIStream, seek, STREAM_SEEK_SET, &chunk_start);
        if (FAILED(hr)) break;
 
        hr = IStream_Read(pIStream, header, 8, &bytesread);
        if (FAILED(hr) || bytesread < 8) break;
 
        chunk_size = (header[0] << 24) | (header[1] << 16) | (header[2] << 8) | header[3];
        if (!memcmp(&header[4], "tRNS", 4))
        {
            has_tRNS = TRUE;
            break;
        }
 
        seek.QuadPart = chunk_start.QuadPart + chunk_size + 12; /* skip data and CRC */
    } while (memcmp(&header[4], "IDAT", 4) && memcmp(&header[4], "IEND", 4));
 
    TRACE("has_tRNS = %d\n", has_tRNS);
    return has_tRNS;
}

Referenced by decode_image_png().

◆ initialize_decoder_wic()

static GpStatus initialize_decoder_wic	(	IStream *	stream,
		REFGUID	container,
		IWICBitmapDecoder **	decoder
	)

static

Definition at line 3612 of file image.c.

{
    IWICImagingFactory *factory;
    HRESULT hr;
 
    TRACE("%p,%s\n", stream, wine_dbgstr_guid(container));
 
    hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
    if (FAILED(hr)) return hresult_to_status(hr);
    hr = IWICImagingFactory_CreateDecoder(factory, container, NULL, decoder);
    IWICImagingFactory_Release(factory);
    if (FAILED(hr)) return hresult_to_status(hr);
 
    hr = IWICBitmapDecoder_Initialize(*decoder, stream, WICDecodeMetadataCacheOnLoad);
    if (FAILED(hr)) return hresult_to_status(hr);
    return Ok;
}

Referenced by decode_image_gif(), decode_image_png(), and decode_image_wic().

◆ load_emf()

static GpStatus load_emf	(	IStream *	stream,
		GpMetafile **	metafile
	)

static

Definition at line 4195 of file image.c.

{
    LARGE_INTEGER seek;
    ENHMETAHEADER emh;
    HENHMETAFILE hemf;
    GpStatus status;
    HRESULT hr;
    UINT size;
    void *buf;
 
    hr = IStream_Read(stream, &emh, sizeof(emh), &size);
    if (hr != S_OK || size != sizeof(emh) || emh.dSignature != ENHMETA_SIGNATURE)
        return GenericError;
 
    seek.QuadPart = 0;
    hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
    if (FAILED(hr)) return hresult_to_status(hr);
 
    buf = heap_alloc(emh.nBytes);
    if (!buf) return OutOfMemory;
 
    hr = IStream_Read(stream, buf, emh.nBytes, &size);
    if (hr != S_OK || size != emh.nBytes)
    {
        heap_free(buf);
        return GenericError;
    }
 
    hemf = SetEnhMetaFileBits(emh.nBytes, buf);
    heap_free(buf);
    if (!hemf)
        return GenericError;
 
    status = GdipCreateMetafileFromEmf(hemf, TRUE, metafile);
    if (status != Ok)
        DeleteEnhMetaFile(hemf);
    return status;
}

Referenced by decode_image_emf().

◆ load_wmf()

static GpStatus load_wmf	(	IStream *	stream,
		GpMetafile **	metafile
	)

static

Definition at line 4114 of file image.c.

{
    WmfPlaceableFileHeader pfh;
    BOOL is_placeable = FALSE;
    LARGE_INTEGER seek;
    GpStatus status;
    METAHEADER mh;
    HMETAFILE hmf;
    HRESULT hr;
    UINT size;
    void *buf;
 
    hr = IStream_Read(stream, &mh, sizeof(mh), &size);
    if (hr != S_OK || size != sizeof(mh))
        return GenericError;
 
    if (((WmfPlaceableFileHeader *)&mh)->Key == WMF_PLACEABLE_KEY)
    {
        seek.QuadPart = 0;
        hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
        if (FAILED(hr)) return hresult_to_status(hr);
 
        hr = IStream_Read(stream, &pfh, sizeof(pfh), &size);
        if (hr != S_OK || size != sizeof(pfh))
            return GenericError;
 
        hr = IStream_Read(stream, &mh, sizeof(mh), &size);
        if (hr != S_OK || size != sizeof(mh))
            return GenericError;
 
        is_placeable = TRUE;
    }
 
    seek.QuadPart = is_placeable ? sizeof(pfh) : 0;
    hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
    if (FAILED(hr)) return hresult_to_status(hr);
 
    buf = heap_alloc(mh.mtSize * 2);
    if (!buf) return OutOfMemory;
 
    hr = IStream_Read(stream, buf, mh.mtSize * 2, &size);
    if (hr != S_OK || size != mh.mtSize * 2)
    {
        heap_free(buf);
        return GenericError;
    }
 
    hmf = SetMetaFileBitsEx(mh.mtSize * 2, buf);
    heap_free(buf);
    if (!hmf)
        return GenericError;
 
    status = GdipCreateMetafileFromWmf(hmf, TRUE, is_placeable ? &pfh : NULL, metafile);
    if (status != Ok)
        DeleteMetaFile(hmf);
    return status;
}

Referenced by decode_image_wmf().

◆ move_bitmap()

static void move_bitmap	(	GpBitmap *	dst,
		GpBitmap *	src,
		BOOL	clobber_palette
	)

static

Definition at line 2081 of file image.c.

{
    assert(src->image.type == ImageTypeBitmap);
    assert(dst->image.type == ImageTypeBitmap);
 
    heap_free(dst->bitmapbits);
    heap_free(dst->own_bits);
    DeleteDC(dst->hdc);
    DeleteObject(dst->hbitmap);
 
    if (clobber_palette)
    {
        heap_free(dst->image.palette);
        dst->image.palette = src->image.palette;
    }
    else
        heap_free(src->image.palette);
 
    dst->image.xres = src->image.xres;
    dst->image.yres = src->image.yres;
    dst->width = src->width;
    dst->height = src->height;
    dst->format = src->format;
    dst->hbitmap = src->hbitmap;
    dst->hdc = src->hdc;
    dst->bits = src->bits;
    dst->stride = src->stride;
    dst->own_bits = src->own_bits;
    if (dst->metadata_reader)
        IWICMetadataReader_Release(dst->metadata_reader);
    dst->metadata_reader = src->metadata_reader;
    heap_free(dst->prop_item);
    dst->prop_item = src->prop_item;
    dst->prop_count = src->prop_count;
    if (dst->image.decoder)
        IWICBitmapDecoder_Release(dst->image.decoder);
    dst->image.decoder = src->image.decoder;
    dst->image.frame_count = src->image.frame_count;
    dst->image.current_frame = src->image.current_frame;
    dst->image.format = src->image.format;
 
    src->image.type = ~0;
    heap_free(src);
}

Referenced by GdipImageRotateFlip().

◆ png_metadata_reader()

static void png_metadata_reader	(	GpBitmap *	bitmap,
		IWICBitmapDecoder *	decoder,
		UINT	active_frame
	)

static

Definition at line 3461 of file image.c.

{
    HRESULT hr;
    IWICBitmapFrameDecode *frame;
    IWICMetadataBlockReader *block_reader;
    IWICMetadataReader *reader;
    UINT block_count, i, j;
    struct keyword_info {
        const char* name;
        PROPID propid;
        BOOL seen;
    } keywords[] = {
        { "Title", PropertyTagImageTitle },
        { "Author", PropertyTagArtist },
        { "Description", PropertyTagImageDescription },
        { "Copyright", PropertyTagCopyright },
        { "Software", PropertyTagSoftwareUsed },
        { "Source", PropertyTagEquipModel },
        { "Comment", PropertyTagExifUserComment },
    };
    BOOL seen_gamma=FALSE, seen_whitepoint=FALSE, seen_chrm=FALSE;
 
    hr = IWICBitmapDecoder_GetFrame(decoder, active_frame, &frame);
    if (hr != S_OK) return;
 
    hr = IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader);
    if (hr == S_OK)
    {
        hr = IWICMetadataBlockReader_GetCount(block_reader, &block_count);
        if (hr == S_OK)
        {
            for (i = 0; i < block_count; i++)
            {
                hr = IWICMetadataBlockReader_GetReaderByIndex(block_reader, i, &reader);
                if (hr == S_OK)
                {
                    GUID format;
 
                    hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
                    if (SUCCEEDED(hr) && IsEqualGUID(&GUID_MetadataFormatChunktEXt, &format))
                    {
                        PROPVARIANT name, value;
                        PropertyItem* item;
 
                        hr = IWICMetadataReader_GetValueByIndex(reader, 0, NULL, &name, &value);
 
                        if (SUCCEEDED(hr))
                        {
                            if (name.vt == VT_LPSTR)
                            {
                                for (j = 0; j < ARRAY_SIZE(keywords); j++)
                                    if (!strcmp(keywords[j].name, name.u.pszVal))
                                        break;
                                if (j < ARRAY_SIZE(keywords) && !keywords[j].seen)
                                {
                                    keywords[j].seen = TRUE;
                                    item = create_prop(keywords[j].propid, &value);
                                    if (item)
                                        add_property(bitmap, item);
                                    heap_free(item);
                                }
                            }
 
                            PropVariantClear(&name);
                            PropVariantClear(&value);
                        }
                    }
                    else if (SUCCEEDED(hr) && IsEqualGUID(&GUID_MetadataFormatChunkgAMA, &format))
                    {
                        PropertyItem* item;
 
                        if (!seen_gamma)
                        {
                            item = heap_alloc_zero(sizeof(PropertyItem) + sizeof(ULONG) * 2);
                            if (item)
                            {
                                ULONG *rational;
                                item->length = sizeof(ULONG) * 2;
                                item->type = PropertyTagTypeRational;
                                item->id = PropertyTagGamma;
                                rational = item->value = item + 1;
                                rational[0] = 100000;
                                rational[1] = get_ulong_by_index(reader, 0);
                                add_property(bitmap, item);
                                seen_gamma = TRUE;
                                heap_free(item);
                            }
                        }
                    }
                    else if (SUCCEEDED(hr) && IsEqualGUID(&GUID_MetadataFormatChunkcHRM, &format))
                    {
                        PropertyItem* item;
 
                        if (!seen_whitepoint)
                        {
                            item = GdipAlloc(sizeof(PropertyItem) + sizeof(ULONG) * 4);
                            if (item)
                            {
                                ULONG *rational;
                                item->length = sizeof(ULONG) * 4;
                                item->type = PropertyTagTypeRational;
                                item->id = PropertyTagWhitePoint;
                                rational = item->value = item + 1;
                                rational[0] = get_ulong_by_index(reader, 0);
                                rational[1] = 100000;
                                rational[2] = get_ulong_by_index(reader, 1);
                                rational[3] = 100000;
                                add_property(bitmap, item);
                                seen_whitepoint = TRUE;
                                GdipFree(item);
                            }
                        }
                        if (!seen_chrm)
                        {
                            item = GdipAlloc(sizeof(PropertyItem) + sizeof(ULONG) * 12);
                            if (item)
                            {
                                ULONG *rational;
                                item->length = sizeof(ULONG) * 12;
                                item->type = PropertyTagTypeRational;
                                item->id = PropertyTagPrimaryChromaticities;
                                rational = item->value = item + 1;
                                rational[0] = get_ulong_by_index(reader, 2);
                                rational[1] = 100000;
                                rational[2] = get_ulong_by_index(reader, 3);
                                rational[3] = 100000;
                                rational[4] = get_ulong_by_index(reader, 4);
                                rational[5] = 100000;
                                rational[6] = get_ulong_by_index(reader, 5);
                                rational[7] = 100000;
                                rational[8] = get_ulong_by_index(reader, 6);
                                rational[9] = 100000;
                                rational[10] = get_ulong_by_index(reader, 7);
                                rational[11] = 100000;
                                add_property(bitmap, item);
                                seen_chrm = TRUE;
                                GdipFree(item);
                            }
                        }
                    }
 
                    IWICMetadataReader_Release(reader);
                }
            }
        }
        IWICMetadataBlockReader_Release(block_reader);
    }
 
    IWICBitmapFrameDecode_Release(frame);
}

Referenced by decode_image_png().

◆ propvariant_size()

static UINT propvariant_size ( PROPVARIANT * value )

static

Definition at line 2502 of file image.c.

{
    switch (value->vt & ~VT_VECTOR)
    {
    case VT_EMPTY:
        return 0;
    case VT_I1:
    case VT_UI1:
        if (!(value->vt & VT_VECTOR)) return 1;
        return value->u.caub.cElems;
    case VT_I2:
    case VT_UI2:
        if (!(value->vt & VT_VECTOR)) return 2;
        return value->u.caui.cElems * 2;
    case VT_I4:
    case VT_UI4:
    case VT_R4:
        if (!(value->vt & VT_VECTOR)) return 4;
        return value->u.caul.cElems * 4;
    case VT_I8:
    case VT_UI8:
    case VT_R8:
        if (!(value->vt & VT_VECTOR)) return 8;
        return value->u.cauh.cElems * 8;
    case VT_LPSTR:
        return value->u.pszVal ? strlen(value->u.pszVal) + 1 : 0;
    case VT_BLOB:
        return value->u.blob.cbSize;
    default:
        FIXME("not supported variant type %d\n", value->vt);
        return 0;
    }
}

Referenced by create_prop(), GdipGetAllPropertyItems(), GdipGetPropertyItemSize(), GdipGetPropertySize(), get_property(), and propvariant_to_item().

◆ propvariant_to_item()

static GpStatus propvariant_to_item	(	PROPVARIANT *	value,
		PropertyItem *	item,
		UINT	size,
		PROPID	id
	)

static

Definition at line 2619 of file image.c.

{
    UINT item_size, item_type;
 
    item_size = propvariant_size(value);
    if (size != item_size + sizeof(PropertyItem)) return InvalidParameter;
 
    item_type = vt_to_itemtype(value->vt & ~VT_VECTOR);
    if (!item_type) return InvalidParameter;
 
    item->value = item + 1;
 
    switch (value->vt & ~VT_VECTOR)
    {
    case VT_I1:
    case VT_UI1:
        if (!(value->vt & VT_VECTOR))
            *(BYTE *)item->value = value->u.bVal;
        else
            memcpy(item->value, value->u.caub.pElems, item_size);
        break;
    case VT_I2:
    case VT_UI2:
        if (!(value->vt & VT_VECTOR))
            *(USHORT *)item->value = value->u.uiVal;
        else
            memcpy(item->value, value->u.caui.pElems, item_size);
        break;
    case VT_I4:
    case VT_UI4:
    case VT_R4:
        if (!(value->vt & VT_VECTOR))
            *(ULONG *)item->value = value->u.ulVal;
        else
            memcpy(item->value, value->u.caul.pElems, item_size);
        break;
    case VT_I8:
    case VT_UI8:
    case VT_R8:
        if (!(value->vt & VT_VECTOR))
            *(ULONGLONG *)item->value = value->u.uhVal.QuadPart;
        else
            memcpy(item->value, value->u.cauh.pElems, item_size);
        break;
    case VT_LPSTR:
        memcpy(item->value, value->u.pszVal, item_size);
        break;
    case VT_BLOB:
        memcpy(item->value, value->u.blob.pBlobData, item_size);
        break;
    default:
        FIXME("not supported variant type %d\n", value->vt);
        return InvalidParameter;
    }
 
    item->length = item_size;
    item->type = item_type;
    item->id = id;
 
    return Ok;
}

Referenced by create_prop(), GdipGetAllPropertyItems(), GdipGetPropertyItem(), and get_property().

◆ select_frame_gif()

static GpStatus select_frame_gif	(	GpImage *	image,
		UINT	active_frame
	)

static

Definition at line 3909 of file image.c.

{
    static const WCHAR disposalW[] = {'D','i','s','p','o','s','a','l',0};
 
    GpBitmap *bitmap = (GpBitmap*)image;
    IWICBitmapFrameDecode *frame;
    int cur_frame=0, disposal;
    BOOL bgcolor_set = FALSE;
    DWORD bgcolor = 0;
    HRESULT hr;
 
    if(active_frame > image->current_frame) {
        hr = IWICBitmapDecoder_GetFrame(bitmap->image.decoder, image->current_frame, &frame);
        if(FAILED(hr))
            return hresult_to_status(hr);
        disposal = get_gif_frame_property(frame, &GUID_MetadataFormatGCE, disposalW);
        IWICBitmapFrameDecode_Release(frame);
 
        if(disposal == GIF_DISPOSE_RESTORE_TO_BKGND)
            cur_frame = image->current_frame;
        else if(disposal != GIF_DISPOSE_RESTORE_TO_PREV)
            cur_frame = image->current_frame+1;
    }
 
    while(cur_frame != active_frame) {
        hr = IWICBitmapDecoder_GetFrame(bitmap->image.decoder, cur_frame, &frame);
        if(FAILED(hr))
            return hresult_to_status(hr);
        disposal = get_gif_frame_property(frame, &GUID_MetadataFormatGCE, disposalW);
 
        if(disposal==GIF_DISPOSE_UNSPECIFIED || disposal==GIF_DISPOSE_DO_NOT_DISPOSE) {
            hr = blit_gif_frame(bitmap, frame, cur_frame==0);
            if(FAILED(hr))
                return hresult_to_status(hr);
        }else if(disposal == GIF_DISPOSE_RESTORE_TO_BKGND) {
            UINT left, top, width, height, i, j;
 
            if(!bgcolor_set) {
                bgcolor = get_gif_background_color(bitmap);
                bgcolor_set = TRUE;
            }
 
            hr = get_gif_frame_rect(frame, &left, &top, &width, &height);
            if(FAILED(hr))
                return hresult_to_status(hr);
            for(i=top; i<top+height && i<bitmap->height; i++) {
                DWORD *bits = (DWORD*)(bitmap->bits+i*bitmap->stride);
                for(j=left; j<left+width && j<bitmap->width; j++)
                    bits[j] = bgcolor;
            }
        }
 
        IWICBitmapFrameDecode_Release(frame);
        cur_frame++;
    }
 
    hr = IWICBitmapDecoder_GetFrame(bitmap->image.decoder, active_frame, &frame);
    if(FAILED(hr))
        return hresult_to_status(hr);
 
    hr = blit_gif_frame(bitmap, frame, cur_frame==0);
    IWICBitmapFrameDecode_Release(frame);
    if(FAILED(hr))
        return hresult_to_status(hr);
 
    image->current_frame = active_frame;
    return Ok;
}

◆ select_frame_wic()

static GpStatus select_frame_wic	(	GpImage *	image,
		UINT	active_frame
	)

static

Definition at line 3801 of file image.c.

{
    GpImage *new_image;
    GpStatus status;
 
    status = decode_frame_wic(image->decoder, FALSE, active_frame, NULL, &new_image);
    if(status != Ok)
        return status;
 
    new_image->busy = image->busy;
    memcpy(&new_image->format, &image->format, sizeof(GUID));
    free_image_data(image);
    if (image->type == ImageTypeBitmap)
        *(GpBitmap *)image = *(GpBitmap *)new_image;
    else if (image->type == ImageTypeMetafile)
        *(GpMetafile *)image = *(GpMetafile *)new_image;
    new_image->type = ~0;
    heap_free(new_image);
    return Ok;
}

◆ set_histogram_point_a()

static void set_histogram_point_a	(	ARGB	color,
		UINT *	ch0,
		UINT *	ch1,
		UINT *	ch2,
		UINT *	ch3
	)

static

Definition at line 5601 of file image.c.

{
    ch0[(color >> 24) & 0xff]++;
}

Referenced by GdipBitmapGetHistogram().

◆ set_histogram_point_argb()

static void set_histogram_point_argb	(	ARGB	color,
		UINT *	ch0,
		UINT *	ch1,
		UINT *	ch2,
		UINT *	ch3
	)

static

Definition at line 5556 of file image.c.

{
    ch0[ color >> 24        ]++;
    ch1[(color >> 16) & 0xff]++;
    ch2[(color >>  8) & 0xff]++;
    ch3[ color        & 0xff]++;
}

Referenced by GdipBitmapGetHistogram().

◆ set_histogram_point_b()

static void set_histogram_point_b	(	ARGB	color,
		UINT *	ch0,
		UINT *	ch1,
		UINT *	ch2,
		UINT *	ch3
	)

static

Definition at line 5586 of file image.c.

{
    ch0[color & 0xff]++;
}

Referenced by GdipBitmapGetHistogram().

◆ set_histogram_point_g()

static void set_histogram_point_g	(	ARGB	color,
		UINT *	ch0,
		UINT *	ch1,
		UINT *	ch2,
		UINT *	ch3
	)

static

Definition at line 5591 of file image.c.

{
    ch0[(color >> 8) & 0xff]++;
}

Referenced by GdipBitmapGetHistogram().

◆ set_histogram_point_gray()

static void set_histogram_point_gray	(	ARGB	color,
		UINT *	ch0,
		UINT *	ch1,
		UINT *	ch2,
		UINT *	ch3
	)

static

Definition at line 5581 of file image.c.

{
    ch0[(76 * ((color >> 16) & 0xff) + 150 * ((color >> 8) & 0xff) + 29 * (color & 0xff)) / 0xff]++;
}

Referenced by GdipBitmapGetHistogram().

◆ set_histogram_point_pargb()

static void set_histogram_point_pargb	(	ARGB	color,
		UINT *	ch0,
		UINT *	ch1,
		UINT *	ch2,
		UINT *	ch3
	)

static

Definition at line 5564 of file image.c.

{
    BYTE alpha = color >> 24;
 
    ch0[alpha]++;
    ch1[(((color >> 16) & 0xff) * alpha) / 0xff]++;
    ch2[(((color >>  8) & 0xff) * alpha) / 0xff]++;
    ch3[(( color        & 0xff) * alpha) / 0xff]++;
}

Referenced by GdipBitmapGetHistogram().

◆ set_histogram_point_r()

static void set_histogram_point_r	(	ARGB	color,
		UINT *	ch0,
		UINT *	ch1,
		UINT *	ch2,
		UINT *	ch3
	)

static

Definition at line 5596 of file image.c.

{
    ch0[(color >> 16) & 0xff]++;
}

Referenced by GdipBitmapGetHistogram().

◆ set_histogram_point_rgb()

static void set_histogram_point_rgb	(	ARGB	color,
		UINT *	ch0,
		UINT *	ch1,
		UINT *	ch2,
		UINT *	ch3
	)

static

Definition at line 5574 of file image.c.

{
    ch0[(color >> 16) & 0xff]++;
    ch1[(color >>  8) & 0xff]++;
    ch2[ color        & 0xff]++;
}

Referenced by GdipBitmapGetHistogram().

◆ setpixel_16bppARGB1555()

static void setpixel_16bppARGB1555	(	BYTE	r,
		BYTE	g,
		BYTE	b,
		BYTE	a,
		BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 430 of file image.c.

{
    *((WORD*)(row)+x) = (a<<8&0x8000)|
                        (r<<7&0x7c00)|
                        (g<<2&0x03e0)|
                        (b>>3&0x001f);
}

Referenced by convert_pixels(), and GdipBitmapSetPixel().

◆ setpixel_16bppGrayScale()

static void setpixel_16bppGrayScale	(	BYTE	r,
		BYTE	g,
		BYTE	b,
		BYTE	a,
		BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 408 of file image.c.

{
    *((WORD*)(row)+x) = (r+g+b)*85;
}

Referenced by convert_pixels(), and GdipBitmapSetPixel().

◆ setpixel_16bppRGB555()

static void setpixel_16bppRGB555	(	BYTE	r,
		BYTE	g,
		BYTE	b,
		BYTE	a,
		BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 414 of file image.c.

{
    *((WORD*)(row)+x) = (r<<7&0x7c00)|
                        (g<<2&0x03e0)|
                        (b>>3&0x001f);
}

Referenced by convert_pixels(), and GdipBitmapSetPixel().

◆ setpixel_16bppRGB565()

static void setpixel_16bppRGB565	(	BYTE	r,
		BYTE	g,
		BYTE	b,
		BYTE	a,
		BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 422 of file image.c.

{
    *((WORD*)(row)+x) = (r<<8&0xf800)|
                         (g<<3&0x07e0)|
                         (b>>3&0x001f);
}

Referenced by convert_pixels(), and GdipBitmapSetPixel().

◆ setpixel_1bppIndexed()

static void setpixel_1bppIndexed	(	BYTE	r,
		BYTE	g,
		BYTE	b,
		BYTE	a,
		BYTE *	row,
		UINT	x,
		ColorPalette *	palette
	)

inlinestatic

Definition at line 393 of file image.c.

{
    row[x/8]  = (row[x/8] & ~(1<<(7-x%8))) | (get_palette_index(r,g,b,a,palette)<<(7-x%8));
}

Referenced by convert_pixels(), and GdipBitmapSetPixel().

◆ setpixel_24bppRGB()

static void setpixel_24bppRGB	(	BYTE	r,
		BYTE	g,
		BYTE	b,
		BYTE	a,
		BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 439 of file image.c.

{
    row[x*3+2] = r;
    row[x*3+1] = g;
    row[x*3] = b;
}

Referenced by convert_pixels(), and GdipBitmapSetPixel().

◆ setpixel_32bppARGB()

static void setpixel_32bppARGB	(	BYTE	r,
		BYTE	g,
		BYTE	b,
		BYTE	a,
		BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 453 of file image.c.

{
    *((DWORD*)(row)+x) = (a<<24)|(r<<16)|(g<<8)|b;
}

Referenced by convert_pixels(), and GdipBitmapSetPixel().

◆ setpixel_32bppPARGB()

static void setpixel_32bppPARGB	(	BYTE	r,
		BYTE	g,
		BYTE	b,
		BYTE	a,
		BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 459 of file image.c.

{
    r = r * a / 255;
    g = g * a / 255;
    b = b * a / 255;
    *((DWORD*)(row)+x) = (a<<24)|(r<<16)|(g<<8)|b;
}

Referenced by convert_pixels(), and GdipBitmapSetPixel().

◆ setpixel_32bppRGB()

static void setpixel_32bppRGB	(	BYTE	r,
		BYTE	g,
		BYTE	b,
		BYTE	a,
		BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 447 of file image.c.

{
    *((DWORD*)(row)+x) = (r<<16)|(g<<8)|b;
}

Referenced by convert_pixels(), and GdipBitmapSetPixel().

◆ setpixel_48bppRGB()

static void setpixel_48bppRGB	(	BYTE	r,
		BYTE	g,
		BYTE	b,
		BYTE	a,
		BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 468 of file image.c.

{
    row[x*6+5] = row[x*6+4] = r;
    row[x*6+3] = row[x*6+2] = g;
    row[x*6+1] = row[x*6] = b;
}

Referenced by convert_pixels(), and GdipBitmapSetPixel().

◆ setpixel_4bppIndexed()

static void setpixel_4bppIndexed	(	BYTE	r,
		BYTE	g,
		BYTE	b,
		BYTE	a,
		BYTE *	row,
		UINT	x,
		ColorPalette *	palette
	)

inlinestatic

Definition at line 399 of file image.c.

{
    if (x & 1)
        row[x/2] = (row[x/2] & 0xf0) | get_palette_index(r,g,b,a,palette);
    else
        row[x/2] = (row[x/2] & 0x0f) | get_palette_index(r,g,b,a,palette)<<4;
}

Referenced by GdipBitmapSetPixel().

◆ setpixel_64bppARGB()

static void setpixel_64bppARGB	(	BYTE	r,
		BYTE	g,
		BYTE	b,
		BYTE	a,
		BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 476 of file image.c.

{
    UINT64 a64=a, r64=r, g64=g, b64=b;
    *((UINT64*)(row)+x) = (a64<<56)|(a64<<48)|(r64<<40)|(r64<<32)|(g64<<24)|(g64<<16)|(b64<<8)|b64;
}

Referenced by convert_pixels(), and GdipBitmapSetPixel().

◆ setpixel_64bppPARGB()

static void setpixel_64bppPARGB	(	BYTE	r,
		BYTE	g,
		BYTE	b,
		BYTE	a,
		BYTE *	row,
		UINT	x
	)

inlinestatic

Definition at line 483 of file image.c.

{
    UINT64 a64, r64, g64, b64;
    a64 = a * 257;
    r64 = r * a / 255;
    g64 = g * a / 255;
    b64 = b * a / 255;
    *((UINT64*)(row)+x) = (a64<<48)|(r64<<32)|(g64<<16)|b64;
}

Referenced by GdipBitmapSetPixel().

◆ setpixel_8bppIndexed()

static void setpixel_8bppIndexed	(	BYTE	r,
		BYTE	g,
		BYTE	b,
		BYTE	a,
		BYTE *	row,
		UINT	x,
		ColorPalette *	palette
	)

inlinestatic

Definition at line 386 of file image.c.

{
     BYTE index = get_palette_index(r,g,b,a,palette);
     row[x]=index;
}

Referenced by convert_pixels(), and GdipBitmapSetPixel().

◆ vt_to_itemtype()

static UINT vt_to_itemtype ( UINT vt )

static

Definition at line 2590 of file image.c.

{
    static const struct
    {
        UINT vt, type;
    } vt2type[] =
    {
        { VT_I1, PropertyTagTypeSByte },
        { VT_UI1, PropertyTagTypeByte },
        { VT_I2, PropertyTagTypeSShort },
        { VT_UI2, PropertyTagTypeShort },
        { VT_I4, PropertyTagTypeSLONG },
        { VT_UI4, PropertyTagTypeLong },
        { VT_I8, PropertyTagTypeSRational },
        { VT_UI8, PropertyTagTypeRational },
        { VT_R4, PropertyTagTypeFloat },
        { VT_R8, PropertyTagTypeDouble },
        { VT_LPSTR, PropertyTagTypeASCII },
        { VT_BLOB, PropertyTagTypeUndefined }
    };
    UINT i;
    for (i = 0; i < ARRAY_SIZE(vt2type); i++)
    {
        if (vt2type[i].vt == vt) return vt2type[i].type;
    }
    FIXME("not supported variant type %u\n", vt);
    return 0;
}

Referenced by propvariant_to_item().

◆ WICCreateImagingFactory_Proxy()

HRESULT WINAPI WICCreateImagingFactory_Proxy	(	UINT	SDKVersion,
		IWICImagingFactory **	ppIImagingFactory
	)

Definition at line 651 of file proxy.c.

{
    TRACE("%x, %p\n", SDKVersion, ppIImagingFactory);
 
    return ImagingFactory_CreateInstance(&IID_IWICImagingFactory, (void**)ppIImagingFactory);
}

Referenced by create_optimal_palette(), encode_image_wic(), get_gif_palette(), get_palette(), and initialize_decoder_wic().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( gdiplus )

Variable Documentation

◆ bmp_codecname

const WCHAR bmp_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}

static

Definition at line 4772 of file image.c.

◆ bmp_extension

const WCHAR bmp_extension[] = {'*','.','B', 'M', 'P',';', '*','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}

static

Definition at line 4773 of file image.c.

◆ bmp_format

const WCHAR bmp_format[] = {'B', 'M', 'P', 0}

static

Definition at line 4775 of file image.c.

Referenced by test_encoders().

◆ bmp_mimetype

const WCHAR bmp_mimetype[] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}

static

Definition at line 4774 of file image.c.

Referenced by test_supported_encoders().

◆ bmp_sig_mask

const BYTE bmp_sig_mask[] = { 0xFF, 0xFF }

static

Definition at line 4777 of file image.c.

◆ bmp_sig_pattern

const BYTE bmp_sig_pattern[] = { 0x42, 0x4D }

static

Definition at line 4776 of file image.c.

◆ codecs

static const struct image_codec codecs

static

Definition at line 4283 of file image.c.

Referenced by GdipGetImageDecoders(), GdipGetImageDecodersSize(), GdipGetImageEncoders(), GdipGetImageEncodersSize(), GdipSaveImageToStream(), get_decoder_info(), get_decoder_info_from_image(), test_encoders(), test_raw_decompress(), test_SavingImages(), and TIFFGetConfiguredCODECs().

◆ emf_codecname

const WCHAR emf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'E','M','F', 0}

static

Definition at line 4800 of file image.c.

◆ emf_extension

const WCHAR emf_extension[] = {'*','.','E','M','F',0}

static

Definition at line 4801 of file image.c.

◆ emf_format

const WCHAR emf_format[] = {'E','M','F',0}

static

Definition at line 4803 of file image.c.

◆ emf_mimetype

const WCHAR emf_mimetype[] = {'i','m','a','g','e','/','x','-','e','m','f', 0}

static

Definition at line 4802 of file image.c.

◆ emf_sig_mask

const BYTE emf_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF }

static

Definition at line 4805 of file image.c.

◆ emf_sig_pattern

const BYTE emf_sig_pattern[] = { 0x01, 0x00, 0x00, 0x00 }

static

Definition at line 4804 of file image.c.

◆ gdip_format

PixelFormat gdip_format

Definition at line 51 of file image.c.

Referenced by decode_frame_wic(), and encode_image_wic().

◆ gif_codecname

const WCHAR gif_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'G','I','F', 0}

static

Definition at line 4786 of file image.c.

◆ gif_extension

const WCHAR gif_extension[] = {'*','.','G','I','F',0}

static

Definition at line 4787 of file image.c.

Referenced by load_GifComment_metadata().

◆ gif_format

const WCHAR gif_format[] = {'G','I','F',0}

static

Definition at line 4789 of file image.c.

◆ gif_mimetype

const WCHAR gif_mimetype[] = {'i','m','a','g','e','/','g','i','f', 0}

static

Definition at line 4788 of file image.c.

Referenced by test_supported_encoders().

◆ gif_sig_mask

const BYTE gif_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }

static

Definition at line 4791 of file image.c.

◆ gif_sig_pattern

const BYTE gif_sig_pattern[12] = "GIF87aGIF89a"

static

Definition at line 4790 of file image.c.

◆ ico_codecname

const WCHAR ico_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'I','C','O', 0}

static

Definition at line 4821 of file image.c.

◆ ico_extension

const WCHAR ico_extension[] = {'*','.','I','C','O',0}

static

Definition at line 4822 of file image.c.

◆ ico_format

const WCHAR ico_format[] = {'I','C','O',0}

static

Definition at line 4824 of file image.c.

◆ ico_mimetype

const WCHAR ico_mimetype[] = {'i','m','a','g','e','/','x','-','i','c','o','n', 0}

static

Definition at line 4823 of file image.c.

◆ ico_sig_mask

const BYTE ico_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF }

static

Definition at line 4826 of file image.c.

◆ ico_sig_pattern

const BYTE ico_sig_pattern[] = { 0x00, 0x00, 0x01, 0x00 }

static

Definition at line 4825 of file image.c.

◆ image_format_dimensions

const struct image_format_dimension image_format_dimensions[]

static

Initial value:

=
{
    {&ImageFormatGIF, &FrameDimensionTime},
    {&ImageFormatIcon, &FrameDimensionResolution},
    {NULL}
}

Definition at line 2906 of file image.c.

Referenced by GdipImageGetFrameDimensionsList().

◆ jpeg_codecname

const WCHAR jpeg_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'J','P','E','G', 0}

static

Definition at line 4779 of file image.c.

◆ jpeg_extension

const WCHAR jpeg_extension[] = {'*','.','J','P','G',';', '*','.','J','P','E','G',';', '*','.','J','P','E',';', '*','.','J','F','I','F',0}

static

Definition at line 4780 of file image.c.

◆ jpeg_format

const WCHAR jpeg_format[] = {'J','P','E','G',0}

static

Definition at line 4782 of file image.c.

◆ jpeg_mimetype

const WCHAR jpeg_mimetype[] = {'i','m','a','g','e','/','j','p','e','g', 0}

static

Definition at line 4781 of file image.c.

Referenced by test_supported_encoders().

◆ jpeg_sig_mask

const BYTE jpeg_sig_mask[] = { 0xFF, 0xFF }

static

Definition at line 4784 of file image.c.

◆ jpeg_sig_pattern

const BYTE jpeg_sig_pattern[] = { 0xFF, 0xD8 }

static

Definition at line 4783 of file image.c.

◆ palette_type

WICBitmapPaletteType palette_type

Definition at line 53 of file image.c.

Referenced by decode_frame_wic(), FormatConverter_Initialize(), get_palette(), and test_createbitmapfromsource().

◆

const struct { ... } pixel_formats[]

Initial value:

=
{
    { &GUID_WICPixelFormatBlackWhite, PixelFormat1bppIndexed, WICBitmapPaletteTypeFixedBW },
    { &GUID_WICPixelFormat1bppIndexed, PixelFormat1bppIndexed, WICBitmapPaletteTypeFixedBW },
    { &GUID_WICPixelFormat4bppIndexed, PixelFormat4bppIndexed, WICBitmapPaletteTypeFixedHalftone8 },
    { &GUID_WICPixelFormat8bppGray, PixelFormat8bppIndexed, WICBitmapPaletteTypeFixedGray256 },
    { &GUID_WICPixelFormat8bppIndexed, PixelFormat8bppIndexed, WICBitmapPaletteTypeFixedHalftone256 },
    { &GUID_WICPixelFormat16bppBGR555, PixelFormat16bppRGB555, WICBitmapPaletteTypeFixedHalftone256 },
    { &GUID_WICPixelFormat24bppBGR, PixelFormat24bppRGB, WICBitmapPaletteTypeFixedHalftone256 },
    { &GUID_WICPixelFormat32bppBGR, PixelFormat32bppRGB, WICBitmapPaletteTypeFixedHalftone256 },
    { &GUID_WICPixelFormat48bppRGB, PixelFormat48bppRGB, WICBitmapPaletteTypeFixedHalftone256 },
    { &GUID_WICPixelFormat32bppBGRA, PixelFormat32bppARGB, WICBitmapPaletteTypeFixedHalftone256 },
    { &GUID_WICPixelFormat32bppPBGRA, PixelFormat32bppPARGB, WICBitmapPaletteTypeFixedHalftone256 },
    { &GUID_WICPixelFormat32bppCMYK, PixelFormat32bppCMYK, WICBitmapPaletteTypeFixedHalftone256 },
    { &GUID_WICPixelFormat32bppGrayFloat, PixelFormat32bppARGB, WICBitmapPaletteTypeFixedGray256 },
    { &GUID_WICPixelFormat64bppCMYK, PixelFormat48bppRGB, WICBitmapPaletteTypeFixedHalftone256 },
    { &GUID_WICPixelFormat64bppRGBA, PixelFormat48bppRGB, WICBitmapPaletteTypeFixedHalftone256 },
    { NULL }
}

Referenced by decode_frame_wic(), and encode_image_wic().

◆ png_codecname

const WCHAR png_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'P','N','G', 0}

static

Definition at line 4814 of file image.c.

◆ png_extension

const WCHAR png_extension[] = {'*','.','P','N','G',0}

static

Definition at line 4815 of file image.c.

◆ png_format

const WCHAR png_format[] = {'P','N','G',0}

static

Definition at line 4817 of file image.c.

◆ png_mimetype

const WCHAR png_mimetype[] = {'i','m','a','g','e','/','p','n','g', 0}

static

Definition at line 4816 of file image.c.

Referenced by test_supported_encoders().

◆ png_sig_mask

const BYTE png_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }

static

Definition at line 4819 of file image.c.

◆ png_sig_pattern

const BYTE png_sig_pattern[] = { 137, 80, 78, 71, 13, 10, 26, 10, }

static

Definition at line 4818 of file image.c.

Referenced by DIB_GetBitmapInfo().

◆ tiff_codecname

const WCHAR tiff_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'T','I','F','F', 0}

static

Definition at line 4793 of file image.c.

◆ tiff_extension

const WCHAR tiff_extension[] = {'*','.','T','I','F','F',';','*','.','T','I','F',0}

static

Definition at line 4794 of file image.c.

◆ tiff_format

const WCHAR tiff_format[] = {'T','I','F','F',0}

static

Definition at line 4796 of file image.c.

◆ tiff_mimetype

const WCHAR tiff_mimetype[] = {'i','m','a','g','e','/','t','i','f','f', 0}

static

Definition at line 4795 of file image.c.

Referenced by test_supported_encoders().

◆ tiff_sig_mask

const BYTE tiff_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }

static

Definition at line 4798 of file image.c.

◆ tiff_sig_pattern

const BYTE tiff_sig_pattern[] = {0x49,0x49,42,0,0x4d,0x4d,0,42}

static

Definition at line 4797 of file image.c.

◆ wic_format

const WICPixelFormatGUID* wic_format

Definition at line 50 of file image.c.

Referenced by decode_frame_wic(), and encode_image_wic().

◆ wmf_codecname

const WCHAR wmf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'W','M','F', 0}

static

Definition at line 4807 of file image.c.

◆ wmf_extension

const WCHAR wmf_extension[] = {'*','.','W','M','F',0}

static

Definition at line 4808 of file image.c.

◆ wmf_format

const WCHAR wmf_format[] = {'W','M','F',0}

static

Definition at line 4810 of file image.c.

◆ wmf_mimetype

const WCHAR wmf_mimetype[] = {'i','m','a','g','e','/','x','-','w','m','f', 0}

static

Definition at line 4809 of file image.c.

◆ wmf_sig_mask

const BYTE wmf_sig_mask[] = { 0xFF, 0xFF }

static

Definition at line 4812 of file image.c.

◆ wmf_sig_pattern

const BYTE wmf_sig_pattern[] = { 0xd7, 0xcd }

static

Definition at line 4811 of file image.c.

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ COBJMACROS

◆ convert_indexed_to_rgb

◆ convert_rgb_to_indexed

◆ convert_rgb_to_rgb

◆ NONAMELESSUNION

◆ PIXELFORMATBPP

◆ PropertyTagTypeDouble

◆ PropertyTagTypeFloat

◆ PropertyTagTypeSByte

◆ PropertyTagTypeSShort

◆ WMF_PLACEABLE_KEY

Typedef Documentation

◆ decode_image_func

◆ encode_image_func

◆ image_codec

◆ metadata_reader_func

◆ select_image_func

Enumeration Type Documentation

◆ ImageFormat

Function Documentation

◆ add_property()

◆ blend_argb_no_bkgnd_alpha()

◆ blit_gif_frame()

◆ convert_pixels()

◆ create_optimal_palette()

◆ create_prop()

◆ decode_frame_wic()

◆ decode_image_bmp()

◆ decode_image_emf()

◆ decode_image_gif()

◆ decode_image_icon()

◆ decode_image_jpeg()

◆ decode_image_png()

◆ decode_image_tiff()

◆ decode_image_wic()

◆ decode_image_wmf()

◆ encode_image_BMP()

◆ encode_image_gif()

◆ encode_image_jpeg()

◆ encode_image_png()

◆ encode_image_tiff()

◆ encode_image_wic()

◆ free_image_data()

◆ GdipBitmapApplyEffect()

◆ GdipBitmapConvertFormat()

◆ GdipBitmapCreateApplyEffect()

◆ GdipBitmapGetHistogram()

◆ GdipBitmapGetHistogramSize()

◆ GdipBitmapGetPixel()

◆ GdipBitmapLockBits()

◆ GdipBitmapSetPixel()

◆ GdipBitmapSetResolution()

◆ GdipBitmapUnlockBits()

◆ GdipCloneBitmapArea()

◆ GdipCloneBitmapAreaI()

◆ GdipCloneImage()

◆ GdipCreateBitmapFromFile()

◆ GdipCreateBitmapFromFileICM()

◆ GdipCreateBitmapFromGdiDib()

◆ GdipCreateBitmapFromGraphics()

◆ GdipCreateBitmapFromHBITMAP()

◆ GdipCreateBitmapFromHICON()

◆ GdipCreateBitmapFromResource()

◆ GdipCreateBitmapFromScan0()

◆ GdipCreateBitmapFromStream()

◆ GdipCreateBitmapFromStreamICM()

◆ GdipCreateCachedBitmap()

◆ GdipCreateEffect()

◆ GdipCreateHBITMAPFromBitmap()

◆ GdipCreateHICONFromBitmap()

◆ GdipDeleteCachedBitmap()

◆ GdipDeleteEffect()

◆ GdipDisposeImage()