ReactOS 0.4.16-dev-747-gbc52d5f
gifformat.c File Reference
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "objbase.h"
#include "shlwapi.h"
#include "ungif.h"
#include "wincodecs_private.h"
#include "wine/debug.h"
#include "pshpack1.h"
#include "poppack.h"
Include dependency graph for gifformat.c:

Go to the source code of this file.

Classes

struct  logical_screen_descriptor
 
struct  image_descriptor
 
struct  GifDecoder
 
struct  GifFrameDecode
 
struct  GifEncoder
 
struct  GifFrameEncode
 
struct  lzw_dict
 
struct  lzw_state
 
struct  input_stream
 
struct  output_stream
 

Macros

#define COBJMACROS
 
#define LZW_DICT_SIZE   (1 << 12)
 

Typedefs

typedef struct GifEncoder GifEncoder
 
typedef struct GifFrameEncode GifFrameEncode
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (wincodecs)
 
static HRESULT load_LSD_metadata (IStream *stream, const GUID *vendor, DWORD options, MetadataItem **items, DWORD *count)
 
HRESULT LSDReader_CreateInstance (REFIID iid, void **ppv)
 
static HRESULT load_IMD_metadata (IStream *stream, const GUID *vendor, DWORD options, MetadataItem **items, DWORD *count)
 
HRESULT IMDReader_CreateInstance (REFIID iid, void **ppv)
 
static HRESULT load_GCE_metadata (IStream *stream, const GUID *vendor, DWORD options, MetadataItem **items, DWORD *count)
 
HRESULT GCEReader_CreateInstance (REFIID iid, void **ppv)
 
static HRESULT load_APE_metadata (IStream *stream, const GUID *vendor, DWORD options, MetadataItem **items, DWORD *count)
 
HRESULT APEReader_CreateInstance (REFIID iid, void **ppv)
 
static HRESULT load_GifComment_metadata (IStream *stream, const GUID *vendor, DWORD options, MetadataItem **items, DWORD *count)
 
HRESULT GifCommentReader_CreateInstance (REFIID iid, void **ppv)
 
static IStreamcreate_stream (const void *data, int data_size)
 
static HRESULT create_metadata_reader (const void *data, int data_size, class_constructor constructor, IWICMetadataReader **reader)
 
static GifDecoderimpl_from_IWICBitmapDecoder (IWICBitmapDecoder *iface)
 
static GifDecoderimpl_from_IWICMetadataBlockReader (IWICMetadataBlockReader *iface)
 
static GifFrameDecodeimpl_from_IWICBitmapFrameDecode (IWICBitmapFrameDecode *iface)
 
static GifFrameDecodeframe_from_IWICMetadataBlockReader (IWICMetadataBlockReader *iface)
 
static HRESULT WINAPI GifFrameDecode_QueryInterface (IWICBitmapFrameDecode *iface, REFIID iid, void **ppv)
 
static ULONG WINAPI GifFrameDecode_AddRef (IWICBitmapFrameDecode *iface)
 
static ULONG WINAPI GifFrameDecode_Release (IWICBitmapFrameDecode *iface)
 
static HRESULT WINAPI GifFrameDecode_GetSize (IWICBitmapFrameDecode *iface, UINT *puiWidth, UINT *puiHeight)
 
static HRESULT WINAPI GifFrameDecode_GetPixelFormat (IWICBitmapFrameDecode *iface, WICPixelFormatGUID *pPixelFormat)
 
static HRESULT WINAPI GifFrameDecode_GetResolution (IWICBitmapFrameDecode *iface, double *pDpiX, double *pDpiY)
 
static void copy_palette (ColorMapObject *cm, Extensions *extensions, int count, WICColor *colors)
 
static HRESULT WINAPI GifFrameDecode_CopyPalette (IWICBitmapFrameDecode *iface, IWICPalette *pIPalette)
 
static HRESULT copy_interlaced_pixels (const BYTE *srcbuffer, UINT srcwidth, UINT srcheight, INT srcstride, const WICRect *rc, UINT dststride, UINT dstbuffersize, BYTE *dstbuffer)
 
