VideoReceiver.cc 32.3 KB
Newer Older
1 2 3 4 5 6 7 8
/****************************************************************************
 *
 *   (c) 2009-2016 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
 *
 * QGroundControl is licensed according to the terms in the file
 * COPYING.md in the root of the source code directory.
 *
 ****************************************************************************/
Gus Grubba's avatar
Gus Grubba committed
9 10 11 12 13 14 15 16 17


/**
 * @file
 *   @brief QGC Video Receiver
 *   @author Gus Grubba <mavlink@grubba.com>
 */

#include "VideoReceiver.h"
18 19
#include "SettingsManager.h"
#include "QGCApplication.h"
20
#include "VideoManager.h"
21 22 23
#ifdef QGC_GST_TAISYNC_ENABLED
#include "TaisyncHandler.h"
#endif
Gus Grubba's avatar
Gus Grubba committed
24
#include <QDebug>
25
#include <QUrl>
26 27
#include <QDir>
#include <QDateTime>
28
#include <QSysInfo>
29

30 31
QGC_LOGGING_CATEGORY(VideoReceiverLog, "VideoReceiverLog")

32 33
#if defined(QGC_GST_STREAMING)

34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
static const char* kVideoExtensions[] =
{
    "mkv",
    "mov",
    "mp4"
};

static const char* kVideoMuxes[] =
{
    "matroskamux",
    "qtmux",
    "mp4mux"
};

#define NUM_MUXES (sizeof(kVideoMuxes) / sizeof(char*))

50 51 52
#endif


Gus Grubba's avatar
Gus Grubba committed
53 54
VideoReceiver::VideoReceiver(QObject* parent)
    : QObject(parent)
55
#if defined(QGC_GST_STREAMING)
56
    , _running(false)
57
    , _recording(false)
58
    , _streaming(false)
59 60
    , _starting(false)
    , _stopping(false)
Gus Grubba's avatar
Gus Grubba committed
61 62 63 64 65 66
    , _sink(nullptr)
    , _tee(nullptr)
    , _pipeline(nullptr)
    , _pipelineStopRec(nullptr)
    , _videoSink(nullptr)
    , _socket(nullptr)
67
    , _serverPresent(false)
68
    , _rtspTestInterval_ms(5000)
69
    , _udpReconnect_us(5000000)
70
#endif
Gus Grubba's avatar
Gus Grubba committed
71
    , _videoSurface(nullptr)
72 73
    , _videoRunning(false)
    , _showFullScreen(false)
Gus Grubba's avatar
Gus Grubba committed
74
    , _videoSettings(nullptr)
Gus Grubba's avatar
Gus Grubba committed
75
{
76 77
    _videoSurface = new VideoSurface;
    _videoSettings = qgcApp()->toolbox()->settingsManager()->videoSettings();
78
#if defined(QGC_GST_STREAMING)
79
    _setVideoSink(_videoSurface->videoSink());
80 81
    _timer.setSingleShot(true);
    connect(&_timer, &QTimer::timeout, this, &VideoReceiver::_timeout);
82 83 84
    connect(this, &VideoReceiver::msgErrorReceived, this, &VideoReceiver::_handleError);
    connect(this, &VideoReceiver::msgEOSReceived, this, &VideoReceiver::_handleEOS);
    connect(this, &VideoReceiver::msgStateChangedReceived, this, &VideoReceiver::_handleStateChanged);
85 86
    connect(&_frameTimer, &QTimer::timeout, this, &VideoReceiver::_updateTimer);
    _frameTimer.start(1000);
87
#endif
Gus Grubba's avatar
Gus Grubba committed
88 89 90 91
}

VideoReceiver::~VideoReceiver()
{
92
#if defined(QGC_GST_STREAMING)
93 94 95 96
    stop();
    if(_socket) {
        delete _socket;
    }
97 98 99
    if (_videoSink) {
        gst_object_unref(_videoSink);
    }
100
#endif
101 102
    if(_videoSurface)
        delete _videoSurface;
Gus Grubba's avatar
Gus Grubba committed
103 104
}

105
#if defined(QGC_GST_STREAMING)
106 107
void
VideoReceiver::_setVideoSink(GstElement* sink)
Gus Grubba's avatar
Gus Grubba committed
108 109 110
{
    if (_videoSink) {
        gst_object_unref(_videoSink);
Gus Grubba's avatar
Gus Grubba committed
111
        _videoSink = nullptr;
Gus Grubba's avatar
Gus Grubba committed
112 113 114 115 116 117
    }
    if (sink) {
        _videoSink = sink;
        gst_object_ref_sink(_videoSink);
    }
}
118
#endif
Gus Grubba's avatar
Gus Grubba committed
119

120 121 122 123 124 125 126 127 128
//-----------------------------------------------------------------------------
void
VideoReceiver::grabImage(QString imageFile)
{
    _imageFile = imageFile;
    emit imageFileChanged();
}

//-----------------------------------------------------------------------------
129
#if defined(QGC_GST_STREAMING)
130 131
static void
newPadCB(GstElement* element, GstPad* pad, gpointer data)
132
{
133
    gchar* name;
134
    name = gst_pad_get_name(pad);
135
    //g_print("A new pad %s was created\n", name);
136 137
    GstCaps* p_caps = gst_pad_get_pad_template_caps (pad);
    gchar* description = gst_caps_to_string(p_caps);
138
    qCDebug(VideoReceiverLog) << p_caps << ", " << description;
139
    g_free(description);
140 141
    GstElement* sink = GST_ELEMENT(data);
    if(gst_element_link_pads(element, name, sink, "sink") == false)
142 143 144
        qCritical() << "newPadCB : failed to link elements\n";
    g_free(name);
}
145
#endif
146

