test_conformance/extensions/cl_khr_dx9_media_sharing/wrappers.cpp

//
// Copyright (c) 2017 The Khronos Group Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#include "wrappers.h"
#include "harness/errorHelpers.h"

LPCTSTR CDeviceWrapper::WINDOW_TITLE = _T( "cl_khr_dx9_media_sharing" );
const int CDeviceWrapper::WINDOW_WIDTH = 256;
const int CDeviceWrapper::WINDOW_HEIGHT = 256;
CDeviceWrapper::TAccelerationType CDeviceWrapper::accelerationType =
    CDeviceWrapper::ACCELERATION_HW;

#if defined(_WIN32)
const D3DFORMAT CDXVAWrapper::RENDER_TARGET_FORMAT = D3DFMT_X8R8G8B8;
const D3DFORMAT CDXVAWrapper::VIDEO_FORMAT = D3DFMT_X8R8G8B8;
const unsigned int CDXVAWrapper::VIDEO_FPS = 60;
#endif

#if defined(_WIN32)
static LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
        case WM_DESTROY: PostQuitMessage(0); return 0;
        case WM_PAINT: ValidateRect(hWnd, 0); return 0;
        default: break;
    }

    return DefWindowProc(hWnd, msg, wParam, lParam);
}
#endif

CDeviceWrapper::CDeviceWrapper()
#if defined(_WIN32)
    : _hInstance(NULL), _hWnd(NULL)
#endif
{}

void CDeviceWrapper::WindowInit()
{
#if defined(_WIN32)
    _hInstance = GetModuleHandle(NULL);
    static WNDCLASSEX wc = {
        sizeof(WNDCLASSEX), CS_CLASSDC, WndProc, 0L,   0L,
        _hInstance,         NULL,       NULL,    NULL, NULL,
        WINDOW_TITLE,       NULL
    };

    RegisterClassEx(&wc);

    _hWnd = CreateWindow(WINDOW_TITLE, WINDOW_TITLE, WS_OVERLAPPEDWINDOW, 0, 0,
                         WINDOW_WIDTH, WINDOW_HEIGHT, NULL, NULL, wc.hInstance,
                         NULL);

    if (!_hWnd)
    {
        log_error("Failed to create window");
        return;
    }

    ShowWindow(_hWnd, SW_SHOWDEFAULT);
    UpdateWindow(_hWnd);
#endif
}

void CDeviceWrapper::WindowDestroy()
{
#if defined(_WIN32)
    if (_hWnd) DestroyWindow(_hWnd);
    _hWnd = NULL;
#endif
}

#if defined(_WIN32)
HWND CDeviceWrapper::WindowHandle() const { return _hWnd; }
#endif

int CDeviceWrapper::WindowWidth() const { return WINDOW_WIDTH; }

int CDeviceWrapper::WindowHeight() const { return WINDOW_HEIGHT; }

CDeviceWrapper::TAccelerationType CDeviceWrapper::AccelerationType()
{
    return accelerationType;
}

void CDeviceWrapper::AccelerationType(TAccelerationType accelerationTypeNew)
{
    accelerationType = accelerationTypeNew;
}

CDeviceWrapper::~CDeviceWrapper() { WindowDestroy(); }

#if defined(_WIN32)
CD3D9Wrapper::CD3D9Wrapper()
    : _d3d9(NULL), _d3dDevice(NULL), _status(DEVICE_PASS), _adapterIdx(0),
      _adapterFound(false)
{
    WindowInit();

    _d3d9 = Direct3DCreate9(D3D_SDK_VERSION);
    if (!_d3d9)
    {
        log_error("Direct3DCreate9 failed\n");
        _status = DEVICE_FAIL;
    }
}

CD3D9Wrapper::~CD3D9Wrapper()
{
    Destroy();

    if (_d3d9) _d3d9->Release();
    _d3d9 = 0;
}

void CD3D9Wrapper::Destroy()
{
    if (_d3dDevice) _d3dDevice->Release();
    _d3dDevice = 0;
}

cl_int CD3D9Wrapper::Init()
{
    if (!WindowHandle())
    {
        log_error("D3D9: Window is not created\n");
        _status = DEVICE_FAIL;
        return DEVICE_FAIL;
    }

    if (!_d3d9 || DEVICE_PASS != _status || !_adapterFound) return false;

    _d3d9->GetAdapterDisplayMode(_adapterIdx - 1, &_d3ddm);

    D3DPRESENT_PARAMETERS d3dParams;
    ZeroMemory(&d3dParams, sizeof(d3dParams));

    d3dParams.Windowed = TRUE;
    d3dParams.BackBufferCount = 1;
    d3dParams.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dParams.hDeviceWindow = WindowHandle();
    d3dParams.BackBufferWidth = WindowWidth();
    d3dParams.BackBufferHeight = WindowHeight();
    d3dParams.BackBufferFormat = _d3ddm.Format;

    DWORD processingType = (AccelerationType() == ACCELERATION_HW)
        ? D3DCREATE_HARDWARE_VERTEXPROCESSING
        : D3DCREATE_SOFTWARE_VERTEXPROCESSING;

    if (FAILED(_d3d9->CreateDevice(_adapterIdx - 1, D3DDEVTYPE_HAL,
                                   WindowHandle(), processingType, &d3dParams,
                                   &_d3dDevice)))
    {
        log_error("CreateDevice failed\n");
        _status = DEVICE_FAIL;
        return DEVICE_FAIL;
    }

    _d3dDevice->BeginScene();
    _d3dDevice->Clear(0, NULL, D3DCLEAR_TARGET, 0, 1.0f, 0);
    _d3dDevice->EndScene();

    return true;
}