static HRESULT WINAPI GifFrameDecode_CopyPixels (IWICBitmapFrameDecode *iface, const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
 
static HRESULT WINAPI GifFrameDecode_GetMetadataQueryReader (IWICBitmapFrameDecode *iface, IWICMetadataQueryReader **ppIMetadataQueryReader)
 
static HRESULT WINAPI GifFrameDecode_GetColorContexts (IWICBitmapFrameDecode *iface, UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
 
static HRESULT WINAPI GifFrameDecode_GetThumbnail (IWICBitmapFrameDecode *iface, IWICBitmapSource **ppIThumbnail)
 
static HRESULT WINAPI GifFrameDecode_Block_QueryInterface (IWICMetadataBlockReader *iface, REFIID iid, void **ppv)
 
static ULONG WINAPI GifFrameDecode_Block_AddRef (IWICMetadataBlockReader *iface)
 
static ULONG WINAPI GifFrameDecode_Block_Release (IWICMetadataBlockReader *iface)
 
static HRESULT WINAPI GifFrameDecode_Block_GetContainerFormat (IWICMetadataBlockReader *iface, GUID *guid)
 
static HRESULT WINAPI GifFrameDecode_Block_GetCount (IWICMetadataBlockReader *iface, UINT *count)
 
static HRESULT create_IMD_metadata_reader (GifFrameDecode *This, IWICMetadataReader **reader)
 
static HRESULT WINAPI GifFrameDecode_Block_GetReaderByIndex (IWICMetadataBlockReader *iface, UINT index, IWICMetadataReader **reader)
 
static HRESULT WINAPI GifFrameDecode_Block_GetEnumerator (IWICMetadataBlockReader *iface, IEnumUnknown **enumerator)
 
static HRESULT WINAPI GifDecoder_QueryInterface (IWICBitmapDecoder *iface, REFIID iid, void **ppv)
 
static ULONG WINAPI GifDecoder_AddRef (IWICBitmapDecoder *iface)
 
static ULONG WINAPI GifDecoder_Release (IWICBitmapDecoder *iface)
 
static HRESULT WINAPI GifDecoder_QueryCapability (IWICBitmapDecoder *iface, IStream *stream, DWORD *capability)
 
static int _gif_inputfunc (GifFileType *gif, GifByteType *data, int len)
 
static HRESULT WINAPI GifDecoder_Initialize (IWICBitmapDecoder *iface, IStream *pIStream, WICDecodeOptions cacheOptions)
 
static HRESULT WINAPI GifDecoder_GetContainerFormat (IWICBitmapDecoder *iface, GUID *pguidContainerFormat)
 
static HRESULT WINAPI GifDecoder_GetDecoderInfo (IWICBitmapDecoder *iface, IWICBitmapDecoderInfo **ppIDecoderInfo)
 
static HRESULT WINAPI GifDecoder_CopyPalette (IWICBitmapDecoder *iface, IWICPalette *palette)
 
static HRESULT WINAPI GifDecoder_GetMetadataQueryReader (IWICBitmapDecoder *iface, IWICMetadataQueryReader **ppIMetadataQueryReader)
 
static HRESULT WINAPI GifDecoder_GetPreview (IWICBitmapDecoder *iface, IWICBitmapSource **ppIBitmapSource)
 
static HRESULT WINAPI GifDecoder_GetColorContexts (IWICBitmapDecoder *iface, UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
 
static HRESULT WINAPI GifDecoder_GetThumbnail (IWICBitmapDecoder *iface, IWICBitmapSource **ppIThumbnail)
 
static HRESULT WINAPI GifDecoder_GetFrameCount (IWICBitmapDecoder *iface, UINT *pCount)
 
static HRESULT WINAPI GifDecoder_GetFrame (IWICBitmapDecoder *iface, UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
 
static HRESULT WINAPI GifDecoder_Block_QueryInterface (IWICMetadataBlockReader *iface, REFIID iid, void **ppv)
 
static ULONG WINAPI GifDecoder_Block_AddRef (IWICMetadataBlockReader *iface)
 
static ULONG WINAPI GifDecoder_Block_Release (IWICMetadataBlockReader *iface)
 
static HRESULT WINAPI GifDecoder_Block_GetContainerFormat (IWICMetadataBlockReader *iface, GUID *guid)
 
static HRESULT WINAPI GifDecoder_Block_GetCount (IWICMetadataBlockReader *iface, UINT *count)
 
static HRESULT WINAPI GifDecoder_Block_GetReaderByIndex (IWICMetadataBlockReader *iface, UINT index, IWICMetadataReader **reader)
 
static HRESULT WINAPI GifDecoder_Block_GetEnumerator (IWICMetadataBlockReader *iface, IEnumUnknown **enumerator)
 
HRESULT GifDecoder_CreateInstance (REFIID iid, void **ppv)
 
static GifEncoderimpl_from_IWICBitmapEncoder (IWICBitmapEncoder *iface)
 
static GifFrameEncodeimpl_from_IWICBitmapFrameEncode (IWICBitmapFrameEncode *iface)
 
static GifFrameEncodeimpl_from_IWICMetadataBlockWriter (IWICMetadataBlockWriter *iface)
 
static HRESULT WINAPI GifFrameEncode_QueryInterface (IWICBitmapFrameEncode *iface, REFIID iid, void **ppv)
 
static ULONG WINAPI GifFrameEncode_AddRef (IWICBitmapFrameEncode *iface)
 
static ULONG WINAPI GifFrameEncode_Release (IWICBitmapFrameEncode *iface)
 
static HRESULT WINAPI GifFrameEncode_Initialize (IWICBitmapFrameEncode *iface, IPropertyBag2 *options)
 
static HRESULT WINAPI GifFrameEncode_SetSize (IWICBitmapFrameEncode *iface, UINT width, UINT height)
 
static HRESULT WINAPI GifFrameEncode_SetResolution (IWICBitmapFrameEncode *iface, double xres, double yres)
 
static HRESULT WINAPI GifFrameEncode_SetPixelFormat (IWICBitmapFrameEncode *iface, WICPixelFormatGUID *format)
 
static HRESULT WINAPI GifFrameEncode_SetColorContexts (IWICBitmapFrameEncode *iface, UINT count, IWICColorContext **context)
 
static HRESULT WINAPI GifFrameEncode_SetPalette (IWICBitmapFrameEncode *iface, IWICPalette *palette)
 
static HRESULT WINAPI GifFrameEncode_SetThumbnail (IWICBitmapFrameEncode *iface, IWICBitmapSource *thumbnail)
 
static HRESULT WINAPI GifFrameEncode_WritePixels (IWICBitmapFrameEncode *iface, UINT lines, UINT stride, UINT size, BYTE *pixels)
 
static HRESULT WINAPI GifFrameEncode_WriteSource (IWICBitmapFrameEncode *iface, IWICBitmapSource *source, WICRect *rc)
 
static int lzw_output_code (struct lzw_state *state, short code)
 
static int lzw_output_clear_code (struct lzw_state *state)
 
static int lzw_output_eof_code (struct lzw_state *state)
 
static int lzw_flush_bits (struct lzw_state *state)
 
static void lzw_dict_reset (struct lzw_state *state)
 
static void lzw_state_init (struct lzw_state *state, short init_code_bits, void *user_write_data, void *user_ptr)
 
static int lzw_dict_add (struct lzw_state *state, short prefix, unsigned char suffix)
 
static short lzw_dict_lookup (const struct lzw_state *state, short prefix, unsigned char suffix)
 
static int write_byte (struct output_stream *out, char byte)
 
static int write_data (void *user_ptr, void *user_data, int length)
 
static int flush_output_data (void *user_ptr)
 
static int read_byte (struct input_stream *in, unsigned char *byte)
 
static HRESULT gif_compress (IStream *out_stream, const BYTE *in_data, ULONG in_size)
 
static HRESULT WINAPI GifFrameEncode_Commit (IWICBitmapFrameEncode *iface)
 
static HRESULT WINAPI GifFrameEncode_GetMetadataQueryWriter (IWICBitmapFrameEncode *iface, IWICMetadataQueryWriter **writer)
 
static HRESULT WINAPI GifEncoder_QueryInterface (IWICBitmapEncoder *iface, REFIID iid, void **ppv)
 
static ULONG WINAPI GifEncoder_AddRef (IWICBitmapEncoder *iface)
 
static ULONG WINAPI GifEncoder_Release (IWICBitmapEncoder *iface)
 
static HRESULT WINAPI GifEncoder_Initialize (IWICBitmapEncoder *iface, IStream *stream, WICBitmapEncoderCacheOption option)
 
static HRESULT WINAPI GifEncoder_GetContainerFormat (IWICBitmapEncoder *iface, GUID *format)
 
static HRESULT WINAPI GifEncoder_GetEncoderInfo (IWICBitmapEncoder *iface, IWICBitmapEncoderInfo **info)
 
static HRESULT WINAPI GifEncoder_SetColorContexts (IWICBitmapEncoder *iface, UINT count, IWICColorContext **context)
 
static HRESULT WINAPI GifEncoder_SetPalette (IWICBitmapEncoder *iface, IWICPalette *palette)
 
static HRESULT WINAPI GifEncoder_SetThumbnail (IWICBitmapEncoder *iface, IWICBitmapSource *thumbnail)
 
static HRESULT WINAPI GifEncoder_SetPreview (IWICBitmapEncoder *iface, IWICBitmapSource *preview)
 
static HRESULT WINAPI GifEncoderFrame_Block_QueryInterface (IWICMetadataBlockWriter *iface, REFIID iid, void **ppv)
 
static ULONG WINAPI GifEncoderFrame_Block_AddRef (IWICMetadataBlockWriter *iface)
 
static ULONG WINAPI GifEncoderFrame_Block_Release (IWICMetadataBlockWriter *iface)
 
static HRESULT WINAPI GifEncoderFrame_Block_GetContainerFormat (IWICMetadataBlockWriter *iface, GUID *container_format)
 
static HRESULT WINAPI GifEncoderFrame_Block_GetCount (IWICMetadataBlockWriter *iface, UINT *count)
 
static HRESULT WINAPI GifEncoderFrame_Block_GetReaderByIndex (IWICMetadataBlockWriter *iface, UINT index, IWICMetadataReader **metadata_reader)
 
static HRESULT WINAPI GifEncoderFrame_Block_GetEnumerator (IWICMetadataBlockWriter *iface, IEnumUnknown **enum_metadata)
 
static HRESULT WINAPI GifEncoderFrame_Block_InitializeFromBlockReader (IWICMetadataBlockWriter *iface, IWICMetadataBlockReader *block_reader)
 
static HRESULT WINAPI GifEncoderFrame_Block_GetWriterByIndex (IWICMetadataBlockWriter *iface, UINT index, IWICMetadataWriter **metadata_writer)
 
static HRESULT WINAPI GifEncoderFrame_Block_AddWriter (IWICMetadataBlockWriter *iface, IWICMetadataWriter *metadata_writer)
 
static HRESULT WINAPI GifEncoderFrame_Block_SetWriterByIndex (IWICMetadataBlockWriter *iface, UINT index, IWICMetadataWriter *metadata_writer)
 
static HRESULT WINAPI GifEncoderFrame_Block_RemoveWriterByIndex (IWICMetadataBlockWriter *iface, UINT index)
 
static HRESULT WINAPI GifEncoder_CreateNewFrame (IWICBitmapEncoder *iface, IWICBitmapFrameEncode **frame, IPropertyBag2 **options)
 
static HRESULT WINAPI GifEncoder_Commit (IWICBitmapEncoder *iface)
 
static HRESULT WINAPI GifEncoder_GetMetadataQueryWriter (IWICBitmapEncoder *iface, IWICMetadataQueryWriter **writer)
 
HRESULT GifEncoder_CreateInstance (REFIID iid, void **ppv)
 

Variables

static const MetadataHandlerVtbl LSDReader_Vtbl
 
static const MetadataHandlerVtbl IMDReader_Vtbl
 
static const MetadataHandlerVtbl GCEReader_Vtbl
 
static const MetadataHandlerVtbl APEReader_Vtbl
 
static const MetadataHandlerVtbl GifCommentReader_Vtbl
 
static const IWICBitmapFrameDecodeVtbl GifFrameDecode_Vtbl
 
static const IWICMetadataBlockReaderVtbl GifFrameDecode_BlockVtbl
 
static const IWICBitmapDecoderVtbl GifDecoder_Vtbl
 
static const IWICMetadataBlockReaderVtbl GifDecoder_BlockVtbl
 
static const IWICBitmapFrameEncodeVtbl GifFrameEncode_Vtbl
 
static const IWICMetadataBlockWriterVtbl GifFrameEncode_BlockVtbl
 
static const IWICBitmapEncoderVtbl GifEncoder_Vtbl
 

Macro Definition Documentation

◆ COBJMACROS

#define COBJMACROS

Definition at line 22 of file gifformat.c.

◆ LZW_DICT_SIZE

#define LZW_DICT_SIZE   (1 << 12)

Definition at line 1730 of file gifformat.c.

Typedef Documentation

◆ GifEncoder

◆ GifFrameEncode

Function Documentation

◆ _gif_inputfunc()

static int _gif_inputfunc ( GifFileType gif,
GifByteType data,
int  len 
)
static

Definition at line 1102 of file gifformat.c.

1102 {
1103 IStream *stream = gif->UserData;
1104 ULONG bytesread;
1105 HRESULT hr;
1106
1107 if (!stream)
1108 {
1109 ERR("attempting to read file after initialization\n");
1110 return 0;
1111 }
1112
1113 hr = IStream_Read(stream, data, len, &bytesread);
1114 if (FAILED(hr)) bytesread = 0;
1115 return bytesread;
1116}
#define ERR(fmt,...)
Definition: precomp.h:57
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLenum GLsizei len
Definition: glext.h:6722
#define FAILED(hr)
Definition: intsafe.h:51
HRESULT hr
Definition: shlfolder.c:183
void * UserData
Definition: ungif.h:125
Definition: parse.h:23
uint32_t ULONG
Definition: typedefs.h:59

Referenced by GifDecoder_Initialize().

◆ APEReader_CreateInstance()

HRESULT APEReader_CreateInstance ( REFIID  iid,
void **  ppv 
)

Definition at line 422 of file gifformat.c.

423{
425}
static const MetadataHandlerVtbl APEReader_Vtbl
Definition: gifformat.c:416
REFIID LPVOID * ppv
Definition: atlbase.h:39
HRESULT MetadataReader_Create(const MetadataHandlerVtbl *vtable, REFIID iid, void **ppv)

Referenced by GifDecoder_Block_GetReaderByIndex().

◆ copy_interlaced_pixels()

static HRESULT copy_interlaced_pixels ( const BYTE srcbuffer,
UINT  srcwidth,
UINT  srcheight,
INT  srcstride,
const WICRect rc,
UINT  dststride,
UINT  dstbuffersize,
BYTE dstbuffer 
)
static

Definition at line 763 of file gifformat.c.

766{
767 UINT row_offset; /* number of bytes into the source rows where the data starts */
768 const BYTE *src;
769 BYTE *dst;
770 UINT y;
772
773 if (!rc)
774 {
775 rect.X = 0;
776 rect.Y = 0;
777 rect.Width = srcwidth;
778 rect.Height = srcheight;
779 rc = &rect;
780 }
781 else
782 {
783 if (rc->X < 0 || rc->Y < 0 || rc->X+rc->Width > srcwidth || rc->Y+rc->Height > srcheight)
784 return E_INVALIDARG;
785 }
786
787 if (dststride < rc->Width)
788 return E_INVALIDARG;
789
790 if ((dststride * rc->Height) > dstbuffersize)
791 return E_INVALIDARG;
792
793 row_offset = rc->X;
794
795 dst = dstbuffer;
796 for (y=rc->Y; y-rc->Y < rc->Height; y++)
797 {
798 if (y%8 == 0)
799 src = srcbuffer + srcstride * (y/8);
800 else if (y%4 == 0)
801 src = srcbuffer + srcstride * ((srcheight+7)/8 + y/8);
802 else if (y%2 == 0)
803 src = srcbuffer + srcstride * ((srcheight+3)/4 + y/4);
804 else /* y%2 == 1 */
805 src = srcbuffer + srcstride * ((srcheight+1)/2 + y/2);
806 src += row_offset;
807 memcpy(dst, src, rc->Width);
808 dst += dststride;
809 }
810 return S_OK;
811}
#define E_INVALIDARG
Definition: ddrawi.h:101
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLenum src
Definition: glext.h:6340
GLenum GLenum dst
Definition: glext.h:6340
#define S_OK
Definition: intsafe.h:52
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
unsigned int UINT
Definition: ndis.h:50
& rect
Definition: startmenu.cpp:1413
INT Height
Definition: wincodec.idl:335
INT Width
Definition: wincodec.idl:334
_In_ HFONT _Out_ PUINT _Out_ PUINT Width
Definition: font.h:89
unsigned char BYTE
Definition: xxhash.c:193

Referenced by GifFrameDecode_CopyPixels().

◆ copy_palette()

static void copy_palette ( ColorMapObject cm,
Extensions extensions,
int  count,
WICColor colors 
)
static

Definition at line 698 of file gifformat.c.

699{
700 int i;
701
702 if (cm)
703 {
704 for (i = 0; i < count; i++)
705 {
706 colors[i] = 0xff000000 | /* alpha */
707 cm->Colors[i].Red << 16 |
708 cm->Colors[i].Green << 8 |
709 cm->Colors[i].Blue;
710 }
711 }
712 else
713 {
714 colors[0] = 0xff000000;
715 colors[1] = 0xffffffff;
716 for (i = 2; i < count; i++)
717 colors[i] = 0xff000000;
718 }
719
720 /* look for the transparent color extension */
721 for (i = 0; i < extensions->ExtensionBlockCount; i++)
722 {
723 ExtensionBlock *eb = extensions->ExtensionBlocks + i;
724 if (eb->Function == GRAPHICS_EXT_FUNC_CODE &&
725 eb->ByteCount == 8 && eb->Bytes[3] & 1)
726 {
727 int trans = (unsigned char)eb->Bytes[6];
728 colors[trans] &= 0xffffff; /* set alpha to 0 */
729 break;
730 }
731 }
732}
unsigned char
Definition: typeof.h:29
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GifColorType * Colors
Definition: ungif.h:92
char * Bytes
Definition: ungif.h:105
int ByteCount
Definition: ungif.h:104
int Function
Definition: ungif.h:103
ExtensionBlock * ExtensionBlocks
Definition: ungif.h:111
int ExtensionBlockCount
Definition: ungif.h:110
GifByteType Blue
Definition: ungif.h:85
GifByteType Green
Definition: ungif.h:85
GifByteType Red
Definition: ungif.h:85
#define GRAPHICS_EXT_FUNC_CODE
Definition: ungif.h:143

Referenced by GifDecoder_CopyPalette(), and GifFrameDecode_CopyPalette().

◆ create_IMD_metadata_reader()

static HRESULT create_IMD_metadata_reader ( GifFrameDecode This,
IWICMetadataReader **  reader 
)
static

Definition at line 917 of file gifformat.c.

918{
919 HRESULT hr;
920 IWICMetadataReader *metadata_reader;
921 IWICPersistStream *persist;
923 struct image_descriptor IMD_data;
924
925 /* FIXME: Use IWICComponentFactory_CreateMetadataReader once it's implemented */
926
927 hr = IMDReader_CreateInstance(&IID_IWICMetadataReader, (void **)&metadata_reader);
928 if (FAILED(hr)) return hr;
929
930 hr = IWICMetadataReader_QueryInterface(metadata_reader, &IID_IWICPersistStream, (void **)&persist);
931 if (FAILED(hr))
932 {
933 IWICMetadataReader_Release(metadata_reader);
934 return hr;
935 }
936
937 /* recreate IMD structure from GIF decoder data */
938 IMD_data.left = This->frame->ImageDesc.Left;
939 IMD_data.top = This->frame->ImageDesc.Top;
940 IMD_data.width = This->frame->ImageDesc.Width;
941 IMD_data.height = This->frame->ImageDesc.Height;
942 IMD_data.packed = 0;
943 /* interlace_flag */
944 IMD_data.packed |= This->frame->ImageDesc.Interlace ? (1 << 6) : 0;
945 if (This->frame->ImageDesc.ColorMap)
946 {
947 /* local_color_table_flag */
948 IMD_data.packed |= 1 << 7;
949 /* local_color_table_size */
950 IMD_data.packed |= This->frame->ImageDesc.ColorMap->BitsPerPixel - 1;
951 /* sort_flag */
952 IMD_data.packed |= This->frame->ImageDesc.ColorMap->SortFlag ? 0x20 : 0;
953 }
954
955 stream = create_stream(&IMD_data, sizeof(IMD_data));
956 IWICPersistStream_LoadEx(persist, stream, NULL, WICPersistOptionDefault);
957 IStream_Release(stream);
958
959 IWICPersistStream_Release(persist);
960
961 *reader = metadata_reader;
962 return S_OK;
963}
#define NULL
Definition: types.h:112
HRESULT IMDReader_CreateInstance(REFIID iid, void **ppv)
Definition: gifformat.c:237
static IStream * create_stream(const void *data, int data_size)
Definition: gifformat.c:521
Definition: reader.h:84
@ WICPersistOptionDefault
Definition: wincodecsdk.idl:23

Referenced by GifFrameDecode_Block_GetReaderByIndex().

◆ create_metadata_reader()

static HRESULT create_metadata_reader ( const void data,
int  data_size,
class_constructor  constructor,
IWICMetadataReader **  reader 
)
static

Definition at line 539 of file gifformat.c.

542{
543 HRESULT hr;
544 IWICMetadataReader *metadata_reader;
545 IWICPersistStream *persist;
547
548 /* FIXME: Use IWICComponentFactory_CreateMetadataReader once it's implemented */
549
550 hr = constructor(&IID_IWICMetadataReader, (void**)&metadata_reader);
551 if (FAILED(hr)) return hr;
552
553 hr = IWICMetadataReader_QueryInterface(metadata_reader, &IID_IWICPersistStream, (void **)&persist);
554 if (FAILED(hr))
555 {
556 IWICMetadataReader_Release(metadata_reader);
557 return hr;
558 }
559
560 stream = create_stream(data, data_size);
561 IWICPersistStream_LoadEx(persist, stream, NULL, WICPersistOptionDefault);
562 IStream_Release(stream);
563
564 IWICPersistStream_Release(persist);
565
566 *reader = metadata_reader;
567 return S_OK;
568}

Referenced by GifDecoder_Block_GetReaderByIndex(), and GifFrameDecode_Block_GetReaderByIndex().

◆ create_stream()

static IStream * create_stream ( const void data,
int  data_size 
)
static

Definition at line 521 of file gifformat.c.

522{
523 HRESULT hr;
525 HGLOBAL hdata;
526 void *locked_data;
527
528 hdata = GlobalAlloc(GMEM_MOVEABLE, data_size);
529 if (!hdata) return NULL;
530
531 locked_data = GlobalLock(hdata);
532 memcpy(locked_data, data, data_size);
533 GlobalUnlock(hdata);
534
536 return FAILED(hr) ? NULL : stream;
537}
#define TRUE
Definition: types.h:120
HRESULT WINAPI CreateStreamOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPSTREAM *ppstm)
LPVOID NTAPI GlobalLock(HGLOBAL hMem)
Definition: heapmem.c:755
BOOL NTAPI GlobalUnlock(HGLOBAL hMem)
Definition: heapmem.c:1190
HGLOBAL NTAPI GlobalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:368
#define GMEM_MOVEABLE
Definition: winbase.h:320

Referenced by create_decoder(), create_IMD_metadata_reader(), create_metadata_reader(), and test_truncated_gif().

◆ flush_output_data()

static int flush_output_data ( void user_ptr)
static

Definition at line 1905 of file gifformat.c.

1906{
1907 struct output_stream *out = user_ptr;
1908
1909 if (out->gif_block.len)
1910 {
1911 if (IStream_Write(out->out, &out->gif_block, out->gif_block.len + sizeof(out->gif_block.len), NULL) != S_OK)
1912 return 0;
1913 }
1914
1915 /* write GIF block terminator */
1916 out->gif_block.len = 0;
1917 return IStream_Write(out->out, &out->gif_block, sizeof(out->gif_block.len), NULL) == S_OK;
1918}
wchar_t tm const _CrtWcstime_Writes_and_advances_ptr_ count wchar_t ** out
Definition: wcsftime.cpp:383

Referenced by gif_compress().

◆ frame_from_IWICMetadataBlockReader()

static GifFrameDecode * frame_from_IWICMetadataBlockReader ( IWICMetadataBlockReader iface)
inlinestatic

Definition at line 605 of file gifformat.c.

606{
607 return CONTAINING_RECORD(iface, GifFrameDecode, IWICMetadataBlockReader_iface);
608}
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

Referenced by GifFrameDecode_Block_AddRef(), GifFrameDecode_Block_GetCount(), GifFrameDecode_Block_GetReaderByIndex(), GifFrameDecode_Block_QueryInterface(), and GifFrameDecode_Block_Release().

◆ GCEReader_CreateInstance()

HRESULT GCEReader_CreateInstance ( REFIID  iid,
void **  ppv 
)

Definition at line 315 of file gifformat.c.

316{
318}
static const MetadataHandlerVtbl GCEReader_Vtbl
Definition: gifformat.c:309

Referenced by GifFrameDecode_Block_GetReaderByIndex().

◆ gif_compress()

static HRESULT gif_compress ( IStream out_stream,
const BYTE in_data,
ULONG  in_size 
)
static

Definition at line 1932 of file gifformat.c.

1933{
1934 struct input_stream in;
1935 struct output_stream out;
1936 struct lzw_state state;
1937 short init_code_bits, prefix, code;
1938 unsigned char suffix;
1939
1940 in.in = in_data;
1941 in.len = in_size;
1942
1943 out.gif_block.len = 0;
1944 out.out = out_stream;
1945
1946 init_code_bits = suffix = 8;
1947 if (IStream_Write(out.out, &suffix, sizeof(suffix), NULL) != S_OK)
1948 return E_FAIL;
1949
1951
1953 return E_FAIL;
1954
1955 if (read_byte(&in, &suffix))
1956 {
1957 prefix = suffix;
1958
1959 while (read_byte(&in, &suffix))
1960 {
1961 code = lzw_dict_lookup(&state, prefix, suffix);
1962 if (code == -1)
1963 {
1965 return E_FAIL;
1966
1967 if (lzw_dict_add(&state, prefix, suffix) == -1)
1968 {
1970 return E_FAIL;
1972 }
1973
1974 prefix = suffix;
1975 }
1976 else
1977 prefix = code;
1978 }
1979
1981 return E_FAIL;
1983 return E_FAIL;
1984 if (!lzw_flush_bits(&state))
1985 return E_FAIL;
1986 }
1987
1988 return flush_output_data(&out) ? S_OK : E_FAIL;
1989}
static int state
Definition: maze.c:121
#define E_FAIL
Definition: ddrawi.h:102
static int lzw_dict_add(struct lzw_state *state, short prefix, unsigned char suffix)
Definition: gifformat.c:1846
static short lzw_dict_lookup(const struct lzw_state *state, short prefix, unsigned char suffix)
Definition: gifformat.c:1863
static void lzw_dict_reset(struct lzw_state *state)
Definition: gifformat.c:1819
static int lzw_output_eof_code(struct lzw_state *state)
Definition: gifformat.c:1786
static int flush_output_data(void *user_ptr)
Definition: gifformat.c:1905
static int lzw_flush_bits(struct lzw_state *state)
Definition: gifformat.c:1791
static void lzw_state_init(struct lzw_state *state, short init_code_bits, void *user_write_data, void *user_ptr)
Definition: gifformat.c:1833
static int lzw_output_clear_code(struct lzw_state *state)
Definition: gifformat.c:1781
static int read_byte(struct input_stream *in, unsigned char *byte)
Definition: gifformat.c:1920
static int lzw_output_code(struct lzw_state *state, short code)
Definition: gifformat.c:1764
GLuint in
Definition: glext.h:9616
static HANDLE PIO_APC_ROUTINE PVOID PIO_STATUS_BLOCK ULONG PVOID ULONG in_size
Definition: file.c:100
Definition: inflate.c:139
short init_code_bits
Definition: gifformat.c:1741
Character const *const prefix
Definition: tempnam.cpp:195

Referenced by GifFrameEncode_Commit().

◆ GifCommentReader_CreateInstance()

HRESULT GifCommentReader_CreateInstance ( REFIID  iid,
void **  ppv 
)

Definition at line 516 of file gifformat.c.

517{
519}
static const MetadataHandlerVtbl GifCommentReader_Vtbl
Definition: gifformat.c:510

Referenced by GifDecoder_Block_GetReaderByIndex(), and GifFrameDecode_Block_GetReaderByIndex().

◆ GifDecoder_AddRef()

static ULONG WINAPI GifDecoder_AddRef ( IWICBitmapDecoder iface)
static

Definition at line 1052 of file gifformat.c.

1053{
1056
1057 TRACE("(%p) refcount=%lu\n", iface, ref);
1058
1059 return ref;
1060}
#define InterlockedIncrement
Definition: armddk.h:53
static GifDecoder * impl_from_IWICBitmapDecoder(IWICBitmapDecoder *iface)
Definition: gifformat.c:590
#define TRACE(s)
Definition: solgame.cpp:4
Definition: send.c:48

◆ GifDecoder_Block_AddRef()

static ULONG WINAPI GifDecoder_Block_AddRef ( IWICMetadataBlockReader iface)
static

Definition at line 1313 of file gifformat.c.

1314{
1316 return IWICBitmapDecoder_AddRef(&This->IWICBitmapDecoder_iface);
1317}
static GifDecoder * impl_from_IWICMetadataBlockReader(IWICMetadataBlockReader *iface)
Definition: gifformat.c:595

◆ GifDecoder_Block_GetContainerFormat()

static HRESULT WINAPI GifDecoder_Block_GetContainerFormat ( IWICMetadataBlockReader iface,
GUID guid 
)
static

Definition at line 1325 of file gifformat.c.

1327{
1328 TRACE("(%p,%p)\n", iface, guid);
1329
1330 if (!guid) return E_INVALIDARG;
1331
1332 *guid = GUID_ContainerFormatGif;
1333 return S_OK;
1334}
const GUID * guid

◆ GifDecoder_Block_GetCount()

static HRESULT WINAPI GifDecoder_Block_GetCount ( IWICMetadataBlockReader iface,
UINT count 
)
static

Definition at line 1336 of file gifformat.c.

1338{
1340
1341 TRACE("%p,%p\n", iface, count);
1342
1343 if (!count) return E_INVALIDARG;
1344
1345 *count = This->gif->Extensions.ExtensionBlockCount + 1;
1346 return S_OK;
1347}

◆ GifDecoder_Block_GetEnumerator()

static HRESULT WINAPI GifDecoder_Block_GetEnumerator ( IWICMetadataBlockReader iface,
IEnumUnknown **  enumerator 
)
static

Definition at line 1384 of file gifformat.c.

1386{
1387 FIXME("(%p,%p): stub\n", iface, enumerator);
1388 return E_NOTIMPL;
1389}
#define FIXME(fmt,...)
Definition: precomp.h:53
#define E_NOTIMPL
Definition: ddrawi.h:99

◆ GifDecoder_Block_GetReaderByIndex()

static HRESULT WINAPI GifDecoder_Block_GetReaderByIndex ( IWICMetadataBlockReader iface,
UINT  index,
IWICMetadataReader **  reader 
)
static

Definition at line 1349 of file gifformat.c.

1351{
1353 int i;
1354
1355 TRACE("(%p,%u,%p)\n", iface, index, reader);
1356
1357 if (!reader) return E_INVALIDARG;
1358
1359 if (index == 0)
1360 return create_metadata_reader(This->LSD_data, sizeof(This->LSD_data),
1362
1363 for (i = 0; i < This->gif->Extensions.ExtensionBlockCount; i++)
1364 {
1365 class_constructor constructor;
1366
1367 if (index != i + 1) continue;
1368
1369 if (This->gif->Extensions.ExtensionBlocks[i].Function == APPLICATION_EXT_FUNC_CODE)
1370 constructor = APEReader_CreateInstance;
1371 else if (This->gif->Extensions.ExtensionBlocks[i].Function == COMMENT_EXT_FUNC_CODE)
1372 constructor = GifCommentReader_CreateInstance;
1373 else
1375
1376 return create_metadata_reader(This->gif->Extensions.ExtensionBlocks[i].Bytes,
1377 This->gif->Extensions.ExtensionBlocks[i].ByteCount,
1378 constructor, reader);
1379 }
1380
1381 return E_INVALIDARG;
1382}
HRESULT APEReader_CreateInstance(REFIID iid, void **ppv)
Definition: gifformat.c:422
HRESULT LSDReader_CreateInstance(REFIID iid, void **ppv)
Definition: gifformat.c:156
static HRESULT create_metadata_reader(const void *data, int data_size, class_constructor constructor, IWICMetadataReader **reader)
Definition: gifformat.c:539
HRESULT GifCommentReader_CreateInstance(REFIID iid, void **ppv)
Definition: gifformat.c:516
GLuint index
Definition: glext.h:6031
HRESULT UnknownMetadataReader_CreateInstance(REFIID iid, void **ppv)
#define COMMENT_EXT_FUNC_CODE
Definition: ungif.h:142
#define APPLICATION_EXT_FUNC_CODE
Definition: ungif.h:145
HRESULT(* class_constructor)(REFIID, void **)

◆ GifDecoder_Block_QueryInterface()

static HRESULT WINAPI GifDecoder_Block_QueryInterface ( IWICMetadataBlockReader iface,
REFIID  iid,
void **  ppv 
)
static

Definition at line 1306 of file gifformat.c.

1308{
1310 return IWICBitmapDecoder_QueryInterface(&This->IWICBitmapDecoder_iface, iid, ppv);
1311}

◆ GifDecoder_Block_Release()

static ULONG WINAPI GifDecoder_Block_Release ( IWICMetadataBlockReader iface)
static

Definition at line 1319 of file gifformat.c.

1320{
1322 return IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
1323}

◆ GifDecoder_CopyPalette()

static HRESULT WINAPI GifDecoder_CopyPalette ( IWICBitmapDecoder iface,
IWICPalette palette 
)
static

Definition at line 1187 of file gifformat.c.

1188{
1190 WICColor colors[256];
1191 ColorMapObject *cm;
1192 int count;
1193
1194 TRACE("(%p,%p)\n", iface, palette);
1195
1196 if (!This->gif)
1198
1199 cm = This->gif->SColorMap;
1200 count = This->gif->SColorTableSize;
1201
1202 if (count > 256)
1203 {
1204 ERR("GIF contains invalid number of colors: %d\n", count);
1205 return E_FAIL;
1206 }
1207
1208 copy_palette(cm, &This->gif->SavedImages[This->current_frame].Extensions, count, colors);
1209
1210 return IWICPalette_InitializeCustom(palette, colors, count);
1211}
static void copy_palette(ColorMapObject *cm, Extensions *extensions, int count, WICColor *colors)
Definition: gifformat.c:698
static HPALETTE palette
Definition: clipboard.c:1345
UINT32 WICColor
Definition: wincodec.idl:364
#define WINCODEC_ERR_WRONGSTATE
Definition: winerror.h:3281

◆ GifDecoder_CreateInstance()

HRESULT GifDecoder_CreateInstance ( REFIID  iid,
void **  ppv 
)

Definition at line 1402 of file gifformat.c.

1403{
1405 HRESULT ret;
1406
1407 TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
1408
1409 *ppv = NULL;
1410
1411 This = malloc(sizeof(GifDecoder));
1412 if (!This) return E_OUTOFMEMORY;
1413
1414 This->IWICBitmapDecoder_iface.lpVtbl = &GifDecoder_Vtbl;
1415 This->IWICMetadataBlockReader_iface.lpVtbl = &GifDecoder_BlockVtbl;
1416 This->stream = NULL;
1417 This->ref = 1;
1418 This->initialized = FALSE;
1419 This->gif = NULL;
1420 This->current_frame = 0;
1421#ifdef __REACTOS__
1423#else
1425#endif
1426 This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": GifDecoder.lock");
1427
1428 ret = IWICBitmapDecoder_QueryInterface(&This->IWICBitmapDecoder_iface, iid, ppv);
1429 IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
1430
1431 return ret;
1432}
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define malloc
Definition: debug_ros.c:4
#define FALSE
Definition: types.h:117
BOOL WINAPI InitializeCriticalSectionEx(OUT LPCRITICAL_SECTION lpCriticalSection, IN DWORD dwSpinCount, IN DWORD flags)
Definition: sync.c:107
static const IWICMetadataBlockReaderVtbl GifDecoder_BlockVtbl
Definition: gifformat.c:1391
static const IWICBitmapDecoderVtbl GifDecoder_Vtbl
Definition: gifformat.c:1289
#define debugstr_guid
Definition: kernel32.h:35
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
#define DWORD_PTR
Definition: treelist.c:76
int ret
#define RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO
Definition: winnt_old.h:1118

◆ GifDecoder_GetColorContexts()

static HRESULT WINAPI GifDecoder_GetColorContexts ( IWICBitmapDecoder iface,
UINT  cCount,
IWICColorContext **  ppIColorContexts,
UINT pcActualCount 
)
static

Definition at line 1232 of file gifformat.c.

1234{
1235 TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
1237}
#define WINCODEC_ERR_UNSUPPORTEDOPERATION
Definition: winerror.h:3308

◆ GifDecoder_GetContainerFormat()

static HRESULT WINAPI GifDecoder_GetContainerFormat ( IWICBitmapDecoder iface,
GUID pguidContainerFormat 
)
static

Definition at line 1172 of file gifformat.c.

1174{
1175 memcpy(pguidContainerFormat, &GUID_ContainerFormatGif, sizeof(GUID));
1176 return S_OK;
1177}

◆ GifDecoder_GetDecoderInfo()

static HRESULT WINAPI GifDecoder_GetDecoderInfo ( IWICBitmapDecoder iface,
IWICBitmapDecoderInfo **  ppIDecoderInfo 
)
static

Definition at line 1179 of file gifformat.c.

1181{
1182 TRACE("(%p,%p)\n", iface, ppIDecoderInfo);
1183
1184 return get_decoder_info(&CLSID_WICGifDecoder, ppIDecoderInfo);
1185}
static GpStatus get_decoder_info(IStream *stream, const struct image_codec **result)
Definition: image.c:4285

◆ GifDecoder_GetFrame()

static HRESULT WINAPI GifDecoder_GetFrame ( IWICBitmapDecoder iface,
UINT  index,
IWICBitmapFrameDecode **  ppIBitmapFrame 
)
static

Definition at line 1262 of file gifformat.c.

1264{
1267 TRACE("(%p,%u,%p)\n", iface, index, ppIBitmapFrame);
1268
1269 if (!This->initialized) return WINCODEC_ERR_FRAMEMISSING;
1270
1271 if (index >= This->gif->ImageCount) return E_INVALIDARG;
1272
1273 result = malloc(sizeof(GifFrameDecode));
1274 if (!result) return E_OUTOFMEMORY;
1275
1276 result->IWICBitmapFrameDecode_iface.lpVtbl = &GifFrameDecode_Vtbl;
1277 result->IWICMetadataBlockReader_iface.lpVtbl = &GifFrameDecode_BlockVtbl;
1278 result->ref = 1;
1279 result->frame = &This->gif->SavedImages[index];
1280 IWICBitmapDecoder_AddRef(iface);
1281 result->parent = This;
1282 This->current_frame = index;
1283
1284 *ppIBitmapFrame = &result->IWICBitmapFrameDecode_iface;
1285
1286 return S_OK;
1287}
#define index(s, c)
Definition: various.h:29
static const IWICMetadataBlockReaderVtbl GifFrameDecode_BlockVtbl
Definition: gifformat.c:1014
static const IWICBitmapFrameDecodeVtbl GifFrameDecode_Vtbl
Definition: gifformat.c:860
GLuint64EXT * result
Definition: glext.h:11304
#define WINCODEC_ERR_FRAMEMISSING
Definition: winerror.h:3301

◆ GifDecoder_GetFrameCount()

static HRESULT WINAPI GifDecoder_GetFrameCount ( IWICBitmapDecoder iface,
UINT pCount 
)
static

Definition at line 1246 of file gifformat.c.

1248{
1250
1251 if (!pCount) return E_INVALIDARG;
1252
1253 EnterCriticalSection(&This->lock);
1254 *pCount = This->gif ? This->gif->ImageCount : 0;
1255 LeaveCriticalSection(&This->lock);
1256
1257 TRACE("(%p) <-- %d\n", iface, *pCount);
1258
1259 return S_OK;
1260}
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)

◆ GifDecoder_GetMetadataQueryReader()

static HRESULT WINAPI GifDecoder_GetMetadataQueryReader ( IWICBitmapDecoder iface,
IWICMetadataQueryReader **  ppIMetadataQueryReader 
)
static

Definition at line 1213 of file gifformat.c.

1215{
1217
1218 TRACE("(%p,%p)\n", iface, ppIMetadataQueryReader);
1219
1220 if (!ppIMetadataQueryReader) return E_INVALIDARG;
1221
1222 return MetadataQueryReader_CreateInstance(&This->IWICMetadataBlockReader_iface, NULL, ppIMetadataQueryReader);
1223}
HRESULT MetadataQueryReader_CreateInstance(IWICMetadataBlockReader *mbr, const WCHAR *root, IWICMetadataQueryReader **out)

◆ GifDecoder_GetPreview()

static HRESULT WINAPI GifDecoder_GetPreview ( IWICBitmapDecoder iface,
IWICBitmapSource **  ppIBitmapSource 
)
static

Definition at line 1225 of file gifformat.c.

1227{
1228 TRACE("(%p,%p)\n", iface, ppIBitmapSource);
1230}

◆ GifDecoder_GetThumbnail()

static HRESULT WINAPI GifDecoder_GetThumbnail ( IWICBitmapDecoder iface,
IWICBitmapSource **  ppIThumbnail 
)
static

Definition at line 1239 of file gifformat.c.

1241{
1242 TRACE("(%p,%p)\n", iface, ppIThumbnail);
1244}
#define WINCODEC_ERR_CODECNOTHUMBNAIL
Definition: winerror.h:3291

◆ GifDecoder_Initialize()

static HRESULT WINAPI GifDecoder_Initialize ( IWICBitmapDecoder iface,
IStream pIStream,
WICDecodeOptions  cacheOptions 
)
static

Definition at line 1118 of file gifformat.c.

1120{
1123 int ret;
1124
1125 TRACE("(%p,%p,%x)\n", iface, pIStream, cacheOptions);
1126
1127 EnterCriticalSection(&This->lock);
1128
1129 if (This->initialized || This->gif)
1130 {
1131 WARN("already initialized\n");
1132 LeaveCriticalSection(&This->lock);
1134 }
1135
1136 /* seek to start of stream */
1137 seek.QuadPart = 0;
1138 IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
1139
1140 /* read all data from the stream */
1141 This->gif = DGifOpen((void*)pIStream, _gif_inputfunc);
1142 if (!This->gif)
1143 {
1144 LeaveCriticalSection(&This->lock);
1145 return E_FAIL;
1146 }
1147
1148 ret = DGifSlurp(This->gif);
1149 if (ret == GIF_ERROR)
1150 {
1151 LeaveCriticalSection(&This->lock);
1152 return E_FAIL;
1153 }
1154
1155 /* make sure we don't use the stream after this method returns */
1156 This->gif->UserData = NULL;
1157
1158 seek.QuadPart = 0;
1159 IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
1160 IStream_Read(pIStream, This->LSD_data, sizeof(This->LSD_data), NULL);
1161
1162 This->stream = pIStream;
1163 IStream_AddRef(This->stream);
1164
1165 This->initialized = TRUE;
1166
1167 LeaveCriticalSection(&This->lock);
1168
1169 return S_OK;
1170}
#define WARN(fmt,...)
Definition: precomp.h:61
static int _gif_inputfunc(GifFileType *gif, GifByteType *data, int len)
Definition: gifformat.c:1102
int seek(void *fd, ulong off, int mode)
Definition: pe.c:51
GifFileType * DGifOpen(void *userData, InputFunc readFunc)
Definition: ungif.c:964
int DGifSlurp(GifFileType *GifFile)
Definition: ungif.c:847
#define GIF_ERROR
Definition: ungif.h:55

◆ GifDecoder_QueryCapability()

static HRESULT WINAPI GifDecoder_QueryCapability ( IWICBitmapDecoder iface,
IStream stream,
DWORD capability 
)
static

Definition at line 1084 of file gifformat.c.

1086{
1087 HRESULT hr;
1088
1089 TRACE("(%p,%p,%p)\n", iface, stream, capability);
1090
1091 if (!stream || !capability) return E_INVALIDARG;
1092
1093 hr = IWICBitmapDecoder_Initialize(iface, stream, WICDecodeMetadataCacheOnDemand);
1094 if (hr != S_OK) return hr;
1095
1099 return S_OK;
1100}
@ WICDecodeMetadataCacheOnDemand
Definition: wincodec.idl:29
@ WICBitmapDecoderCapabilityCanDecodeSomeImages
Definition: wincodec.idl:51
@ WICBitmapDecoderCapabilityCanEnumerateMetadata
Definition: wincodec.idl:52
@ WICBitmapDecoderCapabilityCanDecodeAllImages
Definition: wincodec.idl:50

◆ GifDecoder_QueryInterface()

static HRESULT WINAPI GifDecoder_QueryInterface ( IWICBitmapDecoder iface,
REFIID  iid,
void **  ppv 
)
static

Definition at line 1025 of file gifformat.c.

1027{
1029 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
1030
1031 if (!ppv) return E_INVALIDARG;
1032
1033 if (IsEqualIID(&IID_IUnknown, iid) ||
1034 IsEqualIID(&IID_IWICBitmapDecoder, iid))
1035 {
1036 *ppv = &This->IWICBitmapDecoder_iface;
1037 }
1038 else if (IsEqualIID(&IID_IWICMetadataBlockReader, iid))
1039 {
1040 *ppv = &This->IWICMetadataBlockReader_iface;
1041 }
1042 else
1043 {
1044 *ppv = NULL;
1045 return E_NOINTERFACE;
1046 }
1047
1048 IUnknown_AddRef((IUnknown*)*ppv);
1049 return S_OK;
1050}
const GUID IID_IUnknown
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
#define E_NOINTERFACE
Definition: winerror.h:2364

◆ GifDecoder_Release()

static ULONG WINAPI GifDecoder_Release ( IWICBitmapDecoder iface)
static

Definition at line 1062 of file gifformat.c.

1063{
1066
1067 TRACE("(%p) refcount=%lu\n", iface, ref);
1068
1069 if (ref == 0)
1070 {
1071 if (This->stream)
1072 {
1073 IStream_Release(This->stream);
1074 DGifCloseFile(This->gif);
1075 }
1076 This->lock.DebugInfo->Spare[0] = 0;
1078 free(This);
1079 }
1080
1081 return ref;
1082}
#define InterlockedDecrement
Definition: armddk.h:52
#define free
Definition: debug_ros.c:5
int DGifCloseFile(GifFileType *GifFile)
Definition: ungif.c:1018
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)

◆ GifEncoder_AddRef()

static ULONG WINAPI GifEncoder_AddRef ( IWICBitmapEncoder iface)
static

Definition at line 2147 of file gifformat.c.

2148{
2151
2152 TRACE("%p -> %lu\n", iface, ref);
2153 return ref;
2154}
static GifEncoder * impl_from_IWICBitmapEncoder(IWICBitmapEncoder *iface)
Definition: gifformat.c:1446

◆ GifEncoder_Commit()

static HRESULT WINAPI GifEncoder_Commit ( IWICBitmapEncoder iface)
static

Definition at line 2427 of file gifformat.c.

2428{
2430 HRESULT hr;
2431
2432 TRACE("%p\n", iface);
2433
2434 EnterCriticalSection(&This->lock);
2435
2436 if (This->initialized && !This->committed)
2437 {
2438 char gif_trailer = 0x3b;
2439
2440 /* FIXME: write text, comment GIF extensions */
2441
2442 hr = IStream_Write(This->stream, &gif_trailer, sizeof(gif_trailer), NULL);
2443 if (hr == S_OK)
2444 This->committed = TRUE;
2445 }
2446 else
2448
2449 LeaveCriticalSection(&This->lock);
2450 return hr;
2451}

◆ GifEncoder_CreateInstance()

HRESULT GifEncoder_CreateInstance ( REFIID  iid,
void **  ppv 
)

Definition at line 2476 of file gifformat.c.

2477{
2479 HRESULT ret;
2480
2481 TRACE("%s,%p\n", debugstr_guid(iid), ppv);
2482
2483 *ppv = NULL;
2484
2485 This = malloc(sizeof(*This));
2486 if (!This) return E_OUTOFMEMORY;
2487
2488 This->IWICBitmapEncoder_iface.lpVtbl = &GifEncoder_Vtbl;
2489 This->ref = 1;
2490 This->stream = NULL;
2491#ifdef __REACTOS__
2493#else
2495#endif
2496 This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": GifEncoder.lock");
2497 This->initialized = FALSE;
2498 This->info_written = FALSE;
2499 This->committed = FALSE;
2500 This->n_frames = 0;
2501 This->colors = 0;
2502
2503 ret = IWICBitmapEncoder_QueryInterface(&This->IWICBitmapEncoder_iface, iid, ppv);
2504 IWICBitmapEncoder_Release(&This->IWICBitmapEncoder_iface);
2505
2506 return ret;
2507}
static const IWICBitmapEncoderVtbl GifEncoder_Vtbl
Definition: gifformat.c:2459

