direct2d: optimizing the rendering of several BGRA rectangles on a bitmap

  c++, direct-composition, direct2d, efl, winapi

I am porting a toolkit (namely the EFL) engine from pure GDI to Direct2D. More precisely, I am adding a Direct2D engine. The purpose is to have a faster engine than the GDI one.

This toolkit is cross platform, has existed for a long time, so i can’t modify it. I can just use what it provides me.

It has a state full canvas. When the content of the window has to be drawn, it provides an array of BGRA rectangles (x, y, w, h and BGRA data) that has been modified since the previous window content.

I have set up D2D with DirectComposition in mind (to also have per-pixel transparency, and Kenny Kerr have said that it is faster than without direct composition btw).

The naive way is to create a bitmap of size the size of the widow, and keep it for rendering. Then I do the following steps:

  1. I loop over the rectangles and for each, I call CopyFromMemory() to update each rectangle region in the bitmap
  2. I call BeginDraw()
  3. I call DrawBitmap() to render the whole bitmap
  4. I call EndDraw()

It works. Here is the complete code:

#define _WIN32_WINNT 0x0A00

#include <stdio.h> /* I know, not C++ stuff */

#include <windows.h>
#include <d3d11.h>
#include <dxgi1_3.h>
#include <dcomp.h>
#include <d2d1_1.h>

#define E_DEBUG 1

typedef struct
{
    HINSTANCE instance;
    HWND win;
} Window;

typedef struct
{
    ID3D11Device *d3d_device;
    IDXGIDevice *dxgi_device;
    IDXGIFactory2 *dxgi_factory;
    ID2D1Factory1 *d2d_factory;
    ID2D1Device *d2d_device;
    ID2D1DeviceContext *d2d_device_ctx;
    IDCompositionDevice *dcomp_device;
    IDCompositionVisual *dcomp_visual;
    IDCompositionTarget *dcomp_target;
    IDXGISwapChain1 *dxgi_swapchain;
} D2d;

ID2D1Bitmap1 *bitmap;
void render(D2d* d2d);
void draw(D2d* d2d);


/***************************** Window *****************************/

LRESULT CALLBACK
_window_procedure(HWND   window,
                  UINT   message,
                  WPARAM window_param,
                  LPARAM data_param)
{
  switch (message)
    {
    case WM_CLOSE:
      PostQuitMessage(0);
      return 0;
    case WM_KEYUP:
      if (window_param == 'Q')
        {
          PostQuitMessage(0);
        }
      if (window_param == 'T')
        {
            printf("key 'T'n");
            fflush(stdout);
        }
      if (window_param == 'D')
        {
            D2d *d2d;

            d2d = (D2d *)GetWindowLongPtr(window, GWLP_USERDATA);
            printf("key 'D'n");
            fflush(stdout);
            draw(d2d);
        }
      return 0;
      /* GDI notifications */
    case WM_CREATE:
        return 0;
    case WM_PAINT:
      {
        RECT rect;

        printf("paintn");
        fflush(stdout);

        if (GetUpdateRect(window, &rect, FALSE))
          {
            PAINTSTRUCT ps;
            D2d *d2d = NULL;;

            BeginPaint(window, &ps);

            d2d = (D2d *)GetWindowLongPtr(window, GWLP_USERDATA);
            render(d2d);

            EndPaint(window, &ps);
          }
        return 0;
      }
    default:
      return DefWindowProc(window, message, window_param, data_param);
    }
}

Window *window_new(int x, int y, int w, int h)
{
    WNDCLASS wc;
    RECT r;
    Window *win;
    DWORD style;
    DWORD exstyle;

    win = (Window *)calloc(1, sizeof(Window));
    if (!win)
        return NULL;

    win->instance = GetModuleHandle(NULL);
    if (!win->instance)
        goto free_win;

    memset (&wc, 0, sizeof (WNDCLASS));
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = _window_procedure;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = win->instance;
    wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor (NULL, IDC_ARROW);
    wc.hbrBackground = NULL;
    wc.lpszMenuName =  NULL;
    wc.lpszClassName = "D2D";

    if(!RegisterClass(&wc))
        goto free_library;

    style = WS_OVERLAPPEDWINDOW | WS_SIZEBOX;
    exstyle = WS_EX_NOREDIRECTIONBITMAP;

    r.left = 0;
    r.top = 0;
    r.right = w;
    r.bottom = h;
    if (!AdjustWindowRectEx(&r, style, FALSE, exstyle))
        goto unregister_class;

    win->win = CreateWindowEx(exstyle,
                              "D2D", "Test",
                              style,
                              x, y,
                              r.right - r.left,
                              r.bottom - r.top,
                              NULL,
                              NULL, win->instance, NULL);
    if (!win->win)
        goto unregister_class;

    printf("win new %pn", win);
    fflush(stdout);
    printf("win->win new %pn", win->win);
    fflush(stdout);

    return win;

  unregister_class:
    UnregisterClass("D2D", win->instance);
  free_library:
    FreeLibrary(win->instance);
  free_win:
    free(win);

    return NULL;
}

