QGroundControl
Ground Control Station for MAVLink Drones
Loading...
Searching...
No Matches
VideoRecordingService.cc
Go to the documentation of this file.
2
3#include <algorithm>
4
5#include <QtConcurrent/QtConcurrentRun>
6#include <QtCore/QDateTime>
7#include <QtCore/QDir>
8#include <QtCore/QFileInfo>
9
10#include "AppMessages.h"
11#include "AppSettings.h"
12#include "Fact.h"
13#include "QGCLoggingCategory.h"
14#include "SettingsManager.h"
15#include "SubtitleWriter.h"
16#include "VideoSettings.h"
18
19QGC_LOGGING_CATEGORY(VideoRecordingServiceLog, "Video.VideoRecordingService")
20
21namespace {
22
23constexpr std::chrono::minutes kStorageLimitInterval{1};
24// A file written this recently may be a recording's that has yet to report its first frame.
25constexpr std::chrono::minutes kBeingWritten{1};
26
27} // namespace
28
29VideoRecordingService::VideoRecordingService(const QList<VideoStreamController*>& sources, QObject* parent)
30 : QObject(parent)
31 , _subtitleWriter(new SubtitleWriter(this))
32{
33 for (VideoStreamController* source : sources) {
34 addSource(source);
35 }
36
37 _storageLimitTimer.setInterval(kStorageLimitInterval);
38 (void) connect(&_storageLimitTimer, &QTimer::timeout, this, &VideoRecordingService::_applyStorageLimit);
39}
40
42
44{
45 _sources.append(source);
46 _connectRecordings(source);
47 // The telemetry goes with the video on display: the primary stream, or the camera in its place.
48 if (source->role() != VideoStreamController::Role::Thermal) {
49 _connectSubtitles(source);
50 }
51 (void) connect(source, &QObject::destroyed, this, [this, source] {
52 (void) _sources.removeOne(source);
53 _updateRecording();
54 });
55}
56
57void VideoRecordingService::_connectSubtitles(VideoStreamController* source)
58{
59 // Each file, including a stream's parts after a reconnect, gets its own subtitle file.
60 (void) connect(source, &VideoStreamController::recordingStarted, this, [this, source](const QString& file) {
61 // The recording holds the video as it arrives, without the rotation its outputs add.
62 const VideoReceiver* const receiver = source->receiver();
63 _subtitleWriter->startCapturingTelemetry(file, receiver ? receiver->videoSize() : QSize());
64 });
65 (void) connect(source, &VideoStreamController::recordingFinished, this, [this](const QString& file) {
66 if (file == _subtitleWriter->videoFile()) {
67 _subtitleWriter->stopCapturingTelemetry();
68 }
69 });
70 (void) connect(source, &VideoStreamController::recordingChanged, this, [this](bool recording) {
71 if (!recording) {
72 _subtitleWriter->stopCapturingTelemetry();
73 }
74 });
75}
76
77void VideoRecordingService::_connectRecordings(VideoStreamController* source)
78{
79 (void) connect(source, &VideoStreamController::recordingChanged, this, &VideoRecordingService::_updateRecording);
80 (void) connect(source, &VideoStreamController::recordingStarted, this, [this](const QString& file) {
81 qCDebug(VideoRecordingServiceLog) << "Recording to" << file;
82 _recordingFiles.insert(file);
83 });
84 (void) connect(source, &VideoStreamController::recordingFinished, this,
85 [this](const QString& file, const QString& error) {
86 _recordingFiles.remove(file);
87 if (error.isEmpty()) {
88 qCDebug(VideoRecordingServiceLog) << "Recorded" << file;
89 return;
90 }
91 qCWarning(VideoRecordingServiceLog) << "Recording" << file << "failed:" << error;
92 QGC::showAppMessage(tr("Video recording %1 failed: %2").arg(QFileInfo(file).fileName(), error));
93 });
94}
95
96void VideoRecordingService::_updateRecording()
97{
98 const bool recording =
99 std::ranges::any_of(_sources, [](const VideoStreamController* source) { return source->recording(); });
100 if (recording != _recording) {
101 _recording = recording;
102 if (_recording) {
103 _storageLimitTimer.start();
104 } else {
105 _storageLimitTimer.stop();
106 }
107 emit recordingChanged(_recording);
108 }
109}
110
111void VideoRecordingService::_applyStorageLimit()
112{
113 VideoSettings* const videoSettings = SettingsManager::instance()->videoSettings();
114 const QString directory = SettingsManager::instance()->appSettings()->videoSavePath();
115 if (directory.isEmpty() || !videoSettings->enableStorageLimit()->rawValue().toBool()) {
116 return;
117 }
118 const quint64 maxBytes = videoSettings->maxVideoSize()->rawValue().toULongLong() * 1024 * 1024;
119 (void) QtConcurrent::run(&VideoRecordingService::pruneStorage, directory, maxBytes, _openFiles());
120}
121
122QStringList VideoRecordingService::_openFiles() const
123{
124 QStringList files;
125 for (const QString& file : _recordingFiles) {
126 files << file << SubtitleWriter::subtitleFile(file);
127 }
128 return files;
129}
130
131void VideoRecordingService::startRecording(const QString& baseName)
132{
133 VideoSettings* const videoSettings = SettingsManager::instance()->videoSettings();
134 const int formatValue = videoSettings->recordingFormat()->rawValue().toInt();
135 if (!VideoReceiver::isValidFileFormat(formatValue)) {
136 QGC::showAppMessage(tr("Invalid video format defined."));
137 return;
138 }
139 const auto format = static_cast<VideoReceiver::FileFormat>(formatValue);
140
141 const QString directory = SettingsManager::instance()->appSettings()->videoSavePath();
142 if (directory.isEmpty()) {
143 QGC::showAppMessage(tr("Unable to record video. Video save path must be specified in Settings."));
144 return;
145 }
146
147 QList<VideoStreamController*> sources;
148 for (VideoStreamController* source : std::as_const(_sources)) {
149 if (source->active() && !source->tile()) {
150 sources.append(source);
151 }
152 }
153 if (sources.isEmpty()) {
154 QGC::showAppMessage(tr("Unable to record video: no video stream is active."));
155 return;
156 }
157
158 _applyStorageLimit();
159
160 const QString name = baseName.isEmpty() ? uniqueBaseName(directory, QDateTime::currentDateTime()) : baseName;
161 for (VideoStreamController* source : std::as_const(sources)) {
162 source->startRecording(recordingFile(directory, name, source, format), format);
163 }
164}
165
167{
168 for (VideoStreamController* source : std::as_const(_sources)) {
169 source->stopRecording();
170 }
171}
172
173QString VideoRecordingService::recordingFile(const QString& directory, const QString& baseName,
175{
176 return source->taggedFile(
177 QStringLiteral("%1/%2.%3").arg(directory, baseName, VideoReceiver::fileExtension(format)));
178}
179
180QString VideoRecordingService::uniqueBaseName(const QString& directory, const QDateTime& time)
181{
182 const QString timestamp = time.toString(QStringLiteral("yyyy-MM-dd_hh.mm.ss"));
183 const QDir dir(directory);
184 QString baseName = timestamp;
185 for (int counter = 2; !dir.entryList({baseName + QStringLiteral(".*")}, QDir::Files).isEmpty(); counter++) {
186 baseName = QStringLiteral("%1_%2").arg(timestamp).arg(counter);
187 }
188 return baseName;
189}
190
191QStringList VideoRecordingService::pruneStorage(const QString& directory, quint64 maxBytes,
192 const QStringList& openFiles)
193{
194 QSet<QString> open;
195 for (const QString& file : openFiles) {
196 open.insert(QFileInfo(file).absoluteFilePath());
197 }
198 const QDateTime beingWrittenSince = QDateTime::currentDateTime().addDuration(-kBeingWritten);
199
200 QStringList nameFilters{QStringLiteral("*.ass")};
201 for (const VideoReceiver::FileFormat format :
203 nameFilters.append(QStringLiteral("*.") + VideoReceiver::fileExtension(format));
204 }
205
206 QDir dir(directory);
207 const QFileInfoList files = dir.entryInfoList(
208 nameFilters, QDir::Files | QDir::Readable | QDir::Writable | QDir::NoSymLinks, QDir::Time | QDir::Reversed);
209
210 quint64 total = 0;
211 for (const QFileInfo& file : files) {
212 total += static_cast<quint64>(file.size());
213 }
214
215 QStringList removed;
216 for (const QFileInfo& file : files) {
217 if (total < maxBytes) {
218 break;
219 }
220 if (open.contains(file.absoluteFilePath()) || (file.lastModified() > beingWrittenSince)) {
221 continue;
222 }
223 total -= static_cast<quint64>(file.size());
224 const QString path = file.filePath();
225 if (QFile::remove(path)) {
226 qCDebug(VideoRecordingServiceLog) << "Removed old recording" << path;
227 removed.append(path);
228 } else {
229 qCWarning(VideoRecordingServiceLog) << "Failed to remove old recording" << path;
230 }
231 }
232 return removed;
233}
#define QGC_LOGGING_CATEGORY(name, categoryStr)
QString videoSavePath()
static SettingsManager * instance()
VideoSettings * videoSettings() const
AppSettings * appSettings() const
static QString subtitleFile(const QString &videoFile)
The subtitle file that goes with videoFile: "<videoFile without extension>.ass".
void startCapturingTelemetry(const QString &videoFile, QSize videoSize)
FileFormat
Values are persisted by VideoSettings::recordingFormat.
static bool isValidFileFormat(int format)
static QString fileExtension(FileFormat format)
"mkv", "mov" or "mp4".
QSize videoSize() const
The size of the frames as they are presented, before the orientation the VideoOutput adds.
void startRecording(const QString &baseName=QString())
bool recording() const
True while any source records.
~VideoRecordingService() override
void addSource(VideoStreamController *source)
Follows source as well, for as long as it exists.
void recordingChanged(bool recording)
static QStringList pruneStorage(const QString &directory, quint64 maxBytes, const QStringList &openFiles={})
static QString uniqueBaseName(const QString &directory, const QDateTime &time)
time as "yyyy-MM-dd_hh.mm.ss", suffixed "_2", "_3"... while files of that name exist in directory.
VideoRecordingService(const QList< VideoStreamController * > &sources, QObject *parent=nullptr)
static QString recordingFile(const QString &directory, const QString &baseName, const VideoStreamController *source, VideoReceiver::FileFormat format)
void recordingStarted(const QString &file)
void recordingFinished(const QString &file, const QString &error)
void startRecording(const QString &file, VideoReceiver::FileFormat format)
VideoReceiver * receiver() const
QString taggedFile(const QString &file) const
file for this source: the thermal stream's name goes before the extension, "<base>....
bool active() const
True when the receiver is active, accepting startRecording().
void recordingChanged(bool recording)
void showAppMessage(const QString &message, const QString &title)
Modal application message. Queued if the UI isn't ready yet.
Definition AppMessages.cc:9