#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;

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()