bmpdecode.c File Reference

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

Include dependency graph for bmpdecode.c:

Go to the source code of this file.

Classes
struct	BITMAPCOREHEADER2
struct	BmpDecoder
struct	bitfields_format

Macros
#define	COBJMACROS

Typedefs
typedef HRESULT(*	ReadDataFunc) (BmpDecoder *This)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (wincodecs)
static BmpDecoder *	impl_from_IWICBitmapDecoder (IWICBitmapDecoder *iface)
static BmpDecoder *	impl_from_IWICBitmapFrameDecode (IWICBitmapFrameDecode *iface)
static HRESULT WINAPI	BmpFrameDecode_QueryInterface (IWICBitmapFrameDecode *iface, REFIID iid, void **ppv)
static ULONG WINAPI	BmpFrameDecode_AddRef (IWICBitmapFrameDecode *iface)
static ULONG WINAPI	BmpFrameDecode_Release (IWICBitmapFrameDecode *iface)
static HRESULT WINAPI	BmpFrameDecode_GetSize (IWICBitmapFrameDecode *iface, UINT *puiWidth, UINT *puiHeight)
static HRESULT WINAPI	BmpFrameDecode_GetPixelFormat (IWICBitmapFrameDecode *iface, WICPixelFormatGUID *pPixelFormat)
static HRESULT	BmpHeader_GetResolution (BITMAPV5HEADER *bih, double *pDpiX, double *pDpiY)
static HRESULT WINAPI	BmpFrameDecode_GetResolution (IWICBitmapFrameDecode *iface, double *pDpiX, double *pDpiY)
static HRESULT WINAPI	BmpFrameDecode_CopyPalette (IWICBitmapFrameDecode *iface, IWICPalette *pIPalette)
static HRESULT WINAPI	BmpFrameDecode_CopyPixels (IWICBitmapFrameDecode *iface, const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
static HRESULT WINAPI	BmpFrameDecode_GetMetadataQueryReader (IWICBitmapFrameDecode *iface, IWICMetadataQueryReader **ppIMetadataQueryReader)
static HRESULT WINAPI	BmpFrameDecode_GetColorContexts (IWICBitmapFrameDecode *iface, UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
static HRESULT WINAPI	BmpFrameDecode_GetThumbnail (IWICBitmapFrameDecode *iface, IWICBitmapSource **ppIThumbnail)
static HRESULT	BmpFrameDecode_ReadUncompressed (BmpDecoder *This)
static HRESULT	BmpFrameDecode_ReadRGB8 (BmpDecoder *This)
static HRESULT	ReadByte (IStream *stream, BYTE *buffer, ULONG buffer_size, ULONG *cursor, ULONG *bytesread, BYTE *result)
static HRESULT	BmpFrameDecode_ReadRLE8 (BmpDecoder *This)
static HRESULT	BmpFrameDecode_ReadRLE4 (BmpDecoder *This)
static HRESULT	BmpFrameDecode_ReadUnsupported (BmpDecoder *This)
static HRESULT	BmpDecoder_ReadHeaders (BmpDecoder *This, IStream *stream)
static HRESULT WINAPI	BmpDecoder_QueryInterface (IWICBitmapDecoder *iface, REFIID iid, void **ppv)
static ULONG WINAPI	BmpDecoder_AddRef (IWICBitmapDecoder *iface)
static ULONG WINAPI	BmpDecoder_Release (IWICBitmapDecoder *iface)
static HRESULT WINAPI	BmpDecoder_QueryCapability (IWICBitmapDecoder *iface, IStream *stream, DWORD *capability)
static HRESULT WINAPI	BmpDecoder_Initialize (IWICBitmapDecoder *iface, IStream *pIStream, WICDecodeOptions cacheOptions)
static HRESULT WINAPI	BmpDecoder_GetContainerFormat (IWICBitmapDecoder *iface, GUID *pguidContainerFormat)
static HRESULT WINAPI	BmpDecoder_GetDecoderInfo (IWICBitmapDecoder *iface, IWICBitmapDecoderInfo **ppIDecoderInfo)
static HRESULT WINAPI	BmpDecoder_CopyPalette (IWICBitmapDecoder *iface, IWICPalette *pIPalette)
static HRESULT WINAPI	BmpDecoder_GetMetadataQueryReader (IWICBitmapDecoder *iface, IWICMetadataQueryReader **ppIMetadataQueryReader)
static HRESULT WINAPI	BmpDecoder_GetPreview (IWICBitmapDecoder *iface, IWICBitmapSource **ppIBitmapSource)
static HRESULT WINAPI	BmpDecoder_GetColorContexts (IWICBitmapDecoder *iface, UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
static HRESULT WINAPI	BmpDecoder_GetThumbnail (IWICBitmapDecoder *iface, IWICBitmapSource **ppIThumbnail)
static HRESULT WINAPI	BmpDecoder_GetFrameCount (IWICBitmapDecoder *iface, UINT *pCount)
static HRESULT WINAPI	BmpDecoder_GetFrame (IWICBitmapDecoder *iface, UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
static HRESULT	BmpDecoder_Create (int packed, int icoframe, BmpDecoder **ppDecoder)
static HRESULT	BmpDecoder_Construct (int packed, int icoframe, REFIID iid, void **ppv)
HRESULT	BmpDecoder_CreateInstance (REFIID iid, void **ppv)
HRESULT	DibDecoder_CreateInstance (REFIID iid, void **ppv)
HRESULT	IcoDibDecoder_CreateInstance (BmpDecoder **ppDecoder)
void	BmpDecoder_GetWICDecoder (BmpDecoder *This, IWICBitmapDecoder **ppDecoder)
void	BmpDecoder_FindIconMask (BmpDecoder *This, ULONG *mask_offset, int *topdown)

Variables
static const struct bitfields_format	bitfields_formats []
static const IWICBitmapFrameDecodeVtbl	BmpDecoder_FrameVtbl
static const IWICBitmapDecoderVtbl	BmpDecoder_Vtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 24 of file bmpdecode.c.

Typedef Documentation

ReadDataFunc

typedef HRESULT(* ReadDataFunc) (BmpDecoder *This)

Definition at line 61 of file bmpdecode.c.

Function Documentation

BmpDecoder_AddRef()

static ULONG WINAPI BmpDecoder_AddRef ( IWICBitmapDecoder *  iface )

static

Definition at line 997 of file bmpdecode.c.

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

BmpDecoder_Construct()

static HRESULT BmpDecoder_Construct ( int  packed, int  icoframe, REFIID  iid, void **  ppv  )

static

Definition at line 1177 of file bmpdecode.c.

{
    BmpDecoder *This;
    HRESULT ret;
 
    TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
 
    *ppv = NULL;
 
    ret = BmpDecoder_Create(packed, icoframe, &This);
    if (FAILED(ret)) return ret;
 
    ret = IWICBitmapDecoder_QueryInterface(&This->IWICBitmapDecoder_iface, iid, ppv);
    IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
 
    return ret;
}

Referenced by BmpDecoder_CreateInstance(), and DibDecoder_CreateInstance().

BmpDecoder_CopyPalette()

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

static

Definition at line 1077 of file bmpdecode.c.

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

BmpDecoder_Create()

static HRESULT BmpDecoder_Create ( int  packed, int  icoframe, BmpDecoder **  ppDecoder  )

static

Definition at line 1154 of file bmpdecode.c.

{
    BmpDecoder *This;
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(BmpDecoder));
    if (!This) return E_OUTOFMEMORY;
 
    This->IWICBitmapDecoder_iface.lpVtbl = &BmpDecoder_Vtbl;
    This->IWICBitmapFrameDecode_iface.lpVtbl = &BmpDecoder_FrameVtbl;
    This->ref = 1;
    This->initialized = FALSE;
    This->stream = NULL;
    This->imagedata = NULL;
    InitializeCriticalSection(&This->lock);
    This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": BmpDecoder.lock");
    This->packed = packed;
    This->icoframe = icoframe;
 
    *ppDecoder = This;
 
    return S_OK;
}

Referenced by BmpDecoder_Construct(), and IcoDibDecoder_CreateInstance().

BmpDecoder_CreateInstance()

HRESULT BmpDecoder_CreateInstance	(	REFIID	iid,
		void **	ppv
	)

Definition at line 1195 of file bmpdecode.c.

{
    return BmpDecoder_Construct(FALSE, FALSE, iid, ppv);
}

BmpDecoder_FindIconMask()

void BmpDecoder_FindIconMask	(	BmpDecoder *	This,
		ULONG *	mask_offset,
		int *	topdown
	)

Definition at line 1216 of file bmpdecode.c.

{
    assert(This->stream != NULL);
 
    if (This->read_data_func == BmpFrameDecode_ReadUncompressed)
    {
        /* RGB or BITFIELDS data */
        ULONG width, height, bytesperrow, datasize;
        IWICBitmapFrameDecode_GetSize(&This->IWICBitmapFrameDecode_iface, &width, &height);
        bytesperrow = (((width * This->bitsperpixel)+31)/32)*4;
        datasize = bytesperrow * height;
        *mask_offset = This->image_offset + datasize;
    }
    else
        *mask_offset = 0;
 
    *topdown = This->stride > 0;
}

Referenced by ReadIcoDib().

BmpDecoder_GetColorContexts()

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

static

Definition at line 1099 of file bmpdecode.c.

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

BmpDecoder_GetContainerFormat()

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

static

Definition at line 1062 of file bmpdecode.c.

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

BmpDecoder_GetDecoderInfo()

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

static

Definition at line 1069 of file bmpdecode.c.

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

BmpDecoder_GetFrame()

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

static

Definition at line 1122 of file bmpdecode.c.

{
    BmpDecoder *This = impl_from_IWICBitmapDecoder(iface);
 
    if (index != 0) return E_INVALIDARG;
 
    if (!This->stream) return WINCODEC_ERR_FRAMEMISSING;
 
    *ppIBitmapFrame = &This->IWICBitmapFrameDecode_iface;
    IWICBitmapDecoder_AddRef(iface);
 
    return S_OK;
}

BmpDecoder_GetFrameCount()

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

static

Definition at line 1113 of file bmpdecode.c.

{
    if (!pCount) return E_INVALIDARG;
 
    *pCount = 1;
    return S_OK;
}

BmpDecoder_GetMetadataQueryReader()

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

static

Definition at line 1085 of file bmpdecode.c.

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

BmpDecoder_GetPreview()

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

static

Definition at line 1092 of file bmpdecode.c.

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

BmpDecoder_GetThumbnail()

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

static

Definition at line 1106 of file bmpdecode.c.

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

BmpDecoder_GetWICDecoder()

void BmpDecoder_GetWICDecoder	(	BmpDecoder *	This,
		IWICBitmapDecoder **	ppDecoder
	)

Definition at line 1210 of file bmpdecode.c.

{
    *ppDecoder = &This->IWICBitmapDecoder_iface;
}

Referenced by ReadIcoDib().

BmpDecoder_Initialize()

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

static

Definition at line 1043 of file bmpdecode.c.

{
    HRESULT hr;
    BmpDecoder *This = impl_from_IWICBitmapDecoder(iface);
 
    EnterCriticalSection(&This->lock);
    hr = BmpDecoder_ReadHeaders(This, pIStream);
 
    if (SUCCEEDED(hr))
    {
        This->stream = pIStream;
        IStream_AddRef(pIStream);
    }
    LeaveCriticalSection(&This->lock);
 
    return hr;
}

BmpDecoder_QueryCapability()

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

static

Definition at line 1026 of file bmpdecode.c.

{
    HRESULT hr;
    BmpDecoder *This = impl_from_IWICBitmapDecoder(iface);
 
    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 = This->read_data_func == BmpFrameDecode_ReadUnsupported ? 0 : WICBitmapDecoderCapabilityCanDecodeAllImages;
    return S_OK;
}

BmpDecoder_QueryInterface()

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

static

Definition at line 974 of file bmpdecode.c.

{
    BmpDecoder *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;
}

BmpDecoder_ReadHeaders()

static HRESULT BmpDecoder_ReadHeaders ( BmpDecoder *  This, IStream *  stream  )

static

Definition at line 766 of file bmpdecode.c.

{
    HRESULT hr;
    ULONG bytestoread, bytesread;
    LARGE_INTEGER seek;
 
    if (This->initialized) return WINCODEC_ERR_WRONGSTATE;
 
    seek.QuadPart = 0;
    hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
    if (FAILED(hr)) return hr;
 
    if (!This->packed)
    {
        BITMAPFILEHEADER bfh;
        hr = IStream_Read(stream, &bfh, sizeof(BITMAPFILEHEADER), &bytesread);
        if (FAILED(hr)) return hr;
        if (bytesread != sizeof(BITMAPFILEHEADER) ||
            bfh.bfType != 0x4d42 /* "BM" */) return E_FAIL;
        This->image_offset = bfh.bfOffBits;
    }
 
    hr = IStream_Read(stream, &This->bih.bV5Size, sizeof(DWORD), &bytesread);
    if (FAILED(hr)) return hr;
    if (bytesread != sizeof(DWORD) ||
        (This->bih.bV5Size != sizeof(BITMAPCOREHEADER) &&
         This->bih.bV5Size != sizeof(BITMAPCOREHEADER2) &&
         This->bih.bV5Size != sizeof(BITMAPINFOHEADER) &&
         This->bih.bV5Size != sizeof(BITMAPV4HEADER) &&
         This->bih.bV5Size != sizeof(BITMAPV5HEADER))) return E_FAIL;
 
    bytestoread = This->bih.bV5Size-sizeof(DWORD);
    hr = IStream_Read(stream, &This->bih.bV5Width, bytestoread, &bytesread);
    if (FAILED(hr)) return hr;
    if (bytestoread != bytesread) return E_FAIL;
 
    if (This->packed)
        This->palette_offset = This->bih.bV5Size;
    else
        This->palette_offset = sizeof(BITMAPFILEHEADER) + This->bih.bV5Size;
 
    if (This->icoframe)
    {
        if (This->bih.bV5Size == sizeof(BITMAPCOREHEADER))
        {
            BITMAPCOREHEADER *bch = (BITMAPCOREHEADER*)&This->bih;
            bch->bcHeight /= 2;
        }
        else
        {
            This->bih.bV5Height /= 2;
        }
    }
 
    /* if this is a BITMAPINFOHEADER with BI_BITFIELDS compression, we need to
        read the extra fields */
    if (This->bih.bV5Size == sizeof(BITMAPINFOHEADER) &&
        This->bih.bV5Compression == BI_BITFIELDS)
    {
        hr = IStream_Read(stream, &This->bih.bV5RedMask, 12, &bytesread);
        if (FAILED(hr)) return hr;
        if (bytesread != 12) return E_FAIL;
        This->bih.bV5AlphaMask = 0;
        This->palette_offset += 12;
    }
 
    /* decide what kind of bitmap this is and how/if we can read it */
    if (This->bih.bV5Size == sizeof(BITMAPCOREHEADER))
    {
        BITMAPCOREHEADER *bch = (BITMAPCOREHEADER*)&This->bih;
        TRACE("BITMAPCOREHEADER with depth=%i\n", bch->bcBitCount);
        This->bitsperpixel = bch->bcBitCount;
        This->read_data_func = BmpFrameDecode_ReadUncompressed;
        switch(bch->bcBitCount)
        {
        case 1:
            This->pixelformat = &GUID_WICPixelFormat1bppIndexed;
            break;
        case 2:
            This->pixelformat = &GUID_WICPixelFormat2bppIndexed;
            break;
        case 4:
            This->pixelformat = &GUID_WICPixelFormat4bppIndexed;
            break;
        case 8:
            This->pixelformat = &GUID_WICPixelFormat8bppIndexed;
            break;
        case 24:
            This->pixelformat = &GUID_WICPixelFormat24bppBGR;
            break;
        default:
            This->pixelformat = &GUID_WICPixelFormatUndefined;
            WARN("unsupported bit depth %i for BITMAPCOREHEADER\n", bch->bcBitCount);
            break;
        }
    }
    else /* struct is compatible with BITMAPINFOHEADER */
    {
        TRACE("bitmap header=%i compression=%i depth=%i\n", This->bih.bV5Size, This->bih.bV5Compression, This->bih.bV5BitCount);
        switch(This->bih.bV5Compression)
        {
        case BI_RGB:
            This->bitsperpixel = This->bih.bV5BitCount;
            This->read_data_func = BmpFrameDecode_ReadUncompressed;
            switch(This->bih.bV5BitCount)
            {
            case 1:
                This->pixelformat = &GUID_WICPixelFormat1bppIndexed;
                break;
            case 2:
                This->pixelformat = &GUID_WICPixelFormat2bppIndexed;
                break;
            case 4:
                This->pixelformat = &GUID_WICPixelFormat4bppIndexed;
                break;
            case 8:
                This->pixelformat = &GUID_WICPixelFormat8bppIndexed;
                break;
            case 16:
                This->pixelformat = &GUID_WICPixelFormat16bppBGR555;
                break;
            case 24:
                This->pixelformat = &GUID_WICPixelFormat24bppBGR;
                break;
            case 32:
                This->pixelformat = &GUID_WICPixelFormat32bppBGR;
                break;
            default:
                This->pixelformat = &GUID_WICPixelFormatUndefined;
                FIXME("unsupported bit depth %i for uncompressed RGB\n", This->bih.bV5BitCount);
            }
            break;
        case BI_RLE8:
            This->bitsperpixel = 32;
            This->read_data_func = BmpFrameDecode_ReadRLE8;
            This->pixelformat = &GUID_WICPixelFormat32bppBGR;
            break;
        case BI_RLE4:
            This->bitsperpixel = 32;
            This->read_data_func = BmpFrameDecode_ReadRLE4;
            This->pixelformat = &GUID_WICPixelFormat32bppBGR;
            break;
        case BI_BITFIELDS:
        {
            const struct bitfields_format *format;
            if (This->bih.bV5Size == sizeof(BITMAPCOREHEADER2))
            {
                /* BCH2 doesn't support bitfields; this is Huffman 1D compression */
                This->bitsperpixel = 0;
                This->read_data_func = BmpFrameDecode_ReadUnsupported;
                This->pixelformat = &GUID_WICPixelFormatUndefined;
                FIXME("Huffman 1D compression is unsupported\n");
                break;
            }
            This->bitsperpixel = This->bih.bV5BitCount;
            for (format = bitfields_formats; format->bitcount; format++)
            {
                if ((format->bitcount == This->bih.bV5BitCount) &&
                    (format->redmask == This->bih.bV5RedMask) &&
                    (format->greenmask == This->bih.bV5GreenMask) &&
                    (format->bluemask == This->bih.bV5BlueMask) &&
                    (format->alphamask == This->bih.bV5AlphaMask))
                {
                    This->read_data_func = format->read_data_func;
                    This->pixelformat = format->pixelformat;
                    break;
                }
            }
            if (!format->bitcount)
            {
                This->read_data_func = BmpFrameDecode_ReadUncompressed;
                This->pixelformat = &GUID_WICPixelFormatUndefined;
                FIXME("unsupported bitfields type depth=%i red=%x green=%x blue=%x alpha=%x\n",
                    This->bih.bV5BitCount, This->bih.bV5RedMask, This->bih.bV5GreenMask, This->bih.bV5BlueMask, This->bih.bV5AlphaMask);
            }
            break;
        }
        default:
            This->bitsperpixel = 0;
            This->read_data_func = BmpFrameDecode_ReadUnsupported;
            This->pixelformat = &GUID_WICPixelFormatUndefined;
            FIXME("unsupported bitmap type header=%i compression=%i depth=%i\n", This->bih.bV5Size, This->bih.bV5Compression, This->bih.bV5BitCount);
            break;
        }
    }
 
    if (This->packed)
    {
        /* In a packed DIB, the image follows the palette. */
        ULONG palette_count, palette_size;
        if (This->bih.bV5ClrUsed)
            palette_count = This->bih.bV5ClrUsed;
        else if (This->bih.bV5BitCount <= 8)
            palette_count = 1 << This->bih.bV5BitCount;
        else
            palette_count = 0;
        if (This->bih.bV5Size == sizeof(BITMAPCOREHEADER))
            palette_size = sizeof(RGBTRIPLE) * palette_count;
        else
            palette_size = sizeof(RGBQUAD) * palette_count;
        This->image_offset = This->palette_offset + palette_size;
    }
 
    This->initialized = TRUE;
 
    return S_OK;
}

Referenced by BmpDecoder_Initialize().

BmpDecoder_Release()

static ULONG WINAPI BmpDecoder_Release ( IWICBitmapDecoder *  iface )

static

Definition at line 1007 of file bmpdecode.c.

{
    BmpDecoder *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);
        HeapFree(GetProcessHeap(), 0, This->imagedata);
        This->lock.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&This->lock);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}

