mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-11-24 03:00:14 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

core: added DirectX interop implementation (OpenCL) with samples

Browse Source
This commit is contained in:
Alexander Alekhin 2013-12-02 01:50:24 +04:00
parent cc69d4631a
commit 11b9d5bf4d
15 changed files with 2474 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
modules/core/include/opencv2/core.hpp
View File

@ -1262,5 +1262,4 @@ template<> struct ParamType<uchar>
#include "opencv2/core/operations.hpp"
#include "opencv2/core/cvstd.inl.hpp"
#endif /*__OPENCV_CORE_HPP__*/

21
modules/core/include/opencv2/core/base.hpp
View File

@ -223,19 +223,26 @@ enum {
CV_EXPORTS void error(int _code, const String& _err, const char* _func, const char* _file, int _line);
#ifdef __GNUC__
# if defined __clang__ || defined __APPLE__
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Winvalid-noreturn"
# endif
# if defined __clang__ || defined __APPLE__
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Winvalid-noreturn"
# endif
#endif
CV_INLINE CV_NORETURN void errorNoReturn(int _code, const String& _err, const char* _func, const char* _file, int _line)
{
error(_code, _err, _func, _file, _line);
#ifdef __GNUC__
# if !defined __clang__ && !defined __APPLE__
// this suppresses this warning: "noreturn" function does return [enabled by default]
__builtin_trap();
// or use infinite loop: for (;;) {}
# endif
#endif
}
#ifdef __GNUC__
# if defined __clang__ || defined __APPLE__
# pragma GCC diagnostic pop
# endif
# if defined __clang__ || defined __APPLE__
# pragma GCC diagnostic pop
# endif
#endif

95
modules/core/include/opencv2/core/directx.hpp Normal file
View File

@ -0,0 +1,95 @@
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors as is and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the copyright holders or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#ifndef __OPENCV_CORE_DIRECTX_HPP__
#define __OPENCV_CORE_DIRECTX_HPP__
#include "mat.hpp"
#include "ocl.hpp"
#if !defined(__d3d11_h__)
struct ID3D11Device;
struct ID3D11Texture2D;
#endif
#if !defined(__d3d10_h__)
struct ID3D10Device;
struct ID3D10Texture2D;
#endif
#if !defined(_D3D9_H_)
struct IDirect3DDevice9;
struct IDirect3DDevice9Ex;
struct IDirect3DSurface9;
#endif
namespace cv { namespace directx {
namespace ocl {
using namespace cv::ocl;
// TODO static functions in the Context class
CV_EXPORTS Context2& initializeContextFromD3D11Device(ID3D11Device* pD3D11Device);
CV_EXPORTS Context2& initializeContextFromD3D10Device(ID3D10Device* pD3D10Device);
CV_EXPORTS Context2& initializeContextFromDirect3DDevice9Ex(IDirect3DDevice9Ex* pDirect3DDevice9Ex);
CV_EXPORTS Context2& initializeContextFromDirect3DDevice9(IDirect3DDevice9* pDirect3DDevice9);
} // namespace cv::directx::ocl
CV_EXPORTS void convertToD3D11Texture2D(InputArray src, ID3D11Texture2D* pD3D11Texture2D);
CV_EXPORTS void convertFromD3D11Texture2D(ID3D11Texture2D* pD3D11Texture2D, OutputArray dst);
CV_EXPORTS void convertToD3D10Texture2D(InputArray src, ID3D10Texture2D* pD3D10Texture2D);
CV_EXPORTS void convertFromD3D10Texture2D(ID3D10Texture2D* pD3D10Texture2D, OutputArray dst);
CV_EXPORTS void convertToDirect3DSurface9(InputArray src, IDirect3DSurface9* pDirect3DSurface9, void* surfaceSharedHandle = NULL);
CV_EXPORTS void convertFromDirect3DSurface9(IDirect3DSurface9* pDirect3DSurface9, OutputArray dst, void* surfaceSharedHandle = NULL);
// Get OpenCV type from DirectX type, return -1 if there is no equivalent
CV_EXPORTS int getTypeFromDXGI_FORMAT(const int iDXGI_FORMAT); // enum DXGI_FORMAT for D3D10/D3D11
// Get OpenCV type from DirectX type, return -1 if there is no equivalent
CV_EXPORTS int getTypeFromD3DFORMAT(const int iD3DFORMAT); // enum D3DTYPE for D3D9
} } // namespace cv::directx
#endif // __OPENCV_CORE_DIRECTX_HPP__

27
modules/core/include/opencv2/core/ocl.hpp
View File

@ -214,10 +214,33 @@ public:
Program getProg(const ProgramSource2& prog,
const String& buildopt, String& errmsg);
static Context2& getDefault();
static Context2& getDefault(bool initialize = true);
void* ptr() const;
protected:
struct Impl;
inline struct Impl* _getImpl() const { return p; };
protected:
Impl* p;
};
// TODO Move to internal header
void initializeContextFromHandle(Context2& ctx, void* platform, void* context, void* device);
class CV_EXPORTS Platform
{
public:
Platform();
~Platform();
Platform(const Platform& p);
Platform& operator = (const Platform& p);
void* ptr() const;
static Platform& getDefault();
struct Impl;
inline struct Impl* _getImpl() const { return p; };
protected:
Impl* p;
};

1134
modules/core/src/directx.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

55
modules/core/src/directx.inc.hpp Normal file
View File

@ -0,0 +1,55 @@
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors as is and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the copyright holders or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#if defined(HAVE_DIRECTX)
#include <d3d11.h>
#include <d3d10.h>
#include <d3d9.h>
#ifdef HAVE_OPENCL
#include "opencv2/core/opencl/runtime/opencl_core.hpp"
#include <CL/cl_d3d11.h>
#include <CL/cl_d3d10.h>
#include <CL/cl_dx9_media_sharing.h>
#endif // HAVE_OPENCL
#endif // HAVE_DIRECTX

