gifformat.c File Reference

#include "config.h"
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "objbase.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	NONAMELESSUNION
#define	LZW_DICT_SIZE   (1 << 12)

Typedefs
typedef struct GifEncoder	GifEncoder
typedef struct GifFrameEncode	GifFrameEncode

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (wincodecs)
static LPWSTR	strdupAtoW (const char *src)
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 IStream *	create_stream (const void *data, int data_size)
static HRESULT	create_metadata_reader (const void *data, int data_size, class_constructor constructor, IWICMetadataReader **reader)
static GifDecoder *	impl_from_IWICBitmapDecoder (IWICBitmapDecoder *iface)
static GifDecoder *	impl_from_IWICMetadataBlockReader (IWICMetadataBlockReader *iface)
static GifFrameDecode *	impl_from_IWICBitmapFrameDecode (IWICBitmapFrameDecode *iface)
static GifFrameDecode *	frame_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 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 GifEncoder *	impl_from_IWICBitmapEncoder (IWICBitmapEncoder *iface)
static GifFrameEncode *	impl_from_IWICBitmapFrameEncode (IWICBitmapFrameEncode *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	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 IWICBitmapEncoderVtbl	GifEncoder_Vtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 24 of file gifformat.c.

LZW_DICT_SIZE

#define LZW_DICT_SIZE   (1 << 12)

Definition at line 1743 of file gifformat.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 25 of file gifformat.c.

Typedef Documentation

GifEncoder

typedef struct GifEncoder GifEncoder

GifFrameEncode

typedef struct GifFrameEncode GifFrameEncode

Function Documentation

_gif_inputfunc()

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

static

Definition at line 1099 of file gifformat.c.

                                                                        {
    IStream *stream = gif->UserData;
    ULONG bytesread;
    HRESULT hr;
 
    if (!stream)
    {
        ERR("attempting to read file after initialization\n");
        return 0;
    }
 
    hr = IStream_Read(stream, data, len, &bytesread);
    if (FAILED(hr)) bytesread = 0;
    return bytesread;
}

Referenced by GifDecoder_Initialize().

APEReader_CreateInstance()

HRESULT APEReader_CreateInstance	(	REFIID	iid,
		void **	ppv
	)

Definition at line 434 of file gifformat.c.

{
    return MetadataReader_Create(&APEReader_Vtbl, iid, 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 750 of file gifformat.c.

{
    UINT row_offset; /* number of bytes into the source rows where the data starts */
    const BYTE *src;
    BYTE *dst;
    UINT y;
    WICRect rect;
 
    if (!rc)
    {
        rect.X = 0;
        rect.Y = 0;
        rect.Width = srcwidth;
        rect.Height = srcheight;
        rc = ▭
    }
    else
    {
        if (rc->X < 0 || rc->Y < 0 || rc->X+rc->Width > srcwidth || rc->Y+rc->Height > srcheight)
            return E_INVALIDARG;
    }
 
    if (dststride < rc->Width)
        return E_INVALIDARG;
 
    if ((dststride * rc->Height) > dstbuffersize)
        return E_INVALIDARG;
 
    row_offset = rc->X;
 
    dst = dstbuffer;
    for (y=rc->Y; y-rc->Y < rc->Height; y++)
    {
        if (y%8 == 0)
            src = srcbuffer + srcstride * (y/8);
        else if (y%4 == 0)
            src = srcbuffer + srcstride * ((srcheight+7)/8 + y/8);
        else if (y%2 == 0)
            src = srcbuffer + srcstride * ((srcheight+3)/4 + y/4);
        else /* y%2 == 1 */
            src = srcbuffer + srcstride * ((srcheight+1)/2 + y/2);
        src += row_offset;
        memcpy(dst, src, rc->Width);
        dst += dststride;
    }
    return S_OK;
}

Referenced by GifFrameDecode_CopyPixels().

create_IMD_metadata_reader()

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

static

Definition at line 904 of file gifformat.c.

{
    HRESULT hr;
    IWICMetadataReader *metadata_reader;
    IWICPersistStream *persist;
    IStream *stream;
    struct image_descriptor IMD_data;
 
    /* FIXME: Use IWICComponentFactory_CreateMetadataReader once it's implemented */
 
    hr = IMDReader_CreateInstance(&IID_IWICMetadataReader, (void **)&metadata_reader);
    if (FAILED(hr)) return hr;
 
    hr = IWICMetadataReader_QueryInterface(metadata_reader, &IID_IWICPersistStream, (void **)&persist);
    if (FAILED(hr))
    {
        IWICMetadataReader_Release(metadata_reader);
        return hr;
    }
 
    /* recreate IMD structure from GIF decoder data */
    IMD_data.left = This->frame->ImageDesc.Left;
    IMD_data.top = This->frame->ImageDesc.Top;
    IMD_data.width = This->frame->ImageDesc.Width;
    IMD_data.height = This->frame->ImageDesc.Height;
    IMD_data.packed = 0;
    /* interlace_flag */
    IMD_data.packed |= This->frame->ImageDesc.Interlace ? (1 << 6) : 0;
    if (This->frame->ImageDesc.ColorMap)
    {
        /* local_color_table_flag */
        IMD_data.packed |= 1 << 7;
        /* local_color_table_size */
        IMD_data.packed |= This->frame->ImageDesc.ColorMap->BitsPerPixel - 1;
        /* sort_flag */
        IMD_data.packed |= This->frame->ImageDesc.ColorMap->SortFlag ? 0x20 : 0;
    }
 
    stream = create_stream(&IMD_data, sizeof(IMD_data));
    IWICPersistStream_LoadEx(persist, stream, NULL, WICPersistOptionDefault);
    IStream_Release(stream);
 
    IWICPersistStream_Release(persist);
 
    *reader = metadata_reader;
    return S_OK;
}

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 551 of file gifformat.c.

{
    HRESULT hr;
    IWICMetadataReader *metadata_reader;
    IWICPersistStream *persist;
    IStream *stream;
 
    /* FIXME: Use IWICComponentFactory_CreateMetadataReader once it's implemented */
 
    hr = constructor(&IID_IWICMetadataReader, (void**)&metadata_reader);
    if (FAILED(hr)) return hr;
 
    hr = IWICMetadataReader_QueryInterface(metadata_reader, &IID_IWICPersistStream, (void **)&persist);
    if (FAILED(hr))
    {
        IWICMetadataReader_Release(metadata_reader);
        return hr;
    }
 
    stream = create_stream(data, data_size);
    IWICPersistStream_LoadEx(persist, stream, NULL, WICPersistOptionDefault);
    IStream_Release(stream);
 
    IWICPersistStream_Release(persist);
 
    *reader = metadata_reader;
    return S_OK;
}

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 533 of file gifformat.c.

{
    HRESULT hr;
    IStream *stream;
    HGLOBAL hdata;
    void *locked_data;
 
    hdata = GlobalAlloc(GMEM_MOVEABLE, data_size);
    if (!hdata) return NULL;
 
    locked_data = GlobalLock(hdata);
    memcpy(locked_data, data, data_size);
    GlobalUnlock(hdata);
 
    hr = CreateStreamOnHGlobal(hdata, TRUE, &stream);
    return FAILED(hr) ? NULL : stream;
}

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 1918 of file gifformat.c.

{
    struct output_stream *out = user_ptr;
 
    if (out->gif_block.len)
    {
        if (IStream_Write(out->out, &out->gif_block, out->gif_block.len + sizeof(out->gif_block.len), NULL) != S_OK)
            return 0;
    }
 
    /* write GIF block terminator */
    out->gif_block.len = 0;
    return IStream_Write(out->out, &out->gif_block, sizeof(out->gif_block.len), NULL) == S_OK;
}

Referenced by gif_compress().

frame_from_IWICMetadataBlockReader()

static GifFrameDecode * frame_from_IWICMetadataBlockReader ( IWICMetadataBlockReader *  iface )

inlinestatic

Definition at line 617 of file gifformat.c.

{
    return CONTAINING_RECORD(iface, GifFrameDecode, IWICMetadataBlockReader_iface);
}

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 327 of file gifformat.c.

{
    return MetadataReader_Create(&GCEReader_Vtbl, iid, ppv);
}

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 1945 of file gifformat.c.

{
    struct input_stream in;
    struct output_stream out;
    struct lzw_state state;
    short init_code_bits, prefix, code;
    unsigned char suffix;
 
    in.in = in_data;
    in.len = in_size;
 
    out.gif_block.len = 0;
    out.out = out_stream;
 
    init_code_bits = suffix = 8;
    if (IStream_Write(out.out, &suffix, sizeof(suffix), NULL) != S_OK)
        return E_FAIL;
 
    lzw_state_init(&state, init_code_bits, write_data, &out);
 
    if (!lzw_output_clear_code(&state))
        return E_FAIL;
 
    if (read_byte(&in, &suffix))
    {
        prefix = suffix;
 
        while (read_byte(&in, &suffix))
        {
            code = lzw_dict_lookup(&state, prefix, suffix);
            if (code == -1)
            {
                if (!lzw_output_code(&state, prefix))
                    return E_FAIL;
 
                if (lzw_dict_add(&state, prefix, suffix) == -1)
                {
                    if (!lzw_output_clear_code(&state))
                        return E_FAIL;
                    lzw_dict_reset(&state);
                }
 
                prefix = suffix;
            }
            else
                prefix = code;
        }
 
        if (!lzw_output_code(&state, prefix))
            return E_FAIL;
        if (!lzw_output_eof_code(&state))
            return E_FAIL;
        if (!lzw_flush_bits(&state))
            return E_FAIL;
    }
 
    return flush_output_data(&out) ? S_OK : E_FAIL;
}

Referenced by GifFrameEncode_Commit().

GifCommentReader_CreateInstance()

HRESULT GifCommentReader_CreateInstance	(	REFIID	iid,
		void **	ppv
	)

Definition at line 528 of file gifformat.c.

{
    return MetadataReader_Create(&GifCommentReader_Vtbl, iid, ppv);
}

Referenced by GifDecoder_Block_GetReaderByIndex(), and GifFrameDecode_Block_GetReaderByIndex().

GifDecoder_AddRef()

static ULONG WINAPI GifDecoder_AddRef ( IWICBitmapDecoder *  iface )

static

Definition at line 1049 of file gifformat.c.

{
    GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p) refcount=%u\n", iface, ref);
 
    return ref;
}

GifDecoder_Block_AddRef()

static ULONG WINAPI GifDecoder_Block_AddRef ( IWICMetadataBlockReader *  iface )

static

Definition at line 1345 of file gifformat.c.

{
    GifDecoder *This = impl_from_IWICMetadataBlockReader(iface);
    return IWICBitmapDecoder_AddRef(&This->IWICBitmapDecoder_iface);
}

GifDecoder_Block_GetContainerFormat()

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

static

Definition at line 1357 of file gifformat.c.

{
    TRACE("(%p,%p)\n", iface, guid);
 
    if (!guid) return E_INVALIDARG;
 
    *guid = GUID_ContainerFormatGif;
    return S_OK;
}

GifDecoder_Block_GetCount()

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

static

Definition at line 1368 of file gifformat.c.

{
    GifDecoder *This = impl_from_IWICMetadataBlockReader(iface);
 
    TRACE("%p,%p\n", iface, count);
 
    if (!count) return E_INVALIDARG;
 
    *count = This->gif->Extensions.ExtensionBlockCount + 1;
    return S_OK;
}

GifDecoder_Block_GetEnumerator()

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

static

Definition at line 1416 of file gifformat.c.

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

GifDecoder_Block_GetReaderByIndex()

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

static

Definition at line 1381 of file gifformat.c.

{
    GifDecoder *This = impl_from_IWICMetadataBlockReader(iface);
    int i;
 
    TRACE("(%p,%u,%p)\n", iface, index, reader);
 
    if (!reader) return E_INVALIDARG;
 
    if (index == 0)
        return create_metadata_reader(This->LSD_data, sizeof(This->LSD_data),
                                      LSDReader_CreateInstance, reader);
 
    for (i = 0; i < This->gif->Extensions.ExtensionBlockCount; i++)
    {
        class_constructor constructor;
 
        if (index != i + 1) continue;
 
        if (This->gif->Extensions.ExtensionBlocks[i].Function == APPLICATION_EXT_FUNC_CODE)
            constructor = APEReader_CreateInstance;
        else if (This->gif->Extensions.ExtensionBlocks[i].Function == COMMENT_EXT_FUNC_CODE)
            constructor = GifCommentReader_CreateInstance;
        else
            constructor = UnknownMetadataReader_CreateInstance;
 
        return create_metadata_reader(This->gif->Extensions.ExtensionBlocks[i].Bytes,
                                      This->gif->Extensions.ExtensionBlocks[i].ByteCount,
                                      constructor, reader);
    }
 
    return E_INVALIDARG;
}

GifDecoder_Block_QueryInterface()

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

static

Definition at line 1338 of file gifformat.c.

{
    GifDecoder *This = impl_from_IWICMetadataBlockReader(iface);
    return IWICBitmapDecoder_QueryInterface(&This->IWICBitmapDecoder_iface, iid, ppv);
}

GifDecoder_Block_Release()

static ULONG WINAPI GifDecoder_Block_Release ( IWICMetadataBlockReader *  iface )

static

Definition at line 1351 of file gifformat.c.

{
    GifDecoder *This = impl_from_IWICMetadataBlockReader(iface);
    return IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
}

GifDecoder_CopyPalette()

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

static

Definition at line 1184 of file gifformat.c.

{
    GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
    WICColor colors[256];
    ColorMapObject *cm;
    int i, trans, count;
    ExtensionBlock *eb;
 
    TRACE("(%p,%p)\n", iface, palette);
 
    if (!This->gif)
        return WINCODEC_ERR_WRONGSTATE;
 
    cm = This->gif->SColorMap;
    if (cm)
    {
        if (cm->ColorCount > 256)
        {
            ERR("GIF contains invalid number of colors: %d\n", cm->ColorCount);
            return E_FAIL;
        }
 
        for (i = 0; i < cm->ColorCount; i++)
        {
            colors[i] = 0xff000000 | /* alpha */
                        cm->Colors[i].Red << 16 |
                        cm->Colors[i].Green << 8 |
                        cm->Colors[i].Blue;
        }
 
        count = cm->ColorCount;
    }
    else
    {
        colors[0] = 0xff000000;
        colors[1] = 0xffffffff;
 
        for (i = 2; i < 256; i++)
            colors[i] = 0xff000000;
 
        count = 256;
    }
 
    /* look for the transparent color extension */
    for (i = 0; i < This->gif->SavedImages[This->current_frame].Extensions.ExtensionBlockCount; i++)
    {
        eb = This->gif->SavedImages[This->current_frame].Extensions.ExtensionBlocks + i;
        if (eb->Function == GRAPHICS_EXT_FUNC_CODE && eb->ByteCount == 8)
        {
            if (eb->Bytes[3] & 1)
            {
                trans = (unsigned char)eb->Bytes[6];
                colors[trans] &= 0xffffff; /* set alpha to 0 */
                break;
            }
        }
    }
 
    return IWICPalette_InitializeCustom(palette, colors, count);
}

GifDecoder_CreateInstance()

HRESULT GifDecoder_CreateInstance	(	REFIID	iid,
		void **	ppv
	)

Definition at line 1434 of file gifformat.c.

{
    GifDecoder *This;
    HRESULT ret;
 
    TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
 
    *ppv = NULL;
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(GifDecoder));
    if (!This) return E_OUTOFMEMORY;
 
    This->IWICBitmapDecoder_iface.lpVtbl = &GifDecoder_Vtbl;
    This->IWICMetadataBlockReader_iface.lpVtbl = &GifDecoder_BlockVtbl;
    This->stream = NULL;
    This->ref = 1;
    This->initialized = FALSE;
    This->gif = NULL;
    This->current_frame = 0;
    InitializeCriticalSection(&This->lock);
    This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": GifDecoder.lock");
 
    ret = IWICBitmapDecoder_QueryInterface(&This->IWICBitmapDecoder_iface, iid, ppv);
    IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
 
    return ret;
}