BmpFrameDecode_AddRef()

static ULONG WINAPI BmpFrameDecode_AddRef ( IWICBitmapFrameDecode *  iface )

static

Definition at line 118 of file bmpdecode.c.

{
    BmpDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 
    return IWICBitmapDecoder_AddRef(&This->IWICBitmapDecoder_iface);
}

BmpFrameDecode_CopyPalette()

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

static

Definition at line 205 of file bmpdecode.c.

{
    HRESULT hr;
    BmpDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
    int count;
    WICColor *wiccolors=NULL;
    RGBTRIPLE *bgrcolors=NULL;
 
    TRACE("(%p,%p)\n", iface, pIPalette);
 
    EnterCriticalSection(&This->lock);
 
    if (This->bih.bV5Size == sizeof(BITMAPCOREHEADER))
    {
        BITMAPCOREHEADER *bch = (BITMAPCOREHEADER*)&This->bih;
        if (bch->bcBitCount <= 8)
        {
            /* 2**n colors in BGR format after the header */
            ULONG tablesize, bytesread;
            LARGE_INTEGER offset;
            int i;
 
            count = 1 << bch->bcBitCount;
            wiccolors = HeapAlloc(GetProcessHeap(), 0, sizeof(WICColor) * count);
            tablesize = sizeof(RGBTRIPLE) * count;
            bgrcolors = HeapAlloc(GetProcessHeap(), 0, tablesize);
            if (!wiccolors || !bgrcolors)
            {
                hr = E_OUTOFMEMORY;
                goto end;
            }
 
            offset.QuadPart = This->palette_offset;
            hr = IStream_Seek(This->stream, offset, STREAM_SEEK_SET, NULL);
            if (FAILED(hr)) goto end;
 
            hr = IStream_Read(This->stream, bgrcolors, tablesize, &bytesread);
            if (FAILED(hr)) goto end;
            if (bytesread != tablesize) {
                hr = E_FAIL;
                goto end;
            }
 
            for (i=0; i<count; i++)
            {
                wiccolors[i] = 0xff000000|
                               (bgrcolors[i].rgbtRed<<16)|
                               (bgrcolors[i].rgbtGreen<<8)|
                               bgrcolors[i].rgbtBlue;
            }
        }
        else
        {
            hr = WINCODEC_ERR_PALETTEUNAVAILABLE;
            goto end;
        }
    }
    else
    {
        if (This->bih.bV5BitCount <= 8)
        {
            ULONG tablesize, bytesread;
            LARGE_INTEGER offset;
            int i;
 
            if (This->bih.bV5ClrUsed == 0)
                count = 1 << This->bih.bV5BitCount;
            else
                count = min(This->bih.bV5ClrUsed, 1 << This->bih.bV5BitCount);
 
            tablesize = sizeof(WICColor) * count;
            wiccolors = HeapAlloc(GetProcessHeap(), 0, tablesize);
            if (!wiccolors)
            {
                hr = E_OUTOFMEMORY;
                goto end;
            }
 
            offset.QuadPart = This->palette_offset;
            hr = IStream_Seek(This->stream, offset, STREAM_SEEK_SET, NULL);
            if (FAILED(hr)) goto end;
 
            hr = IStream_Read(This->stream, wiccolors, tablesize, &bytesread);
            if (FAILED(hr)) goto end;
            if (bytesread != tablesize) {
                hr = E_FAIL;
                goto end;
            }
 
            /* convert from BGR to BGRA by setting alpha to 100% */
            for (i=0; i<count; i++)
                wiccolors[i] |= 0xff000000;
        }
        else
        {
            hr = WINCODEC_ERR_PALETTEUNAVAILABLE;
            goto end;
        }
    }
 
end:
 
    LeaveCriticalSection(&This->lock);
 
    if (SUCCEEDED(hr))
        hr = IWICPalette_InitializeCustom(pIPalette, wiccolors, count);
 
    HeapFree(GetProcessHeap(), 0, wiccolors);
    HeapFree(GetProcessHeap(), 0, bgrcolors);
    return hr;
}