79
modules/core/src/ocl.cpp
View File

@ -1363,21 +1363,6 @@ void finish2()
void release() { if( CV_XADD(&refcount, -1) == 1 ) delete this; } \
int refcount
class Platform
{
public:
Platform();
~Platform();
Platform(const Platform& p);
Platform& operator = (const Platform& p);
void* ptr() const;
static Platform& getDefault();
protected:
struct Impl;
Impl* p;
};
struct Platform::Impl
{
Impl()
@ -1773,6 +1758,12 @@ const Device& Device::getDefault()
struct Context2::Impl
{
Impl()
{
refcount = 1;
handle = 0;
}
Impl(int dtype0)
{
refcount = 1;
@ -1855,7 +1846,6 @@ struct Context2::Impl
cl_context handle;
std::vector<Device> devices;
bool initialized;
typedef ProgramSource2::hash_t hash_t;
@ -1937,22 +1927,29 @@ const Device& Context2::device(size_t idx) const
return !p || idx >= p->devices.size() ? dummy : p->devices[idx];
}
Context2& Context2::getDefault()
Context2& Context2::getDefault(bool initialize)
{
static Context2 ctx;
if( !ctx.p && haveOpenCL() )
if(!ctx.p && haveOpenCL())
{
// do not create new Context2 right away.
// First, try to retrieve existing context of the same type.
// In its turn, Platform::getContext() may call Context2::create()
// if there is no such context.
ctx.create(Device::TYPE_ACCELERATOR);
if(!ctx.p)
ctx.create(Device::TYPE_DGPU);
if(!ctx.p)
ctx.create(Device::TYPE_IGPU);
if(!ctx.p)
ctx.create(Device::TYPE_CPU);
if (initialize)
{
// do not create new Context2 right away.
// First, try to retrieve existing context of the same type.
// In its turn, Platform::getContext() may call Context2::create()
// if there is no such context.
ctx.create(Device::TYPE_ACCELERATOR);
if(!ctx.p)
ctx.create(Device::TYPE_DGPU);
if(!ctx.p)
ctx.create(Device::TYPE_IGPU);
if(!ctx.p)
ctx.create(Device::TYPE_CPU);
}
else
{
ctx.p = new Impl();
}
}
return ctx;
@ -1964,6 +1961,30 @@ Program Context2::getProg(const ProgramSource2& prog,
return p ? p->getProg(prog, buildopts, errmsg) : Program();
}
void initializeContextFromHandle(Context2& ctx, void* platform, void* _context, void* _device)
{
cl_context context = (cl_context)_context;
cl_device_id device = (cl_device_id)_device;
// cleanup old context
Context2::Impl* impl = ctx._getImpl();
if (impl->handle)
{
cl_int status = clReleaseContext(impl->handle);
(void)status;
}
impl->devices.clear();
impl->handle = context;
impl->devices.resize(1);
impl->devices[0].set(device);
Platform& p = Platform::getDefault();
Platform::Impl* pImpl = p._getImpl();
pImpl->handle = (cl_platform_id)platform;
}
struct Queue::Impl
{
Impl(const Context2& c, const Device& d)

3
modules/core/src/precomp.hpp
View File

@ -43,6 +43,9 @@
#ifndef __OPENCV_PRECOMP_H__
#define __OPENCV_PRECOMP_H__
#include "opencv2/opencv_modules.hpp"
#include "cvconfig.h"
#include "opencv2/core/utility.hpp"
#include "opencv2/core/core_c.h"
#include "opencv2/core/cuda.hpp"

8
samples/CMakeLists.txt
View File

@ -15,6 +15,10 @@ add_subdirectory(cpp)
add_subdirectory(gpu)
add_subdirectory(ocl)
if(WIN32 AND HAVE_DIRECTX)
add_subdirectory(directx)
endif()
if(ANDROID AND BUILD_ANDROID_EXAMPLES)
add_subdirectory(android)
endif()
@ -62,6 +66,10 @@ add_subdirectory(cpp)
add_subdirectory(ocl)
# FIXIT: can't use cvconfig.h in samples: add_subdirectory(gpu)
if(WIN32)
add_subdirectory(directx)
endif()
#
# END OF BUILD CASE 2: Build samples with library binaries
#

45
samples/directx/CMakeLists.txt Normal file
View File

@ -0,0 +1,45 @@
SET(OPENCV_DIRECTX_SAMPLES_REQUIRED_DEPS opencv_core opencv_imgproc opencv_highgui)
ocv_check_dependencies(${OPENCV_DIRECTX_SAMPLES_REQUIRED_DEPS})
if(BUILD_EXAMPLES AND OCV_DEPENDENCIES_FOUND)
set(project "directx")
string(TOUPPER "${project}" project_upper)
project("${project}_samples")
ocv_include_modules(${OPENCV_DIRECTX_SAMPLES_REQUIRED_DEPS})
# ---------------------------------------------
# Define executable targets
# ---------------------------------------------
MACRO(OPENCV_DEFINE_DIRECTX_EXAMPLE name srcs)
set(the_target "example_${project}_${name}")
add_executable(${the_target} ${srcs})
target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${OPENCV_DIRECTX_SAMPLES_REQUIRED_DEPS})
set_target_properties(${the_target} PROPERTIES
OUTPUT_NAME "${project}-example-${name}"
PROJECT_LABEL "(EXAMPLE_${project_upper}) ${name}")
if(ENABLE_SOLUTION_FOLDERS)
set_target_properties(${the_target} PROPERTIES FOLDER "samples//${project}")
endif()
if(WIN32)
if(MSVC AND NOT BUILD_SHARED_LIBS)
set_target_properties(${the_target} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:atlthunk.lib /NODEFAULTLIB:atlsd.lib /DEBUG")
endif()
install(TARGETS ${the_target} RUNTIME DESTINATION "${OPENCV_SAMPLES_BIN_INSTALL_PATH}/${project}" COMPONENT main)
endif()
ENDMACRO()
file(GLOB all_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
foreach(sample_filename ${all_samples})
get_filename_component(sample ${sample_filename} NAME_WE)
file(GLOB sample_srcs RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${sample}.*)
OPENCV_DEFINE_DIRECTX_EXAMPLE(${sample} ${sample_srcs})
endforeach()
endif()

138
samples/directx/d3d10_interop.cpp Normal file
View File

@ -0,0 +1,138 @@
#include <windows.h>
#include <d3d10.h>
#pragma comment (lib, "d3d10.lib")
#define USE_D3D10
#define WINDOW_NAME "OpenCV Direct3D 10 Sample"
IDXGISwapChain *swapchain = NULL;
ID3D10Device *dev = NULL;
ID3D10Texture2D *pBackBufferTexture = NULL;
ID3D10Texture2D *pCPUWriteTexture = NULL;
ID3D10Texture2D *pInputTexture = NULL;
ID3D10RenderTargetView *backbuffer = NULL;
#include "d3d_base.inl.hpp"
bool initDirect3D()
{
DXGI_SWAP_CHAIN_DESC scd;
ZeroMemory(&scd, sizeof(DXGI_SWAP_CHAIN_DESC));
scd.BufferCount = 1; // one back buffer
scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; // use 32-bit color
scd.BufferDesc.Width = WIDTH; // set the back buffer width
scd.BufferDesc.Height = HEIGHT; // set the back buffer height
scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; // how swap chain is to be used
scd.OutputWindow = hWnd; // the window to be used
scd.SampleDesc.Count = 1; // how many multisamples
scd.Windowed = TRUE; // windowed/full-screen mode
scd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
scd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; // allow full-screen switching
if (FAILED(D3D10CreateDeviceAndSwapChain(
NULL,
D3D10_DRIVER_TYPE_HARDWARE,
NULL,
0,
D3D10_SDK_VERSION,
&scd,
&swapchain,
&dev)))
{
return false;
}
if (FAILED(swapchain->GetBuffer(0, __uuidof(ID3D10Texture2D), (LPVOID*)&pBackBufferTexture)))
{
return false;
}
if (FAILED(dev->CreateRenderTargetView(pBackBufferTexture, NULL, &backbuffer)))
{
return false;
}
dev->OMSetRenderTargets(1, &backbuffer, NULL);
D3D10_VIEWPORT viewport;
ZeroMemory(&viewport, sizeof(D3D10_VIEWPORT));
viewport.Width = WIDTH;
viewport.Height = HEIGHT;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 0.0f;
dev->RSSetViewports(1, &viewport);
return true;
}
bool initDirect3DTextures()
{
{ // Create texture for demo 0
D3D10_TEXTURE2D_DESC desc = { 0 };
desc.Width = WIDTH;
desc.Height = HEIGHT;
desc.MipLevels = desc.ArraySize = 1;
desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
desc.SampleDesc.Count = 1;
desc.BindFlags = D3D10_BIND_SHADER_RESOURCE;
desc.Usage = D3D10_USAGE_DYNAMIC;
desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
if (FAILED(dev->CreateTexture2D(&desc, NULL, &pCPUWriteTexture)))
{
std::cerr << "Can't create texture for CPU write sample" << std::endl;
return false;
}
}
{ // Create Read-only texture
cv::Mat inputMat = getInputTexture();
D3D10_TEXTURE2D_DESC desc = { 0 };
desc.Width = inputMat.size().width;
desc.Height = inputMat.size().height;
desc.MipLevels = desc.ArraySize = 1;
desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
desc.SampleDesc.Count = 1;
desc.BindFlags = D3D10_BIND_SHADER_RESOURCE;
desc.Usage = D3D10_USAGE_IMMUTABLE;
desc.CPUAccessFlags = cv::ocl::useOpenCL() ? 0 : D3D10_CPU_ACCESS_READ;
D3D10_SUBRESOURCE_DATA srInitData;
srInitData.pSysMem = inputMat.data;
srInitData.SysMemPitch = (UINT)inputMat.step[0];
if (FAILED(dev->CreateTexture2D(&desc, &srInitData, &pInputTexture)))
{
std::cerr << "Can't create texture with input image" << std::endl;
return false;
}
}
return true;
}
void cleanUp(void)
{
if (swapchain) swapchain->SetFullscreenState(FALSE, NULL); // switch to windowed mode
SAFE_RELEASE(swapchain);
SAFE_RELEASE(pCPUWriteTexture);
SAFE_RELEASE(pInputTexture);
SAFE_RELEASE(pBackBufferTexture);
SAFE_RELEASE(backbuffer);
SAFE_RELEASE(dev);
}
void render(void)
{
// check to make sure you have a valid Direct3D device
CV_Assert(dev);
renderToD3DObject();
// switch the back buffer and the front buffer
swapchain->Present(0, 0);
}

143
samples/directx/d3d11_interop.cpp Normal file
View File

@ -0,0 +1,143 @@
#include <windows.h>
#include <d3d11.h>
#pragma comment (lib, "d3d11.lib")
#define USE_D3D11
#define WINDOW_NAME "OpenCV Direct3D 11 Sample"
IDXGISwapChain *swapchain = NULL;
ID3D11Device *dev = NULL;
ID3D11DeviceContext *devcon = NULL;
ID3D11Texture2D *pBackBufferTexture = NULL;
ID3D11Texture2D *pCPUWriteTexture = NULL;
ID3D11Texture2D *pInputTexture = NULL;
ID3D11RenderTargetView *backbuffer = NULL;
#include "d3d_base.inl.hpp"
bool initDirect3D()
{
DXGI_SWAP_CHAIN_DESC scd;
ZeroMemory(&scd, sizeof(DXGI_SWAP_CHAIN_DESC));
scd.BufferCount = 1; // one back buffer
scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; // use 32-bit color
scd.BufferDesc.Width = WIDTH; // set the back buffer width
scd.BufferDesc.Height = HEIGHT; // set the back buffer height
scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; // how swap chain is to be used
scd.OutputWindow = hWnd; // the window to be used
scd.SampleDesc.Count = 1; // how many multisamples
scd.Windowed = TRUE; // windowed/full-screen mode
scd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
scd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; // allow full-screen switching
if (FAILED(D3D11CreateDeviceAndSwapChain(
NULL,
D3D_DRIVER_TYPE_HARDWARE,
NULL,
0,
NULL,
0,
D3D11_SDK_VERSION,
&scd,
&swapchain,
&dev,
NULL,
&devcon)))
{
return false;
}
if (FAILED(swapchain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBufferTexture)))
{
return false;
}
if (FAILED(dev->CreateRenderTargetView(pBackBufferTexture, NULL, &backbuffer)))
{
return false;
}
devcon->OMSetRenderTargets(1, &backbuffer, NULL);
D3D11_VIEWPORT viewport = { 0 };
viewport.Width = WIDTH;
viewport.Height = HEIGHT;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 0.0f;
devcon->RSSetViewports(1, &viewport);
return true;
}
bool initDirect3DTextures()
{
{ // Create texture for demo 0
D3D11_TEXTURE2D_DESC desc = { 0 };
desc.Width = WIDTH;
desc.Height = HEIGHT;
desc.MipLevels = desc.ArraySize = 1;
desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
desc.SampleDesc.Count = 1;
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
if (FAILED(dev->CreateTexture2D(&desc, NULL, &pCPUWriteTexture)))
{
std::cerr << "Can't create texture for CPU write sample" << std::endl;
return false;
}
}
{ // Create Read-only texture
cv::Mat inputMat = getInputTexture();
D3D11_TEXTURE2D_DESC desc = { 0 };
desc.Width = inputMat.size().width;
desc.Height = inputMat.size().height;
desc.MipLevels = desc.ArraySize = 1;
desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
desc.SampleDesc.Count = 1;
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
desc.Usage = D3D11_USAGE_IMMUTABLE;
desc.CPUAccessFlags = cv::ocl::useOpenCL() ? 0 : D3D11_CPU_ACCESS_READ;
D3D11_SUBRESOURCE_DATA srInitData;
srInitData.pSysMem = inputMat.data;
srInitData.SysMemPitch = (UINT)inputMat.step[0];
if (FAILED(dev->CreateTexture2D(&desc, &srInitData, &pInputTexture)))
{
std::cerr << "Can't create texture with input image" << std::endl;
return false;
}
}
return true;
}
void cleanUp(void)
{
if (swapchain) swapchain->SetFullscreenState(FALSE, NULL); // switch to windowed mode
SAFE_RELEASE(swapchain);
SAFE_RELEASE(pCPUWriteTexture);
SAFE_RELEASE(pInputTexture);
SAFE_RELEASE(pBackBufferTexture);
SAFE_RELEASE(backbuffer);
SAFE_RELEASE(dev);
SAFE_RELEASE(devcon);
}
void render(void)
{
// check to make sure you have a valid Direct3D device
CV_Assert(dev);
renderToD3DObject();
// switch the back buffer and the front buffer
swapchain->Present(0, 0);
}

149
samples/directx/d3d9_interop.cpp Normal file
View File

@ -0,0 +1,149 @@
#include <windows.h>
#include <d3d9.h>
#pragma comment (lib, "d3d9.lib")
#define USE_D3D9
#define WINDOW_NAME "OpenCV Direct3D 9 Sample"
IDirect3D9 *pD3D = NULL;
IDirect3DDevice9 *dev = NULL;
IDirect3DSurface9 *pBackBuffer = NULL;
IDirect3DSurface9 *pCPUWriteSurface = NULL; // required name
IDirect3DSurface9 *pReadOnlySurface = NULL; // required name
HANDLE readOnlySurfaceShared = 0; // required name
IDirect3DSurface9 *pSurface = NULL; // required name
HANDLE surfaceShared = 0; // required name
#include "d3d_base.inl.hpp"
bool initDirect3D(void)
{
if (NULL == (pD3D = Direct3DCreate9(D3D_SDK_VERSION)))
{
return false;
}
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory(&d3dpp,sizeof(D3DPRESENT_PARAMETERS));
DWORD flags = D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE | D3DCREATE_NOWINDOWCHANGES
| D3DCREATE_MULTITHREADED;
d3dpp.Windowed = true;
d3dpp.Flags = 0;
d3dpp.BackBufferCount = 0;
d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;
d3dpp.BackBufferHeight = HEIGHT;
d3dpp.BackBufferWidth = WIDTH;
d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.hDeviceWindow = hWnd;
d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
if (FAILED(pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, flags, &d3dpp, &dev)))
{
return false;
}
if (FAILED(dev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer)))
{
return false;
}
return true;
}
bool initDirect3DTextures()
{
// Note: sharing is not supported on some platforms
if (FAILED(dev->CreateOffscreenPlainSurface(WIDTH, HEIGHT, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &pSurface, NULL/*&surfaceShared*/)))
{
std::cerr << "Can't create surface for result" << std::endl;
return false;
}
// Note: sharing is not supported on some platforms
if (FAILED(dev->CreateOffscreenPlainSurface(WIDTH, HEIGHT, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &pReadOnlySurface, NULL/*&readOnlySurfaceShared*/)))
{
std::cerr << "Can't create read only surface" << std::endl;
return false;
}
else
{
IDirect3DSurface9* pTmpSurface;
if (FAILED(dev->CreateOffscreenPlainSurface(WIDTH, HEIGHT, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &pTmpSurface, NULL)))
{
std::cerr << "Can't create temp surface for CPU write" << std::endl;
return false;
}
D3DLOCKED_RECT memDesc = {0, NULL};
RECT rc = {0, 0, WIDTH, HEIGHT};
if (SUCCEEDED(pTmpSurface->LockRect(&memDesc, &rc, 0)))
{
cv::Mat m(cv::Size(WIDTH, HEIGHT), CV_8UC4, memDesc.pBits, (int)memDesc.Pitch);
getInputTexture().copyTo(m);
pTmpSurface->UnlockRect();
dev->StretchRect(pTmpSurface, NULL, pReadOnlySurface, NULL, D3DTEXF_NONE);
}
else
{
std::cerr << "Can't LockRect() on surface" << std::endl;
}
pTmpSurface->Release();
}
if (FAILED(dev->CreateOffscreenPlainSurface(WIDTH, HEIGHT, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &pCPUWriteSurface, NULL)))
{
std::cerr << "Can't create surface for CPU write" << std::endl;
return false;
}
return true;
}
void render(void)
{
// check to make sure you have a valid Direct3D device
CV_Assert(dev);
renderToD3DObject();
if (g_sampleType == 0)
{
// nothing
}
else if (g_sampleType == 1)
{
if (FAILED(dev->StretchRect(pCPUWriteSurface, NULL, pBackBuffer, NULL, D3DTEXF_NONE)))
{
std::cerr << "Can't StretchRect()" << std::endl;
}
}
else
{
if (FAILED(dev->StretchRect(pSurface, NULL, pBackBuffer, NULL, D3DTEXF_NONE)))
{
std::cerr << "Can't StretchRect()" << std::endl;
}
}
if (SUCCEEDED(dev -> BeginScene()))
{
// end the scene
dev -> EndScene();
}
// present the back buffer contents to the display
dev->Present(NULL, NULL, NULL, NULL);
}
void cleanUp (void)
{
SAFE_RELEASE(pCPUWriteSurface);
SAFE_RELEASE(pReadOnlySurface);
SAFE_RELEASE(pSurface);
SAFE_RELEASE(pBackBuffer);
SAFE_RELEASE(dev);
SAFE_RELEASE(pD3D);}

158
samples/directx/d3d9ex_interop.cpp Normal file
View File

@ -0,0 +1,158 @@
#include <windows.h>
#include <d3d9.h>
#pragma comment (lib, "d3d9.lib")
#define USE_D3DEX
#define WINDOW_NAME "OpenCV Direct3D 9 Ex Sample"
IDirect3D9Ex *pD3D = NULL;
IDirect3DDevice9Ex *dev = NULL;
IDirect3DSurface9 *pBackBuffer = NULL;
IDirect3DSurface9 *pCPUWriteSurface = NULL; // required name
IDirect3DSurface9 *pReadOnlySurface = NULL; // required name
HANDLE readOnlySurfaceShared = 0; // required name
IDirect3DSurface9 *pSurface = NULL; // required name
HANDLE surfaceShared = 0; // required name
#include "d3d_base.inl.hpp"
bool initDirect3D(void)
{
if (FAILED(Direct3DCreate9Ex(D3D_SDK_VERSION, &pD3D)))
{
return false;
}
D3DDISPLAYMODEEX ddm;
ZeroMemory(&ddm, sizeof(ddm));
ddm.Size = sizeof(D3DDISPLAYMODEEX);
D3DDISPLAYROTATION rotation;
if (FAILED(pD3D->GetAdapterDisplayModeEx(D3DADAPTER_DEFAULT, &ddm, &rotation)))
{
return false;
}
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory(&d3dpp,sizeof(D3DPRESENT_PARAMETERS));
DWORD flags = D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE | D3DCREATE_NOWINDOWCHANGES
| D3DCREATE_MULTITHREADED;
d3dpp.Windowed = true;
d3dpp.Flags = 0;
d3dpp.BackBufferCount = 0;
d3dpp.BackBufferFormat = ddm.Format;
d3dpp.BackBufferHeight = HEIGHT;
d3dpp.BackBufferWidth = WIDTH;
d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.hDeviceWindow = hWnd;
d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
if (FAILED(pD3D->CreateDeviceEx(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, flags, &d3dpp, NULL, &dev)))
{
return false;
}
if (FAILED(dev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer)))
{
return false;
}
return true;
}
bool initDirect3DTextures()
{
if (FAILED(dev->CreateOffscreenPlainSurface(WIDTH, HEIGHT, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &pSurface, &surfaceShared)))
{
std::cerr << "Can't create surface for result" << std::endl;
return false;
}
if (FAILED(dev->CreateOffscreenPlainSurface(WIDTH, HEIGHT, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &pReadOnlySurface, &readOnlySurfaceShared)))
{
std::cerr << "Can't create read only surface" << std::endl;
return false;
}
else
{
IDirect3DSurface9* pTmpSurface;
if (FAILED(dev->CreateOffscreenPlainSurface(WIDTH, HEIGHT, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &pTmpSurface, NULL)))
{
std::cerr << "Can't create temp surface for CPU write" << std::endl;
return false;
}
D3DLOCKED_RECT memDesc = {0, NULL};
RECT rc = {0, 0, WIDTH, HEIGHT};
if (SUCCEEDED(pTmpSurface->LockRect(&memDesc, &rc, 0)))
{
cv::Mat m(cv::Size(WIDTH, HEIGHT), CV_8UC4, memDesc.pBits, (int)memDesc.Pitch);
getInputTexture().copyTo(m);
pTmpSurface->UnlockRect();
dev->StretchRect(pTmpSurface, NULL, pReadOnlySurface, NULL, D3DTEXF_NONE);
}
else
{
std::cerr << "Can't LockRect() on surface" << std::endl;
}
pTmpSurface->Release();
}
if (FAILED(dev->CreateOffscreenPlainSurface(WIDTH, HEIGHT, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &pCPUWriteSurface, NULL)))
{
std::cerr << "Can't create surface for CPU write" << std::endl;
return false;
}
return true;
}
void render(void)
{
// check to make sure you have a valid Direct3D device
CV_Assert(dev);
renderToD3DObject();
if (g_sampleType == 0)
{
// nothing
}
else if (g_sampleType == 1)
{
if (FAILED(dev->StretchRect(pCPUWriteSurface, NULL, pBackBuffer, NULL, D3DTEXF_NONE)))
{
std::cerr << "Can't StretchRect()" << std::endl;
}
}
else
{
if (FAILED(dev->StretchRect(pSurface, NULL, pBackBuffer, NULL, D3DTEXF_NONE)))
{
std::cerr << "Can't StretchRect()" << std::endl;
}
}
if (SUCCEEDED(dev -> BeginScene()))
{
// end the scene
dev -> EndScene();
}
// present the back buffer contents to the display
dev->Present(NULL, NULL, NULL, NULL);
}
void cleanUp (void)
{
SAFE_RELEASE(pCPUWriteSurface);
SAFE_RELEASE(pReadOnlySurface);
SAFE_RELEASE(pSurface);
SAFE_RELEASE(pBackBuffer);
SAFE_RELEASE(dev);
SAFE_RELEASE(pD3D);
}

457
samples/directx/d3d_base.inl.hpp Normal file
View File

@ -0,0 +1,457 @@
//
// Don't use as a standalone file
//
#include "opencv2/core.hpp"
#include "opencv2/core/utility.hpp" // cv::format
#include "opencv2/imgproc.hpp" // cvtColor
#include "opencv2/imgproc/types_c.h" // cvtColor
#include "opencv2/highgui.hpp" // imread
#include "opencv2/core/directx.hpp"
#include <iostream>
#include <queue>
using namespace cv;
using namespace cv::directx;
static const int fontFace = cv::FONT_HERSHEY_DUPLEX;
#if !defined(USE_D3D9) && !defined(USE_D3DEX)
const cv::Scalar frameColor(255,128,0,255);
#else
const cv::Scalar frameColor(0,128,255,255); // BGRA for D3D9
#endif
#define SAFE_RELEASE(p) if (p) { p->Release(); p = NULL; }
const int WIDTH = 1024;
const int HEIGHT = 768;
HINSTANCE hInstance;
HWND hWnd;
// external declaration
bool initDirect3D(void);
bool initDirect3DTextures(void);
void render(void);
void cleanUp (void);
#define USAGE_DESCRIPTION_0 "1 - CPU write via LockRect/Map"
#define USAGE_DESCRIPTION_1 "2* - Mat->D3D"
#define USAGE_DESCRIPTION_2 "3* - D3D->UMat / change UMat / UMat->D3D"
#define USAGE_DESCRIPTION_3 "0 - show input texture without any processing"
#define USAGE_DESCRIPTION_SPACE "SPACE - toggle frame processing (only data transfers)"
static int g_sampleType = 0;
static int g_disableProcessing = false;
// forward declaration
static LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
static bool initWindow()
{
WNDCLASSEX wcex;
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon(0, IDI_APPLICATION);
wcex.hCursor = LoadCursor(0, IDC_ARROW);
wcex.hbrBackground = 0;
wcex.lpszMenuName = 0L;
wcex.lpszClassName = "OpenCVDirectX";
wcex.hIconSm = 0;
RegisterClassEx(&wcex);
RECT rc = {0, 0, WIDTH, HEIGHT};
AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, false);
hWnd = CreateWindow("OpenCVDirectX", WINDOW_NAME,
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, rc.right - rc.left, rc.bottom - rc.top, NULL, NULL, hInstance, NULL);
if (!hWnd)
return false;
ShowWindow(hWnd, SW_SHOW);
UpdateWindow(hWnd);
return true;
}
static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_DESTROY:
PostQuitMessage(0);
return 0;
case WM_CHAR:
if (wParam >= '0' && wParam <= '3')
{
g_sampleType = (char)wParam - '0';
return 0;
}
else if (wParam == ' ')
{
g_disableProcessing = !g_disableProcessing;
return 0;
}
else if (wParam == VK_ESCAPE)
{
DestroyWindow(hWnd);
return 0;
}
break;
}
return DefWindowProc(hWnd, message, wParam, lParam);
}
static float getFps()
{
static std::queue<int64> time_queue;
int64 now = cv::getTickCount(), then = 0;
time_queue.push(now);
if (time_queue.size() >= 2)
then = time_queue.front();
if (time_queue.size() >= 25)
time_queue.pop();
return time_queue.size() * (float)cv::getTickFrequency() / (now - then);
}
static int bgColor[4] = {0, 0, 0, 0};
static cv::Mat* inputMat = NULL;
static void renderToD3DObject(void)
{
static int frame = 0;
const float fps = getFps();
String deviceName = cv::ocl::useOpenCL() ? cv::ocl::Context2::getDefault().device(0).name() : "No OpenCL device";
if ((frame % std::max(1, (int)(fps / 25))) == 0)
{
String msg = format("%s%s: %s, Sample %d, Frame %d, fps %g (%g ms)",
g_disableProcessing ? "(FRAME PROCESSING DISABLED) " : "",
WINDOW_NAME, deviceName.c_str(), g_sampleType,
frame, fps, (int(10 * 1000.0 / fps)) * 0.1);
SetWindowText(hWnd, msg.c_str());
}
// 0..255
int c[4] =
{
std::abs((frame & 0x1ff) - 0x100),
std::abs(((frame * 2) & 0x1ff) - 0x100),
std::abs(((frame / 2) & 0x1ff) - 0x100),
0
};
int c1 = c[0] / 2 - 0x40 - bgColor[0];
int c2 = c[1] / 2 - 0x40 - bgColor[1];
int c3 = c[2] / 2 - 0x40 - bgColor[2];
switch (g_sampleType)
{
case 0:
#if defined(USE_D3D9) || defined (USE_D3DEX)
if (FAILED(dev->StretchRect(pReadOnlySurface, NULL, pBackBuffer, NULL, D3DTEXF_NONE)))
{
std::cerr << "Can't StretchRect()" << std::endl;
}
#elif defined(USE_D3D10)
dev->CopyResource(pBackBufferTexture, pInputTexture);
#elif defined(USE_D3D11)
devcon->CopyResource(pBackBufferTexture, pInputTexture);
#else
#error "Invalid USE_D3D value"
#endif
break;
case 1:
{
int BOXSIZE = 50;
int x = std::abs(((frame * 1) % (2 * (WIDTH - BOXSIZE))) - (WIDTH - BOXSIZE));
int y = std::abs(((frame / 2) % (2 * (HEIGHT - BOXSIZE))) - (HEIGHT - BOXSIZE));
cv::Rect boxRect(x, y, BOXSIZE, BOXSIZE);
#if defined(USE_D3D9) || defined (USE_D3DEX)
D3DLOCKED_RECT memDesc = {0, NULL};
RECT rc = {0, 0, WIDTH, HEIGHT};
if (SUCCEEDED(pCPUWriteSurface->LockRect(&memDesc, &rc, 0)))
{
if (!g_disableProcessing)
{
Mat m(Size(WIDTH, HEIGHT), CV_8UC4, memDesc.pBits, (int)memDesc.Pitch);
inputMat->copyTo(m);
m(boxRect).setTo(Scalar(c[0], c[1], c[2], 255));
}
pCPUWriteSurface->UnlockRect();
}
else
{
std::cerr << "Can't LockRect() on surface" << std::endl;
}
#elif defined(USE_D3D10)
D3D10_MAPPED_TEXTURE2D mappedTex;
if (SUCCEEDED(pCPUWriteTexture->Map( D3D10CalcSubresource(0, 0, 1), D3D10_MAP_WRITE_DISCARD, 0, &mappedTex)))
{
if (!g_disableProcessing)
{
Mat m(Size(WIDTH, HEIGHT), CV_8UC4, mappedTex.pData, (int)mappedTex.RowPitch);
inputMat->copyTo(m);
m(boxRect).setTo(Scalar(c[0], c[1], c[2], 255));
}
pCPUWriteTexture->Unmap(D3D10CalcSubresource(0, 0, 1));
dev->CopyResource(pBackBufferTexture, pCPUWriteTexture);
}
else
{
std::cerr << "Can't Map() texture" << std::endl;
}
#elif defined(USE_D3D11)
D3D11_MAPPED_SUBRESOURCE mappedTex;
if (SUCCEEDED(devcon->Map(pCPUWriteTexture, D3D11CalcSubresource(0, 0, 1), D3D11_MAP_WRITE_DISCARD, 0, &mappedTex)))
{
if (!g_disableProcessing)
{
Mat m(Size(WIDTH, HEIGHT), CV_8UC4, mappedTex.pData, (int)mappedTex.RowPitch);
inputMat->copyTo(m);
m(boxRect).setTo(Scalar(c[0], c[1], c[2], 255));
}
devcon->Unmap(pCPUWriteTexture, D3D11CalcSubresource(0, 0, 1));
devcon->CopyResource(pBackBufferTexture, pCPUWriteTexture);
}
else
{
std::cerr << "Can't Map() texture" << std::endl;
}
#else
#error "Invalid USE_D3D value"
#endif
break;
}
case 2:
{
static Mat m;
if (!g_disableProcessing)
{
#if 1
cv::add(*inputMat, Scalar(c1, c2, c3, 255), m);
#else
inputMat->copyTo(m);
#endif
cv::putText(m,
cv::format("Frame %d, fps %g (%g ms)",
frame, fps, (int(10 * 1000.0 / fps)) * 0.1),
cv::Point(8, 80), fontFace, 1, frameColor, 2);
}
else
{
m.create(Size(WIDTH, HEIGHT), CV_8UC4);
}
try
{
#if defined(USE_D3D9) || defined (USE_D3DEX)
convertToDirect3DSurface9(m, pSurface, (void*)surfaceShared);
#elif defined(USE_D3D10)
convertToD3D10Texture2D(m, pBackBufferTexture);
#elif defined(USE_D3D11)
convertToD3D11Texture2D(m, pBackBufferTexture);
#else
#error "Invalid USE_D3D value"
#endif
}
catch (cv::Exception& e)
{
std::cerr << "Can't convert to D3D object: exception: " << e.what() << std::endl;
}
catch (...)
{
std::cerr << "Can't convert to D3D object" << std::endl;
}
break;
}
case 3:
{
static UMat tmp;
try
{
#if defined(USE_D3D9) || defined (USE_D3DEX)
convertFromDirect3DSurface9(pReadOnlySurface, tmp, (void*)readOnlySurfaceShared);
#elif defined(USE_D3D10)
convertFromD3D10Texture2D(pInputTexture, tmp);
#elif defined(USE_D3D11)
convertFromD3D11Texture2D(pInputTexture, tmp);
#else
#error "Invalid USE_D3D value"
#endif
}
catch (cv::Exception& e)
{
std::cerr << "Can't convert from D3D object: exception: " << e.what() << std::endl;
}
catch (...)
{
std::cerr << "Can't convert from D3D object" << std::endl;
}
static UMat res;
if (!g_disableProcessing)
{
cv::add(tmp, Scalar(c1, c2, c3, 255), res);
}
else
{
res = tmp;
}
try
{
#if defined(USE_D3D9) || defined (USE_D3DEX)
convertToDirect3DSurface9(res, pSurface, (void*)surfaceShared);
#elif defined(USE_D3D10)
convertToD3D10Texture2D(res, pBackBufferTexture);
#elif defined(USE_D3D11)
convertToD3D11Texture2D(res, pBackBufferTexture);
#else
#error "Invalid USE_D3D value"
#endif
}
catch (cv::Exception& e)
{
std::cerr << "Can't convert to D3D object: exception: " << e.what() << std::endl;
}
catch (...)
{
std::cerr << "Can't convert to D3D object" << std::endl;
}
break;
}
}
frame++;
}
static cv::Mat getInputTexture()
{
cv::Mat inputMat = cv::imread("input.bmp", cv::IMREAD_COLOR);
if (inputMat.depth() != CV_8U)
{
inputMat.convertTo(inputMat, CV_8U);
}
if (inputMat.type() == CV_8UC3)
{
cv::cvtColor(inputMat, inputMat, CV_RGB2BGRA);
}
if (inputMat.type() != CV_8UC4 || inputMat.size().area() == 0)
{
std::cerr << "Invalid input image format. Generate other" << std::endl;
inputMat.create(cv::Size(WIDTH, HEIGHT), CV_8UC4);
inputMat.setTo(cv::Scalar(0, 0, 255, 255));
bgColor[0] = -128; bgColor[1] = -128; bgColor[2] = 127; bgColor[3] = -128;
}
if (inputMat.size().width != WIDTH || inputMat.size().height != HEIGHT)
{
cv::resize(inputMat, inputMat, cv::Size(WIDTH, HEIGHT));
}
String deviceName = cv::ocl::useOpenCL() ? cv::ocl::Context2::getDefault().device(0).name() : "No OpenCL device";
cv::Scalar color(64, 255, 64, 255);
cv::putText(inputMat,
cv::format("OpenCL Device name: %s", deviceName.c_str()),
cv::Point(8,32), fontFace, 1, color);
cv::putText(inputMat, WINDOW_NAME, cv::Point(50, HEIGHT - 32), fontFace, 1, color);
cv::putText(inputMat, USAGE_DESCRIPTION_0, cv::Point(30, 128), fontFace, 1, color);
cv::putText(inputMat, USAGE_DESCRIPTION_1, cv::Point(30, 192), fontFace, 1, color);
cv::putText(inputMat, USAGE_DESCRIPTION_2, cv::Point(30, 256), fontFace, 1, color);
cv::putText(inputMat, USAGE_DESCRIPTION_3, cv::Point(30, 320), fontFace, 1, color);
cv::putText(inputMat, USAGE_DESCRIPTION_SPACE, cv::Point(30, 448), fontFace, 1, color);
#if defined(USE_D3D9) || defined (USE_D3DEX)
cv::cvtColor(inputMat, inputMat, CV_RGBA2BGRA);
std::swap(bgColor[0], bgColor[2]);
#endif
// Make a global copy
::inputMat = new cv::Mat(inputMat);
return inputMat;
}
static int mainLoop()
{
hInstance = GetModuleHandle(NULL);
if (!initWindow())
CV_Error(cv::Error::StsError, "Can't create window");
if (!initDirect3D())
CV_Error(cv::Error::StsError, "Can't create D3D object");
if (cv::ocl::haveOpenCL())
{
#if defined(USE_D3D9)
cv::ocl::Context2& ctx = cv::directx::ocl::initializeContextFromDirect3DDevice9(dev);
#elif defined (USE_D3DEX)
cv::ocl::Context2& ctx = cv::directx::ocl::initializeContextFromDirect3DDevice9Ex(dev);
#elif defined(USE_D3D10)
cv::ocl::Context2& ctx = cv::directx::ocl::initializeContextFromD3D10Device(dev);
#elif defined(USE_D3D11)
cv::ocl::Context2& ctx = cv::directx::ocl::initializeContextFromD3D11Device(dev);
#else
#error "Invalid USE_D3D value"
#endif
std::cout << "Selected device: " << ctx.device(0).name().c_str() << std::endl;
g_sampleType = 2;
}
else
{
std::cerr << "OpenCL is not available. DirectX - OpenCL interop will not work" << std::endl;
}
if (!initDirect3DTextures())
CV_Error(cv::Error::StsError, "Can't create D3D texture object");
MSG msg;
ZeroMemory(&msg, sizeof(msg));
while (msg.message != WM_QUIT)
{
if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
render();
}
}
cleanUp();
return static_cast<int>(msg.wParam);
}
int main(int /*argc*/, char ** /*argv*/)
{
try
{
return mainLoop();
}
catch (cv::Exception& e)
{
std::cerr << "Exception: " << e.what() << std::endl;
return 10;
}
catch (...)
{
std::cerr << "FATAL ERROR: Unknown exception" << std::endl;
return 11;
}
}