GifDecoder_GetColorContexts()

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

static

Definition at line 1264 of file gifformat.c.

{
    TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
    return WINCODEC_ERR_UNSUPPORTEDOPERATION;
}

GifDecoder_GetContainerFormat()

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

static

Definition at line 1169 of file gifformat.c.

{
    memcpy(pguidContainerFormat, &GUID_ContainerFormatGif, sizeof(GUID));
    return S_OK;
}

GifDecoder_GetDecoderInfo()

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

static

Definition at line 1176 of file gifformat.c.

{
    TRACE("(%p,%p)\n", iface, ppIDecoderInfo);
 
    return get_decoder_info(&CLSID_WICGifDecoder, ppIDecoderInfo);
}

GifDecoder_GetFrame()

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

static

Definition at line 1294 of file gifformat.c.

{
    GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
    GifFrameDecode *result;
    TRACE("(%p,%u,%p)\n", iface, index, ppIBitmapFrame);
 
    if (!This->initialized) return WINCODEC_ERR_FRAMEMISSING;
 
    if (index >= This->gif->ImageCount) return E_INVALIDARG;
 
    result = HeapAlloc(GetProcessHeap(), 0, sizeof(GifFrameDecode));
    if (!result) return E_OUTOFMEMORY;
 
    result->IWICBitmapFrameDecode_iface.lpVtbl = &GifFrameDecode_Vtbl;
    result->IWICMetadataBlockReader_iface.lpVtbl = &GifFrameDecode_BlockVtbl;
    result->ref = 1;
    result->frame = &This->gif->SavedImages[index];
    IWICBitmapDecoder_AddRef(iface);
    result->parent = This;
    This->current_frame = index;
 
    *ppIBitmapFrame = &result->IWICBitmapFrameDecode_iface;
 
    return S_OK;
}

GifDecoder_GetFrameCount()

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

static

Definition at line 1278 of file gifformat.c.

{
    GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
 
    if (!pCount) return E_INVALIDARG;
 
    EnterCriticalSection(&This->lock);
    *pCount = This->gif ? This->gif->ImageCount : 0;
    LeaveCriticalSection(&This->lock);
 
    TRACE("(%p) <-- %d\n", iface, *pCount);
 
    return S_OK;
}

GifDecoder_GetMetadataQueryReader()

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

static

Definition at line 1245 of file gifformat.c.

{
    GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
 
    TRACE("(%p,%p)\n", iface, ppIMetadataQueryReader);
 
    if (!ppIMetadataQueryReader) return E_INVALIDARG;
 
    return MetadataQueryReader_CreateInstance(&This->IWICMetadataBlockReader_iface, NULL, ppIMetadataQueryReader);
}

GifDecoder_GetPreview()

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

static

Definition at line 1257 of file gifformat.c.

{
    TRACE("(%p,%p)\n", iface, ppIBitmapSource);
    return WINCODEC_ERR_UNSUPPORTEDOPERATION;
}

GifDecoder_GetThumbnail()

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

static

Definition at line 1271 of file gifformat.c.

{
    TRACE("(%p,%p)\n", iface, ppIThumbnail);
    return WINCODEC_ERR_CODECNOTHUMBNAIL;
}