◆ GifEncoder_CreateNewFrame()

static HRESULT WINAPI GifEncoder_CreateNewFrame ( IWICBitmapEncoder iface,
IWICBitmapFrameEncode **  frame,
IPropertyBag2 **  options 
)
static

Definition at line 2367 of file gifformat.c.

2368{
2370 HRESULT hr;
2371
2372 TRACE("%p,%p,%p\n", iface, frame, options);
2373
2374 if (!frame) return E_INVALIDARG;
2375
2376 EnterCriticalSection(&This->lock);
2377
2378 if (This->initialized && !This->committed)
2379 {
2380 GifFrameEncode *ret = malloc(sizeof(*ret));
2381 if (ret)
2382 {
2383 This->n_frames++;
2384
2385 ret->IWICBitmapFrameEncode_iface.lpVtbl = &GifFrameEncode_Vtbl;
2386 ret->IWICMetadataBlockWriter_iface.lpVtbl = &GifFrameEncode_BlockVtbl;
2387
2388 ret->ref = 1;
2389 ret->encoder = This;
2390 ret->initialized = FALSE;
2391 ret->interlace = FALSE; /* FIXME: read from the properties */
2392 ret->committed = FALSE;
2393 ret->width = 0;
2394 ret->height = 0;
2395 ret->lines = 0;
2396 ret->xres = 0.0;
2397 ret->yres = 0.0;
2398 ret->colors = 0;
2399 ret->image_data = NULL;
2400 IWICBitmapEncoder_AddRef(iface);
2401 *frame = &ret->IWICBitmapFrameEncode_iface;
2402
2403 hr = S_OK;
2404
2405 if (options)
2406 {
2408 if (hr != S_OK)
2409 {
2410 IWICBitmapFrameEncode_Release(*frame);
2411 *frame = NULL;
2412 }
2413 }
2414 }
2415 else
2416 hr = E_OUTOFMEMORY;
2417 }
2418 else
2420
2421 LeaveCriticalSection(&This->lock);
2422
2423 return hr;
2424
2425}
static const IWICBitmapFrameEncodeVtbl GifFrameEncode_Vtbl
Definition: gifformat.c:2111
static const IWICMetadataBlockWriterVtbl GifFrameEncode_BlockVtbl
Definition: gifformat.c:2352
HRESULT CreatePropertyBag2(const PROPBAG2 *options, UINT count, IPropertyBag2 **ppPropertyBag2)
Definition: propertybag.c:278

