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>
402 lines
11 KiB
C++
402 lines
11 KiB
C++
#pragma once
|
|
|
|
#include <mfapi.h>
|
|
#include <mftransform.h>
|
|
#include <dmo.h>
|
|
#include <wmcodecdsp.h>
|
|
#include <mfidl.h>
|
|
#include <mfreadwrite.h>
|
|
#include <shlwapi.h>
|
|
#include <mferror.h>
|
|
#include <strmif.h>
|
|
#include <comdef.h>
|
|
|
|
#pragma comment (lib, "ole32.lib")
|
|
#pragma comment (lib, "mf.lib")
|
|
#pragma comment (lib, "mfplat.lib")
|
|
#pragma comment (lib, "mfuuid.lib")
|
|
#pragma comment (lib, "mfreadwrite.lib")
|
|
#pragma comment (lib, "strmiids.lib")
|
|
#pragma comment (lib, "wmcodecdspuuid.lib")
|
|
|
|
#include <grabber/MFGrabber.h>
|
|
|
|
#define SAFE_RELEASE(x) if(x) { x->Release(); x = nullptr; }
|
|
|
|
// Need more supported formats? Visit https://docs.microsoft.com/en-us/windows/win32/medfound/colorconverter
|
|
static PixelFormat GetPixelFormatForGuid(const GUID guid)
|
|
{
|
|
if (IsEqualGUID(guid, MFVideoFormat_RGB32)) return PixelFormat::RGB32;
|
|
if (IsEqualGUID(guid, MFVideoFormat_RGB24)) return PixelFormat::BGR24;
|
|
if (IsEqualGUID(guid, MFVideoFormat_YUY2)) return PixelFormat::YUYV;
|
|
if (IsEqualGUID(guid, MFVideoFormat_UYVY)) return PixelFormat::UYVY;
|
|
if (IsEqualGUID(guid, MFVideoFormat_MJPG)) return PixelFormat::MJPEG;
|
|
if (IsEqualGUID(guid, MFVideoFormat_NV12)) return PixelFormat::NV12;
|
|
if (IsEqualGUID(guid, MFVideoFormat_I420)) return PixelFormat::I420;
|
|
return PixelFormat::NO_CHANGE;
|
|
};
|
|
|
|
class SourceReaderCB : public IMFSourceReaderCallback
|
|
{
|
|
public:
|
|
SourceReaderCB(MFGrabber* grabber)
|
|
: _nRefCount(1)
|
|
, _grabber(grabber)
|
|
, _bEOS(FALSE)
|
|
, _hrStatus(S_OK)
|
|
, _isBusy(false)
|
|
, _transform(nullptr)
|
|
, _pixelformat(PixelFormat::NO_CHANGE)
|
|
{
|
|
// Initialize critical section.
|
|
InitializeCriticalSection(&_critsec);
|
|
}
|
|
|
|
// IUnknown methods
|
|
STDMETHODIMP QueryInterface(REFIID iid, void** ppv)
|
|
{
|
|
static const QITAB qit[] =
|
|
{
|
|
QITABENT(SourceReaderCB, IMFSourceReaderCallback),
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, iid, ppv);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) AddRef()
|
|
{
|
|
return InterlockedIncrement(&_nRefCount);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) Release()
|
|
{
|
|
ULONG uCount = InterlockedDecrement(&_nRefCount);
|
|
if (uCount == 0)
|
|
{
|
|
delete this;
|
|
}
|
|
return uCount;
|
|
}
|
|
|
|
// IMFSourceReaderCallback methods
|
|
STDMETHODIMP OnReadSample(HRESULT hrStatus, DWORD /*dwStreamIndex*/,
|
|
DWORD dwStreamFlags, LONGLONG llTimestamp, IMFSample* pSample)
|
|
{
|
|
EnterCriticalSection(&_critsec);
|
|
_isBusy = true;
|
|
|
|
if (_grabber->_sourceReader == nullptr)
|
|
{
|
|
_isBusy = false;
|
|
LeaveCriticalSection(&_critsec);
|
|
return S_OK;
|
|
}
|
|
|
|
if (dwStreamFlags & MF_SOURCE_READERF_STREAMTICK)
|
|
{
|
|
Debug(_grabber->_log, "Skipping stream gap");
|
|
LeaveCriticalSection(&_critsec);
|
|
_grabber->_sourceReader->ReadSample(MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0, nullptr, nullptr, nullptr, nullptr);
|
|
return S_OK;
|
|
}
|
|
|
|
if (dwStreamFlags & MF_SOURCE_READERF_NATIVEMEDIATYPECHANGED)
|
|
{
|
|
IMFMediaType* type = nullptr;
|
|
GUID format;
|
|
_grabber->_sourceReader->GetNativeMediaType(MF_SOURCE_READER_FIRST_VIDEO_STREAM, MF_SOURCE_READER_CURRENT_TYPE_INDEX, &type);
|
|
type->GetGUID(MF_MT_SUBTYPE, &format);
|
|
Debug(_grabber->_log, "Native media type changed");
|
|
InitializeVideoEncoder(type, GetPixelFormatForGuid(format));
|
|
SAFE_RELEASE(type);
|
|
}
|
|
|
|
if (dwStreamFlags & MF_SOURCE_READERF_CURRENTMEDIATYPECHANGED)
|
|
{
|
|
IMFMediaType* type = nullptr;
|
|
GUID format;
|
|
_grabber->_sourceReader->GetCurrentMediaType(MF_SOURCE_READER_FIRST_VIDEO_STREAM, &type);
|
|
type->GetGUID(MF_MT_SUBTYPE, &format);
|
|
Debug(_grabber->_log, "Current media type changed");
|
|
InitializeVideoEncoder(type, GetPixelFormatForGuid(format));
|
|
SAFE_RELEASE(type);
|
|
}
|
|
|
|
// Variables declaration
|
|
IMFMediaBuffer* buffer = nullptr;
|
|
|
|
if (FAILED(hrStatus))
|
|
{
|
|
_hrStatus = hrStatus;
|
|
_com_error error(_hrStatus);
|
|
Error(_grabber->_log, "%s", error.ErrorMessage());
|
|
goto done;
|
|
}
|
|
|
|
if (!pSample)
|
|
{
|
|
Error(_grabber->_log, "Media sample is empty");
|
|
goto done;
|
|
}
|
|
|
|
if (_pixelformat != PixelFormat::MJPEG && _pixelformat != PixelFormat::BGR24 && _pixelformat != PixelFormat::NO_CHANGE)
|
|
pSample = TransformSample(_transform, pSample);
|
|
|
|
_hrStatus = pSample->ConvertToContiguousBuffer(&buffer);
|
|
if (FAILED(_hrStatus))
|
|
{
|
|
_com_error error(_hrStatus);
|
|
Error(_grabber->_log, "Buffer conversion failed => %s", error.ErrorMessage());
|
|
goto done;
|
|
}
|
|
|
|
BYTE* data = nullptr;
|
|
DWORD maxLength = 0, currentLength = 0;
|
|
_hrStatus = buffer->Lock(&data, &maxLength, ¤tLength);
|
|
if (FAILED(_hrStatus))
|
|
{
|
|
_com_error error(_hrStatus);
|
|
Error(_grabber->_log, "Access to the buffer memory failed => %s", error.ErrorMessage());
|
|
goto done;
|
|
}
|
|
|
|
_grabber->receive_image(data, currentLength);
|
|
|
|
_hrStatus = buffer->Unlock();
|
|
if (FAILED(_hrStatus))
|
|
{
|
|
_com_error error(_hrStatus);
|
|
Error(_grabber->_log, "Unlocking the buffer memory failed => %s", error.ErrorMessage());
|
|
}
|
|
|
|
done:
|
|
SAFE_RELEASE(buffer);
|
|
|
|
if (MF_SOURCE_READERF_ENDOFSTREAM & dwStreamFlags)
|
|
_bEOS = TRUE; // Reached the end of the stream.
|
|
|
|
if (_pixelformat != PixelFormat::MJPEG && _pixelformat != PixelFormat::BGR24 && _pixelformat != PixelFormat::NO_CHANGE)
|
|
SAFE_RELEASE(pSample);
|
|
|
|
_isBusy = false;
|
|
LeaveCriticalSection(&_critsec);
|
|
return _hrStatus;
|
|
}
|
|
|
|
HRESULT SourceReaderCB::InitializeVideoEncoder(IMFMediaType* type, PixelFormat format)
|
|
{
|
|
_pixelformat = format;
|
|
if (format == PixelFormat::MJPEG || format == PixelFormat::BGR24 || format == PixelFormat::NO_CHANGE)
|
|
return S_OK;
|
|
|
|
// Variable declaration
|
|
IMFMediaType* output = nullptr;
|
|
DWORD mftStatus = 0;
|
|
QString error = "";
|
|
|
|
// Create instance of IMFTransform interface pointer as CColorConvertDMO
|
|
_hrStatus = CoCreateInstance(CLSID_CColorConvertDMO, nullptr, CLSCTX_INPROC_SERVER, IID_IMFTransform, (void**)&_transform);
|
|
if (FAILED(_hrStatus))
|
|
{
|
|
_com_error error(_hrStatus);
|
|
Error(_grabber->_log, "Creation of the Color Converter failed => %s", error.ErrorMessage());
|
|
goto done;
|
|
}
|
|
|
|
// Set input type as media type of our input stream
|
|
_hrStatus = _transform->SetInputType(0, type, 0);
|
|
if (FAILED(_hrStatus))
|
|
{
|
|
_com_error error(_hrStatus);
|
|
Error(_grabber->_log, "Setting the input media type failed => %s", error.ErrorMessage());
|
|
goto done;
|
|
}
|
|
|
|
// Create new media type
|
|
_hrStatus = MFCreateMediaType(&output);
|
|
if (FAILED(_hrStatus))
|
|
{
|
|
_com_error error(_hrStatus);
|
|
Error(_grabber->_log, "Creating a new media type failed => %s", error.ErrorMessage());
|
|
goto done;
|
|
}
|
|
|
|
// Copy all attributes from input type to output media type
|
|
_hrStatus = type->CopyAllItems(output);
|
|
if (FAILED(_hrStatus))
|
|
{
|
|
_com_error error(_hrStatus);
|
|
Error(_grabber->_log, "Copying of all attributes from input to output media type failed => %s", error.ErrorMessage());
|
|
goto done;
|
|
}
|
|
|
|
UINT32 width, height;
|
|
UINT32 numerator, denominator;
|
|
|
|
// Fill the missing attributes
|
|
|
|
if (FAILED(output->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video)) ||
|
|
FAILED(output->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_RGB24)) ||
|
|
FAILED(output->SetUINT32(MF_MT_FIXED_SIZE_SAMPLES, TRUE)) ||
|
|
FAILED(output->SetUINT32(MF_MT_ALL_SAMPLES_INDEPENDENT, TRUE)) ||
|
|
FAILED(output->SetUINT32(MF_MT_INTERLACE_MODE, MFVideoInterlace_Progressive)) ||
|
|
FAILED(MFGetAttributeSize(type, MF_MT_FRAME_SIZE, &width, &height)) ||
|
|
FAILED(MFSetAttributeSize(output, MF_MT_FRAME_SIZE, width, height)) ||
|
|
FAILED(MFGetAttributeRatio(type, MF_MT_FRAME_RATE, &numerator, &denominator)) ||
|
|
FAILED(MFSetAttributeRatio(output, MF_MT_PIXEL_ASPECT_RATIO, 1, 1)))
|
|
{
|
|
Error(_grabber->_log, "Setting output media type attributes failed");
|
|
goto done;
|
|
}
|
|
|
|
// Set transform output type
|
|
_hrStatus = _transform->SetOutputType(0, output, 0);
|
|
if (FAILED(_hrStatus))
|
|
{
|
|
_com_error error(_hrStatus);
|
|
Error(_grabber->_log, "Setting the output media type failed => %s", error.ErrorMessage());
|
|
goto done;
|
|
}
|
|
|
|
// Check if encoder parameters set properly
|
|
_hrStatus = _transform->GetInputStatus(0, &mftStatus);
|
|
if (FAILED(_hrStatus))
|
|
{
|
|
_com_error error(_hrStatus);
|
|
Error(_grabber->_log, "Failed to query the input stream for more data => %s", error.ErrorMessage());
|
|
goto done;
|
|
}
|
|
|
|
if (MFT_INPUT_STATUS_ACCEPT_DATA == mftStatus)
|
|
{
|
|
// Notify the transform we are about to begin streaming data
|
|
if (FAILED(_transform->ProcessMessage(MFT_MESSAGE_COMMAND_FLUSH, 0)) ||
|
|
FAILED(_transform->ProcessMessage(MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, 0)) ||
|
|
FAILED(_transform->ProcessMessage(MFT_MESSAGE_NOTIFY_START_OF_STREAM, 0)))
|
|
{
|
|
Error(_grabber->_log, "Failed to begin streaming data");
|
|
}
|
|
}
|
|
|
|
done:
|
|
SAFE_RELEASE(output);
|
|
return _hrStatus;
|
|
}
|
|
|
|
BOOL SourceReaderCB::isBusy()
|
|
{
|
|
EnterCriticalSection(&_critsec);
|
|
BOOL result = _isBusy;
|
|
LeaveCriticalSection(&_critsec);
|
|
|
|
return result;
|
|
}
|
|
|
|
STDMETHODIMP OnEvent(DWORD, IMFMediaEvent*) { return S_OK; }
|
|
STDMETHODIMP OnFlush(DWORD) { return S_OK; }
|
|
|
|
private:
|
|
virtual ~SourceReaderCB()
|
|
{
|
|
if (_transform)
|
|
{
|
|
_transform->ProcessMessage(MFT_MESSAGE_NOTIFY_END_OF_STREAM, 0);
|
|
_transform->ProcessMessage(MFT_MESSAGE_NOTIFY_END_STREAMING, 0);
|
|
}
|
|
|
|
SAFE_RELEASE(_transform);
|
|
|
|
// Delete critical section.
|
|
DeleteCriticalSection(&_critsec);
|
|
}
|
|
|
|
IMFSample* SourceReaderCB::TransformSample(IMFTransform* transform, IMFSample* in_sample)
|
|
{
|
|
IMFSample* result = nullptr;
|
|
IMFMediaBuffer* out_buffer = nullptr;
|
|
MFT_OUTPUT_DATA_BUFFER outputDataBuffer = { 0 };
|
|
|
|
// Process the input sample
|
|
_hrStatus = transform->ProcessInput(0, in_sample, 0);
|
|
if (FAILED(_hrStatus))
|
|
{
|
|
_com_error error(_hrStatus);
|
|
Error(_grabber->_log, "Failed to process the input sample => %s", error.ErrorMessage());
|
|
goto done;
|
|
}
|
|
|
|
// Gets the buffer demand for the output stream
|
|
MFT_OUTPUT_STREAM_INFO streamInfo;
|
|
_hrStatus = transform->GetOutputStreamInfo(0, &streamInfo);
|
|
if (FAILED(_hrStatus))
|
|
{
|
|
_com_error error(_hrStatus);
|
|
Error(_grabber->_log, "Failed to retrieve buffer requirement for output current => %s", error.ErrorMessage());
|
|
goto done;
|
|
}
|
|
|
|
// Create an output media buffer
|
|
_hrStatus = MFCreateMemoryBuffer(streamInfo.cbSize, &out_buffer);
|
|
if (FAILED(_hrStatus))
|
|
{
|
|
_com_error error(_hrStatus);
|
|
Error(_grabber->_log, "Failed to create an output media buffer => %s", error.ErrorMessage());
|
|
goto done;
|
|
}
|
|
|
|
// Create an empty media sample
|
|
_hrStatus = MFCreateSample(&result);
|
|
if (FAILED(_hrStatus))
|
|
{
|
|
_com_error error(_hrStatus);
|
|
Error(_grabber->_log, "Failed to create an empty media sample => %s", error.ErrorMessage());
|
|
goto done;
|
|
}
|
|
|
|
// Add the output media buffer to the media sample
|
|
_hrStatus = result->AddBuffer(out_buffer);
|
|
if (FAILED(_hrStatus))
|
|
{
|
|
_com_error error(_hrStatus);
|
|
Error(_grabber->_log, "Failed to add the output media buffer to the media sample => %s", error.ErrorMessage());
|
|
goto done;
|
|
}
|
|
|
|
// Create the output buffer structure
|
|
memset(&outputDataBuffer, 0, sizeof outputDataBuffer);
|
|
outputDataBuffer.dwStreamID = 0;
|
|
outputDataBuffer.dwStatus = 0;
|
|
outputDataBuffer.pEvents = nullptr;
|
|
outputDataBuffer.pSample = result;
|
|
|
|
DWORD status = 0;
|
|
|
|
// Generate the output sample
|
|
_hrStatus = transform->ProcessOutput(0, 1, &outputDataBuffer, &status);
|
|
if (FAILED(_hrStatus))
|
|
{
|
|
_com_error error(_hrStatus);
|
|
Error(_grabber->_log, "Failed to generate the output sample => %s", error.ErrorMessage());
|
|
}
|
|
else
|
|
{
|
|
SAFE_RELEASE(out_buffer);
|
|
return result;
|
|
}
|
|
|
|
done:
|
|
SAFE_RELEASE(out_buffer);
|
|
return nullptr;
|
|
}
|
|
|
|
private:
|
|
long _nRefCount;
|
|
CRITICAL_SECTION _critsec;
|
|
MFGrabber* _grabber;
|
|
BOOL _bEOS;
|
|
HRESULT _hrStatus;
|
|
IMFTransform* _transform;
|
|
PixelFormat _pixelformat;
|
|
std::atomic<bool> _isBusy;
|
|
};
|