GifDecoder_Initialize()

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

static

Definition at line 1115 of file gifformat.c.

{
    GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
    LARGE_INTEGER seek;
    int ret;
 
    TRACE("(%p,%p,%x)\n", iface, pIStream, cacheOptions);
 
    EnterCriticalSection(&This->lock);
 
    if (This->initialized || This->gif)
    {
        WARN("already initialized\n");
        LeaveCriticalSection(&This->lock);
        return WINCODEC_ERR_WRONGSTATE;
    }
 
    /* seek to start of stream */
    seek.QuadPart = 0;
    IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
 
    /* read all data from the stream */
    This->gif = DGifOpen((void*)pIStream, _gif_inputfunc);
    if (!This->gif)
    {
        LeaveCriticalSection(&This->lock);
        return E_FAIL;
    }
 
    ret = DGifSlurp(This->gif);
    if (ret == GIF_ERROR)
    {
        LeaveCriticalSection(&This->lock);
        return E_FAIL;
    }
 
    /* make sure we don't use the stream after this method returns */
    This->gif->UserData = NULL;
 
    seek.QuadPart = 0;
    IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
    IStream_Read(pIStream, This->LSD_data, sizeof(This->LSD_data), NULL);
 
    This->stream = pIStream;
    IStream_AddRef(This->stream);
 
    This->initialized = TRUE;
 
    LeaveCriticalSection(&This->lock);
 
    return S_OK;
}

GifDecoder_QueryCapability()

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

static

Definition at line 1081 of file gifformat.c.

{
    HRESULT hr;
 
    TRACE("(%p,%p,%p)\n", iface, stream, capability);
 
    if (!stream || !capability) return E_INVALIDARG;
 
    hr = IWICBitmapDecoder_Initialize(iface, stream, WICDecodeMetadataCacheOnDemand);
    if (hr != S_OK) return hr;
 
    *capability = WICBitmapDecoderCapabilityCanDecodeAllImages |
                  WICBitmapDecoderCapabilityCanDecodeSomeImages |
                  WICBitmapDecoderCapabilityCanEnumerateMetadata;
    return S_OK;
}

GifDecoder_QueryInterface()

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

static

Definition at line 1022 of file gifformat.c.

