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

Include dependency graph for scaler.c:

Go to the source code of this file.

Classes
struct	BitmapScaler

Macros
#define	COBJMACROS

Typedefs
typedef struct BitmapScaler	BitmapScaler

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (wincodecs)

static BitmapScaler *	impl_from_IWICBitmapScaler (IWICBitmapScaler *iface)

static BitmapScaler *	impl_from_IMILBitmapScaler (IMILBitmapScaler *iface)

static HRESULT WINAPI	BitmapScaler_QueryInterface (IWICBitmapScaler iface, REFIID iid, void *ppv)

static ULONG WINAPI	BitmapScaler_AddRef (IWICBitmapScaler *iface)

static ULONG WINAPI	BitmapScaler_Release (IWICBitmapScaler *iface)

static HRESULT WINAPI	BitmapScaler_GetSize (IWICBitmapScaler iface, UINT puiWidth, UINT *puiHeight)

static HRESULT WINAPI	BitmapScaler_GetPixelFormat (IWICBitmapScaler iface, WICPixelFormatGUID pPixelFormat)

static HRESULT WINAPI	BitmapScaler_GetResolution (IWICBitmapScaler iface, double pDpiX, double *pDpiY)

static HRESULT WINAPI	BitmapScaler_CopyPalette (IWICBitmapScaler iface, IWICPalette pIPalette)

static void	NearestNeighbor_GetRequiredSourceRect (BitmapScaler This, UINT x, UINT y, WICRect src_rect)

static void	NearestNeighbor_CopyScanline (BitmapScaler This, UINT dst_x, UINT dst_y, UINT dst_width, BYTE src_data, UINT src_data_x, UINT src_data_y, BYTE pbBuffer)

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

static HRESULT WINAPI	BitmapScaler_Initialize (IWICBitmapScaler iface, IWICBitmapSource pISource, UINT uiWidth, UINT uiHeight, WICBitmapInterpolationMode mode)

static HRESULT WINAPI	IMILBitmapScaler_QueryInterface (IMILBitmapScaler iface, REFIID iid, void *ppv)

static ULONG WINAPI	IMILBitmapScaler_AddRef (IMILBitmapScaler *iface)

static ULONG WINAPI	IMILBitmapScaler_Release (IMILBitmapScaler *iface)

static HRESULT WINAPI	IMILBitmapScaler_GetSize (IMILBitmapScaler iface, UINT width, UINT *height)

static HRESULT WINAPI	IMILBitmapScaler_GetPixelFormat (IMILBitmapScaler iface, int format)

static HRESULT WINAPI	IMILBitmapScaler_GetResolution (IMILBitmapScaler iface, double dpix, double *dpiy)

static HRESULT WINAPI	IMILBitmapScaler_CopyPalette (IMILBitmapScaler iface, IWICPalette palette)

static HRESULT WINAPI	IMILBitmapScaler_CopyPixels (IMILBitmapScaler iface, const WICRect rc, UINT stride, UINT size, BYTE *buffer)

static HRESULT WINAPI	IMILBitmapScaler_unknown1 (IMILBitmapScaler iface, void *ppv)

static HRESULT WINAPI	IMILBitmapScaler_Initialize (IMILBitmapScaler iface, IMILBitmapSource mil_source, UINT width, UINT height, WICBitmapInterpolationMode mode)

HRESULT	BitmapScaler_Create (IWICBitmapScaler **scaler)

Variables
static const IWICBitmapScalerVtbl	BitmapScaler_Vtbl

static const IMILBitmapScalerVtbl	IMILBitmapScaler_Vtbl

Macro Definition Documentation

◆ COBJMACROS

#define COBJMACROS

Definition at line 24 of file scaler.c.

Typedef Documentation

◆ BitmapScaler

typedef struct BitmapScaler BitmapScaler

Function Documentation

◆ BitmapScaler_AddRef()

static ULONG WINAPI BitmapScaler_AddRef ( IWICBitmapScaler * iface )

static

Definition at line 89 of file scaler.c.

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

◆ BitmapScaler_CopyPalette()

static HRESULT WINAPI BitmapScaler_CopyPalette	(	IWICBitmapScaler *	iface,
		IWICPalette *	pIPalette
	)

static

Definition at line 168 of file scaler.c.