void *CD3D9Wrapper::D3D() const { return _d3d9; }

void *CD3D9Wrapper::Device() const { return _d3dDevice; }

D3DFORMAT CD3D9Wrapper::Format() { return _d3ddm.Format; }

D3DADAPTER_IDENTIFIER9 CD3D9Wrapper::Adapter() { return _adapter; }

TDeviceStatus CD3D9Wrapper::Status() const { return _status; }

bool CD3D9Wrapper::AdapterNext()
{
    if (DEVICE_PASS != _status) return false;

    _adapterFound = false;
    for (; _adapterIdx < _d3d9->GetAdapterCount();)
    {
        ++_adapterIdx;
        D3DCAPS9 caps;
        if (FAILED(
                _d3d9->GetDeviceCaps(_adapterIdx - 1, D3DDEVTYPE_HAL, &caps)))
            continue;

        if (FAILED(_d3d9->GetAdapterIdentifier(_adapterIdx - 1, 0, &_adapter)))
        {
            log_error("D3D9: GetAdapterIdentifier failed\n");
            _status = DEVICE_FAIL;
            return false;
        }

        _adapterFound = true;

        Destroy();
        if (!Init())
        {
            _status = DEVICE_FAIL;
            _adapterFound = false;
        }
        break;
    }

    return _adapterFound;
}

unsigned int CD3D9Wrapper::AdapterIdx() const { return _adapterIdx - 1; }


CD3D9ExWrapper::CD3D9ExWrapper()
    : _d3d9Ex(NULL), _d3dDeviceEx(NULL), _status(DEVICE_PASS), _adapterIdx(0),
      _adapterFound(false)
{
    WindowInit();

    HRESULT result = Direct3DCreate9Ex(D3D_SDK_VERSION, &_d3d9Ex);
    if (FAILED(result) || !_d3d9Ex)
    {
        log_error("Direct3DCreate9Ex failed\n");
        _status = DEVICE_FAIL;
    }
}

CD3D9ExWrapper::~CD3D9ExWrapper()
{
    Destroy();

    if (_d3d9Ex) _d3d9Ex->Release();
    _d3d9Ex = 0;
}

void *CD3D9ExWrapper::D3D() const { return _d3d9Ex; }

void *CD3D9ExWrapper::Device() const { return _d3dDeviceEx; }

D3DFORMAT CD3D9ExWrapper::Format() { return _d3ddmEx.Format; }

D3DADAPTER_IDENTIFIER9 CD3D9ExWrapper::Adapter() { return _adapter; }

cl_int CD3D9ExWrapper::Init()
{
    if (!WindowHandle())
    {
        log_error("D3D9EX: Window is not created\n");
        _status = DEVICE_FAIL;
        return DEVICE_FAIL;
    }

    if (!_d3d9Ex || DEVICE_FAIL == _status || !_adapterFound)
        return DEVICE_FAIL;

    RECT rect;
    GetClientRect(WindowHandle(), &rect);

    D3DPRESENT_PARAMETERS d3dParams;
    ZeroMemory(&d3dParams, sizeof(d3dParams));

    d3dParams.Windowed = TRUE;
    d3dParams.SwapEffect = D3DSWAPEFFECT_FLIP;
    d3dParams.BackBufferFormat = D3DFMT_X8R8G8B8;
    d3dParams.BackBufferWidth = WindowWidth();
    d3dParams.BackBufferHeight = WindowHeight();

    d3dParams.BackBufferCount = 1;
    d3dParams.hDeviceWindow = WindowHandle();

    DWORD processingType = (AccelerationType() == ACCELERATION_HW)
        ? D3DCREATE_HARDWARE_VERTEXPROCESSING
        : D3DCREATE_SOFTWARE_VERTEXPROCESSING;

    if (FAILED(_d3d9Ex->CreateDeviceEx(_adapterIdx - 1, D3DDEVTYPE_HAL,
                                       WindowHandle(), processingType,
                                       &d3dParams, NULL, &_d3dDeviceEx)))
    {
        log_error("CreateDeviceEx failed\n");
        _status = DEVICE_FAIL;
        return DEVICE_FAIL;
    }

    _d3dDeviceEx->BeginScene();
    _d3dDeviceEx->Clear(0, NULL, D3DCLEAR_TARGET, 0, 1.0f, 0);
    _d3dDeviceEx->EndScene();

    return DEVICE_PASS;
}

