bitmap.c File Reference

#include "d2d1_private.h"
#include "wincodec.h"

Include dependency graph for bitmap.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (d2d)
static struct d2d_bitmap *	impl_from_ID2D1Bitmap1 (ID2D1Bitmap1 *iface)
static HRESULT	d2d_bitmap_unmap (struct d2d_bitmap *bitmap)
static HRESULT STDMETHODCALLTYPE	d2d_bitmap_QueryInterface (ID2D1Bitmap1 *iface, REFIID iid, void **out)
static ULONG STDMETHODCALLTYPE	d2d_bitmap_AddRef (ID2D1Bitmap1 *iface)
static ULONG STDMETHODCALLTYPE	d2d_bitmap_Release (ID2D1Bitmap1 *iface)
static void STDMETHODCALLTYPE	d2d_bitmap_GetFactory (ID2D1Bitmap1 *iface, ID2D1Factory **factory)
static D2D1_SIZE_F *STDMETHODCALLTYPE	d2d_bitmap_GetSize (ID2D1Bitmap1 *iface, D2D1_SIZE_F *size)
static D2D1_SIZE_U *STDMETHODCALLTYPE	d2d_bitmap_GetPixelSize (ID2D1Bitmap1 *iface, D2D1_SIZE_U *pixel_size)
static D2D1_PIXEL_FORMAT *STDMETHODCALLTYPE	d2d_bitmap_GetPixelFormat (ID2D1Bitmap1 *iface, D2D1_PIXEL_FORMAT *format)
static void STDMETHODCALLTYPE	d2d_bitmap_GetDpi (ID2D1Bitmap1 *iface, float *dpi_x, float *dpi_y)
static HRESULT STDMETHODCALLTYPE	d2d_bitmap_CopyFromBitmap (ID2D1Bitmap1 *iface, const D2D1_POINT_2U *dst_point, ID2D1Bitmap *bitmap, const D2D1_RECT_U *src_rect)
static HRESULT STDMETHODCALLTYPE	d2d_bitmap_CopyFromRenderTarget (ID2D1Bitmap1 *iface, const D2D1_POINT_2U *dst_point, ID2D1RenderTarget *render_target, const D2D1_RECT_U *src_rect)
static HRESULT STDMETHODCALLTYPE	d2d_bitmap_CopyFromMemory (ID2D1Bitmap1 *iface, const D2D1_RECT_U *dst_rect, const void *src_data, UINT32 pitch)
static void STDMETHODCALLTYPE	d2d_bitmap_GetColorContext (ID2D1Bitmap1 *iface, ID2D1ColorContext **context)
static D2D1_BITMAP_OPTIONS STDMETHODCALLTYPE	d2d_bitmap_GetOptions (ID2D1Bitmap1 *iface)
static HRESULT STDMETHODCALLTYPE	d2d_bitmap_GetSurface (ID2D1Bitmap1 *iface, IDXGISurface **surface)
static HRESULT STDMETHODCALLTYPE	d2d_bitmap_Map (ID2D1Bitmap1 *iface, D2D1_MAP_OPTIONS options, D2D1_MAPPED_RECT *mapped_rect)
static HRESULT STDMETHODCALLTYPE	d2d_bitmap_Unmap (ID2D1Bitmap1 *iface)
static BOOL	format_supported (const D2D1_PIXEL_FORMAT *format)
static void	d2d_bitmap_init (struct d2d_bitmap *bitmap, struct d2d_device_context *context, ID3D11Resource *resource, D2D1_SIZE_U size, const D2D1_BITMAP_PROPERTIES1 *desc)
static BOOL	check_bitmap_options (unsigned int options)
HRESULT	d2d_bitmap_create (struct d2d_device_context *context, D2D1_SIZE_U size, const void *src_data, UINT32 pitch, const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap)
unsigned int	d2d_get_bitmap_options_for_surface (IDXGISurface *surface)
HRESULT	d2d_bitmap_create_shared (struct d2d_device_context *context, REFIID iid, void *data, const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap)
HRESULT	d2d_bitmap_create_from_wic_bitmap (struct d2d_device_context *context, IWICBitmapSource *bitmap_source, const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap)
struct d2d_bitmap *	unsafe_impl_from_ID2D1Bitmap (ID2D1Bitmap *iface)

Variables
static const struct ID2D1Bitmap1Vtbl	d2d_bitmap_vtbl

Function Documentation

check_bitmap_options()

static BOOL check_bitmap_options ( unsigned int  options )

static

Definition at line 406 of file bitmap.c.

{
    switch (options)
    {
        case D2D1_BITMAP_OPTIONS_NONE:
        case D2D1_BITMAP_OPTIONS_TARGET:
        case D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW:
        case D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW | D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE:
        case D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE:
        case D2D1_BITMAP_OPTIONS_CANNOT_DRAW | D2D1_BITMAP_OPTIONS_CPU_READ:
            return TRUE;
        default:
            WARN("Invalid bitmap options %#x.\n", options);
            return FALSE;
    }
}

Referenced by d2d_bitmap_create().