void window_del(Window *win)
{
    if (!win)
        return;

    DestroyWindow(win->win);
    UnregisterClass("D2D", win->instance);
    FreeLibrary(win->instance);
    free(win);
}

void window_show(Window *win)
{
    ShowWindow(win->win, SW_SHOWNORMAL);
}




/***************************** Direct2D *****************************/

/***** helper functions for rectangles to display *****/

int rect_1(int w, int h, unsigned int **data)
{
    unsigned int *d;
    unsigned int *iter;
    int i;
    int j;

    d = (unsigned int *)malloc(w * h * sizeof(unsigned int));
    if (!d)
    {
        *data = NULL;
        return 0;
    }

    iter = d;
    for (i = 0; i < h; i++)
    {
        for (j = 0; j < w; j++, iter++)
        {
            if (i >= 50 && j >= 50)
                *iter = 0xaa0000ff;
            else
                *iter = 0xffff0000;
        }
    }

    *data = d;
    return 1;
}

int rect_2(int w, int h, unsigned int **data)
{
    unsigned int *d;
    unsigned int *iter;
    int i;
    int j;

    d = (unsigned int *)malloc(w * h * sizeof(unsigned int));
    if (!d)
    {
        *data = NULL;
        return 0;
    }

    iter = d;
    for (i = 0; i < h; i++)
    {
        int g;
        for (j = 0; j < w; j++, iter++)
        {
            g = (j * 255) / (h - 1);
            *iter = (255 << 24) | (g << 8);
        }
    }

    *data = d;
    return 1;
}

int rect_3(int w, int h, unsigned int **data)
{
    unsigned int *d;
    unsigned int *iter;
    int i;
    int j;

    d = (unsigned int *)malloc(w * h * sizeof(unsigned int));
    if (!d)
    {
        *data = NULL;
        return 0;
    }

    iter = d;
    for (i = 0; i < h; i++)
    {
        int b;
        int g;
        b = (i * 255) / (w - 1);
        for (j = 0; j < w; j++, iter++)
        {
            g = (j * 255) / (h - 1);
            *iter = (255 << 24) | (g << 8) | b;
        }
    }

    *data = d;
    return 1;
}

