| /**************************************************************************** |
| ** |
| ** Copyright (C) 2018 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU Lesser General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Lesser |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
| ** packaging of this file. Please review the following information to |
| ** ensure the GNU Lesser General Public License version 3 requirements |
| ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 2.0 or (at your option) the GNU General |
| ** Public license version 3 or any later version approved by the KDE Free |
| ** Qt Foundation. The licenses are as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
| ** https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "directshowcamerazoomcontrol.h" |
| #include "dscamerasession.h" |
| #include "directshowutils.h" |
| |
| QT_BEGIN_NAMESPACE |
| |
| inline static qreal defaultZoomValue() { return qreal(1.0); } |
| |
| DirectShowCameraZoomControl::DirectShowCameraZoomControl(DSCameraSession *session) |
| : m_session(session) |
| , m_opticalZoom({0, 0, 0, 0, 0}) |
| , m_currentOpticalZoom(qreal(0.0)) |
| , m_requestedOpticalZoom(qreal(0.0)) |
| , m_maxOpticalZoom(qreal(1.0)) |
| { |
| Q_ASSERT(m_session); |
| connect(m_session, &DSCameraSession::statusChanged, |
| this, &DirectShowCameraZoomControl::onStatusChanged); |
| } |
| |
| qreal DirectShowCameraZoomControl::maximumOpticalZoom() const |
| { |
| return m_maxOpticalZoom; |
| } |
| |
| qreal DirectShowCameraZoomControl::maximumDigitalZoom() const |
| { |
| return defaultZoomValue(); |
| } |
| |
| qreal DirectShowCameraZoomControl::requestedOpticalZoom() const |
| { |
| return qMax(defaultZoomValue(), m_requestedOpticalZoom); |
| } |
| |
| qreal DirectShowCameraZoomControl::requestedDigitalZoom() const |
| { |
| return defaultZoomValue(); |
| } |
| |
| qreal DirectShowCameraZoomControl::currentOpticalZoom() const |
| { |
| return qMax(defaultZoomValue(), m_currentOpticalZoom); |
| } |
| |
| qreal DirectShowCameraZoomControl::currentDigitalZoom() const |
| { |
| return defaultZoomValue(); |
| } |
| |
| void DirectShowCameraZoomControl::zoomTo(qreal optical, qreal digital) |
| { |
| Q_UNUSED(digital); |
| if (!(m_opticalZoom.caps & CameraControl_Flags_Manual)) |
| return; |
| |
| if (qFuzzyCompare(optical, m_requestedOpticalZoom)) |
| return; |
| |
| m_requestedOpticalZoom = optical; |
| Q_EMIT requestedOpticalZoomChanged(m_requestedOpticalZoom); |
| |
| if (qFuzzyCompare(m_requestedOpticalZoom, m_currentOpticalZoom)) |
| return; |
| |
| if (m_session->status() != QCamera::LoadedStatus && m_session->status() != QCamera::ActiveStatus) |
| return; // We'll wait until the camera is loaded, see: statusChanged connection |
| |
| opticalZoomToPrivate(optical); |
| } |
| |
| void DirectShowCameraZoomControl::onStatusChanged(QCamera::Status status) |
| { |
| if (status == QCamera::LoadedStatus) { |
| updateZoomValues(); |
| } else if (status == QCamera::UnloadedStatus) { |
| SecureZeroMemory(&m_opticalZoom, sizeof(ZoomValues)); |
| m_currentOpticalZoom = qreal(0.0); |
| m_requestedOpticalZoom = qreal(0.0); |
| } |
| |
| } |
| |
| void DirectShowCameraZoomControl::updateZoomValues() |
| { |
| IAMCameraControl *cameraControl = nullptr; |
| const DirectShowUtils::ScopedSafeRelease<IAMCameraControl> rControl { &cameraControl }; |
| if (!m_session->getCameraControlInterface(&cameraControl)) |
| return; |
| |
| ZoomValues values { 0, 0, 0, 0, 0 }; |
| // Zoom levels in DS are in the range [10, 600] |
| // The default zoom is device specific. |
| HRESULT hr = cameraControl->GetRange(CameraControl_Zoom, |
| &values.minZoom, |
| &values.maxZoom, |
| &values.stepping, |
| &values.defaultZoom, |
| &values.caps); |
| |
| if (FAILED(hr)) { |
| qCDebug(qtDirectShowPlugin, "Getting the camera's zoom properties failed"); |
| SecureZeroMemory(&m_opticalZoom, sizeof(ZoomValues)); |
| return; |
| } |
| |
| if (!(values.caps & CameraControl_Flags_Manual)) { |
| qCDebug(qtDirectShowPlugin, "Camera does not support manual zoom"); |
| SecureZeroMemory(&m_opticalZoom, sizeof(ZoomValues)); |
| return; |
| } |
| |
| if (values.maxZoom != m_opticalZoom.maxZoom) { |
| const qreal newMaxZoomScale = (values.minZoom == 0) ? defaultZoomValue() |
| : (qreal(values.maxZoom) / qreal(values.minZoom)); |
| if (!qFuzzyCompare(newMaxZoomScale, m_maxOpticalZoom)) { |
| m_maxOpticalZoom = newMaxZoomScale; |
| Q_EMIT maximumOpticalZoomChanged(m_maxOpticalZoom); |
| } |
| } |
| |
| m_opticalZoom = values; |
| |
| long currentZoom = 0; |
| long flags = 0; |
| if (FAILED(cameraControl->Get(CameraControl_Zoom, ¤tZoom, &flags))) { |
| qCDebug(qtDirectShowPlugin, "Getting the camera's current zoom value failed!"); |
| return; |
| } |
| |
| qreal currentOpticalZoom = (m_opticalZoom.minZoom == 0) ? defaultZoomValue() |
| : (qreal(currentZoom) / qreal(m_opticalZoom.minZoom)); |
| currentOpticalZoom = qMax(defaultZoomValue(), currentOpticalZoom); |
| if (!qFuzzyCompare(m_currentOpticalZoom, currentOpticalZoom)) { |
| m_currentOpticalZoom = currentOpticalZoom; |
| Q_EMIT currentOpticalZoomChanged(m_currentOpticalZoom); |
| } |
| |
| // Check if there is a pending zoom value. |
| if (!qFuzzyCompare(m_currentOpticalZoom, m_requestedOpticalZoom) && !qFuzzyIsNull(m_requestedOpticalZoom)) |
| opticalZoomToPrivate(m_requestedOpticalZoom); |
| } |
| |
| bool DirectShowCameraZoomControl::opticalZoomToPrivate(qreal scaleFactor) |
| { |
| IAMCameraControl *cameraControl = nullptr; |
| const DirectShowUtils::ScopedSafeRelease<IAMCameraControl> rControl { &cameraControl }; |
| if (!m_session->getCameraControlInterface(&cameraControl)) |
| return false; |
| |
| // Convert to DS zoom value |
| const int newDSOpticalZoom = qRound(m_opticalZoom.minZoom * scaleFactor); |
| long newDSOpticalZoomAdjusted = newDSOpticalZoom - (newDSOpticalZoom % m_opticalZoom.stepping); |
| newDSOpticalZoomAdjusted = qBound(m_opticalZoom.minZoom, newDSOpticalZoomAdjusted, m_opticalZoom.maxZoom); |
| |
| if (FAILED(cameraControl->Set(CameraControl_Zoom, newDSOpticalZoomAdjusted, CameraControl_Flags_Manual))) { |
| qCDebug(qtDirectShowPlugin, "Setting the camera's zoom value failed"); |
| return false; |
| } |
| |
| const qreal newScaleFactor = (m_opticalZoom.minZoom == 0) ? defaultZoomValue() |
| : (qreal(newDSOpticalZoomAdjusted) / qreal(m_opticalZoom.minZoom)); |
| // convert back to Qt scale value |
| m_currentOpticalZoom = qMax(defaultZoomValue(), newScaleFactor); |
| Q_EMIT currentOpticalZoomChanged(m_currentOpticalZoom); |
| |
| return true; |
| } |
| |
| QT_END_NAMESPACE |