d2d_bitmap_AddRef()

static ULONG STDMETHODCALLTYPE d2d_bitmap_AddRef ( ID2D1Bitmap1 *  iface )

static

Definition at line 69 of file bitmap.c.

{
    struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
    ULONG refcount = InterlockedIncrement(&bitmap->refcount);
 
    TRACE("%p increasing refcount to %lu.\n", iface, refcount);
 
    return refcount;
}

d2d_bitmap_CopyFromBitmap()

static HRESULT STDMETHODCALLTYPE d2d_bitmap_CopyFromBitmap ( ID2D1Bitmap1 *  iface, const D2D1_POINT_2U *  dst_point, ID2D1Bitmap *  bitmap, const D2D1_RECT_U *  src_rect  )

static

Definition at line 152 of file bitmap.c.

{
    struct d2d_bitmap *src_bitmap = unsafe_impl_from_ID2D1Bitmap(bitmap);
    struct d2d_bitmap *dst_bitmap = impl_from_ID2D1Bitmap1(iface);
    ID3D11DeviceContext *context;
    ID3D11Device *device;
    D3D11_BOX box;
 
    TRACE("iface %p, dst_point %p, bitmap %p, src_rect %p.\n", iface, dst_point, bitmap, src_rect);
 
    if (src_rect)
    {
        box.left = src_rect->left;
        box.top = src_rect->top;
        box.front = 0;
        box.right = src_rect->right;
        box.bottom = src_rect->bottom;
        box.back = 1;
    }
 
    ID3D11Resource_GetDevice(dst_bitmap->resource, &device);
    ID3D11Device_GetImmediateContext(device, &context);
    ID3D11DeviceContext_CopySubresourceRegion(context, dst_bitmap->resource, 0,
            dst_point ? dst_point->x : 0, dst_point ? dst_point->y : 0, 0,
            src_bitmap->resource, 0, src_rect ? &box : NULL);
    ID3D11DeviceContext_Release(context);
    ID3D11Device_Release(device);
 
    return S_OK;
}

d2d_bitmap_CopyFromMemory()

static HRESULT STDMETHODCALLTYPE d2d_bitmap_CopyFromMemory ( ID2D1Bitmap1 *  iface, const D2D1_RECT_U *  dst_rect, const void *  src_data, UINT32  pitch  )

static

Definition at line 192 of file bitmap.c.

{
    struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
    ID3D11DeviceContext *context;
    ID3D11Device *device;
    D3D11_BOX box;
 
    TRACE("iface %p, dst_rect %p, src_data %p, pitch %u.\n", iface, dst_rect, src_data, pitch);
 
    if (dst_rect)
    {
        box.left = dst_rect->left;
        box.top = dst_rect->top;
        box.front = 0;
        box.right = dst_rect->right;
        box.bottom = dst_rect->bottom;
        box.back = 1;
    }
 
    ID3D11Resource_GetDevice(bitmap->resource, &device);
    ID3D11Device_GetImmediateContext(device, &context);
    ID3D11DeviceContext_UpdateSubresource(context, bitmap->resource, 0, dst_rect ? &box : NULL, src_data, pitch, 0);
    ID3D11DeviceContext_Release(context);
    ID3D11Device_Release(device);
 
    return S_OK;
}

d2d_bitmap_CopyFromRenderTarget()

static HRESULT STDMETHODCALLTYPE d2d_bitmap_CopyFromRenderTarget ( ID2D1Bitmap1 *  iface, const D2D1_POINT_2U *  dst_point, ID2D1RenderTarget *  render_target, const D2D1_RECT_U *  src_rect  )

static

Definition at line 184 of file bitmap.c.

{
    FIXME("iface %p, dst_point %p, render_target %p, src_rect %p stub!\n", iface, dst_point, render_target, src_rect);
 
    return E_NOTIMPL;
}

d2d_bitmap_create()

HRESULT d2d_bitmap_create	(	struct d2d_device_context *	context,
		D2D1_SIZE_U	size,
		const void *	src_data,
		UINT32	pitch,
		const D2D1_BITMAP_PROPERTIES1 *	desc,
		struct d2d_bitmap **	bitmap
	)

Definition at line 423 of file bitmap.c.