{
    GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
    TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 
    if (!ppv) return E_INVALIDARG;
 
    if (IsEqualIID(&IID_IUnknown, iid) ||
        IsEqualIID(&IID_IWICBitmapDecoder, iid))
    {
        *ppv = &This->IWICBitmapDecoder_iface;
    }
    else if (IsEqualIID(&IID_IWICMetadataBlockReader, iid))
    {
        *ppv = &This->IWICMetadataBlockReader_iface;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

GifDecoder_Release()

static ULONG WINAPI GifDecoder_Release ( IWICBitmapDecoder *  iface )

static

Definition at line 1059 of file gifformat.c.

{
    GifDecoder *This = impl_from_IWICBitmapDecoder(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p) refcount=%u\n", iface, ref);
 
    if (ref == 0)
    {
        if (This->stream)
        {
            IStream_Release(This->stream);
            DGifCloseFile(This->gif);
        }
        This->lock.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&This->lock);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}

GifEncoder_AddRef()

static ULONG WINAPI GifEncoder_AddRef ( IWICBitmapEncoder *  iface )

static

Definition at line 2151 of file gifformat.c.

{
    GifEncoder *This = impl_from_IWICBitmapEncoder(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("%p -> %u\n", iface, ref);
    return ref;
}

GifEncoder_Commit()

static HRESULT WINAPI GifEncoder_Commit ( IWICBitmapEncoder *  iface )

static

Definition at line 2326 of file gifformat.c.

{
    GifEncoder *This = impl_from_IWICBitmapEncoder(iface);
    HRESULT hr;
 
    TRACE("%p\n", iface);
 
    EnterCriticalSection(&This->lock);
 
    if (This->initialized && !This->committed)
    {
        char gif_trailer = 0x3b;
 
        /* FIXME: write text, comment GIF extensions */
 
        hr = IStream_Write(This->stream, &gif_trailer, sizeof(gif_trailer), NULL);
        if (hr == S_OK)
            This->committed = TRUE;
    }
    else
        hr = WINCODEC_ERR_WRONGSTATE;
 
    LeaveCriticalSection(&This->lock);
    return hr;
}

GifEncoder_CreateInstance()

HRESULT GifEncoder_CreateInstance	(	REFIID	iid,
		void **	ppv
	)

Definition at line 2375 of file gifformat.c.

{
    GifEncoder *This;
    HRESULT ret;
 
    TRACE("%s,%p\n", debugstr_guid(iid), ppv);
 
    *ppv = NULL;
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
    if (!This) return E_OUTOFMEMORY;
 
    This->IWICBitmapEncoder_iface.lpVtbl = &GifEncoder_Vtbl;
    This->ref = 1;
    This->stream = NULL;
    InitializeCriticalSection(&This->lock);
    This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": GifEncoder.lock");
    This->initialized = FALSE;
    This->info_written = FALSE;
    This->committed = FALSE;
    This->n_frames = 0;
    This->colors = 0;
 
    ret = IWICBitmapEncoder_QueryInterface(&This->IWICBitmapEncoder_iface, iid, ppv);
    IWICBitmapEncoder_Release(&This->IWICBitmapEncoder_iface);
 
    return ret;
}

GifEncoder_CreateNewFrame()

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

static

Definition at line 2268 of file gifformat.c.

{
    GifEncoder *This = impl_from_IWICBitmapEncoder(iface);
    HRESULT hr;
 
    TRACE("%p,%p,%p\n", iface, frame, options);
 
    if (!frame) return E_INVALIDARG;
 
    EnterCriticalSection(&This->lock);
 
    if (This->initialized && !This->committed)
    {
        GifFrameEncode *ret = HeapAlloc(GetProcessHeap(), 0, sizeof(*ret));
        if (ret)
        {
            This->n_frames++;
 
            ret->IWICBitmapFrameEncode_iface.lpVtbl = &GifFrameEncode_Vtbl;
            ret->ref = 1;
            ret->encoder = This;
            ret->initialized = FALSE;
            ret->interlace = FALSE; /* FIXME: read from the properties */
            ret->committed = FALSE;
            ret->width = 0;
            ret->height = 0;
            ret->lines = 0;
            ret->xres = 0.0;
            ret->yres = 0.0;
            ret->colors = 0;
            ret->image_data = NULL;
            IWICBitmapEncoder_AddRef(iface);
            *frame = &ret->IWICBitmapFrameEncode_iface;
 
            hr = S_OK;
 
            if (options)
            {
                hr = CreatePropertyBag2(NULL, 0, options);
                if (hr != S_OK)
                {
                    IWICBitmapFrameEncode_Release(*frame);
                    *frame = NULL;
                }
            }
        }
        else
            hr = E_OUTOFMEMORY;
    }
    else
        hr = WINCODEC_ERR_WRONGSTATE;
 
    LeaveCriticalSection(&This->lock);
 
    return hr;
 
}

GifEncoder_GetContainerFormat()

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

static

Definition at line 2204 of file gifformat.c.

{
    if (!format) return E_INVALIDARG;
 
    *format = GUID_ContainerFormatGif;
    return S_OK;
}

GifEncoder_GetEncoderInfo()

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

static

Definition at line 2212 of file gifformat.c.

{
    IWICComponentInfo *comp_info;
    HRESULT hr;
 
    TRACE("%p,%p\n", iface, info);
 
    if (!info) return E_INVALIDARG;
 
    hr = CreateComponentInfo(&CLSID_WICGifEncoder, &comp_info);
    if (hr == S_OK)
    {
        hr = IWICComponentInfo_QueryInterface(comp_info, &IID_IWICBitmapEncoderInfo, (void **)info);
        IWICComponentInfo_Release(comp_info);
    }
    return hr;
}

GifEncoder_GetMetadataQueryWriter()

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

static

Definition at line 2352 of file gifformat.c.

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

GifEncoder_Initialize()

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

static

Definition at line 2178 of file gifformat.c.

{
    GifEncoder *This = impl_from_IWICBitmapEncoder(iface);
    HRESULT hr;
 
    TRACE("%p,%p,%#x\n", iface, stream, option);
 
    if (!stream) return E_INVALIDARG;
 
    EnterCriticalSection(&This->lock);
 
    if (!This->initialized)
    {
        IStream_AddRef(stream);
        This->stream = stream;
        This->initialized = TRUE;
        hr = S_OK;
    }
    else
        hr = WINCODEC_ERR_WRONGSTATE;
 
    LeaveCriticalSection(&This->lock);
 
    return hr;
}

GifEncoder_QueryInterface()

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

static

Definition at line 2133 of file gifformat.c.

{
    TRACE("%p,%s,%p\n", iface, debugstr_guid(iid), ppv);
 
    if (!ppv) return E_INVALIDARG;
 
    if (IsEqualIID(&IID_IUnknown, iid) ||
        IsEqualIID(&IID_IWICBitmapEncoder, iid))
    {
        IWICBitmapEncoder_AddRef(iface);
        *ppv = iface;
        return S_OK;
    }
 
    *ppv = NULL;
    return E_NOINTERFACE;
}

GifEncoder_Release()

static ULONG WINAPI GifEncoder_Release ( IWICBitmapEncoder *  iface )

static

Definition at line 2160 of file gifformat.c.

{
    GifEncoder *This = impl_from_IWICBitmapEncoder(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("%p -> %u\n", iface, ref);
 
    if (!ref)
    {
        if (This->stream) IStream_Release(This->stream);
        This->lock.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&This->lock);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}

GifEncoder_SetColorContexts()

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

static

Definition at line 2230 of file gifformat.c.

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

GifEncoder_SetPalette()

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

static

Definition at line 2236 of file gifformat.c.

{
    GifEncoder *This = impl_from_IWICBitmapEncoder(iface);
    HRESULT hr;
 
    TRACE("%p,%p\n", iface, palette);
 
    if (!palette) return E_INVALIDARG;
 
    EnterCriticalSection(&This->lock);
 
    if (This->initialized)
        hr = IWICPalette_GetColors(palette, 256, This->palette, &This->colors);
    else
        hr = WINCODEC_ERR_NOTINITIALIZED;
 
    LeaveCriticalSection(&This->lock);
    return hr;
}

GifEncoder_SetPreview()

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

static

Definition at line 2262 of file gifformat.c.

{
    TRACE("%p,%p\n", iface, preview);
    return WINCODEC_ERR_UNSUPPORTEDOPERATION;
}

GifEncoder_SetThumbnail()

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

static

Definition at line 2256 of file gifformat.c.

{
    TRACE("%p,%p\n", iface, thumbnail);
    return WINCODEC_ERR_UNSUPPORTEDOPERATION;
}

GifFrameDecode_AddRef()

static ULONG WINAPI GifFrameDecode_AddRef ( IWICBitmapFrameDecode *  iface )

static

Definition at line 650 of file gifformat.c.

{
    GifFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p) refcount=%u\n", iface, ref);
 
    return ref;
}

GifFrameDecode_Block_AddRef()

static ULONG WINAPI GifFrameDecode_Block_AddRef ( IWICMetadataBlockReader *  iface )

static

Definition at line 868 of file gifformat.c.

{
    GifFrameDecode *This = frame_from_IWICMetadataBlockReader(iface);
    return IWICBitmapFrameDecode_AddRef(&This->IWICBitmapFrameDecode_iface);
}

GifFrameDecode_Block_GetContainerFormat()

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

static

Definition at line 880 of file gifformat.c.

{
    TRACE("(%p,%p)\n", iface, guid);
 
    if (!guid) return E_INVALIDARG;
 
    *guid = GUID_ContainerFormatGif;
    return S_OK;
}

GifFrameDecode_Block_GetCount()

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

static

Definition at line 891 of file gifformat.c.

{
    GifFrameDecode *This = frame_from_IWICMetadataBlockReader(iface);
 
    TRACE("%p,%p\n", iface, count);
 
    if (!count) return E_INVALIDARG;
 
    *count = This->frame->Extensions.ExtensionBlockCount + 1;
    return S_OK;
}

GifFrameDecode_Block_GetEnumerator()

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

static

Definition at line 1004 of file gifformat.c.

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

GifFrameDecode_Block_GetReaderByIndex()

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

static

Definition at line 952 of file gifformat.c.

{
    GifFrameDecode *This = frame_from_IWICMetadataBlockReader(iface);
    int i, gce_index = -1, gce_skipped = 0;
 
    TRACE("(%p,%u,%p)\n", iface, index, reader);
 
    if (!reader) return E_INVALIDARG;
 
    if (index == 0)
        return create_IMD_metadata_reader(This, reader);
 
    if (index >= This->frame->Extensions.ExtensionBlockCount + 1)
        return E_INVALIDARG;
 
    for (i = 0; i < This->frame->Extensions.ExtensionBlockCount; i++)
    {
        class_constructor constructor;
        const void *data;
        int data_size;
 
        if (index != i + 1 - gce_skipped) continue;
 
        if (This->frame->Extensions.ExtensionBlocks[i].Function == GRAPHICS_EXT_FUNC_CODE)
        {
            gce_index = i;
            gce_skipped = 1;
            continue;
        }
        else if (This->frame->Extensions.ExtensionBlocks[i].Function == COMMENT_EXT_FUNC_CODE)
        {
            constructor = GifCommentReader_CreateInstance;
            data = This->frame->Extensions.ExtensionBlocks[i].Bytes;
            data_size = This->frame->Extensions.ExtensionBlocks[i].ByteCount;
        }
        else
        {
            constructor = UnknownMetadataReader_CreateInstance;
            data = This->frame->Extensions.ExtensionBlocks[i].Bytes;
            data_size = This->frame->Extensions.ExtensionBlocks[i].ByteCount;
        }
        return create_metadata_reader(data, data_size, constructor, reader);
    }
 
    if (gce_index == -1) return E_INVALIDARG;
 
    return create_metadata_reader(This->frame->Extensions.ExtensionBlocks[gce_index].Bytes + 3,
                                  This->frame->Extensions.ExtensionBlocks[gce_index].ByteCount - 4,
                                  GCEReader_CreateInstance, reader);
}

GifFrameDecode_Block_QueryInterface()

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

static

Definition at line 861 of file gifformat.c.

{
    GifFrameDecode *This = frame_from_IWICMetadataBlockReader(iface);
    return IWICBitmapFrameDecode_QueryInterface(&This->IWICBitmapFrameDecode_iface, iid, ppv);
}

GifFrameDecode_Block_Release()

static ULONG WINAPI GifFrameDecode_Block_Release ( IWICMetadataBlockReader *  iface )

static

Definition at line 874 of file gifformat.c.

{
    GifFrameDecode *This = frame_from_IWICMetadataBlockReader(iface);
    return IWICBitmapFrameDecode_Release(&This->IWICBitmapFrameDecode_iface);
}

GifFrameDecode_CopyPalette()

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

static

Definition at line 710 of file gifformat.c.

{
    GifFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
    WICColor colors[256];
    ColorMapObject *cm = This->frame->ImageDesc.ColorMap;
    int i, trans;
    ExtensionBlock *eb;
    TRACE("(%p,%p)\n", iface, pIPalette);
 
    if (!cm) cm = This->parent->gif->SColorMap;
 
    if (cm->ColorCount > 256)
    {
        ERR("GIF contains %i colors???\n", cm->ColorCount);
        return E_FAIL;
    }
 
    for (i = 0; i < cm->ColorCount; i++) {
        colors[i] = 0xff000000| /* alpha */
                    cm->Colors[i].Red << 16|
                    cm->Colors[i].Green << 8|
                    cm->Colors[i].Blue;
    }
 
    /* look for the transparent color extension */
    for (i = 0; i < This->frame->Extensions.ExtensionBlockCount; ++i) {
    eb = This->frame->Extensions.ExtensionBlocks + i;
    if (eb->Function == GRAPHICS_EXT_FUNC_CODE && eb->ByteCount == 8) {
        if (eb->Bytes[3] & 1) {
            trans = (unsigned char)eb->Bytes[6];
            colors[trans] &= 0xffffff; /* set alpha to 0 */
            break;
        }
    }
    }
 
    return IWICPalette_InitializeCustom(pIPalette, colors, cm->ColorCount);
}

GifFrameDecode_CopyPixels()

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

static

Definition at line 800 of file gifformat.c.

{
    GifFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
    TRACE("(%p,%s,%u,%u,%p)\n", iface, debug_wic_rect(prc), cbStride, cbBufferSize, pbBuffer);
 
    if (This->frame->ImageDesc.Interlace)
    {
        return copy_interlaced_pixels(This->frame->RasterBits, This->frame->ImageDesc.Width,
            This->frame->ImageDesc.Height, This->frame->ImageDesc.Width,
            prc, cbStride, cbBufferSize, pbBuffer);
    }
    else
    {
        return copy_pixels(8, This->frame->RasterBits, This->frame->ImageDesc.Width,
            This->frame->ImageDesc.Height, This->frame->ImageDesc.Width,
            prc, cbStride, cbBufferSize, pbBuffer);
    }
}

GifFrameDecode_GetColorContexts()

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

static

Definition at line 833 of file gifformat.c.

{
    TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
    return WINCODEC_ERR_UNSUPPORTEDOPERATION;
}

GifFrameDecode_GetMetadataQueryReader()

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

static

Definition at line 820 of file gifformat.c.

{
    GifFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 
    TRACE("(%p,%p)\n", iface, ppIMetadataQueryReader);
 
    if (!ppIMetadataQueryReader)
        return E_INVALIDARG;
 
    return MetadataQueryReader_CreateInstance(&This->IWICMetadataBlockReader_iface, NULL, ppIMetadataQueryReader);
}

GifFrameDecode_GetPixelFormat()

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

static

Definition at line 688 of file gifformat.c.

{
    memcpy(pPixelFormat, &GUID_WICPixelFormat8bppIndexed, sizeof(GUID));
 
    return S_OK;
}

GifFrameDecode_GetResolution()

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

static

Definition at line 696 of file gifformat.c.

{
    GifFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
    const GifWord aspect_word = This->parent->gif->SAspectRatio;
    const double aspect = (aspect_word > 0) ? ((aspect_word + 15.0) / 64.0) : 1.0;
    TRACE("(%p,%p,%p)\n", iface, pDpiX, pDpiY);
 
    *pDpiX = 96.0 / aspect;
    *pDpiY = 96.0;
 
    return S_OK;
}

GifFrameDecode_GetSize()

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

static

Definition at line 676 of file gifformat.c.

{
    GifFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
    TRACE("(%p,%p,%p)\n", iface, puiWidth, puiHeight);
 
    *puiWidth = This->frame->ImageDesc.Width;
    *puiHeight = This->frame->ImageDesc.Height;
 
    return S_OK;
}

GifFrameDecode_GetThumbnail()

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

static

Definition at line 840 of file gifformat.c.

{
    TRACE("(%p,%p)\n", iface, ppIThumbnail);
    return WINCODEC_ERR_CODECNOTHUMBNAIL;
}

GifFrameDecode_QueryInterface()

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

static

Definition at line 622 of file gifformat.c.

{
    GifFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
    TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 
    if (!ppv) return E_INVALIDARG;
 
    if (IsEqualIID(&IID_IUnknown, iid) ||
        IsEqualIID(&IID_IWICBitmapSource, iid) ||
        IsEqualIID(&IID_IWICBitmapFrameDecode, iid))
    {
        *ppv = &This->IWICBitmapFrameDecode_iface;
    }
    else if (IsEqualIID(&IID_IWICMetadataBlockReader, iid))
    {
        *ppv = &This->IWICMetadataBlockReader_iface;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

GifFrameDecode_Release()

static ULONG WINAPI GifFrameDecode_Release ( IWICBitmapFrameDecode *  iface )

static

Definition at line 660 of file gifformat.c.

{
    GifFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p) refcount=%u\n", iface, ref);
 
    if (ref == 0)
    {
        IWICBitmapDecoder_Release(&This->parent->IWICBitmapDecoder_iface);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}

GifFrameEncode_AddRef()

static ULONG WINAPI GifFrameEncode_AddRef ( IWICBitmapFrameEncode *  iface )

static

Definition at line 1515 of file gifformat.c.

{
    GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("%p -> %u\n", iface, ref);
    return ref;
}

GifFrameEncode_Commit()

static HRESULT WINAPI GifFrameEncode_Commit ( IWICBitmapFrameEncode *  iface )

static

Definition at line 2004 of file gifformat.c.

{
    GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
    HRESULT hr;
 
    TRACE("%p\n", iface);
 
    EnterCriticalSection(&This->encoder->lock);
 
    if (This->image_data && This->lines == This->height && !This->committed)
    {
        BYTE gif_palette[256][3];
 
        hr = S_OK;
 
        if (!This->encoder->info_written)
        {
            struct logical_screen_descriptor lsd;
 
            /* Logical Screen Descriptor */
            memcpy(lsd.signature, "GIF89a", 6);
            lsd.width = This->width;
            lsd.height = This->height;
            lsd.packed = 0;
            if (This->encoder->colors)
                lsd.packed |= 0x80; /* global color table flag */
            lsd.packed |= 0x07 << 4; /* color resolution */
            lsd.packed |= 0x07; /* global color table size */
            lsd.background_color_index = 0; /* FIXME */
            lsd.pixel_aspect_ratio = 0;
            hr = IStream_Write(This->encoder->stream, &lsd, sizeof(lsd), NULL);
            if (hr == S_OK && This->encoder->colors)
            {
                UINT i;
 
                /* Global Color Table */
                memset(gif_palette, 0, sizeof(gif_palette));
                for (i = 0; i < This->encoder->colors; i++)
                {
                    gif_palette[i][0] = (This->encoder->palette[i] >> 16) & 0xff;
                    gif_palette[i][1] = (This->encoder->palette[i] >> 8) & 0xff;
                    gif_palette[i][2] = This->encoder->palette[i] & 0xff;
                }
                hr = IStream_Write(This->encoder->stream, gif_palette, sizeof(gif_palette), NULL);
            }
 
            /* FIXME: write GCE, APE, etc. GIF extensions */
 
            if (hr == S_OK)
                This->encoder->info_written = TRUE;
        }
 
        if (hr == S_OK)
        {
            char image_separator = 0x2c;
 
            hr = IStream_Write(This->encoder->stream, &image_separator, sizeof(image_separator), NULL);
            if (hr == S_OK)
            {
                struct image_descriptor imd;
 
                /* Image Descriptor */
                imd.left = 0;
                imd.top = 0;
                imd.width = This->width;
                imd.height = This->height;
                imd.packed = 0;
                if (This->colors)
                {
                    imd.packed |= 0x80; /* local color table flag */
                    imd.packed |= 0x07; /* local color table size */
                }
                /* FIXME: interlace flag */
                hr = IStream_Write(This->encoder->stream, &imd, sizeof(imd), NULL);
                if (hr == S_OK && This->colors)
                {
                    UINT i;
 
                    /* Local Color Table */
                    memset(gif_palette, 0, sizeof(gif_palette));
                    for (i = 0; i < This->colors; i++)
                    {
                        gif_palette[i][0] = (This->palette[i] >> 16) & 0xff;
                        gif_palette[i][1] = (This->palette[i] >> 8) & 0xff;
                        gif_palette[i][2] = This->palette[i] & 0xff;
                    }
                    hr = IStream_Write(This->encoder->stream, gif_palette, sizeof(gif_palette), NULL);
                    if (hr == S_OK)
                    {
                        /* Image Data */
                        hr = gif_compress(This->encoder->stream, This->image_data, This->width * This->height);
                        if (hr == S_OK)
                            This->committed = TRUE;
                    }
                }
            }
        }
    }
    else
        hr = WINCODEC_ERR_WRONGSTATE;
 
    LeaveCriticalSection(&This->encoder->lock);
    return hr;
}

GifFrameEncode_GetMetadataQueryWriter()

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

static

Definition at line 2109 of file gifformat.c.

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

GifFrameEncode_Initialize()

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

static

Definition at line 1541 of file gifformat.c.

{
    GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
    HRESULT hr;
 
    TRACE("%p,%p\n", iface, options);
 
    EnterCriticalSection(&This->encoder->lock);
 
    if (!This->initialized)
    {
        This->initialized = TRUE;
        hr = S_OK;
    }
    else
        hr = WINCODEC_ERR_WRONGSTATE;
 
    LeaveCriticalSection(&This->encoder->lock);
 
    return hr;
}

GifFrameEncode_QueryInterface()

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

static

Definition at line 1497 of file gifformat.c.

{
    TRACE("%p,%s,%p\n", iface, debugstr_guid(iid), ppv);
 
    if (!ppv) return E_INVALIDARG;
 
    if (IsEqualIID(&IID_IUnknown, iid) ||
        IsEqualIID(&IID_IWICBitmapFrameEncode, iid))
    {
        IWICBitmapFrameEncode_AddRef(iface);
        *ppv = iface;
        return S_OK;
    }
 
    *ppv = NULL;
    return E_NOINTERFACE;
}

GifFrameEncode_Release()

static ULONG WINAPI GifFrameEncode_Release ( IWICBitmapFrameEncode *  iface )

static

Definition at line 1524 of file gifformat.c.

{
    GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("%p -> %u\n", iface, ref);
 
    if (!ref)
    {
        IWICBitmapEncoder_Release(&This->encoder->IWICBitmapEncoder_iface);
        HeapFree(GetProcessHeap(), 0, This->image_data);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}

GifFrameEncode_SetColorContexts()

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

static

Definition at line 1643 of file gifformat.c.

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

GifFrameEncode_SetPalette()

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

static

Definition at line 1649 of file gifformat.c.

{
    GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
    HRESULT hr;
 
    TRACE("%p,%p\n", iface, palette);
 
    if (!palette) return E_INVALIDARG;
 
    EnterCriticalSection(&This->encoder->lock);
 
    if (This->initialized)
        hr = IWICPalette_GetColors(palette, 256, This->palette, &This->colors);
    else
        hr = WINCODEC_ERR_NOTINITIALIZED;
 
    LeaveCriticalSection(&This->encoder->lock);
    return hr;
}

GifFrameEncode_SetPixelFormat()

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

static

Definition at line 1619 of file gifformat.c.

{
    GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
    HRESULT hr;
 
    TRACE("%p,%s\n", iface, debugstr_guid(format));
 
    if (!format) return E_INVALIDARG;
 
    EnterCriticalSection(&This->encoder->lock);
 
    if (This->initialized)
    {
        *format = GUID_WICPixelFormat8bppIndexed;
        hr = S_OK;
    }
    else
        hr = WINCODEC_ERR_WRONGSTATE;
 
    LeaveCriticalSection(&This->encoder->lock);
 
    return hr;
}

GifFrameEncode_SetResolution()

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

static

Definition at line 1596 of file gifformat.c.

{
    GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
    HRESULT hr;
 
    TRACE("%p,%f,%f\n", iface, xres, yres);
 
    EnterCriticalSection(&This->encoder->lock);
 
    if (This->initialized)
    {
        This->xres = xres;
        This->yres = yres;
        hr = S_OK;
    }
    else
        hr = WINCODEC_ERR_WRONGSTATE;
 
    LeaveCriticalSection(&This->encoder->lock);
 
    return hr;
}

GifFrameEncode_SetSize()

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

static

Definition at line 1563 of file gifformat.c.

{
    GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
    HRESULT hr;
 
    TRACE("%p,%u,%u\n", iface, width, height);
 
    if (!width || !height) return E_INVALIDARG;
 
    EnterCriticalSection(&This->encoder->lock);
 
    if (This->initialized)
    {
        HeapFree(GetProcessHeap(), 0, This->image_data);
 
        This->image_data = HeapAlloc(GetProcessHeap(), 0, width * height);
        if (This->image_data)
        {
            This->width = width;
            This->height = height;
            hr = S_OK;
        }
        else
            hr = E_OUTOFMEMORY;
    }
    else
        hr = WINCODEC_ERR_WRONGSTATE;
 
    LeaveCriticalSection(&This->encoder->lock);
 
    return hr;
}

GifFrameEncode_SetThumbnail()

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

static

Definition at line 1669 of file gifformat.c.

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

GifFrameEncode_WritePixels()

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

static

Definition at line 1675 of file gifformat.c.

{
    GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
    HRESULT hr;
 
    TRACE("%p,%u,%u,%u,%p\n", iface, lines, stride, size, pixels);
 
    if (!pixels) return E_INVALIDARG;
 
    EnterCriticalSection(&This->encoder->lock);
 
    if (This->initialized && This->image_data)
    {
        if (This->lines + lines <= This->height)
        {
            UINT i;
            BYTE *src, *dst;
 
            src = pixels;
            dst = This->image_data + This->lines * This->width;
 
            for (i = 0; i < lines; i++)
            {
                memcpy(dst, src, This->width);
                src += stride;
                dst += This->width;
            }
 
            This->lines += lines;
            hr = S_OK;
        }
        else
            hr = E_INVALIDARG;
    }
    else
        hr = WINCODEC_ERR_WRONGSTATE;
 
    LeaveCriticalSection(&This->encoder->lock);
    return hr;
}

GifFrameEncode_WriteSource()

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

static

Definition at line 1716 of file gifformat.c.

{
    GifFrameEncode *This = impl_from_IWICBitmapFrameEncode(iface);
    HRESULT hr;
 
    TRACE("%p,%p,%p\n", iface, source, rc);
 
    if (!source) return E_INVALIDARG;
 
    EnterCriticalSection(&This->encoder->lock);
 
    if (This->initialized)
    {
        const GUID *format = &GUID_WICPixelFormat8bppIndexed;
 
        hr = configure_write_source(iface, source, rc, format,
                                    This->width, This->height, This->xres, This->yres);
        if (hr == S_OK)
            hr = write_source(iface, source, rc, format, 8, This->width, This->height);
    }
    else
        hr = WINCODEC_ERR_WRONGSTATE;
 
    LeaveCriticalSection(&This->encoder->lock);
    return hr;
}

IMDReader_CreateInstance()

HRESULT IMDReader_CreateInstance	(	REFIID	iid,
		void **	ppv
	)

Definition at line 249 of file gifformat.c.

{
    return MetadataReader_Create(&IMDReader_Vtbl, iid, ppv);
}

Referenced by create_IMD_metadata_reader().

impl_from_IWICBitmapDecoder()

static GifDecoder * impl_from_IWICBitmapDecoder ( IWICBitmapDecoder *  iface )

inlinestatic

Definition at line 602 of file gifformat.c.

{
    return CONTAINING_RECORD(iface, GifDecoder, IWICBitmapDecoder_iface);
}

Referenced by GifDecoder_AddRef(), GifDecoder_CopyPalette(), GifDecoder_GetFrame(), GifDecoder_GetFrameCount(), GifDecoder_GetMetadataQueryReader(), GifDecoder_Initialize(), GifDecoder_QueryInterface(), and GifDecoder_Release().

impl_from_IWICBitmapEncoder()

static GifEncoder * impl_from_IWICBitmapEncoder ( IWICBitmapEncoder *  iface )

inlinestatic

Definition at line 1474 of file gifformat.c.

{
    return CONTAINING_RECORD(iface, GifEncoder, IWICBitmapEncoder_iface);
}

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

impl_from_IWICBitmapFrameDecode()

static GifFrameDecode * impl_from_IWICBitmapFrameDecode ( IWICBitmapFrameDecode *  iface )

inlinestatic

Definition at line 612 of file gifformat.c.

{
    return CONTAINING_RECORD(iface, GifFrameDecode, IWICBitmapFrameDecode_iface);
}

Referenced by GifFrameDecode_AddRef(), GifFrameDecode_CopyPalette(), GifFrameDecode_CopyPixels(), GifFrameDecode_GetMetadataQueryReader(), GifFrameDecode_GetResolution(), GifFrameDecode_GetSize(), GifFrameDecode_QueryInterface(), and GifFrameDecode_Release().

impl_from_IWICBitmapFrameEncode()

static GifFrameEncode * impl_from_IWICBitmapFrameEncode ( IWICBitmapFrameEncode *  iface )

inlinestatic

Definition at line 1492 of file gifformat.c.

{
    return CONTAINING_RECORD(iface, GifFrameEncode, IWICBitmapFrameEncode_iface);
}

Referenced by GifFrameEncode_AddRef(), GifFrameEncode_Commit(), GifFrameEncode_Initialize(), GifFrameEncode_Release(), GifFrameEncode_SetPalette(), GifFrameEncode_SetPixelFormat(), GifFrameEncode_SetResolution(), GifFrameEncode_SetSize(), GifFrameEncode_WritePixels(), and GifFrameEncode_WriteSource().

impl_from_IWICMetadataBlockReader()

static GifDecoder * impl_from_IWICMetadataBlockReader ( IWICMetadataBlockReader *  iface )

inlinestatic

Definition at line 607 of file gifformat.c.

{
    return CONTAINING_RECORD(iface, GifDecoder, IWICMetadataBlockReader_iface);
}

Referenced by GifDecoder_Block_AddRef(), GifDecoder_Block_GetCount(), GifDecoder_Block_GetReaderByIndex(), GifDecoder_Block_QueryInterface(), and GifDecoder_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 332 of file gifformat.c.

{
#include "pshpack1.h"
    struct application_extension
    {
        BYTE extension_introducer;
        BYTE extension_label;
        BYTE block_size;
        BYTE application[11];
    } ape_data;
#include "poppack.h"
    HRESULT hr;
    ULONG bytesread, data_size, i;
    MetadataItem *result;
    BYTE subblock_size;
    BYTE *data;
 
    *items = NULL;
    *count = 0;
 
    hr = IStream_Read(stream, &ape_data, sizeof(ape_data), &bytesread);
    if (FAILED(hr) || bytesread != sizeof(ape_data)) return S_OK;
    if (ape_data.extension_introducer != 0x21 ||
        ape_data.extension_label != APPLICATION_EXT_FUNC_CODE ||
        ape_data.block_size != 11)
        return S_OK;
 
    data = NULL;
    data_size = 0;
 
    for (;;)
    {
        hr = IStream_Read(stream, &subblock_size, sizeof(subblock_size), &bytesread);
        if (FAILED(hr) || bytesread != sizeof(subblock_size))
        {
            HeapFree(GetProcessHeap(), 0, data);
            return S_OK;
        }
        if (!subblock_size) break;
 
        if (!data)
            data = HeapAlloc(GetProcessHeap(), 0, subblock_size + 1);
        else
        {
            BYTE *new_data = HeapReAlloc(GetProcessHeap(), 0, data, data_size + subblock_size + 1);
            if (!new_data)
            {
                HeapFree(GetProcessHeap(), 0, data);
                return S_OK;
            }
            data = new_data;
        }
        data[data_size] = subblock_size;
        hr = IStream_Read(stream, data + data_size + 1, subblock_size, &bytesread);
        if (FAILED(hr) || bytesread != subblock_size)
        {
            HeapFree(GetProcessHeap(), 0, data);
            return S_OK;
        }
        data_size += subblock_size + 1;
    }
 
    result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem) * 2);
    if (!result)
    {
        HeapFree(GetProcessHeap(), 0, data);
        return E_OUTOFMEMORY;
    }
 
    for (i = 0; i < 2; i++)
    {
        PropVariantInit(&result[i].schema);
        PropVariantInit(&result[i].id);
        PropVariantInit(&result[i].value);
    }
 
    result[0].id.vt = VT_LPWSTR;
    result[0].id.u.pwszVal = strdupAtoW("Application");
    result[0].value.vt = VT_UI1|VT_VECTOR;
    result[0].value.u.caub.cElems = sizeof(ape_data.application);
    result[0].value.u.caub.pElems = HeapAlloc(GetProcessHeap(), 0, sizeof(ape_data.application));
    memcpy(result[0].value.u.caub.pElems, ape_data.application, sizeof(ape_data.application));
 
    result[1].id.vt = VT_LPWSTR;
    result[1].id.u.pwszVal = strdupAtoW("Data");
    result[1].value.vt = VT_UI1|VT_VECTOR;
    result[1].value.u.caub.cElems = data_size;
    result[1].value.u.caub.pElems = data;
 
    *items = result;
    *count = 2;
 
    return S_OK;
}

load_GCE_metadata()

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

static

Definition at line 254 of file gifformat.c.

{
#include "pshpack1.h"
    struct graphic_control_extension
    {
        BYTE packed;
        /* reservred: 3;
         * disposal : 3;
         * user_input_flag : 1;
         * transparency_flag : 1;
         */
         USHORT delay;
         BYTE transparent_color_index;
    } gce_data;
#include "poppack.h"
    HRESULT hr;
    ULONG bytesread, i;
    MetadataItem *result;
 
    *items = NULL;
    *count = 0;
 
    hr = IStream_Read(stream, &gce_data, sizeof(gce_data), &bytesread);
    if (FAILED(hr) || bytesread != sizeof(gce_data)) return S_OK;
 
    result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem) * 5);
    if (!result) return E_OUTOFMEMORY;
 
    for (i = 0; i < 5; i++)
    {
        PropVariantInit(&result[i].schema);
        PropVariantInit(&result[i].id);
        PropVariantInit(&result[i].value);
    }
 
    result[0].id.vt = VT_LPWSTR;
    result[0].id.u.pwszVal = strdupAtoW("Disposal");
    result[0].value.vt = VT_UI1;
    result[0].value.u.bVal = (gce_data.packed >> 2) & 7;
 
    result[1].id.vt = VT_LPWSTR;
    result[1].id.u.pwszVal = strdupAtoW("UserInputFlag");
    result[1].value.vt = VT_BOOL;
    result[1].value.u.boolVal = (gce_data.packed >> 1) & 1;
 
    result[2].id.vt = VT_LPWSTR;
    result[2].id.u.pwszVal = strdupAtoW("TransparencyFlag");
    result[2].value.vt = VT_BOOL;
    result[2].value.u.boolVal = gce_data.packed & 1;
 
    result[3].id.vt = VT_LPWSTR;
    result[3].id.u.pwszVal = strdupAtoW("Delay");
    result[3].value.vt = VT_UI2;
    result[3].value.u.uiVal = gce_data.delay;
 
    result[4].id.vt = VT_LPWSTR;
    result[4].id.u.pwszVal = strdupAtoW("TransparentColorIndex");
    result[4].value.vt = VT_UI1;
    result[4].value.u.bVal = gce_data.transparent_color_index;
 
    *items = result;
    *count = 5;
 
    return S_OK;
}

load_GifComment_metadata()

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

static

Definition at line 439 of file gifformat.c.

{
#include "pshpack1.h"
    struct gif_extension
    {
        BYTE extension_introducer;
        BYTE extension_label;
    } ext_data;
#include "poppack.h"
    HRESULT hr;
    ULONG bytesread, data_size;
    MetadataItem *result;
    BYTE subblock_size;
    char *data;
 
    *items = NULL;
    *count = 0;
 
    hr = IStream_Read(stream, &ext_data, sizeof(ext_data), &bytesread);
    if (FAILED(hr) || bytesread != sizeof(ext_data)) return S_OK;
    if (ext_data.extension_introducer != 0x21 ||
        ext_data.extension_label != COMMENT_EXT_FUNC_CODE)
        return S_OK;
 
    data = NULL;
    data_size = 0;
 
    for (;;)
    {
        hr = IStream_Read(stream, &subblock_size, sizeof(subblock_size), &bytesread);
        if (FAILED(hr) || bytesread != sizeof(subblock_size))
        {
            HeapFree(GetProcessHeap(), 0, data);
            return S_OK;
        }
        if (!subblock_size) break;
 
        if (!data)
            data = HeapAlloc(GetProcessHeap(), 0, subblock_size + 1);
        else
        {
            char *new_data = HeapReAlloc(GetProcessHeap(), 0, data, data_size + subblock_size + 1);
            if (!new_data)
            {
                HeapFree(GetProcessHeap(), 0, data);
                return S_OK;
            }
            data = new_data;
        }
        hr = IStream_Read(stream, data + data_size, subblock_size, &bytesread);
        if (FAILED(hr) || bytesread != subblock_size)
        {
            HeapFree(GetProcessHeap(), 0, data);
            return S_OK;
        }
        data_size += subblock_size;
    }
 
    data[data_size] = 0;
 
    result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem));
    if (!result)
    {
        HeapFree(GetProcessHeap(), 0, data);
        return E_OUTOFMEMORY;
    }
 
    PropVariantInit(&result->schema);
    PropVariantInit(&result->id);
    PropVariantInit(&result->value);
 
    result->id.vt = VT_LPWSTR;
    result->id.u.pwszVal = strdupAtoW("TextEntry");
    result->value.vt = VT_LPSTR;
    result->value.u.pszVal = data;
 
    *items = result;
    *count = 1;
 
    return S_OK;
}