◆ GifEncoder_GetContainerFormat()

static HRESULT WINAPI GifEncoder_GetContainerFormat ( IWICBitmapEncoder iface,
GUID format 
)
static

Definition at line 2200 of file gifformat.c.

2201{
2202 if (!format) return E_INVALIDARG;
2203
2204 *format = GUID_ContainerFormatGif;
2205 return S_OK;
2206}
Definition: format.c:58

◆ GifEncoder_GetEncoderInfo()

static HRESULT WINAPI GifEncoder_GetEncoderInfo ( IWICBitmapEncoder iface,
IWICBitmapEncoderInfo **  info 
)
static

Definition at line 2208 of file gifformat.c.

2209{
2210 IWICComponentInfo *comp_info;
2211 HRESULT hr;
2212
2213 TRACE("%p,%p\n", iface, info);
2214
2215 if (!info) return E_INVALIDARG;
2216
2217 hr = CreateComponentInfo(&CLSID_WICGifEncoder, &comp_info);
2218 if (hr == S_OK)
2219 {
2220 hr = IWICComponentInfo_QueryInterface(comp_info, &IID_IWICBitmapEncoderInfo, (void **)info);
2221 IWICComponentInfo_Release(comp_info);
2222 }
2223 return hr;
2224}
HRESULT CreateComponentInfo(REFCLSID clsid, IWICComponentInfo **ppIInfo)
Definition: info.c:2030

◆ GifEncoder_GetMetadataQueryWriter()

static HRESULT WINAPI GifEncoder_GetMetadataQueryWriter ( IWICBitmapEncoder iface,
IWICMetadataQueryWriter **  writer 
)
static

Definition at line 2453 of file gifformat.c.

2454{
2455 FIXME("%p,%p: stub\n", iface, writer);
2456 return E_NOTIMPL;
2457}

◆ GifEncoder_Initialize()

static HRESULT WINAPI GifEncoder_Initialize ( IWICBitmapEncoder iface,
IStream stream,
WICBitmapEncoderCacheOption  option 
)
static

Definition at line 2174 of file gifformat.c.

2175{
2177 HRESULT hr;
2178
2179 TRACE("%p,%p,%#x\n", iface, stream, option);
2180
2181 if (!stream) return E_INVALIDARG;
2182
2183 EnterCriticalSection(&This->lock);
2184
2185 if (!This->initialized)
2186 {
2187 IStream_AddRef(stream);
2188 This->stream = stream;
2189 This->initialized = TRUE;
2190 hr = S_OK;
2191 }
2192 else
2194
2195 LeaveCriticalSection(&This->lock);
2196
2197 return hr;
2198}
Definition: getopt.h:109

◆ GifEncoder_QueryInterface()

static HRESULT WINAPI GifEncoder_QueryInterface ( IWICBitmapEncoder iface,
REFIID  iid,
void **  ppv 
)
static

Definition at line 2129 of file gifformat.c.

2130{
2131 TRACE("%p,%s,%p\n", iface, debugstr_guid(iid), ppv);
2132
2133 if (!ppv) return E_INVALIDARG;
2134
2135 if (IsEqualIID(&IID_IUnknown, iid) ||
2136 IsEqualIID(&IID_IWICBitmapEncoder, iid))
2137 {
2138 IWICBitmapEncoder_AddRef(iface);
2139 *ppv = iface;
2140 return S_OK;
2141 }
2142
2143 *ppv = NULL;
2144 return E_NOINTERFACE;
2145}

◆ GifEncoder_Release()

static ULONG WINAPI GifEncoder_Release ( IWICBitmapEncoder iface)
static

Definition at line 2156 of file gifformat.c.

2157{
2160
2161 TRACE("%p -> %lu\n", iface, ref);
2162
2163 if (!ref)
2164 {
2165 if (This->stream) IStream_Release(This->stream);
2166 This->lock.DebugInfo->Spare[0] = 0;
2168 free(This);
2169 }
2170
2171 return ref;
2172}

◆ GifEncoder_SetColorContexts()

static HRESULT WINAPI GifEncoder_SetColorContexts ( IWICBitmapEncoder iface,
UINT  count,
IWICColorContext **  context 
)
static

Definition at line 2226 of file gifformat.c.

2227{
2228 FIXME("%p,%u,%p: stub\n", iface, count, context);
2229 return E_NOTIMPL;
2230}
Definition: http.c:7252

◆ GifEncoder_SetPalette()

static HRESULT WINAPI GifEncoder_SetPalette ( IWICBitmapEncoder iface,
IWICPalette palette 
)
static

Definition at line 2232 of file gifformat.c.

2233{
2235 HRESULT hr;
2236
2237 TRACE("%p,%p\n", iface, palette);
2238
2239 if (!palette) return E_INVALIDARG;
2240
2241 EnterCriticalSection(&This->lock);
2242
2243 if (This->initialized)
2244 hr = IWICPalette_GetColors(palette, 256, This->palette, &This->colors);
2245 else
2247
2248 LeaveCriticalSection(&This->lock);
2249 return hr;
2250}
#define WINCODEC_ERR_NOTINITIALIZED
Definition: winerror.h:3285

◆ GifEncoder_SetPreview()

static HRESULT WINAPI GifEncoder_SetPreview ( IWICBitmapEncoder iface,
IWICBitmapSource preview 
)
static

Definition at line 2258 of file gifformat.c.

2259{
2260 TRACE("%p,%p\n", iface, preview);
2262}
static previewinfo preview
Definition: print.c:56

◆ GifEncoder_SetThumbnail()

static HRESULT WINAPI GifEncoder_SetThumbnail ( IWICBitmapEncoder iface,
IWICBitmapSource thumbnail 
)
static

Definition at line 2252 of file gifformat.c.

2253{
2254 TRACE("%p,%p\n", iface, thumbnail);
2256}

◆ GifEncoderFrame_Block_AddRef()

static ULONG WINAPI GifEncoderFrame_Block_AddRef ( IWICMetadataBlockWriter iface)
static

Definition at line 2271 of file gifformat.c.

2272{
2273 GifFrameEncode *frame_encoder = impl_from_IWICMetadataBlockWriter(iface);
2274
2275 return IWICBitmapFrameEncode_AddRef(&frame_encoder->IWICBitmapFrameEncode_iface);
2276}
static GifFrameEncode * impl_from_IWICMetadataBlockWriter(IWICMetadataBlockWriter *iface)
Definition: gifformat.c:1470
IWICBitmapFrameEncode IWICBitmapFrameEncode_iface
Definition: gifformat.c:1453

◆ GifEncoderFrame_Block_AddWriter()

static HRESULT WINAPI GifEncoderFrame_Block_AddWriter ( IWICMetadataBlockWriter iface,
IWICMetadataWriter metadata_writer 
)
static

Definition at line 2330 of file gifformat.c.

2331{
2332 FIXME("iface %p, metadata_writer %p stub.\n", iface, metadata_writer);
2333
2334 return E_NOTIMPL;
2335}

◆ GifEncoderFrame_Block_GetContainerFormat()

static HRESULT WINAPI GifEncoderFrame_Block_GetContainerFormat ( IWICMetadataBlockWriter iface,
GUID container_format 
)
static

Definition at line 2285 of file gifformat.c.

2286{
2287 FIXME("iface %p, container_format %p stub.\n", iface, container_format);
2288
2289 return E_NOTIMPL;
2290}

◆ GifEncoderFrame_Block_GetCount()

static HRESULT WINAPI GifEncoderFrame_Block_GetCount ( IWICMetadataBlockWriter iface,
UINT count 
)
static

Definition at line 2292 of file gifformat.c.

2293{
2294 FIXME("iface %p, count %p stub.\n", iface, count);
2295
2296 return E_NOTIMPL;
2297}

◆ GifEncoderFrame_Block_GetEnumerator()

static HRESULT WINAPI GifEncoderFrame_Block_GetEnumerator ( IWICMetadataBlockWriter iface,
IEnumUnknown **  enum_metadata 
)
static

Definition at line 2307 of file gifformat.c.

2308{
2309 FIXME("iface %p, enum_metadata %p stub.\n", iface, enum_metadata);
2310
2311 return E_NOTIMPL;
2312}

◆ GifEncoderFrame_Block_GetReaderByIndex()

static HRESULT WINAPI GifEncoderFrame_Block_GetReaderByIndex ( IWICMetadataBlockWriter iface,
UINT  index,
IWICMetadataReader **  metadata_reader 
)
static

Definition at line 2299 of file gifformat.c.

2301{
2302 FIXME("iface %p, index %d, metadata_reader %p stub.\n", iface, index, metadata_reader);
2303
2304 return E_NOTIMPL;
2305}

◆ GifEncoderFrame_Block_GetWriterByIndex()

static HRESULT WINAPI GifEncoderFrame_Block_GetWriterByIndex ( IWICMetadataBlockWriter iface,
UINT  index,
IWICMetadataWriter **  metadata_writer 
)
static

Definition at line 2322 of file gifformat.c.

2324{
2325 FIXME("iface %p, index %u, metadata_writer %p stub.\n", iface, index, metadata_writer);
2326
2327 return E_NOTIMPL;
2328}

◆ GifEncoderFrame_Block_InitializeFromBlockReader()

static HRESULT WINAPI GifEncoderFrame_Block_InitializeFromBlockReader ( IWICMetadataBlockWriter iface,
IWICMetadataBlockReader block_reader 
)
static

Definition at line 2314 of file gifformat.c.

2316{
2317 FIXME("iface %p, block_reader %p stub.\n", iface, block_reader);
2318
2319 return E_NOTIMPL;
2320}

◆ GifEncoderFrame_Block_QueryInterface()

static HRESULT WINAPI GifEncoderFrame_Block_QueryInterface ( IWICMetadataBlockWriter iface,
REFIID  iid,
void **  ppv 
)
static

Definition at line 2264 of file gifformat.c.

2265{
2266 GifFrameEncode *frame_encoder = impl_from_IWICMetadataBlockWriter(iface);
2267
2268 return IWICBitmapFrameEncode_QueryInterface(&frame_encoder->IWICBitmapFrameEncode_iface, iid, ppv);
2269}

◆ GifEncoderFrame_Block_Release()

static ULONG WINAPI GifEncoderFrame_Block_Release ( IWICMetadataBlockWriter iface)
static

Definition at line 2278 of file gifformat.c.

2279{
2280 GifFrameEncode *frame_encoder = impl_from_IWICMetadataBlockWriter(iface);
2281
2282 return IWICBitmapFrameEncode_Release(&frame_encoder->IWICBitmapFrameEncode_iface);
2283}

◆ GifEncoderFrame_Block_RemoveWriterByIndex()

static HRESULT WINAPI GifEncoderFrame_Block_RemoveWriterByIndex ( IWICMetadataBlockWriter iface,
UINT  index 
)
static

Definition at line 2345 of file gifformat.c.

2346{
2347 FIXME("iface %p, index %u stub.\n", iface, index);
2348
2349 return E_NOTIMPL;
2350}

◆ GifEncoderFrame_Block_SetWriterByIndex()

static HRESULT WINAPI GifEncoderFrame_Block_SetWriterByIndex ( IWICMetadataBlockWriter iface,
UINT  index,
IWICMetadataWriter metadata_writer 
)
static