{
    D3D11_SUBRESOURCE_DATA resource_data;
    D2D1_BITMAP_PROPERTIES1 bitmap_desc;
    D3D11_TEXTURE2D_DESC texture_desc;
    ID3D11Texture2D *texture;
    HRESULT hr;
 
    if (!format_supported(&desc->pixelFormat))
    {
        WARN("Tried to create bitmap with unsupported format {%#x / %#x}.\n",
                desc->pixelFormat.format, desc->pixelFormat.alphaMode);
        return D2DERR_UNSUPPORTED_PIXEL_FORMAT;
    }
 
    if (desc->dpiX == 0.0f && desc->dpiY == 0.0f)
    {
        bitmap_desc = *desc;
        bitmap_desc.dpiX = context->desc.dpiX;
        bitmap_desc.dpiY = context->desc.dpiY;
        desc = &bitmap_desc;
    }
    else if (desc->dpiX <= 0.0f || desc->dpiY <= 0.0f)
    {
        return E_INVALIDARG;
    }
 
    if (!check_bitmap_options(desc->bitmapOptions))
        return E_INVALIDARG;
 
    texture_desc.Width = size.width;
    texture_desc.Height = size.height;
    if (!texture_desc.Width || !texture_desc.Height)
        texture_desc.Width = texture_desc.Height = 1;
    texture_desc.MipLevels = 1;
    texture_desc.ArraySize = 1;
    texture_desc.Format = desc->pixelFormat.format;
    texture_desc.SampleDesc.Count = 1;
    texture_desc.SampleDesc.Quality = 0;
    texture_desc.Usage = D3D11_USAGE_DEFAULT;
    if (desc->bitmapOptions & D2D1_BITMAP_OPTIONS_CPU_READ)
        texture_desc.Usage = D3D11_USAGE_STAGING;
    texture_desc.BindFlags = 0;
    if (desc->bitmapOptions & D2D1_BITMAP_OPTIONS_TARGET)
        texture_desc.BindFlags |= D3D11_BIND_RENDER_TARGET;
    if (!(desc->bitmapOptions & D2D1_BITMAP_OPTIONS_CANNOT_DRAW))
        texture_desc.BindFlags |= D3D11_BIND_SHADER_RESOURCE;
    texture_desc.CPUAccessFlags = 0;
    if (desc->bitmapOptions & D2D1_BITMAP_OPTIONS_CPU_READ)
        texture_desc.CPUAccessFlags |= D3D11_CPU_ACCESS_READ;
    texture_desc.MiscFlags = 0;
    if (desc->bitmapOptions & D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE)
        texture_desc.MiscFlags |= D3D11_RESOURCE_MISC_GDI_COMPATIBLE;
 
    resource_data.pSysMem = src_data;
    resource_data.SysMemPitch = pitch;
 
    if (FAILED(hr = ID3D11Device1_CreateTexture2D(context->d3d_device, &texture_desc,
            src_data ? &resource_data : NULL, &texture)))
    {
        ERR("Failed to create texture, hr %#lx.\n", hr);
        return hr;
    }
 
    if ((*bitmap = calloc(1, sizeof(**bitmap))))
    {
        d2d_bitmap_init(*bitmap, context, (ID3D11Resource *)texture, size, desc);
        TRACE("Created bitmap %p.\n", *bitmap);
    }
    ID3D11Texture2D_Release(texture);
 
    return *bitmap ? S_OK : E_OUTOFMEMORY;
}

Referenced by d2d_bitmap_create_from_wic_bitmap(), d2d_device_context_CreateBitmap(), and d2d_device_context_ID2D1DeviceContext_CreateBitmap().

d2d_bitmap_create_from_wic_bitmap()

HRESULT d2d_bitmap_create_from_wic_bitmap	(	struct d2d_device_context *	context,
		IWICBitmapSource *	bitmap_source,
		const D2D1_BITMAP_PROPERTIES1 *	desc,
		struct d2d_bitmap **	bitmap
	)

Definition at line 659 of file bitmap.c.