load_IMD_metadata()

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

static

Definition at line 173 of file gifformat.c.

{
    struct image_descriptor imd_data;
    HRESULT hr;
    ULONG bytesread, i;
    MetadataItem *result;
 
    *items = NULL;
    *count = 0;
 
    hr = IStream_Read(stream, &imd_data, sizeof(imd_data), &bytesread);
    if (FAILED(hr) || bytesread != sizeof(imd_data)) return S_OK;
 
    result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem) * 8);
    if (!result) return E_OUTOFMEMORY;
 
    for (i = 0; i < 8; i++)
    {
        PropVariantInit(&result[i].schema);
        PropVariantInit(&result[i].id);
        PropVariantInit(&result[i].value);
    }
 
    result[0].id.vt = VT_LPWSTR;
    result[0].id.u.pwszVal = strdupAtoW("Left");
    result[0].value.vt = VT_UI2;
    result[0].value.u.uiVal = imd_data.left;
 
    result[1].id.vt = VT_LPWSTR;
    result[1].id.u.pwszVal = strdupAtoW("Top");
    result[1].value.vt = VT_UI2;
    result[1].value.u.uiVal = imd_data.top;
 
    result[2].id.vt = VT_LPWSTR;
    result[2].id.u.pwszVal = strdupAtoW("Width");
    result[2].value.vt = VT_UI2;
    result[2].value.u.uiVal = imd_data.width;
 
    result[3].id.vt = VT_LPWSTR;
    result[3].id.u.pwszVal = strdupAtoW("Height");
    result[3].value.vt = VT_UI2;
    result[3].value.u.uiVal = imd_data.height;
 
    result[4].id.vt = VT_LPWSTR;
    result[4].id.u.pwszVal = strdupAtoW("LocalColorTableFlag");
    result[4].value.vt = VT_BOOL;
    result[4].value.u.boolVal = (imd_data.packed >> 7) & 1;
 
    result[5].id.vt = VT_LPWSTR;
    result[5].id.u.pwszVal = strdupAtoW("InterlaceFlag");
    result[5].value.vt = VT_BOOL;
    result[5].value.u.boolVal = (imd_data.packed >> 6) & 1;
 
    result[6].id.vt = VT_LPWSTR;
    result[6].id.u.pwszVal = strdupAtoW("SortFlag");
    result[6].value.vt = VT_BOOL;
    result[6].value.u.boolVal = (imd_data.packed >> 5) & 1;
 
    result[7].id.vt = VT_LPWSTR;
    result[7].id.u.pwszVal = strdupAtoW("LocalColorTableSize");
    result[7].value.vt = VT_UI1;
    result[7].value.u.bVal = imd_data.packed & 7;
 
    *items = result;
    *count = 8;
 
    return S_OK;
}