{
    BitmapScaler *This = impl_from_IWICBitmapScaler(iface);
    TRACE("(%p,%p)\n", iface, pIPalette);
 
    if (!pIPalette)
        return E_INVALIDARG;
 
    if (!This->source)
        return WINCODEC_ERR_PALETTEUNAVAILABLE;
 
    return IWICBitmapSource_CopyPalette(This->source, pIPalette);
}

◆ BitmapScaler_CopyPixels()

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

static

Definition at line 208 of file scaler.c.

{
    BitmapScaler *This = impl_from_IWICBitmapScaler(iface);
    HRESULT hr;
    WICRect dest_rect;
    WICRect src_rect_ul, src_rect_br, src_rect;
    BYTE **src_rows;
    BYTE *src_bits;
    ULONG bytesperrow;
    ULONG src_bytesperrow;
    ULONG buffer_size;
    UINT y;
 
    TRACE("(%p,%s,%u,%u,%p)\n", iface, debug_wic_rect(prc), cbStride, cbBufferSize, pbBuffer);
 
    EnterCriticalSection(&This->lock);
 
    if (!This->source)
    {
        hr = WINCODEC_ERR_NOTINITIALIZED;
        goto end;
    }
 
    if (prc)
        dest_rect = *prc;
    else
    {
        dest_rect.X = dest_rect.Y = 0;
        dest_rect.Width = This->width;
        dest_rect.Height = This->height;
    }
 
    if (dest_rect.X < 0 || dest_rect.Y < 0 ||
        dest_rect.X+dest_rect.Width > This->width|| dest_rect.Y+dest_rect.Height > This->height)
    {
        hr = E_INVALIDARG;
        goto end;
    }
 
    bytesperrow = ((This->bpp * dest_rect.Width)+7)/8;
 
    if (cbStride < bytesperrow)
    {
        hr = E_INVALIDARG;
        goto end;
    }
 
    if ((cbStride * dest_rect.Height) > cbBufferSize)
    {
        hr = E_INVALIDARG;
        goto end;
    }
 
    /* MSDN recommends calling CopyPixels once for each scanline from top to
     * bottom, and claims codecs optimize for this. Ideally, when called in this
     * way, we should avoid requesting a scanline from the source more than
     * once, by saving the data that will be useful for the next scanline after
     * the call returns. The GetRequiredSourceRect/CopyScanline functions are
     * designed to make it possible to do this in a generic way, but for now we
     * just grab all the data we need in each call. */
 
    This->fn_get_required_source_rect(This, dest_rect.X, dest_rect.Y, &src_rect_ul);
    This->fn_get_required_source_rect(This, dest_rect.X+dest_rect.Width-1,
        dest_rect.Y+dest_rect.Height-1, &src_rect_br);
 
    src_rect.X = src_rect_ul.X;
    src_rect.Y = src_rect_ul.Y;
    src_rect.Width = src_rect_br.Width + src_rect_br.X - src_rect_ul.X;
    src_rect.Height = src_rect_br.Height + src_rect_br.Y - src_rect_ul.Y;
 
    src_bytesperrow = (src_rect.Width * This->bpp + 7)/8;
    buffer_size = src_bytesperrow * src_rect.Height;
 
    src_rows = HeapAlloc(GetProcessHeap(), 0, sizeof(BYTE*) * src_rect.Height);
    src_bits = HeapAlloc(GetProcessHeap(), 0, buffer_size);
 
    if (!src_rows || !src_bits)
    {
        HeapFree(GetProcessHeap(), 0, src_rows);
        HeapFree(GetProcessHeap(), 0, src_bits);
        hr = E_OUTOFMEMORY;
        goto end;
    }
 
    for (y=0; y<src_rect.Height; y++)
        src_rows[y] = src_bits + y * src_bytesperrow;
 
    hr = IWICBitmapSource_CopyPixels(This->source, &src_rect, src_bytesperrow,
        buffer_size, src_bits);
 
    if (SUCCEEDED(hr))
    {
        for (y=0; y < dest_rect.Height; y++)
        {
            This->fn_copy_scanline(This, dest_rect.X, dest_rect.Y+y, dest_rect.Width,
                src_rows, src_rect.X, src_rect.Y, pbBuffer + cbStride * y);
        }
    }
 
    HeapFree(GetProcessHeap(), 0, src_rows);
    HeapFree(GetProcessHeap(), 0, src_bits);
 
end:
    LeaveCriticalSection(&This->lock);
 
    return hr;
}

◆ BitmapScaler_Create()

