Revision control

++ // Copyright (C) 2026 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++
++ #include "qohoscamerasession_p.h"
++
++ #include "common/qohosvideooutput_p.h"
++ #include "qohosglobal_p.h"
++
++ #include <QtCore/qdir.h>
++ #include <QtCore/qfile.h>
++ #include <QtCore/qfileinfo.h>
++ #include <QtCore/qstandardpaths.h>
++ #include <QtCore/qloggingcategory.h>
++ #include <QtCore/qmutex.h>
++ #include <QtCore/qset.h>
++ #include <QtCore/qthread.h>
++ #include <QtCore/qthreadpool.h>
++ #include <QtGui/qguiapplication.h>
++ #include <QtGui/qimage.h>
++ #include <QtMultimedia/qvideosink.h>
++
++ #include <fcntl.h>
++ #include <unistd.h>
++
++ #include <private/qcameradevice_p.h>
++ #include <private/qmediastoragelocation_p.h>
++ #include <private/qmemoryvideobuffer_p.h>
++ #include <private/qvideoframe_p.h>
++
++ #include <multimedia/image_framework/image/image_native.h>
++ #include <multimedia/image_framework/image/image_packer_native.h>
++ #include <multimedia/image_framework/image/image_source_native.h>
++ #include <native_buffer/native_buffer.h>
++ #include <native_window/external_window.h>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace {
++
++ constexpr int32_t kImageReceiverCapacity = 4;
++ constexpr const char *kJpegMimeType = "image/jpeg";
++
++ // OHOS phones only allow one Camera_Input open at a time. Other platforms
++ // auto-preempt the previously-open camera when a new one is opened, but on
++ // OHOS OH_CameraInput_Open fails with CAMERA_OPERATION_NOT_ALLOWED if any
++ // other input is still alive in this process. Track live sessions so a
++ // starting session can stop the others first.
++ //
++ // The mutex is recursive because stopSession() -> releaseSession() removes
++ // the session from liveSessions() under the same lock, and preemption iterates
++ // while holding it (so a pointer can't be destroyed mid-iteration).
++ QRecursiveMutex &liveSessionMutex()
++ {
++ static QRecursiveMutex m;
++ return m;
++ }
++ QSet<QOhosCameraSession *> &liveSessions()
++ {
++ static QSet<QOhosCameraSession *> s;
++ return s;
++ }
++
++ QVideoFrameFormat::PixelFormat pixelFormatFor(Camera_Format format)
++ {
++ switch (format) {
++ case CAMERA_FORMAT_RGBA_8888:
++ return QVideoFrameFormat::Format_RGBA8888;
++ case CAMERA_FORMAT_YUV_420_SP:
++ return QVideoFrameFormat::Format_NV12;
++ case CAMERA_FORMAT_JPEG:
++ return QVideoFrameFormat::Format_Jpeg;
++ default:
++ break;
++ }
++ return QVideoFrameFormat::Format_Invalid;
++ }
++
++ int qualityToInt(QImageCapture::Quality q)
++ {
++ switch (q) {
++ case QImageCapture::VeryLowQuality:
++ return 25;
++ case QImageCapture::LowQuality:
++ return 50;
++ case QImageCapture::HighQuality:
++ return 90;
++ case QImageCapture::VeryHighQuality:
++ return 100;
++ case QImageCapture::NormalQuality:
++ default:
++ return 75;
++ }
++ }
++
++ QByteArray encodeNativeImageToJpeg(OH_ImageNative *image, int quality)
++ {
++ uint32_t *components = nullptr;
++ size_t componentCount = 0;
++ if (OH_ImageNative_GetComponentTypes(image, nullptr, &componentCount) != IMAGE_SUCCESS
++ || componentCount == 0) {
++ return {};
++ }
++ std::vector<uint32_t> types(componentCount);
++ components = types.data();
++ if (OH_ImageNative_GetComponentTypes(image, &components, &componentCount) != IMAGE_SUCCESS)
++ return {};
++
++ OH_NativeBuffer *nativeBuffer = nullptr;
++ if (OH_ImageNative_GetByteBuffer(image, types[0], &nativeBuffer) != IMAGE_SUCCESS
++ || !nativeBuffer) {
++ return {};
++ }
++
++ OH_NativeBuffer_Config bufferConfig{};
++ OH_NativeBuffer_GetConfig(nativeBuffer, &bufferConfig);
++
++ void *mapped = nullptr;
++ if (OH_NativeBuffer_Map(nativeBuffer, &mapped) != 0 || !mapped)
++ return {};
++
++ size_t bufferSize = 0;
++ OH_ImageNative_GetBufferSize(image, types[0], &bufferSize);
++
++ QByteArray result;
++ OH_ImageSourceNative *source = nullptr;
++ if (OH_ImageSourceNative_CreateFromData(static_cast<uint8_t *>(mapped), bufferSize, &source)
++ == IMAGE_SUCCESS
++ && source) {
++ OH_ImagePackerNative *packer = nullptr;
++ if (OH_ImagePackerNative_Create(&packer) == IMAGE_SUCCESS && packer) {
++ OH_PackingOptions *options = nullptr;
++ if (OH_PackingOptions_Create(&options) == IMAGE_SUCCESS && options) {
++ Image_MimeType mime{ const_cast<char *>(kJpegMimeType),
++ std::strlen(kJpegMimeType) };
++ OH_PackingOptions_SetMimeType(options, &mime);
++ OH_PackingOptions_SetQuality(options, uint32_t(quality));
++
++ size_t outSize = bufferSize * 2 + 1024;
++ result.resize(int(outSize));
++ if (OH_ImagePackerNative_PackToDataFromImageSource(
++ packer, options, source,
++ reinterpret_cast<uint8_t *>(result.data()), &outSize)
++ == IMAGE_SUCCESS) {
++ result.resize(int(outSize));
++ } else {
++ result.clear();
++ }
++ OH_PackingOptions_Release(options);
++ }
++ OH_ImagePackerNative_Release(packer);
++ }
++ OH_ImageSourceNative_Release(source);
++ }
++
++ OH_NativeBuffer_Unmap(nativeBuffer);
++ return result;
++ }
++
++ void imageArriveCallbackTrampoline(OH_ImageReceiverNative * /*receiver*/, void *userData)
++ {
++ auto *session = static_cast<QOhosCameraSession *>(userData);
++ if (!session)
++ return;
++ QMetaObject::invokeMethod(session, &QOhosCameraSession::onCapturedImageAvailable,
++ Qt::QueuedConnection);
++ }
++
++ } // namespace
++
++ QOhosCameraSession::QOhosCameraSession(QObject *parent) : QObject(parent)
++ {
++ if (qApp) {
++ connect(qApp, &QGuiApplication::applicationStateChanged, this,
++ &QOhosCameraSession::onApplicationStateChanged);
++ }
++ }
++
++ void QOhosCameraSession::onApplicationStateChanged()
++ {
++ // HarmonyOS revokes camera access in the background and the session is left
++ // dead with no notification, so tear it down and build a new one on return.
++ if (QGuiApplication::applicationState() == Qt::ApplicationActive) {
++ if (m_restoreOnForeground) {
++ m_restoreOnForeground = false;
++ setActive(true);
++ }
++ } else if (m_active) {
++ setActive(false);
++ m_restoreOnForeground = true;
++ }
++ }
++
++ QOhosCameraSession::~QOhosCameraSession()
++ {
++ {
++ QMutexLocker lock{ &liveSessionMutex() };
++ liveSessions().remove(this);
++ }
++ releaseSession();
++ if (m_supportedDevices) {
++ OH_CameraManager_DeleteSupportedCameras(m_manager, m_supportedDevices,
++ m_supportedDeviceCount);
++ m_supportedDevices = nullptr;
++ }
++ if (m_manager) {
++ OH_Camera_DeleteCameraManager(m_manager);
++ m_manager = nullptr;
++ }
++ }
++
++ void QOhosCameraSession::setCamera(const QCameraDevice &camera)
++ {
++ if (m_cameraDevice == camera)
++ return;
++ const bool wasActive = m_active;
++ if (wasActive)
++ setActive(false);
++ m_cameraDevice = camera;
++ if (wasActive)
++ setActive(true);
++ }
++
++ void QOhosCameraSession::setCameraFormat(const QCameraFormat &format)
++ {
++ m_cameraFormat = format;
++ }
++
++ void QOhosCameraSession::setVideoSink(QVideoSink *sink)
++ {
++ if (m_videoSink == sink)
++ return;
++ m_videoSink = sink;
++ if (m_videoOutput)
++ m_videoOutput.reset();
++ m_videoOutput = std::make_unique<QOhosVideoOutput>(
++ sink, QOhosVideoOutput::ContentSource::Camera, this);
++ connect(m_videoOutput.get(), &QOhosVideoOutput::surfaceReady, this,
++ &QOhosCameraSession::onSurfaceReady);
++ }
++
++ void QOhosCameraSession::setActive(bool active)
++ {
++ if (m_active == active)
++ return;
++
++ // Starting is refused while the application is in the background, so keep
++ // the request and act on it once the application is active again.
++ if (active && qApp && QGuiApplication::applicationState() != Qt::ApplicationActive) {
++ m_restoreOnForeground = true;
++ return;
++ }
++ m_restoreOnForeground = false;
++
++ if (active) {
++ if (!startSession()) {
++ m_pendingStart = true;
++ return;
++ }
++ } else {
++ m_pendingStart = false;
++ stopSession();
++ }
++ m_active = active;
++ Q_EMIT activeChanged(active);
++ emitReadyForCaptureChanged();
++ }
++
++ void QOhosCameraSession::setImageSettings(const QImageEncoderSettings &settings)
++ {
++ m_imageSettings = settings;
++ }
++
++ int QOhosCameraSession::capture(const QString &fileName, bool toBuffer)
++ {
++ const int id = ++m_lastCaptureId;
++ if (!m_active || !m_photoOutput) {
++ Q_EMIT imageCaptureError(id, QImageCapture::NotReadyError,
++ tr("Camera not ready for capture"));
++ return id;
++ }
++ if (m_captureInProgress) {
++ Q_EMIT imageCaptureError(id, QImageCapture::NotReadyError,
++ tr("Capture already in progress"));
++ return id;
++ }
++
++ m_pendingCaptureId = id;
++ m_pendingCaptureFileName = fileName;
++ m_pendingCaptureToBuffer = toBuffer;
++ m_captureInProgress = true;
++ emitReadyForCaptureChanged();
++
++ if (OH_PhotoOutput_Capture(m_photoOutput) != CAMERA_OK) {
++ m_captureInProgress = false;
++ Q_EMIT imageCaptureError(id, QImageCapture::ResourceError,
++ tr("OH_PhotoOutput_Capture failed"));
++ emitReadyForCaptureChanged();
++ }
++ return id;
++ }
++
++ void QOhosCameraSession::onSurfaceReady()
++ {
++ if (m_pendingStart && !m_active) {
++ m_pendingStart = false;
++ if (startSession()) {
++ m_active = true;
++ Q_EMIT activeChanged(true);
++ emitReadyForCaptureChanged();
++ }
++ return;
++ }
++
++ // Rebuild when the surface the session was started with has been replaced.
++ if (!m_active || !m_videoOutput)
++ return;
++ const QByteArray surfaceId = m_videoOutput->surfaceId();
++ if (surfaceId.isEmpty() || surfaceId == m_previewSurfaceId)
++ return;
++
++ m_active = false;
++ stopSession();
++ if (startSession()) {
++ m_active = true;
++ Q_EMIT activeChanged(true);
++ emitReadyForCaptureChanged();
++ }
++ }
++
++ void QOhosCameraSession::onCapturedImageAvailable()
++ {
++ if (!m_imageReceiver)
++ return;
++
++ OH_ImageNative *image = nullptr;
++ if (OH_ImageReceiverNative_ReadLatestImage(m_imageReceiver, &image) != IMAGE_SUCCESS
++ || !image) {
++ m_captureInProgress = false;
++ Q_EMIT imageCaptureError(m_pendingCaptureId, QImageCapture::ResourceError,
++ tr("Failed to read captured image"));
++ emitReadyForCaptureChanged();
++ return;
++ }
++
++ const int quality = qualityToInt(m_imageSettings.quality());
++ QByteArray jpegBytes = encodeNativeImageToJpeg(image, quality);
++ OH_ImageNative_Release(image);
++
++ const int id = m_pendingCaptureId;
++ const QString fileName = m_pendingCaptureFileName;
++ const bool toBuffer = m_pendingCaptureToBuffer;
++ m_pendingCaptureFileName.clear();
++ m_pendingCaptureToBuffer = false;
++ m_pendingCaptureId = 0;
++ m_captureInProgress = false;
++
++ if (jpegBytes.isEmpty()) {
++ Q_EMIT imageCaptureError(id, QImageCapture::FormatError,
++ tr("Failed to encode captured image"));
++ emitReadyForCaptureChanged();
++ return;
++ }
++
++ QImage preview = QImage::fromData(jpegBytes, "JPEG");
++ Q_EMIT imageExposed(id);
++ Q_EMIT imageCaptured(id, preview);
++
++ if (toBuffer) {
++ QVideoFrame buffer = QVideoFramePrivate::createFrame(
++ std::make_unique<QMemoryVideoBuffer>(QByteArray(jpegBytes),
++ preview.bytesPerLine()),
++ QVideoFrameFormat(preview.size(), QVideoFrameFormat::Format_Jpeg));
++ Q_EMIT imageAvailable(id, buffer);
++ emitReadyForCaptureChanged();
++ return;
++ }
++
++ // captureToFile: persist to disk and emit imageSaved. Empty filename means
++ // "let the platform pick" — Qt apps default to PicturesLocation/IMG_<n>.jpg.
++ // Mirrors the Android backend.
++ const QImageCapture::FileFormat targetFormat = m_imageSettings.format();
++ const QString defaultExt = [&]() -> QString {
++ switch (targetFormat) {
++ case QImageCapture::PNG: return QStringLiteral("png");
++ case QImageCapture::WebP: return QStringLiteral("webp");
++ case QImageCapture::Tiff: return QStringLiteral("tiff");
++ case QImageCapture::JPEG:
++ case QImageCapture::UnspecifiedFormat:
++ default: return QStringLiteral("jpg");
++ }
++ }();
++ const char *qImageFormat = [&]() -> const char * {
++ switch (targetFormat) {
++ case QImageCapture::PNG: return "PNG";
++ case QImageCapture::WebP: return "WEBP";
++ case QImageCapture::Tiff: return "TIFF";
++ default: return nullptr; // JPEG: stream raw bytes
++ }
++ }();
++ const QString resolved = QMediaStorageLocation::generateFileName(
++ fileName, QStandardPaths::PicturesLocation, defaultExt);
++ bool saved = false;
++ if (qImageFormat) {
++ saved = preview.save(resolved, qImageFormat, quality);
++ } else {
++ QFile out(resolved);
++ if (out.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
++ out.write(jpegBytes);
++ out.close();
++ saved = true;
++ }
++ }
++ if (saved) {
++ Q_EMIT imageSaved(id, resolved);
++ } else {
++ Q_EMIT imageCaptureError(id, QImageCapture::ResourceError,
++ tr("Could not save captured image to: %1").arg(resolved));
++ }
++
++ emitReadyForCaptureChanged();
++ }
++
++ void QOhosCameraSession::emitReadyForCaptureChanged()
++ {
++ const bool ready = isReadyForCapture();
++ if (m_lastReadyForCapture && *m_lastReadyForCapture == ready)
++ return;
++ m_lastReadyForCapture = ready;
++ Q_EMIT readyForCaptureChanged(ready);
++ }
++
++ bool QOhosCameraSession::ensureManager()
++ {
++ if (m_manager)
++ return true;
++ if (OH_Camera_GetCameraManager(&m_manager) != CAMERA_OK || !m_manager) {
++ qCWarning(qLcOhosMediaPlugin) << "OH_Camera_GetCameraManager failed";
++ return false;
++ }
++ if (OH_CameraManager_GetSupportedCameras(m_manager, &m_supportedDevices,
++ &m_supportedDeviceCount) != CAMERA_OK) {
++ qCWarning(qLcOhosMediaPlugin) << "GetSupportedCameras failed";
++ m_supportedDevices = nullptr;
++ m_supportedDeviceCount = 0;
++ }
++ return true;
++ }
++
++ Camera_Device *QOhosCameraSession::findDevice(const QByteArray &id)
++ {
++ if (!m_supportedDevices)
++ return nullptr;
++ for (uint32_t i = 0; i < m_supportedDeviceCount; ++i) {
++ if (m_supportedDevices[i].cameraId && id == m_supportedDevices[i].cameraId)
++ return &m_supportedDevices[i];
++ }
++ return nullptr;
++ }
++
++ bool QOhosCameraSession::createPhotoPath(Camera_OutputCapability *caps,
++ Camera_Profile *previewProfile)
++ {
++ if (!caps || caps->photoProfilesSize == 0)
++ return false;
++
++ Camera_Profile *photoProfile = caps->photoProfiles[0];
++ if (m_imageSettings.resolution().isValid()) {
++ const QSize wanted = m_imageSettings.resolution();
++ for (uint32_t i = 0; i < caps->photoProfilesSize; ++i) {
++ Camera_Profile *p = caps->photoProfiles[i];
++ if (!p)
++ continue;
++ if (int(p->size.width) == wanted.width()
++ && int(p->size.height) == wanted.height()) {
++ photoProfile = p;
++ break;
++ }
++ }
++ } else if (previewProfile) {
++ for (uint32_t i = 0; i < caps->photoProfilesSize; ++i) {
++ Camera_Profile *p = caps->photoProfiles[i];
++ if (!p)
++ continue;
++ if (p->size.width == previewProfile->size.width
++ && p->size.height == previewProfile->size.height) {
++ photoProfile = p;
++ break;
++ }
++ }
++ }
++ if (!photoProfile)
++ return false;
++
++ if (OH_ImageReceiverOptions_Create(&m_imageReceiverOptions) != IMAGE_SUCCESS
++ || !m_imageReceiverOptions) {
++ return false;
++ }
++ Image_Size size{ uint32_t(photoProfile->size.width), uint32_t(photoProfile->size.height) };
++ OH_ImageReceiverOptions_SetSize(m_imageReceiverOptions, size);
++ OH_ImageReceiverOptions_SetCapacity(m_imageReceiverOptions, kImageReceiverCapacity);
++
++ if (OH_ImageReceiverNative_Create(m_imageReceiverOptions, &m_imageReceiver) != IMAGE_SUCCESS
++ || !m_imageReceiver) {
++ return false;
++ }
++
++ OH_ImageReceiverNative_OnImageArrive(m_imageReceiver, imageArriveCallbackTrampoline, this);
++
++ uint64_t surfaceIdNum = 0;
++ if (OH_ImageReceiverNative_GetReceivingSurfaceId(m_imageReceiver, &surfaceIdNum) != IMAGE_SUCCESS
++ || surfaceIdNum == 0) {
++ return false;
++ }
++ const QByteArray surfaceId = QByteArray::number(qulonglong(surfaceIdNum));
++
++ if (OH_CameraManager_CreatePhotoOutput(m_manager, photoProfile, surfaceId.constData(),
++ &m_photoOutput) != CAMERA_OK
++ || !m_photoOutput) {
++ return false;
++ }
++ return true;
++ }
++
++ void QOhosCameraSession::destroyPhotoPath()
++ {
++ if (m_photoOutput) {
++ OH_PhotoOutput_Release(m_photoOutput);
++ m_photoOutput = nullptr;
++ }
++ if (m_imageReceiver) {
++ OH_ImageReceiverNative_OffImageArrive(m_imageReceiver, imageArriveCallbackTrampoline);
++ OH_ImageReceiverNative_Release(m_imageReceiver);
++ m_imageReceiver = nullptr;
++ }
++ if (m_imageReceiverOptions) {
++ OH_ImageReceiverOptions_Release(m_imageReceiverOptions);
++ m_imageReceiverOptions = nullptr;
++ }
++ }
++
++ bool QOhosCameraSession::startSession()
++ {
++ // Phones only let one Camera_Input be open at a time. Preempt any other
++ // live session in this process before attempting to open ours; otherwise
++ // OH_CameraInput_Open returns CAMERA_OPERATION_NOT_ALLOWED.
++ {
++ QMutexLocker lock{ &liveSessionMutex() };
++ const auto sessions = liveSessions();
++ for (auto *other : sessions) {
++ if (other != this)
++ other->stopSession();
++ }
++ }
++
++ // OHOS capture sessions require at least one preview output to commit, so
++ // we always produce a surface — backed by a real QVideoSink RHI when one is
++ // attached, or an internal offscreen GLES2 RHI otherwise. surfaceReady will
++ // re-attach later if a sink with a live RHI shows up.
++ if (!m_videoOutput) {
++ m_videoOutput = std::make_unique<QOhosVideoOutput>(
++ nullptr, QOhosVideoOutput::ContentSource::Camera, this);
++ connect(m_videoOutput.get(), &QOhosVideoOutput::surfaceReady, this,
++ &QOhosCameraSession::onSurfaceReady);
++ }
++ m_previewSurfaceId = m_videoOutput->surfaceId();
++
++ if (!ensureManager())
++ return false;
++
++ Camera_Device *device = findDevice(m_cameraDevice.id());
++ if (!device && m_supportedDeviceCount > 0)
++ device = &m_supportedDevices[0];
++ if (!device) {
++ qCWarning(qLcOhosMediaPlugin) << "No camera device available";
++ return false;
++ }
++
++ Camera_Profile *previewProfile = nullptr;
++ Camera_OutputCapability *caps = nullptr;
++ if (OH_CameraManager_GetSupportedCameraOutputCapability(m_manager, device, &caps) == CAMERA_OK
++ && caps && caps->previewProfilesSize > 0) {
++ previewProfile = caps->previewProfiles[0];
++ const bool haveRequest = !m_cameraFormat.isNull();
++ const QSize requestedSize = haveRequest ? m_cameraFormat.resolution() : QSize{};
++ const QVideoFrameFormat::PixelFormat requestedPixel =
++ haveRequest ? m_cameraFormat.pixelFormat() : QVideoFrameFormat::Format_Invalid;
++ for (uint32_t i = 0; i < caps->previewProfilesSize; ++i) {
++ Camera_Profile *p = caps->previewProfiles[i];
++ if (!p)
++ continue;
++ const bool sizeMatches = !haveRequest
++ || (int(p->size.width) == requestedSize.width()
++ && int(p->size.height) == requestedSize.height());
++ const bool formatMatches = !haveRequest
++ || requestedPixel == QVideoFrameFormat::Format_Invalid
++ || requestedPixel == pixelFormatFor(p->format);
++ if (sizeMatches && formatMatches) {
++ previewProfile = p;
++ if (haveRequest)
++ break;
++ if (p->format == CAMERA_FORMAT_YUV_420_SP && p->size.width == 1280
++ && p->size.height == 720)
++ break;
++ }
++ }
++ }
++
++ if (!previewProfile) {
++ qCWarning(qLcOhosMediaPlugin) << "No preview profile available";
++ if (caps)
++ OH_CameraManager_DeleteSupportedCameraOutputCapability(m_manager, caps);
++ return false;
++ }
++
++ if (OH_CameraManager_CreateCameraInput(m_manager, device, &m_cameraInput) != CAMERA_OK
++ || !m_cameraInput) {
++ qCWarning(qLcOhosMediaPlugin) << "CreateCameraInput failed";
++ OH_CameraManager_DeleteSupportedCameraOutputCapability(m_manager, caps);
++ return false;
++ }
++
++ // OH_CameraInput_Open can briefly fail with CAMERA_CONFLICT_CAMERA right
++ // after a sibling Camera_Input was released — the camera service finishes
++ // tearing down its session asynchronously. Poll for up to ~1 s.
++ {
++ Camera_ErrorCode err = CAMERA_OK;
++ constexpr int kMaxAttempts = 20;
++ constexpr int kBackoffMs = 50;
++ for (int attempt = 0; attempt < kMaxAttempts; ++attempt) {
++ err = OH_CameraInput_Open(m_cameraInput);
++ if (err == CAMERA_OK)
++ break;
++ // CAMERA_OPERATION_NOT_ALLOWED is returned when another
++ // Camera_Input is still alive in this process. Force-stop any
++ // other live QOhosCameraSession and retry.
++ if (err == CAMERA_OPERATION_NOT_ALLOWED) {
++ QSet<QOhosCameraSession *> snapshot;
++ {
++ QMutexLocker lock{ &liveSessionMutex() };
++ snapshot = liveSessions();
++ }
++ for (auto *other : snapshot) {
++ if (other != this)
++ other->stopSession();
++ }
++ } else if (err != CAMERA_CONFLICT_CAMERA && err != CAMERA_DEVICE_PREEMPTED) {
++ break;
++ }
++ QThread::msleep(kBackoffMs);
++ }
++ if (err != CAMERA_OK) {
++ qCWarning(qLcOhosMediaPlugin) << "CameraInput_Open failed:" << err;
++ OH_CameraManager_DeleteSupportedCameraOutputCapability(m_manager, caps);
++ releaseSession();
++ return false;
++ }
++ QMutexLocker lock{ &liveSessionMutex() };
++ liveSessions().insert(this);
++ }
++
++ if (m_videoOutput && !m_previewSurfaceId.isEmpty()) {
++ m_videoOutput->setVideoSize(
++ QSize{ int(previewProfile->size.width), int(previewProfile->size.height) });
++ if (OH_CameraManager_CreatePreviewOutput(m_manager, previewProfile,
++ m_previewSurfaceId.constData(), &m_previewOutput)
++ != CAMERA_OK
++ || !m_previewOutput) {
++ qCWarning(qLcOhosMediaPlugin) << "CreatePreviewOutput failed";
++ OH_CameraManager_DeleteSupportedCameraOutputCapability(m_manager, caps);
++ releaseSession();
++ return false;
++ }
++ }
++
++ const bool hasPhoto = createPhotoPath(caps, previewProfile);
++ if (!hasPhoto)
++ qCWarning(qLcOhosMediaPlugin) << "Photo output unavailable; image capture disabled";
++
++ OH_CameraManager_DeleteSupportedCameraOutputCapability(m_manager, caps);
++
++ if (!m_previewOutput && !m_photoOutput) {
++ qCWarning(qLcOhosMediaPlugin) << "No capture outputs available";
++ releaseSession();
++ return false;
++ }
++
++ if (OH_CameraManager_CreateCaptureSession(m_manager, &m_captureSession) != CAMERA_OK
++ || !m_captureSession) {
++ qCWarning(qLcOhosMediaPlugin) << "CreateCaptureSession failed";
++ releaseSession();
++ return false;
++ }
++
++ OH_CaptureSession_BeginConfig(m_captureSession);
++ OH_CaptureSession_AddInput(m_captureSession, m_cameraInput);
++ if (m_previewOutput)
++ OH_CaptureSession_AddPreviewOutput(m_captureSession, m_previewOutput);
++ if (m_photoOutput)
++ OH_CaptureSession_AddPhotoOutput(m_captureSession, m_photoOutput);
++ if (OH_CaptureSession_CommitConfig(m_captureSession) != CAMERA_OK) {
++ qCWarning(qLcOhosMediaPlugin) << "CommitConfig failed";
++ releaseSession();
++ return false;
++ }
++
++ if (OH_CaptureSession_Start(m_captureSession) != CAMERA_OK) {
++ qCWarning(qLcOhosMediaPlugin) << "CaptureSession_Start failed";
++ releaseSession();
++ return false;
++ }
++
++ return true;
++ }
++
++ void QOhosCameraSession::stopSession()
++ {
++ if (m_captureSession) {
++ OH_CaptureSession_Stop(m_captureSession);
++ }
++ releaseSession();
++ }
++
++ void QOhosCameraSession::releaseSession()
++ {
++ destroyRecorder();
++ detachVideoOutput();
++ destroyPhotoPath();
++ if (m_captureSession) {
++ OH_CaptureSession_Release(m_captureSession);
++ m_captureSession = nullptr;
++ }
++ if (m_previewOutput) {
++ OH_PreviewOutput_Release(m_previewOutput);
++ m_previewOutput = nullptr;
++ }
++ m_previewSurfaceId.clear();
++ if (m_cameraInput) {
++ OH_CameraInput_Close(m_cameraInput);
++ OH_CameraInput_Release(m_cameraInput);
++ m_cameraInput = nullptr;
++ }
++ QMutexLocker lock{ &liveSessionMutex() };
++ liveSessions().remove(this);
++ }
++
++ namespace {
++
++ OH_AVRecorder_CodecMimeType videoCodecToOhos(QMediaFormat::VideoCodec codec)
++ {
++ switch (codec) {
++ case QMediaFormat::VideoCodec::H265:
++ return AVRECORDER_VIDEO_HEVC;
++ case QMediaFormat::VideoCodec::MPEG4:
++ return AVRECORDER_VIDEO_MPEG4;
++ case QMediaFormat::VideoCodec::H264:
++ case QMediaFormat::VideoCodec::Unspecified:
++ default:
++ return AVRECORDER_VIDEO_AVC;
++ }
++ }
++
++ OH_AVRecorder_CodecMimeType audioCodecToOhos(QMediaFormat::AudioCodec codec)
++ {
++ switch (codec) {
++ case QMediaFormat::AudioCodec::MP3:
++ return AVRECORDER_AUDIO_MP3;
++ case QMediaFormat::AudioCodec::AAC:
++ case QMediaFormat::AudioCodec::Unspecified:
++ default:
++ return AVRECORDER_AUDIO_AAC;
++ }
++ }
++
++ OH_AVRecorder_ContainerFormatType containerToOhos(QMediaFormat::FileFormat fmt)
++ {
++ switch (fmt) {
++ case QMediaFormat::AAC:
++ return AVRECORDER_CFT_AAC;
++ case QMediaFormat::MP3:
++ return AVRECORDER_CFT_MP3;
++ case QMediaFormat::Wave:
++ return AVRECORDER_CFT_WAV;
++ case QMediaFormat::Mpeg4Audio:
++ return AVRECORDER_CFT_MPEG_4A;
++ case QMediaFormat::MPEG4:
++ case QMediaFormat::UnspecifiedFormat:
++ default:
++ return AVRECORDER_CFT_MPEG_4;
++ }
++ }
++
++ int qualityToVideoBitrate(QMediaRecorder::Quality q, const QSize &resolution)
++ {
++ const int pixels = qMax(1, resolution.width() * resolution.height());
++ const double bpp = [&]() {
++ switch (q) {
++ case QMediaRecorder::VeryLowQuality: return 0.05;
++ case QMediaRecorder::LowQuality: return 0.1;
++ case QMediaRecorder::HighQuality: return 0.25;
++ case QMediaRecorder::VeryHighQuality:return 0.4;
++ case QMediaRecorder::NormalQuality:
++ default: return 0.15;
++ }
++ }();
++ return int(pixels * 30 * bpp);
++ }
++
++ int qualityToAudioBitrate(QMediaRecorder::Quality q)
++ {
++ switch (q) {
++ case QMediaRecorder::VeryLowQuality: return 32000;
++ case QMediaRecorder::LowQuality: return 64000;
++ case QMediaRecorder::HighQuality: return 192000;
++ case QMediaRecorder::VeryHighQuality:return 256000;
++ case QMediaRecorder::NormalQuality:
++ default: return 128000;
++ }
++ }
++
++ } // namespace
++
++ bool QOhosCameraSession::findVideoProfile(const QMediaEncoderSettings &settings,
++ Camera_VideoProfile *out)
++ {
++ if (!m_manager || !out)
++ return false;
++ Camera_Device *device = findDevice(m_cameraDevice.id());
++ if (!device && m_supportedDeviceCount > 0)
++ device = &m_supportedDevices[0];
++ if (!device)
++ return false;
++
++ Camera_OutputCapability *caps = nullptr;
++ if (OH_CameraManager_GetSupportedCameraOutputCapability(m_manager, device, &caps) != CAMERA_OK
++ || !caps || caps->videoProfilesSize == 0) {
++ if (caps)
++ OH_CameraManager_DeleteSupportedCameraOutputCapability(m_manager, caps);
++ return false;
++ }
++
++ Camera_VideoProfile *chosen = nullptr;
++ const QSize wanted = settings.videoResolution();
++ if (wanted.isValid()) {
++ for (uint32_t i = 0; i < caps->videoProfilesSize; ++i) {
++ Camera_VideoProfile *p = caps->videoProfiles[i];
++ if (!p)
++ continue;
++ if (int(p->size.width) == wanted.width()
++ && int(p->size.height) == wanted.height()) {
++ chosen = p;
++ break;
++ }
++ }
++ }
++ if (!chosen) {
++ for (uint32_t i = 0; i < caps->videoProfilesSize; ++i) {
++ Camera_VideoProfile *p = caps->videoProfiles[i];
++ if (!p)
++ continue;
++ if (p->size.width == 1280 && p->size.height == 720
++ && p->format == CAMERA_FORMAT_YUV_420_SP) {
++ chosen = p;
++ break;
++ }
++ }
++ }
++ if (!chosen)
++ chosen = caps->videoProfiles[0];
++ *out = *chosen;
++ OH_CameraManager_DeleteSupportedCameraOutputCapability(m_manager, caps);
++ return true;
++ }
++
++ bool QOhosCameraSession::attachVideoOutput(const Camera_VideoProfile &profile,
++ const QByteArray &surfaceId)
++ {
++ if (!m_captureSession)
++ return false;
++ if (OH_CameraManager_CreateVideoOutput(m_manager, &profile, surfaceId.constData(),
++ &m_videoOutputCamera) != CAMERA_OK
++ || !m_videoOutputCamera) {
++ return false;
++ }
++
++ OH_CaptureSession_Stop(m_captureSession);
++ OH_CaptureSession_BeginConfig(m_captureSession);
++ OH_CaptureSession_AddVideoOutput(m_captureSession, m_videoOutputCamera);
++ if (OH_CaptureSession_CommitConfig(m_captureSession) != CAMERA_OK) {
++ OH_VideoOutput_Release(m_videoOutputCamera);
++ m_videoOutputCamera = nullptr;
++ OH_CaptureSession_Start(m_captureSession);
++ return false;
++ }
++ if (OH_CaptureSession_Start(m_captureSession) != CAMERA_OK)
++ return false;
++ if (OH_VideoOutput_Start(m_videoOutputCamera) != CAMERA_OK)
++ return false;
++ return true;
++ }
++
++ void QOhosCameraSession::detachVideoOutput()
++ {
++ if (!m_videoOutputCamera)
++ return;
++ OH_VideoOutput_Stop(m_videoOutputCamera);
++ if (m_captureSession) {
++ OH_CaptureSession_Stop(m_captureSession);
++ OH_CaptureSession_BeginConfig(m_captureSession);
++ OH_CaptureSession_RemoveVideoOutput(m_captureSession, m_videoOutputCamera);
++ OH_CaptureSession_CommitConfig(m_captureSession);
++ OH_CaptureSession_Start(m_captureSession);
++ }
++ OH_VideoOutput_Release(m_videoOutputCamera);
++ m_videoOutputCamera = nullptr;
++ }
++
++ void QOhosCameraSession::recorderStateCallback(OH_AVRecorder * /*recorder*/,
++ OH_AVRecorder_State state,
++ OH_AVRecorder_StateChangeReason /*reason*/,
++ void *userData)
++ {
++ auto *self = static_cast<QOhosCameraSession *>(userData);
++ if (!self)
++ return;
++ QMetaObject::invokeMethod(self, "onRecorderStateNotification", Qt::QueuedConnection,
++ Q_ARG(int, int(state)));
++ }
++
++ void QOhosCameraSession::recorderErrorCallback(OH_AVRecorder * /*recorder*/, int32_t errorCode,
++ const char *errorMsg, void *userData)
++ {
++ auto *self = static_cast<QOhosCameraSession *>(userData);
++ if (!self)
++ return;
++ QMetaObject::invokeMethod(self, "onRecorderErrorNotification", Qt::QueuedConnection,
++ Q_ARG(int, errorCode),
++ Q_ARG(QString, QString::fromUtf8(errorMsg ? errorMsg : "")));
++ }
++
++ void QOhosCameraSession::onRecorderStateNotification(int state)
++ {
++ QMediaRecorder::RecorderState mapped = m_recorderState;
++ switch (state) {
++ case AVRECORDER_STARTED:
++ mapped = QMediaRecorder::RecordingState;
++ break;
++ case AVRECORDER_PAUSED:
++ mapped = QMediaRecorder::PausedState;
++ break;
++ case AVRECORDER_STOPPED:
++ case AVRECORDER_IDLE:
++ case AVRECORDER_RELEASED:
++ mapped = QMediaRecorder::StoppedState;
++ break;
++ case AVRECORDER_ERROR:
++ mapped = QMediaRecorder::StoppedState;
++ break;
++ default:
++ return;
++ }
++ if (mapped == m_recorderState)
++ return;
++ m_recorderState = mapped;
++ Q_EMIT recorderStateChanged(int(mapped));
++ }
++
++ void QOhosCameraSession::onRecorderErrorNotification(int code, const QString &message)
++ {
++ Q_EMIT recorderErrorOccurred(int(QMediaRecorder::ResourceError),
++ message.isEmpty()
++ ? tr("Recorder error %1").arg(code)
++ : message);
++ }
++
++ qint64 QOhosCameraSession::recorderDuration() const
++ {
++ if (m_recorderState == QMediaRecorder::StoppedState)
++ return 0;
++ if (m_recorderState == QMediaRecorder::PausedState)
++ return m_recorderPausedMs;
++ if (!m_recorderTimer.isValid())
++ return m_recorderPausedMs;
++ return m_recorderPausedMs + (m_recorderTimer.elapsed() - m_recorderResumeStartMs);
++ }
++
++ bool QOhosCameraSession::startRecording(const QMediaEncoderSettings &settings,
++ const QString &location)
++ {
++ if (m_recorder) {
++ Q_EMIT recorderErrorOccurred(int(QMediaRecorder::ResourceError),
++ tr("Recording already in progress"));
++ return false;
++ }
++
++ // Audio-only recording when no camera is attached: skip the camera
++ // pipeline and let OH_AVRecorder capture audio directly.
++ const bool videoEnabled = m_active && m_captureSession;
++ Camera_VideoProfile videoProfile{};
++ if (videoEnabled) {
++ if (!findVideoProfile(settings, &videoProfile)) {
++ Q_EMIT recorderErrorOccurred(int(QMediaRecorder::ResourceError),
++ tr("No matching camera video profile"));
++ return false;
++ }
++ }
++
++ m_recorder = OH_AVRecorder_Create();
++ if (!m_recorder) {
++ Q_EMIT recorderErrorOccurred(int(QMediaRecorder::ResourceError),
++ tr("OH_AVRecorder_Create failed"));
++ return false;
++ }
++
++ OH_AVRecorder_SetStateCallback(m_recorder, recorderStateCallback, this);
++ OH_AVRecorder_SetErrorCallback(m_recorder, recorderErrorCallback, this);
++
++ QString resolved = location;
++ if (QFileInfo(resolved).suffix().isEmpty()) {
++ const QString suffix = settings.preferredSuffix();
++ if (!suffix.isEmpty())
++ resolved.append(QLatin1Char('.')).append(suffix);
++ else
++ resolved.append(QStringLiteral(".mp4"));
++ }
++
++ QByteArray urlBytes = QStringLiteral("fd://").toUtf8();
++ int fd = ::open(QFile::encodeName(resolved).constData(),
++ O_RDWR | O_CREAT | O_TRUNC, 0644);
++ if (fd < 0) {
++ Q_EMIT recorderErrorOccurred(int(QMediaRecorder::ResourceError),
++ tr("Could not open output file: %1").arg(resolved));
++ destroyRecorder();
++ return false;
++ }
++ urlBytes.append(QByteArray::number(fd));
++
++ OH_AVRecorder_Config config{};
++ config.audioSourceType = AVRECORDER_MIC;
++ config.profile.audioBitrate = settings.audioBitRate() > 0
++ ? settings.audioBitRate() : qualityToAudioBitrate(settings.quality());
++ config.profile.audioChannels = settings.audioChannelCount() > 0
++ ? settings.audioChannelCount() : 2;
++ config.profile.audioCodec = audioCodecToOhos(settings.audioCodec());
++ config.profile.audioSampleRate = settings.audioSampleRate() > 0
++ ? settings.audioSampleRate() : 48000;
++ config.profile.fileFormat = containerToOhos(settings.fileFormat());
++ if (videoEnabled) {
++ const QSize videoSize{ int(videoProfile.size.width), int(videoProfile.size.height) };
++ config.videoSourceType = AVRECORDER_SURFACE_YUV;
++ config.profile.videoBitrate = settings.videoBitRate() > 0
++ ? settings.videoBitRate() : qualityToVideoBitrate(settings.quality(), videoSize);
++ config.profile.videoCodec = videoCodecToOhos(settings.videoCodec());
++ config.profile.videoFrameWidth = videoSize.width();
++ config.profile.videoFrameHeight = videoSize.height();
++ config.profile.videoFrameRate = settings.videoFrameRate() > 0
++ ? int(settings.videoFrameRate()) : 30;
++ }
++ config.profile.isHdr = false;
++ config.profile.enableTemporalScale = false;
++ config.url = const_cast<char *>(urlBytes.constData());
++ config.fileGenerationMode = AVRECORDER_APP_CREATE;
++ config.maxDuration = 0;
++
++ if (OH_AVRecorder_Prepare(m_recorder, &config) != AV_ERR_OK) {
++ Q_EMIT recorderErrorOccurred(int(QMediaRecorder::FormatError),
++ tr("OH_AVRecorder_Prepare failed"));
++ ::close(fd);
++ destroyRecorder();
++ return false;
++ }
++
++ if (videoEnabled) {
++ if (OH_AVRecorder_GetInputSurface(m_recorder, &m_recorderWindow) != AV_ERR_OK
++ || !m_recorderWindow) {
++ Q_EMIT recorderErrorOccurred(int(QMediaRecorder::ResourceError),
++ tr("OH_AVRecorder_GetInputSurface failed"));
++ destroyRecorder();
++ return false;
++ }
++
++ uint64_t surfaceIdNum = 0;
++ if (OH_NativeWindow_GetSurfaceId(m_recorderWindow, &surfaceIdNum) != 0
++ || surfaceIdNum == 0) {
++ Q_EMIT recorderErrorOccurred(int(QMediaRecorder::ResourceError),
++ tr("Failed to obtain recorder surface ID"));
++ destroyRecorder();
++ return false;
++ }
++ const QByteArray surfaceId = QByteArray::number(qulonglong(surfaceIdNum));
++
++ if (!attachVideoOutput(videoProfile, surfaceId)) {
++ Q_EMIT recorderErrorOccurred(int(QMediaRecorder::ResourceError),
++ tr("Failed to attach video output to capture session"));
++ destroyRecorder();
++ return false;
++ }
++ }
++
++ if (OH_AVRecorder_Start(m_recorder) != AV_ERR_OK) {
++ Q_EMIT recorderErrorOccurred(int(QMediaRecorder::ResourceError),
++ tr("OH_AVRecorder_Start failed"));
++ detachVideoOutput();
++ destroyRecorder();
++ return false;
++ }
++
++ m_recorderActualLocation = QUrl::fromLocalFile(resolved);
++ Q_EMIT recorderActualLocationChanged(m_recorderActualLocation);
++ m_recorderPausedMs = 0;
++ m_recorderResumeStartMs = 0;
++ m_recorderTimer.restart();
++ return true;
++ }
++
++ void QOhosCameraSession::pauseRecording()
++ {
++ if (!m_recorder || m_recorderState != QMediaRecorder::RecordingState)
++ return;
++ if (OH_AVRecorder_Pause(m_recorder) == AV_ERR_OK) {
++ m_recorderPausedMs += (m_recorderTimer.elapsed() - m_recorderResumeStartMs);
++ }
++ }
++
++ void QOhosCameraSession::resumeRecording()
++ {
++ if (!m_recorder || m_recorderState != QMediaRecorder::PausedState)
++ return;
++ if (OH_AVRecorder_Resume(m_recorder) == AV_ERR_OK)
++ m_recorderResumeStartMs = m_recorderTimer.elapsed();
++ }
++
++ void QOhosCameraSession::stopRecording()
++ {
++ if (!m_recorder)
++ return;
++ OH_AVRecorder_Stop(m_recorder);
++ detachVideoOutput();
++ destroyRecorder();
++ }
++
++ void QOhosCameraSession::destroyRecorder()
++ {
++ if (m_recorder) {
++ OH_AVRecorder_Release(m_recorder);
++ m_recorder = nullptr;
++ }
++ m_recorderWindow = nullptr;
++ if (m_recorderState != QMediaRecorder::StoppedState) {
++ m_recorderState = QMediaRecorder::StoppedState;
++ Q_EMIT recorderStateChanged(int(QMediaRecorder::StoppedState));
++ }
++ m_recorderTimer.invalidate();
++ m_recorderPausedMs = 0;
++ m_recorderResumeStartMs = 0;
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qohoscamerasession_p.cpp"