{
    const D2D1_PIXEL_FORMAT *d2d_format;
    D2D1_BITMAP_PROPERTIES1 bitmap_desc;
    WICPixelFormatGUID wic_format;
    unsigned int bpp, data_size;
    D2D1_SIZE_U size;
    unsigned int i;
    WICRect rect;
    UINT32 pitch;
    HRESULT hr;
    void *data;
 
    static const struct
    {
        const WICPixelFormatGUID *wic;
        D2D1_PIXEL_FORMAT d2d;
    }
    format_lookup[] =
    {
        {&GUID_WICPixelFormat32bppPBGRA, {DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED}},
        {&GUID_WICPixelFormat32bppPRGBA, {DXGI_FORMAT_R8G8B8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED}},
        {&GUID_WICPixelFormat32bppBGR,   {DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE}},
        {&GUID_WICPixelFormat32bppRGB,   {DXGI_FORMAT_R8G8B8A8_UNORM, D2D1_ALPHA_MODE_IGNORE}},
    };
 
    if (FAILED(hr = IWICBitmapSource_GetSize(bitmap_source, &size.width, &size.height)))
    {
        WARN("Failed to get bitmap size, hr %#lx.\n", hr);
        return hr;
    }
 
    if (!desc)
    {
        bitmap_desc.pixelFormat.format = DXGI_FORMAT_UNKNOWN;
        bitmap_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_UNKNOWN;
        bitmap_desc.dpiX = 0.0f;
        bitmap_desc.dpiY = 0.0f;
        bitmap_desc.bitmapOptions = 0;
        bitmap_desc.colorContext = NULL;
    }
    else
    {
        bitmap_desc = *desc;
    }
 
    if (FAILED(hr = IWICBitmapSource_GetPixelFormat(bitmap_source, &wic_format)))
    {
        WARN("Failed to get bitmap format, hr %#lx.\n", hr);
        return hr;
    }
 
    for (i = 0, d2d_format = NULL; i < ARRAY_SIZE(format_lookup); ++i)
    {
        if (IsEqualGUID(&wic_format, format_lookup[i].wic))
        {
            d2d_format = &format_lookup[i].d2d;
            break;
        }
    }
 
    if (!d2d_format)
    {
        WARN("Unsupported WIC bitmap format %s.\n", debugstr_guid(&wic_format));
        return D2DERR_UNSUPPORTED_PIXEL_FORMAT;
    }
 
    if (bitmap_desc.pixelFormat.format == DXGI_FORMAT_UNKNOWN)
        bitmap_desc.pixelFormat.format = d2d_format->format;
    if (bitmap_desc.pixelFormat.alphaMode == D2D1_ALPHA_MODE_UNKNOWN)
        bitmap_desc.pixelFormat.alphaMode = d2d_format->alphaMode;
 
    switch (bitmap_desc.pixelFormat.format)
    {
        case DXGI_FORMAT_B8G8R8A8_UNORM:
        case DXGI_FORMAT_R8G8B8A8_UNORM:
            bpp = 4;
            break;
 
        default:
            FIXME("Unhandled format %#x.\n", bitmap_desc.pixelFormat.format);
            return D2DERR_UNSUPPORTED_PIXEL_FORMAT;
    }
 
    pitch = ((bpp * size.width) + 15) & ~15;
    if (pitch / bpp < size.width)
        return E_OUTOFMEMORY;
    if (!(data = calloc(size.height, pitch)))
        return E_OUTOFMEMORY;
    data_size = size.height * pitch;
 
    rect.X = 0;
    rect.Y = 0;
    rect.Width = size.width;
    rect.Height = size.height;
    if (FAILED(hr = IWICBitmapSource_CopyPixels(bitmap_source, &rect, pitch, data_size, data)))
    {
        WARN("Failed to copy bitmap pixels, hr %#lx.\n", hr);
        free(data);
        return hr;
    }
 
    hr = d2d_bitmap_create(context, size, data, pitch, &bitmap_desc, bitmap);
 
    free(data);
 
    return hr;
}

Referenced by d2d_device_context_CreateBitmapFromWicBitmap(), and d2d_device_context_ID2D1DeviceContext_CreateBitmapFromWicBitmap().

d2d_bitmap_create_shared()

HRESULT d2d_bitmap_create_shared	(	struct d2d_device_context *	context,
		REFIID	iid,
		void *	data,
		const D2D1_BITMAP_PROPERTIES1 *	desc,
		struct d2d_bitmap **	bitmap
	)

Definition at line 522 of file bitmap.c.

{
    D2D1_BITMAP_PROPERTIES1 d;
 
    if (IsEqualGUID(iid, &IID_ID2D1Bitmap))
    {
        struct d2d_bitmap *src_impl = unsafe_impl_from_ID2D1Bitmap(data);
        ID3D11Device *device;
        HRESULT hr = S_OK;
 
        if (src_impl->factory != context->factory)
        {
            hr = D2DERR_WRONG_FACTORY;
            goto failed;
        }
 
        ID3D11Resource_GetDevice(src_impl->resource, &device);
        ID3D11Device_Release(device);
        if (device != (ID3D11Device *)context->d3d_device)
        {
            hr = D2DERR_UNSUPPORTED_OPERATION;
            goto failed;
        }
 
        if (desc)
        {
            d = *desc;
            if (d.pixelFormat.format == DXGI_FORMAT_UNKNOWN)
                d.pixelFormat.format = src_impl->format.format;
            if (d.pixelFormat.alphaMode == D2D1_ALPHA_MODE_UNKNOWN)
                d.pixelFormat.alphaMode = src_impl->format.alphaMode;
        }
        else
        {
            d.pixelFormat = src_impl->format;
            d.dpiX = src_impl->dpi_x;
            d.dpiY = src_impl->dpi_y;
            d.bitmapOptions = src_impl->options;
            d.colorContext = NULL;
        }
        desc = &d;
 
        if (!format_supported(&desc->pixelFormat))
        {
            WARN("Tried to create bitmap with unsupported format {%#x / %#x}.\n",
                    desc->pixelFormat.format, desc->pixelFormat.alphaMode);
            hr = D2DERR_UNSUPPORTED_PIXEL_FORMAT;
            goto failed;
        }
 
        if (!(*bitmap = calloc(1, sizeof(**bitmap))))
        {
            hr = E_OUTOFMEMORY;
            goto failed;
        }
 
        d2d_bitmap_init(*bitmap, context, src_impl->resource, src_impl->pixel_size, desc);
        TRACE("Created bitmap %p.\n", *bitmap);
 
    failed:
        return hr;
    }
 
    if (IsEqualGUID(iid, &IID_IDXGISurface) || IsEqualGUID(iid, &IID_IDXGISurface1))
    {
        DXGI_SURFACE_DESC surface_desc;
        IDXGISurface *surface = data;
        ID3D11Resource *resource;
        D2D1_SIZE_U pixel_size;
        ID3D11Device *device;
        HRESULT hr;
 
        if (FAILED(IDXGISurface_QueryInterface(surface, &IID_ID3D11Resource, (void **)&resource)))
        {
            WARN("Failed to get d3d resource from dxgi surface.\n");
            return E_FAIL;
        }
 
        ID3D11Resource_GetDevice(resource, &device);
        ID3D11Device_Release(device);
        if (device != (ID3D11Device *)context->d3d_device)
        {
            ID3D11Resource_Release(resource);
            return D2DERR_UNSUPPORTED_OPERATION;
        }
 
        if (!(*bitmap = calloc(1, sizeof(**bitmap))))
        {
            ID3D11Resource_Release(resource);
            return E_OUTOFMEMORY;
        }
 
 
        if (FAILED(hr = IDXGISurface_GetDesc(surface, &surface_desc)))
        {
            WARN("Failed to get surface desc, hr %#lx.\n", hr);
            ID3D11Resource_Release(resource);
            return hr;
        }
 
        if (!desc)
        {
            memset(&d, 0, sizeof(d));
            d.pixelFormat.format = surface_desc.Format;
            d.bitmapOptions = d2d_get_bitmap_options_for_surface(surface);
        }
        else
        {
            d = *desc;
            if (d.pixelFormat.format == DXGI_FORMAT_UNKNOWN)
                d.pixelFormat.format = surface_desc.Format;
        }
 
        if (d.dpiX == 0.0f || d.dpiY == 0.0f)
        {
            if (d.dpiX == 0.0f)
                d.dpiX = context->desc.dpiX;
            if (d.dpiY == 0.0f)
                d.dpiY = context->desc.dpiY;
        }
 
        pixel_size.width = surface_desc.Width;
        pixel_size.height = surface_desc.Height;
 
        d2d_bitmap_init(*bitmap, context, resource, pixel_size, &d);
        ID3D11Resource_Release(resource);
        TRACE("Created bitmap %p.\n", *bitmap);
 
        return S_OK;
    }
 
    WARN("Unhandled interface %s.\n", debugstr_guid(iid));
 
    return E_INVALIDARG;
}

