zhaohuwei
/
QG4
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Merge pull request #8455 from tcanabrava/remove_settings_receiver 

Remove QGCApplication and VideoSettings from the VideoReceiver
QGC4.4
Gus Grubba 5 years ago committed by GitHub
parent
7cb08b796f 63623b0f33
commit
532260241d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 272 additions and 74 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      src/QGCApplication.h
  2. 2
      src/Settings/VideoSettings.cc
  3. 2
      src/Settings/VideoSettings.h
  4. 100
      src/VideoStreaming/VideoManager.cc
  5. 5
      src/VideoStreaming/VideoManager.h
  6. 178
      src/VideoStreaming/VideoReceiver.cc
  7. 57
      src/VideoStreaming/VideoReceiver.h

2
src/QGCApplication.h
Unescape View File

@ -71,7 +71,7 @@ public:
void reportMissingParameter(int componentId, const QString& name); void reportMissingParameter(int componentId, const QString& name);
/// Show a non-modal message to the user /// Show a non-modal message to the user
void showMessage(const QString& message); Q_SLOT void showMessage(const QString& message);
/// @return true: Fake ui into showing mobile interface /// @return true: Fake ui into showing mobile interface
bool fakeMobile(void) const { return _fakeMobile; } bool fakeMobile(void) const { return _fakeMobile; }

2
src/Settings/VideoSettings.cc
Unescape View File

@ -167,5 +167,5 @@ bool VideoSettings::streamConfigured(void)
void VideoSettings::_configChanged(QVariant) void VideoSettings::_configChanged(QVariant)
{ {
emit streamConfiguredChanged(); emit streamConfiguredChanged(streamConfigured());
} }

2
src/Settings/VideoSettings.h
Unescape View File

@ -60,7 +60,7 @@ public:
static const char* videoSourceMPEGTS; static const char* videoSourceMPEGTS;
signals: signals:
void streamConfiguredChanged (); void streamConfiguredChanged (bool configured);
private slots: private slots:
void _configChanged (QVariant value); void _configChanged (QVariant value);

100
src/VideoStreaming/VideoManager.cc
Unescape View File