147
//-----------------------------------------------------------------------------
148
#if defined(QGC_GST_STREAMING)
149 150
void
VideoReceiver::_connected()
151 152 153
{
    //-- Server showed up. Now we start the stream.
    _timer.stop();
154
    _socket->deleteLater();
Gus Grubba's avatar
Gus Grubba committed
155
    _socket = nullptr;
156
    if(_videoSettings->streamEnabled()->rawValue().toBool()) {
Gus Grubba's avatar
Gus Grubba committed
157 158 159
        _serverPresent = true;
        start();
    }
160 161 162
}
#endif

163
//-----------------------------------------------------------------------------
164
#if defined(QGC_GST_STREAMING)
165 166
void
VideoReceiver::_socketError(QAbstractSocket::SocketError socketError)
167 168
{
    Q_UNUSED(socketError);
169
    _socket->deleteLater();
Gus Grubba's avatar
Gus Grubba committed
170
    _socket = nullptr;
171
    //-- Try again in a while
172
    if(_videoSettings->streamEnabled()->rawValue().toBool()) {
173
        _timer.start(_rtspTestInterval_ms);
Gus Grubba's avatar
Gus Grubba committed
174
    }
175 176 177
}
#endif

178
//-----------------------------------------------------------------------------
179
#if defined(QGC_GST_STREAMING)
180 181
void
VideoReceiver::_timeout()
182 183 184 185
{
    //-- If socket is live, we got no connection nor a socket error
    if(_socket) {
        delete _socket;
Gus Grubba's avatar
Gus Grubba committed
186
        _socket = nullptr;
187
    }
188
    if(_videoSettings->streamEnabled()->rawValue().toBool()) {
Gus Grubba's avatar
Gus Grubba committed
189 190 191 192 193
        //-- RTSP will try to connect to the server. If it cannot connect,
        //   it will simply give up and never try again. Instead, we keep
        //   attempting a connection on this timer. Once a connection is
        //   found to be working, only then we actually start the stream.
        QUrl url(_uri);
194 195 196 197
        //-- If RTSP and no port is defined, set default RTSP port (554)
        if(_uri.contains("rtsp://") && url.port() <= 0) {
            url.setPort(554);
        }
Gus Grubba's avatar
Gus Grubba committed
198
        _socket = new QTcpSocket;
199 200 201
        QNetworkProxy tempProxy;
        tempProxy.setType(QNetworkProxy::DefaultProxy);
        _socket->setProxy(tempProxy);
Gus Grubba's avatar
Gus Grubba committed
202 203
        connect(_socket, static_cast<void (QTcpSocket::*)(QAbstractSocket::SocketError)>(&QTcpSocket::error), this, &VideoReceiver::_socketError);
        connect(_socket, &QTcpSocket::connected, this, &VideoReceiver::_connected);
Gus Grubba's avatar
Gus Grubba committed
204
        _socket->connectToHost(url.host(), static_cast<uint16_t>(url.port()));
205
        _timer.start(_rtspTestInterval_ms);
Gus Grubba's avatar
Gus Grubba committed
206
    }
207 208 209
}
#endif