load_LSD_metadata()

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

static

Definition at line 85 of file gifformat.c.

{
    struct logical_screen_descriptor lsd_data;
    HRESULT hr;
    ULONG bytesread, i;
    MetadataItem *result;
 
    *items = NULL;
    *count = 0;
 
    hr = IStream_Read(stream, &lsd_data, sizeof(lsd_data), &bytesread);
    if (FAILED(hr) || bytesread != sizeof(lsd_data)) return S_OK;
 
    result = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MetadataItem) * 9);
    if (!result) return E_OUTOFMEMORY;
 
    for (i = 0; i < 9; i++)
    {
        PropVariantInit(&result[i].schema);
        PropVariantInit(&result[i].id);
        PropVariantInit(&result[i].value);
    }
 
    result[0].id.vt = VT_LPWSTR;
    result[0].id.u.pwszVal = strdupAtoW("Signature");
    result[0].value.vt = VT_UI1|VT_VECTOR;
    result[0].value.u.caub.cElems = sizeof(lsd_data.signature);
    result[0].value.u.caub.pElems = HeapAlloc(GetProcessHeap(), 0, sizeof(lsd_data.signature));
    memcpy(result[0].value.u.caub.pElems, lsd_data.signature, sizeof(lsd_data.signature));
 
    result[1].id.vt = VT_LPWSTR;
    result[1].id.u.pwszVal = strdupAtoW("Width");
    result[1].value.vt = VT_UI2;
    result[1].value.u.uiVal = lsd_data.width;
 
    result[2].id.vt = VT_LPWSTR;
    result[2].id.u.pwszVal = strdupAtoW("Height");
    result[2].value.vt = VT_UI2;
    result[2].value.u.uiVal = lsd_data.height;
 
    result[3].id.vt = VT_LPWSTR;
    result[3].id.u.pwszVal = strdupAtoW("GlobalColorTableFlag");
    result[3].value.vt = VT_BOOL;
    result[3].value.u.boolVal = (lsd_data.packed >> 7) & 1;
 
    result[4].id.vt = VT_LPWSTR;
    result[4].id.u.pwszVal = strdupAtoW("ColorResolution");
    result[4].value.vt = VT_UI1;
    result[4].value.u.bVal = (lsd_data.packed >> 4) & 7;
 
    result[5].id.vt = VT_LPWSTR;
    result[5].id.u.pwszVal = strdupAtoW("SortFlag");
    result[5].value.vt = VT_BOOL;
    result[5].value.u.boolVal = (lsd_data.packed >> 3) & 1;
 
    result[6].id.vt = VT_LPWSTR;
    result[6].id.u.pwszVal = strdupAtoW("GlobalColorTableSize");
    result[6].value.vt = VT_UI1;
    result[6].value.u.bVal = lsd_data.packed & 7;
 
    result[7].id.vt = VT_LPWSTR;
    result[7].id.u.pwszVal = strdupAtoW("BackgroundColorIndex");
    result[7].value.vt = VT_UI1;
    result[7].value.u.bVal = lsd_data.background_color_index;
 
    result[8].id.vt = VT_LPWSTR;
    result[8].id.u.pwszVal = strdupAtoW("PixelAspectRatio");
    result[8].value.vt = VT_UI1;
    result[8].value.u.bVal = lsd_data.pixel_aspect_ratio;
 
    *items = result;
    *count = 9;
 
    return S_OK;
}