Referenced by d2d_device_context_CreateBitmapFromDxgiSurface(), and d2d_device_context_CreateSharedBitmap().

d2d_bitmap_GetColorContext()

static void STDMETHODCALLTYPE d2d_bitmap_GetColorContext ( ID2D1Bitmap1 *  iface, ID2D1ColorContext **  context  )

static

Definition at line 221 of file bitmap.c.

{
    FIXME("iface %p, context %p stub!\n", iface, context);
}

d2d_bitmap_GetDpi()

static void STDMETHODCALLTYPE d2d_bitmap_GetDpi ( ID2D1Bitmap1 *  iface, float *  dpi_x, float *  dpi_y  )

static

Definition at line 142 of file bitmap.c.

{
    struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
 
    TRACE("iface %p, dpi_x %p, dpi_y %p.\n", iface, dpi_x, dpi_y);
 
    *dpi_x = bitmap->dpi_x;
    *dpi_y = bitmap->dpi_y;
}

d2d_bitmap_GetFactory()

static void STDMETHODCALLTYPE d2d_bitmap_GetFactory ( ID2D1Bitmap1 *  iface, ID2D1Factory **  factory  )

static

Definition at line 102 of file bitmap.c.

{
    struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
 
    TRACE("iface %p, factory %p.\n", iface, factory);
 
    ID2D1Factory_AddRef(*factory = bitmap->factory);
}

d2d_bitmap_GetOptions()

static D2D1_BITMAP_OPTIONS STDMETHODCALLTYPE d2d_bitmap_GetOptions ( ID2D1Bitmap1 *  iface )

static

Definition at line 226 of file bitmap.c.

{
    struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
 
    TRACE("iface %p.\n", iface);
 
    return bitmap->options;
}

d2d_bitmap_GetPixelFormat()

static D2D1_PIXEL_FORMAT *STDMETHODCALLTYPE d2d_bitmap_GetPixelFormat ( ID2D1Bitmap1 *  iface, D2D1_PIXEL_FORMAT *  format  )

static

Definition at line 132 of file bitmap.c.

{
    struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
 
    TRACE("iface %p, format %p.\n", iface, format);
 
    *format = bitmap->format;
    return format;
}

d2d_bitmap_GetPixelSize()

static D2D1_SIZE_U *STDMETHODCALLTYPE d2d_bitmap_GetPixelSize ( ID2D1Bitmap1 *  iface, D2D1_SIZE_U *  pixel_size  )

static

Definition at line 122 of file bitmap.c.

{
    struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
 
    TRACE("iface %p, pixel_size %p.\n", iface, pixel_size);
 
    *pixel_size = bitmap->pixel_size;
    return pixel_size;
}

d2d_bitmap_GetSize()

static D2D1_SIZE_F *STDMETHODCALLTYPE d2d_bitmap_GetSize ( ID2D1Bitmap1 *  iface, D2D1_SIZE_F *  size  )