BmpFrameDecode_CopyPixels()

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

static

Definition at line 318 of file bmpdecode.c.

{
    BmpDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
    HRESULT hr=S_OK;
    UINT width, height;
    TRACE("(%p,%s,%u,%u,%p)\n", iface, debug_wic_rect(prc), cbStride, cbBufferSize, pbBuffer);
 
    EnterCriticalSection(&This->lock);
    if (!This->imagedata)
    {
        hr = This->read_data_func(This);
    }
    LeaveCriticalSection(&This->lock);
    if (FAILED(hr)) return hr;
 
    hr = BmpFrameDecode_GetSize(iface, &width, &height);
    if (FAILED(hr)) return hr;
 
    return copy_pixels(This->bitsperpixel, This->imagedatastart,
        width, height, This->stride,
        prc, cbStride, cbBufferSize, pbBuffer);
}

BmpFrameDecode_GetColorContexts()

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

static

Definition at line 349 of file bmpdecode.c.

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

BmpFrameDecode_GetMetadataQueryReader()

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

static

Definition at line 342 of file bmpdecode.c.

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

BmpFrameDecode_GetPixelFormat()

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

static

Definition at line 152 of file bmpdecode.c.

{
    BmpDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
    TRACE("(%p,%p)\n", iface, pPixelFormat);
 
    memcpy(pPixelFormat, This->pixelformat, sizeof(GUID));
 
    return S_OK;
}