LSDReader_CreateInstance()

HRESULT LSDReader_CreateInstance	(	REFIID	iid,
		void **	ppv
	)

Definition at line 168 of file gifformat.c.

{
    return MetadataReader_Create(&LSDReader_Vtbl, iid, ppv);
}

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 1859 of file gifformat.c.

{
    if (state->next_code < LZW_DICT_SIZE)
    {
        state->dict.prefix[state->next_code] = prefix;
        state->dict.suffix[state->next_code] = suffix;
 
        if ((state->next_code & (state->next_code - 1)) == 0)
            state->code_bits++;
 
        state->next_code++;
        return state->next_code;
    }
 
    return -1;
}

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 1876 of file gifformat.c.

{
    short i;
 
    for (i = 0; i < state->next_code; i++)
    {
        if (state->dict.prefix[i] == prefix && state->dict.suffix[i] == suffix)
            return i;
    }
 
    return -1;
}

Referenced by gif_compress().

lzw_dict_reset()

static void lzw_dict_reset ( struct lzw_state *  state )

static

Definition at line 1832 of file gifformat.c.

{
    int i;
 
    state->code_bits = state->init_code_bits + 1;
    state->next_code = (1 << state->init_code_bits) + 2;
 
    for(i = 0; i < LZW_DICT_SIZE; i++)
    {
        state->dict.prefix[i] = 1 << 12; /* impossible LZW code value */
        state->dict.suffix[i] = 0;
    }
}

