443 lines
25 KiB
C++
443 lines
25 KiB
C++
#include "video_capture_source.h"
|
|
#include "video_capture_protocol.h"
|
|
#include "video_capture_buffer.h"
|
|
#include "call_video_capture_clock.h"
|
|
#include "call_video_cadence.h"
|
|
#include "call_camera_rate.h"
|
|
#include "../../../src/call/call_video_playout.h"
|
|
#include "debug_config.h"
|
|
#include <QGuiApplication>
|
|
#include <QTimer>
|
|
#include <QScopeGuard>
|
|
#include <QTransform>
|
|
#include <QUuid>
|
|
#include <mutex>
|
|
#include <climits>
|
|
#include <algorithm>
|
|
#include <atomic>
|
|
#include <cstring>
|
|
#ifdef Q_OS_WIN
|
|
#include <qt_windows.h>
|
|
#endif
|
|
#ifdef HAVE_STREAM_CAPTURE
|
|
#include <QCamera>
|
|
#include <QMediaDevices>
|
|
#include <QMediaCaptureSession>
|
|
#include <QVideoSink>
|
|
#include <QScreenCapture>
|
|
#include <QWindowCapture>
|
|
#include <QScreen>
|
|
#include <QPixmap>
|
|
#include <QJsonArray>
|
|
#include <QJsonDocument>
|
|
#include <QHash>
|
|
#ifdef UTUN_STREAM_PORTAL
|
|
#include "stream_portal_capture.h"
|
|
#endif
|
|
#if defined(UTUN_STREAM_X11_CURSOR) || defined(UTUN_STREAM_WIN_CURSOR)
|
|
#include "stream_screen_cursor.h"
|
|
#endif
|
|
|
|
using namespace VideoCaptureProtocol;
|
|
|
|
/* Все Qt/native объекты создаются и закрываются в главном потоке дочернего процесса. */
|
|
class QtVideoCaptureSource : public VideoCaptureSource {
|
|
std::unique_ptr<QCamera> camera;
|
|
std::unique_ptr<QScreenCapture> screen;
|
|
std::unique_ptr<QWindowCapture> window;
|
|
std::unique_ptr<QMediaCaptureSession> session;
|
|
std::unique_ptr<QVideoSink> sink;
|
|
QMediaDevices devicesMonitor;
|
|
QTimer grabTimer;
|
|
QPointer<QScreen> selectedScreen;
|
|
QHash<QByteArray, QCapturableWindow> windows;
|
|
quint64 nextWindow = 0;
|
|
const QByteArray windowPrefix = QUuid::createUuid().toByteArray(QUuid::Id128) + '-';
|
|
CallCameraRate rate;
|
|
#ifdef UTUN_STREAM_PORTAL
|
|
std::unique_ptr<StreamPortalCapture> portal;
|
|
#endif
|
|
#if defined(UTUN_STREAM_X11_CURSOR) || defined(UTUN_STREAM_WIN_CURSOR)
|
|
std::unique_ptr<StreamScreenCursor> cursor;
|
|
#endif
|
|
static QByteArray screenId(QScreen* selected) {
|
|
int duplicate = 0;
|
|
for (auto* item : QGuiApplication::screens()) {
|
|
if (item == selected) break;
|
|
if (item->name() == selected->name() && item->manufacturer() == selected->manufacturer()
|
|
&& item->model() == selected->model() && item->serialNumber() == selected->serialNumber()) ++duplicate;
|
|
}
|
|
return QJsonDocument(QJsonArray{selected->name(), selected->manufacturer(), selected->model(),
|
|
selected->serialNumber(), duplicate}).toJson(QJsonDocument::Compact);
|
|
}
|
|
void fail(const QString& message) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_VIDEO, "capture backend: %s", qUtf8Printable(message)); emit error(message);
|
|
}
|
|
public:
|
|
QtVideoCaptureSource() {
|
|
connect(&devicesMonitor, &QMediaDevices::videoInputsChanged, this, &VideoCaptureSource::devicesChanged);
|
|
auto watchScreen = [this](QScreen* item) {
|
|
connect(item, &QScreen::geometryChanged, this, &VideoCaptureSource::devicesChanged);
|
|
connect(item, &QScreen::physicalDotsPerInchChanged, this, &VideoCaptureSource::devicesChanged);
|
|
};
|
|
for (auto* item : QGuiApplication::screens()) watchScreen(item);
|
|
connect(qGuiApp, &QGuiApplication::screenAdded, this, [this, watchScreen](QScreen* item) { watchScreen(item); emit devicesChanged(); });
|
|
connect(qGuiApp, &QGuiApplication::screenRemoved, this, [this](QScreen* removed) {
|
|
if (selectedScreen == removed) fail(QStringLiteral("Selected screen was disconnected"));
|
|
emit devicesChanged();
|
|
});
|
|
}
|
|
~QtVideoCaptureSource() override { stop(); }
|
|
VideoCaptureDevices devices(bool stream) override {
|
|
VideoCaptureDevices result;
|
|
for (const auto& device : QMediaDevices::videoInputs()) {
|
|
VideoCaptureDevice entry{device.description(), device.id(), {}};
|
|
for (const auto& format : device.videoFormats()) {
|
|
const QSize size = format.resolution();
|
|
if (stream ? validStreamSize(size.width(), size.height()) : validSize(size.width(), size.height()))
|
|
stream_video_add_camera_modes(entry.modes, size, format.minFrameRate(), format.maxFrameRate());
|
|
}
|
|
DEBUG_DEBUG(DEBUG_CATEGORY_VIDEO, "capture camera enumerated device=%s modes=%lld stream=%d",
|
|
device.id().constData(), (long long)entry.modes.size(), stream);
|
|
result.append(entry);
|
|
}
|
|
if (!stream) return result;
|
|
if (qEnvironmentVariableIsSet("WAYLAND_DISPLAY") || qEnvironmentVariable("XDG_SESSION_TYPE") == "wayland") {
|
|
result.append({QStringLiteral("Screen (system selection)"), "portal", {}, VideoCaptureKind::Screen, {}});
|
|
} else {
|
|
for (auto* item : QGuiApplication::screens())
|
|
result.append({item->name(), screenId(item), {}, VideoCaptureKind::Screen, item->size() * item->devicePixelRatio()});
|
|
}
|
|
QHash<QByteArray, QCapturableWindow> current;
|
|
for (const auto& item : QWindowCapture::capturableWindows()) {
|
|
QByteArray id;
|
|
for (auto it = windows.cbegin(); it != windows.cend(); ++it) if (it.value() == item) { id = it.key(); break; }
|
|
if (id.isEmpty()) id = windowPrefix + QByteArray::number(++nextWindow);
|
|
current.insert(id, item);
|
|
result.append({item.description(), id, {}, VideoCaptureKind::Window, {}});
|
|
}
|
|
windows = std::move(current);
|
|
return result;
|
|
}
|
|
bool start(const VideoCaptureConfig& config) override {
|
|
emit stage(QStringLiteral("session.create"));
|
|
session = std::make_unique<QMediaCaptureSession>(); sink = std::make_unique<QVideoSink>();
|
|
session->setVideoSink(sink.get());
|
|
connect(sink.get(), &QVideoSink::videoFrameChanged, this, &VideoCaptureSource::frame, Qt::DirectConnection);
|
|
if (config.kind == VideoCaptureKind::Camera) {
|
|
QCameraDevice selected;
|
|
for (const auto& item : QMediaDevices::videoInputs()) if (item.id() == config.device) selected = item;
|
|
if (selected.isNull()) { fail(QStringLiteral("Camera is unavailable")); return false; }
|
|
camera = std::make_unique<QCamera>(selected);
|
|
QCameraFormat best;
|
|
for (const auto& format : selected.videoFormats()) {
|
|
if (!stream_video_camera_supports(format.resolution(), format.minFrameRate(), format.maxFrameRate(),
|
|
{QSize(config.width, config.height), config.fps})) continue;
|
|
if (best.isNull() || format.maxFrameRate() < best.maxFrameRate()) best = format;
|
|
}
|
|
if (best.isNull()) { fail(QStringLiteral("Selected camera mode is unavailable")); return false; }
|
|
camera->setCameraFormat(best); session->setCamera(camera.get());
|
|
connect(camera.get(), &QCamera::activeChanged, this, [this, id = config.device](bool active) {
|
|
if (active) rate.activate(id); else { rate.restore(); fail(QStringLiteral("Camera capture stopped unexpectedly")); }
|
|
});
|
|
connect(camera.get(), &QCamera::errorOccurred, this, [this](QCamera::Error, const QString& message) { fail(message); });
|
|
emit stage(QStringLiteral("camera.start")); camera->start();
|
|
} else if (config.kind == VideoCaptureKind::Screen) {
|
|
#ifdef UTUN_STREAM_PORTAL
|
|
if (config.device == "portal") {
|
|
portal = std::make_unique<StreamPortalCapture>();
|
|
connect(portal.get(), &StreamPortalCapture::frameReady, sink.get(), &QVideoSink::setVideoFrame);
|
|
connect(portal.get(), &StreamPortalCapture::errorOccurred, this, &VideoCaptureSource::error);
|
|
emit stage(QStringLiteral("portal.start")); portal->start(config.cursor); return true;
|
|
}
|
|
#endif
|
|
for (auto* item : QGuiApplication::screens()) if (screenId(item) == config.device) selectedScreen = item;
|
|
if (!selectedScreen) { fail(QStringLiteral("Selected screen is unavailable")); return false; }
|
|
#if defined(UTUN_STREAM_X11_CURSOR) || defined(UTUN_STREAM_WIN_CURSOR)
|
|
if (config.cursor) cursor = std::make_unique<StreamScreenCursor>(selectedScreen);
|
|
#endif
|
|
if (QGuiApplication::platformName() == "xcb") {
|
|
grabTimer.setTimerType(Qt::PreciseTimer);
|
|
connect(&grabTimer, &QTimer::timeout, this, [this] {
|
|
QImage image = selectedScreen ? selectedScreen->grabWindow(0).toImage() : QImage();
|
|
if (image.isNull()) { grabTimer.stop(); fail(QStringLiteral("Screen capture failed")); return; }
|
|
#if QT_VERSION >= QT_VERSION_CHECK(6, 8, 0)
|
|
QVideoFrame raw(image);
|
|
#else
|
|
image = image.convertToFormat(QImage::Format_RGBA8888);
|
|
QVideoFrame raw(QVideoFrameFormat(image.size(), QVideoFrameFormat::Format_RGBA8888));
|
|
if (!raw.map(QVideoFrame::WriteOnly)) { fail(QStringLiteral("Screen frame mapping failed")); return; }
|
|
for (int row = 0; row < image.height(); ++row)
|
|
std::memcpy(raw.bits(0) + row * raw.bytesPerLine(0), image.constScanLine(row), size_t(image.width()) * 4);
|
|
raw.unmap();
|
|
#endif
|
|
raw.setStartTime(call_video_playout_now_us()); emit frame(raw);
|
|
});
|
|
emit stage(QStringLiteral("screen.start")); grabTimer.start(std::max(1, 1000 / config.fps));
|
|
} else {
|
|
screen = std::make_unique<QScreenCapture>(); screen->setScreen(selectedScreen); session->setScreenCapture(screen.get());
|
|
connect(screen.get(), &QScreenCapture::errorOccurred, this,
|
|
[this](QScreenCapture::Error, const QString& message) { fail(message); });
|
|
connect(screen.get(), &QScreenCapture::activeChanged, this,
|
|
[this](bool active) { if (!active) fail(QStringLiteral("Screen capture stopped unexpectedly")); });
|
|
emit stage(QStringLiteral("screen.start")); screen->start();
|
|
}
|
|
} else {
|
|
if (!windows.contains(config.device) || !windows.value(config.device).isValid()) {
|
|
fail(QStringLiteral("Selected window is unavailable")); return false;
|
|
}
|
|
window = std::make_unique<QWindowCapture>(); window->setWindow(windows.value(config.device));
|
|
session->setWindowCapture(window.get());
|
|
connect(window.get(), &QWindowCapture::errorOccurred, this,
|
|
[this](QWindowCapture::Error, const QString& message) { fail(message); });
|
|
connect(window.get(), &QWindowCapture::activeChanged, this,
|
|
[this](bool active) { if (!active) fail(QStringLiteral("Window capture stopped unexpectedly")); });
|
|
emit stage(QStringLiteral("window.start")); window->start();
|
|
}
|
|
DEBUG_INFO(DEBUG_CATEGORY_VIDEO, "capture started kind=%u source=%s size=%dx%d fps=%d cursor=%d",
|
|
unsigned(config.kind), config.device.constData(), config.width, config.height, config.fps, config.cursor);
|
|
return true;
|
|
}
|
|
bool prepareImage(QImage& image) override {
|
|
#if defined(UTUN_STREAM_X11_CURSOR) || defined(UTUN_STREAM_WIN_CURSOR)
|
|
if (cursor) {
|
|
emit stage(QStringLiteral("cursor.draw"));
|
|
if (!cursor->draw(image)) { fail(QStringLiteral("Mouse cursor capture failed")); return false; }
|
|
}
|
|
#else
|
|
Q_UNUSED(image);
|
|
#endif
|
|
return true;
|
|
}
|
|
void stop() override {
|
|
if (!session && !sink && !camera && !screen && !window) return;
|
|
grabTimer.stop(); disconnect(&grabTimer, nullptr, this, nullptr);
|
|
if (sink) disconnect(sink.get(), nullptr, this, nullptr);
|
|
#ifdef UTUN_STREAM_PORTAL
|
|
if (portal) { emit stage(QStringLiteral("portal.destroy")); portal.reset(); }
|
|
#endif
|
|
if (camera) { disconnect(camera.get(), nullptr, this, nullptr); emit stage(QStringLiteral("camera.stop")); camera->stop(); }
|
|
if (screen) { disconnect(screen.get(), nullptr, this, nullptr); emit stage(QStringLiteral("screen.stop")); screen->stop(); }
|
|
if (window) { disconnect(window.get(), nullptr, this, nullptr); emit stage(QStringLiteral("window.stop")); window->stop(); }
|
|
if (camera) { emit stage(QStringLiteral("camera-rate.restore")); rate.restore(); }
|
|
if (session) { emit stage(QStringLiteral("session.destroy")); session.reset(); }
|
|
if (camera) { emit stage(QStringLiteral("camera.destroy")); camera.reset(); }
|
|
if (screen) { emit stage(QStringLiteral("screen.destroy")); screen.reset(); }
|
|
if (window) { emit stage(QStringLiteral("window.destroy")); window.reset(); }
|
|
if (sink) { emit stage(QStringLiteral("sink.destroy")); sink.reset(); }
|
|
#if defined(UTUN_STREAM_X11_CURSOR) || defined(UTUN_STREAM_WIN_CURSOR)
|
|
cursor.reset();
|
|
#endif
|
|
selectedScreen = nullptr;
|
|
}
|
|
};
|
|
|
|
class VideoCaptureWorker : public QObject {
|
|
struct Pending {
|
|
std::mutex lock;
|
|
QVideoFrame raw;
|
|
qint64 arrival = 0;
|
|
bool posted = false;
|
|
};
|
|
QLocalSocket socket;
|
|
QTimer heartbeat;
|
|
VideoCaptureBuffer buffer;
|
|
uchar* pixels = nullptr;
|
|
Reader reader;
|
|
std::unique_ptr<VideoCaptureSource> source;
|
|
std::shared_ptr<Pending> pending;
|
|
QMetaObject::Connection captureConnection, errorConnection;
|
|
CallVideoCaptureClock clock;
|
|
CallVideoCadence cadence;
|
|
quint64 generation = 0, inFlight = 0;
|
|
bool sending = false;
|
|
bool stream = false;
|
|
VideoCaptureConfig config;
|
|
int width = 640, height = 480, fps = 30;
|
|
qint64 lastPts = -1, reportAt = 0, convertMax = 0;
|
|
unsigned frames = 0, paced = 0;
|
|
|
|
void send(const QByteArray& data) {
|
|
if (socket.write(data) != data.size()) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_VIDEO, "capture worker IPC write failed: %s", qPrintable(socket.errorString()));
|
|
QCoreApplication::exit(2);
|
|
}
|
|
socket.flush(); // Стадия должна уйти до потенциально блокирующего вызова драйвера.
|
|
}
|
|
void stage(const QString& name) { send(packet(Stage, generation, [&](QDataStream& out) { out << name; })); }
|
|
void enumerate() {
|
|
if (socket.state() != QLocalSocket::ConnectedState) return; // Первичный опрос повторит connected.
|
|
stage(QStringLiteral("enumerate"));
|
|
const auto devices = source->devices(stream);
|
|
send(packet(Devices, 0, [&](QDataStream& out) {
|
|
out << quint32(devices.size());
|
|
for (const auto& device : devices) {
|
|
out << device.name << device.id << quint32(device.modes.size()) << quint8(device.kind) << device.size;
|
|
for (const auto& mode : device.modes) out << qint32(mode.size.width()) << qint32(mode.size.height()) << qint32(mode.fps);
|
|
}
|
|
}));
|
|
stage(pending ? QStringLiteral("running") : QStringLiteral("idle"));
|
|
}
|
|
void stop() {
|
|
stage(QStringLiteral("stop"));
|
|
disconnect(captureConnection); disconnect(errorConnection); source->stop();
|
|
stage(QStringLiteral("frame.release")); pending.reset();
|
|
DEBUG_INFO(DEBUG_CATEGORY_VIDEO, "capture stopped generation=%llu", (unsigned long long)generation);
|
|
stage(QStringLiteral("idle"));
|
|
}
|
|
void convert(std::shared_ptr<Pending> slot, quint64 revision) {
|
|
if (slot != pending || revision != generation || sending) return;
|
|
QVideoFrame raw; QImage image; qint64 arrival;
|
|
auto release = qScopeGuard([this] { stage(QStringLiteral("frame.release")); });
|
|
{ std::lock_guard<std::mutex> guard(slot->lock);
|
|
raw.swap(slot->raw); arrival = slot->arrival; slot->posted = false; }
|
|
if (!raw.isValid()) return;
|
|
const qint64 started = call_video_playout_now_us(), sourcePts = raw.startTime();
|
|
if (clock.source >= 0 && sourcePts < clock.source)
|
|
DEBUG_WARN(DEBUG_CATEGORY_VIDEO, "camera clock reset source=%lld previous=%lld", (long long)sourcePts, (long long)clock.source);
|
|
const qint64 pts = clock.map(sourcePts, arrival);
|
|
if (pts <= lastPts || started - pts > VideoCaptureMaxFrameAgeUs) {
|
|
DEBUG_WARN(DEBUG_CATEGORY_VIDEO, "camera skips old frame age_us=%lld pts=%lld last=%lld",
|
|
(long long)(started - pts), (long long)pts, (long long)lastPts); return;
|
|
}
|
|
// Ограничиваем поток до дорогой конвертации и IPC; preview и TX получают выбранную частоту.
|
|
if (!cadence.accept(pts)) { ++paced; return; }
|
|
stage(QStringLiteral("convert"));
|
|
image = raw.toImage();
|
|
if (image.isNull()) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_VIDEO, "camera frame conversion failed");
|
|
send(packet(Error, generation, [](QDataStream& out) { out << QStringLiteral("Camera frame conversion failed"); })); return;
|
|
}
|
|
if (!source->prepareImage(image)) return;
|
|
if (config.kind == VideoCaptureKind::Camera && image.size() != QSize(width, height)) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_VIDEO, "camera geometry changed requested=%dx%d actual=%dx%d", width, height, image.width(), image.height());
|
|
send(packet(Error, generation, [](QDataStream& out) { out << QStringLiteral("Camera changed the selected resolution"); })); return;
|
|
}
|
|
if (stream) {
|
|
#if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
|
|
if (raw.rotation() != QtVideo::Rotation::None) image = image.transformed(QTransform().rotate(static_cast<int>(raw.rotation())));
|
|
if (raw.mirrored()) image = image.transformed(QTransform().scale(-1, 1));
|
|
#else
|
|
if (raw.rotationAngle()) image = image.transformed(QTransform().rotate(raw.rotationAngle()));
|
|
#endif
|
|
}
|
|
if (stream && config.kind != VideoCaptureKind::Camera) {
|
|
const QSize size = stream_video_screen_size(image.size());
|
|
if (size.isEmpty()) { send(packet(Error, generation, [](QDataStream& out) { out << QStringLiteral("Invalid screen size"); })); return; }
|
|
if (image.size() != size) image = image.scaled(size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
|
|
}
|
|
const int outputWidth = image.width(), outputHeight = image.height();
|
|
if (!(stream ? validStreamSize(outputWidth, outputHeight) : validSize(outputWidth, outputHeight))) {
|
|
send(packet(Error, generation, [](QDataStream& out) { out << QStringLiteral("Invalid converted frame size"); })); return;
|
|
}
|
|
image = image.convertToFormat(QImage::Format_RGB32);
|
|
const qint64 converted = call_video_playout_now_us();
|
|
if (converted - pts <= VideoCaptureMaxFrameAgeUs) {
|
|
for (int row = 0; row < outputHeight; ++row)
|
|
std::memcpy(pixels + size_t(row) * outputWidth * 4, image.constScanLine(row), size_t(outputWidth) * 4);
|
|
std::atomic_thread_fence(std::memory_order_release);
|
|
auto bytes = packet(Frame, generation, [&](QDataStream& out) {
|
|
out << pts << qint64(clock.correction) << qint32(outputWidth) << qint32(outputHeight);
|
|
});
|
|
sending = true; inFlight = generation; lastPts = pts; send(bytes); ++frames;
|
|
} else DEBUG_WARN(DEBUG_CATEGORY_VIDEO, "camera conversion exceeded frame age budget age_us=%lld", (long long)(converted - pts));
|
|
stage(QStringLiteral("frame.release")); image = {}; raw = {}; release.dismiss(); stage(QStringLiteral("running"));
|
|
convertMax = std::max(convertMax, call_video_playout_now_us() - started);
|
|
if (started - reportAt >= 1000000) {
|
|
DEBUG_DEBUG(DEBUG_CATEGORY_VIDEO, "camera flow output_fps=%d frames=%u paced=%u convert_max_us=%lld age_us=%lld clock_correction_us=%lld",
|
|
fps, frames, paced, (long long)convertMax, (long long)(converted - pts), (long long)clock.correction);
|
|
reportAt = started; convertMax = 0; frames = paced = 0;
|
|
}
|
|
}
|
|
bool receive(quint8 type, quint64 revision, QDataStream& in) {
|
|
if (type == Buffer) {
|
|
QString name; quint32 capacity = 0; in >> name >> capacity;
|
|
if (pixels) return false;
|
|
if (capacity != (stream ? MaxFrameBytes : FrameBytes) || !buffer.attach(name, capacity)) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_VIDEO, "camera frame mapping failed: %s", qPrintable(buffer.errorString())); return false;
|
|
}
|
|
pixels = buffer.data();
|
|
} else if (type == Refresh) enumerate();
|
|
else if (type == Quit) { generation = revision; stop(); stage(QStringLiteral("process.exit")); QCoreApplication::quit(); }
|
|
else if (type == Ack) {
|
|
if (sending && revision == inFlight) { sending = false; if (pending) convert(pending, generation); }
|
|
} else if (type == Configure) {
|
|
bool enabled = false, cursor = false; QByteArray device; qint32 w = 0, h = 0, rate = 0; quint8 kind = 0;
|
|
in >> enabled >> device >> w >> h >> rate >> kind >> cursor;
|
|
if (in.status() != QDataStream::Ok || !(stream ? validStreamSize(w, h) : validSize(w, h))
|
|
|| rate < 1 || rate > 60 || !pixels || kind > quint8(VideoCaptureKind::Window)
|
|
|| (!stream && kind != quint8(VideoCaptureKind::Camera))) return false;
|
|
generation = revision; stop(); width = w; height = h; fps = rate;
|
|
config = {enabled, device, w, h, rate, VideoCaptureKind(kind), cursor};
|
|
clock = {}; cadence = CallVideoCadence(rate); lastPts = -1;
|
|
if (!enabled) { stage(QStringLiteral("idle")); return true; }
|
|
stage(QStringLiteral("start"));
|
|
pending = std::make_shared<Pending>();
|
|
errorConnection = connect(source.get(), &VideoCaptureSource::error, this, [this, revision](const QString& error) {
|
|
if (revision != generation) return;
|
|
DEBUG_ERROR(DEBUG_CATEGORY_VIDEO, "camera backend: %s", qUtf8Printable(error));
|
|
send(packet(Error, revision, [&](QDataStream& out) { out << error; }));
|
|
}, Qt::QueuedConnection);
|
|
captureConnection = connect(source.get(), &VideoCaptureSource::frame, this,
|
|
[this, slot = pending, revision](const QVideoFrame& frame) {
|
|
if (!frame.isValid()) return;
|
|
const qint64 arrival = call_video_playout_now_us();
|
|
QVideoFrame previous; bool post;
|
|
{ std::lock_guard<std::mutex> guard(slot->lock);
|
|
previous.swap(slot->raw); slot->raw = frame; slot->arrival = arrival;
|
|
post = !slot->posted; slot->posted = true; }
|
|
if (post) QMetaObject::invokeMethod(this, [this, slot, revision] { convert(slot, revision); }, Qt::QueuedConnection);
|
|
}, Qt::DirectConnection);
|
|
if (source->start(config)) stage(QStringLiteral("running"));
|
|
} else return false;
|
|
return true;
|
|
}
|
|
public:
|
|
explicit VideoCaptureWorker(std::unique_ptr<VideoCaptureSource> backend, bool useStream) : source(std::move(backend)), stream(useStream) {
|
|
connect(source.get(), &VideoCaptureSource::stage, this, &VideoCaptureWorker::stage);
|
|
heartbeat.setInterval(1000);
|
|
connect(&heartbeat, &QTimer::timeout, this, [this] { if (socket.state() == QLocalSocket::ConnectedState) send(packet(Heartbeat, generation)); });
|
|
heartbeat.start();
|
|
connect(&socket, &QLocalSocket::connected, this, &VideoCaptureWorker::enumerate);
|
|
connect(source.get(), &VideoCaptureSource::devicesChanged, this, &VideoCaptureWorker::enumerate);
|
|
connect(&socket, &QLocalSocket::readyRead, this, [this] {
|
|
if (!reader.read(socket, [this](quint8 type, quint64 revision, QDataStream& in) { return receive(type, revision, in); })) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_VIDEO, "capture worker invalid command"); QCoreApplication::exit(2);
|
|
}
|
|
});
|
|
connect(&socket, &QLocalSocket::disconnected, qApp, &QCoreApplication::quit);
|
|
connect(&socket, &QLocalSocket::errorOccurred, this, [this](QLocalSocket::LocalSocketError) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_VIDEO, "capture worker IPC: %s", qPrintable(socket.errorString())); QCoreApplication::exit(2);
|
|
});
|
|
}
|
|
~VideoCaptureWorker() override {
|
|
disconnect(captureConnection); source->stop();
|
|
stage(QStringLiteral("source.destroy")); source.reset();
|
|
stage(QStringLiteral("frame.release")); pending.reset();
|
|
stage(QStringLiteral("thread-resources.release"));
|
|
}
|
|
void connectTo(const QString& endpoint) { socket.connectToServer(endpoint); }
|
|
};
|
|
|
|
int video_capture_worker_run(const QString& endpoint, std::unique_ptr<VideoCaptureSource> source, bool stream) {
|
|
VideoCaptureWorker worker(std::move(source), stream); worker.connectTo(endpoint); return QCoreApplication::exec();
|
|
}
|
|
#endif
|
|
|
|
int video_capture_worker_main(int argc, char** argv) {
|
|
#ifdef HAVE_STREAM_CAPTURE
|
|
QGuiApplication app(argc, argv); debug_config_init(); debug_set_level(DEBUG_LEVEL_INFO);
|
|
debug_set_category_level(DEBUG_CATEGORY_VIDEO, DEBUG_LEVEL_DEBUG);
|
|
#ifdef Q_OS_WIN
|
|
const UINT codePage = GetACP();
|
|
DEBUG_INFO(DEBUG_CATEGORY_VIDEO, "capture worker Windows code_page=%u Qt=%s camera_errors=Unicode", codePage, qVersion());
|
|
#endif
|
|
if (argc != 4 || (std::strcmp(argv[3], "stream") && std::strcmp(argv[3], "call"))) {
|
|
DEBUG_ERROR(DEBUG_CATEGORY_VIDEO, "capture worker endpoint/usage missing"); return 2;
|
|
}
|
|
return video_capture_worker_run(QString::fromLocal8Bit(argv[2]), std::make_unique<QtVideoCaptureSource>(), !std::strcmp(argv[3], "stream"));
|
|
#else
|
|
Q_UNUSED(argc); Q_UNUSED(argv); return 2;
|
|
#endif
|
|
}
|