evgeny
3 days ago
13 changed files with 915 additions and 115 deletions
@ -0,0 +1,79 @@
|
||||
#pragma once |
||||
#include "call_camera_protocol.h" |
||||
#include "debug_config.h" |
||||
#include <QUuid> |
||||
#ifdef Q_OS_WIN |
||||
#include <qt_windows.h> |
||||
#else |
||||
#include <QTemporaryFile> |
||||
#include <memory> |
||||
#endif |
||||
|
||||
// Владение пикселями задаётся FRAME/ACK. Закрытие mapping никогда не ждёт другой процесс.
|
||||
class CallCameraBuffer { |
||||
QString m_name, m_error; |
||||
uchar* m_data = nullptr; |
||||
#ifdef Q_OS_WIN |
||||
HANDLE m_mapping = nullptr; |
||||
#else |
||||
std::unique_ptr<QFile> m_file; |
||||
#endif |
||||
bool fail(const QString& error) { m_error = error; close(); return false; } |
||||
bool map() { |
||||
#ifdef Q_OS_WIN |
||||
m_data = static_cast<uchar*>(MapViewOfFile(m_mapping, FILE_MAP_WRITE, 0, 0, CallCameraProtocol::FrameBytes)); |
||||
if (!m_data) return fail(QStringLiteral("MapViewOfFile error=%1").arg(GetLastError())); |
||||
#else |
||||
m_data = m_file->map(0, CallCameraProtocol::FrameBytes); |
||||
if (!m_data) return fail(m_file->errorString()); |
||||
#endif |
||||
return true; |
||||
} |
||||
public: |
||||
CallCameraBuffer() = default; |
||||
CallCameraBuffer(const CallCameraBuffer&) = delete; |
||||
CallCameraBuffer& operator=(const CallCameraBuffer&) = delete; |
||||
~CallCameraBuffer() { close(); } |
||||
bool create() { |
||||
close(); |
||||
#ifdef Q_OS_WIN |
||||
m_name = QStringLiteral("Local\\vibechat-camera-") + QUuid::createUuid().toString(QUuid::Id128); |
||||
m_mapping = CreateFileMappingW(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE, 0, CallCameraProtocol::FrameBytes, |
||||
reinterpret_cast<const wchar_t*>(m_name.utf16())); |
||||
const DWORD error = GetLastError(); |
||||
if (!m_mapping || error == ERROR_ALREADY_EXISTS) return fail(QStringLiteral("CreateFileMapping error=%1").arg(error)); |
||||
#else |
||||
auto file = std::make_unique<QTemporaryFile>(); |
||||
if (!file->open() || !file->resize(CallCameraProtocol::FrameBytes)) return fail(file->errorString()); |
||||
m_name = file->fileName(); m_file = std::move(file); |
||||
#endif |
||||
return map(); |
||||
} |
||||
bool attach(const QString& name) { |
||||
close(); m_name = name; |
||||
#ifdef Q_OS_WIN |
||||
m_mapping = OpenFileMappingW(FILE_MAP_WRITE, FALSE, reinterpret_cast<const wchar_t*>(name.utf16())); |
||||
if (!m_mapping) return fail(QStringLiteral("OpenFileMapping error=%1").arg(GetLastError())); |
||||
#else |
||||
m_file = std::make_unique<QFile>(name); |
||||
if (!m_file->open(QIODevice::ReadWrite | QIODevice::ExistingOnly)) return fail(m_file->errorString()); |
||||
if (m_file->size() != CallCameraProtocol::FrameBytes) return fail(QStringLiteral("Invalid camera buffer size")); |
||||
#endif |
||||
return map(); |
||||
} |
||||
void close() { |
||||
#ifdef Q_OS_WIN |
||||
if (m_data && !UnmapViewOfFile(m_data)) |
||||
DEBUG_WARN(DEBUG_CATEGORY_CALL, "camera buffer unmap error=%lu", (unsigned long)GetLastError()); |
||||
if (m_mapping && !CloseHandle(m_mapping)) |
||||
DEBUG_WARN(DEBUG_CATEGORY_CALL, "camera buffer close error=%lu", (unsigned long)GetLastError()); |
||||
m_mapping = nullptr; |
||||
#else |
||||
m_file.reset(); |
||||
#endif |
||||
m_data = nullptr; |
||||
} |
||||
uchar* data() const { return m_data; } |
||||
QString name() const { return m_name; } |
||||
QString errorString() const { return m_error; } |
||||
}; |
||||
@ -0,0 +1,186 @@
|
||||
#include "call_camera_capture.h" |
||||
#include "call_camera_protocol.h" |
||||
#include "call_camera_buffer.h" |
||||
#include "../../../src/call/call_video_playout.h" |
||||
#include "debug_config.h" |
||||
#include <QCoreApplication> |
||||
#include <QLocalServer> |
||||
#include <QPointer> |
||||
#include <QProcess> |
||||
#include <QTimer> |
||||
#include <QUuid> |
||||
#include <atomic> |
||||
#include <cstring> |
||||
|
||||
using namespace CallCameraProtocol; |
||||
|
||||
struct CallCameraCapture::Session : QObject { |
||||
QPointer<CallCameraCapture> owner; |
||||
QLocalServer server; |
||||
QProcess process; |
||||
QLocalSocket* socket = nullptr; |
||||
QTimer watchdog; |
||||
CallCameraBuffer buffer; |
||||
uchar* pixels = nullptr; |
||||
Reader reader; |
||||
quint64 generation = 0; |
||||
bool enabled = false, retiring = false, failureReported = false, restartRequested = false, exiting = false; |
||||
QByteArray device; |
||||
int width = 640, height = 480; |
||||
QString phase = QStringLiteral("launch"); |
||||
qint64 progressAt = 0, frameAt = 0, stopAt = 0; |
||||
|
||||
explicit Session(CallCameraCapture* target) : owner(target) { |
||||
server.setSocketOptions(QLocalServer::UserAccessOption); |
||||
connect(&server, &QLocalServer::newConnection, this, [this] { |
||||
auto* connection = server.nextPendingConnection(); |
||||
if (socket) { connection->abort(); connection->deleteLater(); return; } |
||||
socket = connection; socket->setParent(this); socket->setReadBufferSize(MaxPacket + 4); |
||||
server.close(); progressAt = call_video_playout_now_us(); |
||||
connect(socket, &QLocalSocket::readyRead, this, [this] { |
||||
if (!reader.read(*socket, [this](quint8 type, quint64 revision, QDataStream& in) { return receive(type, revision, in); })) |
||||
fail(QStringLiteral("Invalid camera worker response")); |
||||
}); |
||||
if (retiring) send(packet(Quit, generation)); |
||||
else { |
||||
send(packet(Buffer, 0, [this](QDataStream& out) { out << buffer.name(); })); |
||||
sendConfiguration(); |
||||
} |
||||
}); |
||||
process.setProcessChannelMode(QProcess::MergedChannels); |
||||
connect(&process, &QProcess::readyReadStandardOutput, this, [this] { |
||||
const auto log = process.readAllStandardOutput().trimmed(); |
||||
for (const auto& line : log.split('\n')) { |
||||
if (line.isEmpty()) continue; |
||||
if (line.contains("[ERROR]")) DEBUG_ERROR(DEBUG_CATEGORY_CALL, "camera worker: %s", line.constData()); |
||||
else if (line.contains("[WARN]")) DEBUG_WARN(DEBUG_CATEGORY_CALL, "camera worker: %s", line.constData()); |
||||
else if (line.contains("[DEBUG]")) DEBUG_DEBUG(DEBUG_CATEGORY_CALL, "camera worker: %s", line.constData()); |
||||
else DEBUG_INFO(DEBUG_CATEGORY_CALL, "camera worker: %s", line.constData()); |
||||
} |
||||
}); |
||||
connect(&process, &QProcess::errorOccurred, this, [this](QProcess::ProcessError error) { |
||||
if (error == QProcess::FailedToStart) { |
||||
fail(QStringLiteral("Cannot start camera worker: %1").arg(process.errorString())); |
||||
if (retiring) deleteLater(); |
||||
} |
||||
}); |
||||
connect(&process, QOverload<int, QProcess::ExitStatus>::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); |
||||
if (socket) { socket->disconnect(this); socket->deleteLater(); socket = nullptr; } |
||||
server.close(); watchdog.stop(); |
||||
if (retiring) deleteLater(); |
||||
else if (restartRequested) { restartRequested = false; launch(); } |
||||
else if (!failureReported) fail(QStringLiteral("Camera worker stopped")); |
||||
}); |
||||
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)); |
||||
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))) { |
||||
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")); |
||||
} |
||||
}); |
||||
// При выходе приложения не вызываем деструктор живого QProcess: он синхронно ждёт child.
|
||||
connect(qApp, &QCoreApplication::aboutToQuit, this, [this] { |
||||
exiting = true; enabled = false; failureReported = true; restartRequested = false; process.kill(); |
||||
buffer.close(); pixels = nullptr; |
||||
}); |
||||
QTimer::singleShot(0, this, [this] { if (!retiring && !generation && !failureReported) launch(); }); |
||||
} |
||||
void launch() { |
||||
if (exiting || process.state() != QProcess::NotRunning) return; |
||||
server.close(); |
||||
reader = {}; failureReported = false; phase = QStringLiteral("launch"); progressAt = call_video_playout_now_us(); |
||||
if (!pixels) { |
||||
if (!buffer.create()) { |
||||
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("--call-camera-worker"), server.fullServerName()}); |
||||
watchdog.start(); |
||||
} |
||||
void send(const QByteArray& data) { |
||||
if (!socket || socket->state() != QLocalSocket::ConnectedState) return; |
||||
if (socket->write(data) != data.size()) fail(QStringLiteral("Cannot write camera IPC")); |
||||
socket->flush(); |
||||
} |
||||
void sendConfiguration() { |
||||
send(packet(Configure, generation, [this](QDataStream& out) { out << enabled << device << qint32(width) << qint32(height); })); |
||||
} |
||||
void configure(bool active, const QByteArray& id, int w, int h) { |
||||
if (exiting) return; |
||||
if (enabled == active && device == id && width == w && height == h && !failureReported) return; |
||||
enabled = active; device = id; width = w; height = h; ++generation; |
||||
progressAt = call_video_playout_now_us(); |
||||
frameAt = progressAt; |
||||
stopAt = active ? 0 : progressAt + 1500000; |
||||
DEBUG_INFO(DEBUG_CATEGORY_CALL, "camera request generation=%llu enabled=%d size=%dx%d device=%s", |
||||
(unsigned long long)generation, active, w, h, id.constData()); |
||||
if (failureReported && active) restartRequested = true; |
||||
if (process.state() == QProcess::NotRunning) { restartRequested = false; launch(); } |
||||
if (socket) sendConfiguration(); |
||||
} |
||||
void shutdown() { |
||||
owner = nullptr; retiring = true; enabled = false; ++generation; |
||||
if (process.state() == QProcess::NotRunning) { deleteLater(); return; } |
||||
stopAt = call_video_playout_now_us() + 1500000; watchdog.start(); send(packet(Quit, generation)); |
||||
} |
||||
void fail(const QString& error) { |
||||
if (failureReported) return; |
||||
failureReported = true; enabled = false; restartRequested = false; stopAt = 0; |
||||
DEBUG_ERROR(DEBUG_CATEGORY_CALL, "camera worker failure phase=%s: %s", qPrintable(phase), qPrintable(error)); |
||||
process.kill(); |
||||
if (owner) emit owner->failed(error); |
||||
} |
||||
bool receive(quint8 type, quint64 revision, QDataStream& in) { |
||||
if (type == Devices) { |
||||
quint32 count = 0; in >> count; |
||||
if (in.status() != QDataStream::Ok || count > 128) return false; |
||||
CallCameraDevices devices; |
||||
for (quint32 i = 0; i < count; ++i) { QString name; QByteArray id; in >> name >> id; devices.append({name, id}); } |
||||
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; |
||||
} 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 || w < 1 || h < 1 || w > 1280 || h > 720 || !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 <= CallCameraMaxFrameAgeUs) { |
||||
QImage image(w, h, QImage::Format_RGB32); |
||||
if (image.isNull()) return false; |
||||
std::atomic_thread_fence(std::memory_order_acquire); |
||||
std::memcpy(image.bits(), pixels, size_t(w) * h * 4); |
||||
progressAt = frameAt = now; |
||||
send(packet(Ack, revision)); |
||||
emit owner->frameReady(image, pts, correction); |
||||
return true; |
||||
} else { |
||||
if (current) DEBUG_WARN(DEBUG_CATEGORY_CALL, "camera dropped stale frame age_us=%lld", (long long)(now - pts)); |
||||
} |
||||
send(packet(Ack, revision)); |
||||
} else return false; |
||||
return true; |
||||
} |
||||
}; |
||||
|
||||
CallCameraCapture::CallCameraCapture(QObject* parent) : QObject(parent), m(new Session(this)) {} |
||||
CallCameraCapture::~CallCameraCapture() { m->shutdown(); } |
||||
void CallCameraCapture::configure(bool enabled, const QByteArray& device, int width, int height) { |
||||
m->configure(enabled, device, width, height); |
||||
} |
||||
@ -0,0 +1,26 @@
|
||||
#pragma once |
||||
#include <QObject> |
||||
#include <QImage> |
||||
#include <QList> |
||||
|
||||
using CallCameraDevices = QList<QPair<QString, QByteArray>>; |
||||
constexpr qint64 CallCameraMaxFrameAgeUs = 250000; |
||||
|
||||
// GUI получает только собственную CPU-память. Процесс захвата завершается асинхронно.
|
||||
class CallCameraCapture : public QObject { |
||||
Q_OBJECT |
||||
public: |
||||
explicit CallCameraCapture(QObject* parent = nullptr); |
||||
~CallCameraCapture() override; |
||||
void configure(bool enabled, const QByteArray& device = {}, int width = 640, int height = 480); |
||||
signals: |
||||
void devicesChanged(const CallCameraDevices& devices); |
||||
void frameReady(const QImage& image, qint64 pts, qint64 correction); |
||||
void failed(const QString& error); |
||||
private: |
||||
struct Session; |
||||
Session* m; |
||||
}; |
||||
|
||||
// Вызывается до обычной инициализации приложения, конфига, БД и single-instance lock.
|
||||
int call_camera_worker_main(int argc, char** argv); |
||||
@ -0,0 +1,45 @@
|
||||
#pragma once |
||||
#include <QDataStream> |
||||
#include <QLocalSocket> |
||||
#include <QByteArray> |
||||
#include <functional> |
||||
|
||||
namespace CallCameraProtocol { |
||||
enum Type : quint8 { Configure = 1, Quit, Ack, Devices, Frame, Stage, Error, Buffer }; |
||||
constexpr quint32 FrameBytes = 1280 * 720 * 4; |
||||
constexpr quint32 MaxPacket = 65536; |
||||
|
||||
// Только команды и метаданные. Пиксели — в mapping с владением Frame -> Ack, без shared mutex.
|
||||
inline QByteArray packet(Type type, quint64 generation, const std::function<void(QDataStream&)>& write = {}) { |
||||
QByteArray result; |
||||
QDataStream out(&result, QIODevice::WriteOnly); out.setVersion(QDataStream::Qt_5_15); |
||||
out << quint32(0) << quint8(type) << generation; |
||||
if (write) write(out); |
||||
out.device()->seek(0); out << quint32(result.size() - 4); |
||||
return result; |
||||
} |
||||
|
||||
class Reader { |
||||
QByteArray pending; |
||||
quint32 length = 0; |
||||
public: |
||||
bool read(QLocalSocket& socket, const std::function<bool(quint8, quint64, QDataStream&)>& consume) { |
||||
while (socket.bytesAvailable()) { |
||||
const qsizetype wanted = length ? length : 4; |
||||
pending += socket.read(wanted - pending.size()); |
||||
if (pending.size() != wanted) return true; |
||||
QDataStream in(pending); in.setVersion(QDataStream::Qt_5_15); |
||||
if (!length) { |
||||
in >> length; pending.clear(); |
||||
if (length < 9 || length > MaxPacket) return false; |
||||
} else { |
||||
quint8 type; quint64 generation; in >> type >> generation; |
||||
bool valid = consume(type, generation, in) && in.status() == QDataStream::Ok && in.atEnd(); |
||||
pending.clear(); length = 0; |
||||
if (!valid) return false; |
||||
} |
||||
} |
||||
return true; |
||||
} |
||||
}; |
||||
} |
||||
@ -0,0 +1,20 @@
|
||||
#pragma once |
||||
#include "call_camera_capture.h" |
||||
#ifdef HAVE_STREAM_CAPTURE |
||||
#include <QVideoFrame> |
||||
#include <functional> |
||||
#include <memory> |
||||
|
||||
// Backend принадлежит только процессу захвата; тесты подставляют неисправное устройство.
|
||||
class CallCameraSource : public QObject { |
||||
Q_OBJECT |
||||
public: |
||||
virtual CallCameraDevices devices() = 0; |
||||
virtual bool start(const QByteArray& device, int width, int height) = 0; |
||||
virtual void stop() = 0; |
||||
signals: |
||||
void frame(const QVideoFrame& frame); |
||||
void error(const QString& message); |
||||
}; |
||||
int call_camera_worker_run(const QString& endpoint, std::unique_ptr<CallCameraSource> source); |
||||
#endif |
||||
@ -0,0 +1,216 @@
|
||||
#include "call_camera_source.h" |
||||
#include "call_camera_protocol.h" |
||||
#include "call_camera_buffer.h" |
||||
#include "call_video_capture_clock.h" |
||||
#include "call_camera_rate.h" |
||||
#include "../../../src/call/call_video_playout.h" |
||||
#include "debug_config.h" |
||||
#include <QGuiApplication> |
||||
#include <QTimer> |
||||
#include <mutex> |
||||
#include <climits> |
||||
#include <algorithm> |
||||
#include <atomic> |
||||
#include <cstring> |
||||
#ifdef HAVE_STREAM_CAPTURE |
||||
#include <QCamera> |
||||
#include <QMediaDevices> |
||||
#include <QMediaCaptureSession> |
||||
#include <QVideoSink> |
||||
|
||||
using namespace CallCameraProtocol; |
||||
|
||||
class QtCallCameraSource : public CallCameraSource { |
||||
std::unique_ptr<QCamera> camera; |
||||
std::unique_ptr<QMediaCaptureSession> session; |
||||
std::unique_ptr<QVideoSink> sink; |
||||
CallCameraRate rate; |
||||
public: |
||||
~QtCallCameraSource() override { stop(); } |
||||
CallCameraDevices devices() override { |
||||
CallCameraDevices result; |
||||
for (const auto& device : QMediaDevices::videoInputs()) result.append({device.description(), device.id()}); |
||||
return result; |
||||
} |
||||
bool start(const QByteArray& device, int width, int height) 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; } |
||||
session = std::make_unique<QMediaCaptureSession>(); sink = std::make_unique<QVideoSink>(); |
||||
camera = std::make_unique<QCamera>(selected); |
||||
session->setCamera(camera.get()); session->setVideoSink(sink.get()); |
||||
QCameraFormat best; int distance = INT_MAX; |
||||
for (const auto& format : selected.videoFormats()) { |
||||
if (format.maxFrameRate() < 29.9) continue; |
||||
int score = std::abs(format.resolution().width() - width) + std::abs(format.resolution().height() - height); |
||||
if (score < distance) { best = format; distance = score; } |
||||
} |
||||
if (!best.isNull()) camera->setCameraFormat(best); |
||||
const auto format = camera->cameraFormat(); |
||||
DEBUG_INFO(DEBUG_CATEGORY_CALL, "camera selected device=%s size=%dx%d pixel=%d fps=%.3f..%.3f", |
||||
device.constData(), format.resolution().width(), format.resolution().height(), format.pixelFormat(), |
||||
format.minFrameRate(), format.maxFrameRate()); |
||||
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); }); |
||||
connect(sink.get(), &QVideoSink::videoFrameChanged, this, &CallCameraSource::frame, Qt::DirectConnection); |
||||
camera->start(); return true; |
||||
} |
||||
void stop() override { |
||||
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(); |
||||
} |
||||
}; |
||||
|
||||
class CameraWorker : public QObject { |
||||
struct Pending { |
||||
std::mutex lock; |
||||
QVideoFrame raw; |
||||
qint64 arrival = 0; |
||||
bool posted = false; |
||||
}; |
||||
QLocalSocket socket; |
||||
CallCameraBuffer buffer; |
||||
uchar* pixels = nullptr; |
||||
Reader reader; |
||||
std::unique_ptr<CallCameraSource> source; |
||||
std::shared_ptr<Pending> pending; |
||||
QMetaObject::Connection captureConnection, errorConnection; |
||||
CallVideoCaptureClock clock; |
||||
quint64 generation = 0, inFlight = 0; |
||||
bool sending = false; |
||||
int width = 640, height = 480; |
||||
qint64 lastPts = -1, reportAt = 0, convertMax = 0; |
||||
unsigned frames = 0; |
||||
|
||||
void send(const QByteArray& data) { |
||||
if (socket.write(data) != data.size()) { |
||||
DEBUG_ERROR(DEBUG_CATEGORY_CALL, "camera 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 stop() { |
||||
stage(QStringLiteral("stop")); |
||||
disconnect(captureConnection); disconnect(errorConnection); source->stop(); pending.reset(); |
||||
DEBUG_INFO(DEBUG_CATEGORY_CALL, "camera 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; qint64 arrival; |
||||
{ 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_CALL, "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 > CallCameraMaxFrameAgeUs) { |
||||
DEBUG_WARN(DEBUG_CATEGORY_CALL, "camera skips old frame age_us=%lld pts=%lld last=%lld", |
||||
(long long)(started - pts), (long long)pts, (long long)lastPts); return; |
||||
} |
||||
stage(QStringLiteral("convert")); |
||||
QImage image = raw.toImage(); |
||||
if (image.isNull()) { |
||||
DEBUG_ERROR(DEBUG_CATEGORY_CALL, "camera frame conversion failed"); |
||||
send(packet(Error, generation, [](QDataStream& out) { out << QStringLiteral("Camera frame conversion failed"); })); return; |
||||
} |
||||
if (image.width() > width || image.height() > height) image = image.scaled(width, height, Qt::KeepAspectRatio, Qt::FastTransformation); |
||||
image = image.convertToFormat(QImage::Format_RGB32); |
||||
const qint64 converted = call_video_playout_now_us(); |
||||
if (converted - pts <= CallCameraMaxFrameAgeUs) { |
||||
std::memcpy(pixels, image.constBits(), size_t(image.width()) * image.height() * 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()); |
||||
}); |
||||
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)); |
||||
stage(QStringLiteral("release")); image = {}; raw = {}; stage(QStringLiteral("running")); |
||||
convertMax = std::max(convertMax, call_video_playout_now_us() - started); |
||||
if (started - reportAt >= 1000000) { |
||||
DEBUG_DEBUG(DEBUG_CATEGORY_CALL, "camera flow frames=%u convert_max_us=%lld age_us=%lld clock_correction_us=%lld", |
||||
frames, (long long)convertMax, (long long)(converted - pts), (long long)clock.correction); |
||||
reportAt = started; convertMax = 0; frames = 0; |
||||
} |
||||
} |
||||
bool receive(quint8 type, quint64 revision, QDataStream& in) { |
||||
if (type == Buffer) { |
||||
QString name; in >> name; |
||||
if (pixels) return false; |
||||
if (!buffer.attach(name)) { |
||||
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 == 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; in >> enabled >> device >> w >> h; |
||||
if (in.status() != QDataStream::Ok || w < 1 || h < 1 || w > 1280 || h > 720 || !pixels) return false; |
||||
stop(); generation = revision; width = w; height = h; clock = {}; lastPts = -1; |
||||
if (!enabled) { stage(QStringLiteral("idle")); return true; } |
||||
stage(QStringLiteral("start")); |
||||
pending = std::make_shared<Pending>(); |
||||
errorConnection = connect(source.get(), &CallCameraSource::error, this, [this, revision](const QString& error) { |
||||
if (revision != generation) return; |
||||
DEBUG_ERROR(DEBUG_CATEGORY_CALL, "camera backend: %s", qPrintable(error)); |
||||
send(packet(Error, revision, [&](QDataStream& out) { out << error; })); |
||||
}, Qt::QueuedConnection); |
||||
captureConnection = connect(source.get(), &CallCameraSource::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(device, width, height)) stage(QStringLiteral("running")); |
||||
} else return false; |
||||
return true; |
||||
} |
||||
public: |
||||
explicit CameraWorker(std::unique_ptr<CallCameraSource> backend) : source(std::move(backend)) { |
||||
connect(&socket, &QLocalSocket::connected, this, [this] { |
||||
stage(QStringLiteral("enumerate")); |
||||
const auto devices = source->devices(); |
||||
send(packet(Devices, 0, [&](QDataStream& out) { |
||||
out << quint32(devices.size()); for (const auto& device : devices) out << device.first << device.second; |
||||
})); |
||||
stage(QStringLiteral("idle")); |
||||
}); |
||||
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_CALL, "camera 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_CALL, "camera worker IPC: %s", qPrintable(socket.errorString())); QCoreApplication::exit(2); |
||||
}); |
||||
} |
||||
~CameraWorker() override { disconnect(captureConnection); source->stop(); } |
||||
void connectTo(const QString& endpoint) { socket.connectToServer(endpoint); } |
||||
}; |
||||
|
||||
int call_camera_worker_run(const QString& endpoint, std::unique_ptr<CallCameraSource> source) { |
||||
CameraWorker worker(std::move(source)); worker.connectTo(endpoint); return QCoreApplication::exec(); |
||||
} |
||||
#endif |
||||
|
||||
int call_camera_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_CALL, DEBUG_LEVEL_DEBUG); |
||||
if (argc != 3) { DEBUG_ERROR(DEBUG_CATEGORY_CALL, "camera worker endpoint missing"); return 2; } |
||||
return call_camera_worker_run(QString::fromLocal8Bit(argv[2]), std::make_unique<QtCallCameraSource>()); |
||||
#else |
||||
Q_UNUSED(argc); Q_UNUSED(argv); return 2; |
||||
#endif |
||||
} |
||||
@ -0,0 +1,217 @@
|
||||
#include "../src/call_camera_source.h" |
||||
#include "../src/call_camera_buffer.h" |
||||
#include "../../../src/call/call_video_playout.h" |
||||
#include "debug_config.h" |
||||
#include <QtTest> |
||||
#include <QGuiApplication> |
||||
#include <QFile> |
||||
#include <QTemporaryDir> |
||||
#include <QTimer> |
||||
#include <QProcess> |
||||
#ifdef TEST_CALL_VIDEO_ENGINE |
||||
#include "../src/call_video_engine.h" |
||||
#include "../../../src/call/call_video_port.h" |
||||
#include "../../../src/call/call_audio.h" |
||||
extern "C" int __wrap_call_audio_get_clock(uint64_t, int64_t, call_clock_snapshot* out) { *out = {}; return 0; } |
||||
extern "C" int __wrap_call_video_port_open(uint64_t, const call_video_caps*) { return 0; } |
||||
extern "C" void __wrap_call_video_port_close(uint64_t) {} |
||||
extern "C" int __wrap_call_video_port_status(uint64_t, struct call_video_port_status* out) { *out = {}; return 0; } |
||||
extern "C" int __wrap_call_video_port_pull(uint64_t, call_video_frame*) { return 0; } |
||||
extern "C" void __wrap_call_video_port_request_key(uint64_t) {} |
||||
extern "C" int __wrap_call_video_port_decoded(uint64_t, uint64_t, int) { return 0; } |
||||
#endif |
||||
#if QT_VERSION >= QT_VERSION_CHECK(6, 8, 0) |
||||
#include <QAbstractVideoBuffer> |
||||
#endif |
||||
#ifdef Q_OS_WIN |
||||
#include <qt_windows.h> |
||||
#else |
||||
#include <signal.h> |
||||
#endif |
||||
|
||||
static void record(const QByteArray& event) { |
||||
QFile file(qEnvironmentVariable("UTUN_CAMERA_TEST_LOG")); |
||||
if (file.open(QIODevice::WriteOnly | QIODevice::Append)) |
||||
file.write(QByteArray::number(QCoreApplication::applicationPid()) + ' ' + event + '\n'); |
||||
} |
||||
static bool alive(qint64 pid) { |
||||
#ifdef Q_OS_WIN |
||||
HANDLE handle = OpenProcess(SYNCHRONIZE, FALSE, DWORD(pid)); |
||||
if (!handle) return false; |
||||
bool running = WaitForSingleObject(handle, 0) == WAIT_TIMEOUT; CloseHandle(handle); return running; |
||||
#else |
||||
return kill(pid, 0) == 0; |
||||
#endif |
||||
} |
||||
|
||||
#if QT_VERSION >= QT_VERSION_CHECK(6, 8, 0) |
||||
class StuckBuffer : public QAbstractVideoBuffer { |
||||
public: |
||||
MapData map(QVideoFrame::MapMode) override { record("convert-blocked"); QThread::sleep(60); return {}; } |
||||
QVideoFrameFormat format() const override { return {QSize(16, 16), QVideoFrameFormat::Format_BGRX8888}; } |
||||
}; |
||||
#endif |
||||
class TestSource : public CallCameraSource { |
||||
QTimer timer; |
||||
QByteArray device; |
||||
int width = 16, height = 16; |
||||
public: |
||||
TestSource() { |
||||
record("created"); timer.setInterval(33); timer.setTimerType(Qt::PreciseTimer); |
||||
connect(&timer, &QTimer::timeout, this, [this] { |
||||
#if QT_VERSION >= QT_VERSION_CHECK(6, 8, 0) |
||||
if (device == "convert-stall") { |
||||
QVideoFrame raw(std::make_unique<StuckBuffer>()); raw.setStartTime(call_video_playout_now_us()); emit frame(raw); return; |
||||
} |
||||
#endif |
||||
QVideoFrame raw(QVideoFrameFormat(QSize(width, height), QVideoFrameFormat::Format_BGRX8888)); |
||||
if (!raw.map(QVideoFrame::WriteOnly)) qFatal("test frame map failed"); |
||||
QImage image(raw.bits(0), width, height, raw.bytesPerLine(0), QImage::Format_RGB32); |
||||
image.fill(device == "blue" ? Qt::blue : Qt::red); raw.unmap(); |
||||
raw.setStartTime(call_video_playout_now_us()); emit frame(raw); |
||||
}); |
||||
} |
||||
CallCameraDevices devices() override { return {{QStringLiteral("Test camera"), "red"}}; } |
||||
bool start(const QByteArray& id, int w, int h) override { |
||||
device = id; width = w; height = h; record("start:" + id); |
||||
if (id == "start-stall") QThread::sleep(60); |
||||
timer.start(); return true; |
||||
} |
||||
void stop() override { |
||||
timer.stop(); |
||||
if (!device.isEmpty()) record("stop:" + device); |
||||
if (device == "stop-stall") QThread::sleep(60); |
||||
device.clear(); |
||||
} |
||||
}; |
||||
|
||||
class Heartbeat { |
||||
QTimer timer; |
||||
QElapsedTimer clock; |
||||
qint64 previous = 0; |
||||
public: |
||||
qint64 maximum = 0; |
||||
unsigned ticks = 0; |
||||
Heartbeat() { |
||||
clock.start(); timer.setInterval(5); timer.setTimerType(Qt::PreciseTimer); |
||||
QObject::connect(&timer, &QTimer::timeout, [&] { |
||||
const qint64 now = clock.elapsed(); maximum = std::max(maximum, now - previous); previous = now; ++ticks; |
||||
}); timer.start(); |
||||
} |
||||
}; |
||||
|
||||
class CameraTest : public QObject { |
||||
Q_OBJECT |
||||
QTemporaryDir directory; |
||||
QString path; |
||||
QByteArray log() { QFile file(path); if (!file.open(QIODevice::ReadOnly)) return {}; return file.readAll(); } |
||||
qint64 pid() { return log().split(' ').value(0).toLongLong(); } |
||||
private slots: |
||||
void init() { |
||||
path = directory.filePath(QString::number(QDateTime::currentMSecsSinceEpoch())); |
||||
qputenv("UTUN_CAMERA_TEST_LOG", path.toUtf8()); |
||||
} |
||||
void latestFrameAndGeneration() { |
||||
auto capture = std::make_unique<CallCameraCapture>(); |
||||
unsigned frames = 0; qint64 maxAge = 0; QColor color; bool expectBlue = false, wrongGeneration = false; |
||||
connect(capture.get(), &CallCameraCapture::frameReady, this, [&](const QImage& image, qint64 pts, qint64) { |
||||
++frames; maxAge = std::max(maxAge, call_video_playout_now_us() - pts); color = image.pixelColor(0, 0); |
||||
if (expectBlue && color != QColor(Qt::blue)) wrongGeneration = true; |
||||
}); |
||||
QSignalSpy errors(capture.get(), &CallCameraCapture::failed); |
||||
capture->configure(true, "red", 1280, 720); |
||||
{ Heartbeat heartbeat; |
||||
QTRY_VERIFY_WITH_TIMEOUT(frames >= 15, 4000); |
||||
qInfo("camera 720p latency max=%lldus GUI gap=%lldms", (long long)maxAge, (long long)heartbeat.maximum); |
||||
QVERIFY(maxAge < 100000); QVERIFY(heartbeat.maximum < 150); } |
||||
QCOMPARE(color, QColor(Qt::red)); |
||||
// Пока GUI занят, разрешён лишь один передаваемый кадр; после паузы берётся свежий.
|
||||
QThread::msleep(350); const unsigned before = frames; |
||||
expectBlue = true; |
||||
capture->configure(true, "blue", 1280, 720); |
||||
QTRY_VERIFY_WITH_TIMEOUT(frames > before && color == QColor(Qt::blue), 2000); |
||||
QVERIFY(!wrongGeneration); |
||||
const unsigned stopped = frames; capture->configure(false, "blue", 1280, 720); |
||||
QTest::qWait(150); QCOMPARE(frames, stopped); QCOMPARE(errors.size(), 0); |
||||
const qint64 child = pid(); QVERIFY(child > 0); capture.reset(); QTRY_VERIFY_WITH_TIMEOUT(!alive(child), 3000); |
||||
} |
||||
void bufferLifetime() { |
||||
CallCameraBuffer creator, peer; |
||||
QVERIFY(creator.create()); const QString name = creator.name(); |
||||
QVERIFY(peer.attach(name)); creator.data()[0] = 17; |
||||
QCOMPARE(peer.data()[0], uchar(17)); |
||||
creator.close(); peer.data()[0] = 23; QCOMPARE(peer.data()[0], uchar(23)); |
||||
peer.close(); QVERIFY(!peer.attach(name)); |
||||
} |
||||
void blockedOperation_data() { |
||||
QTest::addColumn<QByteArray>("device"); |
||||
QTest::newRow("start") << QByteArray("start-stall"); |
||||
#if QT_VERSION >= QT_VERSION_CHECK(6, 8, 0) |
||||
QTest::newRow("conversion") << QByteArray("convert-stall"); |
||||
#endif |
||||
} |
||||
void blockedOperation() { |
||||
QFETCH(QByteArray, device); |
||||
auto capture = std::make_unique<CallCameraCapture>(); |
||||
QSignalSpy errors(capture.get(), &CallCameraCapture::failed); Heartbeat heartbeat; |
||||
capture->configure(true, device); |
||||
QTRY_COMPARE_WITH_TIMEOUT(errors.size(), 1, 7500); |
||||
QVERIFY(heartbeat.ticks > 100); QVERIFY(heartbeat.maximum < 150); |
||||
qInfo("blocked %s: GUI gap max=%lldms ticks=%u", device.constData(), (long long)heartbeat.maximum, heartbeat.ticks); |
||||
if (device == "convert-stall") QVERIFY(log().contains("convert-blocked")); |
||||
const qint64 child = pid(); QVERIFY(child > 0); QTRY_VERIFY_WITH_TIMEOUT(!alive(child), 3000); |
||||
// Тот же владелец допускает явный повтор после отказа, без зависшего старого процесса.
|
||||
unsigned frames = 0; |
||||
connect(capture.get(), &CallCameraCapture::frameReady, this, [&](const QImage&, qint64, qint64) { ++frames; }); |
||||
capture->configure(true, "blue"); QTRY_VERIFY_WITH_TIMEOUT(frames > 0, 3000); |
||||
capture.reset(); |
||||
} |
||||
void destroyWhileStopping() { |
||||
auto capture = std::make_unique<CallCameraCapture>(); |
||||
unsigned frames = 0; |
||||
connect(capture.get(), &CallCameraCapture::frameReady, this, [&](const QImage&, qint64, qint64) { ++frames; }); |
||||
capture->configure(true, "stop-stall"); QTRY_VERIFY_WITH_TIMEOUT(frames > 0, 3000); |
||||
const qint64 child = pid(); QVERIFY(child > 0); |
||||
Heartbeat heartbeat; QElapsedTimer elapsed; elapsed.start(); capture.reset(); |
||||
QVERIFY(elapsed.elapsed() < 50); |
||||
QTRY_VERIFY_WITH_TIMEOUT(!alive(child), 3500); |
||||
QVERIFY(log().contains("stop:stop-stall")); QVERIFY(heartbeat.maximum < 150); |
||||
} |
||||
void applicationExit() { |
||||
QProcess probe; probe.start(QCoreApplication::applicationFilePath(), {QStringLiteral("--exit-probe")}); |
||||
QTRY_COMPARE_WITH_TIMEOUT(probe.state(), QProcess::NotRunning, 3000); |
||||
QCOMPARE(probe.exitStatus(), QProcess::NormalExit); QCOMPARE(probe.exitCode(), 0); |
||||
QVERIFY(!probe.readAllStandardError().contains("Destroyed while process")); |
||||
} |
||||
#ifdef TEST_CALL_VIDEO_ENGINE |
||||
void engineKeepsCameraAcrossCodecChange() { |
||||
auto engine = std::make_unique<CallVideoEngine>(); |
||||
unsigned frames = 0; |
||||
connect(engine.get(), &CallVideoEngine::localImageChanged, this, [&](const QImage& image) { if (!image.isNull()) ++frames; }); |
||||
engine->start(7); engine->setVideo(true, "red", 640, 480, 1); |
||||
QTRY_VERIFY_WITH_TIMEOUT(frames >= 5, 4000); |
||||
QCOMPARE(log().count("start:red"), 1); |
||||
unsigned before = frames; engine->setVideo(true, "red", 640, 480, 2); |
||||
QTRY_VERIFY_WITH_TIMEOUT(frames >= before + 5, 2000); |
||||
QCOMPARE(log().count("start:red"), 1); QVERIFY(!log().contains("stop:red")); |
||||
engine->setVideo(true, "stop-stall", 640, 480, 2); |
||||
QTRY_VERIFY_WITH_TIMEOUT(log().contains("start:stop-stall"), 2000); |
||||
const qint64 child = pid(); Heartbeat heartbeat; QElapsedTimer elapsed; elapsed.start(); |
||||
engine.reset(); QVERIFY(elapsed.elapsed() < 150); |
||||
QTRY_VERIFY_WITH_TIMEOUT(!alive(child), 3500); QVERIFY(heartbeat.maximum < 150); |
||||
} |
||||
#endif |
||||
}; |
||||
|
||||
int main(int argc, char** argv) { |
||||
QGuiApplication app(argc, argv); debug_config_init(); debug_set_level(DEBUG_LEVEL_INFO); |
||||
if (app.arguments().value(1) == "--call-camera-worker") |
||||
return call_camera_worker_run(app.arguments().value(2), std::make_unique<TestSource>()); |
||||
if (app.arguments().value(1) == "--exit-probe") { |
||||
auto capture = std::make_unique<CallCameraCapture>(); capture->configure(true, "stop-stall"); |
||||
QTimer::singleShot(500, &app, &QCoreApplication::quit); |
||||
const int result = app.exec(); capture.reset(); return result; |
||||
} |
||||
CameraTest test; return QTest::qExec(&test, argc, argv); |
||||
} |
||||
#include "test_call_camera_capture.moc" |
||||
Loading…
Reference in new issue