Definition at line 2337 of file gifformat.c.

2339{
2340 FIXME("iface %p, index %u, metadata_writer %p stub.\n", iface, index, metadata_writer);
2341
2342 return E_NOTIMPL;
2343}

◆ GifFrameDecode_AddRef()

static ULONG WINAPI GifFrameDecode_AddRef ( IWICBitmapFrameDecode iface)
static

Definition at line 638 of file gifformat.c.

639{
642
643 TRACE("(%p) refcount=%lu\n", iface, ref);
644
645 return ref;
646}
static GifFrameDecode * impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode *iface)
Definition: gifformat.c:600

◆ GifFrameDecode_Block_AddRef()

static ULONG WINAPI GifFrameDecode_Block_AddRef ( IWICMetadataBlockReader iface)
static

Definition at line 881 of file gifformat.c.

882{
884 return IWICBitmapFrameDecode_AddRef(&This->IWICBitmapFrameDecode_iface);
885}
static GifFrameDecode * frame_from_IWICMetadataBlockReader(IWICMetadataBlockReader *iface)
Definition: gifformat.c:605

◆ GifFrameDecode_Block_GetContainerFormat()

static HRESULT WINAPI GifFrameDecode_Block_GetContainerFormat ( IWICMetadataBlockReader iface,
GUID guid 
)
static

Definition at line 893 of file gifformat.c.

895{
896 TRACE("(%p,%p)\n", iface, guid);
897
898 if (!guid) return E_INVALIDARG;
899
900 *guid = GUID_ContainerFormatGif;
901 return S_OK;
902}

◆ GifFrameDecode_Block_GetCount()

static HRESULT WINAPI GifFrameDecode_Block_GetCount ( IWICMetadataBlockReader iface,
UINT count 
)
static

Definition at line 904 of file gifformat.c.

906{
908
909 TRACE("%p,%p\n", iface, count);
910
911 if (!count) return E_INVALIDARG;
912
913 *count = This->frame->Extensions.ExtensionBlockCount + 1;
914 return S_OK;
915}

◆ GifFrameDecode_Block_GetEnumerator()

static HRESULT WINAPI GifFrameDecode_Block_GetEnumerator ( IWICMetadataBlockReader iface,
IEnumUnknown **  enumerator 
)
static

Definition at line 1007 of file gifformat.c.

1009{
1010 FIXME("(%p,%p): stub\n", iface, enumerator);
1011 return E_NOTIMPL;
1012}

◆ GifFrameDecode_Block_GetReaderByIndex()

static HRESULT WINAPI GifFrameDecode_Block_GetReaderByIndex ( IWICMetadataBlockReader iface,
UINT  index,
IWICMetadataReader **  reader 
)
static

Definition at line 965 of file gifformat.c.

967{
969 class_constructor constructor;
971 const void *data;
972 int data_size;
973
974 TRACE("(%p,%u,%p)\n", iface, index, reader);
975
976 if (!reader) return E_INVALIDARG;
977
978 if (index == 0)
980
981 if (index >= This->frame->Extensions.ExtensionBlockCount + 1)
982 return E_INVALIDARG;
983
984 ext = This->frame->Extensions.ExtensionBlocks + index - 1;
985 if (ext->Function == GRAPHICS_EXT_FUNC_CODE)
986 {
987 constructor = GCEReader_CreateInstance;
988 data = ext->Bytes + 3;
989 data_size = ext->ByteCount - 4;
990 }
991 else if (ext->Function == COMMENT_EXT_FUNC_CODE)
992 {
994 data = ext->Bytes;
995 data_size = ext->ByteCount;
996 }
997 else
998 {
1000 data = ext->Bytes;
1001 data_size = ext->ByteCount;
1002 }
1003
1004 return create_metadata_reader(data, data_size, constructor, reader);
1005}
static const WCHAR *const ext[]
Definition: module.c:53
HRESULT GCEReader_CreateInstance(REFIID iid, void **ppv)
Definition: gifformat.c:315
static HRESULT create_IMD_metadata_reader(GifFrameDecode *This, IWICMetadataReader **reader)
Definition: gifformat.c:917

◆ GifFrameDecode_Block_QueryInterface()

static HRESULT WINAPI GifFrameDecode_Block_QueryInterface ( IWICMetadataBlockReader iface,
REFIID  iid,
void **  ppv 
)
static

Definition at line 874 of file gifformat.c.

876{
878 return IWICBitmapFrameDecode_QueryInterface(&This->IWICBitmapFrameDecode_iface, iid, ppv);
879}

◆ GifFrameDecode_Block_Release()

static ULONG WINAPI GifFrameDecode_Block_Release ( IWICMetadataBlockReader iface)
static

Definition at line 887 of file gifformat.c.

888{
890 return IWICBitmapFrameDecode_Release(&This->IWICBitmapFrameDecode_iface);
891}

◆ GifFrameDecode_CopyPalette()

static HRESULT WINAPI GifFrameDecode_CopyPalette ( IWICBitmapFrameDecode iface,
IWICPalette pIPalette 
)
static

Definition at line 734 of file gifformat.c.

736{
738 WICColor colors[256];
739 ColorMapObject *cm = This->frame->ImageDesc.ColorMap;
740 int count;
741
742 TRACE("(%p,%p)\n", iface, pIPalette);
743
744 if (cm)
745 count = cm->ColorCount;
746 else
747 {
748 cm = This->parent->gif->SColorMap;
749 count = This->parent->gif->SColorTableSize;
750 }
751
752 if (count > 256)
753 {
754 ERR("GIF contains %i colors???\n", count);
755 return E_FAIL;
756 }
757
758 copy_palette(cm, &This->frame->Extensions, count, colors);
759
760 return IWICPalette_InitializeCustom(pIPalette, colors, count);
761}
int ColorCount
Definition: ungif.h:89

◆ GifFrameDecode_CopyPixels()

static HRESULT WINAPI GifFrameDecode_CopyPixels ( IWICBitmapFrameDecode iface,
const WICRect prc,
UINT  cbStride,
UINT  cbBufferSize,
BYTE pbBuffer 
)
static

Definition at line 813 of file gifformat.c.

815{
817 TRACE("(%p,%s,%u,%u,%p)\n", iface, debug_wic_rect(prc), cbStride, cbBufferSize, pbBuffer);
818
819 if (This->frame->ImageDesc.Interlace)
820 {
821 return copy_interlaced_pixels(This->frame->RasterBits, This->frame->ImageDesc.Width,
822 This->frame->ImageDesc.Height, This->frame->ImageDesc.Width,
823 prc, cbStride, cbBufferSize, pbBuffer);
824 }
825 else
826 {
827 return copy_pixels(8, This->frame->RasterBits, This->frame->ImageDesc.Width,
828 This->frame->ImageDesc.Height, This->frame->ImageDesc.Width,
829 prc, cbStride, cbBufferSize, pbBuffer);
830 }
831}
void copy_pixels(const BYTE *src, UINT src_row_pitch, UINT src_slice_pitch, BYTE *dst, UINT dst_row_pitch, UINT dst_slice_pitch, const struct volume *size, const struct pixel_format_desc *format) DECLSPEC_HIDDEN
Definition: surface.c:1700
static HRESULT copy_interlaced_pixels(const BYTE *srcbuffer, UINT srcwidth, UINT srcheight, INT srcstride, const WICRect *rc, UINT dststride, UINT dstbuffersize, BYTE *dstbuffer)
Definition: gifformat.c:763
_Out_ LPRECT prc
Definition: ntgdi.h:1658
static const char * debug_wic_rect(const WICRect *rect)

◆ GifFrameDecode_GetColorContexts()

static HRESULT WINAPI GifFrameDecode_GetColorContexts ( IWICBitmapFrameDecode iface,
UINT  cCount,
IWICColorContext **  ppIColorContexts,
UINT pcActualCount 
)
static

Definition at line 846 of file gifformat.c.

848{
849 TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
851}

◆ GifFrameDecode_GetMetadataQueryReader()

static HRESULT WINAPI GifFrameDecode_GetMetadataQueryReader ( IWICBitmapFrameDecode iface,
IWICMetadataQueryReader **  ppIMetadataQueryReader 
)
static

Definition at line 833 of file gifformat.c.

835{
837
838 TRACE("(%p,%p)\n", iface, ppIMetadataQueryReader);
839
840 if (!ppIMetadataQueryReader)
841 return E_INVALIDARG;
842
843 return MetadataQueryReader_CreateInstance(&This->IWICMetadataBlockReader_iface, NULL, ppIMetadataQueryReader);
844}

◆ GifFrameDecode_GetPixelFormat()

static HRESULT WINAPI GifFrameDecode_GetPixelFormat ( IWICBitmapFrameDecode iface,
WICPixelFormatGUID pPixelFormat 
)
static

Definition at line 676 of file gifformat.c.

678{
679 memcpy(pPixelFormat, &GUID_WICPixelFormat8bppIndexed, sizeof(GUID));
680
681 return S_OK;
682}

◆ GifFrameDecode_GetResolution()

static HRESULT WINAPI GifFrameDecode_GetResolution ( IWICBitmapFrameDecode iface,
double pDpiX,
double pDpiY 
)
static

Definition at line 684 of file gifformat.c.

686{
688 const GifWord aspect_word = This->parent->gif->SAspectRatio;
689 const double aspect = (aspect_word > 0) ? ((aspect_word + 15.0) / 64.0) : 1.0;
690 TRACE("(%p,%p,%p)\n", iface, pDpiX, pDpiY);
691
692 *pDpiX = 96.0 / aspect;
693 *pDpiY = 96.0;
694
695 return S_OK;
696}
int GifWord
Definition: ungif.h:82

◆ GifFrameDecode_GetSize()

static HRESULT WINAPI GifFrameDecode_GetSize ( IWICBitmapFrameDecode iface,
UINT puiWidth,
UINT puiHeight 
)
static

Definition at line 664 of file gifformat.c.

666{
668 TRACE("(%p,%p,%p)\n", iface, puiWidth, puiHeight);
669
670 *puiWidth = This->frame->ImageDesc.Width;
671 *puiHeight = This->frame->ImageDesc.Height;
672
673 return S_OK;
674}

◆ GifFrameDecode_GetThumbnail()

static HRESULT WINAPI GifFrameDecode_GetThumbnail ( IWICBitmapFrameDecode iface,
IWICBitmapSource **  ppIThumbnail 
)
static

Definition at line 853 of file gifformat.c.

855{
856 TRACE("(%p,%p)\n", iface, ppIThumbnail);
858}

◆ GifFrameDecode_QueryInterface()

static HRESULT WINAPI GifFrameDecode_QueryInterface ( IWICBitmapFrameDecode iface,
REFIID  iid,
void **  ppv 
)
static

Definition at line 610 of file gifformat.c.

612{
614 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
615
616 if (!ppv) return E_INVALIDARG;
617
618 if (IsEqualIID(&IID_IUnknown, iid) ||
619 IsEqualIID(&IID_IWICBitmapSource, iid) ||
620 IsEqualIID(&IID_IWICBitmapFrameDecode, iid))
621 {
622 *ppv = &This->IWICBitmapFrameDecode_iface;
623 }
624 else if (IsEqualIID(&IID_IWICMetadataBlockReader, iid))
625 {
626 *ppv = &This->IWICMetadataBlockReader_iface;
627 }
628 else
629 {
630 *ppv = NULL;
631 return E_NOINTERFACE;
632 }
633
634 IUnknown_AddRef((IUnknown*)*ppv);
635 return S_OK;
636}

◆ GifFrameDecode_Release()

static ULONG WINAPI GifFrameDecode_Release ( IWICBitmapFrameDecode iface)
static

Definition at line 648 of file gifformat.c.

649{
652
653 TRACE("(%p) refcount=%lu\n", iface, ref);
654
655 if (ref == 0)
656 {
657 IWICBitmapDecoder_Release(&This->parent->IWICBitmapDecoder_iface);
658 free(This);
659 }
660
661 return ref;
662}

◆ GifFrameEncode_AddRef()

static ULONG WINAPI GifFrameEncode_AddRef ( IWICBitmapFrameEncode iface)
static

Definition at line 1502 of file gifformat.c.

1503{
1506
1507 TRACE("%p -> %lu\n", iface, ref);
1508 return ref;
1509}
static GifFrameEncode * impl_from_IWICBitmapFrameEncode(IWICBitmapFrameEncode *iface)
Definition: gifformat.c:1465

◆ GifFrameEncode_Commit()

static HRESULT WINAPI GifFrameEncode_Commit ( IWICBitmapFrameEncode iface)
static

Definition at line 1991 of file gifformat.c.

1992{
1994 HRESULT hr;
1995
1996 TRACE("%p\n", iface);
1997
1998 EnterCriticalSection(&This->encoder->lock);
1999
2000 if (This->image_data && This->lines == This->height && !This->committed)
2001 {
2002 BYTE gif_palette[256][3];
2003
2004 hr = S_OK;
2005
2006 if (!This->encoder->info_written)
2007 {
2008 struct logical_screen_descriptor lsd;
2009
2010 /* Logical Screen Descriptor */
2011 memcpy(lsd.signature, "GIF89a", 6);
2012 lsd.width = This->width;
2013 lsd.height = This->height;
2014 lsd.packed = 0;
2015 if (This->encoder->colors)
2016 lsd.packed |= 0x80; /* global color table flag */
2017 lsd.packed |= 0x07 << 4; /* color resolution */
2018 lsd.packed |= 0x07; /* global color table size */
2019 lsd.background_color_index = 0; /* FIXME */
2020 lsd.pixel_aspect_ratio = 0;
2021 hr = IStream_Write(This->encoder->stream, &lsd, sizeof(lsd), NULL);
2022 if (hr == S_OK && This->encoder->colors)
2023 {
2024 UINT i;
2025
2026 /* Global Color Table */
2027 memset(gif_palette, 0, sizeof(gif_palette));
2028 for (i = 0; i < This->encoder->colors; i++)
2029 {
2030 gif_palette[i][0] = (This->encoder->palette[i] >> 16) & 0xff;
2031 gif_palette[i][1] = (This->encoder->palette[i] >> 8) & 0xff;
2032 gif_palette[i][2] = This->encoder->palette[i] & 0xff;
2033 }
2034 hr = IStream_Write(This->encoder->stream, gif_palette, sizeof(gif_palette), NULL);
2035 }
2036
2037 /* FIXME: write GCE, APE, etc. GIF extensions */
2038
2039 if (hr == S_OK)
2040 This->encoder->info_written = TRUE;
2041 }
2042
2043 if (hr == S_OK)
2044 {
2045 char image_separator = 0x2c;
2046
2047 hr = IStream_Write(This->encoder->stream, &image_separator, sizeof(image_separator), NULL);
2048 if (hr == S_OK)
2049 {
2050 struct image_descriptor imd;
2051
2052 /* Image Descriptor */
2053 imd.left = 0;
2054 imd.top = 0;
2055 imd.width = This->width;
2056 imd.height = This->height;
2057 imd.packed = 0;
2058 if (This->colors)
2059 {
2060 imd.packed |= 0x80; /* local color table flag */
2061 imd.packed |= 0x07; /* local color table size */
2062 }
2063 /* FIXME: interlace flag */
2064 hr = IStream_Write(This->encoder->stream, &imd, sizeof(imd), NULL);
2065 if (hr == S_OK && This->colors)
2066 {
2067 UINT i;
2068
2069 /* Local Color Table */
2070 memset(gif_palette, 0, sizeof(gif_palette));
2071 for (i = 0; i < This->colors; i++)
2072 {
2073 gif_palette[i][0] = (This->palette[i] >> 16) & 0xff;
2074 gif_palette[i][1] = (This->palette[i] >> 8) & 0xff;
2075 gif_palette[i][2] = This->palette[i] & 0xff;
2076 }
2077 hr = IStream_Write(This->encoder->stream, gif_palette, sizeof(gif_palette), NULL);
2078 if (hr == S_OK)
2079 {
2080 /* Image Data */
2081 hr = gif_compress(This->encoder->stream, This->image_data, This->width * This->height);
2082 if (hr == S_OK)
2083 This->committed = TRUE;
2084 }
2085 }
2086 }
2087 }
2088 }
2089 else
2091
2092 LeaveCriticalSection(&This->encoder->lock);
2093 return hr;
2094}
static HRESULT gif_compress(IStream *out_stream, const BYTE *in_data, ULONG in_size)
Definition: gifformat.c:1932
#define memset(x, y, z)
Definition: compat.h:39

◆ GifFrameEncode_GetMetadataQueryWriter()

static HRESULT WINAPI GifFrameEncode_GetMetadataQueryWriter ( IWICBitmapFrameEncode iface,
IWICMetadataQueryWriter **  writer 
)
static

Definition at line 2096 of file gifformat.c.