210
//-----------------------------------------------------------------------------
211 212 213 214 215 216 217 218 219
// When we finish our pipeline will look like this:
//
//                                   +-->queue-->decoder-->_videosink
//                                   |
//    datasource-->demux-->parser-->tee
//
//                                   ^
//                                   |
//                                   +-Here we will later link elements for recording
220 221
void
VideoReceiver::start()
Gus Grubba's avatar
Gus Grubba committed
222
{
Gus Grubba's avatar
Gus Grubba committed
223 224
    qCDebug(VideoReceiverLog) << "start():" << _uri;
    if(qgcApp()->runningUnitTests()) {
225 226
        return;
    }
227 228
    if(!_videoSettings->streamEnabled()->rawValue().toBool() ||
       !_videoSettings->streamConfigured()) {
229 230 231
        qCDebug(VideoReceiverLog) << "start() but not enabled/configured";
        return;
    }
232
#if defined(QGC_GST_STREAMING)
233
    _stop = false;
234 235
    qCDebug(VideoReceiverLog) << "start()";

236 237
#if  defined(QGC_GST_TAISYNC_ENABLED) && (defined(__android__) || defined(__ios__))
    //-- Taisync on iOS or Android sends a raw h.264 stream
238 239 240 241
    bool isTaisyncUSB = qgcApp()->toolbox()->videoManager()->isTaisync();
#else
    bool isTaisyncUSB = false;
#endif
242 243 244 245
    bool isUdp      = _uri.contains("udp://")  && !isTaisyncUSB;
    bool isRtsp     = _uri.contains("rtsp://") && !isTaisyncUSB;
    bool isTCP      = _uri.contains("tcp://")  && !isTaisyncUSB;
    bool isMPEGTS   = _uri.contains("mpegts://")  && !isTaisyncUSB;
246 247

    if (!isTaisyncUSB && _uri.isEmpty()) {
Gus Grubba's avatar
Gus Grubba committed
248 249 250
        qCritical() << "VideoReceiver::start() failed because URI is not specified";
        return;
    }
Gus Grubba's avatar
Gus Grubba committed
251
    if (_videoSink == nullptr) {
Gus Grubba's avatar
Gus Grubba committed
252 253 254
        qCritical() << "VideoReceiver::start() failed because video sink is not set";
        return;
    }
255 256 257 258
    if(_running) {
        qCDebug(VideoReceiverLog) << "Already running!";
        return;
    }
Gus Grubba's avatar
Gus Grubba committed
259

260
    _starting = true;
261

262 263
    //-- For RTSP and TCP, check to see if server is there first
    if(!_serverPresent && (isRtsp || isTCP)) {
264 265 266 267
        _timer.start(100);
        return;
    }

268
    bool running    = false;
269
    bool pipelineUp = false;
Gus Grubba's avatar
Gus Grubba committed
270

Gus Grubba's avatar
Gus Grubba committed
271 272 273 274 275 276 277
    GstElement*     dataSource  = nullptr;
    GstCaps*        caps        = nullptr;
    GstElement*     demux       = nullptr;
    GstElement*     parser      = nullptr;
    GstElement*     queue       = nullptr;
    GstElement*     decoder     = nullptr;
    GstElement*     queue1      = nullptr;
278

Gus Grubba's avatar
Gus Grubba committed
279
    do {
Gus Grubba's avatar
Gus Grubba committed
280
        if ((_pipeline = gst_pipeline_new("receiver")) == nullptr) {
281
            qCritical() << "VideoReceiver::start() failed. Error with gst_pipeline_new()";
Gus Grubba's avatar
Gus Grubba committed
282 283 284
            break;
        }

285
        if(isUdp || isMPEGTS || isTaisyncUSB) {
286
            dataSource = gst_element_factory_make("udpsrc", "udp-source");
287 288
        } else if(isTCP) {
            dataSource = gst_element_factory_make("tcpclientsrc", "tcpclient-source");
289 290
        } else {
            dataSource = gst_element_factory_make("rtspsrc", "rtsp-source");
Gus Grubba's avatar
Gus Grubba committed
291 292
        }

293 294
        if (!dataSource) {
            qCritical() << "VideoReceiver::start() failed. Error with data source for gst_element_factory_make()";
Gus Grubba's avatar
Gus Grubba committed
295 296 297
            break;
        }

298
        if(isUdp) {
Gus Grubba's avatar
Gus Grubba committed
299
            if ((caps = gst_caps_from_string("application/x-rtp, media=(string)video, clock-rate=(int)90000, encoding-name=(string)H264")) == nullptr) {
300 301 302
                qCritical() << "VideoReceiver::start() failed. Error with gst_caps_from_string()";
                break;
            }
303
            g_object_set(static_cast<gpointer>(dataSource), "uri", qPrintable(_uri), "caps", caps, nullptr);
304
#if  defined(QGC_GST_TAISYNC_ENABLED) && (defined(__android__) || defined(__ios__))
305 306 307 308 309
        } else if(isTaisyncUSB) {
            QString uri = QString("0.0.0.0:%1").arg(TAISYNC_VIDEO_UDP_PORT);
            qCDebug(VideoReceiverLog) << "Taisync URI:" << uri;
            g_object_set(static_cast<gpointer>(dataSource), "port", TAISYNC_VIDEO_UDP_PORT, nullptr);
#endif
310 311
        } else if(isTCP) {
            QUrl url(_uri);
312
            g_object_set(static_cast<gpointer>(dataSource), "host", qPrintable(url.host()), "port", url.port(), nullptr );
313 314 315
        } else if(isMPEGTS) {
            QUrl url(_uri);
            g_object_set(static_cast<gpointer>(dataSource), "port", url.port(), nullptr);
316
        } else {
317
            g_object_set(static_cast<gpointer>(dataSource), "location", qPrintable(_uri), "latency", 17, "udp-reconnect", 1, "timeout", _udpReconnect_us, NULL);
318
        }
Gus Grubba's avatar
Gus Grubba committed
319

320 321
        if (isTCP || isMPEGTS) {
            if ((demux = gst_element_factory_make("tsdemux", "mpeg-ts-demuxer")) == nullptr) {
322 323 324 325
                qCritical() << "VideoReceiver::start() failed. Error with gst_element_factory_make('tsdemux')";
                break;
            }
        } else {
326 327
            if(!isTaisyncUSB) {
                if ((demux = gst_element_factory_make("rtph264depay", "rtp-h264-depacketizer")) == nullptr) {
328 329 330
                   qCritical() << "VideoReceiver::start() failed. Error with gst_element_factory_make('rtph264depay')";
                    break;
                }
331
            }
332 333
        }

Gus Grubba's avatar
Gus Grubba committed
334
        if ((parser = gst_element_factory_make("h264parse", "h264-parser")) == nullptr) {
335
            qCritical() << "VideoReceiver::start() failed. Error with gst_element_factory_make('h264parse')";
Gus Grubba's avatar
Gus Grubba committed
336 337 338
            break;
        }

Gus Grubba's avatar
Gus Grubba committed
339
        if((_tee = gst_element_factory_make("tee", nullptr)) == nullptr)  {
340 341 342
            qCritical() << "VideoReceiver::start() failed. Error with gst_element_factory_make('tee')";
            break;
        }
Gus Grubba's avatar
Gus Grubba committed
343

Gus Grubba's avatar
Gus Grubba committed
344
        if((queue = gst_element_factory_make("queue", nullptr)) == nullptr)  {
345 346
            // TODO: We may want to add queue2 max-size-buffers=1 to get lower latency
            //       We should compare gstreamer scripts to QGroundControl to determine the need
347
            qCritical() << "VideoReceiver::start() failed. Error with gst_element_factory_make('queue')";
348 349
            break;
        }
350

Gus Grubba's avatar
Gus Grubba committed
351
        if ((decoder = gst_element_factory_make("avdec_h264", "h264-decoder")) == nullptr) {
352 353 354 355
            qCritical() << "VideoReceiver::start() failed. Error with gst_element_factory_make('avdec_h264')";
            break;
        }

Gus Grubba's avatar
Gus Grubba committed
356
        if ((queue1 = gst_element_factory_make("queue", nullptr)) == nullptr) {
357 358 359 360
            qCritical() << "VideoReceiver::start() failed. Error with gst_element_factory_make('queue') [1]";
            break;
        }

361 362 363 364 365
        if(isTaisyncUSB) {
            gst_bin_add_many(GST_BIN(_pipeline), dataSource, parser, _tee, queue, decoder, queue1, _videoSink, nullptr);
        } else {
            gst_bin_add_many(GST_BIN(_pipeline), dataSource, demux, parser, _tee, queue, decoder, queue1, _videoSink, nullptr);
        }
366
        pipelineUp = true;
367

368 369
        if(isUdp) {
            // Link the pipeline in front of the tee
Gus Grubba's avatar
Gus Grubba committed
370
            if(!gst_element_link_many(dataSource, demux, parser, _tee, queue, decoder, queue1, _videoSink, nullptr)) {
371 372 373
                qCritical() << "Unable to link UDP elements.";
                break;
            }
374 375 376 377 378 379
        } else if(isTaisyncUSB) {
            // Link the pipeline in front of the tee
            if(!gst_element_link_many(dataSource, parser, _tee, queue, decoder, queue1, _videoSink, nullptr)) {
                qCritical() << "Unable to link Taisync USB elements.";
                break;
            }
380
        } else if (isTCP || isMPEGTS) {
381
            if(!gst_element_link(dataSource, demux)) {
382
                qCritical() << "Unable to link TCP/MPEG-TS dataSource to Demux.";
383 384
                break;
            }
Gus Grubba's avatar
Gus Grubba committed
385
            if(!gst_element_link_many(parser, _tee, queue, decoder, queue1, _videoSink, nullptr)) {
386
                qCritical() << "Unable to link TCP/MPEG-TS pipline to parser.";
387 388
                break;
            }
389
            g_signal_connect(demux, "pad-added", G_CALLBACK(newPadCB), parser);
390
        } else {
391
            g_signal_connect(dataSource, "pad-added", G_CALLBACK(newPadCB), demux);
Gus Grubba's avatar
Gus Grubba committed
392
            if(!gst_element_link_many(demux, parser, _tee, queue, decoder, _videoSink, nullptr)) {
393
                qCritical() << "Unable to link RTSP elements.";
394 395
                break;
            }
396 397
        }

Gus Grubba's avatar
Gus Grubba committed
398
        dataSource = demux = parser = queue = decoder = queue1 = nullptr;
Gus Grubba's avatar
Gus Grubba committed
399

Gus Grubba's avatar
Gus Grubba committed
400
        GstBus* bus = nullptr;
Gus Grubba's avatar
Gus Grubba committed
401

Gus Grubba's avatar
Gus Grubba committed
402
        if ((bus = gst_pipeline_get_bus(GST_PIPELINE(_pipeline))) != nullptr) {
403 404 405
            gst_bus_enable_sync_message_emission(bus);
            g_signal_connect(bus, "sync-message", G_CALLBACK(_onBusMessage), this);
            gst_object_unref(bus);
Gus Grubba's avatar
Gus Grubba committed
406
            bus = nullptr;
407
        }
Gus Grubba's avatar
Gus Grubba committed
408

409
        GST_DEBUG_BIN_TO_DOT_FILE(GST_BIN(_pipeline), GST_DEBUG_GRAPH_SHOW_ALL, "pipeline-paused");
Gus Grubba's avatar
Gus Grubba committed
410 411 412 413
        running = gst_element_set_state(_pipeline, GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE;

    } while(0);

Gus Grubba's avatar
Gus Grubba committed
414
    if (caps != nullptr) {
Gus Grubba's avatar
Gus Grubba committed
415
        gst_caps_unref(caps);
Gus Grubba's avatar
Gus Grubba committed
416
        caps = nullptr;
Gus Grubba's avatar
Gus Grubba committed
417 418 419 420 421
    }

    if (!running) {
        qCritical() << "VideoReceiver::start() failed";

422
        // In newer versions, the pipeline will clean up all references that are added to it
Gus Grubba's avatar
Gus Grubba committed
423
        if (_pipeline != nullptr) {
424
            gst_object_unref(_pipeline);
Gus Grubba's avatar
Gus Grubba committed
425
            _pipeline = nullptr;
Gus Grubba's avatar
Gus Grubba committed
426 427
        }

428 429
        // If we failed before adding items to the pipeline, then clean up
        if (!pipelineUp) {
Gus Grubba's avatar
Gus Grubba committed
430
            if (decoder != nullptr) {
431
                gst_object_unref(decoder);
Gus Grubba's avatar
Gus Grubba committed
432
                decoder = nullptr;
433
            }
Gus Grubba's avatar
Gus Grubba committed
434

Gus Grubba's avatar
Gus Grubba committed
435
            if (parser != nullptr) {
436
                gst_object_unref(parser);
Gus Grubba's avatar
Gus Grubba committed
437
                parser = nullptr;
438
            }
Gus Grubba's avatar
Gus Grubba committed
439

Gus Grubba's avatar
Gus Grubba committed
440
            if (demux != nullptr) {
441
                gst_object_unref(demux);
Gus Grubba's avatar
Gus Grubba committed
442
                demux = nullptr;
443
            }
Gus Grubba's avatar
Gus Grubba committed
444

Gus Grubba's avatar
Gus Grubba committed
445
            if (dataSource != nullptr) {
446
                gst_object_unref(dataSource);
Gus Grubba's avatar
Gus Grubba committed
447
                dataSource = nullptr;
448
            }
449

Gus Grubba's avatar
Gus Grubba committed
450
            if (_tee != nullptr) {
451
                gst_object_unref(_tee);
Gus Grubba's avatar
Gus Grubba committed
452
                dataSource = nullptr;
453
            }
454

Gus Grubba's avatar
Gus Grubba committed
455
            if (queue != nullptr) {
456
                gst_object_unref(queue);
Gus Grubba's avatar
Gus Grubba committed
457
                dataSource = nullptr;
458
            }
Gus Grubba's avatar
Gus Grubba committed
459
        }
460 461 462

        _running = false;
    } else {
463
        GST_DEBUG_BIN_TO_DOT_FILE(GST_BIN(_pipeline), GST_DEBUG_GRAPH_SHOW_ALL, "pipeline-playing");
464 465
        _running = true;
        qCDebug(VideoReceiverLog) << "Running";
Gus Grubba's avatar
Gus Grubba committed
466
    }
467
    _starting = false;
468
#endif
Gus Grubba's avatar
Gus Grubba committed
469 470
}

471 472 473
//-----------------------------------------------------------------------------
void
VideoReceiver::stop()
Gus Grubba's avatar
Gus Grubba committed
474
{
475
    if(qgcApp() && qgcApp()->runningUnitTests()) {
476 477
        return;
    }
478
#if defined(QGC_GST_STREAMING)
479
    _stop = true;
480
    qCDebug(VideoReceiverLog) << "stop()";
481 482
    if(!_streaming) {
        _shutdownPipeline();
Gus Grubba's avatar
Gus Grubba committed
483
    } else if (_pipeline != nullptr && !_stopping) {
484 485 486 487
        qCDebug(VideoReceiverLog) << "Stopping _pipeline";
        gst_element_send_event(_pipeline, gst_event_new_eos());
        _stopping = true;
        GstBus* bus = gst_pipeline_get_bus(GST_PIPELINE(_pipeline));
488
        GstMessage* message = gst_bus_timed_pop_filtered(bus, GST_CLOCK_TIME_NONE, (GstMessageType)(GST_MESSAGE_EOS|GST_MESSAGE_ERROR));
489
        gst_object_unref(bus);
490 491 492 493 494 495
        if(GST_MESSAGE_TYPE(message) == GST_MESSAGE_ERROR) {
            _shutdownPipeline();
            qCritical() << "Error stopping pipeline!";
        } else if(GST_MESSAGE_TYPE(message) == GST_MESSAGE_EOS) {
            _handleEOS();
        }
496
        gst_message_unref(message);
Gus Grubba's avatar
Gus Grubba committed
497
    }
498
#endif
Gus Grubba's avatar
Gus Grubba committed
499 500
}

501 502 503
//-----------------------------------------------------------------------------
void
VideoReceiver::setUri(const QString & uri)
Gus Grubba's avatar
Gus Grubba committed
504 505 506 507
{
    _uri = uri;
}

508
//-----------------------------------------------------------------------------
509
#if defined(QGC_GST_STREAMING)
510 511
void
VideoReceiver::_shutdownPipeline() {
512 513 514 515
    if(!_pipeline) {
        qCDebug(VideoReceiverLog) << "No pipeline";
        return;
    }
Gus Grubba's avatar
Gus Grubba committed
516 517
    GstBus* bus = nullptr;
    if ((bus = gst_pipeline_get_bus(GST_PIPELINE(_pipeline))) != nullptr) {
518 519
        gst_bus_disable_sync_message_emission(bus);
        gst_object_unref(bus);
Gus Grubba's avatar
Gus Grubba committed
520
        bus = nullptr;
521 522 523 524
    }
    gst_element_set_state(_pipeline, GST_STATE_NULL);
    gst_bin_remove(GST_BIN(_pipeline), _videoSink);
    gst_object_unref(_pipeline);
Gus Grubba's avatar
Gus Grubba committed
525
    _pipeline = nullptr;
526
    delete _sink;
Gus Grubba's avatar
Gus Grubba committed
527
    _sink = nullptr;
528 529 530 531 532 533 534
    _serverPresent = false;
    _streaming = false;
    _recording = false;
    _stopping = false;
    _running = false;
    emit recordingChanged();
}
535
#endif
536

537
//-----------------------------------------------------------------------------
538
#if defined(QGC_GST_STREAMING)
539 540
void
VideoReceiver::_handleError() {
541
    qCDebug(VideoReceiverLog) << "Gstreamer error!";
542 543
    stop();
    start();
544 545 546
}
#endif

547
//-----------------------------------------------------------------------------
548
#if defined(QGC_GST_STREAMING)
549 550
void
VideoReceiver::_handleEOS() {
551 552
    if(_stopping) {
        _shutdownPipeline();
553
        qCDebug(VideoReceiverLog) << "Stopped";
554 555 556
    } else if(_recording && _sink->removing) {
        _shutdownRecordingBranch();
    } else {
557
        qWarning() << "VideoReceiver: Unexpected EOS!";
558 559
        stop();
        start();
Gus Grubba's avatar
Gus Grubba committed
560 561
    }
}
562
#endif
Gus Grubba's avatar
Gus Grubba committed
563

564
//-----------------------------------------------------------------------------
565
#if defined(QGC_GST_STREAMING)
566 567 568 569 570 571
void
VideoReceiver::_handleStateChanged() {
    if(_pipeline) {
        _streaming = GST_STATE(_pipeline) == GST_STATE_PLAYING;
        qCDebug(VideoReceiverLog) << "State changed, _streaming:" << _streaming;
    }
572 573 574
}
#endif

575
//-----------------------------------------------------------------------------
576
#if defined(QGC_GST_STREAMING)
577 578
gboolean
VideoReceiver::_onBusMessage(GstBus* bus, GstMessage* msg, gpointer data)
Gus Grubba's avatar
Gus Grubba committed
579 580
{
    Q_UNUSED(bus)
Gus Grubba's avatar
Gus Grubba committed
581
    Q_ASSERT(msg != nullptr && data != nullptr);
Gus Grubba's avatar
Gus Grubba committed
582
    VideoReceiver* pThis = (VideoReceiver*)data;
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604

    switch(GST_MESSAGE_TYPE(msg)) {
    case(GST_MESSAGE_ERROR): {
        gchar* debug;
        GError* error;
        gst_message_parse_error(msg, &error, &debug);
        g_free(debug);
        qCritical() << error->message;
        g_error_free(error);
        pThis->msgErrorReceived();
    }
        break;
    case(GST_MESSAGE_EOS):
        pThis->msgEOSReceived();
        break;
    case(GST_MESSAGE_STATE_CHANGED):
        pThis->msgStateChangedReceived();
        break;
    default:
        break;
    }

Gus Grubba's avatar
Gus Grubba committed
605 606
    return TRUE;
}
607
#endif
608

609
//-----------------------------------------------------------------------------
610
#if defined(QGC_GST_STREAMING)
611 612
void
VideoReceiver::_cleanupOldVideos()
613
{
614
    //-- Only perform cleanup if storage limit is enabled
615
    if(_videoSettings->enableStorageLimit()->rawValue().toBool()) {
616 617 618 619 620 621 622 623
        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]);
624
        }
