icoformat.c File Reference

#include "config.h"
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "objbase.h"
#include "wincodecs_private.h"
#include "wine/debug.h"
#include "pshpack1.h"
#include "poppack.h"

Include dependency graph for icoformat.c:

Go to the source code of this file.

Classes
struct	ICONDIRENTRY
struct	ICONHEADER
struct	IcoDecoder
struct	IcoFrameDecode

Macros
#define	COBJMACROS

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (wincodecs)
static IcoDecoder *	impl_from_IWICBitmapDecoder (IWICBitmapDecoder *iface)
static IcoFrameDecode *	impl_from_IWICBitmapFrameDecode (IWICBitmapFrameDecode *iface)
static HRESULT WINAPI	IcoFrameDecode_QueryInterface (IWICBitmapFrameDecode *iface, REFIID iid, void **ppv)
static ULONG WINAPI	IcoFrameDecode_AddRef (IWICBitmapFrameDecode *iface)
static ULONG WINAPI	IcoFrameDecode_Release (IWICBitmapFrameDecode *iface)
static HRESULT WINAPI	IcoFrameDecode_GetSize (IWICBitmapFrameDecode *iface, UINT *puiWidth, UINT *puiHeight)
static HRESULT WINAPI	IcoFrameDecode_GetPixelFormat (IWICBitmapFrameDecode *iface, WICPixelFormatGUID *pPixelFormat)
static HRESULT WINAPI	IcoFrameDecode_GetResolution (IWICBitmapFrameDecode *iface, double *pDpiX, double *pDpiY)
static HRESULT WINAPI	IcoFrameDecode_CopyPalette (IWICBitmapFrameDecode *iface, IWICPalette *pIPalette)
static HRESULT WINAPI	IcoFrameDecode_CopyPixels (IWICBitmapFrameDecode *iface, const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
static HRESULT WINAPI	IcoFrameDecode_GetMetadataQueryReader (IWICBitmapFrameDecode *iface, IWICMetadataQueryReader **ppIMetadataQueryReader)
static HRESULT WINAPI	IcoFrameDecode_GetColorContexts (IWICBitmapFrameDecode *iface, UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
static HRESULT WINAPI	IcoFrameDecode_GetThumbnail (IWICBitmapFrameDecode *iface, IWICBitmapSource **ppIThumbnail)
static void	pixel_set_trans (DWORD *pixel, BOOL transparent)
static HRESULT	ReadIcoDib (IStream *stream, IcoFrameDecode *result)
static HRESULT	ReadIcoPng (IStream *stream, IcoFrameDecode *result)
static HRESULT WINAPI	IcoDecoder_QueryInterface (IWICBitmapDecoder *iface, REFIID iid, void **ppv)
static ULONG WINAPI	IcoDecoder_AddRef (IWICBitmapDecoder *iface)
static ULONG WINAPI	IcoDecoder_Release (IWICBitmapDecoder *iface)
static HRESULT WINAPI	IcoDecoder_QueryCapability (IWICBitmapDecoder *iface, IStream *stream, DWORD *capability)
static HRESULT WINAPI	IcoDecoder_Initialize (IWICBitmapDecoder *iface, IStream *pIStream, WICDecodeOptions cacheOptions)
static HRESULT WINAPI	IcoDecoder_GetContainerFormat (IWICBitmapDecoder *iface, GUID *pguidContainerFormat)
static HRESULT WINAPI	IcoDecoder_GetDecoderInfo (IWICBitmapDecoder *iface, IWICBitmapDecoderInfo **ppIDecoderInfo)
static HRESULT WINAPI	IcoDecoder_CopyPalette (IWICBitmapDecoder *iface, IWICPalette *pIPalette)
static HRESULT WINAPI	IcoDecoder_GetMetadataQueryReader (IWICBitmapDecoder *iface, IWICMetadataQueryReader **ppIMetadataQueryReader)
static HRESULT WINAPI	IcoDecoder_GetPreview (IWICBitmapDecoder *iface, IWICBitmapSource **ppIBitmapSource)
static HRESULT WINAPI	IcoDecoder_GetColorContexts (IWICBitmapDecoder *iface, UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
static HRESULT WINAPI	IcoDecoder_GetThumbnail (IWICBitmapDecoder *iface, IWICBitmapSource **ppIThumbnail)
static HRESULT WINAPI	IcoDecoder_GetFrameCount (IWICBitmapDecoder *iface, UINT *pCount)
static HRESULT WINAPI	IcoDecoder_GetFrame (IWICBitmapDecoder *iface, UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
HRESULT	IcoDecoder_CreateInstance (REFIID iid, void **ppv)

Variables
static const IWICBitmapFrameDecodeVtbl	IcoFrameDecode_Vtbl
static const IWICBitmapDecoderVtbl	IcoDecoder_Vtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 23 of file icoformat.c.

Function Documentation

IcoDecoder_AddRef()

static ULONG WINAPI IcoDecoder_AddRef ( IWICBitmapDecoder *  iface )

static

Definition at line 463 of file icoformat.c.

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

IcoDecoder_CopyPalette()

static HRESULT WINAPI IcoDecoder_CopyPalette ( IWICBitmapDecoder *  iface, IWICPalette *  pIPalette  )

static

Definition at line 594 of file icoformat.c.

{
    TRACE("(%p,%p)\n", iface, pIPalette);
    return WINCODEC_ERR_PALETTEUNAVAILABLE;
}

IcoDecoder_CreateInstance()

HRESULT IcoDecoder_CreateInstance	(	REFIID	iid,
		void **	ppv
	)

Definition at line 759 of file icoformat.c.

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

IcoDecoder_GetColorContexts()

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

static

Definition at line 615 of file icoformat.c.

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

IcoDecoder_GetContainerFormat()

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

static

Definition at line 579 of file icoformat.c.

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

IcoDecoder_GetDecoderInfo()

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

static

Definition at line 586 of file icoformat.c.

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

IcoDecoder_GetFrame()

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

static

Definition at line 645 of file icoformat.c.

{
    IcoDecoder *This = impl_from_IWICBitmapDecoder(iface);
    IcoFrameDecode *result=NULL;
    LARGE_INTEGER seek;
    ULARGE_INTEGER offset, length;
    HRESULT hr;
    ULONG bytesread;
    ICONDIRENTRY entry;
    IWICStream *substream=NULL;
    DWORD magic;
    TRACE("(%p,%u,%p)\n", iface, index, ppIBitmapFrame);
 
    EnterCriticalSection(&This->lock);
 
    if (!This->initialized)
    {
        hr = WINCODEC_ERR_FRAMEMISSING;
        goto fail;
    }
 
    if (This->header.idCount < index)
    {
        hr = E_INVALIDARG;
        goto fail;
    }
 
    result = HeapAlloc(GetProcessHeap(), 0, sizeof(IcoFrameDecode));
    if (!result)
    {
        hr = E_OUTOFMEMORY;
        goto fail;
    }
 
    result->IWICBitmapFrameDecode_iface.lpVtbl = &IcoFrameDecode_Vtbl;
    result->ref = 1;
    result->bits = NULL;
 
    /* read the icon entry */
    seek.QuadPart = sizeof(ICONHEADER) + sizeof(ICONDIRENTRY) * index;
    hr = IStream_Seek(This->stream, seek, STREAM_SEEK_SET, 0);
    if (FAILED(hr)) goto fail;
 
    hr = IStream_Read(This->stream, &entry, sizeof(ICONDIRENTRY), &bytesread);
    if (FAILED(hr) || bytesread != sizeof(ICONDIRENTRY)) goto fail;
 
    /* create a stream object for this icon */
    hr = StreamImpl_Create(&substream);
    if (FAILED(hr)) goto fail;
 
    offset.QuadPart = entry.dwDIBOffset;
    length.QuadPart = entry.dwDIBSize;
    hr = IWICStream_InitializeFromIStreamRegion(substream, This->stream, offset, length);
    if (FAILED(hr)) goto fail;
 
    /* read the bitmapinfo size or magic number */
    hr = IWICStream_Read(substream, &magic, sizeof(magic), &bytesread);
    if (FAILED(hr) || bytesread != sizeof(magic)) goto fail;
 
    /* forward to the appropriate decoding function based on the magic number */
    switch (magic)
    {
    case sizeof(BITMAPCOREHEADER):
    case 64: /* sizeof(BITMAPCOREHEADER2) */
    case sizeof(BITMAPINFOHEADER):
    case sizeof(BITMAPV4HEADER):
    case sizeof(BITMAPV5HEADER):
        hr = ReadIcoDib((IStream*)substream, result);
        break;
    case 0x474e5089:
        hr = ReadIcoPng((IStream*)substream, result);
        break;
    default:
        FIXME("Unrecognized ICO frame magic: %x\n", magic);
        hr = E_FAIL;
        break;
    }
    if (FAILED(hr)) goto fail;
 
    *ppIBitmapFrame = &result->IWICBitmapFrameDecode_iface;
 
    LeaveCriticalSection(&This->lock);
 
    IWICStream_Release(substream);
 
    return S_OK;
 
fail:
    LeaveCriticalSection(&This->lock);
    HeapFree(GetProcessHeap(), 0, result);
    if (substream) IWICStream_Release(substream);
    if (SUCCEEDED(hr)) hr = E_FAIL;
    TRACE("<-- %x\n", hr);
    return hr;
}

IcoDecoder_GetFrameCount()

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

static

Definition at line 629 of file icoformat.c.

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

IcoDecoder_GetMetadataQueryReader()

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

static

Definition at line 601 of file icoformat.c.

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

IcoDecoder_GetPreview()

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

static

Definition at line 608 of file icoformat.c.

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

IcoDecoder_GetThumbnail()

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

static

Definition at line 622 of file icoformat.c.

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

IcoDecoder_Initialize()

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

static

Definition at line 507 of file icoformat.c.

{
    IcoDecoder *This = impl_from_IWICBitmapDecoder(iface);
    LARGE_INTEGER seek;
    HRESULT hr;
    ULONG bytesread;
    STATSTG statstg;
    unsigned int i;
 
    TRACE("(%p,%p,%x)\n", iface, pIStream, cacheOptions);
 
    EnterCriticalSection(&This->lock);
 
    if (This->initialized)
    {
        hr = WINCODEC_ERR_WRONGSTATE;
        goto end;
    }
 
    seek.QuadPart = 0;
    hr = IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
    if (FAILED(hr)) goto end;
 
    hr = IStream_Read(pIStream, &This->header, sizeof(ICONHEADER), &bytesread);
    if (FAILED(hr)) goto end;
 
    if (bytesread != sizeof(ICONHEADER))
    {
        hr = WINCODEC_ERR_STREAMREAD;
        goto end;
    }
 
    if (This->header.idReserved != 0 ||
        This->header.idType != 1)
    {
        hr = E_FAIL;
        goto end;
    }
 
    hr = IStream_Stat(pIStream, &statstg, STATFLAG_NONAME);
    if (FAILED(hr))
    {
        WARN("Stat() failed, hr %#x.\n", hr);
        goto end;
    }
 
    for (i = 0; i < This->header.idCount; i++)
    {
        ICONDIRENTRY direntry;
 
        hr = IStream_Read(pIStream, &direntry, sizeof(direntry), &bytesread);
        if (FAILED(hr)) goto end;
 
        if (bytesread != sizeof(direntry) || (direntry.dwDIBSize + direntry.dwDIBOffset > statstg.cbSize.QuadPart))
        {
            hr = WINCODEC_ERR_BADIMAGE;
            goto end;
        }
    }
 
    This->initialized = TRUE;
    This->stream = pIStream;
    IStream_AddRef(pIStream);
 
end:
 
    LeaveCriticalSection(&This->lock);
 
    return hr;
}

IcoDecoder_QueryCapability()

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

static

Definition at line 491 of file icoformat.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;
    return S_OK;
}

IcoDecoder_QueryInterface()

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

static

Definition at line 440 of file icoformat.c.

{
    IcoDecoder *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
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

IcoDecoder_Release()

static ULONG WINAPI IcoDecoder_Release ( IWICBitmapDecoder *  iface )

static

Definition at line 473 of file icoformat.c.

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

IcoFrameDecode_AddRef()

static ULONG WINAPI IcoFrameDecode_AddRef ( IWICBitmapFrameDecode *  iface )

static

Definition at line 109 of file icoformat.c.

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

IcoFrameDecode_CopyPalette()

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

static

Definition at line 168 of file icoformat.c.

{
    TRACE("(%p,%p)\n", iface, pIPalette);
    return WINCODEC_ERR_PALETTEUNAVAILABLE;
}

IcoFrameDecode_CopyPixels()

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

static

Definition at line 175 of file icoformat.c.

{
    IcoFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
    TRACE("(%p,%s,%u,%u,%p)\n", iface, debug_wic_rect(prc), cbStride, cbBufferSize, pbBuffer);
 
    return copy_pixels(32, This->bits, This->width, This->height, This->width * 4,
        prc, cbStride, cbBufferSize, pbBuffer);
}

IcoFrameDecode_GetColorContexts()

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

static

Definition at line 192 of file icoformat.c.

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

IcoFrameDecode_GetMetadataQueryReader()

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

static

Definition at line 185 of file icoformat.c.

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

IcoFrameDecode_GetPixelFormat()

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

static

Definition at line 148 of file icoformat.c.

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

IcoFrameDecode_GetResolution()

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

static

Definition at line 155 of file icoformat.c.

{
    IcoFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 
    *pDpiX = This->dpiX;
    *pDpiY = This->dpiY;
 
    TRACE("(%p) -> (%f,%f)\n", iface, *pDpiX, *pDpiY);
 
    return S_OK;
}

IcoFrameDecode_GetSize()

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

static

Definition at line 135 of file icoformat.c.

{
    IcoFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 
    *puiWidth = This->width;
    *puiHeight = This->height;
 
    TRACE("(%p) -> (%i,%i)\n", iface, *puiWidth, *puiHeight);
 
    return S_OK;
}

IcoFrameDecode_GetThumbnail()

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

static

Definition at line 199 of file icoformat.c.

{
    TRACE("(%p,%p)\n", iface, ppIThumbnail);
    return IWICBitmapFrameDecode_QueryInterface(iface, &IID_IWICBitmapSource, (void **)ppIThumbnail);
}

IcoFrameDecode_QueryInterface()

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

static

Definition at line 85 of file icoformat.c.

{
    IcoFrameDecode *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
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

IcoFrameDecode_Release()

static ULONG WINAPI IcoFrameDecode_Release ( IWICBitmapFrameDecode *  iface )

static

Definition at line 119 of file icoformat.c.

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

impl_from_IWICBitmapDecoder()

static IcoDecoder * impl_from_IWICBitmapDecoder ( IWICBitmapDecoder *  iface )

inlinestatic

Definition at line 75 of file icoformat.c.

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

Referenced by IcoDecoder_AddRef(), IcoDecoder_GetFrame(), IcoDecoder_GetFrameCount(), IcoDecoder_Initialize(), IcoDecoder_QueryInterface(), and IcoDecoder_Release().

impl_from_IWICBitmapFrameDecode()

static IcoFrameDecode * impl_from_IWICBitmapFrameDecode ( IWICBitmapFrameDecode *  iface )

inlinestatic

Definition at line 80 of file icoformat.c.

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

Referenced by IcoFrameDecode_AddRef(), IcoFrameDecode_CopyPixels(), IcoFrameDecode_GetResolution(), IcoFrameDecode_GetSize(), IcoFrameDecode_QueryInterface(), and IcoFrameDecode_Release().

pixel_set_trans()

static void pixel_set_trans ( DWORD *  pixel, BOOL  transparent  )

inlinestatic

Definition at line 220 of file icoformat.c.

{
    if (transparent) *pixel = 0;
    else *pixel |= 0xff000000;
}

Referenced by ReadIcoDib().

ReadIcoDib()

static HRESULT ReadIcoDib ( IStream *  stream, IcoFrameDecode *  result  )

static

Definition at line 226 of file icoformat.c.

{
    HRESULT hr;
    BmpDecoder *bmp_decoder;
    IWICBitmapDecoder *decoder;
    IWICBitmapFrameDecode *framedecode;
    WICPixelFormatGUID pixelformat;
    IWICBitmapSource *source;
    BOOL has_alpha=FALSE; /* if TRUE, alpha data might be in the image data */
    WICRect rc;
 
    hr = IcoDibDecoder_CreateInstance(&bmp_decoder);
    if (SUCCEEDED(hr))
    {
        BmpDecoder_GetWICDecoder(bmp_decoder, &decoder);
        hr = IWICBitmapDecoder_Initialize(decoder, stream, WICDecodeMetadataCacheOnLoad);
 
        if (SUCCEEDED(hr))
            hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
 
        if (SUCCEEDED(hr))
        {
            hr = IWICBitmapFrameDecode_GetSize(framedecode, &result->width, &result->height);
 
            if (SUCCEEDED(hr))
            {
                result->bits = HeapAlloc(GetProcessHeap(), 0, result->width * result->height * 4);
                if (!result->bits) hr = E_OUTOFMEMORY;
            }
 
            if (SUCCEEDED(hr))
                hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &pixelformat);
 
            if (IsEqualGUID(&pixelformat, &GUID_WICPixelFormat32bppBGR) ||
                IsEqualGUID(&pixelformat, &GUID_WICPixelFormat32bppBGRA))
            {
                source = (IWICBitmapSource*)framedecode;
                IWICBitmapSource_AddRef(source);
                has_alpha = TRUE;
            }
            else
            {
                hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA,
                    (IWICBitmapSource*)framedecode, &source);
                has_alpha = FALSE;
            }
 
            if (SUCCEEDED(hr))
            {
                rc.X = 0;
                rc.Y = 0;
                rc.Width = result->width;
                rc.Height = result->height;
                hr = IWICBitmapSource_CopyPixels(source, &rc, result->width * 4,
                    result->width * result->height * 4, result->bits);
 
                IWICBitmapSource_Release(source);
            }
 
            if (SUCCEEDED(hr))
                hr = IWICBitmapFrameDecode_GetResolution(framedecode, &result->dpiX, &result->dpiY);
 
            IWICBitmapFrameDecode_Release(framedecode);
        }
 
        if (SUCCEEDED(hr) && has_alpha)
        {
            /* If the alpha channel is fully transparent, we should ignore it. */
            int nonzero_alpha = 0;
            UINT i;
 
            for (i=0; i<(result->height*result->width); i++)
            {
                if (result->bits[i*4+3] != 0)
                {
                    nonzero_alpha = 1;
                    break;
                }
            }
 
            if (!nonzero_alpha)
            {
                for (i=0; i<(result->height*result->width); i++)
                    result->bits[i*4+3] = 0xff;
 
                has_alpha = FALSE;
            }
        }
 
        if (SUCCEEDED(hr) && !has_alpha)
        {
            /* set alpha data based on the AND mask */
            UINT andBytesPerRow = (result->width+31)/32*4;
            UINT andBytes = andBytesPerRow * result->height;
            INT andStride;
            BYTE *tempdata=NULL;
            BYTE *andRow;
            BYTE *bitsRow;
            UINT bitsStride = result->width * 4;
            UINT x, y;
            ULONG offset;
            ULONG bytesread;
            LARGE_INTEGER seek;
            int topdown;
 
            BmpDecoder_FindIconMask(bmp_decoder, &offset, &topdown);
 
            if (offset)
            {
                seek.QuadPart = offset;
 
                hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, 0);
 
                if (SUCCEEDED(hr))
                {
                    tempdata = HeapAlloc(GetProcessHeap(), 0, andBytes);
                    if (!tempdata) hr = E_OUTOFMEMORY;
                }
 
                if (SUCCEEDED(hr))
                    hr = IStream_Read(stream, tempdata, andBytes, &bytesread);
 
                if (SUCCEEDED(hr) && bytesread == andBytes)
                {
                    if (topdown)
                    {
                        andStride = andBytesPerRow;
                        andRow = tempdata;
                    }
                    else
                    {
                        andStride = -andBytesPerRow;
                        andRow = tempdata + (result->height-1)*andBytesPerRow;
                    }
 
                    bitsRow = result->bits;
                    for (y=0; y<result->height; y++) {
                        BYTE *andByte=andRow;
                        DWORD *bitsPixel=(DWORD*)bitsRow;
                        for (x=0; x<result->width; x+=8) {
                            BYTE andVal=*andByte++;
                            pixel_set_trans(bitsPixel++, andVal>>7&1);
                            if (x+1 < result->width) pixel_set_trans(bitsPixel++, andVal>>6&1);
                            if (x+2 < result->width) pixel_set_trans(bitsPixel++, andVal>>5&1);
                            if (x+3 < result->width) pixel_set_trans(bitsPixel++, andVal>>4&1);
                            if (x+4 < result->width) pixel_set_trans(bitsPixel++, andVal>>3&1);
                            if (x+5 < result->width) pixel_set_trans(bitsPixel++, andVal>>2&1);
                            if (x+6 < result->width) pixel_set_trans(bitsPixel++, andVal>>1&1);
                            if (x+7 < result->width) pixel_set_trans(bitsPixel++, andVal&1);
                        }
                        andRow += andStride;
                        bitsRow += bitsStride;
                    }
                }
 
                HeapFree(GetProcessHeap(), 0, tempdata);
            }
        }
 
        IWICBitmapDecoder_Release(decoder);
    }
 
    return hr;
}

Referenced by IcoDecoder_GetFrame().

ReadIcoPng()

static HRESULT ReadIcoPng ( IStream *  stream, IcoFrameDecode *  result  )

static

Definition at line 391 of file icoformat.c.

{
    IWICBitmapDecoder *decoder = NULL;
    IWICBitmapFrameDecode *sourceFrame = NULL;
    IWICBitmapSource *sourceBitmap = NULL;
    WICRect rect;
    HRESULT hr;
 
    hr = PngDecoder_CreateInstance(&IID_IWICBitmapDecoder, (void**)&decoder);
    if (FAILED(hr))
        goto end;
    hr = IWICBitmapDecoder_Initialize(decoder, stream, WICDecodeMetadataCacheOnLoad);
    if (FAILED(hr))
        goto end;
    hr = IWICBitmapDecoder_GetFrame(decoder, 0, &sourceFrame);
    if (FAILED(hr))
        goto end;
    hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, (IWICBitmapSource*)sourceFrame, &sourceBitmap);
    if (FAILED(hr))
        goto end;
    hr = IWICBitmapFrameDecode_GetSize(sourceFrame, &result->width, &result->height);
    if (FAILED(hr))
        goto end;
    hr = IWICBitmapFrameDecode_GetResolution(sourceFrame, &result->dpiX, &result->dpiY);
    if (FAILED(hr))
        goto end;
    result->bits = HeapAlloc(GetProcessHeap(), 0, 4 * result->width * result->height);
    if (result->bits == NULL)
    {
        hr = E_OUTOFMEMORY;
        goto end;
    }
    rect.X = 0;
    rect.Y = 0;
    rect.Width = result->width;
    rect.Height = result->height;
    hr = IWICBitmapSource_CopyPixels(sourceBitmap, &rect, 4*result->width,
                                     4*result->width*result->height, result->bits);
 
end:
    if (decoder != NULL)
        IWICBitmapDecoder_Release(decoder);
    if (sourceFrame != NULL)
        IWICBitmapFrameDecode_Release(sourceFrame);
    if (sourceBitmap != NULL)
        IWICBitmapSource_Release(sourceBitmap);
    return hr;
}

Referenced by IcoDecoder_GetFrame().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

wincodecs

)