HRESULT BitmapScaler_Create ( IWICBitmapScaler ** scaler )

Definition at line 515 of file scaler.c.

{
    BitmapScaler *This;
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(BitmapScaler));
    if (!This) return E_OUTOFMEMORY;
 
    This->IWICBitmapScaler_iface.lpVtbl = &BitmapScaler_Vtbl;
    This->IMILBitmapScaler_iface.lpVtbl = &IMILBitmapScaler_Vtbl;
    This->ref = 1;
    This->source = NULL;
    This->width = 0;
    This->height = 0;
    This->src_width = 0;
    This->src_height = 0;
    This->mode = 0;
    This->bpp = 0;
    InitializeCriticalSection(&This->lock);
    This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": BitmapScaler.lock");
 
    *scaler = &This->IWICBitmapScaler_iface;
 
    return S_OK;
}

Referenced by ImagingFactory_CreateBitmapScaler().

◆ BitmapScaler_GetPixelFormat()

static HRESULT WINAPI BitmapScaler_GetPixelFormat	(	IWICBitmapScaler *	iface,
		WICPixelFormatGUID *	pPixelFormat
	)

static

Definition at line 135 of file scaler.c.

{
    BitmapScaler *This = impl_from_IWICBitmapScaler(iface);
    TRACE("(%p,%p)\n", iface, pPixelFormat);
 
    if (!pPixelFormat)
        return E_INVALIDARG;
 
    if (!This->source)
    {
        memcpy(pPixelFormat, &GUID_WICPixelFormatDontCare, sizeof(*pPixelFormat));
        return S_OK;
    }
 
    return IWICBitmapSource_GetPixelFormat(This->source, pPixelFormat);
}

◆ BitmapScaler_GetResolution()

static HRESULT WINAPI BitmapScaler_GetResolution	(	IWICBitmapScaler *	iface,
		double *	pDpiX,
		double *	pDpiY
	)

static

Definition at line 153 of file scaler.c.

{
    BitmapScaler *This = impl_from_IWICBitmapScaler(iface);
    TRACE("(%p,%p,%p)\n", iface, pDpiX, pDpiY);
 
    if (!This->source)
        return WINCODEC_ERR_NOTINITIALIZED;
 
    if (!pDpiX || !pDpiY)
        return E_INVALIDARG;
 
    return IWICBitmapSource_GetResolution(This->source, pDpiX, pDpiY);
}

◆ BitmapScaler_GetSize()

static HRESULT WINAPI BitmapScaler_GetSize	(	IWICBitmapScaler *	iface,
		UINT *	puiWidth,
		UINT *	puiHeight
	)

static

Definition at line 117 of file scaler.c.

{
    BitmapScaler *This = impl_from_IWICBitmapScaler(iface);
    TRACE("(%p,%p,%p)\n", iface, puiWidth, puiHeight);
 
    if (!This->source)
        return WINCODEC_ERR_NOTINITIALIZED;
 
    if (!puiWidth || !puiHeight)
        return E_INVALIDARG;
 
    *puiWidth = This->width;
    *puiHeight = This->height;
 
    return S_OK;
}

◆ BitmapScaler_Initialize()

static HRESULT WINAPI BitmapScaler_Initialize	(	IWICBitmapScaler *	iface,
		IWICBitmapSource *	pISource,
		UINT	uiWidth,
		UINT	uiHeight,
		WICBitmapInterpolationMode	mode
	)

static

Definition at line 317 of file scaler.c.

{
    BitmapScaler *This = impl_from_IWICBitmapScaler(iface);
    HRESULT hr;
    GUID src_pixelformat;
 
    TRACE("(%p,%p,%u,%u,%u)\n", iface, pISource, uiWidth, uiHeight, mode);
 
    if (!pISource || !uiWidth || !uiHeight)
        return E_INVALIDARG;
 
    EnterCriticalSection(&This->lock);
 
    if (This->source)
    {
        hr = WINCODEC_ERR_WRONGSTATE;
        goto end;
    }
 
    This->width = uiWidth;
    This->height = uiHeight;
    This->mode = mode;
 
    hr = IWICBitmapSource_GetSize(pISource, &This->src_width, &This->src_height);
 
    if (SUCCEEDED(hr))
        hr = IWICBitmapSource_GetPixelFormat(pISource, &src_pixelformat);
 
    if (SUCCEEDED(hr))
    {
        hr = get_pixelformat_bpp(&src_pixelformat, &This->bpp);
    }
 
    if (SUCCEEDED(hr))
    {
        switch (mode)
        {
        default:
            FIXME("unsupported mode %i\n", mode);
            /* fall-through */
        case WICBitmapInterpolationModeNearestNeighbor:
            if ((This->bpp % 8) == 0)
            {
                IWICBitmapSource_AddRef(pISource);
                This->source = pISource;
            }
            else
            {
                hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA,
                    pISource, &This->source);
                This->bpp = 32;
            }
            This->fn_get_required_source_rect = NearestNeighbor_GetRequiredSourceRect;
            This->fn_copy_scanline = NearestNeighbor_CopyScanline;
            break;
        }
    }
 