625 626 627 628 629 630
        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
631
            uint64_t maxSize = (_videoSettings->maxVideoSize()->rawValue().toUInt() * 1024 * 1024);
632 633 634 635 636 637 638 639 640 641 642 643
            //-- 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();
            }
644 645 646
        }
    }
}
647
#endif
648

649
//-----------------------------------------------------------------------------
650 651 652 653 654 655 656 657 658 659 660
// When we finish our pipeline will look like this:
//
//                                   +-->queue-->decoder-->_videosink
//                                   |
//    datasource-->demux-->parser-->tee
//                                   |
//                                   |    +--------------_sink-------------------+
//                                   |    |                                      |
//   we are adding these elements->  +->teepad-->queue-->matroskamux-->_filesink |
//                                        |                                      |
//                                        +--------------------------------------+
661
void
662
VideoReceiver::startRecording(const QString &videoFile)
663
{
664
#if defined(QGC_GST_STREAMING)
665

666 667
    qCDebug(VideoReceiverLog) << "startRecording()";
    // exit immediately if we are already recording
Gus Grubba's avatar
Gus Grubba committed
668
    if(_pipeline == nullptr || _recording) {
669 670 671 672
        qCDebug(VideoReceiverLog) << "Already recording!";
        return;
    }

673
    uint32_t muxIdx = _videoSettings->recordingFormat()->rawValue().toUInt();
674 675 676 677 678 679 680 681
    if(muxIdx >= NUM_MUXES) {
        qgcApp()->showMessage(tr("Invalid video format defined."));
        return;
    }

    //-- Disk usage maintenance
    _cleanupOldVideos();

682
    _sink           = new Sink();
683
    _sink->teepad   = gst_element_get_request_pad(_tee, "src_%u");
Gus Grubba's avatar
Gus Grubba committed
684 685 686 687
    _sink->queue    = gst_element_factory_make("queue", nullptr);
    _sink->parse    = gst_element_factory_make("h264parse", nullptr);
    _sink->mux      = gst_element_factory_make(kVideoMuxes[muxIdx], nullptr);
    _sink->filesink = gst_element_factory_make("filesink", nullptr);
688 689
    _sink->removing = false;

690
    if(!_sink->teepad || !_sink->queue || !_sink->mux || !_sink->filesink || !_sink->parse) {
691 692 693 694
        qCritical() << "VideoReceiver::startRecording() failed to make _sink elements";
        return;
    }

695 696 697 698 699 700 701 702 703 704 705
    if(videoFile.isEmpty()) {
        QString savePath = qgcApp()->toolbox()->settingsManager()->appSettings()->videoSavePath();
        if(savePath.isEmpty()) {
            qgcApp()->showMessage(tr("Unabled to record video. Video save path must be specified in Settings."));
            return;
        }
        _videoFile = savePath + "/" + QDateTime::currentDateTime().toString("yyyy-MM-dd_hh.mm.ss") + "." + kVideoExtensions[muxIdx];
    } else {
        _videoFile = videoFile;
    }
    emit videoFileChanged();
706

707
    g_object_set(static_cast<gpointer>(_sink->filesink), "location", qPrintable(_videoFile), nullptr);
708
    qCDebug(VideoReceiverLog) << "New video file:" << _videoFile;
709 710

    gst_object_ref(_sink->queue);
711
    gst_object_ref(_sink->parse);
712 713 714
    gst_object_ref(_sink->mux);
    gst_object_ref(_sink->filesink);

Gus Grubba's avatar
Gus Grubba committed
715 716
    gst_bin_add_many(GST_BIN(_pipeline), _sink->queue, _sink->parse, _sink->mux, _sink->filesink, nullptr);
    gst_element_link_many(_sink->queue, _sink->parse, _sink->mux, _sink->filesink, nullptr);
717 718

    gst_element_sync_state_with_parent(_sink->queue);
719
    gst_element_sync_state_with_parent(_sink->parse);
720 721 722
    gst_element_sync_state_with_parent(_sink->mux);
    gst_element_sync_state_with_parent(_sink->filesink);

723 724 725 726
    // Install a probe on the recording branch to drop buffers until we hit our first keyframe
    // When we hit our first keyframe, we can offset the timestamps appropriately according to the first keyframe time
    // This will ensure the first frame is a keyframe at t=0, and decoding can begin immediately on playback
    GstPad* probepad = gst_element_get_static_pad(_sink->queue, "src");
Gus Grubba's avatar
Gus Grubba committed
727
    gst_pad_add_probe(probepad, (GstPadProbeType)(GST_PAD_PROBE_TYPE_BUFFER /* | GST_PAD_PROBE_TYPE_BLOCK */), _keyframeWatch, this, nullptr); // to drop the buffer or to block the buffer?
728 729 730
    gst_object_unref(probepad);

    // Link the recording branch to the pipeline
731 732 733 734
    GstPad* sinkpad = gst_element_get_static_pad(_sink->queue, "sink");
    gst_pad_link(_sink->teepad, sinkpad);
    gst_object_unref(sinkpad);

735 736
    GST_DEBUG_BIN_TO_DOT_FILE(GST_BIN(_pipeline), GST_DEBUG_GRAPH_SHOW_ALL, "pipeline-recording");

737 738 739
    _recording = true;
    emit recordingChanged();
    qCDebug(VideoReceiverLog) << "Recording started";
DonLakeFlyer's avatar
DonLakeFlyer committed
740 741
#else
    Q_UNUSED(videoFile)
742 743 744
#endif
}

