image.c File Reference

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

Go to the source code of this file.

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 2539 of file image.c.

PropertyTagTypeFloat

#define PropertyTagTypeFloat   11

Definition at line 2538 of file image.c.

PropertyTagTypeSByte

#define PropertyTagTypeSByte   6

Definition at line 2536 of file image.c.

PropertyTagTypeSShort

#define PropertyTagTypeSShort   8

Definition at line 2537 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 4212 of file image.c.

encode_image_func

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

Definition at line 4209 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 3582 of file image.c.

select_image_func

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

Definition at line 4214 of file image.c.

Enumeration Type Documentation

ImageFormat

enum ImageFormat

Enumerator
BMP
JPEG
GIF
TIFF
EMF
WMF
PNG
ICO
NUM_CODECS

Definition at line 4223 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 2961 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 3786 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 5645 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 3371 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 3584 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 3935 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 4186 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 4034 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 3930 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 3953 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 3991 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 4061 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 3738 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 4124 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 4590 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 4614 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 4608 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 4602 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 4596 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 4455 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 2078 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 5501 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 5561 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 5634 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(), Bitmap::GetPixel(), 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(), Bitmap::LockBits(), 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(), Bitmap::SetPixel(), 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(), Bitmap::SetResolution(), 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(), test_pen_thickness(), and Bitmap::UnlockBits().

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;