Referenced by gif_compress(), and lzw_state_init().

lzw_flush_bits()

static int lzw_flush_bits ( struct lzw_state *  state )

static

Definition at line 1804 of file gifformat.c.

{
    unsigned char byte;
 
    while (state->bits_count >= 8)
    {
        byte = (unsigned char)state->bits_buf;
        if (state->user_write_data(state->user_ptr, &byte, 1) != 1)
            return 0;
        state->bits_buf >>= 8;
        state->bits_count -= 8;
    }
 
    if (state->bits_count)
    {
        static const char mask[8] = { 0x00,0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f };
 
        byte = (unsigned char)state->bits_buf & mask[state->bits_count];
        if (state->user_write_data(state->user_ptr, &byte, 1) != 1)
            return 0;
    }
 
    state->bits_buf = 0;
    state->bits_count = 0;
 
    return 1;
}

Referenced by gif_compress().

lzw_output_clear_code()

static int lzw_output_clear_code ( struct lzw_state *  state )

inlinestatic

Definition at line 1794 of file gifformat.c.

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

Referenced by gif_compress().

lzw_output_code()

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

static

Definition at line 1777 of file gifformat.c.

{
    state->bits_buf |= code << state->bits_count;
    state->bits_count += state->code_bits;
 
    while (state->bits_count >= 8)
    {
        unsigned char byte = (unsigned char)state->bits_buf;
        if (state->user_write_data(state->user_ptr, &byte, 1) != 1)
            return 0;
        state->bits_buf >>= 8;
        state->bits_count -= 8;
    }
 
    return 1;
}

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 1799 of file gifformat.c.

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

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 1846 of file gifformat.c.

{
    state->init_code_bits = init_code_bits;
    state->clear_code = 1 << init_code_bits;
    state->eof_code = state->clear_code + 1;
    state->bits_buf = 0;
    state->bits_count = 0;
    state->user_write_data = user_write_data;
    state->user_ptr = user_ptr;
 
    lzw_dict_reset(state);
}

Referenced by gif_compress().

read_byte()

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

inlinestatic

Definition at line 1933 of file gifformat.c.

{
    if (in->len)
    {
        in->len--;
        *byte = *in->in++;
        return 1;
    }
 
    return 0;
}

Referenced by gif_compress().

strdupAtoW()

static LPWSTR strdupAtoW ( const char *  src )

static

Definition at line 77 of file gifformat.c.

{
    int len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
    LPWSTR dst = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
    if (dst) MultiByteToWideChar(CP_ACP, 0, src, -1, dst, len);
    return dst;
}

Referenced by load_APE_metadata(), load_GCE_metadata(), load_GifComment_metadata(), load_IMD_metadata(), and load_LSD_metadata().

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 1889 of file gifformat.c.

{
    if (out->gif_block.len == 255)
    {
        if (IStream_Write(out->out, &out->gif_block, sizeof(out->gif_block), NULL) != S_OK)
            return 0;
 
        out->gif_block.len = 0;
    }
 
    out->gif_block.data[out->gif_block.len++] = byte;
 
    return 1;
}

Referenced by write_data().

write_data()

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

static

Definition at line 1904 of file gifformat.c.

{
    unsigned char *data = user_data;
    struct output_stream *out = user_ptr;
    int len = length;
 
    while (len-- > 0)
    {
        if (!write_byte(out, *data++)) return 0;
    }
 
    return length;
}

Variable Documentation

APEReader_Vtbl

const MetadataHandlerVtbl APEReader_Vtbl

static

Initial value:

= {
    0,
    &CLSID_WICAPEMetadataReader,
    load_APE_metadata
}

Definition at line 428 of file gifformat.c.

Referenced by APEReader_CreateInstance().

GCEReader_Vtbl

const MetadataHandlerVtbl GCEReader_Vtbl

static

Initial value:

= {
    0,
    &CLSID_WICGCEMetadataReader,
    load_GCE_metadata
}

Definition at line 321 of file gifformat.c.

Referenced by GCEReader_CreateInstance().

GifCommentReader_Vtbl

const MetadataHandlerVtbl GifCommentReader_Vtbl

static

Initial value:

= {
    0,
    &CLSID_WICGifCommentMetadataReader,
    load_GifComment_metadata
}

Definition at line 522 of file gifformat.c.

Referenced by GifCommentReader_CreateInstance().

GifDecoder_BlockVtbl

const IWICMetadataBlockReaderVtbl GifDecoder_BlockVtbl

static

Initial value:

=
{
    GifDecoder_Block_QueryInterface,
    GifDecoder_Block_AddRef,
    GifDecoder_Block_Release,
    GifDecoder_Block_GetContainerFormat,
    GifDecoder_Block_GetCount,
    GifDecoder_Block_GetReaderByIndex,
    GifDecoder_Block_GetEnumerator
}

Definition at line 1423 of file gifformat.c.

Referenced by GifDecoder_CreateInstance().

GifDecoder_Vtbl

const IWICBitmapDecoderVtbl GifDecoder_Vtbl

static

Initial value:

= {
    GifDecoder_QueryInterface,
    GifDecoder_AddRef,
    GifDecoder_Release,
    GifDecoder_QueryCapability,
    GifDecoder_Initialize,
    GifDecoder_GetContainerFormat,
    GifDecoder_GetDecoderInfo,
    GifDecoder_CopyPalette,
    GifDecoder_GetMetadataQueryReader,
    GifDecoder_GetPreview,
    GifDecoder_GetColorContexts,
    GifDecoder_GetThumbnail,
    GifDecoder_GetFrameCount,
    GifDecoder_GetFrame
}

Definition at line 1321 of file gifformat.c.

Referenced by GifDecoder_CreateInstance().

GifEncoder_Vtbl

const IWICBitmapEncoderVtbl GifEncoder_Vtbl

static

Initial value:

=
{
    GifEncoder_QueryInterface,
    GifEncoder_AddRef,
    GifEncoder_Release,
    GifEncoder_Initialize,
    GifEncoder_GetContainerFormat,
    GifEncoder_GetEncoderInfo,
    GifEncoder_SetColorContexts,
    GifEncoder_SetPalette,
    GifEncoder_SetThumbnail,
    GifEncoder_SetPreview,
    GifEncoder_CreateNewFrame,
    GifEncoder_Commit,
    GifEncoder_GetMetadataQueryWriter
}

Definition at line 2358 of file gifformat.c.

Referenced by GifEncoder_CreateInstance().

GifFrameDecode_BlockVtbl

const IWICMetadataBlockReaderVtbl GifFrameDecode_BlockVtbl

static

Initial value:

=
{
    GifFrameDecode_Block_QueryInterface,
    GifFrameDecode_Block_AddRef,
    GifFrameDecode_Block_Release,
    GifFrameDecode_Block_GetContainerFormat,
    GifFrameDecode_Block_GetCount,
    GifFrameDecode_Block_GetReaderByIndex,
    GifFrameDecode_Block_GetEnumerator
}

Definition at line 1011 of file gifformat.c.

Referenced by GifDecoder_GetFrame().

GifFrameDecode_Vtbl

const IWICBitmapFrameDecodeVtbl GifFrameDecode_Vtbl

static

Initial value:

= {
    GifFrameDecode_QueryInterface,
    GifFrameDecode_AddRef,
    GifFrameDecode_Release,
    GifFrameDecode_GetSize,
    GifFrameDecode_GetPixelFormat,
    GifFrameDecode_GetResolution,
    GifFrameDecode_CopyPalette,
    GifFrameDecode_CopyPixels,
    GifFrameDecode_GetMetadataQueryReader,
    GifFrameDecode_GetColorContexts,
    GifFrameDecode_GetThumbnail
}

Definition at line 847 of file gifformat.c.

Referenced by GifDecoder_GetFrame().

GifFrameEncode_Vtbl

const IWICBitmapFrameEncodeVtbl GifFrameEncode_Vtbl

static

Initial value:

=
{
    GifFrameEncode_QueryInterface,
    GifFrameEncode_AddRef,
    GifFrameEncode_Release,
    GifFrameEncode_Initialize,
    GifFrameEncode_SetSize,
    GifFrameEncode_SetResolution,
    GifFrameEncode_SetPixelFormat,
    GifFrameEncode_SetColorContexts,
    GifFrameEncode_SetPalette,
    GifFrameEncode_SetThumbnail,
    GifFrameEncode_WritePixels,
    GifFrameEncode_WriteSource,
    GifFrameEncode_Commit,
    GifFrameEncode_GetMetadataQueryWriter
}

Definition at line 2115 of file gifformat.c.

Referenced by GifEncoder_CreateNewFrame().

IMDReader_Vtbl

const MetadataHandlerVtbl IMDReader_Vtbl

static

Initial value:

= {
    0,
    &CLSID_WICIMDMetadataReader,
    load_IMD_metadata
}

Definition at line 243 of file gifformat.c.

Referenced by IMDReader_CreateInstance().

LSDReader_Vtbl

const MetadataHandlerVtbl LSDReader_Vtbl

static

Initial value:

= {
    0,
    &CLSID_WICLSDMetadataReader,
    load_LSD_metadata
}

Definition at line 162 of file gifformat.c.

Referenced by LSDReader_CreateInstance().