745 746 747
//-----------------------------------------------------------------------------
void
VideoReceiver::stopRecording(void)
748
{
749
#if defined(QGC_GST_STREAMING)
750 751
    qCDebug(VideoReceiverLog) << "stopRecording()";
    // exit immediately if we are not recording
Gus Grubba's avatar
Gus Grubba committed
752
    if(_pipeline == nullptr || !_recording) {
753 754 755 756
        qCDebug(VideoReceiverLog) << "Not recording!";
        return;
    }
    // Wait for data block before unlinking
Gus Grubba's avatar
Gus Grubba committed
757
    gst_pad_add_probe(_sink->teepad, GST_PAD_PROBE_TYPE_IDLE, _unlinkCallBack, this, nullptr);
758 759 760
#endif
}

761
//-----------------------------------------------------------------------------
762 763 764 765 766 767
// This is only installed on the transient _pipelineStopRec in order
// to finalize a video file. It is not used for the main _pipeline.
// -EOS has appeared on the bus of the temporary pipeline
// -At this point all of the recoring elements have been flushed, and the video file has been finalized
// -Now we can remove the temporary pipeline and its elements
#if defined(QGC_GST_STREAMING)
768 769
void
VideoReceiver::_shutdownRecordingBranch()
770 771
{
    gst_bin_remove(GST_BIN(_pipelineStopRec), _sink->queue);
772
    gst_bin_remove(GST_BIN(_pipelineStopRec), _sink->parse);
773 774 775 776 777
    gst_bin_remove(GST_BIN(_pipelineStopRec), _sink->mux);
    gst_bin_remove(GST_BIN(_pipelineStopRec), _sink->filesink);

    gst_element_set_state(_pipelineStopRec, GST_STATE_NULL);
    gst_object_unref(_pipelineStopRec);
Gus Grubba's avatar
Gus Grubba committed
778
    _pipelineStopRec = nullptr;
779

780 781 782 783
    gst_element_set_state(_sink->filesink,  GST_STATE_NULL);
    gst_element_set_state(_sink->parse,     GST_STATE_NULL);
    gst_element_set_state(_sink->mux,       GST_STATE_NULL);
    gst_element_set_state(_sink->queue,     GST_STATE_NULL);
784 785

    gst_object_unref(_sink->queue);
786
    gst_object_unref(_sink->parse);
787 788 789 790
    gst_object_unref(_sink->mux);
    gst_object_unref(_sink->filesink);

    delete _sink;
Gus Grubba's avatar
Gus Grubba committed
791
    _sink = nullptr;
792
    _recording = false;
793

794 795 796 797 798
    emit recordingChanged();
    qCDebug(VideoReceiverLog) << "Recording Stopped";
}
#endif

