DirectX9 Grabber (#1039)

libsrc/grabber/directx/CMakeLists.txt

@@ -0,0 +1,14 @@
+# Define the current source locations
+SET( CURRENT_HEADER_DIR ${CMAKE_SOURCE_DIR}/include/grabber )
+SET( CURRENT_SOURCE_DIR ${CMAKE_SOURCE_DIR}/libsrc/grabber/directx )
+
+include_directories(${DIRECTX9_INCLUDE_DIRS})
+
+FILE ( GLOB DIRECTX_GRAB_SOURCES "${CURRENT_HEADER_DIR}/DirectX*.h"  "${CURRENT_SOURCE_DIR}/*.h"  "${CURRENT_SOURCE_DIR}/*.cpp" )
+
+add_library( directx-grabber ${DIRECTX_GRAB_SOURCES} )
+
+target_link_libraries(directx-grabber
+    hyperion
+    ${DIRECTX9_LIBRARIES}
+)

libsrc/grabber/directx/DirectXGrabber.cpp

@@ -0,0 +1,181 @@
+#include <windows.h>
+#include <grabber/DirectXGrabber.h>
+#include <QImage>
+#pragma comment(lib, "d3d9.lib")
+#pragma comment(lib,"d3dx9.lib")
+
+DirectXGrabber::DirectXGrabber(int cropLeft, int cropRight, int cropTop, int cropBottom, int pixelDecimation, int display)
+	: Grabber("DXGRABBER", 0, 0, cropLeft, cropRight, cropTop, cropBottom)
+	, _pixelDecimation(pixelDecimation)
+	, _displayWidth(0)
+	, _displayHeight(0)
+	, _srcRect(0)
+	, _d3d9(nullptr)
+	, _device(nullptr)
+	, _surface(nullptr)
+{
+	// init
+	setupDisplay();
+}
+
+DirectXGrabber::~DirectXGrabber()
+{
+	freeResources();
+}
+
+void DirectXGrabber::freeResources()
+{
+	if (_surface)
+		_surface->Release();
+
+	if (_device)
+		_device->Release();
+
+	if (_d3d9)
+		_d3d9->Release();
+
+	delete _srcRect;
+}
+
+bool DirectXGrabber::setupDisplay()
+{
+	freeResources();
+
+	D3DDISPLAYMODE ddm;
+	D3DPRESENT_PARAMETERS d3dpp;
+
+	if ((_d3d9 = Direct3DCreate9(D3D_SDK_VERSION)) == nullptr)
+	{
+		Error(_log, "Failed to create Direct3D");
+		return false;
+	}
+
+	if (FAILED(_d3d9->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &ddm)))
+	{
+		Error(_log, "Failed to get current display mode");
+		return false;
+	}
+
+	SecureZeroMemory(&d3dpp, sizeof(D3DPRESENT_PARAMETERS));
+
+	d3dpp.Windowed = TRUE;
+	d3dpp.Flags = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
+	d3dpp.BackBufferFormat = ddm.Format;
+	d3dpp.BackBufferHeight = _displayHeight = ddm.Height;
+	d3dpp.BackBufferWidth = _displayWidth = ddm.Width;
+	d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
+	d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
+	d3dpp.hDeviceWindow = nullptr;
+	d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
+	d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
+
+	if (FAILED(_d3d9->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, nullptr, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &_device)))
+	{
+		Error(_log, "CreateDevice failed");
+		return false;
+	}
+
+	if (FAILED(_device->CreateOffscreenPlainSurface(ddm.Width, ddm.Height, D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &_surface, nullptr)))
+	{
+		Error(_log, "CreateOffscreenPlainSurface failed");
+		return false;
+	}
+
+	int width = _displayWidth / _pixelDecimation;
+	int height =_displayHeight / _pixelDecimation;
+
+	// calculate final image dimensions and adjust top/left cropping in 3D modes
+	_srcRect = new RECT;
+	switch (_videoMode)
+	{
+		case VideoMode::VIDEO_3DSBS:
+			_width         = width / 2;
+			_height        = height;
+			_srcRect->left = _cropLeft * _pixelDecimation / 2;
+			_srcRect->top  = _cropTop * _pixelDecimation;
+			_srcRect->right = (_displayWidth / 2) - (_cropRight * _pixelDecimation);
+			_srcRect->bottom = _displayHeight - (_cropBottom * _pixelDecimation);
+			break;
+		case VideoMode::VIDEO_3DTAB:
+			_width  = width;
+			_height = height / 2;
+			_srcRect->left = _cropLeft * _pixelDecimation;
+			_srcRect->top  = (_cropTop * _pixelDecimation) / 2;
+			_srcRect->right = _displayWidth - (_cropRight * _pixelDecimation);
+			_srcRect->bottom = (_displayHeight / 2) - (_cropBottom * _pixelDecimation);
+			break;
+		case VideoMode::VIDEO_2D:
+		default:
+			_width  = width;
+			_height = height;
+			_srcRect->left = _cropLeft * _pixelDecimation;
+			_srcRect->top  = _cropTop * _pixelDecimation;
+			_srcRect->right = _displayWidth - _cropRight * _pixelDecimation;
+			_srcRect->bottom = _displayHeight - _cropBottom * _pixelDecimation;
+			break;
+	}
+
+	if (FAILED(_device->CreateOffscreenPlainSurface(_width, _height, D3DFMT_R8G8B8, D3DPOOL_SCRATCH, &_surfaceDest, nullptr)))
+	{
+		Error(_log, "CreateOffscreenPlainSurface failed");
+		return false;
+	}
+
+	Info(_log, "Update output image resolution to [%dx%d]", _width, _height);
+	return true;
+}
+
+int DirectXGrabber::grabFrame(Image<ColorRgb> & image)
+{
+	if (!_enabled)
+		return 0;
+
+	if (FAILED(_device->GetFrontBufferData(0, _surface)))
+	{
+		// reinit, this will disable capture on failure
+		Error(_log, "Unable to get Buffer Surface Data");
+		setEnabled(setupDisplay());
+		return -1;
+	}
+
+	D3DXLoadSurfaceFromSurface(_surfaceDest, nullptr, nullptr, _surface, nullptr, _srcRect, D3DX_DEFAULT, 0);
+
+	D3DLOCKED_RECT lockedRect;
+	if (FAILED(_surfaceDest->LockRect(&lockedRect, nullptr, D3DLOCK_NO_DIRTY_UPDATE | D3DLOCK_NOSYSLOCK | D3DLOCK_READONLY)))
+	{
+		Error(_log, "Unable to lock destination Front Buffer Surface");
+		return 0;
+	}
+
+	memcpy(image.memptr(), lockedRect.pBits, _width * _height * 3);
+	for (int idx = 0; idx < _width * _height; idx++)
+	{
+		const ColorRgb & color = image.memptr()[idx];
+		image.memptr()[idx] = ColorRgb{color.blue, color.green, color.red};
+	}
+
+	if (FAILED(_surfaceDest->UnlockRect()))
+	{
+		Error(_log, "Unable to unlock destination Front Buffer Surface");
+		return 0;
+	}
+
+	return 0;
+}
+
+void DirectXGrabber::setVideoMode(VideoMode mode)
+{
+	Grabber::setVideoMode(mode);
+	setupDisplay();
+}
+
+void DirectXGrabber::setPixelDecimation(int pixelDecimation)
+{
+	_pixelDecimation = pixelDecimation;
+}
+
+void DirectXGrabber::setCropping(unsigned cropLeft, unsigned cropRight, unsigned cropTop, unsigned cropBottom)
+{
+	Grabber::setCropping(cropLeft, cropRight, cropTop, cropBottom);
+	setupDisplay();
+}

libsrc/grabber/directx/DirectXWrapper.cpp

@@ -0,0 +1,11 @@
+#include <grabber/DirectXWrapper.h>
+
+DirectXWrapper::DirectXWrapper(int cropLeft, int cropRight, int cropTop, int cropBottom, int pixelDecimation, int display, const unsigned updateRate_Hz)
+	: GrabberWrapper("DirectX", &_grabber, 0, 0, updateRate_Hz)
+	, _grabber(cropLeft, cropRight, cropTop, cropBottom, pixelDecimation, display)
+{}
+
+void DirectXWrapper::action()
+{
+	transferFrame(_grabber);
+}