Merge pull request #8596 from andrewvoznytsa/pr-small-video-tweaks

Small video tweaks

.gitmodules

@@ -7,6 +7,6 @@
 [submodule "libs/OpenSSL/android_openssl"]
 	path = libs/OpenSSL/android_openssl
 	url = https://github.com/Auterion/android_openssl
-[submodule "libs/gst-plugins-good"]
+[submodule "libs/qmlglsink/gst-plugins-good"]
 	path = libs/qmlglsink/gst-plugins-good
 	url = https://github.com/mavlink/gst-plugins-good.git

VideoReceiverApp/README.md

+# VideoReceiverApp
+ 
+## Application
+ 
+This is a simple test application developed to make VideoReceiver library development and testing easier. It can also be used as part of CI for system tests.
+ 
+## Use cases and options
+ 
+Application's behaviour depends on the executable name. There are two modes - QML and console. QML mode is enabled by renaming application executable to something that starts with **Q** (for example QVideoReceiverApp). In this case **video-sink** option is not available and application always tries to use **qmlglsink** for video rendering. In regular case (executable name does not start with **Q**) **autovideosink** or **fakesink** are used, depending on options.
+ 
+### Available options and required arguments
+ ```VideoReceiverApp  [options] url```
+ 
+for example:
+ 
+ ```VideoReceiverApp -d --stop-decoding 30 rtsp://127.0.0.1:8554/test```
+ 
+#### Options
+ ```-h, --help``` - displays help
+ 
+ ```-t, --timeout <seconds>``` - specifies source timeout
+ 
+ ```-c, --connect <attempts>``` - specifies number of connection attempts
+ 
+ ```-d, --decode``` - enables or disables video decoding and rendering
+ 
+ ```--no-decode``` - disables video decoding and rendering if it was enabled by default
+ 
+ ```--stop-decoding <seconds>``` - specifies amount of seconds after which decoding should be stopped
+ 
+ ```-r, --record <file>```  - enables record video into file
+ 
+ ```-f, --format <format>``` - specifies recording file format, where format 0 - MKV, 1 - MOV, 2 - MP4
+ 
+ ```--stop-recording <seconds>``` - specifies amount of seconds after which recording should be stopped
+  ```--video-sink <sink>``` - specifies which video sink to use : 0 - autovideosink, 1 - fakesink
+ 
+#### Arguments
+ ```url``` - required, specifies video URL.
+  Following URLs are supported:
+  ```rtsp://<host>:<port>/mount/point``` - usual RTSP URL
+ 
+ ```udp://<interface>:<port>``` - H.264 over RTP/UDP
+ 
+ ```udp265://<interface>:<port>``` - H.265 over RTP/UDP
+ 
+ ```tsusb://<interface>:<port>``` - Taisync's forwarded H.264 byte aligned NALU stream over UDP
+ 
+ ```tcp://<host>:<port>``` - MPEG-2 TS over TCP
+ 
+ ```mpegts://<interface>:<port>``` - MPEG-2 TS over UDP
+ 

VideoReceiverApp/main.cpp

@@ -155,6 +155,9 @@ private:
     unsigned int _fileFormat = VideoReceiver::FILE_FORMAT_MIN;
     unsigned _stopRecordingAfter = 15;
     bool _useFakeSink = false;
+    bool _streaming = false;
+    bool _decoding = false;
+    bool _recording = false;
 };
 
 void
@@ -299,52 +302,27 @@ VideoReceiverApp::exec()
 
     startStreaming();
 