@ -53,6 +53,8 @@ VideoManager::setToolbox(QGCToolbox *toolbox)
QQmlEngine::setObjectOwnership(this, QQmlEngine::CppOwnership); QQmlEngine::setObjectOwnership(this, QQmlEngine::CppOwnership);
qmlRegisterUncreatableType<VideoManager> ("QGroundControl.VideoManager", 1, 0, "VideoManager", "Reference only"); qmlRegisterUncreatableType<VideoManager> ("QGroundControl.VideoManager", 1, 0, "VideoManager", "Reference only");
qmlRegisterUncreatableType<VideoReceiver>("QGroundControl", 1, 0, "VideoReceiver","Reference only"); qmlRegisterUncreatableType<VideoReceiver>("QGroundControl", 1, 0, "VideoReceiver","Reference only");
// TODO: Those connections should be Per Video, not per VideoManager.
_videoSettings = toolbox->settingsManager()->videoSettings(); _videoSettings = toolbox->settingsManager()->videoSettings();
QString videoSource = _videoSettings->videoSource()->rawValue().toString(); QString videoSource = _videoSettings->videoSource()->rawValue().toString();
connect(_videoSettings->videoSource(), &Fact::rawValueChanged, this, &VideoManager::_videoSourceChanged); connect(_videoSettings->videoSource(), &Fact::rawValueChanged, this, &VideoManager::_videoSourceChanged);
@ -72,7 +74,56 @@ VideoManager::setToolbox(QGCToolbox *toolbox)
emit isGStreamerChanged(); emit isGStreamerChanged();
qCDebug(VideoManagerLog) << "New Video Source:" << videoSource; qCDebug(VideoManagerLog) << "New Video Source:" << videoSource;
_videoReceiver = toolbox->corePlugin()->createVideoReceiver(this); _videoReceiver = toolbox->corePlugin()->createVideoReceiver(this);
_videoReceiver->setUnittestMode(qgcApp()->runningUnitTests());
_thermalVideoReceiver = toolbox->corePlugin()->createVideoReceiver(this); _thermalVideoReceiver = toolbox->corePlugin()->createVideoReceiver(this);
_thermalVideoReceiver->setUnittestMode(qgcApp()->runningUnitTests());
_videoReceiver->moveToThread(qgcApp()->thread());
_thermalVideoReceiver->moveToThread(qgcApp()->thread());
// Those connects are temporary: In a perfect world those connections are going to be done on the Qml
// but because currently the videoReceiver is created in the C++ world, this is easier.
// The fact returning a QVariant is a quite annoying to use proper signal / slot connection.
_updateSettings();
auto appSettings = toolbox->settingsManager()->appSettings();
for (auto *videoReceiver : { _videoReceiver, _thermalVideoReceiver}) {
// First, Setup the current values from the settings.
videoReceiver->setRtspTimeout(_videoSettings->rtspTimeout()->rawValue().toInt());
videoReceiver->setStreamEnabled(_videoSettings->streamEnabled()->rawValue().toBool());
videoReceiver->setRecordingFormatId(_videoSettings->recordingFormat()->rawValue().toInt());
videoReceiver->setStreamConfigured(_videoSettings->streamConfigured());
connect(_videoSettings->rtspTimeout(), &Fact::rawValueChanged,
videoReceiver, [videoReceiver](const QVariant &value) {
videoReceiver->setRtspTimeout(value.toInt());
}
);
connect(_videoSettings->streamEnabled(), &Fact::rawValueChanged,
videoReceiver, [videoReceiver](const QVariant &value) {
videoReceiver->setStreamEnabled(value.toBool());
}
);
connect(_videoSettings->recordingFormat(), &Fact::rawValueChanged,
videoReceiver, [videoReceiver](const QVariant &value) {
videoReceiver->setRecordingFormatId(value.toInt());
}
);
// Why some options are facts while others aren't?
connect(_videoSettings, &VideoSettings::streamConfiguredChanged, videoReceiver, &VideoReceiver::setStreamConfigured);
// Fix those.
// connect(appSettings, &Fact::rawValueChanged, videoReceiver, &VideoReceiver::setVideoPath);
// connect(appSettings->videoSavePath(), &Fact::rawValueChanged, videoReceiver, &VideoReceiver::setImagePath);
// Connect the video receiver with the rest of the app.
connect(videoReceiver, &VideoReceiver::restartTimeout, this, &VideoManager::restartVideo);
connect(videoReceiver, &VideoReceiver::sendMessage, qgcApp(), &QGCApplication::showMessage);
connect(videoReceiver, &VideoReceiver::beforeRecording, this, &VideoManager::cleanupOldVideos);
}
_updateSettings(); _updateSettings();
if(isGStreamer()) { if(isGStreamer()) {
startVideo(); startVideo();
@ -84,6 +135,55 @@ VideoManager::setToolbox(QGCToolbox *toolbox)
#endif #endif
} }
QStringList VideoManager::videoMuxes()
{
return {"matroskamux", "qtmux", "mp4mux"};
}
QStringList VideoManager::videoExtensions()
{
return {"mkv", "mov", "mp4"};
}
void VideoManager::cleanupOldVideos()
{
#if defined(QGC_GST_STREAMING)
//-- Only perform cleanup if storage limit is enabled
if(!_videoSettings->enableStorageLimit()->rawValue().toBool()) {
return;
}
QString savePath = qgcApp()->toolbox()->settingsManager()->appSettings()->videoSavePath();
QDir videoDir = QDir(savePath);
videoDir.setFilter(QDir::Files | QDir::Readable | QDir::NoSymLinks | QDir::Writable);
videoDir.setSorting(QDir::Time);
QStringList nameFilters;
for(const QString& extension : videoExtensions()) {
nameFilters << QString("*.") + extension;
}
videoDir.setNameFilters(nameFilters);
//-- get the list of videos stored
QFileInfoList vidList = videoDir.entryInfoList();
if(!vidList.isEmpty()) {
uint64_t total = 0;
//-- Settings are stored using MB
uint64_t maxSize = _videoSettings->maxVideoSize()->rawValue().toUInt() * 1024 * 1024;
//-- Compute total used storage
for(int i = 0; i < vidList.size(); i++) {
total += vidList[i].size();
}
//-- Remove old movies until max size is satisfied.
while(total >= maxSize && !vidList.isEmpty()) {
total -= vidList.last().size();
qCDebug(VideoReceiverLog) << "Removing old video file:" << vidList.last().filePath();
QFile file (vidList.last().filePath());
file.remove();
vidList.removeLast();
}
}
#endif
}
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void void
VideoManager::startVideo() VideoManager::startVideo()