2097{
2099
2100 TRACE("iface, %p, writer %p.\n", iface, writer);
2101
2102 if (!writer)
2103 return E_INVALIDARG;
2104
2105 if (!encode->initialized)
2107
2109}
HRESULT MetadataQueryWriter_CreateInstance(IWICMetadataBlockWriter *mbw, const WCHAR *root, IWICMetadataQueryWriter **out)
IWICMetadataBlockWriter IWICMetadataBlockWriter_iface
Definition: gifformat.c:1454

◆ GifFrameEncode_Initialize()

static HRESULT WINAPI GifFrameEncode_Initialize ( IWICBitmapFrameEncode iface,
IPropertyBag2 options 
)
static

Definition at line 1528 of file gifformat.c.

1529{
1531 HRESULT hr;
1532
1533 TRACE("%p,%p\n", iface, options);
1534
1535 EnterCriticalSection(&This->encoder->lock);
1536
1537 if (!This->initialized)
1538 {
1539 This->initialized = TRUE;
1540 hr = S_OK;
1541 }
1542 else
1544
1545 LeaveCriticalSection(&This->encoder->lock);
1546
1547 return hr;
1548}

◆ GifFrameEncode_QueryInterface()

static HRESULT WINAPI GifFrameEncode_QueryInterface ( IWICBitmapFrameEncode iface,
REFIID  iid,
void **  ppv 
)
static

Definition at line 1475 of file gifformat.c.

1476{
1478
1479 TRACE("%p,%s,%p\n", iface, debugstr_guid(iid), ppv);
1480
1481 if (!ppv) return E_INVALIDARG;
1482
1483 if (IsEqualIID(&IID_IUnknown, iid) ||
1484 IsEqualIID(&IID_IWICBitmapFrameEncode, iid))
1485 {
1486 *ppv = iface;
1487 }
1488 else if (IsEqualIID(&IID_IWICMetadataBlockWriter, iid))
1489 {
1490 *ppv = &encoder->IWICMetadataBlockWriter_iface;
1491 }
1492 else
1493 {
1494 *ppv = NULL;
1495 return E_NOINTERFACE;
1496 }
1497
1498 IUnknown_AddRef((IUnknown *)*ppv);
1499 return S_OK;
1500}

◆ GifFrameEncode_Release()

static ULONG WINAPI GifFrameEncode_Release ( IWICBitmapFrameEncode iface)
static

Definition at line 1511 of file gifformat.c.

1512{
1515
1516 TRACE("%p -> %lu\n", iface, ref);
1517
1518 if (!ref)
1519 {
1520 IWICBitmapEncoder_Release(&This->encoder->IWICBitmapEncoder_iface);
1521 free(This->image_data);
1522 free(This);
1523 }
1524
1525 return ref;
1526}

◆ GifFrameEncode_SetColorContexts()

static HRESULT WINAPI GifFrameEncode_SetColorContexts ( IWICBitmapFrameEncode iface,
UINT  count,
IWICColorContext **  context 
)
static

Definition at line 1630 of file gifformat.c.

1631{
1632 FIXME("%p,%u,%p: stub\n", iface, count, context);
1633 return E_NOTIMPL;
1634}

◆ GifFrameEncode_SetPalette()

static HRESULT WINAPI GifFrameEncode_SetPalette ( IWICBitmapFrameEncode iface,
IWICPalette palette 
)
static

Definition at line 1636 of file gifformat.c.

1637{
1639 HRESULT hr;
1640
1641 TRACE("%p,%p\n", iface, palette);
1642
1643 if (!palette) return E_INVALIDARG;
1644
1645 EnterCriticalSection(&This->encoder->lock);
1646
1647 if (This->initialized)
1648 hr = IWICPalette_GetColors(palette, 256, This->palette, &This->colors);
1649 else
1651
1652 LeaveCriticalSection(&This->encoder->lock);
1653 return hr;
1654}

◆ GifFrameEncode_SetPixelFormat()

static HRESULT WINAPI GifFrameEncode_SetPixelFormat ( IWICBitmapFrameEncode iface,
WICPixelFormatGUID format 
)
static

Definition at line 1606 of file gifformat.c.

1607{
1609 HRESULT hr;
1610
1611 TRACE("%p,%s\n", iface, debugstr_guid(format));
1612
1613 if (!format) return E_INVALIDARG;
1614
1615 EnterCriticalSection(&This->encoder->lock);
1616
1617 if (This->initialized)
1618 {
1619 *format = GUID_WICPixelFormat8bppIndexed;
1620 hr = S_OK;
1621 }
1622 else
1624
1625 LeaveCriticalSection(&This->encoder->lock);
1626
1627 return hr;
1628}

◆ GifFrameEncode_SetResolution()

static HRESULT WINAPI GifFrameEncode_SetResolution ( IWICBitmapFrameEncode iface,
double  xres,
double  yres 
)
static

Definition at line 1583 of file gifformat.c.

1584{
1586 HRESULT hr;
1587
1588 TRACE("%p,%f,%f\n", iface, xres, yres);
1589
1590 EnterCriticalSection(&This->encoder->lock);
1591
1592 if (This->initialized)
1593 {
1594 This->xres = xres;
1595 This->yres = yres;
1596 hr = S_OK;
1597 }
1598 else
1600
1601 LeaveCriticalSection(&This->encoder->lock);
1602
1603 return hr;
1604}

◆ GifFrameEncode_SetSize()

static HRESULT WINAPI GifFrameEncode_SetSize ( IWICBitmapFrameEncode iface,
UINT  width,
UINT  height 
)
static

Definition at line 1550 of file gifformat.c.

1551{
1553 HRESULT hr;
1554
1555 TRACE("%p,%u,%u\n", iface, width, height);
1556
1557 if (!width || !height) return E_INVALIDARG;
1558
1559 EnterCriticalSection(&This->encoder->lock);
1560
1561 if (This->initialized)
1562 {
1563 free(This->image_data);
1564
1565 This->image_data = malloc(width * height);
1566 if (This->image_data)
1567 {
1568 This->width = width;
1569 This->height = height;
1570 hr = S_OK;
1571 }
1572 else
1573 hr = E_OUTOFMEMORY;
1574 }
1575 else
1577
1578 LeaveCriticalSection(&This->encoder->lock);
1579
1580 return hr;
1581}
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
GLint GLint GLsizei width
Definition: gl.h:1546

◆ GifFrameEncode_SetThumbnail()

static HRESULT WINAPI GifFrameEncode_SetThumbnail ( IWICBitmapFrameEncode iface,
IWICBitmapSource thumbnail 
)
static

Definition at line 1656 of file gifformat.c.

1657{
1658 FIXME("%p,%p: stub\n", iface, thumbnail);
1659 return E_NOTIMPL;
1660}

◆ GifFrameEncode_WritePixels()

static HRESULT WINAPI GifFrameEncode_WritePixels ( IWICBitmapFrameEncode iface,
UINT  lines,
UINT  stride,
UINT  size,
BYTE pixels 
)
static

Definition at line 1662 of file gifformat.c.

1663{
1665 HRESULT hr;
1666
1667 TRACE("%p,%u,%u,%u,%p\n", iface, lines, stride, size, pixels);
1668
1669 if (!pixels) return E_INVALIDARG;
1670
1671 EnterCriticalSection(&This->encoder->lock);
1672
1673 if (This->initialized && This->image_data)
1674 {
1675 if (This->lines + lines <= This->height)
1676 {
1677 UINT i;
1678 BYTE *src, *dst;
1679
1680 src = pixels;
1681 dst = This->image_data + This->lines * This->width;
1682
1683 for (i = 0; i < lines; i++)
1684 {
1685 memcpy(dst, src, This->width);
1686 src += stride;
1687 dst += This->width;
1688 }
1689
1690 This->lines += lines;
1691 hr = S_OK;
1692 }
1693 else
1694 hr = E_INVALIDARG;
1695 }
1696 else
1698
1699 LeaveCriticalSection(&This->encoder->lock);
1700 return hr;
1701}
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: gl.h:1546
GLsizei stride
Definition: glext.h:5848
GLsizeiptr size
Definition: glext.h:5919
eMaj lines
Definition: tritemp.h:206

◆ GifFrameEncode_WriteSource()

static HRESULT WINAPI GifFrameEncode_WriteSource ( IWICBitmapFrameEncode iface,
IWICBitmapSource source,
WICRect rc 
)
static

Definition at line 1703 of file gifformat.c.

1704{
1706 HRESULT hr;
1707
1708 TRACE("%p,%p,%p\n", iface, source, rc);
1709
1710 if (!source) return E_INVALIDARG;
1711
1712 EnterCriticalSection(&This->encoder->lock);
1713
1714 if (This->initialized)
1715 {
1716 const GUID *format = &GUID_WICPixelFormat8bppIndexed;
1717
1718 hr = configure_write_source(iface, source, rc, format,
1719 This->width, This->height, This->xres, This->yres);
1720 if (hr == S_OK)
1721 hr = write_source(iface, source, rc, format, 8, !This->colors, This->width, This->height);
1722 }
1723 else
1725
1726 LeaveCriticalSection(&This->encoder->lock);
1727 return hr;
1728}
HRESULT write_source(IWICBitmapFrameEncode *iface, IWICBitmapSource *source, const WICRect *prc, const WICPixelFormatGUID *format, UINT bpp, BOOL need_palette, INT width, INT height)
HRESULT configure_write_source(IWICBitmapFrameEncode *iface, IWICBitmapSource *source, const WICRect *prc, const WICPixelFormatGUID *format, INT width, INT height, double xres, double yres)

◆ IMDReader_CreateInstance()

HRESULT IMDReader_CreateInstance ( REFIID  iid,
void **  ppv 
)

Definition at line 237 of file gifformat.c.

238{
240}
static const MetadataHandlerVtbl IMDReader_Vtbl
Definition: gifformat.c:231

Referenced by create_IMD_metadata_reader().

◆ impl_from_IWICBitmapDecoder()

static GifDecoder * impl_from_IWICBitmapDecoder ( IWICBitmapDecoder iface)
inlinestatic

◆ impl_from_IWICBitmapEncoder()

static GifEncoder * impl_from_IWICBitmapEncoder ( IWICBitmapEncoder iface)
inlinestatic

Definition at line 1446 of file gifformat.c.

1447{
1448 return CONTAINING_RECORD(iface, GifEncoder, IWICBitmapEncoder_iface);
1449}

Referenced by GifEncoder_AddRef(), GifEncoder_Commit(), GifEncoder_CreateNewFrame(), GifEncoder_Initialize(), GifEncoder_Release(), and GifEncoder_SetPalette().

◆ impl_from_IWICBitmapFrameDecode()

◆ impl_from_IWICBitmapFrameEncode()

◆ impl_from_IWICMetadataBlockReader()

static GifDecoder * impl_from_IWICMetadataBlockReader ( IWICMetadataBlockReader iface)
inlinestatic

◆ impl_from_IWICMetadataBlockWriter()

static GifFrameEncode * impl_from_IWICMetadataBlockWriter ( IWICMetadataBlockWriter iface)
inlinestatic

Definition at line 1470 of file gifformat.c.

1471{
1472 return CONTAINING_RECORD(iface, GifFrameEncode, IWICMetadataBlockWriter_iface);
1473}

Referenced by GifEncoderFrame_Block_AddRef(), GifEncoderFrame_Block_QueryInterface(), and GifEncoderFrame_Block_Release().

◆ load_APE_metadata()

static HRESULT load_APE_metadata ( IStream stream,
const GUID vendor,
DWORD  options,
MetadataItem **  items,
DWORD count 
)
static

Definition at line 320 of file gifformat.c.

322{
323#include "pshpack1.h"
324 struct application_extension
325 {
326 BYTE extension_introducer;
327 BYTE extension_label;
329 BYTE application[11];
330 } ape_data;
331#include "poppack.h"
332 HRESULT hr;
333 ULONG bytesread, data_size, i;
335 BYTE subblock_size;
336 BYTE *data;
337
338 *items = NULL;
339 *count = 0;
340
341 hr = IStream_Read(stream, &ape_data, sizeof(ape_data), &bytesread);
342 if (FAILED(hr) || bytesread != sizeof(ape_data)) return S_OK;
343 if (ape_data.extension_introducer != 0x21 ||
344 ape_data.extension_label != APPLICATION_EXT_FUNC_CODE ||
345 ape_data.block_size != 11)
346 return S_OK;
347
348 data = NULL;
349 data_size = 0;
350
351 for (;;)
352 {
353 hr = IStream_Read(stream, &subblock_size, sizeof(subblock_size), &bytesread);
354 if (FAILED(hr) || bytesread != sizeof(subblock_size))
355 {
357 return S_OK;
358 }
359 if (!subblock_size) break;
360
361 if (!data)
362 data = CoTaskMemAlloc(subblock_size + 1);
363 else
364 {
365 BYTE *new_data = CoTaskMemRealloc(data, data_size + subblock_size + 1);
366 if (!new_data)
367 {
369 return S_OK;
370 }
371 data = new_data;
372 }
373 data[data_size] = subblock_size;
374 hr = IStream_Read(stream, data + data_size + 1, subblock_size, &bytesread);
375 if (FAILED(hr) || bytesread != subblock_size)
376 {
378 return S_OK;
379 }
380 data_size += subblock_size + 1;
381 }
382
383 result = calloc(2, sizeof(MetadataItem));
384 if (!result)
385 {
387 return E_OUTOFMEMORY;
388 }
389
390 for (i = 0; i < 2; i++)
391 {
392 PropVariantInit(&result[i].schema);
393 PropVariantInit(&result[i].id);
394 PropVariantInit(&result[i].value);
395 }
396
397 result[0].id.vt = VT_LPWSTR;
398 SHStrDupW(L"Application", &result[0].id.pwszVal);
399 result[0].value.vt = VT_UI1|VT_VECTOR;
400 result[0].value.caub.cElems = sizeof(ape_data.application);
401 result[0].value.caub.pElems = CoTaskMemAlloc(sizeof(ape_data.application));
402 memcpy(result[0].value.caub.pElems, ape_data.application, sizeof(ape_data.application));
403
404 result[1].id.vt = VT_LPWSTR;
405 SHStrDupW(L"Data", &result[1].id.pwszVal);
406 result[1].value.vt = VT_UI1|VT_VECTOR;
407 result[1].value.caub.cElems = data_size;
408 result[1].value.caub.pElems = data;
409
410 *items = result;
411 *count = 2;
412
413 return S_OK;
414}
@ VT_LPWSTR
Definition: compat.h:2325
@ VT_VECTOR
Definition: compat.h:2340
@ VT_UI1
Definition: compat.h:2311
HRESULT WINAPI SHStrDupW(LPCWSTR src, LPWSTR *dest)
Definition: string.c:2018
LPVOID WINAPI CoTaskMemRealloc(LPVOID pvOld, SIZE_T size)
Definition: ifs.c:460
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
Definition: ifs.c:426
static DWORD block_size(DWORD block)
Definition: jsutils.c:66
const WCHAR * schema
#define L(x)
Definition: ntvdm.h:50
static TCHAR * items[]
Definition: page1.c:45
#define calloc
Definition: rosglue.h:14
Definition: pdh_main.c:94

◆ load_GCE_metadata()

static HRESULT load_GCE_metadata ( IStream stream,
const GUID vendor,
DWORD  options,
MetadataItem **  items,
DWORD count 
)
static

Definition at line 242 of file gifformat.c.

244{
245#include "pshpack1.h"
246 struct graphic_control_extension
247 {
248 BYTE packed;
249 /* reservred: 3;
250 * disposal : 3;
251 * user_input_flag : 1;
252 * transparency_flag : 1;
253 */
254 USHORT delay;
255 BYTE transparent_color_index;
256 } gce_data;
257#include "poppack.h"
258 HRESULT hr;
259 ULONG bytesread, i;
261
262 *items = NULL;
263 *count = 0;
264
265 hr = IStream_Read(stream, &gce_data, sizeof(gce_data), &bytesread);
266 if (FAILED(hr) || bytesread != sizeof(gce_data)) return S_OK;
267
268 result = calloc(5, sizeof(MetadataItem));
269 if (!result) return E_OUTOFMEMORY;
270
271 for (i = 0; i < 5; i++)
272 {
273 PropVariantInit(&result[i].schema);
274 PropVariantInit(&result[i].id);
275 PropVariantInit(&result[i].value);
276 }
277
278 result[0].id.vt = VT_LPWSTR;
279 SHStrDupW(L"Disposal", &result[0].id.pwszVal);
280 result[0].value.vt = VT_UI1;
281 result[0].value.bVal = (gce_data.packed >> 2) & 7;
282
283 result[1].id.vt = VT_LPWSTR;
284 SHStrDupW(L"UserInputFlag", &result[1].id.pwszVal);
285 result[1].value.vt = VT_BOOL;
286 result[1].value.boolVal = (gce_data.packed >> 1) & 1;
287
288 result[2].id.vt = VT_LPWSTR;
289 SHStrDupW(L"TransparencyFlag", &result[2].id.pwszVal);
290 result[2].value.vt = VT_BOOL;
291 result[2].value.boolVal = gce_data.packed & 1;
292
293 result[3].id.vt = VT_LPWSTR;
294 SHStrDupW(L"Delay", &result[3].id.pwszVal);
295 result[3].value.vt = VT_UI2;
296 result[3].value.uiVal = gce_data.delay;
297
298 result[4].id.vt = VT_LPWSTR;
299 SHStrDupW(L"TransparentColorIndex", &result[4].id.pwszVal);
300 result[4].value.vt = VT_UI1;
301 result[4].value.bVal = gce_data.transparent_color_index;
302
303 *items = result;
304 *count = 5;
305
306 return S_OK;
307}
@ VT_UI2
Definition: compat.h:2312
@ VT_BOOL
Definition: compat.h:2306
GLuint GLenum GLsizei GLsizei GLint GLint GLboolean packed
Definition: glext.h:9271
unsigned short USHORT
Definition: pedump.c:61