BmpFrameDecode_GetResolution()

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

static

Definition at line 196 of file bmpdecode.c.

{
    BmpDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
    TRACE("(%p,%p,%p)\n", iface, pDpiX, pDpiY);
 
    return BmpHeader_GetResolution(&This->bih, pDpiX, pDpiY);
}

BmpFrameDecode_GetSize()

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

static

Definition at line 132 of file bmpdecode.c.

{
    BmpDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
    TRACE("(%p,%p,%p)\n", iface, puiWidth, puiHeight);
 
    if (This->bih.bV5Size == sizeof(BITMAPCOREHEADER))
    {
        BITMAPCOREHEADER *bch = (BITMAPCOREHEADER*)&This->bih;
        *puiWidth = bch->bcWidth;
        *puiHeight = bch->bcHeight;
    }
    else
    {
        *puiWidth = This->bih.bV5Width;
        *puiHeight = abs(This->bih.bV5Height);
    }
    return S_OK;
}

Referenced by BmpFrameDecode_CopyPixels().

BmpFrameDecode_GetThumbnail()

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

static

Definition at line 356 of file bmpdecode.c.

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

BmpFrameDecode_QueryInterface()

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

static

Definition at line 93 of file bmpdecode.c.

{
    BmpDecoder *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;
}

BmpFrameDecode_ReadRGB8()