static

Definition at line 111 of file bitmap.c.

{
    struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
 
    TRACE("iface %p, size %p.\n", iface, size);
 
    size->width = bitmap->pixel_size.width / (bitmap->dpi_x / 96.0f);
    size->height = bitmap->pixel_size.height / (bitmap->dpi_y / 96.0f);
    return size;
}

d2d_bitmap_GetSurface()

static HRESULT STDMETHODCALLTYPE d2d_bitmap_GetSurface ( ID2D1Bitmap1 *  iface, IDXGISurface **  surface  )

static

Definition at line 235 of file bitmap.c.

{
    struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
 
    TRACE("iface %p, surface %p.\n", iface, surface);
 
    *surface = bitmap->surface;
    if (*surface)
        IDXGISurface_AddRef(*surface);
 
    return *surface ? S_OK : D2DERR_INVALID_CALL;
}

d2d_bitmap_init()

static void d2d_bitmap_init ( struct d2d_bitmap *  bitmap, struct d2d_device_context *  context, ID3D11Resource *  resource, D2D1_SIZE_U  size, const D2D1_BITMAP_PROPERTIES1 *  desc  )

static

Definition at line 366 of file bitmap.c.

{
    ID3D11Device *d3d_device;
    HRESULT hr;
 
    bitmap->ID2D1Bitmap1_iface.lpVtbl = &d2d_bitmap_vtbl;
    bitmap->refcount = 1;
    ID2D1Factory_AddRef(bitmap->factory = context->factory);
    ID3D11Resource_AddRef(bitmap->resource = resource);
    bitmap->pixel_size = size;
    bitmap->format = desc->pixelFormat;
    bitmap->dpi_x = desc->dpiX;
    bitmap->dpi_y = desc->dpiY;
    bitmap->options = desc->bitmapOptions;
 
    if (d2d_device_context_is_dxgi_target(context))
        ID3D11Resource_QueryInterface(resource, &IID_IDXGISurface, (void **)&bitmap->surface);
 
    ID3D11Resource_GetDevice(resource, &d3d_device);
    if (bitmap->options & D2D1_BITMAP_OPTIONS_TARGET)
    {
        if (FAILED(hr = ID3D11Device_CreateRenderTargetView(d3d_device, resource, NULL, &bitmap->rtv)))
            WARN("Failed to create RTV, hr %#lx.\n", hr);
    }
 
    if (!(bitmap->options & D2D1_BITMAP_OPTIONS_CANNOT_DRAW))
    {
        if (FAILED(hr = ID3D11Device_CreateShaderResourceView(d3d_device, resource, NULL, &bitmap->srv)))
            WARN("Failed to create SRV, hr %#lx.\n", hr);
    }
    ID3D11Device_Release(d3d_device);
 
    if (bitmap->dpi_x == 0.0f && bitmap->dpi_y == 0.0f)
    {
        bitmap->dpi_x = 96.0f;
        bitmap->dpi_y = 96.0f;
    }
}

Referenced by d2d_bitmap_create(), and d2d_bitmap_create_shared().

d2d_bitmap_Map()

static HRESULT STDMETHODCALLTYPE d2d_bitmap_Map ( ID2D1Bitmap1 *  iface, D2D1_MAP_OPTIONS  options, D2D1_MAPPED_RECT *  mapped_rect  )

static

Definition at line 248 of file bitmap.c.

{
    struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
    D3D11_MAPPED_SUBRESOURCE mapped_resource;
    ID3D11DeviceContext *context;
    ID3D11Device *device;
    D3D11_MAP map_type;
    HRESULT hr;
 
    TRACE("iface %p, options %#x, mapped_rect %p.\n", iface, options, mapped_rect);
 
    if (!(bitmap->options & D2D1_BITMAP_OPTIONS_CPU_READ))
        return E_INVALIDARG;
 
    if (bitmap->mapped_resource.pData)
        return D2DERR_WRONG_STATE;
 
    if (options == D2D1_MAP_OPTIONS_READ)
        map_type = D3D11_MAP_READ;
    else if (options == D2D1_MAP_OPTIONS_WRITE)
        map_type = D3D11_MAP_WRITE;
    else if (options == (D2D1_MAP_OPTIONS_READ | D2D1_MAP_OPTIONS_WRITE))
        map_type = D3D11_MAP_READ_WRITE;
    else if (options == (D2D1_MAP_OPTIONS_WRITE | D2D1_MAP_OPTIONS_DISCARD))
        map_type = D3D11_MAP_WRITE_DISCARD;
    else
    {
        WARN("Invalid mapping options %#x.\n", options);
        return E_INVALIDARG;
    }
 
    ID3D11Resource_GetDevice(bitmap->resource, &device);
    ID3D11Device_GetImmediateContext(device, &context);
    if (SUCCEEDED(hr = ID3D11DeviceContext_Map(context, bitmap->resource, 0, map_type,
            0, &mapped_resource)))
    {
        bitmap->mapped_resource = mapped_resource;
    }
    ID3D11DeviceContext_Release(context);
    ID3D11Device_Release(device);
 
    if (FAILED(hr))
    {
        WARN("Failed to map resource, hr %#lx.\n", hr);
        return E_INVALIDARG;
    }
 
    mapped_rect->pitch = bitmap->mapped_resource.RowPitch;
    mapped_rect->bits  = bitmap->mapped_resource.pData;
 
    return S_OK;
}