D2d *d2d_init(Window *win)
{
    const D3D_FEATURE_LEVEL levels[] =
    {
        D3D_FEATURE_LEVEL_12_1,
        D3D_FEATURE_LEVEL_12_0,
        D3D_FEATURE_LEVEL_11_1,
        D3D_FEATURE_LEVEL_11_0,
        D3D_FEATURE_LEVEL_10_1,
        D3D_FEATURE_LEVEL_10_0
    };
    D2D1_FACTORY_OPTIONS opt;
    DXGI_SWAP_CHAIN_DESC1 desc;
    D2d *d2d;
    IDXGISurface *surface;
    ID2D1Bitmap1 *bmp;
    RECT r;
    HRESULT res;

    d2d = (D2d *)calloc(1, sizeof(D2d));
    if (!d2d)
        return NULL;

    /* direct3d device */
    res = D3D11CreateDevice(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL,
                            D3D11_CREATE_DEVICE_BGRA_SUPPORT
#if E_DEBUG
                            | D3D11_CREATE_DEVICE_DEBUG
#endif
                            ,
                            levels, sizeof(levels) / sizeof(D3D_FEATURE_LEVEL),
                            D3D11_SDK_VERSION, &d2d->d3d_device, NULL, NULL);
    if (FAILED(res))
        goto free_d2d;

    /* dxgi device */
    res = d2d->d3d_device->QueryInterface(&d2d->dxgi_device);
    if (FAILED(res))
        goto release_d3d_device;

    /* dxgi factory */
    res = CreateDXGIFactory2(
#if E_DEBUG
                             DXGI_CREATE_FACTORY_DEBUG,
#else
                             0,
#endif
                             __uuidof(d2d->dxgi_factory),
                             (void **)&d2d->dxgi_factory);
    if (FAILED(res))
        goto release_dxgi_device;

    /* d2d factory */
#if E_DEBUG
    opt.debugLevel = D2D1_DEBUG_LEVEL_INFORMATION;
#else
    opt.debugLevel = D2D1_DEBUG_LEVEL_NONE;
#endif
    res = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED,
                            __uuidof(d2d->d2d_factory), &opt,
                            (void **)&d2d->d2d_factory);
    if (FAILED(res))
        goto release_dxgi_factory;

    /* d2d device */

    res = d2d->d2d_factory->CreateDevice(d2d->dxgi_device, &d2d->d2d_device);
    if (FAILED(res))
        goto release_d2d_factory;

    /* d2d device context */

    // FIXME : D2D1_DEVICE_CONTEXT_OPTIONS_ENABLE_MULTITHREADED_OPTIMIZATIONS ?
    res = d2d->d2d_device->CreateDeviceContext(D2D1_DEVICE_CONTEXT_OPTIONS_NONE,
                                               &d2d->d2d_device_ctx);
    if (FAILED(res))
        goto release_d2d_device;

    /* dcomp device */
    res = DCompositionCreateDevice(d2d->dxgi_device,
                                   __uuidof(d2d->dcomp_device),
                                   (void **)&d2d->dcomp_device);
    if (FAILED(res))
        goto release_d2d_device_ctx;

    /* dcomp visual */
    res = d2d->dcomp_device->CreateVisual(&d2d->dcomp_visual);
    if (FAILED(res))
        goto release_dcomp_device;

    /* dcomp target */
    res = d2d->dcomp_device->CreateTargetForHwnd(win->win, TRUE,
                                                 &d2d->dcomp_target);
    if (FAILED(res))
        goto release_dcomp_visual;

    /* dxgi swapchain */
    if (!GetClientRect(win->win, &r))
        goto release_dcomp_target;

    desc.Width = r.right - r.left; /* width of client area */
    desc.Height = r.bottom - r.top; /* height of client area */
    desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
    desc.Stereo = FALSE;
    desc.SampleDesc.Count = 1;
    desc.SampleDesc.Quality = 0;
    desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    desc.BufferCount = 2;
    desc.Scaling = DXGI_SCALING_STRETCH;
    desc.SwapEffect= DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
    desc.AlphaMode = DXGI_ALPHA_MODE_PREMULTIPLIED;
    desc.Flags = 0;

    res = d2d->dxgi_factory->CreateSwapChainForComposition(d2d->dxgi_device,
                                                           &desc,
                                                           NULL,
                                                           &d2d->dxgi_swapchain);
    if (FAILED(res))
        goto release_dcomp_target;

    printf(" * %s : swapchain : %p  %pn", __FUNCTION__, d2d, d2d->dxgi_swapchain);
    fflush(stdout);

    /* swapchain buffer in a IDXGISurface */
    res = d2d->dxgi_swapchain->GetBuffer(0, __uuidof(surface),
                                         (void **)&surface);
    if (FAILED(res))
        goto release_dxgi_swapchain;

    printf("backbuffer1n");
    res = d2d->d2d_device_ctx->CreateBitmapFromDxgiSurface(surface,
                                                           NULL,
                                                           &bmp);
    if (!FAILED(res))
    {
        printf("backbuffer2n");
        d2d->d2d_device_ctx->SetTarget(bmp);
        bmp->Release();
    }

    surface->Release();

    return d2d;

  release_dxgi_swapchain:
    d2d->dxgi_swapchain->Release();
  release_dcomp_target:
    d2d->dcomp_target->Release();
  release_dcomp_visual:
    d2d->dcomp_visual->Release();
  release_dcomp_device:
    d2d->dcomp_device->Release();
  release_d2d_device_ctx:
    d2d->d2d_device_ctx->Release();
  release_d2d_device:
    d2d->d2d_device->Release();
  release_d2d_factory:
    d2d->d2d_factory->Release();
  release_dxgi_factory:
    d2d->dxgi_factory->Release();
  release_dxgi_device:
    d2d->dxgi_device->Release();
  release_d3d_device:
    d2d->d3d_device->Release();
  free_d2d:
    free(d2d);

    return NULL;
}

void d2d_shutdown(D2d *d2d)
{
    d2d->dxgi_swapchain->Release();
    d2d->dcomp_target->Release();
    d2d->dcomp_visual->Release();
    d2d->dcomp_device->Release();
    d2d->d2d_device_ctx->Release();
    d2d->d2d_device->Release();
    d2d->d2d_factory->Release();
    d2d->dxgi_factory->Release();
    d2d->dxgi_device->Release();
    d2d->d3d_device->Release();
}