static HRESULT BmpFrameDecode_ReadRGB8 ( BmpDecoder *  This )

static

Definition at line 420 of file bmpdecode.c.

{
    HRESULT hr;
    UINT width, height;
 
    hr = IWICBitmapFrameDecode_GetSize(&This->IWICBitmapFrameDecode_iface, &width, &height);
 
    if (SUCCEEDED(hr))
    {
        hr = BmpFrameDecode_ReadUncompressed(This);
    }
 
    if (SUCCEEDED(hr))
    {
        reverse_bgr8(This->bitsperpixel/8, This->imagedatastart,
            width, height, This->stride);
    }
 
    return hr;
}

BmpFrameDecode_ReadRLE4()

static HRESULT BmpFrameDecode_ReadRLE4 ( BmpDecoder *  This )

static

Definition at line 587 of file bmpdecode.c.

{
    UINT bytesperrow;
    UINT width, height;
    BYTE rledata[4096];
    UINT datasize, palettesize;
    DWORD palette[16];
    UINT x, y;
    DWORD *bgrdata;
    HRESULT hr;
    LARGE_INTEGER offbits;
    ULONG cursor=0, bytesread=0;
 
    width = This->bih.bV5Width;
    height = abs(This->bih.bV5Height);
    bytesperrow = width * 4;
    datasize = bytesperrow * height;
    if (This->bih.bV5ClrUsed && This->bih.bV5ClrUsed < 16)
        palettesize = 4 * This->bih.bV5ClrUsed;
    else
        palettesize = 4 * 16;
 
    This->imagedata = HeapAlloc(GetProcessHeap(), 0, datasize);
    if (!This->imagedata)
    {
        hr = E_OUTOFMEMORY;
        goto fail;
    }
 
    /* read palette */
    offbits.QuadPart = This->palette_offset;
    hr = IStream_Seek(This->stream, offbits, STREAM_SEEK_SET, NULL);
    if (FAILED(hr)) goto fail;
 
    hr = IStream_Read(This->stream, palette, palettesize, &bytesread);
    if (FAILED(hr) || bytesread != palettesize) goto fail;
 
    /* read RLE data */
    offbits.QuadPart = This->image_offset;
    hr = IStream_Seek(This->stream, offbits, STREAM_SEEK_SET, NULL);
    if (FAILED(hr)) goto fail;
 
    /* decode RLE */
    bgrdata = (DWORD*)This->imagedata;
    x = 0;
    y = 0;
    cursor = 0;
    bytesread = 0;
    while (y < height)
    {
        BYTE length;
        hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &length);
 
        if (FAILED(hr))
            goto fail;
        else if (length == 0)
        {
            /* escape code */
            BYTE escape;
            hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &escape);
            if (FAILED(hr))
                goto fail;
            switch(escape)
            {
            case 0: /* end of line */
                x = 0;
                y++;
                break;
            case 1: /* end of bitmap */
                goto end;
            case 2: /* delta */
            {
                BYTE dx, dy;
                hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &dx);
                if (SUCCEEDED(hr))
                    hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &dy);
                if (FAILED(hr))
                    goto fail;
                x += dx;
                y += dy;
                break;
            }
            default: /* absolute mode */
            {
                BYTE realsize=0;
                length = escape;
                while (length-- && x < width)
                {
                    BYTE colors;
                    hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &colors);
                    realsize++;
                    if (FAILED(hr))
                        goto fail;
                    bgrdata[y*width + x++] = palette[colors>>4];
                    if (length-- && x < width)
                        bgrdata[y*width + x++] = palette[colors&0xf];
                    else
                        break;
                }
                if (realsize & 1)
                    hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &length); /* skip pad byte */
                if (FAILED(hr))
                    goto fail;
            }
            }
        }
        else
        {
            BYTE colors;
            DWORD color1;
            DWORD color2;
            hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &colors);
            if (FAILED(hr))
                goto fail;
            color1 = palette[colors>>4];
            color2 = palette[colors&0xf];
            while (length-- && x < width)
            {
                bgrdata[y*width + x++] = color1;
                if (length-- && x < width)
                    bgrdata[y*width + x++] = color2;
                else
                    break;
            }
        }
    }
 