d2d_bitmap_QueryInterface()

static HRESULT STDMETHODCALLTYPE d2d_bitmap_QueryInterface ( ID2D1Bitmap1 *  iface, REFIID  iid, void **  out  )

static

Definition at line 48 of file bitmap.c.

{
    TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 
    if (IsEqualGUID(iid, &IID_ID2D1Bitmap1)
            || IsEqualGUID(iid, &IID_ID2D1Bitmap)
            || IsEqualGUID(iid, &IID_ID2D1Image)
            || IsEqualGUID(iid, &IID_ID2D1Resource)
            || IsEqualGUID(iid, &IID_IUnknown))
    {
        ID2D1Bitmap1_AddRef(iface);
        *out = iface;
        return S_OK;
    }
 
    WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 
    *out = NULL;
    return E_NOINTERFACE;
}

d2d_bitmap_Release()

static ULONG STDMETHODCALLTYPE d2d_bitmap_Release ( ID2D1Bitmap1 *  iface )

static

Definition at line 79 of file bitmap.c.

{
    struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
    ULONG refcount = InterlockedDecrement(&bitmap->refcount);
 
    TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
 
    if (!refcount)
    {
        if (bitmap->srv)
            ID3D11ShaderResourceView_Release(bitmap->srv);
        if (bitmap->rtv)
            ID3D11RenderTargetView_Release(bitmap->rtv);
        if (bitmap->surface)
            IDXGISurface_Release(bitmap->surface);
        ID3D11Resource_Release(bitmap->resource);
        ID2D1Factory_Release(bitmap->factory);
        free(bitmap);
    }
 
    return refcount;
}

d2d_bitmap_Unmap()

static HRESULT STDMETHODCALLTYPE d2d_bitmap_Unmap ( ID2D1Bitmap1 *  iface )

static

Definition at line 302 of file bitmap.c.

{
    struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
 
    TRACE("iface %p.\n", iface);
 
    return d2d_bitmap_unmap(bitmap);
}

d2d_bitmap_unmap()

static HRESULT d2d_bitmap_unmap ( struct d2d_bitmap *  bitmap )

static

Definition at line 29 of file bitmap.c.

{
    ID3D11DeviceContext *context;
    ID3D11Device *device;
 
    if (!bitmap->mapped_resource.pData)
        return D2DERR_WRONG_STATE;
 
    ID3D11Resource_GetDevice(bitmap->resource, &device);
    ID3D11Device_GetImmediateContext(device, &context);
    ID3D11DeviceContext_Unmap(context, bitmap->resource, 0);
    ID3D11DeviceContext_Release(context);
    ID3D11Device_Release(device);
 
    memset(&bitmap->mapped_resource, 0, sizeof(bitmap->mapped_resource));
 
    return S_OK;
}

Referenced by d2d_bitmap_Unmap().

d2d_get_bitmap_options_for_surface()

unsigned int d2d_get_bitmap_options_for_surface

(

IDXGISurface *

surface

)

Definition at line 498 of file bitmap.c.

{
    D3D11_TEXTURE2D_DESC desc;
    unsigned int options = 0;
    ID3D11Texture2D *texture;
 
    if (FAILED(IDXGISurface_QueryInterface(surface, &IID_ID3D11Texture2D, (void **)&texture)))
        return 0;
 
    ID3D11Texture2D_GetDesc(texture, &desc);
    ID3D11Texture2D_Release(texture);
 
    if (desc.BindFlags & D3D11_BIND_RENDER_TARGET)
        options |= D2D1_BITMAP_OPTIONS_TARGET;
    if (!(desc.BindFlags & D3D11_BIND_SHADER_RESOURCE))
        options |= D2D1_BITMAP_OPTIONS_CANNOT_DRAW;
    if (desc.MiscFlags & D3D11_RESOURCE_MISC_GDI_COMPATIBLE)
        options |= D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE;
    if (desc.Usage == D3D11_USAGE_STAGING && desc.CPUAccessFlags & D3D11_CPU_ACCESS_READ)
        options |= D2D1_BITMAP_OPTIONS_CPU_READ;
 
    return options;
}

Referenced by d2d_bitmap_create_shared(), d2d_device_context_CreateBitmapFromDxgiSurface(), and d2d_device_context_CreateSharedBitmap().

format_supported()

static BOOL format_supported ( const D2D1_PIXEL_FORMAT *  format )

static

Definition at line 331 of file bitmap.c.

