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>
334 lines
7.6 KiB
C++
334 lines
7.6 KiB
C++
// STL includes
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
#include <iostream>
|
|
|
|
// Linux includes
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
|
|
// qt
|
|
#include <QFile>
|
|
#include <QJsonObject>
|
|
#include <QJsonArray>
|
|
#include <QJsonDocument>
|
|
#include <QSize>
|
|
|
|
// Local includes
|
|
#include <utils/Logger.h>
|
|
#include <grabber/AmlogicGrabber.h>
|
|
#include "Amvideocap.h"
|
|
|
|
// Constants
|
|
namespace {
|
|
const bool verbose = false;
|
|
|
|
const char DEFAULT_FB_DEVICE[] = "/dev/fb0";
|
|
const char DEFAULT_VIDEO_DEVICE[] = "/dev/amvideo";
|
|
const char DEFAULT_CAPTURE_DEVICE[] = "/dev/amvideocap0";
|
|
|
|
const int AMVIDEOCAP_WAIT_MAX_MS = 50;
|
|
|
|
} //End of constants
|
|
|
|
AmlogicGrabber::AmlogicGrabber()
|
|
: Grabber("AMLOGICGRABBER") // Minimum required width or height is 160
|
|
, _captureDev(-1)
|
|
, _videoDev(-1)
|
|
, _lastError(0)
|
|
, _fbGrabber(DEFAULT_FB_DEVICE)
|
|
, _grabbingModeNotification(0)
|
|
{
|
|
_image_ptr = _image_bgr.memptr();
|
|
|
|
_useImageResampler = true;
|
|
}
|
|
|
|
AmlogicGrabber::~AmlogicGrabber()
|
|
{
|
|
closeDevice(_captureDev);
|
|
closeDevice(_videoDev);
|
|
}
|
|
|
|
bool AmlogicGrabber::setupScreen()
|
|
{
|
|
bool rc (false);
|
|
|
|
QSize screenSize = _fbGrabber.getScreenSize(DEFAULT_FB_DEVICE);
|
|
if ( !screenSize.isEmpty() )
|
|
{
|
|
if (setWidthHeight(screenSize.width(), screenSize.height()))
|
|
{
|
|
rc = _fbGrabber.setupScreen();
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
bool AmlogicGrabber::openDevice(int &fd, const char* dev)
|
|
{
|
|
if (fd<0)
|
|
{
|
|
fd = ::open(dev, O_RDWR);
|
|
}
|
|
return fd >= 0;
|
|
}
|
|
|
|
void AmlogicGrabber::closeDevice(int &fd)
|
|
{
|
|
if (fd >= 0)
|
|
{
|
|
::close(fd);
|
|
fd = -1;
|
|
}
|
|
}
|
|
|
|
bool AmlogicGrabber::isVideoPlaying()
|
|
{
|
|
bool rc = false;
|
|
if(QFile::exists(DEFAULT_VIDEO_DEVICE))
|
|
{
|
|
|
|
int videoDisabled = 1;
|
|
if (!openDevice(_videoDev, DEFAULT_VIDEO_DEVICE))
|
|
{
|
|
Error(_log, "Failed to open video device(%s): %d - %s", DEFAULT_VIDEO_DEVICE, errno, strerror(errno));
|
|
}
|
|
else
|
|
{
|
|
// Check the video disabled flag
|
|
if(ioctl(_videoDev, AMSTREAM_IOC_GET_VIDEO_DISABLE, &videoDisabled) < 0)
|
|
{
|
|
Error(_log, "Failed to retrieve video state from device: %d - %s", errno, strerror(errno));
|
|
closeDevice(_videoDev);
|
|
}
|
|
else
|
|
{
|
|
if ( videoDisabled == 0 )
|
|
{
|
|
rc = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
int AmlogicGrabber::grabFrame(Image<ColorRgb> & image)
|
|
{
|
|
int rc = 0;
|
|
if (_isEnabled && !_isDeviceInError)
|
|
{
|
|
// Make sure video is playing, else there is nothing to grab
|
|
if (isVideoPlaying())
|
|
{
|
|
if (_grabbingModeNotification!=1)
|
|
{
|
|
Info(_log, "Switch to VPU capture mode");
|
|
_grabbingModeNotification = 1;
|
|
_lastError = 0;
|
|
}
|
|
|
|
if (grabFrame_amvideocap(image) < 0) {
|
|
closeDevice(_captureDev);
|
|
rc = -1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (_grabbingModeNotification!=2)
|
|
{
|
|
Info( _log, "Switch to Framebuffer capture mode");
|
|
_grabbingModeNotification = 2;
|
|
_lastError = 0;
|
|
}
|
|
rc = _fbGrabber.grabFrame(image);
|
|
|
|
//usleep(50 * 1000);
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
int AmlogicGrabber::grabFrame_amvideocap(Image<ColorRgb> & image)
|
|
{
|
|
int rc = 0;
|
|
|
|
// If the device is not open, attempt to open it
|
|
if (_captureDev < 0)
|
|
{
|
|
if (! openDevice(_captureDev, DEFAULT_CAPTURE_DEVICE))
|
|
{
|
|
ErrorIf( _lastError != 1, _log,"Failed to open the AMLOGIC device (%d - %s):", errno, strerror(errno));
|
|
_lastError = 1;
|
|
rc = -1;
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
long r1 = ioctl(_captureDev, AMVIDEOCAP_IOW_SET_WANTFRAME_WIDTH, _width);
|
|
long r2 = ioctl(_captureDev, AMVIDEOCAP_IOW_SET_WANTFRAME_HEIGHT, _height);
|
|
long r3 = ioctl(_captureDev, AMVIDEOCAP_IOW_SET_WANTFRAME_AT_FLAGS, CAP_FLAG_AT_END);
|
|
long r4 = ioctl(_captureDev, AMVIDEOCAP_IOW_SET_WANTFRAME_WAIT_MAX_MS, AMVIDEOCAP_WAIT_MAX_MS);
|
|
|
|
if (r1<0 || r2<0 || r3<0 || r4<0 || _height==0 || _width==0)
|
|
{
|
|
ErrorIf(_lastError != 2,_log,"Failed to configure capture device (%d - %s)", errno, strerror(errno));
|
|
_lastError = 2;
|
|
rc = -1;
|
|
}
|
|
else
|
|
{
|
|
int linelen = ((_width + 31) & ~31) * 3;
|
|
size_t _bytesToRead = linelen * _height;
|
|
|
|
// Read the snapshot into the memory
|
|
ssize_t bytesRead = pread(_captureDev, _image_ptr, _bytesToRead, 0);
|
|
if (bytesRead < 0)
|
|
{
|
|
int state;
|
|
ioctl(_captureDev, AMVIDEOCAP_IOR_GET_STATE, &state);
|
|
if (state == AMVIDEOCAP_STATE_ON_CAPTURE)
|
|
{
|
|
DebugIf(_lastError != 5, _log,"Video playback has been paused");
|
|
_lastError = 5;
|
|
}
|
|
else
|
|
{
|
|
ErrorIf(_lastError != 3, _log,"Read of device failed: %d - %s", errno, strerror(errno));
|
|
_lastError = 3;
|
|
}
|
|
rc = -1;
|
|
}
|
|
else
|
|
{
|
|
if (static_cast<ssize_t>(_bytesToRead) != bytesRead)
|
|
{
|
|
// Read of snapshot failed
|
|
ErrorIf(_lastError != 4, _log,"Capture failed to grab entire image [bytesToRead(%d) != bytesRead(%d)]", _bytesToRead, bytesRead);
|
|
_lastError = 4;
|
|
rc = -1;
|
|
}
|
|
else {
|
|
_imageResampler.processImage(static_cast<uint8_t*>(_image_ptr),
|
|
_width,
|
|
_height,
|
|
linelen,
|
|
PixelFormat::BGR24, image);
|
|
_lastError = 0;
|
|
rc = 0;
|
|
}
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
QJsonObject AmlogicGrabber::discover(const QJsonObject& params)
|
|
{
|
|
DebugIf(verbose, _log, "params: [%s]", QString(QJsonDocument(params).toJson(QJsonDocument::Compact)).toUtf8().constData());
|
|
|
|
QJsonObject inputsDiscovered;
|
|
|
|
if(QFile::exists(DEFAULT_VIDEO_DEVICE) && QFile::exists(DEFAULT_CAPTURE_DEVICE) )
|
|
{
|
|
QJsonArray video_inputs;
|
|
|
|
QSize screenSize = _fbGrabber.getScreenSize();
|
|
if ( !screenSize.isEmpty() )
|
|
{
|
|
int fbIdx = _fbGrabber.getPath().rightRef(1).toInt();
|
|
|
|
DebugIf(verbose, _log, "FB device [%s] found with resolution: %dx%d", QSTRING_CSTR(_fbGrabber.getPath()), screenSize.width(), screenSize.height());
|
|
QJsonArray fps = { 1, 5, 10, 15, 20, 25, 30, 40, 50, 60 };
|
|
|
|
QJsonObject in;
|
|
|
|
QString displayName;
|
|
displayName = QString("Display%1").arg(fbIdx);
|
|
|
|
in["name"] = displayName;
|
|
in["inputIdx"] = fbIdx;
|
|
|
|
QJsonArray formats;
|
|
QJsonObject format;
|
|
|
|
QJsonArray resolutionArray;
|
|
|
|
QJsonObject resolution;
|
|
|
|
resolution["width"] = screenSize.width();
|
|
resolution["height"] = screenSize.height();
|
|
resolution["fps"] = fps;
|
|
|
|
resolutionArray.append(resolution);
|
|
|
|
format["resolutions"] = resolutionArray;
|
|
formats.append(format);
|
|
|
|
in["formats"] = formats;
|
|
video_inputs.append(in);
|
|
}
|
|
|
|
if (!video_inputs.isEmpty())
|
|
{
|
|
inputsDiscovered["device"] = "amlogic";
|
|
inputsDiscovered["device_name"] = "AmLogic";
|
|
inputsDiscovered["type"] = "screen";
|
|
inputsDiscovered["video_inputs"] = video_inputs;
|
|
}
|
|
}
|
|
|
|
if (inputsDiscovered.isEmpty())
|
|
{
|
|
DebugIf(verbose, _log, "No displays found to capture from!");
|
|
}
|
|
|
|
DebugIf(verbose, _log, "device: [%s]", QString(QJsonDocument(inputsDiscovered).toJson(QJsonDocument::Compact)).toUtf8().constData());
|
|
|
|
return inputsDiscovered;
|
|
}
|
|
|
|
void AmlogicGrabber::setVideoMode(VideoMode mode)
|
|
{
|
|
Grabber::setVideoMode(mode);
|
|
_fbGrabber.setVideoMode(mode);
|
|
}
|
|
|
|
bool AmlogicGrabber::setPixelDecimation(int pixelDecimation)
|
|
{
|
|
return ( Grabber::setPixelDecimation( pixelDecimation) &&
|
|
_fbGrabber.setPixelDecimation( pixelDecimation));
|
|
}
|
|
|
|
void AmlogicGrabber::setCropping(int cropLeft, int cropRight, int cropTop, int cropBottom)
|
|
{
|
|
Grabber::setCropping(cropLeft, cropRight, cropTop, cropBottom);
|
|
_fbGrabber.setCropping(cropLeft, cropRight, cropTop, cropBottom);
|
|
}
|
|
|
|
bool AmlogicGrabber::setWidthHeight(int width, int height)
|
|
{
|
|
bool rc (false);
|
|
if ( Grabber::setWidthHeight(width, height) )
|
|
{
|
|
_image_bgr.resize(static_cast<unsigned>(width), static_cast<unsigned>(height));
|
|
_width = width;
|
|
_height = height;
|
|
_bytesToRead = _image_bgr.size();
|
|
_image_ptr = _image_bgr.memptr();
|
|
rc = _fbGrabber.setWidthHeight(width, height);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
bool AmlogicGrabber::setFramerate(int fps)
|
|
{
|
|
return (Grabber::setFramerate(fps) &&
|
|
_fbGrabber.setFramerate(fps));
|
|
}
|