Revision control
Copy as Markdown
// Copyright (C) 2022 The Qt Company Ltd and/or its subsidiary(-ies).
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qwasmcamera_p.h"
#include "qwasmmediacapturesession_p.h"
#include <common/qwasmvideooutput_p.h>
#include <QtMultimedia/qcameradevice.h>
#include <QtMultimedia/qmediadevices.h>
#include <QtMultimedia/private/qcameradevice_p.h>
#include <QtMultimedia/private/qmemoryvideobuffer_p.h>
#include <QtMultimedia/private/qmultimedia_ranges_p.h>
#include <QtMultimedia/private/qplatformvideodevices_p.h>
#include <QtMultimedia/private/qplatformvideosink_p.h>
#include <QtMultimedia/private/qvideotexturehelper_p.h>
#include <QtMultimedia/private/qwasmmediadevices_p.h>
#include <QtCore/qtimer.h>
#include <QtCore/quuid.h>
#include <QtCore/private/qstdweb_p.h>
#include <emscripten/val.h>
#include <emscripten/bind.h>
#include <emscripten/html5.h>
Q_LOGGING_CATEGORY(qWasmCamera, "qt.multimedia.wasm.camera")
namespace ranges = QtMultimediaPrivate::ranges;
QWasmCamera::QWasmCamera(QCamera *camera)
: QPlatformCamera(camera),
m_cameraOutput(new QWasmVideoOutput),
m_cameraIsReady(false)
{
connect(this, &QWasmCamera::cameraIsReady, this, [this]() {
m_cameraIsReady = true;
if (m_cameraShouldStartActive) {
QTimer::singleShot(50, this, [this]() {
setActive(true);
});
}
});
}
QWasmCamera::~QWasmCamera() = default;
bool QWasmCamera::isActive() const
{
return m_cameraActive;
}
void QWasmCamera::setActive(bool active)
{
if (m_cameraActive == active)
return;
if (!m_CaptureSession) {
updateError(QCamera::CameraError, QStringLiteral("video surface error"));
m_shouldBeActive = true;
return;
}
if (m_cameraActive && !active)
m_cameraOutput->stop();
m_shouldBeActive = active;
if (!m_cameraIsReady) {
m_cameraShouldStartActive = true;
return;
}
QVideoSink *sink = m_CaptureSession->videoSink();
if (!sink) {
qWarning() << Q_FUNC_INFO << "sink not ready";
return;
}
m_cameraOutput->setSurface(m_CaptureSession->videoSink());
m_cameraActive = active;
m_shouldBeActive = false;
if (active)
updateCameraFeatures();
Q_EMIT activeChanged(active);
if (m_CaptureSession->imageCapture()) {
if (active) {
m_readyChangedConnection = connect(cameraOutput(), &QWasmVideoOutput::readyChanged, this, [this] () {
m_CaptureSession->setReadyForCapture(true);
});
}
}
if (!active && m_readyChangedConnection) {
QObject::disconnect(m_readyChangedConnection);
}
if (m_cameraActive)
m_cameraOutput->start();
}
void QWasmCamera::setCamera(const QCameraDevice &camera)
{
if (camera.id().isEmpty() || (m_cameraDev.id() == camera.id())) {
return;
}
const bool wasActive = m_cameraActive;
if (wasActive)
m_cameraOutput->stop();
m_cameraOutput->setVideoMode(QWasmVideoOutput::Camera);
constexpr QSize initialSize(0, 0);
constexpr QRect initialRect(QPoint(0, 0), initialSize);
m_cameraOutput->createVideoElement(
QUuid::createUuid().toString(QUuid::WithoutBraces).toStdString()); // videoElementId
m_cameraOutput->doElementCallbacks();
m_cameraOutput->updateVideoElementGeometry(initialRect);
const auto cameras = QMediaDevices::videoInputs();
if (ranges::contains(cameras, camera)) {
m_cameraDev = camera;
createCamera(m_cameraDev);
Q_EMIT cameraIsReady();
if (wasActive)
m_cameraOutput->start();
return;
}
if (cameras.count() > 0) {
m_cameraDev = camera;
createCamera(m_cameraDev);
Q_EMIT cameraIsReady();
if (wasActive)
m_cameraOutput->start();
} else {
updateError(QCamera::CameraError, QStringLiteral("Failed to find a camera"));
}
}
bool QWasmCamera::setCameraFormat(const QCameraFormat &format)
{
m_cameraFormat = format;
m_cameraOutput->setVideoConstraints(format.resolution(), format.minFrameRate(), format.maxFrameRate());
return true;
}
void QWasmCamera::setCaptureSession(QPlatformMediaCaptureSession *session)
{
QWasmMediaCaptureSession *captureSession = static_cast<QWasmMediaCaptureSession *>(session);
if (m_CaptureSession == captureSession)
return;
m_CaptureSession = captureSession;
if (m_shouldBeActive)
setActive(true);
}
void QWasmCamera::setFocusMode(QCamera::FocusMode mode)
{
if (!isFocusModeSupported(mode))
return;
static constexpr std::string_view focusModeString = "focusMode";
if (mode == QCamera::FocusModeManual)
m_cameraOutput->setDeviceSetting(focusModeString.data(), emscripten::val("manual"));
if (mode == QCamera::FocusModeAuto)
m_cameraOutput->setDeviceSetting(focusModeString.data(), emscripten::val("continuous"));
focusModeChanged(mode);
}
bool QWasmCamera::isFocusModeSupported(QCamera::FocusMode mode) const
{
emscripten::val caps = m_cameraOutput->getDeviceCapabilities();
if (caps.isUndefined())
return false;
emscripten::val focusMode = caps["focusMode"];
if (focusMode.isUndefined())
return false;
std::vector<std::string> focalModes;
for (int i = 0; i < focusMode["length"].as<int>(); i++)
focalModes.push_back(focusMode[i].as<std::string>());
// Do we need to take into account focusDistance
// it is not always available, and what distance
// would be far/near
bool found = false;
switch (mode) {
case QCamera::FocusModeAuto:
return ranges::contains(focalModes, "continuous")
|| ranges::contains(focalModes, "single-shot");
case QCamera::FocusModeAutoNear:
case QCamera::FocusModeAutoFar:
case QCamera::FocusModeHyperfocal:
case QCamera::FocusModeInfinity:
break;
case QCamera::FocusModeManual:
found = ranges::contains(focalModes, "manual");
};
return found;
}
void QWasmCamera::setTorchMode(QCamera::TorchMode mode)
{
if (!isTorchModeSupported(mode))
return;
if (m_wasmTorchMode == mode)
return;
static constexpr std::string_view torchModeString = "torchMode";
bool hasChanged = false;
switch (mode) {
case QCamera::TorchOff:
m_cameraOutput->setDeviceSetting(torchModeString.data(), emscripten::val(false));
hasChanged = true;
break;
case QCamera::TorchOn:
m_cameraOutput->setDeviceSetting(torchModeString.data(), emscripten::val(true));
hasChanged = true;
break;
case QCamera::TorchAuto:
break;
};
m_wasmTorchMode = mode;
if (hasChanged)
torchModeChanged(m_wasmTorchMode);
}
bool QWasmCamera::isTorchModeSupported(QCamera::TorchMode mode) const
{
if (!m_cameraIsReady)
return false;
emscripten::val caps = m_cameraOutput->getDeviceCapabilities();
if (caps.isUndefined())
return false;
emscripten::val exposureMode = caps["torch"];
if (exposureMode.isUndefined())
return false;
return (mode != QCamera::TorchAuto);
}
void QWasmCamera::setExposureMode(QCamera::ExposureMode mode)
{
// TODO manually come up with exposureTime values ?
if (!isExposureModeSupported(mode))
return;
if (m_wasmExposureMode == mode)
return;
bool hasChanged = false;
static constexpr std::string_view exposureModeString = "exposureMode";
switch (mode) {
case QCamera::ExposureManual:
m_cameraOutput->setDeviceSetting(exposureModeString.data(), emscripten::val("manual"));
hasChanged = true;
break;
case QCamera::ExposureAuto:
m_cameraOutput->setDeviceSetting(exposureModeString.data(), emscripten::val("continuous"));
hasChanged = true;
break;
default:
break;
};
if (hasChanged) {
m_wasmExposureMode = mode;
exposureModeChanged(m_wasmExposureMode);
}
}
bool QWasmCamera::isExposureModeSupported(QCamera::ExposureMode mode) const
{
if (!m_cameraIsReady)
return false;
emscripten::val caps = m_cameraOutput->getDeviceCapabilities();
if (caps.isUndefined())
return false;
emscripten::val exposureMode = caps["exposureMode"];
if (exposureMode.isUndefined())
return false;
std::vector<std::string> exposureModes;
for (int i = 0; i < exposureMode["length"].as<int>(); i++)
exposureModes.push_back(exposureMode[i].as<std::string>());
bool found = false;
switch (mode) {
case QCamera::ExposureAuto:
found = ranges::contains(exposureModes, "continuous");
break;
case QCamera::ExposureManual:
found = ranges::contains(exposureModes, "manual");
break;
default:
break;
};
return found;
}
void QWasmCamera::setExposureCompensation(float bias)
{
if (!m_cameraIsReady)
return;
emscripten::val caps = m_cameraOutput->getDeviceCapabilities();
if (caps.isUndefined())
return;
emscripten::val exposureComp = caps["exposureCompensation"];
if (exposureComp.isUndefined())
return;
if (m_wasmExposureCompensation == bias)
return;
static constexpr std::string_view exposureCompensationModeString = "exposureCompensation";
m_cameraOutput->setDeviceSetting(exposureCompensationModeString.data(), emscripten::val(bias));
m_wasmExposureCompensation = bias;
Q_EMIT exposureCompensationChanged(m_wasmExposureCompensation);
}
void QWasmCamera::setManualExposureTime(float secs)
{
if (m_wasmExposureTime == secs)
return;
if (!m_cameraIsReady)
return;
emscripten::val caps = m_cameraOutput->getDeviceCapabilities();
emscripten::val exposureTime = caps["exposureTime"];
if (exposureTime.isUndefined())
return;
static constexpr std::string_view exposureTimeString = "exposureTime";
m_cameraOutput->setDeviceSetting(exposureTimeString.data(), emscripten::val(secs));
m_wasmExposureTime = secs;
Q_EMIT exposureTimeChanged(m_wasmExposureTime);
}
int QWasmCamera::isoSensitivity() const
{
if (!m_cameraIsReady)
return 0;
emscripten::val caps = m_cameraOutput->getDeviceCapabilities();
if (caps.isUndefined())
return false;
emscripten::val isoSpeed = caps["iso"];
if (isoSpeed.isUndefined())
return 0;
return isoSpeed.as<double>();
}
void QWasmCamera::setManualIsoSensitivity(int sens)
{
if (!m_cameraIsReady)
return;
emscripten::val caps = m_cameraOutput->getDeviceCapabilities();
if (caps.isUndefined())
return;
emscripten::val isoSpeed = caps["iso"];
if (isoSpeed.isUndefined())
return;
if (m_wasmIsoSensitivity == sens)
return;
static constexpr std::string_view isoString = "iso";
m_cameraOutput->setDeviceSetting(isoString.data(), emscripten::val(sens));
m_wasmIsoSensitivity = sens;
Q_EMIT isoSensitivityChanged(m_wasmIsoSensitivity);
}
bool QWasmCamera::isWhiteBalanceModeSupported(QCamera::WhiteBalanceMode mode) const
{
if (!m_cameraIsReady)
return false;
emscripten::val caps = m_cameraOutput->getDeviceCapabilities();
if (caps.isUndefined())
return false;
emscripten::val whiteBalanceMode = caps["whiteBalanceMode"];
if (whiteBalanceMode.isUndefined())
return false;
if (mode == QCamera::WhiteBalanceAuto || mode == QCamera::WhiteBalanceManual)
return true;
return false;
}
void QWasmCamera::setWhiteBalanceMode(QCamera::WhiteBalanceMode mode)
{
if (!isWhiteBalanceModeSupported(mode))
return;
if (m_wasmWhiteBalanceMode == mode)
return;
bool hasChanged = false;
static constexpr std::string_view whiteBalanceModeString = "whiteBalanceMode";
switch (mode) {
case QCamera::WhiteBalanceAuto:
m_cameraOutput->setDeviceSetting(whiteBalanceModeString.data(), emscripten::val("auto"));
hasChanged = true;
break;
case QCamera::WhiteBalanceManual:
m_cameraOutput->setDeviceSetting(whiteBalanceModeString.data(), emscripten::val("manual"));
hasChanged = true;
break;
default:
break;
};
if (hasChanged) {
m_wasmWhiteBalanceMode = mode;
Q_EMIT whiteBalanceModeChanged(m_wasmWhiteBalanceMode);
}
}
void QWasmCamera::setColorTemperature(int temperature)
{
if (!m_cameraIsReady)
return;
emscripten::val caps = m_cameraOutput->getDeviceCapabilities();
if (caps.isUndefined())
return;
emscripten::val whiteBalanceMode = caps["colorTemperature"];
if (whiteBalanceMode.isUndefined())
return;
if(m_wasmColorTemperature == temperature)
return;
static constexpr std::string_view colorBalanceString = "colorTemperature";
m_cameraOutput->setDeviceSetting(colorBalanceString.data(), emscripten::val(temperature));
m_wasmColorTemperature = temperature;
colorTemperatureChanged(m_wasmColorTemperature);
}
void QWasmCamera::createCamera(const QCameraDevice &camera)
{
m_cameraOutput->addCameraSourceElement(camera.id().toStdString());
}
void QWasmCamera::updateCameraFeatures()
{
if (!m_cameraIsReady)
return;
emscripten::val caps = m_cameraOutput->getDeviceCapabilities();
if (caps.isUndefined())
return;
QCamera::Features cameraFeatures;
if (!caps["colorTemperature"].isUndefined())
cameraFeatures |= QCamera::Feature::ColorTemperature;
if (!caps["exposureCompensation"].isUndefined())
cameraFeatures |= QCamera::Feature::ExposureCompensation;
if (!caps["iso"].isUndefined())
cameraFeatures |= QCamera::Feature::IsoSensitivity;
if (!caps["exposureTime"].isUndefined())
cameraFeatures |= QCamera::Feature::ManualExposureTime;
if (!caps["focusDistance"].isUndefined())
cameraFeatures |= QCamera::Feature::FocusDistance;
supportedFeaturesChanged(cameraFeatures);
updateVideoFormats(caps);
}
void QWasmCamera::updateVideoFormats(const emscripten::val &cababilities)
{
// Use synthetic standard res and framerates. Webaudio
// only allows real camera format from a live camera stream
// camera constraints are only a suggestion anyway
emscripten::val widthCapabilities = cababilities["width"];
emscripten::val heightCapabilities = cababilities["height"];
emscripten::val frameRateCapabilities = cababilities["frameRate"];
if (widthCapabilities.isUndefined() || heightCapabilities.isUndefined()
|| frameRateCapabilities.isUndefined())
return;
const int maxWidth = widthCapabilities["max"].as<int>();
const int maxHeight = heightCapabilities["max"].as<int>();
const float minFrameRate = frameRateCapabilities["min"].as<double>();
const float maxFrameRate = frameRateCapabilities["max"].as<double>();
static const QSize standardResolutions[] = {
{ 3840, 2160 }, // 4k
{ 2560, 1440 }, // 1440p
{ 2048, 1080 }, // 2k
{ 1920, 1080 }, // FHD
{ 1280, 720 }, // HD
{ 640, 480 }, // SD
};
static const float standardFrameRates[] = { 15.f, 24.f, 25.f, 29.97f, 30.f,
60.f, 100.f, 120.f };
QList<QCameraFormat> formats;
for (const QSize &resolution : standardResolutions) {
if (resolution.width() > maxWidth || resolution.height() > maxHeight)
continue;
for (float rate : standardFrameRates) {
if (rate < minFrameRate || rate > maxFrameRate + 0.5f)
continue;
auto *oneFormat = new QCameraFormatPrivate{
QSharedData(),
QVideoFrameFormat::Format_RGBA8888,
resolution,
rate, rate
};
formats << oneFormat->create();
}
}
if (formats.isEmpty())
return;
QCameraDevicePrivate *devicePrivate = QCameraDevicePrivate::handle(m_cameraDev);
devicePrivate->videoFormats = formats;
}