{
    unsigned int i;
 
    static const D2D1_PIXEL_FORMAT supported_formats[] =
    {
        {DXGI_FORMAT_R32G32B32A32_FLOAT,    D2D1_ALPHA_MODE_PREMULTIPLIED},
        {DXGI_FORMAT_R32G32B32A32_FLOAT,    D2D1_ALPHA_MODE_IGNORE       },
        {DXGI_FORMAT_R16G16B16A16_FLOAT,    D2D1_ALPHA_MODE_PREMULTIPLIED},
        {DXGI_FORMAT_R16G16B16A16_FLOAT,    D2D1_ALPHA_MODE_IGNORE       },
        {DXGI_FORMAT_R16G16B16A16_UNORM,    D2D1_ALPHA_MODE_PREMULTIPLIED},
        {DXGI_FORMAT_R16G16B16A16_UNORM,    D2D1_ALPHA_MODE_IGNORE       },
        {DXGI_FORMAT_R8G8B8A8_UNORM,        D2D1_ALPHA_MODE_PREMULTIPLIED},
        {DXGI_FORMAT_R8G8B8A8_UNORM,        D2D1_ALPHA_MODE_IGNORE       },
        {DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,   D2D1_ALPHA_MODE_PREMULTIPLIED},
        {DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,   D2D1_ALPHA_MODE_IGNORE       },
        {DXGI_FORMAT_A8_UNORM,              D2D1_ALPHA_MODE_PREMULTIPLIED},
        {DXGI_FORMAT_A8_UNORM,              D2D1_ALPHA_MODE_STRAIGHT     },
        {DXGI_FORMAT_B8G8R8A8_UNORM,        D2D1_ALPHA_MODE_PREMULTIPLIED},
        {DXGI_FORMAT_B8G8R8A8_UNORM,        D2D1_ALPHA_MODE_IGNORE       },
        {DXGI_FORMAT_B8G8R8X8_UNORM,        D2D1_ALPHA_MODE_IGNORE       },
        {DXGI_FORMAT_B8G8R8A8_UNORM_SRGB,   D2D1_ALPHA_MODE_PREMULTIPLIED},
        {DXGI_FORMAT_B8G8R8A8_UNORM_SRGB,   D2D1_ALPHA_MODE_IGNORE       },
    };
 
    for (i = 0; i < ARRAY_SIZE(supported_formats); ++i)
    {
        if (supported_formats[i].format == format->format
                && supported_formats[i].alphaMode == format->alphaMode)
            return TRUE;
    }
 
    return FALSE;
}

Referenced by d2d_bitmap_create(), and d2d_bitmap_create_shared().

impl_from_ID2D1Bitmap1()

static struct d2d_bitmap * impl_from_ID2D1Bitmap1 ( ID2D1Bitmap1 *  iface )

inlinestatic

Definition at line 24 of file bitmap.c.

{
    return CONTAINING_RECORD(iface, struct d2d_bitmap, ID2D1Bitmap1_iface);
}

Referenced by d2d_bitmap_AddRef(), d2d_bitmap_CopyFromBitmap(), d2d_bitmap_CopyFromMemory(), d2d_bitmap_GetDpi(), d2d_bitmap_GetFactory(), d2d_bitmap_GetOptions(), d2d_bitmap_GetPixelFormat(), d2d_bitmap_GetPixelSize(), d2d_bitmap_GetSize(), d2d_bitmap_GetSurface(), d2d_bitmap_Map(), d2d_bitmap_Release(), and d2d_bitmap_Unmap().

unsafe_impl_from_ID2D1Bitmap()

struct d2d_bitmap * unsafe_impl_from_ID2D1Bitmap

(

ID2D1Bitmap *

iface

)

Definition at line 769 of file bitmap.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == (ID2D1BitmapVtbl *)&d2d_bitmap_vtbl);
    return CONTAINING_RECORD(iface, struct d2d_bitmap, ID2D1Bitmap1_iface);
}

Referenced by d2d_bitmap_brush_create(), d2d_bitmap_brush_SetBitmap(), d2d_bitmap_CopyFromBitmap(), d2d_bitmap_create_shared(), d2d_brush_bind_image(), d2d_brush_fill_cb(), d2d_dc_render_target_BindDC(), and d2d_device_context_SetTarget().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

d2d

)

Variable Documentation

d2d_bitmap_vtbl

const struct ID2D1Bitmap1Vtbl d2d_bitmap_vtbl

static

Initial value:

=
{
    d2d_bitmap_QueryInterface,
    d2d_bitmap_AddRef,
    d2d_bitmap_Release,
    d2d_bitmap_GetFactory,
    d2d_bitmap_GetSize,
    d2d_bitmap_GetPixelSize,
    d2d_bitmap_GetPixelFormat,
    d2d_bitmap_GetDpi,
    d2d_bitmap_CopyFromBitmap,
    d2d_bitmap_CopyFromRenderTarget,
    d2d_bitmap_CopyFromMemory,
    d2d_bitmap_GetColorContext,
    d2d_bitmap_GetOptions,
    d2d_bitmap_GetSurface,
    d2d_bitmap_Map,
    d2d_bitmap_Unmap,
}

Definition at line 311 of file bitmap.c.

Referenced by d2d_bitmap_init(), and unsafe_impl_from_ID2D1Bitmap().