5
src/VideoStreaming/VideoManager.h
Unescape View File

@ -67,6 +67,9 @@ public:
virtual VideoReceiver* videoReceiver () { return _videoReceiver; } virtual VideoReceiver* videoReceiver () { return _videoReceiver; }
virtual VideoReceiver* thermalVideoReceiver () { return _thermalVideoReceiver; } virtual VideoReceiver* thermalVideoReceiver () { return _thermalVideoReceiver; }
QStringList videoExtensions();
QStringList videoMuxes();
#if defined(QGC_DISABLE_UVC) #if defined(QGC_DISABLE_UVC)
virtual bool uvcEnabled () { return false; } virtual bool uvcEnabled () { return false; }
#else #else
@ -82,6 +85,8 @@ public:
Q_INVOKABLE void startVideo (); Q_INVOKABLE void startVideo ();
Q_INVOKABLE void stopVideo (); Q_INVOKABLE void stopVideo ();
void cleanupOldVideos();
signals: signals:
void hasVideoChanged (); void hasVideoChanged ();
void isGStreamerChanged (); void isGStreamerChanged ();

178
src/VideoStreaming/VideoReceiver.cc
Unescape View File

@ -15,8 +15,6 @@
*/ */
#include "VideoReceiver.h" #include "VideoReceiver.h"
#include "SettingsManager.h"
#include "QGCApplication.h"
#include "VideoManager.h" #include "VideoManager.h"
#ifdef QGC_GST_TAISYNC_ENABLED #ifdef QGC_GST_TAISYNC_ENABLED
#include "TaisyncHandler.h" #include "TaisyncHandler.h"
@ -70,14 +68,15 @@ VideoReceiver::VideoReceiver(QObject* parent)
#endif #endif
, _videoRunning(false) , _videoRunning(false)
, _showFullScreen(false) , _showFullScreen(false)
, _videoSettings(nullptr) , _streamEnabled(false)
, _streamConfigured(false)
, _unittTestMode(false)
, _isTaisync(false)
{ {
// FIXME: AV: temporal workaround to allow for Qt::QueuedConnection for gstreamer signals. Need to evaluate proper solution - perhaps QtGst will be helpful // FIXME: AV: temporal workaround to allow for Qt::QueuedConnection for gstreamer signals. Need to evaluate proper solution - perhaps QtGst will be helpful
moveToThread(qgcApp()->thread());
_videoSettings = qgcApp()->toolbox()->settingsManager()->videoSettings();
#if defined(QGC_GST_STREAMING) #if defined(QGC_GST_STREAMING)
_restart_timer.setSingleShot(true); _restart_timer.setSingleShot(true);
connect(&_restart_timer, &QTimer::timeout, this, &VideoReceiver::_restart_timeout); connect(&_restart_timer, &QTimer::timeout, this, &VideoReceiver::restartTimeout);
connect(this, &VideoReceiver::msgErrorReceived, this, &VideoReceiver::_handleError, Qt::QueuedConnection); connect(this, &VideoReceiver::msgErrorReceived, this, &VideoReceiver::_handleError, Qt::QueuedConnection);
connect(this, &VideoReceiver::msgEOSReceived, this, &VideoReceiver::_handleEOS, Qt::QueuedConnection); connect(this, &VideoReceiver::msgEOSReceived, this, &VideoReceiver::_handleEOS, Qt::QueuedConnection);
connect(this, &VideoReceiver::msgStateChangedReceived, this, &VideoReceiver::_handleStateChanged, Qt::QueuedConnection); connect(this, &VideoReceiver::msgStateChangedReceived, this, &VideoReceiver::_handleStateChanged, Qt::QueuedConnection);
@ -433,12 +432,102 @@ VideoReceiver::_makeSource(const QString& uri)
return srcbin; return srcbin;
} }
//----------------------------------------------------------------------------- bool VideoReceiver::streamEnabled() const
void {
VideoReceiver::_restart_timeout() return _streamEnabled;
}
void VideoReceiver::setStreamEnabled(bool enabled)
{
if (_streamEnabled != enabled) {
_streamEnabled = enabled;
emit streamEnabledChanged();
}
}
bool VideoReceiver::streamConfigured() const
{
return _streamConfigured;
}
void VideoReceiver::setStreamConfigured(bool enabled)
{
if (_streamConfigured != enabled) {
_streamConfigured = enabled;
emit streamEnabledChanged();
}
}
bool VideoReceiver::isTaisync() const
{
return _isTaisync;
}
void VideoReceiver::setIsTaysinc(bool enabled)
{
if (_isTaisync != enabled) {
_isTaisync = enabled;
emit isTaisyncChanged();
}
}
QString VideoReceiver::videoPath() const
{
return _videoPath;
}
void VideoReceiver::setVideoPath(const QString& value)
{ {
qgcApp()->toolbox()->videoManager()->restartVideo(); if (_videoPath != value) {
_videoPath = value;
emit videoPathChanged();
}
}
QString VideoReceiver::imagePath() const
{
return _imagePath;
}
void VideoReceiver::setImagePath(const QString& value)
{
if (_imagePath != value) {
_imagePath = value;
emit imagePathChanged();
}
} }
int VideoReceiver::recordingFormatId() const
{
return _recordingFormatId;
}
void VideoReceiver::setRecordingFormatId(int value)
{
if (_recordingFormatId != value && value < (int) NUM_MUXES) {
_recordingFormatId = value;
emit recordingFormatIdChanged();
}
}
int VideoReceiver::rtspTimeout() const
{
return _rtspTimeout;
}
void VideoReceiver::setRtspTimeout(int value)
{
if (_rtspTimeout != value) {
_rtspTimeout = value;
emit rtspTimeoutChanged();
}
}
void VideoReceiver::setUnittestMode(bool runUnitTests)
{
_unittTestMode = runUnitTests;
}
#endif #endif
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -454,11 +543,10 @@ void
VideoReceiver::start() VideoReceiver::start()
{ {
qCDebug(VideoReceiverLog) << "Starting " << _uri; qCDebug(VideoReceiverLog) << "Starting " << _uri;
if(qgcApp()->runningUnitTests()) { if(_unittTestMode) {
return; return;
} }
if(!_videoSettings->streamEnabled()->rawValue().toBool() || if(!_streamEnabled || !_streamConfigured) {
!_videoSettings->streamConfigured()) {
qCDebug(VideoReceiverLog) << "Stream not enabled/configured"; qCDebug(VideoReceiverLog) << "Stream not enabled/configured";
return; return;
} }
@ -470,7 +558,7 @@ VideoReceiver::start()
#if defined(QGC_GST_TAISYNC_ENABLED) && (defined(__android__) || defined(__ios__)) #if defined(QGC_GST_TAISYNC_ENABLED) && (defined(__android__) || defined(__ios__))
//-- Taisync on iOS or Android sends a raw h.264 stream //-- Taisync on iOS or Android sends a raw h.264 stream
if (qgcApp()->toolbox()->videoManager()->isTaisync()) { if (_isTaisync) {
uri = QString("tsusb://0.0.0.0:%1").arg(TAISYNC_VIDEO_UDP_PORT); uri = QString("tsusb://0.0.0.0:%1").arg(TAISYNC_VIDEO_UDP_PORT);
} }
#endif #endif
@ -609,7 +697,7 @@ VideoReceiver::start()
void void
VideoReceiver::stop() VideoReceiver::stop()
{ {
if(qgcApp() && qgcApp()->runningUnitTests()) { if(_unittTestMode) {
return; return;
} }
#if defined(QGC_GST_STREAMING) #if defined(QGC_GST_STREAMING)
@ -765,46 +853,6 @@ VideoReceiver::_onBusMessage(GstBus* bus, GstMessage* msg, gpointer data)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#if defined(QGC_GST_STREAMING) #if defined(QGC_GST_STREAMING)
void void
VideoReceiver::_cleanupOldVideos()
{
//-- Only perform cleanup if storage limit is enabled
if(_videoSettings->enableStorageLimit()->rawValue().toBool()) {
QString savePath = qgcApp()->toolbox()->settingsManager()->appSettings()->videoSavePath();
QDir videoDir = QDir(savePath);
videoDir.setFilter(QDir::Files | QDir::Readable | QDir::NoSymLinks | QDir::Writable);
videoDir.setSorting(QDir::Time);
//-- All the movie extensions we support
QStringList nameFilters;
for(uint32_t i = 0; i < NUM_MUXES; i++) {
nameFilters << QString("*.") + QString(kVideoExtensions[i]);
}
videoDir.setNameFilters(nameFilters);
//-- get the list of videos stored
QFileInfoList vidList = videoDir.entryInfoList();
if(!vidList.isEmpty()) {
uint64_t total = 0;
//-- Settings are stored using MB
uint64_t maxSize = (_videoSettings->maxVideoSize()->rawValue().toUInt() * 1024 * 1024);
//-- Compute total used storage
for(int i = 0; i < vidList.size(); i++) {
total += vidList[i].size();
}
//-- Remove old movies until max size is satisfied.
while(total >= maxSize && !vidList.isEmpty()) {
total -= vidList.last().size();
qCDebug(VideoReceiverLog) << "Removing old video file:" << vidList.last().filePath();
QFile file (vidList.last().filePath());
file.remove();
vidList.removeLast();
}
}
}
}
#endif
//-----------------------------------------------------------------------------
#if defined(QGC_GST_STREAMING)
void
VideoReceiver::setVideoSink(GstElement* videoSink) VideoReceiver::setVideoSink(GstElement* videoSink)
{ {
if(_pipeline != nullptr) { if(_pipeline != nullptr) {
@ -934,6 +982,7 @@ void
VideoReceiver::startRecording(const QString &videoFile) VideoReceiver::startRecording(const QString &videoFile)
{ {
#if defined(QGC_GST_STREAMING) #if defined(QGC_GST_STREAMING)
emit beforeRecording();
qCDebug(VideoReceiverLog) << "Starting recording"; qCDebug(VideoReceiverLog) << "Starting recording";
// exit immediately if we are already recording // exit immediately if we are already recording
@ -942,18 +991,15 @@ VideoReceiver::startRecording(const QString &videoFile)
return; return;
} }
uint32_t muxIdx = _videoSettings->recordingFormat()->rawValue().toUInt(); uint32_t muxIdx = _recordingFormatId;
if(muxIdx >= NUM_MUXES) { if(muxIdx >= NUM_MUXES) {
qgcApp()->showMessage(tr("Invalid video format defined.")); emit sendMessage(tr("Invalid video format defined."));
return; return;
} }
//-- Disk usage maintenance QString savePath = _videoPath;
_cleanupOldVideos();
QString savePath = qgcApp()->toolbox()->settingsManager()->appSettings()->videoSavePath();
if(savePath.isEmpty()) { if(savePath.isEmpty()) {
qgcApp()->showMessage(tr("Unabled to record video. Video save path must be specified in Settings.")); emit sendMessage(tr("Unabled to record video. Video save path must be specified in Settings."));
return; return;
} }
@ -1175,11 +1221,7 @@ VideoReceiver::_updateTimer()
} }
if(_videoRunning) { if(_videoRunning) {
uint32_t timeout = 1; uint32_t timeout = _rtspTimeout;
if(qgcApp()->toolbox() && qgcApp()->toolbox()->settingsManager()) {
timeout = _videoSettings->rtspTimeout()->rawValue().toUInt();
}
const qint64 now = QDateTime::currentSecsSinceEpoch(); const qint64 now = QDateTime::currentSecsSinceEpoch();
if(now - _lastFrameTime > timeout) { if(now - _lastFrameTime > timeout) {
@ -1189,7 +1231,7 @@ VideoReceiver::_updateTimer()
} }
} else { } else {
// FIXME: AV: if pipeline is _running but not _streaming for some time then we need to restart // FIXME: AV: if pipeline is _running but not _streaming for some time then we need to restart
if(!_stop && !_running && !_uri.isEmpty() && _videoSettings->streamEnabled()->rawValue().toBool()) { if(!_stop && !_running && !_uri.isEmpty() && _streamEnabled) {
start(); start();
} }
} }

57
src/VideoStreaming/VideoReceiver.h
Unescape View File

@ -39,11 +39,54 @@ public:
Q_PROPERTY(bool videoRunning READ videoRunning NOTIFY videoRunningChanged) Q_PROPERTY(bool videoRunning READ videoRunning NOTIFY videoRunningChanged)
Q_PROPERTY(QString imageFile READ imageFile NOTIFY imageFileChanged) Q_PROPERTY(QString imageFile READ imageFile NOTIFY imageFileChanged)
Q_PROPERTY(QString videoFile READ videoFile NOTIFY videoFileChanged) Q_PROPERTY(QString videoFile READ videoFile NOTIFY videoFileChanged)
Q_PROPERTY(QString imagePath READ imagePath NOTIFY imagePathChanged)
Q_PROPERTY(QString videoPath READ videoPath NOTIFY videoPathChanged)
Q_PROPERTY(bool showFullScreen READ showFullScreen WRITE setShowFullScreen NOTIFY showFullScreenChanged) Q_PROPERTY(bool showFullScreen READ showFullScreen WRITE setShowFullScreen NOTIFY showFullScreenChanged)
Q_PROPERTY(bool streamEnabled READ streamEnabled WRITE setStreamEnabled NOTIFY streamEnabledChanged)
Q_PROPERTY(bool streamConfigured READ streamConfigured WRITE setStreamConfigured NOTIFY streamConfiguredChanged)
Q_PROPERTY(bool isTaisync READ isTaisync WRITE setIsTaysinc NOTIFY isTaisyncChanged)
Q_PROPERTY(int recordingFormatId READ recordingFormatId WRITE setRecordingFormatId NOTIFY recordingFormatIdChanged)
Q_PROPERTY(int rtspTimeout READ rtspTimeout WRITE setRtspTimeout NOTIFY rtspTimeoutChanged)
explicit VideoReceiver(QObject* parent = nullptr); explicit VideoReceiver(QObject* parent = nullptr);
~VideoReceiver(); ~VideoReceiver();
bool streamEnabled() const;
Q_SLOT void setStreamEnabled(bool enabled);
Q_SIGNAL void streamEnabledChanged();
bool streamConfigured() const;
Q_SLOT void setStreamConfigured(bool enabled);
Q_SIGNAL void streamConfiguredChanged();
bool isTaisync() const;
Q_SLOT void setIsTaysinc(bool value);
Q_SIGNAL void isTaisyncChanged();
QString videoPath() const;
Q_SLOT void setVideoPath(const QString& path);
Q_SIGNAL void videoPathChanged();
QString imagePath() const;
Q_SLOT void setImagePath(const QString& path);
Q_SIGNAL void imagePathChanged();
int recordingFormatId() const;
Q_SLOT void setRecordingFormatId(int value);
Q_SIGNAL void recordingFormatIdChanged();
int rtspTimeout() const;
Q_SLOT void setRtspTimeout(int value);
Q_SIGNAL void rtspTimeoutChanged();
Q_SIGNAL void restartTimeout();
Q_SIGNAL void sendMessage(const QString& message);
// Emitted before recording starts.
Q_SIGNAL void beforeRecording();
void setUnittestMode(bool runUnitTests);
#if defined(QGC_GST_STREAMING) #if defined(QGC_GST_STREAMING)
virtual bool recording () { return _recording; } virtual bool recording () { return _recording; }
#endif #endif
@ -86,7 +129,6 @@ protected slots:
#if defined(QGC_GST_STREAMING) #if defined(QGC_GST_STREAMING)
GstElement* _makeSource (const QString& uri); GstElement* _makeSource (const QString& uri);
GstElement* _makeFileSink (const QString& videoFile, unsigned format); GstElement* _makeFileSink (const QString& videoFile, unsigned format);
virtual void _restart_timeout ();
virtual void _handleError (); virtual void _handleError ();
virtual void _handleEOS (); virtual void _handleEOS ();
virtual void _handleStateChanged (); virtual void _handleStateChanged ();
@ -122,7 +164,6 @@ protected:
virtual void _unlinkRecordingBranch (GstPadProbeInfo* info); virtual void _unlinkRecordingBranch (GstPadProbeInfo* info);
virtual void _shutdownRecordingBranch(); virtual void _shutdownRecordingBranch();
virtual void _shutdownPipeline (); virtual void _shutdownPipeline ();
virtual void _cleanupOldVideos ();
GstElement* _pipeline; GstElement* _pipeline;
GstElement* _videoSink; GstElement* _videoSink;
@ -141,8 +182,18 @@ protected:
QString _uri; QString _uri;
QString _imageFile; QString _imageFile;
QString _videoFile; QString _videoFile;
QString _videoPath;
QString _imagePath;
bool _videoRunning; bool _videoRunning;
bool _showFullScreen; bool _showFullScreen;
VideoSettings* _videoSettings; bool _streamEnabled;
bool _streamConfigured;
bool _storageLimit;
bool _unittTestMode;
bool _isTaisync;
int _recordingFormatId; // 0 - 2, defined in VideoReceiver.cc / kVideoExtensions. TODO: use a better representation.
int _rtspTimeout;
}; };

Write Preview
Loading…
Cancel
Save