diff --git a/tools/chatgui/src/video_capture.cpp b/tools/chatgui/src/video_capture.cpp index b1f201641..502e43b2a 100644 --- a/tools/chatgui/src/video_capture.cpp +++ b/tools/chatgui/src/video_capture.cpp @@ -23,14 +23,17 @@ struct VideoCapture::Session : QObject { VideoCaptureBuffer buffer; uchar* pixels = nullptr; Reader reader; + Usage usage; + VideoCaptureKind kind = VideoCaptureKind::Camera; + bool cursor = true, stopping = false, forced = false; quint64 generation = 0; bool enabled = false, retiring = false, failureReported = false, restartRequested = false, exiting = false; QByteArray device; int width = 640, height = 480, fps = 30; QString phase = QStringLiteral("launch"); - qint64 progressAt = 0, frameAt = 0, stopAt = 0; + qint64 progressAt = 0, frameAt = 0, stopAt = 0, stopStarted = 0, stageAt = 0; - explicit Session(VideoCapture* target) : owner(target) { + explicit Session(VideoCapture* target, Usage use) : owner(target), usage(use) { server.setSocketOptions(QLocalServer::UserAccessOption); connect(&server, &QLocalServer::newConnection, this, [this] { auto* connection = server.nextPendingConnection(); @@ -43,7 +46,9 @@ struct VideoCapture::Session : QObject { }); if (retiring) send(packet(Quit, generation)); else { - send(packet(Buffer, 0, [this](QDataStream& out) { out << buffer.name(); })); + send(packet(Buffer, 0, [this](QDataStream& out) { + out << buffer.name() << quint32(usage == Usage::Stream ? MaxFrameBytes : FrameBytes); + })); sendConfiguration(); } }); @@ -65,22 +70,30 @@ struct VideoCapture::Session : QObject { } }); connect(&process, QOverload::of(&QProcess::finished), this, [this](int code, QProcess::ExitStatus status) { - DEBUG_INFO(DEBUG_CATEGORY_CALL, "camera worker exited code=%d status=%d retiring=%d", code, int(status), retiring); + DEBUG_INFO(DEBUG_CATEGORY_VIDEO, "capture process exited pid=%lld generation=%llu code=%d status=%d expected=%d forced=%d " + "last_stage=%s stop_ms=%lld", (long long)process.processId(), (unsigned long long)generation, code, int(status), + stopping, forced, qPrintable(phase), stopStarted ? (long long)((call_video_playout_now_us() - stopStarted) / 1000) : 0); if (socket) { socket->disconnect(this); socket->deleteLater(); socket = nullptr; } server.close(); watchdog.stop(); + const bool expected = stopping; stopping = false; stopAt = 0; + if (owner && expected) emit owner->stopped(); if (retiring) deleteLater(); else if (restartRequested) { restartRequested = false; launch(); } - else if (!failureReported) fail(QStringLiteral("Camera worker stopped")); + else if (!expected && !failureReported) fail(QStringLiteral("Capture worker stopped unexpectedly")); }); watchdog.setInterval(250); connect(&watchdog, &QTimer::timeout, this, [this] { const qint64 now = call_video_playout_now_us(); if (stopAt && now >= stopAt) { - DEBUG_WARN(DEBUG_CATEGORY_CALL, "camera stop timed out phase=%s; killing worker", qPrintable(phase)); + DEBUG_ERROR(DEBUG_CATEGORY_VIDEO, "capture stop timeout pid=%lld generation=%llu elapsed_ms=%lld " + "last_stage=%s stage_age_ms=%lld; killing worker", (long long)process.processId(), + (unsigned long long)generation, (long long)((now - stopStarted) / 1000), qPrintable(phase), + (long long)((now - stageAt) / 1000)); stopAt = 0; - if (!retiring) fail(QStringLiteral("Camera did not stop")); else process.kill(); - } else if (!retiring && !failureReported && ((phase != "idle" && now - progressAt >= 5000000) - || (enabled && now - frameAt >= 5000000))) { + forced = true; + if (!stopping && !retiring) fail(QStringLiteral("Capture did not stop")); else process.kill(); + } else if (!stopping && !retiring && !failureReported && ((phase != "idle" && now - progressAt >= 5000000) + || (enabled && kind == VideoCaptureKind::Camera && now - frameAt >= 5000000))) { DEBUG_ERROR(DEBUG_CATEGORY_CALL, "camera stalled generation=%llu phase=%s operation_age_us=%lld frame_age_us=%lld", (unsigned long long)generation, qPrintable(phase), (long long)(now - progressAt), (long long)(now - frameAt)); fail(QStringLiteral("Camera stopped responding")); @@ -98,15 +111,18 @@ struct VideoCapture::Session : QObject { server.close(); reader = {}; failureReported = false; phase = QStringLiteral("launch"); progressAt = call_video_playout_now_us(); if (!pixels) { - if (!buffer.create()) { + if (!buffer.create(usage == Usage::Stream ? MaxFrameBytes : FrameBytes)) { fail(QStringLiteral("Cannot allocate camera frame buffer: %1").arg(buffer.errorString())); return; } pixels = buffer.data(); } const QString name = QStringLiteral("vibechat-camera-") + QUuid::createUuid().toString(QUuid::Id128); if (!server.listen(name)) { fail(QStringLiteral("Cannot create camera IPC: %1").arg(server.errorString())); return; } - DEBUG_INFO(DEBUG_CATEGORY_CALL, "camera worker starting; hardware isolated from GUI"); - process.start(QCoreApplication::applicationFilePath(), {QStringLiteral("--video-capture-worker"), server.fullServerName()}); + stopping = forced = false; stopAt = stopStarted = 0; + DEBUG_INFO(DEBUG_CATEGORY_VIDEO, "capture process starting generation=%llu usage=%s buffer_bytes=%u", + (unsigned long long)generation, usage == Usage::Stream ? "stream" : "call", usage == Usage::Stream ? MaxFrameBytes : FrameBytes); + process.start(QCoreApplication::applicationFilePath(), {QStringLiteral("--video-capture-worker"), server.fullServerName(), + usage == Usage::Stream ? QStringLiteral("stream") : QStringLiteral("call")}); watchdog.start(); } void send(const QByteArray& data) { @@ -116,27 +132,42 @@ struct VideoCapture::Session : QObject { } void sendConfiguration() { send(packet(Configure, generation, [this](QDataStream& out) { - out << enabled << device << qint32(width) << qint32(height) << qint32(fps); + out << enabled << device << qint32(width) << qint32(height) << qint32(fps) << quint8(kind) << cursor; })); } - void configure(bool active, const QByteArray& id, int w, int h, int rate) { + void configure(const VideoCaptureConfig& config) { if (exiting) return; - if (!validSize(w, h) || rate < 1 || rate > 60) { fail(QStringLiteral("Invalid camera size/frame rate")); return; } - if (enabled == active && device == id && width == w && height == h && fps == rate && !failureReported) return; + const auto [active, id, w, h, rate, nextKind, showCursor] = config; + if (stopping) { DEBUG_WARN(DEBUG_CATEGORY_VIDEO, "capture configure refused while process is closing"); return; } + if (!(usage == Usage::Stream ? validStreamSize(w, h) : validSize(w, h)) || rate < 1 || rate > 60 + || quint8(nextKind) > quint8(VideoCaptureKind::Window) || (usage == Usage::Call && nextKind != VideoCaptureKind::Camera)) { + fail(QStringLiteral("Invalid capture source/size/frame rate")); return; + } + if (enabled == active && device == id && width == w && height == h && fps == rate + && kind == nextKind && cursor == showCursor && !failureReported) return; + kind = nextKind; cursor = showCursor; enabled = active; device = id; width = w; height = h; fps = rate; ++generation; progressAt = call_video_playout_now_us(); frameAt = progressAt; - stopAt = active ? 0 : progressAt + 1500000; + stopStarted = active ? 0 : progressAt; stopAt = active ? 0 : progressAt + 1500000; DEBUG_INFO(DEBUG_CATEGORY_CALL, "camera request generation=%llu enabled=%d size=%dx%d output_fps=%d device=%s", (unsigned long long)generation, active, w, h, rate, id.constData()); if (failureReported && active) restartRequested = true; if (process.state() == QProcess::NotRunning) { restartRequested = false; launch(); } if (socket) sendConfiguration(); } + void stop() { + if (stopping || process.state() == QProcess::NotRunning) return; + stopping = true; enabled = false; ++generation; + stopStarted = call_video_playout_now_us(); stopAt = stopStarted + 1500000; + DEBUG_INFO(DEBUG_CATEGORY_VIDEO, "capture stop requested pid=%lld generation=%llu last_stage=%s deadline_ms=1500", + (long long)process.processId(), (unsigned long long)generation, qPrintable(phase)); + watchdog.start(); send(packet(Quit, generation)); + } void shutdown() { - owner = nullptr; retiring = true; enabled = false; ++generation; + owner = nullptr; retiring = true; if (process.state() == QProcess::NotRunning) { deleteLater(); return; } - stopAt = call_video_playout_now_us() + 1500000; watchdog.start(); send(packet(Quit, generation)); + stop(); } void fail(const QString& error) { if (failureReported) return; @@ -151,11 +182,13 @@ struct VideoCapture::Session : QObject { if (in.status() != QDataStream::Ok || count > 128) return false; VideoCaptureDevices devices; for (quint32 i = 0; i < count; ++i) { - VideoCaptureDevice device; quint32 modes = 0; in >> device.name >> device.id >> modes; - if (in.status() != QDataStream::Ok || modes > 256) return false; + VideoCaptureDevice device; quint32 modes = 0; quint8 kind = 0; + in >> device.name >> device.id >> modes >> kind >> device.size; + if (in.status() != QDataStream::Ok || modes > 256 || kind > quint8(VideoCaptureKind::Window)) return false; + device.kind = VideoCaptureKind(kind); for (quint32 j = 0; j < modes; ++j) { qint32 w = 0, h = 0, rate = 0; in >> w >> h >> rate; - if (!validSize(w, h) || rate < 1 || rate > 60) return false; + if (!(usage == Usage::Stream ? validStreamSize(w, h) : validSize(w, h)) || rate < 1 || rate > 60) return false; device.modes.append({QSize(w, h), rate}); } devices.append(device); @@ -163,14 +196,21 @@ struct VideoCapture::Session : QObject { if (owner) emit owner->devicesChanged(devices); } else if (type == Stage) { QString next; in >> next; - phase = next; progressAt = call_video_playout_now_us(); - if (revision == generation && next == "idle") stopAt = 0; + const qint64 now = call_video_playout_now_us(); + if (next != phase) stageAt = now; + phase = next; progressAt = now; + if (stopping) DEBUG_INFO(DEBUG_CATEGORY_VIDEO, "capture closing pid=%lld generation=%llu stage=%s elapsed_ms=%lld", + (long long)process.processId(), (unsigned long long)generation, qPrintable(phase), (long long)((now - stopStarted) / 1000)); + if (!stopping && revision == generation && next == "idle") stopAt = 0; + } else if (type == Heartbeat) { + progressAt = call_video_playout_now_us(); } else if (type == Error) { QString error; in >> error; if (revision == generation) fail(error); } else if (type == Frame) { qint64 pts = -1, correction = 0; qint32 w = 0, h = 0; in >> pts >> correction >> w >> h; - if (in.status() != QDataStream::Ok || pts < 0 || correction < 0 || !validSize(w, h) || !pixels) return false; + if (in.status() != QDataStream::Ok || pts < 0 || correction < 0 + || !(usage == Usage::Stream ? validStreamSize(w, h) : validSize(w, h)) || !pixels) return false; const qint64 now = call_video_playout_now_us(); const bool current = owner && enabled && revision == generation && !failureReported; if (current && pts <= now && now - pts <= VideoCaptureMaxFrameAgeUs) { @@ -191,8 +231,8 @@ struct VideoCapture::Session : QObject { } }; -VideoCapture::VideoCapture(QObject* parent) : QObject(parent), m(new Session(this)) {} +VideoCapture::VideoCapture(QObject* parent, Usage usage) : QObject(parent), m(new Session(this, usage)) {} VideoCapture::~VideoCapture() { m->shutdown(); } -void VideoCapture::configure(bool enabled, const QByteArray& device, int width, int height, int fps) { - m->configure(enabled, device, width, height, fps); -} +void VideoCapture::configure(const VideoCaptureConfig& config) { m->configure(config); } +void VideoCapture::stop() { m->stop(); } +bool VideoCapture::closing() const { return m->stopping; } diff --git a/tools/chatgui/src/video_capture_source.h b/tools/chatgui/src/video_capture_source.h index c7cf78ade..792c965a4 100644 --- a/tools/chatgui/src/video_capture_source.h +++ b/tools/chatgui/src/video_capture_source.h @@ -12,11 +12,12 @@ class VideoCaptureSource : public QObject { Q_OBJECT public: /* Возвращает текущий полный список с аппаратными размерами/FPS передачи, допустимыми для звонка. */ - virtual VideoCaptureDevices devices() = 0; + virtual VideoCaptureDevices devices(bool stream) = 0; /* Запрашивает точный device/размер и предел FPS выдачи; worker вызывает stop перед каждым start. * true — запуск принят, готовность наступает с frame; отказ/асинхронная ошибка сообщаются также сигналом error. * Сам return false не создаёт IPC-ошибку. Qt backend выбирает подходящий формат без масштабирования кадров. */ - virtual bool start(const QByteArray& device, int width, int height, int fps) = 0; + virtual bool start(const VideoCaptureConfig& config) = 0; + virtual bool prepareImage(QImage&) { return true; } // Наложение курсора до IPC; только worker event loop. /* Освобождает захват; должен допускать вызов без успешного start и повтор при уничтожении worker. */ virtual void stop() = 0; signals: @@ -26,9 +27,10 @@ signals: void frame(const QVideoFrame& frame); /* Текст ошибки, передаётся GUI с поколением активной конфигурации. */ void error(const QString& message); + void stage(const QString& name); // Перед аппаратным вызовом; supervisor сохраняет последний этап при зависании. }; /* Забирает ненулевой source, подключается к endpoint GUI и выполняет QCoreApplication::exec. * Qt application уже должен существовать, event loop ещё не запущен; возвращает его exit code. * При выходе останавливает/уничтожает backend; предназначен только для отдельного процесса. */ -int video_capture_worker_run(const QString& endpoint, std::unique_ptr source); +int video_capture_worker_run(const QString& endpoint, std::unique_ptr source, bool stream = false); #endif diff --git a/tools/chatgui/src/video_capture_worker.cpp b/tools/chatgui/src/video_capture_worker.cpp index 3b6c9ee66..6b6ba681f 100644 --- a/tools/chatgui/src/video_capture_worker.cpp +++ b/tools/chatgui/src/video_capture_worker.cpp @@ -21,70 +21,197 @@ #include #include #include +#include +#include +#include +#include +#include +#include +#include +#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 camera; + std::unique_ptr screen; + std::unique_ptr window; std::unique_ptr session; std::unique_ptr sink; QMediaDevices devicesMonitor; + QTimer grabTimer; + QPointer selectedScreen; + QHash windows; + quint64 nextWindow = 0; CallCameraRate rate; +#ifdef UTUN_STREAM_PORTAL + std::unique_ptr portal; +#endif +#if defined(UTUN_STREAM_X11_CURSOR) || defined(UTUN_STREAM_WIN_CURSOR) + std::unique_ptr 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); + connect(qGuiApp, &QGuiApplication::screenAdded, this, &VideoCaptureSource::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() override { + 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(); - DEBUG_DEBUG(DEBUG_CATEGORY_CALL, "camera capability device=%s size=%dx%d pixel=%d fps=%.3f..%.3f", - device.id().constData(), size.width(), size.height(), format.pixelFormat(), format.minFrameRate(), format.maxFrameRate()); - if (validSize(size.width(), size.height())) + 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_INFO(DEBUG_CATEGORY_CALL, "camera modes device=%s count=%lld limit=1920x1080 output_fps<=60", - device.id().constData(), (long long)entry.modes.size()); + 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 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 = "window-" + QByteArray::number(++nextWindow); + current.insert(id, item); + result.append({item.description(), id, {}, VideoCaptureKind::Window, {}}); + } + windows = std::move(current); return result; } - bool start(const QByteArray& device, int width, int height, int fps) override { - QCameraDevice selected; - for (const auto& item : QMediaDevices::videoInputs()) if (item.id() == device) selected = item; - if (selected.isNull()) { emit error(QStringLiteral("Camera is unavailable")); return false; } + bool start(const VideoCaptureConfig& config) override { + emit stage(QStringLiteral("session.create")); session = std::make_unique(); sink = std::make_unique(); - camera = std::make_unique(selected); - session->setCamera(camera.get()); session->setVideoSink(sink.get()); - QCameraFormat best; - for (const auto& format : selected.videoFormats()) { - if (!stream_video_camera_supports(format.resolution(), format.minFrameRate(), format.maxFrameRate(), - {QSize(width, height), fps})) continue; - if (best.isNull() || format.maxFrameRate() < best.maxFrameRate()) best = format; - } - if (best.isNull()) { - DEBUG_ERROR(DEBUG_CATEGORY_CALL, "camera mode unavailable device=%s size=%dx%d output_fps=%d", device.constData(), width, height, fps); - emit error(QStringLiteral("Selected camera mode is unavailable")); return false; - } - camera->setCameraFormat(best); - const auto format = camera->cameraFormat(); - DEBUG_INFO(DEBUG_CATEGORY_CALL, "camera selected device=%s size=%dx%d pixel=%d capture_fps=%.3f..%.3f output_fps=%d", - device.constData(), format.resolution().width(), format.resolution().height(), format.pixelFormat(), - format.minFrameRate(), format.maxFrameRate(), fps); - connect(camera.get(), &QCamera::activeChanged, this, [this, device](bool active) { - if (active) rate.activate(device); else rate.restore(); - }); - connect(camera.get(), &QCamera::errorOccurred, this, [this](QCamera::Error, const QString& message) { emit error(message); }); + session->setVideoSink(sink.get()); connect(sink.get(), &QVideoSink::videoFrameChanged, this, &VideoCaptureSource::frame, Qt::DirectConnection); - camera->start(); return true; + 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(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(); + }); + 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(); + 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(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(); screen->setScreen(selectedScreen); session->setScreenCapture(screen.get()); + connect(screen.get(), &QScreenCapture::errorOccurred, this, + [this](QScreenCapture::Error, const QString& message) { fail(message); }); + 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(); window->setWindow(windows.value(config.device)); + session->setWindowCapture(window.get()); + connect(window.get(), &QWindowCapture::errorOccurred, this, + [this](QWindowCapture::Error, const QString& message) { fail(message); }); + 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 && !cursor->draw(image)) { fail(QStringLiteral("Mouse cursor capture failed")); return false; } +#else + Q_UNUSED(image); +#endif + return true; } void stop() override { + grabTimer.stop(); disconnect(&grabTimer, nullptr, this, nullptr); if (sink) disconnect(sink.get(), nullptr, this, nullptr); - if (camera) { disconnect(camera.get(), nullptr, this, nullptr); camera->stop(); } - rate.restore(); session.reset(); camera.reset(); sink.reset(); +#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(); } + emit stage(QStringLiteral("camera-rate.restore")); rate.restore(); + emit stage(QStringLiteral("session.destroy")); session.reset(); + emit stage(QStringLiteral("camera.destroy")); camera.reset(); + emit stage(QStringLiteral("screen.destroy")); screen.reset(); + emit stage(QStringLiteral("window.destroy")); window.reset(); + emit stage(QStringLiteral("sink.destroy")); sink.reset(); +#if defined(UTUN_STREAM_X11_CURSOR) || defined(UTUN_STREAM_WIN_CURSOR) + cursor.reset(); +#endif + selectedScreen = nullptr; } }; @@ -96,6 +223,7 @@ class VideoCaptureWorker : public QObject { bool posted = false; }; QLocalSocket socket; + QTimer heartbeat; VideoCaptureBuffer buffer; uchar* pixels = nullptr; Reader reader; @@ -106,6 +234,8 @@ class VideoCaptureWorker : public QObject { 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; @@ -121,11 +251,11 @@ class VideoCaptureWorker : public QObject { void enumerate() { if (socket.state() != QLocalSocket::ConnectedState) return; // Первичный опрос повторит connected. stage(QStringLiteral("enumerate")); - const auto devices = source->devices(); + 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()); + 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); } })); @@ -159,17 +289,34 @@ class VideoCaptureWorker : public QObject { DEBUG_ERROR(DEBUG_CATEGORY_CALL, "camera frame conversion failed"); send(packet(Error, generation, [](QDataStream& out) { out << QStringLiteral("Camera frame conversion failed"); })); return; } - if (image.size() != QSize(width, height)) { + if (!source->prepareImage(image)) return; +#if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0) + if (raw.rotation() != QtVideo::Rotation::None) image = image.transformed(QTransform().rotate(static_cast(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 (config.kind == VideoCaptureKind::Camera && image.size() != QSize(width, height)) { DEBUG_ERROR(DEBUG_CATEGORY_CALL, "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 && 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 < height; ++row) std::memcpy(pixels + size_t(row) * width * 4, image.constScanLine(row), size_t(width) * 4); + 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(image.width()) << qint32(image.height()); + out << pts << qint64(clock.correction) << qint32(outputWidth) << qint32(outputHeight); }); sending = true; inFlight = generation; lastPts = pts; send(bytes); ++frames; } else DEBUG_WARN(DEBUG_CATEGORY_CALL, "camera conversion exceeded frame age budget age_us=%lld", (long long)(converted - pts)); @@ -183,19 +330,24 @@ class VideoCaptureWorker : public QObject { } bool receive(quint8 type, quint64 revision, QDataStream& in) { if (type == Buffer) { - QString name; in >> name; + QString name; quint32 capacity = 0; in >> name >> capacity; if (pixels) return false; - if (!buffer.attach(name)) { + if (capacity != (stream ? MaxFrameBytes : FrameBytes) || !buffer.attach(name, capacity)) { DEBUG_ERROR(DEBUG_CATEGORY_CALL, "camera frame mapping failed: %s", qPrintable(buffer.errorString())); return false; } pixels = buffer.data(); - } else if (type == Quit) { stop(); QCoreApplication::quit(); } + } 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; QByteArray device; qint32 w = 0, h = 0, rate = 0; in >> enabled >> device >> w >> h >> rate; - if (in.status() != QDataStream::Ok || !validSize(w, h) || rate < 1 || rate > 60 || !pixels) return false; - stop(); generation = revision; width = w; height = h; fps = rate; clock = {}; cadence = CallVideoCadence(rate); lastPts = -1; + 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(); @@ -214,12 +366,16 @@ class VideoCaptureWorker : public QObject { post = !slot->posted; slot->posted = true; } if (post) QMetaObject::invokeMethod(this, [this, slot, revision] { convert(slot, revision); }, Qt::QueuedConnection); }, Qt::DirectConnection); - if (source->start(device, width, height, fps)) stage(QStringLiteral("running")); + if (source->start(config)) stage(QStringLiteral("running")); } else return false; return true; } public: - explicit VideoCaptureWorker(std::unique_ptr backend) : source(std::move(backend)) { + explicit VideoCaptureWorker(std::unique_ptr 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] { @@ -232,12 +388,17 @@ public: DEBUG_ERROR(DEBUG_CATEGORY_CALL, "camera worker IPC: %s", qPrintable(socket.errorString())); QCoreApplication::exit(2); }); } - ~VideoCaptureWorker() override { disconnect(captureConnection); source->stop(); } + ~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 source) { - VideoCaptureWorker worker(std::move(source)); worker.connectTo(endpoint); return QCoreApplication::exec(); +int video_capture_worker_run(const QString& endpoint, std::unique_ptr source, bool stream) { + VideoCaptureWorker worker(std::move(source), stream); worker.connectTo(endpoint); return QCoreApplication::exec(); } #endif @@ -249,8 +410,10 @@ int video_capture_worker_main(int argc, char** argv) { const UINT codePage = GetACP(); DEBUG_INFO(DEBUG_CATEGORY_CALL, "camera worker Windows code_page=%u Qt=%s camera_errors=Unicode", codePage, qVersion()); #endif - if (argc != 3) { DEBUG_ERROR(DEBUG_CATEGORY_CALL, "camera worker endpoint missing"); return 2; } - return video_capture_worker_run(QString::fromLocal8Bit(argv[2]), std::make_unique()); + 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(), !std::strcmp(argv[3], "stream")); #else Q_UNUSED(argc); Q_UNUSED(argv); return 2; #endif