Variable Documentation

IcoDecoder_Vtbl

const IWICBitmapDecoderVtbl IcoDecoder_Vtbl

static

Initial value:

= {
    IcoDecoder_QueryInterface,
    IcoDecoder_AddRef,
    IcoDecoder_Release,
    IcoDecoder_QueryCapability,
    IcoDecoder_Initialize,
    IcoDecoder_GetContainerFormat,
    IcoDecoder_GetDecoderInfo,
    IcoDecoder_CopyPalette,
    IcoDecoder_GetMetadataQueryReader,
    IcoDecoder_GetPreview,
    IcoDecoder_GetColorContexts,
    IcoDecoder_GetThumbnail,
    IcoDecoder_GetFrameCount,
    IcoDecoder_GetFrame
}

Definition at line 742 of file icoformat.c.

Referenced by IcoDecoder_CreateInstance().

IcoFrameDecode_Vtbl

const IWICBitmapFrameDecodeVtbl IcoFrameDecode_Vtbl

static

Initial value:

= {
    IcoFrameDecode_QueryInterface,
    IcoFrameDecode_AddRef,
    IcoFrameDecode_Release,
    IcoFrameDecode_GetSize,
    IcoFrameDecode_GetPixelFormat,
    IcoFrameDecode_GetResolution,
    IcoFrameDecode_CopyPalette,
    IcoFrameDecode_CopyPixels,
    IcoFrameDecode_GetMetadataQueryReader,
    IcoFrameDecode_GetColorContexts,
    IcoFrameDecode_GetThumbnail
}

Definition at line 206 of file icoformat.c.

Referenced by IcoDecoder_GetFrame().