799
//-----------------------------------------------------------------------------
800 801 802 803 804
// -Unlink the recording branch from the tee in the main _pipeline
// -Create a second temporary pipeline, and place the recording branch elements into that pipeline
// -Setup watch and handler for EOS event on the temporary pipeline's bus
// -Send an EOS event at the beginning of that pipeline
#if defined(QGC_GST_STREAMING)
805 806
void
VideoReceiver::_detachRecordingBranch(GstPadProbeInfo* info)
807 808 809 810
{
    Q_UNUSED(info)

    // Also unlinks and unrefs
Gus Grubba's avatar
Gus Grubba committed
811
    gst_bin_remove_many(GST_BIN(_pipeline), _sink->queue, _sink->parse, _sink->mux, _sink->filesink, nullptr);
812 813 814 815 816 817 818 819 820

    // Give tee its pad back
    gst_element_release_request_pad(_tee, _sink->teepad);
    gst_object_unref(_sink->teepad);

    // Create temporary pipeline
    _pipelineStopRec = gst_pipeline_new("pipeStopRec");

    // Put our elements from the recording branch into the temporary pipeline
Gus Grubba's avatar
Gus Grubba committed
821 822
    gst_bin_add_many(GST_BIN(_pipelineStopRec), _sink->queue, _sink->parse, _sink->mux, _sink->filesink, nullptr);
    gst_element_link_many(_sink->queue, _sink->parse, _sink->mux, _sink->filesink, nullptr);
823

824 825 826
    // Add handler for EOS event
    GstBus* bus = gst_pipeline_get_bus(GST_PIPELINE(_pipelineStopRec));
    gst_bus_enable_sync_message_emission(bus);
827
    g_signal_connect(bus, "sync-message", G_CALLBACK(_onBusMessage), this);
828
    gst_object_unref(bus);
829 830 831 832 833 834 835 836 837 838 839 840 841

    if(gst_element_set_state(_pipelineStopRec, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE) {
        qCDebug(VideoReceiverLog) << "problem starting _pipelineStopRec";
    }

    // Send EOS at the beginning of the pipeline
    GstPad* sinkpad = gst_element_get_static_pad(_sink->queue, "sink");
    gst_pad_send_event(sinkpad, gst_event_new_eos());
    gst_object_unref(sinkpad);
    qCDebug(VideoReceiverLog) << "Recording branch unlinked";
}
#endif

842
//-----------------------------------------------------------------------------
843
#if defined(QGC_GST_STREAMING)
844 845
GstPadProbeReturn
VideoReceiver::_unlinkCallBack(GstPad* pad, GstPadProbeInfo* info, gpointer user_data)
846 847
{
    Q_UNUSED(pad);
Gus Grubba's avatar
Gus Grubba committed
848 849
    if(info != nullptr && user_data != nullptr) {
        VideoReceiver* pThis = static_cast<VideoReceiver*>(user_data);
850 851 852 853 854
        // We will only act once
        if(g_atomic_int_compare_and_exchange(&pThis->_sink->removing, FALSE, TRUE)) {
            pThis->_detachRecordingBranch(info);
        }
    }
855 856 857
    return GST_PAD_PROBE_REMOVE;
}
#endif
858

859 860 861 862 863 864
//-----------------------------------------------------------------------------
#if defined(QGC_GST_STREAMING)
GstPadProbeReturn
VideoReceiver::_keyframeWatch(GstPad* pad, GstPadProbeInfo* info, gpointer user_data)
{
    Q_UNUSED(pad);
Gus Grubba's avatar
Gus Grubba committed
865
    if(info != nullptr && user_data != nullptr) {
866 867 868 869
        GstBuffer* buf = gst_pad_probe_info_get_buffer(info);
        if(GST_BUFFER_FLAG_IS_SET(buf, GST_BUFFER_FLAG_DELTA_UNIT)) { // wait for a keyframe
            return GST_PAD_PROBE_DROP;
        } else {
Gus Grubba's avatar
Gus Grubba committed
870
            VideoReceiver* pThis = static_cast<VideoReceiver*>(user_data);
871
            // reset the clock
Jacob Walser's avatar
Jacob Walser committed
872
            GstClock* clock = gst_pipeline_get_clock(GST_PIPELINE(pThis->_pipeline));
873 874 875 876 877 878 879 880 881 882 883 884 885
            GstClockTime time = gst_clock_get_time(clock);
            gst_object_unref(clock);
            gst_element_set_base_time(pThis->_pipeline, time); // offset pipeline timestamps to start at zero again
            buf->dts = 0; // The offset will not apply to this current buffer, our first frame, timestamp is zero
            buf->pts = 0;
            qCDebug(VideoReceiverLog) << "Got keyframe, stop dropping buffers";
        }
    }

    return GST_PAD_PROBE_REMOVE;
}
#endif

886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907
//-----------------------------------------------------------------------------
void
VideoReceiver::_updateTimer()
{
#if defined(QGC_GST_STREAMING)
    if(_videoSurface) {
        if(stopping() || starting()) {
            return;
        }
        if(streaming()) {
            if(!_videoRunning) {
                _videoSurface->setLastFrame(0);
                _videoRunning = true;
                emit videoRunningChanged();
            }
        } else {
            if(_videoRunning) {
                _videoRunning = false;
                emit videoRunningChanged();
            }
        }
        if(_videoRunning) {
908 909
            uint32_t timeout = 1;
            if(qgcApp()->toolbox() && qgcApp()->toolbox()->settingsManager()) {
910
                timeout = _videoSettings->rtspTimeout()->rawValue().toUInt();
911
            }
912 913 914
            time_t elapsed = 0;
            time_t lastFrame = _videoSurface->lastFrame();
            if(lastFrame != 0) {
Gus Grubba's avatar
Gus Grubba committed
915
                elapsed = time(nullptr) - _videoSurface->lastFrame();
916
            }
Gus Grubba's avatar
Gus Grubba committed
917
            if(elapsed > static_cast<time_t>(timeout) && _videoSurface) {
918
                stop();
919 920
                // We want to start it back again with _updateTimer
                _stop = false;
921 922
            }
        } else {
923
            if(!_stop && !running() && !_uri.isEmpty() && _videoSettings->streamEnabled()->rawValue().toBool()) {
924 925 926 927 928 929 930
                start();
            }
        }
    }
#endif
}