void render(D2d* d2d)
{
    D2D1_BITMAP_PROPERTIES1 properties;
    DXGI_SWAP_CHAIN_DESC1 desc;
    D2D1_COLOR_F c;
    HRESULT res;

    printf(" * %s : %pn", __FUNCTION__, d2d);
    fflush(stdout);
    printf(" * %s : %pn", __FUNCTION__, d2d->dxgi_swapchain);
    fflush(stdout);

    // get size from swapchain (for example)
    d2d->dxgi_swapchain->GetDesc1(&desc);
    D2D1_SIZE_U s = { desc.Width, desc.Height };

    unsigned int* data;
    if (!rect_1(s.width, s.height, &data))
    {
        printf(" * %s malloc failedn", __FUNCTION__);
        fflush(stdout);
        return;
    }

    // create a bitmap from properties & pixel buffer
    // hint: in general for most structures, it's much easier to use ZeroMemory or memset(0) so by default values are automatically set
    ZeroMemory(&properties, sizeof(properties));
    properties.pixelFormat.format = desc.Format;
    properties.pixelFormat.alphaMode = D2D1_ALPHA_MODE_PREMULTIPLIED;

    res = d2d->d2d_device_ctx->CreateBitmap(s, data, 4 * s.width, properties, &bitmap);
    if (FAILED(res))
    {
        printf(" * %s CreateBitmap failedn", __FUNCTION__);
        fflush(stdout);
        goto data_free;
    }

    d2d->d2d_device_ctx->BeginDraw();

    c.r = 0.0f;
    c.g = 0.0f;
    c.b = 0.0f;
    c.a = 0.0f;
    d2d->d2d_device_ctx->Clear(&c);

    D2D1_RECT_F rect;
    rect.left = 0.0f;
    rect.top = 0.0f;
    rect.right = (float)s.width;
    rect.bottom = (float)s.height;
    d2d->d2d_device_ctx->DrawBitmap(bitmap, rect, 1.0f, D2D1_BITMAP_INTERPOLATION_MODE_LINEAR, rect);

    d2d->d2d_device_ctx->EndDraw(NULL, NULL);

    d2d->dxgi_swapchain->Present(1, 0);
    d2d->dcomp_visual->SetContent(d2d->dxgi_swapchain);
    d2d->dcomp_target->SetRoot(d2d->dcomp_visual);
    d2d->dcomp_device->Commit();

data_free:
    free(data);
}

void draw(D2d *d2d)
{
    D2D1_RECT_U r;
    unsigned int *data;
    int x, y, w, h;

    x = 10;
    y = 10;
    w = 100;
    h = 100;
    if (!rect_2(w, h, &data))
    {
        printf("rect_2 failedn");
        return;
    }

    r.left = x;
    r.top= y;
    r.right = x + w - 1;
    r.bottom = y + h - 1;
    bitmap->CopyFromMemory(&r, data, 4 * w);

    x = 150;
    y = 150;
    w = 100;
    h = 100;
    if (!rect_3(w, h, &data))
    {
        printf("rect_2 failedn");
        return;
    }

    r.left = x;
    r.top= y;
    r.right = x + w - 1;
    r.bottom = y + h - 1;
    bitmap->CopyFromMemory(&r, data, 4 * w);

    d2d->d2d_device_ctx->BeginDraw();

    D2D1_RECT_F rect;
    rect.left = 0.0f;
    rect.top = 0.0f;
    rect.right = (float)640;
    rect.bottom = (float)480;
    d2d->d2d_device_ctx->DrawBitmap(bitmap, rect, 1.0f,
                                    D2D1_BITMAP_INTERPOLATION_MODE_LINEAR, rect);

    d2d->d2d_device_ctx->EndDraw(NULL, NULL);

    d2d->dxgi_swapchain->Present(1, 0);
    d2d->dcomp_visual->SetContent(d2d->dxgi_swapchain);
    d2d->dcomp_target->SetRoot(d2d->dcomp_visual);
    d2d->dcomp_device->Commit();
}


/***************************** main *****************************/

int main()
{
    Window *win;
    D2d *d2d;

    win = window_new(100, 100, 640, 480);
    if (!win)
        return 1;

    d2d = d2d_init(win);
    if (!d2d)
        goto win_del;

    SetWindowLongPtr(win->win, GWLP_USERDATA, (LONG_PTR)d2d);

    window_show(win);

    /* msg loop */
    while(1)
    {
        MSG msg;
        BOOL ret;

        ret = PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
        if (ret)
        {
            do
            {
                if (msg.message == WM_QUIT)
                  goto beach;
                TranslateMessage(&msg);
                DispatchMessageW(&msg);
            } while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE));
        }
    }

  beach:
    d2d_shutdown(d2d);
  win_del:
    window_del(win);

    return 0;
}

The first part of this code is windows creation and destruction, the second deals with Direct2D. The function render() renders the background. The function draw() renders 2 BGRA rectangles (well squares, actually…).

My question: is there a faster way than calling several times CopyFromMemory(), like in my draw() function, to achieve this ?

thank you

Source: Windows Questions C++

LEAVE A COMMENT