◆ load_GifComment_metadata()

static HRESULT load_GifComment_metadata ( IStream stream,
const GUID vendor,
DWORD  options,
MetadataItem **  items,
DWORD count 
)
static

Definition at line 427 of file gifformat.c.

429{
430#include "pshpack1.h"
431 struct gif_extension
432 {
433 BYTE extension_introducer;
434 BYTE extension_label;
435 } ext_data;
436#include "poppack.h"
437 HRESULT hr;
438 ULONG bytesread, data_size;
440 BYTE subblock_size;
441 char *data;
442
443 *items = NULL;
444 *count = 0;
445
446 hr = IStream_Read(stream, &ext_data, sizeof(ext_data), &bytesread);
447 if (FAILED(hr) || bytesread != sizeof(ext_data)) return S_OK;
448 if (ext_data.extension_introducer != 0x21 ||
449 ext_data.extension_label != COMMENT_EXT_FUNC_CODE)
450 return S_OK;
451
452 data = NULL;
453 data_size = 0;
454
455 for (;;)
456 {
457 hr = IStream_Read(stream, &subblock_size, sizeof(subblock_size), &bytesread);
458 if (FAILED(hr) || bytesread != sizeof(subblock_size))
459 {
461 return S_OK;
462 }
463 if (!subblock_size) break;
464
465 if (!data)
466 data = CoTaskMemAlloc(subblock_size + 1);
467 else
468 {
469 char *new_data = CoTaskMemRealloc(data, data_size + subblock_size + 1);
470 if (!new_data)
471 {
473 return S_OK;
474 }
475 data = new_data;
476 }
477 hr = IStream_Read(stream, data + data_size, subblock_size, &bytesread);
478 if (FAILED(hr) || bytesread != subblock_size)
479 {
481 return S_OK;
482 }
483 data_size += subblock_size;
484 }
485
486 data[data_size] = 0;
487
488 result = calloc(1, sizeof(MetadataItem));
489 if (!result)
490 {
492 return E_OUTOFMEMORY;
493 }
494
495 PropVariantInit(&result->schema);
496 PropVariantInit(&result->id);
497 PropVariantInit(&result->value);
498
499 result->id.vt = VT_LPWSTR;
500 SHStrDupW(L"TextEntry", &result->id.pwszVal);
501 result->value.vt = VT_LPSTR;
502 result->value.pszVal = data;
503
504 *items = result;
505 *count = 1;
506
507 return S_OK;
508}
@ VT_LPSTR
Definition: compat.h:2324
static const WCHAR gif_extension[]
Definition: image.c:4787

◆ load_IMD_metadata()

static HRESULT load_IMD_metadata ( IStream stream,
const GUID vendor,
DWORD  options,
MetadataItem **  items,
DWORD count 
)
static

Definition at line 161 of file gifformat.c.

163{
164 struct image_descriptor imd_data;
165 HRESULT hr;
166 ULONG bytesread, i;
168
169 *items = NULL;
170 *count = 0;
171
172 hr = IStream_Read(stream, &imd_data, sizeof(imd_data), &bytesread);
173 if (FAILED(hr) || bytesread != sizeof(imd_data)) return S_OK;
174
175 result = calloc(8, sizeof(MetadataItem));
176 if (!result) return E_OUTOFMEMORY;
177
178 for (i = 0; i < 8; i++)
179 {
180 PropVariantInit(&result[i].schema);
181 PropVariantInit(&result[i].id);
182 PropVariantInit(&result[i].value);
183 }
184
185 result[0].id.vt = VT_LPWSTR;
186 SHStrDupW(L"Left", &result[0].id.pwszVal);
187 result[0].value.vt = VT_UI2;
188 result[0].value.uiVal = imd_data.left;
189
190 result[1].id.vt = VT_LPWSTR;
191 SHStrDupW(L"Top", &result[1].id.pwszVal);
192 result[1].value.vt = VT_UI2;
193 result[1].value.uiVal = imd_data.top;
194
195 result[2].id.vt = VT_LPWSTR;
196 SHStrDupW(L"Width", &result[2].id.pwszVal);
197 result[2].value.vt = VT_UI2;
198 result[2].value.uiVal = imd_data.width;
199
200 result[3].id.vt = VT_LPWSTR;
201 SHStrDupW(L"Height", &result[3].id.pwszVal);
202 result[3].value.vt = VT_UI2;
203 result[3].value.uiVal = imd_data.height;
204
205 result[4].id.vt = VT_LPWSTR;
206 SHStrDupW(L"LocalColorTableFlag", &result[4].id.pwszVal);
207 result[4].value.vt = VT_BOOL;
208 result[4].value.boolVal = (imd_data.packed >> 7) & 1;
209
210 result[5].id.vt = VT_LPWSTR;
211 SHStrDupW(L"InterlaceFlag", &result[5].id.pwszVal);
212 result[5].value.vt = VT_BOOL;
213 result[5].value.boolVal = (imd_data.packed >> 6) & 1;
214
215 result[6].id.vt = VT_LPWSTR;
216 SHStrDupW(L"SortFlag", &result[6].id.pwszVal);
217 result[6].value.vt = VT_BOOL;
218 result[6].value.boolVal = (imd_data.packed >> 5) & 1;
219
220 result[7].id.vt = VT_LPWSTR;
221 SHStrDupW(L"LocalColorTableSize", &result[7].id.pwszVal);
222 result[7].value.vt = VT_UI1;
223 result[7].value.bVal = imd_data.packed & 7;
224
225 *items = result;
226 *count = 8;
227
228 return S_OK;
229}

◆ load_LSD_metadata()

static HRESULT load_LSD_metadata ( IStream stream,
const GUID vendor,
DWORD  options,
MetadataItem **  items,
DWORD count 
)
static

Definition at line 73 of file gifformat.c.

75{
76 struct logical_screen_descriptor lsd_data;
77 HRESULT hr;
78 ULONG bytesread, i;
80
81 *items = NULL;
82 *count = 0;
83
84 hr = IStream_Read(stream, &lsd_data, sizeof(lsd_data), &bytesread);
85 if (FAILED(hr) || bytesread != sizeof(lsd_data)) return S_OK;
86
87 result = calloc(9, sizeof(MetadataItem));
88 if (!result) return E_OUTOFMEMORY;
89
90 for (i = 0; i < 9; i++)
91 {
92 PropVariantInit(&result[i].schema);
93 PropVariantInit(&result[i].id);
94 PropVariantInit(&result[i].value);
95 }
96
97 result[0].id.vt = VT_LPWSTR;
98 SHStrDupW(L"Signature", &result[0].id.pwszVal);
99 result[0].value.vt = VT_UI1|VT_VECTOR;
100 result[0].value.caub.cElems = sizeof(lsd_data.signature);
101 result[0].value.caub.pElems = CoTaskMemAlloc(sizeof(lsd_data.signature));
102 memcpy(result[0].value.caub.pElems, lsd_data.signature, sizeof(lsd_data.signature));
103
104 result[1].id.vt = VT_LPWSTR;
105 SHStrDupW(L"Width", &result[1].id.pwszVal);
106 result[1].value.vt = VT_UI2;
107 result[1].value.uiVal = lsd_data.width;
108
109 result[2].id.vt = VT_LPWSTR;
110 SHStrDupW(L"Height", &result[2].id.pwszVal);
111 result[2].value.vt = VT_UI2;
112 result[2].value.uiVal = lsd_data.height;
113
114 result[3].id.vt = VT_LPWSTR;
115 SHStrDupW(L"GlobalColorTableFlag", &result[3].id.pwszVal);
116 result[3].value.vt = VT_BOOL;
117 result[3].value.boolVal = (lsd_data.packed >> 7) & 1;
118
119 result[4].id.vt = VT_LPWSTR;
120 SHStrDupW(L"ColorResolution", &result[4].id.pwszVal);
121 result[4].value.vt = VT_UI1;
122 result[4].value.bVal = (lsd_data.packed >> 4) & 7;
123
124 result[5].id.vt = VT_LPWSTR;
125 SHStrDupW(L"SortFlag", &result[5].id.pwszVal);
126 result[5].value.vt = VT_BOOL;
127 result[5].value.boolVal = (lsd_data.packed >> 3) & 1;
128
129 result[6].id.vt = VT_LPWSTR;
130 SHStrDupW(L"GlobalColorTableSize", &result[6].id.pwszVal);
131 result[6].value.vt = VT_UI1;
132 result[6].value.bVal = lsd_data.packed & 7;
133
134 result[7].id.vt = VT_LPWSTR;
135 SHStrDupW(L"BackgroundColorIndex", &result[7].id.pwszVal);
136 result[7].value.vt = VT_UI1;
137 result[7].value.bVal = lsd_data.background_color_index;
138
139 result[8].id.vt = VT_LPWSTR;
140 SHStrDupW(L"PixelAspectRatio", &result[8].id.pwszVal);
141 result[8].value.vt = VT_UI1;
142 result[8].value.bVal = lsd_data.pixel_aspect_ratio;
143
144 *items = result;
145 *count = 9;
146
147 return S_OK;
148}

◆ LSDReader_CreateInstance()

HRESULT LSDReader_CreateInstance ( REFIID  iid,
void **  ppv 
)

Definition at line 156 of file gifformat.c.

157{
159}
static const MetadataHandlerVtbl LSDReader_Vtbl
Definition: gifformat.c:150

Referenced by GifDecoder_Block_GetReaderByIndex().

◆ lzw_dict_add()

static int lzw_dict_add ( struct lzw_state state,
short  prefix,
unsigned char  suffix 
)
static

Definition at line 1846 of file gifformat.c.

1847{
1848 if (state->next_code < LZW_DICT_SIZE)
1849 {
1850 state->dict.prefix[state->next_code] = prefix;
1851 state->dict.suffix[state->next_code] = suffix;
1852
1853 if ((state->next_code & (state->next_code - 1)) == 0)
1854 state->code_bits++;
1855
1856 state->next_code++;
1857 return state->next_code;
1858 }
1859
1860 return -1;
1861}
#define LZW_DICT_SIZE
Definition: gifformat.c:1730

Referenced by gif_compress().

◆ lzw_dict_lookup()

static short lzw_dict_lookup ( const struct lzw_state state,
short  prefix,
unsigned char  suffix 
)
static

Definition at line 1863 of file gifformat.c.

1864{
1865 short i;
1866
1867 for (i = 0; i < state->next_code; i++)
1868 {
1869 if (state->dict.prefix[i] == prefix && state->dict.suffix[i] == suffix)
1870 return i;
1871 }
1872
1873 return -1;
1874}

Referenced by gif_compress().

◆ lzw_dict_reset()

static void lzw_dict_reset ( struct lzw_state state)
static

Definition at line 1819 of file gifformat.c.

1820{
1821 int i;
1822
1823 state->code_bits = state->init_code_bits + 1;
1824 state->next_code = (1 << state->init_code_bits) + 2;
1825
1826 for(i = 0; i < LZW_DICT_SIZE; i++)
1827 {
1828 state->dict.prefix[i] = 1 << 12; /* impossible LZW code value */
1829 state->dict.suffix[i] = 0;
1830 }
1831}

Referenced by gif_compress(), and lzw_state_init().

◆ lzw_flush_bits()

static int lzw_flush_bits ( struct lzw_state state)
static

Definition at line 1791 of file gifformat.c.

1792{
1793 unsigned char byte;
1794
1795 while (state->bits_count >= 8)
1796 {
1797 byte = (unsigned char)state->bits_buf;
1798 if (state->user_write_data(state->user_ptr, &byte, 1) != 1)
1799 return 0;
1800 state->bits_buf >>= 8;
1801 state->bits_count -= 8;
1802 }
1803
1804 if (state->bits_count)
1805 {
1806 static const char mask[8] = { 0x00,0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f };
1807
1808 byte = (unsigned char)state->bits_buf & mask[state->bits_count];
1809 if (state->user_write_data(state->user_ptr, &byte, 1) != 1)
1810 return 0;
1811 }
1812
1813 state->bits_buf = 0;
1814 state->bits_count = 0;
1815
1816 return 1;
1817}
#define byte(x, n)
Definition: tomcrypt.h:118
GLenum GLint GLuint mask
Definition: glext.h:6028
if(dx< 0)
Definition: linetemp.h:194

Referenced by gif_compress().

◆ lzw_output_clear_code()

static int lzw_output_clear_code ( struct lzw_state state)
inlinestatic

Definition at line 1781 of file gifformat.c.

1782{
1783 return lzw_output_code(state, state->clear_code);
1784}

Referenced by gif_compress().

◆ lzw_output_code()

static int lzw_output_code ( struct lzw_state state,
short  code 
)
static

Definition at line 1764 of file gifformat.c.

1765{
1766 state->bits_buf |= code << state->bits_count;
1767 state->bits_count += state->code_bits;
1768
1769 while (state->bits_count >= 8)
1770 {
1771 unsigned char byte = (unsigned char)state->bits_buf;
1772 if (state->user_write_data(state->user_ptr, &byte, 1) != 1)
1773 return 0;
1774 state->bits_buf >>= 8;
1775 state->bits_count -= 8;
1776 }
1777
1778 return 1;
1779}

Referenced by gif_compress(), lzw_output_clear_code(), and lzw_output_eof_code().

◆ lzw_output_eof_code()

static int lzw_output_eof_code ( struct lzw_state state)
inlinestatic

Definition at line 1786 of file gifformat.c.

1787{
1788 return lzw_output_code(state, state->eof_code);
1789}

Referenced by gif_compress().

◆ lzw_state_init()

static void lzw_state_init ( struct lzw_state state,
short  init_code_bits,
void user_write_data,
void user_ptr 
)
static

Definition at line 1833 of file gifformat.c.

1834{
1835 state->init_code_bits = init_code_bits;
1836 state->clear_code = 1 << init_code_bits;
1837 state->eof_code = state->clear_code + 1;
1838 state->bits_buf = 0;
1839 state->bits_count = 0;
1840 state->user_write_data = user_write_data;
1841 state->user_ptr = user_ptr;
1842
1844}
static void user_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
Definition: libpng.c:537

Referenced by gif_compress().

◆ read_byte()

static int read_byte ( struct input_stream in,
unsigned char byte 
)
inlinestatic

Definition at line 1920 of file gifformat.c.

1921{
1922 if (in->len)
1923 {
1924 in->len--;
1925 *byte = *in->in++;
1926 return 1;
1927 }
1928
1929 return 0;
1930}

Referenced by gif_compress().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( wincodecs  )

◆ write_byte()

static int write_byte ( struct output_stream out,
char  byte 
)
inlinestatic

Definition at line 1876 of file gifformat.c.

1877{
1878 if (out->gif_block.len == 255)
1879 {
1880 if (IStream_Write(out->out, &out->gif_block, sizeof(out->gif_block), NULL) != S_OK)
1881 return 0;
1882
1883 out->gif_block.len = 0;
1884 }
1885
1886 out->gif_block.data[out->gif_block.len++] = byte;
1887
1888 return 1;
1889}

Referenced by write_data().

◆ write_data()

static int write_data ( void user_ptr,
void user_data,
int  length 
)
static

Definition at line 1891 of file gifformat.c.

1892{
1893 unsigned char *data = user_data;
1894 struct output_stream *out = user_ptr;
1895 int len = length;
1896
1897 while (len-- > 0)
1898 {
1899 if (!write_byte(out, *data++)) return 0;
1900 }
1901
1902 return length;
1903}
static int write_byte(struct output_stream *out, char byte)
Definition: gifformat.c:1876
GLuint GLsizei GLsizei * length
Definition: glext.h:6040

Variable Documentation

◆ APEReader_Vtbl

const MetadataHandlerVtbl APEReader_Vtbl
static
Initial value:
= {
0,
&CLSID_WICAPEMetadataReader,
}
static HRESULT load_APE_metadata(IStream *stream, const GUID *vendor, DWORD options, MetadataItem **items, DWORD *count)
Definition: gifformat.c:320