end:
    This->imagedatastart = This->imagedata + (height-1) * bytesperrow;
    This->stride = -bytesperrow;
 
    return S_OK;
 
fail:
    HeapFree(GetProcessHeap(), 0, This->imagedata);
    This->imagedata = NULL;
    if (SUCCEEDED(hr)) hr = E_FAIL;
    return hr;
}

Referenced by BmpDecoder_ReadHeaders().

BmpFrameDecode_ReadRLE8()

static HRESULT BmpFrameDecode_ReadRLE8 ( BmpDecoder *  This )

static

Definition at line 463 of file bmpdecode.c.

{
    UINT bytesperrow;
    UINT width, height;
    BYTE rledata[4096];
    UINT datasize, palettesize;
    DWORD palette[256];
    UINT x, y;
    DWORD *bgrdata;
    HRESULT hr;
    LARGE_INTEGER offbits;
    ULONG cursor=0, bytesread=0;
 
    width = This->bih.bV5Width;
    height = abs(This->bih.bV5Height);
    bytesperrow = width * 4;
    datasize = bytesperrow * height;
    if (This->bih.bV5ClrUsed && This->bih.bV5ClrUsed < 256)
        palettesize = 4 * This->bih.bV5ClrUsed;
    else
        palettesize = 4 * 256;
 
    This->imagedata = HeapAlloc(GetProcessHeap(), 0, datasize);
    if (!This->imagedata)
    {
        hr = E_OUTOFMEMORY;
        goto fail;
    }
 
    /* read palette */
    offbits.QuadPart = This->palette_offset;
    hr = IStream_Seek(This->stream, offbits, STREAM_SEEK_SET, NULL);
    if (FAILED(hr)) goto fail;
 
    hr = IStream_Read(This->stream, palette, palettesize, &bytesread);
    if (FAILED(hr) || bytesread != palettesize) goto fail;
 
    /* read RLE data */
    offbits.QuadPart = This->image_offset;
    hr = IStream_Seek(This->stream, offbits, STREAM_SEEK_SET, NULL);
    if (FAILED(hr)) goto fail;
 
    /* decode RLE */
    bgrdata = (DWORD*)This->imagedata;
    x = 0;
    y = 0;
    cursor = 0;
    bytesread = 0;
    while (y < height)
    {
        BYTE length;
        hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &length);
 
        if (FAILED(hr))
            goto fail;
        else if (length == 0)
        {
            /* escape code */
            BYTE escape;
            hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &escape);
            if (FAILED(hr))
                goto fail;
            switch(escape)
            {
            case 0: /* end of line */
                x = 0;
                y++;
                break;
            case 1: /* end of bitmap */
                goto end;
            case 2: /* delta */
            {
                BYTE dx, dy;
                hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &dx);
                if (SUCCEEDED(hr))
                    hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &dy);
                if (FAILED(hr))
                    goto fail;
                x += dx;
                y += dy;
                break;
            }
            default: /* absolute mode */
                length = escape;
                while (length-- && x < width)
                {
                    BYTE index;
                    hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &index);
                    if (FAILED(hr))
                        goto fail;
                    bgrdata[y*width + x++] = palette[index];
                }
                if (escape & 1)
                    hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &length); /* skip pad byte */
                if (FAILED(hr))
                    goto fail;
            }
        }
        else
        {
            BYTE index;
            DWORD color;
            hr = ReadByte(This->stream, rledata, 4096, &cursor, &bytesread, &index);
            if (FAILED(hr))
                goto fail;
            color = palette[index];
            while (length-- && x < width)
                bgrdata[y*width + x++] = color;
        }
    }
 
