Revision control
++ // Copyright (C) 2016 Research In Motion
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ #include "qqnxcamera_p.h"
++ #include "qqnxcameraframebuffer_p.h"
++ #include "qqnxmediacapturesession_p.h"
++ #include "qqnxvideosink_p.h"
++
++ #include <qcameradevice.h>
++ #include <qmediadevices.h>
++
++ #include <private/qmediastoragelocation_p.h>
++
++ QDebug &operator<<(QDebug &d, const QQnxCamera::VideoFormat &f)
++ {
++ d << "VideoFormat - width=" << f.width
++ << "height=" << f.height
++ << "rotation=" << f.rotation
++ << "frameRate=" << f.frameRate
++ << "frameType=" << f.frameType;
++
++ return d;
++ }
++
++ static QString statusToString(camera_devstatus_t status)
++ {
++ switch (status) {
++ case CAMERA_STATUS_DISCONNECTED:
++ return QStringLiteral("No user is connected to the camera");
++ case CAMERA_STATUS_POWERDOWN:
++ return QStringLiteral("Power down");
++ case CAMERA_STATUS_VIDEOVF:
++ return QStringLiteral("The video viewfinder has started");
++ case CAMERA_STATUS_CAPTURE_ABORTED:
++ return QStringLiteral("The capture of a still image failed and was aborted");
++ case CAMERA_STATUS_FILESIZE_WARNING:
++ return QStringLiteral("Time-remaining threshold has been exceeded");
++ case CAMERA_STATUS_FOCUS_CHANGE:
++ return QStringLiteral("The focus has changed on the camera");
++ case CAMERA_STATUS_RESOURCENOTAVAIL:
++ return QStringLiteral("The camera is about to free resources");
++ case CAMERA_STATUS_VIEWFINDER_ERROR:
++ return QStringLiteral(" An unexpected error was encountered while the "
++ "viewfinder was active");
++ case CAMERA_STATUS_MM_ERROR:
++ return QStringLiteral("The recording has stopped due to a memory error or multimedia "
++ "framework error");
++ case CAMERA_STATUS_FILESIZE_ERROR:
++ return QStringLiteral("A file has exceeded the maximum size.");
++ case CAMERA_STATUS_NOSPACE_ERROR:
++ return QStringLiteral("Not enough disk space");
++ case CAMERA_STATUS_BUFFER_UNDERFLOW:
++ return QStringLiteral("The viewfinder is out of buffers");
++ default:
++ break;
++ }
++
++ return {};
++ }
++
++ QT_BEGIN_NAMESPACE
++
++ QQnxCamera::QQnxCamera(camera_unit_t unit, QObject *parent)
++ : QObject(parent)
++ , m_cameraUnit(unit)
++ {
++ if (!m_handle.open(m_cameraUnit, CAMERA_MODE_RW))
++ qWarning("QQnxCamera: Failed to open camera (0x%x)", m_handle.lastError());
++
++ if (camera_set_vf_mode(m_handle.get(), CAMERA_VFMODE_VIDEO) != CAMERA_EOK) {
++ qWarning("QQnxCamera: unable to configure viewfinder mode");
++ return;
++ }
++
++ if (camera_set_vf_property(m_handle.get(), CAMERA_IMGPROP_CREATEWINDOW, 0,
++ CAMERA_IMGPROP_RENDERTOWINDOW, 0) != CAMERA_EOK) {
++ qWarning("QQnxCamera: failed to set camera properties");
++ return;
++ }
++
++ updateZoomLimits();
++ updateSupportedWhiteBalanceValues();
++
++ m_valid = true;
++ }
++
++ QQnxCamera::~QQnxCamera()
++ {
++ stop();
++ }
++
++ camera_unit_t QQnxCamera::unit() const
++ {
++ return m_cameraUnit;
++ }
++
++ QString QQnxCamera::name() const
++ {
++ char name[CAMERA_LOCATION_NAMELEN];
++
++ if (camera_get_location_property(m_cameraUnit,
++ CAMERA_LOCATION_NAME, &name, CAMERA_LOCATION_END) != CAMERA_EOK) {
++ qWarning("QQnxCamera: unable to obtain camera name");
++ return {};
++ }
++
++ return QString::fromUtf8(name);
++ }
++
++ bool QQnxCamera::isValid() const
++ {
++ return m_valid;
++ }
++
++ bool QQnxCamera::isActive() const
++ {
++ return m_handle.isOpen() && m_viewfinderActive;
++ }
++
++ void QQnxCamera::start()
++ {
++ if (isActive())
++ return;
++
++ if (camera_start_viewfinder(m_handle.get(), viewfinderCallback,
++ statusCallback, this) != CAMERA_EOK) {
++ qWarning("QQnxCamera: unable to start viewfinder");
++ return;
++ }
++
++ m_viewfinderActive = true;
++ }
++
++ void QQnxCamera::stop()
++ {
++ if (!isActive())
++ return;
++
++ if (m_recordingVideo)
++ stopVideoRecording();
++
++ if (camera_stop_viewfinder(m_handle.get()) != CAMERA_EOK)
++ qWarning("QQnxCamera: Failed to stop camera");
++
++ m_viewfinderActive = false;
++ }
++
++ bool QQnxCamera::setCameraFormat(uint32_t width, uint32_t height, double frameRate)
++ {
++ if (!m_handle.isOpen())
++ return false;
++
++ const camera_error_t error = camera_set_vf_property(m_handle.get(),
++ CAMERA_IMGPROP_WIDTH, width,
++ CAMERA_IMGPROP_HEIGHT, height,
++ CAMERA_IMGPROP_FRAMERATE, frameRate);
++
++ if (error != CAMERA_EOK) {
++ qWarning("QQnxCamera: failed to set camera format");
++ return false;
++ }
++
++ return true;
++ }
++
++ bool QQnxCamera::isFocusModeSupported(camera_focusmode_t mode) const
++ {
++ return supportedFocusModes().contains(mode);
++ }
++
++ bool QQnxCamera::setFocusMode(camera_focusmode_t mode)
++ {
++ if (!isActive())
++ return false;
++
++ const camera_error_t result = camera_set_focus_mode(m_handle.get(), mode);
++
++ if (result != CAMERA_EOK) {
++ qWarning("QQnxCamera: Unable to set focus mode (0x%x)", result);
++ return false;
++ }
++
++ focusModeChanged(mode);
++
++ return true;
++ }
++
++ camera_focusmode_t QQnxCamera::focusMode() const
++ {
++ if (!isActive())
++ return CAMERA_FOCUSMODE_OFF;
++
++ camera_focusmode_t mode;
++
++ const camera_error_t result = camera_get_focus_mode(m_handle.get(), &mode);
++
++ if (result != CAMERA_EOK) {
++ qWarning("QQnxCamera: Unable to set focus mode (0x%x)", result);
++ return CAMERA_FOCUSMODE_OFF;
++ }
++
++ return mode;
++ }
++
++ QQnxCamera::VideoFormat QQnxCamera::vfFormat() const
++ {
++ VideoFormat f = {};
++
++ if (camera_get_vf_property(m_handle.get(),
++ CAMERA_IMGPROP_WIDTH, &f.width,
++ CAMERA_IMGPROP_HEIGHT, &f.height,
++ CAMERA_IMGPROP_ROTATION, &f.rotation,
++ CAMERA_IMGPROP_FRAMERATE, &f.frameRate,
++ CAMERA_IMGPROP_FORMAT, &f.frameType) != CAMERA_EOK) {
++ qWarning("QQnxCamera: Failed to query video finder frameType");
++ }
++
++ return f;
++ }
++
++ void QQnxCamera::setVfFormat(const VideoFormat &f)
++ {
++ const bool active = isActive();
++
++ if (active)
++ stop();
++
++ if (camera_set_vf_property(m_handle.get(),
++ CAMERA_IMGPROP_WIDTH, f.width,
++ CAMERA_IMGPROP_HEIGHT, f.height,
++ CAMERA_IMGPROP_ROTATION, f.rotation,
++ CAMERA_IMGPROP_FRAMERATE, f.frameRate,
++ CAMERA_IMGPROP_FORMAT, f.frameType) != CAMERA_EOK) {
++ qWarning("QQnxCamera: Failed to set video finder frameType");
++ }
++
++ if (active)
++ start();
++ }
++
++ QQnxCamera::VideoFormat QQnxCamera::recordingFormat() const
++ {
++ VideoFormat f = {};
++
++ if (camera_get_video_property(m_handle.get(),
++ CAMERA_IMGPROP_WIDTH, &f.width,
++ CAMERA_IMGPROP_HEIGHT, &f.height,
++ CAMERA_IMGPROP_ROTATION, &f.rotation,
++ CAMERA_IMGPROP_FRAMERATE, &f.frameRate,
++ CAMERA_IMGPROP_FORMAT, &f.frameType) != CAMERA_EOK) {
++ qWarning("QQnxCamera: Failed to query recording frameType");
++ }
++
++ return f;
++ }
++
++ void QQnxCamera::setRecordingFormat(const VideoFormat &f)
++ {
++ if (camera_set_video_property(m_handle.get(),
++ CAMERA_IMGPROP_WIDTH, f.width,
++ CAMERA_IMGPROP_HEIGHT, f.height,
++ CAMERA_IMGPROP_ROTATION, f.rotation,
++ CAMERA_IMGPROP_FRAMERATE, f.frameRate,
++ CAMERA_IMGPROP_FORMAT, f.frameType) != CAMERA_EOK) {
++ qWarning("QQnxCamera: Failed to set recording frameType");
++ }
++ }
++
++ void QQnxCamera::setCustomFocusPoint(const QPointF &point)
++ {
++ const QSize vfSize = viewFinderSize();
++
++ if (vfSize.isEmpty())
++ return;
++
++ const auto toUint32 = [](double value) {
++ return static_cast<uint32_t>(std::max(0.0, value));
++ };
++
++ // define a 40x40 pixel focus region around the custom focus point
++ constexpr int pixelSize = 40;
++
++ const auto left = toUint32(point.x() * vfSize.width() - pixelSize / 2);
++ const auto top = toUint32(point.y() * vfSize.height() - pixelSize / 2);
++
++ camera_region_t focusRegion {
++ .left = left,
++ .top = top,
++ .width = pixelSize,
++ .height = pixelSize,
++ .extra = 0
++ };
++
++ if (camera_set_focus_regions(m_handle.get(), 1, &focusRegion) != CAMERA_EOK) {
++ qWarning("QQnxCamera: Unable to set focus region");
++ return;
++ }
++
++ if (setFocusMode(focusMode()))
++ customFocusPointChanged(point);
++ }
++
++ void QQnxCamera::setManualFocusStep(int step)
++ {
++ if (!isActive()) {
++ qWarning("QQnxCamera: Failed to set focus distance - view finder not active");
++ return;
++ }
++
++ if (!isFocusModeSupported(CAMERA_FOCUSMODE_MANUAL)) {
++ qWarning("QQnxCamera: Failed to set focus distance - manual focus mode not supported");
++ return;
++ }
++
++ if (camera_set_manual_focus_step(m_handle.get(), step) != CAMERA_EOK)
++ qWarning("QQnxCamera: Failed to set focus distance");
++ }
++
++ int QQnxCamera::manualFocusStep() const
++ {
++ return focusStep().step;
++ }
++
++ int QQnxCamera::maxFocusStep() const
++ {
++ return focusStep().maxStep;
++ }
++
++ QQnxCamera::FocusStep QQnxCamera::focusStep() const
++ {
++ constexpr FocusStep invalidStep { -1, -1 };
++
++ if (!isActive()) {
++ qWarning("QQnxCamera: Failed to query max focus distance - view finder not active");
++ return invalidStep;
++ }
++
++ if (!isFocusModeSupported(CAMERA_FOCUSMODE_MANUAL)) {
++ qWarning("QQnxCamera: Failed to query max focus distance - "
++ "manual focus mode not supported");
++ return invalidStep;
++ }
++
++ FocusStep focusStep;
++
++ if (camera_get_manual_focus_step(m_handle.get(),
++ &focusStep.maxStep, &focusStep.step) != CAMERA_EOK) {
++ qWarning("QQnxCamera: Unable to query camera focus step");
++ return invalidStep;
++ }
++
++ return focusStep;
++ }
++
++
++ QSize QQnxCamera::viewFinderSize() const
++ {
++ // get the size of the viewfinder
++ int width = 0;
++ int height = 0;
++
++ if (camera_get_vf_property(m_handle.get(),
++ CAMERA_IMGPROP_WIDTH, width,
++ CAMERA_IMGPROP_HEIGHT, height) != CAMERA_EOK) {
++ qWarning("QQnxCamera: failed to query view finder size");
++ return {};
++ }
++
++ return { width, height };
++ }
++
++ uint32_t QQnxCamera::minimumZoomLevel() const
++ {
++ return m_minZoom;
++ }
++
++ uint32_t QQnxCamera::maximumZoomLevel() const
++ {
++ return m_maxZoom;
++ }
++
++ bool QQnxCamera::isSmoothZoom() const
++ {
++ return m_smoothZoom;
++ }
++
++ double QQnxCamera::zoomRatio(uint32_t zoomLevel) const
++ {
++ double ratio;
++
++ if (camera_get_zoom_ratio_from_zoom_level(m_handle.get(), zoomLevel, &ratio) != CAMERA_EOK) {
++ qWarning("QQnxCamera: failed to query zoom ratio from zoom level");
++ return 0.0;
++ }
++
++ return ratio;
++ }
++
++ bool QQnxCamera::setZoomFactor(uint32_t factor)
++ {
++ if (camera_set_vf_property(m_handle.get(), CAMERA_IMGPROP_ZOOMFACTOR, factor) != CAMERA_EOK) {
++ qWarning("QQnxCamera: failed to set zoom factor");
++ return false;
++ }
++
++ return true;
++ }
++
++ void QQnxCamera::setEvOffset(float ev)
++ {
++ if (!isActive())
++ return;
++
++ if (camera_set_ev_offset(m_handle.get(), ev) != CAMERA_EOK)
++ qWarning("QQnxCamera: Failed to set up exposure compensation");
++ }
++
++ uint32_t QQnxCamera::manualIsoSensitivity() const
++ {
++ if (!isActive())
++ return 0;
++
++ uint32_t isoValue;
++
++ if (camera_get_manual_iso(m_handle.get(), &isoValue) != CAMERA_EOK) {
++ qWarning("QQnxCamera: Failed to query ISO value");
++ return 0;
++ }
++
++ return isoValue;
++ }
++
++ void QQnxCamera::setManualIsoSensitivity(uint32_t value)
++ {
++ if (!isActive())
++ return;
++
++ if (camera_set_manual_iso(m_handle.get(), value) != CAMERA_EOK)
++ qWarning("QQnxCamera: Failed to set ISO value");
++ }
++
++ void QQnxCamera::setManualExposureTime(double seconds)
++ {
++ if (!isActive())
++ return;
++
++ if (camera_set_manual_shutter_speed(m_handle.get(), seconds) != CAMERA_EOK)
++ qWarning("QQnxCamera: Failed to set exposure time");
++ }
++
++ double QQnxCamera::manualExposureTime() const
++ {
++ if (!isActive())
++ return 0.0;
++
++ double shutterSpeed;
++
++ if (camera_get_manual_shutter_speed(m_handle.get(), &shutterSpeed) != CAMERA_EOK) {
++ qWarning("QQnxCamera: Failed to get exposure time");
++ return 0.0;
++ }
++
++ return shutterSpeed;
++ }
++
++ bool QQnxCamera::hasFeature(camera_feature_t feature) const
++ {
++ return camera_has_feature(m_handle.get(), feature);
++ }
++
++ void QQnxCamera::setWhiteBalanceMode(camera_whitebalancemode_t mode)
++ {
++ if (!isActive())
++ return;
++
++ if (camera_set_whitebalance_mode(m_handle.get(), mode) != CAMERA_EOK)
++ qWarning("QQnxCamera: failed to set whitebalance mode");
++ }
++
++ camera_whitebalancemode_t QQnxCamera::whiteBalanceMode() const
++ {
++ if (!isActive())
++ return CAMERA_WHITEBALANCEMODE_OFF;
++
++ camera_whitebalancemode_t mode;
++
++ if (camera_get_whitebalance_mode(m_handle.get(), &mode) != CAMERA_EOK) {
++ qWarning("QQnxCamera: failed to get white balance mode");
++ return CAMERA_WHITEBALANCEMODE_OFF;
++ }
++
++ return mode;
++ }
++
++ void QQnxCamera::setManualWhiteBalance(uint32_t value)
++ {
++ if (!isActive())
++ return;
++
++ if (camera_set_manual_white_balance(m_handle.get(), value) != CAMERA_EOK)
++ qWarning("QQnxCamera: failed to set manual white balance");
++ }
++
++ uint32_t QQnxCamera::manualWhiteBalance() const
++ {
++ if (!isActive())
++ return 0;
++
++ uint32_t value;
++
++ if (camera_get_manual_white_balance(m_handle.get(), &value) != CAMERA_EOK) {
++ qWarning("QQnxCamera: failed to get manual white balance");
++ return 0;
++ }
++
++ return value;
++ }
++
++ bool QQnxCamera::startVideoRecording(const QString &filename)
++ {
++ // when preview is video, we must ensure that the recording properties
++ // match the view finder properties
++ if (hasFeature(CAMERA_FEATURE_PREVIEWISVIDEO)) {
++ VideoFormat newFormat = vfFormat();
++
++ const QList<camera_frametype_t> recordingTypes = supportedRecordingFrameTypes();
++
++ // find a suitable matching frame type in case the current view finder
++ // frametype is not supported
++ if (newFormat.frameType != recordingFormat().frameType
++ && !recordingTypes.contains(newFormat.frameType)) {
++
++ bool found = false;
++
++ for (const camera_frametype_t type : supportedVfFrameTypes()) {
++ if (recordingTypes.contains(type)) {
++ newFormat.frameType = type;
++ found = true;
++ break;
++ }
++ }
++
++ if (found) {
++ m_originalVfFormat = vfFormat();
++
++ // reconfigure and restart the view finder
++ setVfFormat(newFormat);
++ } else {
++ qWarning("QQnxCamera: failed to find suitable frame type for recording - aborting");
++ return false;
++ }
++ }
++
++ setRecordingFormat(newFormat);
++ }
++
++ if (camera_start_video(m_handle.get(), qPrintable(filename),
++ nullptr, nullptr, nullptr) == CAMERA_EOK) {
++ m_recordingVideo = true;
++ } else {
++ qWarning("QQnxCamera: failed to start video encoding");
++ }
++
++ return m_recordingVideo;
++ }
++
++ void QQnxCamera::stopVideoRecording()
++ {
++ m_recordingVideo = false;
++
++ if (camera_stop_video(m_handle.get()) != CAMERA_EOK)
++ qWarning("QQnxCamera: error when stopping video recording");
++
++ // restore original vf format
++ if (m_originalVfFormat) {
++ setVfFormat(*m_originalVfFormat);
++ m_originalVfFormat.reset();
++ }
++ }
++
++ bool QQnxCamera::isVideoEncodingSupported() const
++ {
++ if (!isActive())
++ return false;
++
++ return camera_has_feature(m_handle.get(), CAMERA_FEATURE_VIDEO);
++ }
++
++ camera_handle_t QQnxCamera::handle() const
++ {
++ return m_handle.get();
++ }
++
++ void QQnxCamera::updateZoomLimits()
++ {
++ bool smooth;
++
++ if (camera_get_zoom_limits(m_handle.get(), &m_minZoom, &m_maxZoom, &smooth) != CAMERA_EOK) {
++ qWarning("QQnxCamera: failed to update zoom limits - using default values");
++ m_minZoom = m_maxZoom = 0;
++ }
++ }
++
++ void QQnxCamera::updateSupportedWhiteBalanceValues()
++ {
++ uint32_t numSupported = 0;
++
++ const camera_error_t result = camera_get_supported_manual_white_balance_values(
++ m_handle.get(), 0, &numSupported, nullptr, &m_continuousWhiteBalanceValues);
++
++ if (result != CAMERA_EOK) {
++ if (result == CAMERA_EOPNOTSUPP)
++ qWarning("QQnxCamera: white balance not supported");
++ else
++ qWarning("QQnxCamera: unable to query manual white balance value count");
++
++ m_supportedWhiteBalanceValues.clear();
++
++ return;
++ }
++
++ m_supportedWhiteBalanceValues.resize(numSupported);
++
++ if (camera_get_supported_manual_white_balance_values(m_handle.get(),
++ m_supportedWhiteBalanceValues.size(),
++ &numSupported,
++ m_supportedWhiteBalanceValues.data(),
++ &m_continuousWhiteBalanceValues) != CAMERA_EOK) {
++ qWarning("QQnxCamera: unable to query manual white balance values");
++
++ m_supportedWhiteBalanceValues.clear();
++ }
++ }
++
++ QList<camera_vfmode_t> QQnxCamera::supportedVfModes() const
++ {
++ return queryValues(camera_get_supported_vf_modes);
++ }
++
++ QList<camera_res_t> QQnxCamera::supportedVfResolutions() const
++ {
++ return queryValues(camera_get_supported_vf_resolutions);
++ }
++
++ QList<camera_frametype_t> QQnxCamera::supportedVfFrameTypes() const
++ {
++ return queryValues(camera_get_supported_vf_frame_types);
++ }
++
++ QList<camera_focusmode_t> QQnxCamera::supportedFocusModes() const
++ {
++ return queryValues(camera_get_focus_modes);
++ }
++
++ QList<double> QQnxCamera::specifiedVfFrameRates(camera_frametype_t frameType,
++ camera_res_t resolution) const
++ {
++ uint32_t numSupported = 0;
++
++ if (camera_get_specified_vf_framerates(m_handle.get(), frameType, resolution,
++ 0, &numSupported, nullptr, nullptr) != CAMERA_EOK) {
++ qWarning("QQnxCamera: unable to query specified framerates count");
++ return {};
++ }
++
++ QList<double> values(numSupported);
++
++ if (camera_get_specified_vf_framerates(m_handle.get(), frameType, resolution,
++ values.size(), &numSupported, values.data(), nullptr) != CAMERA_EOK) {
++ qWarning("QQnxCamera: unable to query specified framerates values");
++ return {};
++ }
++
++ return values;
++ }
++
++ QList<camera_frametype_t> QQnxCamera::supportedRecordingFrameTypes() const
++ {
++ return queryValues(camera_get_video_frame_types);
++ }
++
++ QList<uint32_t> QQnxCamera::supportedWhiteBalanceValues() const
++ {
++ return m_supportedWhiteBalanceValues;
++ }
++
++ bool QQnxCamera::hasContinuousWhiteBalanceValues() const
++ {
++ return m_continuousWhiteBalanceValues;
++ }
++
++ QList<camera_unit_t> QQnxCamera::supportedUnits()
++ {
++ unsigned int numSupported = 0;
++
++ if (camera_get_supported_cameras(0, &numSupported, nullptr) != CAMERA_EOK) {
++ qWarning("QQnxCamera: failed to query supported camera unit count");
++ return {};
++ }
++
++ QList<camera_unit_t> cameraUnits(numSupported);
++
++ if (camera_get_supported_cameras(cameraUnits.size(), &numSupported,
++ cameraUnits.data()) != CAMERA_EOK) {
++ qWarning("QQnxCamera: failed to enumerate supported camera units");
++ return {};
++ }
++
++ return cameraUnits;
++ }
++
++ template <typename T, typename U>
++ QList<T> QQnxCamera::queryValues(QueryFuncPtr<T,U> func) const
++ {
++ static_assert(std::is_integral_v<U>, "Parameter U must be of integral type");
++
++ U numSupported = 0;
++
++ if (func(m_handle.get(), 0, &numSupported, nullptr) != CAMERA_EOK) {
++ qWarning("QQnxCamera: unable to query camera value count");
++ return {};
++ }
++
++ QList<T> values(numSupported);
++
++ if (func(m_handle.get(), values.size(), &numSupported, values.data()) != CAMERA_EOK) {
++ qWarning("QQnxCamera: unable to query camera values");
++ return {};
++ }
++
++ return values;
++ }
++
++ void QQnxCamera::handleVfBuffer(camera_buffer_t *buffer)
++ {
++ // process the frame on this thread before locking the mutex
++ auto frame = std::make_unique<QQnxCameraFrameBuffer>(buffer);
++
++ // skip a frame if mutex is busy
++ if (m_currentFrameMutex.tryLock()) {
++ m_currentFrame = std::move(frame);
++ m_currentFrameMutex.unlock();
++
++ Q_EMIT frameAvailable();
++ }
++ }
++
++ void QQnxCamera::handleVfStatus(camera_devstatus_t status, uint16_t extraData)
++ {
++ QMetaObject::invokeMethod(this, "handleStatusChange", Qt::QueuedConnection,
++ Q_ARG(camera_devstatus_t, status),
++ Q_ARG(uint16_t, extraData));
++ }
++
++ void QQnxCamera::handleStatusChange(camera_devstatus_t status, uint16_t extraData)
++ {
++ Q_UNUSED(extraData);
++
++ switch (status) {
++ case CAMERA_STATUS_BUFFER_UNDERFLOW:
++ #if _NTO_VERSION < 800
++ case CAMERA_STATUS_CAPTURECOMPLETE:
++ case CAMERA_STATUS_FLASH_LEVEL_CHANGE:
++ case CAMERA_STATUS_LOWLIGHT:
++ case CAMERA_STATUS_PHOTOVF:
++ case CAMERA_STATUS_VIDEOLIGHT_CHANGE:
++ case CAMERA_STATUS_VIDEOLIGHT_LEVEL_CHANGE:
++ case CAMERA_STATUS_VIEWFINDER_FREEZE:
++ case CAMERA_STATUS_VIEWFINDER_SUSPEND:
++ case CAMERA_STATUS_VIEWFINDER_UNFREEZE:
++ case CAMERA_STATUS_VIEWFINDER_UNSUSPEND:
++ #endif
++ case CAMERA_STATUS_CAPTURE_ABORTED:
++ case CAMERA_STATUS_CONNECTED:
++ case CAMERA_STATUS_DISCONNECTED:
++ case CAMERA_STATUS_FILESIZE_ERROR:
++ case CAMERA_STATUS_FILESIZE_LIMIT_WARNING:
++ case CAMERA_STATUS_FILESIZE_WARNING:
++ case CAMERA_STATUS_FOCUS_CHANGE:
++ case CAMERA_STATUS_FRAME_DROPPED:
++ case CAMERA_STATUS_MM_ERROR:
++ case CAMERA_STATUS_NOSPACE_ERROR:
++ case CAMERA_STATUS_POWERDOWN:
++ case CAMERA_STATUS_POWERUP:
++ case CAMERA_STATUS_RESOURCENOTAVAIL:
++ case CAMERA_STATUS_UNKNOWN:
++ case CAMERA_STATUS_VIDEOVF:
++ case CAMERA_STATUS_VIDEO_PAUSE:
++ case CAMERA_STATUS_VIDEO_RESUME:
++ case CAMERA_STATUS_VIEWFINDER_ACTIVE:
++ case CAMERA_STATUS_VIEWFINDER_ERROR:
++ qDebug() << "QQnxCamera:" << ::statusToString(status);
++ break;
++ default:
++ break;
++ }
++ }
++
++ std::unique_ptr<QQnxCameraFrameBuffer> QQnxCamera::takeCurrentFrame()
++ {
++ QMutexLocker l(&m_currentFrameMutex);
++
++ return std::move(m_currentFrame);
++ }
++
++ void QQnxCamera::viewfinderCallback(camera_handle_t handle, camera_buffer_t *buffer, void *arg)
++ {
++ Q_UNUSED(handle);
++
++ auto *camera = static_cast<QQnxCamera*>(arg);
++ camera->handleVfBuffer(buffer);
++ }
++
++ void QQnxCamera::statusCallback(camera_handle_t handle, camera_devstatus_t status,
++ uint16_t extraData, void *arg)
++ {
++ Q_UNUSED(handle);
++
++ auto *camera = static_cast<QQnxCamera*>(arg);
++ camera->handleVfStatus(status, extraData);
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qqnxcamera_p.cpp"