Definition at line 416 of file gifformat.c.

Referenced by APEReader_CreateInstance().

◆ GCEReader_Vtbl

const MetadataHandlerVtbl GCEReader_Vtbl
static
Initial value:
= {
0,
&CLSID_WICGCEMetadataReader,
}
static HRESULT load_GCE_metadata(IStream *stream, const GUID *vendor, DWORD options, MetadataItem **items, DWORD *count)
Definition: gifformat.c:242

Definition at line 309 of file gifformat.c.

Referenced by GCEReader_CreateInstance().

◆ GifCommentReader_Vtbl

const MetadataHandlerVtbl GifCommentReader_Vtbl
static
Initial value:
= {
0,
&CLSID_WICGifCommentMetadataReader,
}
static HRESULT load_GifComment_metadata(IStream *stream, const GUID *vendor, DWORD options, MetadataItem **items, DWORD *count)
Definition: gifformat.c:427

Definition at line 510 of file gifformat.c.

Referenced by GifCommentReader_CreateInstance().

◆ GifDecoder_BlockVtbl

const IWICMetadataBlockReaderVtbl GifDecoder_BlockVtbl
static
Initial value:
=
{
}
static HRESULT WINAPI GifDecoder_Block_GetCount(IWICMetadataBlockReader *iface, UINT *count)
Definition: gifformat.c:1336
static ULONG WINAPI GifDecoder_Block_Release(IWICMetadataBlockReader *iface)
Definition: gifformat.c:1319
static HRESULT WINAPI GifDecoder_Block_GetEnumerator(IWICMetadataBlockReader *iface, IEnumUnknown **enumerator)
Definition: gifformat.c:1384
static HRESULT WINAPI GifDecoder_Block_GetContainerFormat(IWICMetadataBlockReader *iface, GUID *guid)
Definition: gifformat.c:1325
static HRESULT WINAPI GifDecoder_Block_GetReaderByIndex(IWICMetadataBlockReader *iface, UINT index, IWICMetadataReader **reader)
Definition: gifformat.c:1349
static ULONG WINAPI GifDecoder_Block_AddRef(IWICMetadataBlockReader *iface)
Definition: gifformat.c:1313
static HRESULT WINAPI GifDecoder_Block_QueryInterface(IWICMetadataBlockReader *iface, REFIID iid, void **ppv)
Definition: gifformat.c:1306

Definition at line 1391 of file gifformat.c.

Referenced by GifDecoder_CreateInstance().

◆ GifDecoder_Vtbl

const IWICBitmapDecoderVtbl GifDecoder_Vtbl
static
Initial value:
= {
}
static HRESULT WINAPI GifDecoder_GetPreview(IWICBitmapDecoder *iface, IWICBitmapSource **ppIBitmapSource)
Definition: gifformat.c:1225
static HRESULT WINAPI GifDecoder_GetContainerFormat(IWICBitmapDecoder *iface, GUID *pguidContainerFormat)
Definition: gifformat.c:1172
static HRESULT WINAPI GifDecoder_GetFrame(IWICBitmapDecoder *iface, UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
Definition: gifformat.c:1262
static HRESULT WINAPI GifDecoder_GetThumbnail(IWICBitmapDecoder *iface, IWICBitmapSource **ppIThumbnail)
Definition: gifformat.c:1239
static HRESULT WINAPI GifDecoder_CopyPalette(IWICBitmapDecoder *iface, IWICPalette *palette)
Definition: gifformat.c:1187
static HRESULT WINAPI GifDecoder_QueryCapability(IWICBitmapDecoder *iface, IStream *stream, DWORD *capability)
Definition: gifformat.c:1084
static HRESULT WINAPI GifDecoder_GetFrameCount(IWICBitmapDecoder *iface, UINT *pCount)
Definition: gifformat.c:1246
static HRESULT WINAPI GifDecoder_GetColorContexts(IWICBitmapDecoder *iface, UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
Definition: gifformat.c:1232
static HRESULT WINAPI GifDecoder_QueryInterface(IWICBitmapDecoder *iface, REFIID iid, void **ppv)
Definition: gifformat.c:1025
static HRESULT WINAPI GifDecoder_GetDecoderInfo(IWICBitmapDecoder *iface, IWICBitmapDecoderInfo **ppIDecoderInfo)
Definition: gifformat.c:1179
static HRESULT WINAPI GifDecoder_GetMetadataQueryReader(IWICBitmapDecoder *iface, IWICMetadataQueryReader **ppIMetadataQueryReader)
Definition: gifformat.c:1213
static HRESULT WINAPI GifDecoder_Initialize(IWICBitmapDecoder *iface, IStream *pIStream, WICDecodeOptions cacheOptions)
Definition: gifformat.c:1118
static ULONG WINAPI GifDecoder_Release(IWICBitmapDecoder *iface)
Definition: gifformat.c:1062
static ULONG WINAPI GifDecoder_AddRef(IWICBitmapDecoder *iface)
Definition: gifformat.c:1052

Definition at line 1289 of file gifformat.c.

Referenced by GifDecoder_CreateInstance().

◆ GifEncoder_Vtbl

const IWICBitmapEncoderVtbl GifEncoder_Vtbl
static
Initial value:
=
{
}
static HRESULT WINAPI GifEncoder_Commit(IWICBitmapEncoder *iface)
Definition: gifformat.c:2427
static ULONG WINAPI GifEncoder_Release(IWICBitmapEncoder *iface)
Definition: gifformat.c:2156
static ULONG WINAPI GifEncoder_AddRef(IWICBitmapEncoder *iface)
Definition: gifformat.c:2147
static HRESULT WINAPI GifEncoder_GetContainerFormat(IWICBitmapEncoder *iface, GUID *format)
Definition: gifformat.c:2200
static HRESULT WINAPI GifEncoder_GetEncoderInfo(IWICBitmapEncoder *iface, IWICBitmapEncoderInfo **info)
Definition: gifformat.c:2208
static HRESULT WINAPI GifEncoder_SetColorContexts(IWICBitmapEncoder *iface, UINT count, IWICColorContext **context)
Definition: gifformat.c:2226
static HRESULT WINAPI GifEncoder_SetThumbnail(IWICBitmapEncoder *iface, IWICBitmapSource *thumbnail)
Definition: gifformat.c:2252
static HRESULT WINAPI GifEncoder_SetPalette(IWICBitmapEncoder *iface, IWICPalette *palette)
Definition: gifformat.c:2232
static HRESULT WINAPI GifEncoder_GetMetadataQueryWriter(IWICBitmapEncoder *iface, IWICMetadataQueryWriter **writer)
Definition: gifformat.c:2453
static HRESULT WINAPI GifEncoder_CreateNewFrame(IWICBitmapEncoder *iface, IWICBitmapFrameEncode **frame, IPropertyBag2 **options)
Definition: gifformat.c:2367
static HRESULT WINAPI GifEncoder_SetPreview(IWICBitmapEncoder *iface, IWICBitmapSource *preview)
Definition: gifformat.c:2258
static HRESULT WINAPI GifEncoder_Initialize(IWICBitmapEncoder *iface, IStream *stream, WICBitmapEncoderCacheOption option)
Definition: gifformat.c:2174
static HRESULT WINAPI GifEncoder_QueryInterface(IWICBitmapEncoder *iface, REFIID iid, void **ppv)
Definition: gifformat.c:2129

Definition at line 2459 of file gifformat.c.

Referenced by GifEncoder_CreateInstance().

◆ GifFrameDecode_BlockVtbl

const IWICMetadataBlockReaderVtbl GifFrameDecode_BlockVtbl
static
Initial value:
=
{
}
static ULONG WINAPI GifFrameDecode_Block_AddRef(IWICMetadataBlockReader *iface)
Definition: gifformat.c:881
static ULONG WINAPI GifFrameDecode_Block_Release(IWICMetadataBlockReader *iface)
Definition: gifformat.c:887
static HRESULT WINAPI GifFrameDecode_Block_GetContainerFormat(IWICMetadataBlockReader *iface, GUID *guid)
Definition: gifformat.c:893
static HRESULT WINAPI GifFrameDecode_Block_QueryInterface(IWICMetadataBlockReader *iface, REFIID iid, void **ppv)
Definition: gifformat.c:874
static HRESULT WINAPI GifFrameDecode_Block_GetCount(IWICMetadataBlockReader *iface, UINT *count)
Definition: gifformat.c:904
static HRESULT WINAPI GifFrameDecode_Block_GetEnumerator(IWICMetadataBlockReader *iface, IEnumUnknown **enumerator)
Definition: gifformat.c:1007
static HRESULT WINAPI GifFrameDecode_Block_GetReaderByIndex(IWICMetadataBlockReader *iface, UINT index, IWICMetadataReader **reader)
Definition: gifformat.c:965

Definition at line 1014 of file gifformat.c.

Referenced by GifDecoder_GetFrame().

◆ GifFrameDecode_Vtbl

const IWICBitmapFrameDecodeVtbl GifFrameDecode_Vtbl
static
Initial value:
= {
}
static HRESULT WINAPI GifFrameDecode_GetThumbnail(IWICBitmapFrameDecode *iface, IWICBitmapSource **ppIThumbnail)
Definition: gifformat.c:853
static HRESULT WINAPI GifFrameDecode_GetSize(IWICBitmapFrameDecode *iface, UINT *puiWidth, UINT *puiHeight)
Definition: gifformat.c:664
static ULONG WINAPI GifFrameDecode_AddRef(IWICBitmapFrameDecode *iface)
Definition: gifformat.c:638
static HRESULT WINAPI GifFrameDecode_GetPixelFormat(IWICBitmapFrameDecode *iface, WICPixelFormatGUID *pPixelFormat)
Definition: gifformat.c:676
static HRESULT WINAPI GifFrameDecode_QueryInterface(IWICBitmapFrameDecode *iface, REFIID iid, void **ppv)
Definition: gifformat.c:610
static HRESULT WINAPI GifFrameDecode_GetMetadataQueryReader(IWICBitmapFrameDecode *iface, IWICMetadataQueryReader **ppIMetadataQueryReader)
Definition: gifformat.c:833
static HRESULT WINAPI GifFrameDecode_GetResolution(IWICBitmapFrameDecode *iface, double *pDpiX, double *pDpiY)
Definition: gifformat.c:684
static HRESULT WINAPI GifFrameDecode_CopyPixels(IWICBitmapFrameDecode *iface, const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
Definition: gifformat.c:813
static ULONG WINAPI GifFrameDecode_Release(IWICBitmapFrameDecode *iface)
Definition: gifformat.c:648
static HRESULT WINAPI GifFrameDecode_GetColorContexts(IWICBitmapFrameDecode *iface, UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
Definition: gifformat.c:846
static HRESULT WINAPI GifFrameDecode_CopyPalette(IWICBitmapFrameDecode *iface, IWICPalette *pIPalette)
Definition: gifformat.c:734

Definition at line 860 of file gifformat.c.

Referenced by GifDecoder_GetFrame().

◆ GifFrameEncode_BlockVtbl

const IWICMetadataBlockWriterVtbl GifFrameEncode_BlockVtbl
static
Initial value:
= {
}
static HRESULT WINAPI GifEncoderFrame_Block_SetWriterByIndex(IWICMetadataBlockWriter *iface, UINT index, IWICMetadataWriter *metadata_writer)
Definition: gifformat.c:2337
static ULONG WINAPI GifEncoderFrame_Block_Release(IWICMetadataBlockWriter *iface)
Definition: gifformat.c:2278
static HRESULT WINAPI GifEncoderFrame_Block_QueryInterface(IWICMetadataBlockWriter *iface, REFIID iid, void **ppv)
Definition: gifformat.c:2264
static HRESULT WINAPI GifEncoderFrame_Block_GetWriterByIndex(IWICMetadataBlockWriter *iface, UINT index, IWICMetadataWriter **metadata_writer)
Definition: gifformat.c:2322
static HRESULT WINAPI GifEncoderFrame_Block_GetContainerFormat(IWICMetadataBlockWriter *iface, GUID *container_format)
Definition: gifformat.c:2285
static HRESULT WINAPI GifEncoderFrame_Block_GetEnumerator(IWICMetadataBlockWriter *iface, IEnumUnknown **enum_metadata)
Definition: gifformat.c:2307
static HRESULT WINAPI GifEncoderFrame_Block_InitializeFromBlockReader(IWICMetadataBlockWriter *iface, IWICMetadataBlockReader *block_reader)
Definition: gifformat.c:2314
static HRESULT WINAPI GifEncoderFrame_Block_AddWriter(IWICMetadataBlockWriter *iface, IWICMetadataWriter *metadata_writer)
Definition: gifformat.c:2330
static HRESULT WINAPI GifEncoderFrame_Block_RemoveWriterByIndex(IWICMetadataBlockWriter *iface, UINT index)
Definition: gifformat.c:2345
static HRESULT WINAPI GifEncoderFrame_Block_GetReaderByIndex(IWICMetadataBlockWriter *iface, UINT index, IWICMetadataReader **metadata_reader)
Definition: gifformat.c:2299
static HRESULT WINAPI GifEncoderFrame_Block_GetCount(IWICMetadataBlockWriter *iface, UINT *count)
Definition: gifformat.c:2292
static ULONG WINAPI GifEncoderFrame_Block_AddRef(IWICMetadataBlockWriter *iface)
Definition: gifformat.c:2271

Definition at line 2352 of file gifformat.c.

Referenced by GifEncoder_CreateNewFrame().

◆ GifFrameEncode_Vtbl

const IWICBitmapFrameEncodeVtbl GifFrameEncode_Vtbl
static
Initial value:
=
{
}
static HRESULT WINAPI GifFrameEncode_SetResolution(IWICBitmapFrameEncode *iface, double xres, double yres)
Definition: gifformat.c:1583
static HRESULT WINAPI GifFrameEncode_SetPalette(IWICBitmapFrameEncode *iface, IWICPalette *palette)
Definition: gifformat.c:1636
static HRESULT WINAPI GifFrameEncode_QueryInterface(IWICBitmapFrameEncode *iface, REFIID iid, void **ppv)
Definition: gifformat.c:1475
static ULONG WINAPI GifFrameEncode_Release(IWICBitmapFrameEncode *iface)
Definition: gifformat.c:1511
static HRESULT WINAPI GifFrameEncode_GetMetadataQueryWriter(IWICBitmapFrameEncode *iface, IWICMetadataQueryWriter **writer)
Definition: gifformat.c:2096
static ULONG WINAPI GifFrameEncode_AddRef(IWICBitmapFrameEncode *iface)
Definition: gifformat.c:1502
static HRESULT WINAPI GifFrameEncode_Initialize(IWICBitmapFrameEncode *iface, IPropertyBag2 *options)
Definition: gifformat.c:1528
static HRESULT WINAPI GifFrameEncode_SetThumbnail(IWICBitmapFrameEncode *iface, IWICBitmapSource *thumbnail)
Definition: gifformat.c:1656
static HRESULT WINAPI GifFrameEncode_SetColorContexts(IWICBitmapFrameEncode *iface, UINT count, IWICColorContext **context)
Definition: gifformat.c:1630
static HRESULT WINAPI GifFrameEncode_SetPixelFormat(IWICBitmapFrameEncode *iface, WICPixelFormatGUID *format)
Definition: gifformat.c:1606
static HRESULT WINAPI GifFrameEncode_Commit(IWICBitmapFrameEncode *iface)
Definition: gifformat.c:1991
static HRESULT WINAPI GifFrameEncode_SetSize(IWICBitmapFrameEncode *iface, UINT width, UINT height)
Definition: gifformat.c:1550
static HRESULT WINAPI GifFrameEncode_WritePixels(IWICBitmapFrameEncode *iface, UINT lines, UINT stride, UINT size, BYTE *pixels)
Definition: gifformat.c:1662
static HRESULT WINAPI GifFrameEncode_WriteSource(IWICBitmapFrameEncode *iface, IWICBitmapSource *source, WICRect *rc)
Definition: gifformat.c:1703

Definition at line 2111 of file gifformat.c.

Referenced by GifEncoder_CreateNewFrame().

◆ IMDReader_Vtbl

const MetadataHandlerVtbl IMDReader_Vtbl
static
Initial value:
= {
0,
&CLSID_WICIMDMetadataReader,
}
static HRESULT load_IMD_metadata(IStream *stream, const GUID *vendor, DWORD options, MetadataItem **items, DWORD *count)
Definition: gifformat.c:161

Definition at line 231 of file gifformat.c.

Referenced by IMDReader_CreateInstance().

◆ LSDReader_Vtbl

const MetadataHandlerVtbl LSDReader_Vtbl
static
Initial value:
= {
0,
&CLSID_WICLSDMetadataReader,
}
static HRESULT load_LSD_metadata(IStream *stream, const GUID *vendor, DWORD options, MetadataItem **items, DWORD *count)
Definition: gifformat.c:73

Definition at line 150 of file gifformat.c.

Referenced by LSDReader_CreateInstance().