end:
    LeaveCriticalSection(&This->lock);
 
    return hr;
}

◆ BitmapScaler_QueryInterface()

static HRESULT WINAPI BitmapScaler_QueryInterface	(	IWICBitmapScaler *	iface,
		REFIID	iid,
		void **	ppv
	)

static

Definition at line 60 of file scaler.c.

{
    BitmapScaler *This = impl_from_IWICBitmapScaler(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_IWICBitmapScaler, iid))
    {
        *ppv = &This->IWICBitmapScaler_iface;
    }
    else if (IsEqualIID(&IID_IMILBitmapScaler, iid))
    {
        *ppv = &This->IMILBitmapScaler_iface;
    }
    else
    {
        FIXME("unknown interface %s\n", debugstr_guid(iid));
        *ppv = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

◆ BitmapScaler_Release()

static ULONG WINAPI BitmapScaler_Release ( IWICBitmapScaler * iface )

static

Definition at line 99 of file scaler.c.

{
    BitmapScaler *This = impl_from_IWICBitmapScaler(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->source) IWICBitmapSource_Release(This->source);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}

◆ IMILBitmapScaler_AddRef()

static ULONG WINAPI IMILBitmapScaler_AddRef ( IMILBitmapScaler * iface )

static

Definition at line 403 of file scaler.c.

{
    BitmapScaler *This = impl_from_IMILBitmapScaler(iface);
    return IWICBitmapScaler_AddRef(&This->IWICBitmapScaler_iface);
}

◆ IMILBitmapScaler_CopyPalette()

static HRESULT WINAPI IMILBitmapScaler_CopyPalette	(	IMILBitmapScaler *	iface,
		IWICPalette *	palette
	)

static

Definition at line 454 of file scaler.c.

{
    BitmapScaler *This = impl_from_IMILBitmapScaler(iface);
 
    TRACE("(%p,%p)\n", iface, palette);
 
    if (!This->source)
        return WINCODEC_ERR_NOTINITIALIZED;
 
    return IWICBitmapScaler_CopyPalette(&This->IWICBitmapScaler_iface, palette);
}

◆ IMILBitmapScaler_CopyPixels()

static HRESULT WINAPI IMILBitmapScaler_CopyPixels	(	IMILBitmapScaler *	iface,
		const WICRect *	rc,
		UINT	stride,
		UINT	size,
		BYTE *	buffer
	)

static

Definition at line 467 of file scaler.c.

{
    BitmapScaler *This = impl_from_IMILBitmapScaler(iface);
    TRACE("(%p,%p,%u,%u,%p)\n", iface, rc, stride, size, buffer);
    return IWICBitmapScaler_CopyPixels(&This->IWICBitmapScaler_iface, rc, stride, size, buffer);
}

◆ IMILBitmapScaler_GetPixelFormat()

static HRESULT WINAPI IMILBitmapScaler_GetPixelFormat	(	IMILBitmapScaler *	iface,
		int *	format
	)

static

Definition at line 423 of file scaler.c.

{
    BitmapScaler *This = impl_from_IMILBitmapScaler(iface);
    IMILBitmapSource *source;
    HRESULT hr;
 
    TRACE("(%p,%p)\n", iface, format);
 
    if (!format) return E_INVALIDARG;
 
    if (!This->source)
        return WINCODEC_ERR_NOTINITIALIZED;
 
    hr = IWICBitmapSource_QueryInterface(This->source, &IID_IMILBitmapSource, (void **)&source);
    if (hr == S_OK)
    {
        hr = source->lpVtbl->GetPixelFormat(source, format);
        source->lpVtbl->Release(source);
    }
    return hr;
}

◆ IMILBitmapScaler_GetResolution()

static HRESULT WINAPI IMILBitmapScaler_GetResolution	(	IMILBitmapScaler *	iface,
		double *	dpix,
		double *	dpiy
	)

static

Definition at line 446 of file scaler.c.

{
    BitmapScaler *This = impl_from_IMILBitmapScaler(iface);
    TRACE("(%p,%p,%p)\n", iface, dpix, dpiy);
    return IWICBitmapScaler_GetResolution(&This->IWICBitmapScaler_iface, dpix, dpiy);
}

◆ IMILBitmapScaler_GetSize()

static HRESULT WINAPI IMILBitmapScaler_GetSize	(	IMILBitmapScaler *	iface,
		UINT *	width,
		UINT *	height
	)

static

Definition at line 415 of file scaler.c.

{
    BitmapScaler *This = impl_from_IMILBitmapScaler(iface);
    TRACE("(%p,%p,%p)\n", iface, width, height);
    return IWICBitmapScaler_GetSize(&This->IWICBitmapScaler_iface, width, height);
}

◆ IMILBitmapScaler_Initialize()

static HRESULT WINAPI IMILBitmapScaler_Initialize	(	IMILBitmapScaler *	iface,
		IMILBitmapSource *	mil_source,
		UINT	width,
		UINT	height,
		WICBitmapInterpolationMode	mode
	)

static

Definition at line 481 of file scaler.c.

{
    BitmapScaler *This = impl_from_IMILBitmapScaler(iface);
    IWICBitmapSource *wic_source;
    HRESULT hr;
 
    TRACE("(%p,%p,%u,%u,%u)\n", iface, mil_source, width, height, mode);
 
    if (!mil_source) return E_INVALIDARG;
 
    hr = mil_source->lpVtbl->QueryInterface(mil_source, &IID_IWICBitmapSource, (void **)&wic_source);
    if (hr == S_OK)
    {
        hr = IWICBitmapScaler_Initialize(&This->IWICBitmapScaler_iface, wic_source, width, height, mode);
        IWICBitmapSource_Release(wic_source);
    }
    return hr;
}

◆ IMILBitmapScaler_QueryInterface()

static HRESULT WINAPI IMILBitmapScaler_QueryInterface	(	IMILBitmapScaler *	iface,
		REFIID	iid,
		void **	ppv
	)

static

Definition at line 395 of file scaler.c.

{
    BitmapScaler *This = impl_from_IMILBitmapScaler(iface);
    TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
    return IWICBitmapScaler_QueryInterface(&This->IWICBitmapScaler_iface, iid, ppv);
}

◆ IMILBitmapScaler_Release()

static ULONG WINAPI IMILBitmapScaler_Release ( IMILBitmapScaler * iface )

static

Definition at line 409 of file scaler.c.

{
    BitmapScaler *This = impl_from_IMILBitmapScaler(iface);
    return IWICBitmapScaler_Release(&This->IWICBitmapScaler_iface);
}

◆ IMILBitmapScaler_unknown1()

static HRESULT WINAPI IMILBitmapScaler_unknown1	(	IMILBitmapScaler *	iface,
		void **	ppv
	)

static

Definition at line 475 of file scaler.c.

{
    TRACE("(%p,%p)\n", iface, ppv);
    return E_NOINTERFACE;
}

◆ impl_from_IMILBitmapScaler()

static BitmapScaler * impl_from_IMILBitmapScaler ( IMILBitmapScaler * iface )

inlinestatic

Definition at line 55 of file scaler.c.

{
    return CONTAINING_RECORD(iface, BitmapScaler, IMILBitmapScaler_iface);
}

Referenced by IMILBitmapScaler_AddRef(), IMILBitmapScaler_CopyPalette(), IMILBitmapScaler_CopyPixels(), IMILBitmapScaler_GetPixelFormat(), IMILBitmapScaler_GetResolution(), IMILBitmapScaler_GetSize(), IMILBitmapScaler_Initialize(), IMILBitmapScaler_QueryInterface(), and IMILBitmapScaler_Release().

◆ impl_from_IWICBitmapScaler()

static BitmapScaler * impl_from_IWICBitmapScaler ( IWICBitmapScaler * iface )

inlinestatic

Definition at line 50 of file scaler.c.

{
    return CONTAINING_RECORD(iface, BitmapScaler, IWICBitmapScaler_iface);
}

Referenced by BitmapScaler_AddRef(), BitmapScaler_CopyPalette(), BitmapScaler_CopyPixels(), BitmapScaler_GetPixelFormat(), BitmapScaler_GetResolution(), BitmapScaler_GetSize(), BitmapScaler_Initialize(), BitmapScaler_QueryInterface(), and BitmapScaler_Release().

◆ NearestNeighbor_CopyScanline()

static void NearestNeighbor_CopyScanline	(	BitmapScaler *	This,
		UINT	dst_x,
		UINT	dst_y,
		UINT	dst_width,
		BYTE **	src_data,
		UINT	src_data_x,
		UINT	src_data_y,
		BYTE *	pbBuffer
	)

static

Definition at line 191 of file scaler.c.

{
    UINT i;
    UINT bytesperpixel = This->bpp/8;
    UINT src_x, src_y;
 
    src_y = dst_y * This->src_height / This->height - src_data_y;
 
    for (i=0; i<dst_width; i++)
    {
        src_x = (dst_x + i) * This->src_width / This->width - src_data_x;
        memcpy(pbBuffer + bytesperpixel * i, src_data[src_y] + bytesperpixel * src_x, bytesperpixel);
    }
}

Referenced by BitmapScaler_Initialize().

◆ NearestNeighbor_GetRequiredSourceRect()

static void NearestNeighbor_GetRequiredSourceRect	(	BitmapScaler *	This,
		UINT	x,
		UINT	y,
		WICRect *	src_rect
	)

static

Definition at line 183 of file scaler.c.

{
    src_rect->X = x * This->src_width / This->width;
    src_rect->Y = y * This->src_height / This->height;
    src_rect->Width = src_rect->Height = 1;
}

Referenced by BitmapScaler_Initialize().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( wincodecs )

Variable Documentation

◆ BitmapScaler_Vtbl

const IWICBitmapScalerVtbl BitmapScaler_Vtbl

static

Initial value:

= {
    BitmapScaler_QueryInterface,
    BitmapScaler_AddRef,
    BitmapScaler_Release,
    BitmapScaler_GetSize,
    BitmapScaler_GetPixelFormat,
    BitmapScaler_GetResolution,
    BitmapScaler_CopyPalette,
    BitmapScaler_CopyPixels,
    BitmapScaler_Initialize
}

Definition at line 383 of file scaler.c.

Referenced by BitmapScaler_Create().

◆ IMILBitmapScaler_Vtbl

const IMILBitmapScalerVtbl IMILBitmapScaler_Vtbl

static

Initial value:

= {
    IMILBitmapScaler_QueryInterface,
    IMILBitmapScaler_AddRef,
    IMILBitmapScaler_Release,
    IMILBitmapScaler_GetSize,
    IMILBitmapScaler_GetPixelFormat,
    IMILBitmapScaler_GetResolution,
    IMILBitmapScaler_CopyPalette,
    IMILBitmapScaler_CopyPixels,
    IMILBitmapScaler_unknown1,
    IMILBitmapScaler_Initialize
}

Definition at line 502 of file scaler.c.

Referenced by BitmapScaler_Create().

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ COBJMACROS

Typedef Documentation

◆ BitmapScaler

Function Documentation

◆ BitmapScaler_AddRef()

◆ BitmapScaler_CopyPalette()

◆ BitmapScaler_CopyPixels()

◆ BitmapScaler_Create()

◆ BitmapScaler_GetPixelFormat()

◆ BitmapScaler_GetResolution()

◆ BitmapScaler_GetSize()

◆ BitmapScaler_Initialize()

◆ BitmapScaler_QueryInterface()

◆ BitmapScaler_Release()

◆ IMILBitmapScaler_AddRef()

◆ IMILBitmapScaler_CopyPalette()

◆ IMILBitmapScaler_CopyPixels()

◆ IMILBitmapScaler_GetPixelFormat()

◆ IMILBitmapScaler_GetResolution()

◆ IMILBitmapScaler_GetSize()

◆ IMILBitmapScaler_Initialize()

◆ IMILBitmapScaler_QueryInterface()

◆ IMILBitmapScaler_Release()

◆ IMILBitmapScaler_unknown1()

◆ impl_from_IMILBitmapScaler()

◆ impl_from_IWICBitmapScaler()

◆ NearestNeighbor_CopyScanline()

◆ NearestNeighbor_GetRequiredSourceRect()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

Variable Documentation

◆ BitmapScaler_Vtbl

◆ IMILBitmapScaler_Vtbl