void CD3D9ExWrapper::Destroy()
{
    if (_d3dDeviceEx) _d3dDeviceEx->Release();
    _d3dDeviceEx = 0;
}

TDeviceStatus CD3D9ExWrapper::Status() const { return _status; }

bool CD3D9ExWrapper::AdapterNext()
{
    if (DEVICE_FAIL == _status) return false;

    _adapterFound = false;
    for (; _adapterIdx < _d3d9Ex->GetAdapterCount();)
    {
        ++_adapterIdx;
        D3DCAPS9 caps;
        if (FAILED(
                _d3d9Ex->GetDeviceCaps(_adapterIdx - 1, D3DDEVTYPE_HAL, &caps)))
            continue;

        if (FAILED(
                _d3d9Ex->GetAdapterIdentifier(_adapterIdx - 1, 0, &_adapter)))
        {
            log_error("D3D9EX: GetAdapterIdentifier failed\n");
            _status = DEVICE_FAIL;
            return false;
        }

        _adapterFound = true;
        Destroy();
        if (!Init())
        {
            _status = DEVICE_FAIL;
            _adapterFound = _status;
        }

        break;
    }

    return _adapterFound;
}

unsigned int CD3D9ExWrapper::AdapterIdx() const { return _adapterIdx - 1; }

CDXVAWrapper::CDXVAWrapper()
    : _dxvaDevice(NULL), _status(DEVICE_PASS), _adapterFound(false)
{
    _status = _d3d9.Status();
}

CDXVAWrapper::~CDXVAWrapper() { DXVAHDDestroy(); }

void *CDXVAWrapper::Device() const { return _dxvaDevice; }

TDeviceStatus CDXVAWrapper::Status() const
{
    if (_status == DEVICE_FAIL || _d3d9.Status() == DEVICE_FAIL)
        return DEVICE_FAIL;
    else if (_status == DEVICE_NOTSUPPORTED
             || _d3d9.Status() == DEVICE_NOTSUPPORTED)
        return DEVICE_NOTSUPPORTED;
    else
        return DEVICE_PASS;
}

bool CDXVAWrapper::AdapterNext()
{
    if (DEVICE_PASS != _status) return false;

    _adapterFound = _d3d9.AdapterNext();
    _status = _d3d9.Status();
    if (DEVICE_PASS != _status)
    {
        _adapterFound = false;
        return false;
    }

    if (!_adapterFound) return false;

    DXVAHDDestroy();
    _status = DXVAHDInit();
    if (DEVICE_PASS != _status)
    {
        _adapterFound = false;
        return false;
    }

    return true;
}

TDeviceStatus CDXVAWrapper::DXVAHDInit()
{
    if ((_status == DEVICE_FAIL) || (_d3d9.Status() == DEVICE_FAIL)
        || !_adapterFound)
        return DEVICE_FAIL;

    DXVAHD_RATIONAL fps = { VIDEO_FPS, 1 };

    DXVAHD_CONTENT_DESC desc;
    desc.InputFrameFormat = DXVAHD_FRAME_FORMAT_PROGRESSIVE;
    desc.InputFrameRate = fps;
    desc.InputWidth = WindowWidth();
    desc.InputHeight = WindowHeight();
    desc.OutputFrameRate = fps;
    desc.OutputWidth = WindowWidth();
    desc.OutputHeight = WindowHeight();

#ifdef USE_SOFTWARE_PLUGIN
    _status = DEVICE_FAIL;
    return DEVICE_FAIL;
#endif

    HRESULT hr = DXVAHD_CreateDevice(
        static_cast<IDirect3DDevice9Ex *>(_d3d9.Device()), &desc,
        DXVAHD_DEVICE_USAGE_PLAYBACK_NORMAL, NULL, &_dxvaDevice);
    if (FAILED(hr))
    {
        if (hr == E_NOINTERFACE)
        {
            log_error(
                "DXVAHD_CreateDevice skipped due to no supported devices!\n");
            _status = DEVICE_NOTSUPPORTED;
        }
        else
        {
            log_error("DXVAHD_CreateDevice failed\n");
            _status = DEVICE_FAIL;
        }
    }

    return _status;
}

void CDXVAWrapper::DXVAHDDestroy()
{
    if (_dxvaDevice) _dxvaDevice->Release();
    _dxvaDevice = 0;
}

void *CDXVAWrapper::D3D() const { return _d3d9.D3D(); }

unsigned int CDXVAWrapper::AdapterIdx() const { return _d3d9.AdapterIdx(); }

const CD3D9ExWrapper &CDXVAWrapper::D3D9() const { return _d3d9; }

CD3D9SurfaceWrapper::CD3D9SurfaceWrapper(): mMem(NULL) {}

CD3D9SurfaceWrapper::CD3D9SurfaceWrapper(IDirect3DSurface9 *mem): mMem(mem) {}

CD3D9SurfaceWrapper::~CD3D9SurfaceWrapper()
{
    if (mMem != NULL) mMem->Release();
    mMem = NULL;
}

#endif

CSurfaceWrapper::CSurfaceWrapper() {}

CSurfaceWrapper::~CSurfaceWrapper() {}