mirror of
https://github.com/hyperion-project/hyperion.ng.git
synced 2023-10-10 13:36:59 +02:00
* - New Media Foundation grabber
- JsonAPI available grabber fix
- commented json config removed
* Added libjpeg-turbo to dependencies
* Fix OSX build
Removed Azure Pipelines from build scripts
* Remove Platform from Dashboard
* Correct Grabber Namings
* Grabber UI improvements, generic JSONEditor Selection Update
* Active grabber fix
* Stop Framebuffer grabber on failure
* - Image format NV12 and I420 added
- Flip mode
- Scaling factor for MJPEG
- VSCode (compile before run)
- CI (push) dependency libjpeg-turbo added
* Refactor MediaFoundation (Part 1)
* Remove QDebug output
* Added image flipping ability to MF Grabber
* fix issue 1160
* -Reload MF Grabber only once per WebUI update
- Cleanup
* Improvements
* - Set 'Software Frame Decimation' begin to 0
- Removed grabber specific device name from Log
- Keep pixel format when switching resolution
- Display 'Flip mode' correct in Log
- BGR24 images always flipped
* Refactor MediaFoundation (Part 2)
* Refactor V4L2 grabber (part 1) (#62)
* Media Foundation grabber adapted to V4L2 change
* Enable Media Foundation grabber on windows
* Have fps as int, fix height typo
* Added video standards to JsonAPI output
* Error handling in source reader improved
* Fix "Frame to small" error
* Discovery VideoSources and Dynamically Update Editor
* Hide all element when no video grabber discovered, upate naming
* Do not show unsupported grabbers
* Copy Log to Clipboard
* Update Grabber schema and Defaults
* Update access levels and validate crop ranges
* Height and width in Qt grabber corrected
* Correct formatting
* Untabify
* Global component states across instances
* Components divided on the dashboard
* refactor
* Fix Merge-issues
* Database migration aligning with updated grabber model
* Align Grabber.js with new utility functions
* Allow editor-validation for enum-lists
* Handle "Show Explainations scenario" correctly
* Grabber - Ensure save is only possible on valid content
* Dashboard update + fix GlobalSignal connection
* Ensure default database is populated with current release
* Correct grabber4L2 access level
* Display Signal detection area in preview
* Write Hyperion version into default config on compiling.
* Create defaultconfig.json dynamically
* WebUI changes
* Correct grabber config look-ups
* Refactor i18n language loading
* Fix en.json
* Split global capture from instance capture config
* Update grabber default values
* Standalone grabber: Add --debug switch
* Enhance showInputOptionsForKey for multiple keys
* Add grabber instance link to system grabber config
* Only show signal detection area, if grabber is enabled
* Always show Active element on grabber page
* Remote control - Only display gabber status, if global grabber is enabled
* WebUI optimization (thx to @mkcologne)
Start Grabber only when global settings are enabled
Fixed an issue in the WebUI preview
* V4L2/MF changes
* Jsoneditor, Correct translation for default values
* Refactor LED-Device handling in UI and make element naming consistent
* MF Discovery extended
* Fix LGTM finding
* Support Grabber Bri, Hue, Sat and Con in UI, plus their defaults
* Concider Access level for item filtering
* Concider Access level for item filtering
* Revert "Concider Access level for item filtering"
This reverts commit 5b0ce3c0f2
.
* Disable fpsSoftwareDecimation for framegrabber, as not supported yet
* JSON-Editor- Add updated schema for validation on dynamic elements
* added V4L2 color IDs
* LGTM findings fix
* destroy SR callback only on exit
* Grabber.js - Hide elements not supported by platform
* Fixed freezing start effect
* Grabber UI - Hardware controls - Show current values and allow to reset to defaults
* Grabber - Discovery - Add current values to properties
* Small things
* Clean-up Effects and have ENDLESS consistently defined
* Fix on/off/on priority during startup, by initializing _prevVisComp in line with background priority
* Add missing translation mappings
* DirectX Grabber reactivated/ QT Grabber size decimation fixed
* typo in push-master workflow
* Use PreciseTimer for Grabber to ensure stable FPS timing
* Set default Screencapture rate consistently
* Fix libjpeg-turbo download
* Remove Zero character from file
* docker-compile Add PLATFORM parameter, only copy output file after successful compile
* Framebuffer, Dispmanx, OSX, AML Grabber discovery, various clean-up and consistencies across grabbers
* Fix merge problem - on docker-compile Add PLATFORM parameter, only copy output file after successful compile
* Fix definition
* OSXFRameGrabber - Revert cast
* Clean-ups nach Feedback
* Disable certain libraries when building armlogic via standard stretch image as developer
* Add CEC availability to ServerInfo to have it platform independent
* Grabber UI - Fix problem that crop values are not populated when refining editor rage
* Preserve value when updating json-editor range
* LEDVisualisation - Clear image when source changes
* Fix - Preserve value when updating json-editor range
* LEDVisualisation - Clear image when no component is active
* Allow to have password handled by Password-Manager (#1263)
* Update default signal detection area to green assuming rainbow grabber
* LED Visualisation - Handle empty priority update
* Fix yuv420 in v4l2 grabber
* V4L2-Grabber discovery - Only report grabbers with valid video input information
* Grabber - Update static variables to have them working in release build
* LED Visualisation - ClearImage when no priorities
* LED Visualisation - Fix Logo resizing issue
* LED Visualisation - Have nearly black background and negative logo
Co-authored-by: LordGrey <lordgrey.emmel@gmail.com>
Co-authored-by: LordGrey <48840279+Lord-Grey@users.noreply.github.com>
283 lines
7.4 KiB
C++
283 lines
7.4 KiB
C++
#include <windows.h>
|
|
#include <grabber/DirectXGrabber.h>
|
|
|
|
#pragma comment(lib, "d3d9.lib")
|
|
#pragma comment(lib,"d3dx9.lib")
|
|
|
|
// Constants
|
|
namespace {
|
|
const bool verbose = true;
|
|
} //End of constants
|
|
|
|
DirectXGrabber::DirectXGrabber(int display, int cropLeft, int cropRight, int cropTop, int cropBottom)
|
|
: Grabber("DXGRABBER", cropLeft, cropRight, cropTop, cropBottom)
|
|
, _display(unsigned(display))
|
|
, _displayWidth(0)
|
|
, _displayHeight(0)
|
|
, _srcRect(0)
|
|
, _d3d9(nullptr)
|
|
, _device(nullptr)
|
|
, _surface(nullptr)
|
|
{
|
|
}
|
|
|
|
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;
|
|
HMONITOR hMonitor = nullptr;
|
|
MONITORINFO monitorInfo = { 0 };
|
|
|
|
if ((_d3d9 = Direct3DCreate9(D3D_SDK_VERSION)) == nullptr)
|
|
{
|
|
Error(_log, "Failed to create Direct3D");
|
|
return false;
|
|
}
|
|
|
|
SecureZeroMemory(&monitorInfo, sizeof(monitorInfo));
|
|
monitorInfo.cbSize = sizeof(MONITORINFO);
|
|
|
|
hMonitor = _d3d9->GetAdapterMonitor(_display);
|
|
if (hMonitor == nullptr || GetMonitorInfo(hMonitor, &monitorInfo) == FALSE)
|
|
{
|
|
Info(_log, "Specified display %d is not available. Primary display %d is used", _display, D3DADAPTER_DEFAULT);
|
|
_display = D3DADAPTER_DEFAULT;
|
|
}
|
|
|
|
if (FAILED(_d3d9->GetAdapterDisplayMode(_display, &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(_display, 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 (!_isEnabled)
|
|
{
|
|
qDebug() << "AUS";
|
|
return 0;
|
|
}
|
|
|
|
if (_device == nullptr)
|
|
{
|
|
// reinit, this will disable capture on failure
|
|
bool result = setupDisplay();
|
|
setEnabled(result);
|
|
return -1;
|
|
}
|
|
|
|
if (FAILED(_device->GetFrontBufferData(0, _surface)))
|
|
{
|
|
Error(_log, "Unable to get Buffer Surface Data");
|
|
return 0;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
for(int i=0 ; i < _height ; i++)
|
|
memcpy((unsigned char*)image.memptr() + i * _width * 3, (unsigned char*)lockedRect.pBits + i * lockedRect.Pitch, _width * 3);
|
|
|
|
for (int idx = 0; idx < _width * _height; idx++)
|
|
image.memptr()[idx] = ColorRgb{image.memptr()[idx].blue, image.memptr()[idx].green, image.memptr()[idx].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();
|
|
}
|
|
|
|
bool DirectXGrabber::setPixelDecimation(int pixelDecimation)
|
|
{
|
|
if(Grabber::setPixelDecimation(pixelDecimation))
|
|
return setupDisplay();
|
|
|
|
return false;
|
|
}
|
|
|
|
void DirectXGrabber::setCropping(int cropLeft, int cropRight, int cropTop, int cropBottom)
|
|
{
|
|
Grabber::setCropping(cropLeft, cropRight, cropTop, cropBottom);
|
|
setupDisplay();
|
|
}
|
|
|
|
bool DirectXGrabber::setDisplayIndex(int index)
|
|
{
|
|
bool rc (true);
|
|
if(_display != unsigned(index))
|
|
{
|
|
_display = unsigned(index);
|
|
rc = setupDisplay();
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
QJsonObject DirectXGrabber::discover(const QJsonObject& params)
|
|
{
|
|
DebugIf(verbose, _log, "params: [%s]", QString(QJsonDocument(params).toJson(QJsonDocument::Compact)).toUtf8().constData());
|
|
|
|
QJsonObject inputsDiscovered;
|
|
if ((_d3d9 = Direct3DCreate9(D3D_SDK_VERSION)) != nullptr)
|
|
{
|
|
int adapterCount = (int)_d3d9->GetAdapterCount();
|
|
if(adapterCount > 0)
|
|
{
|
|
inputsDiscovered["device"] = "dx";
|
|
inputsDiscovered["device_name"] = "DX";
|
|
inputsDiscovered["type"] = "screen";
|
|
|
|
QJsonArray video_inputs;
|
|
QJsonArray fps = { 1, 5, 10, 15, 20, 25, 30, 40, 50, 60 };
|
|
|
|
for(int adapter = 0; adapter < adapterCount; adapter++)
|
|
{
|
|
QJsonObject in;
|
|
in["inputIdx"] = adapter;
|
|
|
|
D3DADAPTER_IDENTIFIER9 identifier;
|
|
_d3d9->GetAdapterIdentifier(adapter, D3DENUM_WHQL_LEVEL, &identifier);
|
|
|
|
QString name = identifier.DeviceName;
|
|
int pos = name.lastIndexOf('\\');
|
|
if (pos != -1)
|
|
name = name.right(name.length()-pos-1);
|
|
|
|
in["name"] = name;
|
|
|
|
D3DDISPLAYMODE ddm;
|
|
_d3d9->GetAdapterDisplayMode(adapter, &ddm);
|
|
|
|
QJsonArray formats, resolutionArray;
|
|
QJsonObject format, resolution;
|
|
|
|
resolution["width"] = (int)ddm.Width;
|
|
resolution["height"] = (int)ddm.Height;
|
|
resolution["fps"] = fps;
|
|
|
|
resolutionArray.append(resolution);
|
|
format["resolutions"] = resolutionArray;
|
|
|
|
formats.append(format);
|
|
|
|
|
|
in["formats"] = formats;
|
|
video_inputs.append(in);
|
|
}
|
|
inputsDiscovered["video_inputs"] = video_inputs;
|
|
}
|
|
else
|
|
{
|
|
DebugIf(verbose, _log, "No displays found to capture from!");
|
|
}
|
|
}
|
|
DebugIf(verbose, _log, "device: [%s]", QString(QJsonDocument(inputsDiscovered).toJson(QJsonDocument::Compact)).toUtf8().constData());
|
|
|
|
return inputsDiscovered;
|
|
|
|
}
|