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>
228 lines
6.4 KiB
C++
228 lines
6.4 KiB
C++
#include <hyperion/HyperionIManager.h>
|
|
|
|
// hyperion
|
|
#include <hyperion/Hyperion.h>
|
|
#include <db/InstanceTable.h>
|
|
|
|
// qt
|
|
#include <QThread>
|
|
|
|
HyperionIManager* HyperionIManager::HIMinstance;
|
|
|
|
HyperionIManager::HyperionIManager(const QString& rootPath, QObject* parent, bool readonlyMode)
|
|
: QObject(parent)
|
|
, _log(Logger::getInstance("HYPERION"))
|
|
, _instanceTable( new InstanceTable(rootPath, this, readonlyMode) )
|
|
, _rootPath( rootPath )
|
|
, _readonlyMode(readonlyMode)
|
|
{
|
|
HIMinstance = this;
|
|
qRegisterMetaType<InstanceState>("InstanceState");
|
|
}
|
|
|
|
Hyperion* HyperionIManager::getHyperionInstance(quint8 instance)
|
|
{
|
|
if(_runningInstances.contains(instance))
|
|
return _runningInstances.value(instance);
|
|
|
|
Warning(_log,"The requested instance index '%d' with name '%s' isn't running, return main instance", instance, QSTRING_CSTR(_instanceTable->getNamebyIndex(instance)));
|
|
return _runningInstances.value(0);
|
|
}
|
|
|
|
QVector<QVariantMap> HyperionIManager::getInstanceData() const
|
|
{
|
|
QVector<QVariantMap> instances = _instanceTable->getAllInstances();
|
|
for( auto & entry : instances)
|
|
{
|
|
// add running state
|
|
entry["running"] = _runningInstances.contains(entry["instance"].toInt());
|
|
}
|
|
return instances;
|
|
}
|
|
|
|
void HyperionIManager::startAll()
|
|
{
|
|
for(const auto & entry : _instanceTable->getAllInstances(true))
|
|
{
|
|
startInstance(entry["instance"].toInt());
|
|
}
|
|
}
|
|
|
|
void HyperionIManager::stopAll()
|
|
{
|
|
// copy the instances due to loop corruption, even with .erase() return next iter
|
|
QMap<quint8, Hyperion*> instCopy = _runningInstances;
|
|
for(const auto instance : instCopy)
|
|
{
|
|
instance->stop();
|
|
}
|
|
}
|
|
|
|
void HyperionIManager::toggleStateAllInstances(bool pause)
|
|
{
|
|
// copy the instances due to loop corruption, even with .erase() return next iter
|
|
QMap<quint8, Hyperion*> instCopy = _runningInstances;
|
|
for(const auto instance : instCopy)
|
|
{
|
|
emit instance->compStateChangeRequest(hyperion::COMP_ALL, pause);
|
|
}
|
|
}
|
|
|
|
bool HyperionIManager::startInstance(quint8 inst, bool block, QObject* caller, int tan)
|
|
{
|
|
if(_instanceTable->instanceExist(inst))
|
|
{
|
|
if(!_runningInstances.contains(inst) && !_startQueue.contains(inst))
|
|
{
|
|
QThread* hyperionThread = new QThread();
|
|
hyperionThread->setObjectName("HyperionThread");
|
|
Hyperion* hyperion = new Hyperion(inst, _readonlyMode);
|
|
hyperion->moveToThread(hyperionThread);
|
|
// setup thread management
|
|
connect(hyperionThread, &QThread::started, hyperion, &Hyperion::start);
|
|
connect(hyperion, &Hyperion::started, this, &HyperionIManager::handleStarted);
|
|
connect(hyperion, &Hyperion::finished, this, &HyperionIManager::handleFinished);
|
|
connect(hyperion, &Hyperion::finished, hyperionThread, &QThread::quit, Qt::DirectConnection);
|
|
|
|
// setup further connections
|
|
// from Hyperion
|
|
connect(hyperion, &Hyperion::settingsChanged, this, &HyperionIManager::settingsChanged);
|
|
connect(hyperion, &Hyperion::videoMode, this, &HyperionIManager::requestVideoMode);
|
|
// to Hyperion
|
|
connect(this, &HyperionIManager::newVideoMode, hyperion, &Hyperion::newVideoMode);
|
|
|
|
// add to queue and start
|
|
_startQueue << inst;
|
|
hyperionThread->start();
|
|
|
|
// update db
|
|
_instanceTable->setLastUse(inst);
|
|
_instanceTable->setEnable(inst, true);
|
|
|
|
if(block)
|
|
{
|
|
while(!hyperionThread->isRunning()){};
|
|
}
|
|
|
|
if (!_pendingRequests.contains(inst) && caller != nullptr)
|
|
{
|
|
PendingRequests newDef{caller, tan};
|
|
_pendingRequests[inst] = newDef;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
Debug(_log,"Can't start Hyperion instance index '%d' with name '%s' it's already running or queued for start", inst, QSTRING_CSTR(_instanceTable->getNamebyIndex(inst)));
|
|
return false;
|
|
}
|
|
Debug(_log,"Can't start Hyperion instance index '%d' it doesn't exist in DB", inst);
|
|
return false;
|
|
}
|
|
|
|
bool HyperionIManager::stopInstance(quint8 inst)
|
|
{
|
|
// inst 0 can't be stopped
|
|
if(!isInstAllowed(inst))
|
|
return false;
|
|
|
|
if(_instanceTable->instanceExist(inst))
|
|
{
|
|
if(_runningInstances.contains(inst))
|
|
{
|
|
// notify a ON_STOP rather sooner than later, queued signal listener should have some time to drop the pointer before it's deleted
|
|
emit instanceStateChanged(InstanceState::H_ON_STOP, inst);
|
|
Hyperion* hyperion = _runningInstances.value(inst);
|
|
hyperion->stop();
|
|
|
|
// update db
|
|
_instanceTable->setEnable(inst, false);
|
|
|
|
return true;
|
|
}
|
|
Debug(_log,"Can't stop Hyperion instance index '%d' with name '%s' it's not running'", inst, QSTRING_CSTR(_instanceTable->getNamebyIndex(inst)));
|
|
return false;
|
|
}
|
|
Debug(_log,"Can't stop Hyperion instance index '%d' it doesn't exist in DB", inst);
|
|
return false;
|
|
}
|
|
|
|
bool HyperionIManager::createInstance(const QString& name, bool start)
|
|
{
|
|
quint8 inst;
|
|
if(_instanceTable->createInstance(name, inst))
|
|
{
|
|
Info(_log,"New Hyperion instance created with name '%s'",QSTRING_CSTR(name));
|
|
emit instanceStateChanged(InstanceState::H_CREATED, inst, name);
|
|
emit change();
|
|
|
|
if(start)
|
|
startInstance(inst);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool HyperionIManager::deleteInstance(quint8 inst)
|
|
{
|
|
// inst 0 can't be deleted
|
|
if(!isInstAllowed(inst))
|
|
return false;
|
|
|
|
// stop it if required as blocking and wait
|
|
stopInstance(inst);
|
|
|
|
if(_instanceTable->deleteInstance(inst))
|
|
{
|
|
Info(_log,"Hyperion instance with index '%d' has been deleted", inst);
|
|
emit instanceStateChanged(InstanceState::H_DELETED, inst);
|
|
emit change();
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool HyperionIManager::saveName(quint8 inst, const QString& name)
|
|
{
|
|
if(_instanceTable->saveName(inst, name))
|
|
{
|
|
emit change();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void HyperionIManager::handleFinished()
|
|
{
|
|
Hyperion* hyperion = qobject_cast<Hyperion*>(sender());
|
|
quint8 instance = hyperion->getInstanceIndex();
|
|
|
|
Info(_log,"Hyperion instance '%s' has been stopped", QSTRING_CSTR(_instanceTable->getNamebyIndex(instance)));
|
|
|
|
_runningInstances.remove(instance);
|
|
hyperion->thread()->deleteLater();
|
|
hyperion->deleteLater();
|
|
emit instanceStateChanged(InstanceState::H_STOPPED, instance);
|
|
emit change();
|
|
}
|
|
|
|
void HyperionIManager::handleStarted()
|
|
{
|
|
Hyperion* hyperion = qobject_cast<Hyperion*>(sender());
|
|
quint8 instance = hyperion->getInstanceIndex();
|
|
|
|
Info(_log,"Hyperion instance '%s' has been started", QSTRING_CSTR(_instanceTable->getNamebyIndex(instance)));
|
|
|
|
_startQueue.removeAll(instance);
|
|
_runningInstances.insert(instance, hyperion);
|
|
emit instanceStateChanged(InstanceState::H_STARTED, instance);
|
|
emit change();
|
|
|
|
if (_pendingRequests.contains(instance))
|
|
{
|
|
PendingRequests def = _pendingRequests.take(instance);
|
|
emit startInstanceResponse(def.caller, def.tan);
|
|
_pendingRequests.remove(instance);
|
|
}
|
|
}
|