-    QObject::connect(_receiver, &VideoReceiver::timeout, [this](){
+    QObject::connect(_receiver, &VideoReceiver::timeout, [](){
         qCDebug(AppLog) << "Streaming timeout";
-
-        _dispatch([this](){
-            if (_receiver->streaming()) {
-                _receiver->stop();
-            } else {
-                if (--_connect > 0) {
-                    qCDebug(AppLog) << "Restarting streaming";
-                    _dispatch([this](){
-                        startStreaming();
-                    });
-                } else {
-                    qCDebug(AppLog) << "Closing...";
-                    delete _receiver;
-                    _app.exit();
-                }
-            }
-        });
      });
 
-    QObject::connect(_receiver, &VideoReceiver::streamingChanged, [this](){
-        if (_receiver->streaming()) {
+    QObject::connect(_receiver, &VideoReceiver::streamingChanged, [this](bool active){
+        _streaming = active;
+        if (_streaming) {
             qCDebug(AppLog) << "Streaming started";
         } else {
             qCDebug(AppLog) << "Streaming stopped";
-            _dispatch([this](){
-                if (--_connect > 0) {
-                    qCDebug(AppLog) << "Restarting streaming";
-                    startStreaming();
-                } else {
-                    qCDebug(AppLog) << "Closing...";
-                    delete _receiver;
-                    _app.exit();
-                }
-            });
         }
      });
 
-    QObject::connect(_receiver, &VideoReceiver::decodingChanged, [this](){
-        if (_receiver->decoding()) {
+    QObject::connect(_receiver, &VideoReceiver::decodingChanged, [this](bool active){
+        _decoding = active;
+        if (_decoding) {
             qCDebug(AppLog) << "Decoding started";
         } else {
             qCDebug(AppLog) << "Decoding stopped";
-            if (_receiver->streaming()) {
-                if (!_receiver->recording()) {
+            if (_streaming) {
+                if (!_recording) {
                     _dispatch([this](){
                         _receiver->stop();
                     });
@@ -353,13 +331,14 @@ VideoReceiverApp::exec()
         }
      });
 
-    QObject::connect(_receiver, &VideoReceiver::recordingChanged, [this](){
-        if (_receiver->recording()) {
+    QObject::connect(_receiver, &VideoReceiver::recordingChanged, [this](bool active){
+        _recording = active;
+        if (_recording) {
             qCDebug(AppLog) << "Recording started";
         } else {
             qCDebug(AppLog) << "Recording stopped";
-            if (_receiver->streaming()) {
-                if (!_receiver->decoding()) {
+            if (_streaming) {
+                if (!_decoding) {
                     _dispatch([this](){
                         _receiver->stop();
                     });
@@ -368,6 +347,44 @@ VideoReceiverApp::exec()
         }
      });
 
+    QObject::connect(_receiver, &VideoReceiver::onStartComplete, [this](VideoReceiver::STATUS status){
+        if (status != VideoReceiver::STATUS_OK) {
+            qCDebug(AppLog) << "Video receiver start failed";
+            _dispatch([this](){
+                if (--_connect > 0) {
+                    qCDebug(AppLog) << "Restarting ...";
+                    _dispatch([this](){
+                        startStreaming();
+                    });
+                } else {
+                    qCDebug(AppLog) << "Closing...";
+                    delete _receiver;
+                    _app.exit();
+                }
+            });
+        } else {
+            qCDebug(AppLog) << "Video receiver started";
+        }
+     });
+
+    QObject::connect(_receiver, &VideoReceiver::onStopComplete, [this](VideoReceiver::STATUS ){
+        qCDebug(AppLog) << "Video receiver stopped";
+
+        _dispatch([this](){
+            if (--_connect > 0) {
+                qCDebug(AppLog) << "Restarting ...";
+                _dispatch([this](){
+                    startStreaming();
+                });
+            } else {
+                qCDebug(AppLog) << "Closing...";
+                delete _receiver;
+                _app.exit();
+            }
+        });
+     });
+
+
     return _app.exec();
 }
 

custom-example/res/CustomCameraControl.qml

@@ -44,8 +44,8 @@ Item {
     property real   _labelFieldWidth:       ScreenTools.defaultFontPixelWidth  * 28
     property real   _editFieldWidth:        ScreenTools.defaultFontPixelWidth  * 30
     property real   _editFieldHeight:       ScreenTools.defaultFontPixelHeight * 2
-    property var    _videoReceiver:         QGroundControl.videoManager.videoReceiver
-    property bool   _recordingLocalVideo:   _videoReceiver && _videoReceiver.recording
+    property var    _videoManager:          QGroundControl.videoManager
+    property bool   _recordingLocalVideo:   QGroundControl.videoManager.recording
 
     property var    _dynamicCameras:        activeVehicle ? activeVehicle.dynamicCameras : null
     property bool   _isCamera:              _dynamicCameras ? _dynamicCameras.cameras.count > 0 : false
@@ -305,15 +305,15 @@ Item {
                                         _camera.stopVideo()
                                         //-- Local video as well
                                         if (_recordingVideo) {
-                                            _videoReceiver.stopRecording()
+                                            _videoManager.stopRecording()
                                         }
                                     } else {
                                         if(!_fullSD) {
                                             _camera.startVideo()
                                         }
                                         //-- Local video as well
-                                        if(_videoReceiver) {
-                                            _videoReceiver.startRecording()
+                                        if(_videoManager) {
+                                            _videoManager.startRecording()
                                         }
                                     }
                                 } else {

custom-example/src/CustomPlugin.cc

@@ -29,12 +29,8 @@
 QGC_LOGGING_CATEGORY(CustomLog, "CustomLog")
 
 CustomVideoReceiver::CustomVideoReceiver(QObject* parent)
-    : VideoReceiver(parent)
+    : GstVideoReceiver(parent)
 {
-#if defined(QGC_GST_STREAMING)
-    //-- Shorter RTSP test interval
-    _restart_time_ms = 1000;
-#endif
 }
 
 CustomVideoReceiver::~CustomVideoReceiver()

custom-example/src/CustomPlugin.h

@@ -14,7 +14,7 @@
 #include "QGCCorePlugin.h"
 #include "QGCOptions.h"
 #include "QGCLoggingCategory.h"
-#include "VideoReceiver.h"
+#include "GstVideoReceiver.h"
 #include "SettingsManager.h"
 
 #include <QTranslator>
@@ -25,7 +25,7 @@ class CustomSettings;
 Q_DECLARE_LOGGING_CATEGORY(CustomLog)
 
 //-- Our own, custom video receiver
-class CustomVideoReceiver : public VideoReceiver
+class CustomVideoReceiver : public GstVideoReceiver
 {
     Q_OBJECT
 public:

custom-example/src/CustomVideoManager.cc

@@ -20,10 +20,10 @@ CustomVideoManager::CustomVideoManager(QGCApplication* app, QGCToolbox* toolbox)
 
 //-----------------------------------------------------------------------------
 void
-CustomVideoManager::_updateSettings()
+CustomVideoManager::_updateSettings(unsigned id)
 {
     if(!_videoSettings || !_videoReceiver)
         return;
-    VideoManager::_updateSettings();
+    VideoManager::_updateSettings(id);
 }
 

custom-example/src/CustomVideoManager.h

@@ -23,6 +23,6 @@ public:
     CustomVideoManager      (QGCApplication* app, QGCToolbox* toolbox);
 
 protected:
-    void _updateSettings    ();
+    void _updateSettings    (unsigned id);
 
 };

src/FlightDisplay/FlightDisplayViewVideo.qml

@@ -25,7 +25,6 @@ Item {
     clip:   true
     property double _ar:                QGroundControl.videoManager.aspectRatio
     property bool   _showGrid:          QGroundControl.settingsManager.videoSettings.gridLines.rawValue > 0
-    property var    _videoReceiver:     QGroundControl.videoManager.videoReceiver
     property var    _dynamicCameras:    activeVehicle ? activeVehicle.dynamicCameras : null
     property bool   _connected:         activeVehicle ? !activeVehicle.connectionLost : false
     property int    _curCameraIndex:    _dynamicCameras ? _dynamicCameras.currentCamera : 0
@@ -40,7 +39,7 @@ Item {
         id:             noVideo
         anchors.fill:   parent
         color:          Qt.rgba(0,0,0,0.75)
-        visible:        !(_videoReceiver && _videoReceiver.decoding)
+        visible:        !(QGroundControl.videoManager.decoding)
         QGCLabel {
             text:               QGroundControl.settingsManager.videoSettings.streamEnabled.rawValue ? qsTr("WAITING FOR VIDEO") : qsTr("VIDEO DISABLED")
             font.family:        ScreenTools.demiboldFontFamily
@@ -58,7 +57,7 @@ Item {
     Rectangle {
         anchors.fill:   parent
         color:          "black"
-        visible:        _videoReceiver && _videoReceiver.decoding
+        visible:        QGroundControl.videoManager.decoding
         function getWidth() {
             //-- Fit Width or Stretch
             if(_fitMode === 0 || _fitMode === 2) {
@@ -80,10 +79,9 @@ Item {
             QGCVideoBackground {
                 id:             videoContent
                 objectName:     "videoContent"
-                receiver:       _videoReceiver
 
                 Connections {
-                    target:         _videoReceiver
+                    target: QGroundControl.videoManager
                     onImageFileChanged: {
                         videoContent.grabToImage(function(result) {
                             if (!result.saveToFile(QGroundControl.videoManager.imageFile)) {
@@ -130,7 +128,7 @@ Item {
             height:             parent.getHeight()
             width:              parent.getWidth()
             anchors.centerIn:   parent
-            visible:            _videoReceiver && _videoReceiver.decoding
+            visible:            QGroundControl.videoManager.decoding
             sourceComponent:    videoBackgroundComponent
 
             property bool videoDisabled: QGroundControl.settingsManager.videoSettings.videoSource.rawValue === QGroundControl.settingsManager.videoSettings.disabledVideoSource

src/FlightMap/Widgets/VideoPageWidget.qml

@@ -31,9 +31,8 @@ Item {
     anchors.centerIn:   parent
 
     property bool   _communicationLost:     activeVehicle ? activeVehicle.connectionLost : false
-    property var    _videoReceiver:         QGroundControl.videoManager.videoReceiver
-    property bool   _recordingVideo:        _videoReceiver && _videoReceiver.recording
-    property bool   _decodingVideo:         _videoReceiver && _videoReceiver.decoding
+    property bool   _recordingVideo:        QGroundControl.videoManager.recording
+    property bool   _decodingVideo:         QGroundControl.videoManager.decoding
     property bool   _streamingEnabled:      QGroundControl.settingsManager.videoSettings.streamConfigured
     property var    _dynamicCameras:        activeVehicle ? activeVehicle.dynamicCameras : null
     property int    _curCameraIndex:        _dynamicCameras ? _dynamicCameras.currentCamera : 0
@@ -70,10 +69,10 @@ Item {
             onClicked: {
                 if(checked) {
                     QGroundControl.settingsManager.videoSettings.streamEnabled.rawValue = 1
-                    _videoReceiver.start()
+                    QGroundControl.videoManager.startVideo()
                 } else {
                     QGroundControl.settingsManager.videoSettings.streamEnabled.rawValue = 0
-                    _videoReceiver.stop()
+                    QGroundControl.videoManager.stopVideo()
                 }
             }
         }

src/VideoManager/VideoManager.h

@@ -49,8 +49,12 @@ public:
     Q_PROPERTY(double           hfov                    READ    hfov                                        NOTIFY aspectRatioChanged)
     Q_PROPERTY(double           thermalHfov             READ    thermalHfov                                 NOTIFY aspectRatioChanged)
     Q_PROPERTY(bool             autoStreamConfigured    READ    autoStreamConfigured                        NOTIFY autoStreamConfiguredChanged)
-    Q_PROPERTY(bool             hasThermal              READ    hasThermal                                  NOTIFY aspectRatioChanged)
+    Q_PROPERTY(bool             hasThermal              READ    hasThermal                                  NOTIFY decodingChanged)
     Q_PROPERTY(QString          imageFile               READ    imageFile                                   NOTIFY imageFileChanged)
+    Q_PROPERTY(bool             streaming               READ    streaming                                   NOTIFY streamingChanged)
+    Q_PROPERTY(bool             decoding                READ    decoding                                    NOTIFY decodingChanged)
+    Q_PROPERTY(bool             recording               READ    recording                                   NOTIFY recordingChanged)
+    Q_PROPERTY(QSize            videoSize               READ    videoSize                                   NOTIFY videoSizeChanged)
 
     virtual bool        hasVideo            ();
     virtual bool        isGStreamer         ();
@@ -65,9 +69,27 @@ public:
     virtual bool        hasThermal          ();
     virtual QString     imageFile           ();
 
+    bool streaming(void) {
+        return _streaming;
+    }
 
-    virtual VideoReceiver*  videoReceiver           () { return _videoReceiver; }
-    virtual VideoReceiver*  thermalVideoReceiver    () { return _thermalVideoReceiver; }
+    bool decoding(void) {
+        return _decoding;
+    }
+
+    bool recording(void) {
+        return _recording;
+    }
+
+    QSize videoSize(void) {
+        const quint32 size = _videoSize;
+        return QSize((size >> 16) & 0xFFFF, size & 0xFFFF);
+    }
+
+// FIXME: AV: they should be removed after finishing multiple video stream support
+// new arcitecture does not assume direct access to video receiver from QML side, even if it works for now
+    virtual VideoReceiver*  videoReceiver           () { return _videoReceiver[0]; }
+    virtual VideoReceiver*  thermalVideoReceiver    () { return _videoReceiver[1]; }
 
 #if defined(QGC_DISABLE_UVC)
     virtual bool        uvcEnabled          () { return false; }
@@ -99,6 +121,11 @@ signals:
     void aspectRatioChanged         ();
     void autoStreamConfiguredChanged();
     void imageFileChanged           ();
+    void streamingChanged           ();
+    void decodingChanged            ();
+    void recordingChanged           ();
+    void recordingStarted           ();
+    void videoSizeChanged           ();
 
 protected slots:
     void _videoSourceChanged        ();
@@ -115,31 +142,37 @@ protected:
     friend class FinishVideoInitialization;
 
     void _initVideo                 ();
-    void _updateSettings            ();
-    void _setVideoUri               (const QString& uri);
-    void _setThermalVideoUri        (const QString& uri);
+    bool _updateSettings            (unsigned id);
+    bool _updateVideoUri            (unsigned id, const QString& uri);
     void _cleanupOldVideos          ();
-    void _restartVideo              ();
-    void _streamingChanged          ();
-    void _recordingStarted          ();
-    void _recordingChanged          ();
-    void _screenshotComplete        ();
+    void _restartAllVideos          ();
+    void _restartVideo              (unsigned id);
+    void _startReceiver             (unsigned id);
+    void _stopReceiver              (unsigned id);
 
 protected:
-    QString         _videoFile;
-    QString         _imageFile;
-    SubtitleWriter  _subtitleWriter;
-    bool            _isTaisync              = false;
-    VideoReceiver*  _videoReceiver          = nullptr;
-    VideoReceiver*  _thermalVideoReceiver   = nullptr;
-    void*           _videoSink              = nullptr;
-    void*           _thermalVideoSink       = nullptr;
-    VideoSettings*  _videoSettings          = nullptr;
-    QString         _videoUri;
-    QString         _thermalVideoUri;
-    QString         _videoSourceID;
-    bool            _fullScreen             = false;
-    Vehicle*        _activeVehicle          = nullptr;
+    QString                 _videoFile;
+    QString                 _imageFile;
+    SubtitleWriter          _subtitleWriter;
+    bool                    _isTaisync              = false;
+    VideoReceiver*          _videoReceiver[2]       = { nullptr, nullptr };
+    void*                   _videoSink[2]           = { nullptr, nullptr };
+    QString                 _videoUri[2];
+    // FIXME: AV: _videoStarted seems to be access from 3 different threads, from time to time
+    // 1) Video Receiver thread
+    // 2) Video Manager/main app thread
+    // 3) Qt rendering thread (during video sink creation process which should happen in this thread)
+    // It works for now but...
+    bool                    _videoStarted[2]        = { false, false };
+    bool                    _lowLatencyStreaming[2] = { false, false };
+    QAtomicInteger<bool>    _streaming              = false;
+    QAtomicInteger<bool>    _decoding               = false;
+    QAtomicInteger<bool>    _recording              = false;
+    QAtomicInteger<quint32> _videoSize              = 0;
+    VideoSettings*          _videoSettings          = nullptr;
+    QString                 _videoSourceID;
+    bool                    _fullScreen             = false;
+    Vehicle*                _activeVehicle          = nullptr;
 };
 
 #endif

src/VideoReceiver/GStreamer.cc

@@ -105,9 +105,28 @@ static void qgcputenv(const QString& key, const QString& root, const QString& pa
 }
 #endif
 
+static void
+blacklist()
+{
+    GstRegistry* reg;
+
+    if ((reg = gst_registry_get()) == nullptr) {
+        return;
+    }
+
+    GstPluginFeature* plugin;
+
+    if ((plugin = gst_registry_lookup_feature(reg, "bcmdec")) != nullptr) {
+        qCCritical(GStreamerLog) << "Disable bcmdec";
+        gst_plugin_feature_set_rank(plugin, GST_RANK_NONE);
+    }
+}
+
 void
 GStreamer::initialize(int argc, char* argv[], int debuglevel)
 {
+    qRegisterMetaType<VideoReceiver::STATUS>("STATUS");
+
 #ifdef Q_OS_MAC
     #ifdef QGC_INSTALL_RELEASE
         QString currentDir = QCoreApplication::applicationDirPath();
@@ -171,6 +190,8 @@ GStreamer::initialize(int argc, char* argv[], int debuglevel)
     gst_ios_post_init();
 #endif
 
+    blacklist();
+
     /* the plugin must be loaded before loading the qml file to register the
      * GstGLVideoItem qml item
      * FIXME Add a QQmlExtensionPlugin into qmlglsink to register GstGLVideoItem

src/VideoReceiver/GstVideoReceiver.h

@@ -89,7 +89,7 @@ public:
     ~GstVideoReceiver(void);
 
 public slots:
-    virtual void start(const QString& uri, unsigned timeout);
+    virtual void start(const QString& uri, unsigned timeout, int buffer = 0);
     virtual void stop(void);
     virtual void startDecoding(void* sink);
     virtual void stopDecoding(void);
@@ -102,11 +102,6 @@ protected slots:
     virtual void _handleEOS(void);
 
 protected:
-    void _setVideoSize(const QSize& size) {
-        _videoSize = ((quint32)size.width() << 16) | (quint32)size.height();
-        emit videoSizeChanged();
-    }
-
     virtual GstElement* _makeSource(const QString& uri);
     virtual GstElement* _makeDecoder(GstCaps* caps, GstElement* videoSink);
     virtual GstElement* _makeFileSink(const QString& videoFile, FILE_FORMAT format);
@@ -118,16 +113,19 @@ protected:
     virtual void _noteTeeFrame(void);
     virtual void _noteVideoSinkFrame(void);
     virtual void _noteEndOfStream(void);
-    virtual void _unlinkBranch(GstElement* from);
+    virtual bool _unlinkBranch(GstElement* from);
     virtual void _shutdownDecodingBranch (void);
     virtual void _shutdownRecordingBranch(void);
 
-private:
+    bool _needDispatch(void);
+    void _dispatchSignal(std::function<void()> emitter);
+
     static gboolean _onBusMessage(GstBus* bus, GstMessage* message, gpointer user_data);
     static void _onNewPad(GstElement* element, GstPad* pad, gpointer data);
     static void _wrapWithGhostPad(GstElement* element, GstPad* pad, gpointer data);
-    static void _linkPadWithOptionalBuffer(GstElement* element, GstPad* pad, gpointer data);
+    static void _linkPad(GstElement* element, GstPad* pad, gpointer data);
     static gboolean _padProbe(GstElement* element, GstPad* pad, gpointer user_data);
+    static gboolean _filterParserCaps(GstElement* bin, GstPad* pad, GstElement* element, GstQuery* query, gpointer data);
     static gboolean _autoplugQueryCaps(GstElement* bin, GstPad* pad, GstElement* element, GstQuery* query, gpointer data);
     static gboolean _autoplugQueryContext(GstElement* bin, GstPad* pad, GstElement* element, GstQuery* query, gpointer data);
     static gboolean _autoplugQuery(GstElement* bin, GstPad* pad, GstElement* element, GstQuery* query, gpointer data);
@@ -136,6 +134,9 @@ private:
     static GstPadProbeReturn _eosProbe(GstPad* pad, GstPadProbeInfo* info, gpointer user_data);
     static GstPadProbeReturn _keyframeWatch(GstPad* pad, GstPadProbeInfo* info, gpointer user_data);
 
+    bool                _streaming;
+    bool                _decoding;
+    bool                _recording;
     bool                _removingDecoder;
     bool                _removingRecorder;
     GstElement*         _source;
@@ -157,10 +158,12 @@ private:
     //-- RTSP UDP reconnect timeout
     uint64_t            _udpReconnect_us;
 
+    QString             _uri;
     unsigned            _timeout;
+    int                 _buffer;
 
-    Worker              _apiHandler;
-    Worker              _notificationHandler;
+    Worker              _slotHandler;
+    uint32_t            _signalDepth;
 
     bool                _endOfStream;
 

src/VideoReceiver/README.md

@@ -39,7 +39,7 @@ gst-launch-1.0 videotestsrc ! video/x-raw,width=640,height=480 ! videoconvert !
 
 On the receiving end, if you want to test it from the command line, you can use something like:
 ```
-gst-launch-1.0 udpsrc port=5600 caps='application/x-rtp, media=(string)video, clock-rate=(int)90000, encoding-name=(string)H264' ! rtph264depay ! h264parse ! avdec_h264 ! autovideosink fps-update-interval=1000 sync=false
+gst-launch-1.0 udpsrc port=5600 caps='application/x-rtp, media=(string)video, clock-rate=(int)90000, encoding-name=(string)H264' ! rtpjitterbuffer ! rtph264depay ! h264parse ! avdec_h264 ! autovideosink fps-update-interval=1000 sync=false
 ```
 
 ### Additional Protocols

src/VideoReceiver/VideoReceiver.h

@@ -17,9 +17,6 @@
 
 #include <QObject>
 #include <QSize>
-#include <QQuickItem>
-
-#include <atomic>
 
 class VideoReceiver : public QObject
 {
@@ -28,10 +25,6 @@ class VideoReceiver : public QObject
 public:
     explicit VideoReceiver(QObject* parent = nullptr)
         : QObject(parent)
-        , _streaming(false)
-        , _decoding(false)
-        , _recording(false)
-        , _videoSize(0)
     {}
 
     virtual ~VideoReceiver(void) {}
@@ -44,50 +37,42 @@ public:
         FILE_FORMAT_MAX
     } FILE_FORMAT;
 
-    Q_PROPERTY(bool     streaming   READ    streaming   NOTIFY  streamingChanged)
-    Q_PROPERTY(bool     decoding    READ    decoding    NOTIFY  decodingChanged)
-    Q_PROPERTY(bool     recording   READ    recording   NOTIFY  recordingChanged)
-    Q_PROPERTY(QSize    videoSize   READ    videoSize   NOTIFY  videoSizeChanged)
-
-    bool streaming(void) {
-        return _streaming;
-    }
-
-    bool decoding(void) {
-        return _decoding;
-    }
-
-    bool recording(void) {
-        return _recording;
-    }
+    typedef enum {
+        STATUS_OK = 0,
+        STATUS_FAIL,
+        STATUS_INVALID_STATE,
+        STATUS_INVALID_URL,
+        STATUS_NOT_IMPLEMENTED
+    } STATUS;
 
-    QSize videoSize(void) {
-        const quint32 size = _videoSize;
-        return QSize((size >> 16) & 0xFFFF, size & 0xFFFF);
-    }
+    Q_ENUM(STATUS)
 
 signals:
     void timeout(void);
-    void streamingChanged(void);
-    void decodingChanged(void);
-    void recordingChanged(void);
+    void streamingChanged(bool active);
+    void decodingChanged(bool active);
+    void recordingChanged(bool active);
     void recordingStarted(void);
-    void videoSizeChanged(void);
-    void screenshotComplete(void);
+    void videoSizeChanged(QSize size);
+
+    void onStartComplete(STATUS status);
+    void onStopComplete(STATUS status);
+    void onStartDecodingComplete(STATUS status);
+    void onStopDecodingComplete(STATUS status);
+    void onStartRecordingComplete(STATUS status);
+    void onStopRecordingComplete(STATUS status);
+    void onTakeScreenshotComplete(STATUS status);
 
 public slots:
-    virtual void start(const QString& uri, unsigned timeout) = 0;
+    // buffer:
+    //      -1 - disable buffer and video sync
+    //      0 - default buffer length
+    //      N - buffer length, ms
+    virtual void start(const QString& uri, unsigned timeout, int buffer = 0) = 0;
     virtual void stop(void) = 0;
     virtual void startDecoding(void* sink) = 0;
     virtual void stopDecoding(void) = 0;
     virtual void startRecording(const QString& videoFile, FILE_FORMAT format) = 0;
     virtual void stopRecording(void) = 0;
     virtual void takeScreenshot(const QString& imageFile) = 0;
-
-protected:
-    std::atomic<bool>   _streaming;
-    std::atomic<bool>   _decoding;
-    std::atomic<bool>   _recording;
-    std::atomic<quint32>_videoSize;
 };
-

src/api/QGCCorePlugin.cc

@@ -485,6 +485,15 @@ void* QGCCorePlugin::createVideoSink(QObject* parent, QQuickItem* widget)
 #endif
 }
 
+void QGCCorePlugin::releaseVideoSink(void* sink)
+{
+#if defined(QGC_GST_STREAMING)
+    GStreamer::releaseVideoSink(sink);
+#else
+    Q_UNUSED(sink)
+#endif
+}
+
 bool QGCCorePlugin::guidedActionsControllerLogging() const
 {
     return GuidedActionsControllerLog().isDebugEnabled();

src/api/QGCCorePlugin.h

@@ -119,6 +119,8 @@ public:
     virtual VideoReceiver* createVideoReceiver(QObject* parent);
     /// Allows the plugin to override the creation of VideoSink.
     virtual void* createVideoSink(QObject* parent, QQuickItem* widget);
+    /// Allows the plugin to override the release of VideoSink.
+    virtual void releaseVideoSink(void* sink);
 
     /// Allows the plugin to see all mavlink traffic to a vehicle
     /// @return true: Allow vehicle to continue processing, false: Vehicle should not process message