end:
    This->imagedatastart = This->imagedata + (height-1) * bytesperrow;
    This->stride = -bytesperrow;
 
    return S_OK;
 
fail:
    HeapFree(GetProcessHeap(), 0, This->imagedata);
    This->imagedata = NULL;
    if (SUCCEEDED(hr)) hr = E_FAIL;
    return hr;
}

Referenced by BmpDecoder_ReadHeaders().

BmpFrameDecode_ReadUncompressed()

static HRESULT BmpFrameDecode_ReadUncompressed ( BmpDecoder *  This )

static

Definition at line 363 of file bmpdecode.c.

{
    UINT bytesperrow;
    UINT width, height;
    UINT datasize;
    int bottomup;
    HRESULT hr;
    LARGE_INTEGER offbits;
    ULONG bytesread;
 
    if (This->bih.bV5Size == sizeof(BITMAPCOREHEADER))
    {
        BITMAPCOREHEADER *bch = (BITMAPCOREHEADER*)&This->bih;
        width = bch->bcWidth;
        height = bch->bcHeight;
        bottomup = 1;
    }
    else
    {
        width = This->bih.bV5Width;
        height = abs(This->bih.bV5Height);
        bottomup = (This->bih.bV5Height > 0);
    }
 
    /* row sizes in BMP files must be divisible by 4 bytes */
    bytesperrow = (((width * This->bitsperpixel)+31)/32)*4;
    datasize = bytesperrow * height;
 
    This->imagedata = HeapAlloc(GetProcessHeap(), 0, datasize);
    if (!This->imagedata) return E_OUTOFMEMORY;
 
    offbits.QuadPart = This->image_offset;
    hr = IStream_Seek(This->stream, offbits, STREAM_SEEK_SET, NULL);
    if (FAILED(hr)) goto fail;
 
    hr = IStream_Read(This->stream, This->imagedata, datasize, &bytesread);
    if (FAILED(hr) || bytesread != datasize) goto fail;
 
    if (bottomup)
    {
        This->imagedatastart = This->imagedata + (height-1) * bytesperrow;
        This->stride = -bytesperrow;
    }
    else
    {
        This->imagedatastart = This->imagedata;
        This->stride = bytesperrow;
    }
    return S_OK;
 
fail:
    HeapFree(GetProcessHeap(), 0, This->imagedata);
    This->imagedata = NULL;
    if (SUCCEEDED(hr)) hr = E_FAIL;
    return hr;
}

Referenced by BmpDecoder_FindIconMask(), BmpDecoder_ReadHeaders(), and BmpFrameDecode_ReadRGB8().

BmpFrameDecode_ReadUnsupported()

static HRESULT BmpFrameDecode_ReadUnsupported ( BmpDecoder *  This )

static

Definition at line 727 of file bmpdecode.c.

{
    return E_FAIL;
}

Referenced by BmpDecoder_QueryCapability(), and BmpDecoder_ReadHeaders().

BmpFrameDecode_Release()

static ULONG WINAPI BmpFrameDecode_Release ( IWICBitmapFrameDecode *  iface )

static

Definition at line 125 of file bmpdecode.c.

{
    BmpDecoder *This = impl_from_IWICBitmapFrameDecode(iface);
 
    return IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
}

BmpHeader_GetResolution()

static HRESULT BmpHeader_GetResolution ( BITMAPV5HEADER *  bih, double *  pDpiX, double *  pDpiY  )

static

Definition at line 163 of file bmpdecode.c.

{
    LONG resx = 0, resy = 0;
 
    switch (bih->bV5Size)
    {
    default:
    case sizeof(BITMAPCOREHEADER):
        break;
 
    case sizeof(BITMAPCOREHEADER2):
    case sizeof(BITMAPINFOHEADER):
    case sizeof(BITMAPV4HEADER):
    case sizeof(BITMAPV5HEADER):
        resx = bih->bV5XPelsPerMeter;
        resy = bih->bV5YPelsPerMeter;
        break;
    }
 
    if (!resx || !resy)
    {
        *pDpiX = 96.0;
        *pDpiY = 96.0;
    }
    else
    {
        *pDpiX = resx * 0.0254;
        *pDpiY = resy * 0.0254;
    }
 
    return S_OK;
}

Referenced by BmpFrameDecode_GetResolution().

DibDecoder_CreateInstance()

HRESULT DibDecoder_CreateInstance	(	REFIID	iid,
		void **	ppv
	)

Definition at line 1200 of file bmpdecode.c.

{
    return BmpDecoder_Construct(TRUE, FALSE, iid, ppv);
}

IcoDibDecoder_CreateInstance()

HRESULT IcoDibDecoder_CreateInstance

(

BmpDecoder **

ppDecoder

)

Definition at line 1205 of file bmpdecode.c.

{
    return BmpDecoder_Create(TRUE, TRUE, ppDecoder);
}

Referenced by ReadIcoDib().

impl_from_IWICBitmapDecoder()

static BmpDecoder * impl_from_IWICBitmapDecoder ( IWICBitmapDecoder *  iface )

inlinestatic

Definition at line 83 of file bmpdecode.c.

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

Referenced by BmpDecoder_AddRef(), BmpDecoder_GetFrame(), BmpDecoder_Initialize(), BmpDecoder_QueryCapability(), BmpDecoder_QueryInterface(), and BmpDecoder_Release().

impl_from_IWICBitmapFrameDecode()

static BmpDecoder * impl_from_IWICBitmapFrameDecode ( IWICBitmapFrameDecode *  iface )

inlinestatic

Definition at line 88 of file bmpdecode.c.

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

Referenced by BmpFrameDecode_AddRef(), BmpFrameDecode_CopyPalette(), BmpFrameDecode_CopyPixels(), BmpFrameDecode_GetPixelFormat(), BmpFrameDecode_GetResolution(), BmpFrameDecode_GetSize(), BmpFrameDecode_QueryInterface(), and BmpFrameDecode_Release().

ReadByte()

static HRESULT ReadByte ( IStream *  stream, BYTE *  buffer, ULONG  buffer_size, ULONG *  cursor, ULONG *  bytesread, BYTE *  result  )

static

Definition at line 441 of file bmpdecode.c.

{
    HRESULT hr=S_OK;
 
    if (*bytesread == 0 || *cursor == *bytesread)
    {
        hr = IStream_Read(stream, buffer, buffer_size, bytesread);
        *cursor = 0;
    }
 
    if (SUCCEEDED(hr))
    {
        if (*cursor < *bytesread)
            *result = buffer[(*cursor)++];
        else
            hr = E_FAIL;
    }
 
    return hr;
}

Referenced by BmpFrameDecode_ReadRLE4(), and BmpFrameDecode_ReadRLE8().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

wincodecs

)

Variable Documentation

bitfields_formats

const struct bitfields_format bitfields_formats[]

static

Initial value:

= {
    {16,0x7c00,0x3e0,0x1f,0,&GUID_WICPixelFormat16bppBGR555,BmpFrameDecode_ReadUncompressed},
    {16,0xf800,0x7e0,0x1f,0,&GUID_WICPixelFormat16bppBGR565,BmpFrameDecode_ReadUncompressed},
    {32,0xff0000,0xff00,0xff,0,&GUID_WICPixelFormat32bppBGR,BmpFrameDecode_ReadUncompressed},
    {32,0xff0000,0xff00,0xff,0xff000000,&GUID_WICPixelFormat32bppBGRA,BmpFrameDecode_ReadUncompressed},
    {32,0xff000000,0xff0000,0xff00,0xff,&GUID_WICPixelFormat32bppRGBA,BmpFrameDecode_ReadUncompressed},
    {32,0xff,0xff00,0xff0000,0,&GUID_WICPixelFormat32bppBGR,BmpFrameDecode_ReadRGB8},
    {0}
}

Definition at line 742 of file bmpdecode.c.

Referenced by BmpDecoder_ReadHeaders().

BmpDecoder_FrameVtbl

const IWICBitmapFrameDecodeVtbl BmpDecoder_FrameVtbl

static

Initial value:

= {
    BmpFrameDecode_QueryInterface,
    BmpFrameDecode_AddRef,
    BmpFrameDecode_Release,
    BmpFrameDecode_GetSize,
    BmpFrameDecode_GetPixelFormat,
    BmpFrameDecode_GetResolution,
    BmpFrameDecode_CopyPalette,
    BmpFrameDecode_CopyPixels,
    BmpFrameDecode_GetMetadataQueryReader,
    BmpFrameDecode_GetColorContexts,
    BmpFrameDecode_GetThumbnail
}

Definition at line 752 of file bmpdecode.c.

Referenced by BmpDecoder_Create().

BmpDecoder_Vtbl

const IWICBitmapDecoderVtbl BmpDecoder_Vtbl

static

Initial value:

= {
    BmpDecoder_QueryInterface,
    BmpDecoder_AddRef,
    BmpDecoder_Release,
    BmpDecoder_QueryCapability,
    BmpDecoder_Initialize,
    BmpDecoder_GetContainerFormat,
    BmpDecoder_GetDecoderInfo,
    BmpDecoder_CopyPalette,
    BmpDecoder_GetMetadataQueryReader,
    BmpDecoder_GetPreview,
    BmpDecoder_GetColorContexts,
    BmpDecoder_GetThumbnail,
    BmpDecoder_GetFrameCount,
    BmpDecoder_GetFrame
}

Definition at line 1137 of file bmpdecode.c.

Referenced by BmpDecoder_Create().