diff options
Diffstat (limited to 'src/multimedia/qcameraexposure.cpp')
| -rw-r--r-- | src/multimedia/qcameraexposure.cpp | 646 |
1 files changed, 646 insertions, 0 deletions
diff --git a/src/multimedia/qcameraexposure.cpp b/src/multimedia/qcameraexposure.cpp new file mode 100644 index 000000000..580b1cad9 --- /dev/null +++ b/src/multimedia/qcameraexposure.cpp @@ -0,0 +1,646 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** This file may be used under the terms of the GNU Lesser General Public +** License version 2.1 as published by the Free Software Foundation and +** appearing in the file LICENSE.LGPL included in the packaging of this +** file. Please review the following information to ensure the GNU Lesser +** General Public License version 2.1 requirements will be met: +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QDebug> + +#include <qcameraexposure.h> +#include <qcamera.h> + +#include <qmediaobject_p.h> +#include <qcameraexposurecontrol.h> +#include <qcameraflashcontrol.h> +#include <qmetaobject.h> + +QT_BEGIN_NAMESPACE + +/*! + \class QCameraExposure + + + \brief The QCameraExposure class provides interface for exposure related camera settings. + + \inmodule QtMultimedia + \ingroup camera + \since 1.1 + +*/ + +//#define DEBUG_EXPOSURE_CHANGES 1 + +#ifdef DEBUG_EXPOSURE_CHANGES +#define ENUM_NAME(c,e,v) (c::staticMetaObject.enumerator(c::staticMetaObject.indexOfEnumerator(e)).valueToKey((v))) +#endif + +namespace +{ +class CameraExposureRegisterMetaTypes +{ +public: + CameraExposureRegisterMetaTypes() + { + qRegisterMetaType<QCameraExposure::ExposureMode>("QCameraExposure::ExposureMode"); + qRegisterMetaType<QCameraExposure::FlashModes>("QCameraExposure::FlashModes"); + qRegisterMetaType<QCameraExposure::MeteringMode>("QCameraExposure::MeteringMode"); + } +} _registerCameraExposureMetaTypes; +} + + + +class QCameraExposurePrivate +{ + Q_DECLARE_NON_CONST_PUBLIC(QCameraExposure) +public: + void initControls(); + QCameraExposure *q_ptr; + + QCamera *camera; + QCameraExposureControl *exposureControl; + QCameraFlashControl *flashControl; + + void _q_exposureParameterChanged(int parameter); + void _q_exposureParameterRangeChanged(int parameter); +}; + +void QCameraExposurePrivate::initControls() +{ + Q_Q(QCameraExposure); + + QMediaService *service = camera->service(); + exposureControl = 0; + flashControl = 0; + if (service) { + exposureControl = qobject_cast<QCameraExposureControl *>(service->requestControl(QCameraExposureControl_iid)); + flashControl = qobject_cast<QCameraFlashControl *>(service->requestControl(QCameraFlashControl_iid)); + } + if (exposureControl) { + q->connect(exposureControl, SIGNAL(exposureParameterChanged(int)), + q, SLOT(_q_exposureParameterChanged(int))); + q->connect(exposureControl, SIGNAL(exposureParameterRangeChanged(int)), + q, SLOT(_q_exposureParameterRangeChanged(int))); + } + + if (flashControl) + q->connect(flashControl, SIGNAL(flashReady(bool)), q, SIGNAL(flashReady(bool))); +} + +void QCameraExposurePrivate::_q_exposureParameterChanged(int parameter) +{ + Q_Q(QCameraExposure); + +#if DEBUG_EXPOSURE_CHANGES + qDebug() << "Exposure parameter changed:" + << ENUM_NAME(QCameraExposureControl, "ExposureParameter", parameter) + << exposureControl->exposureParameter(QCameraExposureControl::ExposureParameter(parameter)); +#endif + + switch (parameter) { + case QCameraExposureControl::ISO: + emit q->isoSensitivityChanged(q->isoSensitivity()); + break; + case QCameraExposureControl::Aperture: + emit q->apertureChanged(q->aperture()); + break; + case QCameraExposureControl::ShutterSpeed: + emit q->shutterSpeedChanged(q->shutterSpeed()); + break; + case QCameraExposureControl::ExposureCompensation: + emit q->exposureCompensationChanged(q->exposureCompensation()); + break; + } +} + +void QCameraExposurePrivate::_q_exposureParameterRangeChanged(int parameter) +{ + Q_Q(QCameraExposure); + + switch (parameter) { + case QCameraExposureControl::Aperture: + emit q->apertureRangeChanged(); + break; + case QCameraExposureControl::ShutterSpeed: + emit q->shutterSpeedRangeChanged(); + break; + } +} + +/*! + Construct a QCameraExposure from service \a provider and \a parent. +*/ + +QCameraExposure::QCameraExposure(QCamera *parent): + QObject(parent), d_ptr(new QCameraExposurePrivate) +{ + Q_D(QCameraExposure); + d->camera = parent; + d->q_ptr = this; + d->initControls(); +} + + +/*! + Destroys the camera exposure object. +*/ + +QCameraExposure::~QCameraExposure() +{ + Q_D(QCameraExposure); + if (d->exposureControl) + d->camera->service()->releaseControl(d->exposureControl); +} + +/*! + Returns true if exposure settings are supported by this camera. + \since 1.1 +*/ +bool QCameraExposure::isAvailable() const +{ + return d_func()->exposureControl != 0; +} + + +/*! + \property QCameraExposure::flashMode + \brief The flash mode being used. + + Usually the single QCameraExposure::FlashMode flag is used, + but some non conflicting flags combination are also allowed, + like QCameraExposure::FlashManual | QCameraExposure::FlashSlowSyncRearCurtain. + + \since 1.1 + \sa QCameraExposure::isFlashModeSupported(), QCameraExposure::isFlashReady() +*/ + +QCameraExposure::FlashModes QCameraExposure::flashMode() const +{ + return d_func()->flashControl ? d_func()->flashControl->flashMode() : QCameraExposure::FlashOff; +} + +void QCameraExposure::setFlashMode(QCameraExposure::FlashModes mode) +{ + if (d_func()->flashControl) + d_func()->flashControl->setFlashMode(mode); +} + +/*! + Returns true if the flash \a mode is supported. + \since 1.1 +*/ + +bool QCameraExposure::isFlashModeSupported(QCameraExposure::FlashModes mode) const +{ + return d_func()->flashControl ? d_func()->flashControl->isFlashModeSupported(mode) : false; +} + +/*! + Returns true if flash is charged. +*/ + +bool QCameraExposure::isFlashReady() const +{ + return d_func()->flashControl ? d_func()->flashControl->isFlashReady() : false; +} + + +/*! + \property QCameraExposure::exposureMode + \brief The exposure mode being used. + + \since 1.1 + \sa QCameraExposure::isExposureModeSupported() +*/ + +QCameraExposure::ExposureMode QCameraExposure::exposureMode() const +{ + return d_func()->exposureControl ? d_func()->exposureControl->exposureMode() : QCameraExposure::ExposureAuto; +} + +void QCameraExposure::setExposureMode(QCameraExposure::ExposureMode mode) +{ + if (d_func()->exposureControl) + d_func()->exposureControl->setExposureMode(mode); +} + +/*! + Returns true if the exposure \a mode is supported. + \since 1.1 +*/ + +bool QCameraExposure::isExposureModeSupported(QCameraExposure::ExposureMode mode) const +{ + return d_func()->exposureControl ? + d_func()->exposureControl->isExposureModeSupported(mode) : false; +} + +/*! + \property QCameraExposure::exposureCompensation + \brief Exposure compensation in EV units. + + Exposure compensation property allows to adjust the automatically calculated exposure. + \since 1.1 +*/ + +qreal QCameraExposure::exposureCompensation() const +{ + if (d_func()->exposureControl) + return d_func()->exposureControl->exposureParameter(QCameraExposureControl::ExposureCompensation).toReal(); + else + return 0; +} + +void QCameraExposure::setExposureCompensation(qreal ev) +{ + if (d_func()->exposureControl) + d_func()->exposureControl->setExposureParameter(QCameraExposureControl::ExposureCompensation, QVariant(ev)); +} + +/*! + \property QCameraExposure::meteringMode + \brief The metering mode being used. + + \since 1.1 + \sa QCameraExposure::isMeteringModeSupported() +*/ + +QCameraExposure::MeteringMode QCameraExposure::meteringMode() const +{ + return d_func()->exposureControl ? d_func()->exposureControl->meteringMode() : QCameraExposure::MeteringMatrix; +} + +void QCameraExposure::setMeteringMode(QCameraExposure::MeteringMode mode) +{ + if (d_func()->exposureControl) + d_func()->exposureControl->setMeteringMode(mode); +} + +/*! + Returns true if the metering \a mode is supported. + \since 1.1 +*/ +bool QCameraExposure::isMeteringModeSupported(QCameraExposure::MeteringMode mode) const +{ + return d_func()->exposureControl ? d_func()->exposureControl->isMeteringModeSupported(mode) : false; +} + +int QCameraExposure::isoSensitivity() const +{ + if (d_func()->exposureControl) + return d_func()->exposureControl->exposureParameter(QCameraExposureControl::ISO).toInt(); + + return -1; +} + +/*! + Returns the list of ISO senitivities camera supports. + + If the camera supports arbitrary ISO sensitivities within the supported range, + *\a continuous is set to true, otherwise *\a continuous is set to false. + \since 1.1 +*/ +QList<int> QCameraExposure::supportedIsoSensitivities(bool *continuous) const +{ + QList<int> res; + QCameraExposureControl *control = d_func()->exposureControl; + + if (!control) + return res; + + foreach (const QVariant &value, + control->supportedParameterRange(QCameraExposureControl::ISO)) { + bool ok = false; + int intValue = value.toInt(&ok); + if (ok) + res.append(intValue); + else + qWarning() << "Incompatible ISO value type, int is expected"; + } + + if (continuous) + *continuous = control->exposureParameterFlags(QCameraExposureControl::ISO) & + QCameraExposureControl::ContinuousRange; + + return res; +} + +/*! + \fn QCameraExposure::setManualIsoSensitivity(int iso) + Sets the manual sensitivity to \a iso + \since 1.1 +*/ + +void QCameraExposure::setManualIsoSensitivity(int iso) +{ + if (d_func()->exposureControl) + d_func()->exposureControl->setExposureParameter(QCameraExposureControl::ISO, QVariant(iso)); +} + +/*! + \fn QCameraExposure::setAutoIsoSensitivity() + Turn on auto sensitivity + \since 1.1 +*/ + +void QCameraExposure::setAutoIsoSensitivity() +{ + if (d_func()->exposureControl) + d_func()->exposureControl->setExposureParameter(QCameraExposureControl::ISO, QVariant()); +} + +/*! + \property QCameraExposure::shutterSpeed + \brief Camera's shutter speed in seconds. + + \since 1.1 + \sa supportedShutterSpeeds(), setAutoShutterSpeed(), setManualShutterSpeed() +*/ + +/*! + \fn QCameraExposure::shutterSpeedChanged(qreal speed) + + Signals that a camera's shutter \a speed has changed. + \since 1.1 +*/ + +/*! + \property QCameraExposure::isoSensitivity + \brief The sensor ISO sensitivity. + + \sa supportedIsoSensitivities(), setAutoIsoSensitivity(), setManualIsoSensitivity() + \since 1.1 +*/ + +/*! + \property QCameraExposure::aperture + \brief Lens aperture is specified as an F number, the ratio of the focal length to effective aperture diameter. + + \since 1.1 + \sa supportedApertures(), setAutoAperture(), setManualAperture() +*/ + + +qreal QCameraExposure::aperture() const +{ + if (d_func()->exposureControl) + return d_func()->exposureControl->exposureParameter(QCameraExposureControl::Aperture).toReal(); + + return -1.0; +} + +/*! + Returns the list of aperture values camera supports. + The apertures list can change depending on the focal length, + in such a case the apertureRangeChanged() signal is emitted. + + If the camera supports arbitrary aperture values within the supported range, + *\a continuous is set to true, otherwise *\a continuous is set to false. + \since 1.1 +*/ +QList<qreal> QCameraExposure::supportedApertures(bool * continuous) const +{ + QList<qreal> res; + QCameraExposureControl *control = d_func()->exposureControl; + + if (!control) + return res; + + foreach (const QVariant &value, + control->supportedParameterRange(QCameraExposureControl::Aperture)) { + bool ok = false; + qreal realValue = value.toReal(&ok); + if (ok) + res.append(realValue); + else + qWarning() << "Incompatible aperture value type, qreal is expected"; + } + + if (continuous) + *continuous = control->exposureParameterFlags(QCameraExposureControl::Aperture) & + QCameraExposureControl::ContinuousRange; + + return res; +} + +/*! + \fn QCameraExposure::setManualAperture(qreal aperture) + Sets the manual camera \a aperture value. + \since 1.1 +*/ + +void QCameraExposure::setManualAperture(qreal aperture) +{ + if (d_func()->exposureControl) + d_func()->exposureControl->setExposureParameter(QCameraExposureControl::Aperture, QVariant(aperture)); +} + +/*! + \fn QCameraExposure::setAutoAperture() + Turn on auto aperture + \since 1.1 +*/ + +void QCameraExposure::setAutoAperture() +{ + if (d_func()->exposureControl) + d_func()->exposureControl->setExposureParameter(QCameraExposureControl::Aperture, QVariant()); +} + +/*! + Returns the current shutter speed in seconds. + \since 1.1 +*/ + +qreal QCameraExposure::shutterSpeed() const +{ + if (d_func()->exposureControl) + return d_func()->exposureControl->exposureParameter(QCameraExposureControl::ShutterSpeed).toReal(); + + return -1.0; +} + +/*! + Returns the list of shutter speed values in seconds camera supports. + + If the camera supports arbitrary shutter speed values within the supported range, + *\a continuous is set to true, otherwise *\a continuous is set to false. + \since 1.1 +*/ +QList<qreal> QCameraExposure::supportedShutterSpeeds(bool *continuous) const +{ + QList<qreal> res; + + QCameraExposureControl *control = d_func()->exposureControl; + if (!control) + return res; + + foreach (const QVariant &value, + control->supportedParameterRange(QCameraExposureControl::ShutterSpeed)) { + bool ok = false; + qreal realValue = value.toReal(&ok); + if (ok) + res.append(realValue); + else + qWarning() << "Incompatible shutter speed value type, qreal is expected"; + } + + if (continuous) + *continuous = control->exposureParameterFlags(QCameraExposureControl::ShutterSpeed) & + QCameraExposureControl::ContinuousRange; + + return res; +} + +/*! + Set the manual shutter speed to \a seconds + \since 1.1 +*/ + +void QCameraExposure::setManualShutterSpeed(qreal seconds) +{ + if (d_func()->exposureControl) + d_func()->exposureControl->setExposureParameter(QCameraExposureControl::ShutterSpeed, QVariant(seconds)); +} + +/*! + Turn on auto shutter speed + \since 1.1 +*/ + +void QCameraExposure::setAutoShutterSpeed() +{ + if (d_func()->exposureControl) + d_func()->exposureControl->setExposureParameter(QCameraExposureControl::ShutterSpeed, QVariant()); +} + + +/*! + \enum QCameraExposure::FlashMode + + \value FlashOff Flash is Off. + \value FlashOn Flash is On. + \value FlashAuto Automatic flash. + \value FlashRedEyeReduction Red eye reduction flash. + \value FlashFill Use flash to fillin shadows. + \value FlashTorch Constant light source, useful for focusing and video capture. + \value FlashSlowSyncFrontCurtain + Use the flash in conjunction with a slow shutter speed. + This mode allows better exposure of distant objects and/or motion blur effect. + \value FlashSlowSyncRearCurtain + The similar mode to FlashSlowSyncFrontCurtain but flash is fired at the end of exposure. + \value FlashManual Flash power is manualy set. +*/ + +/*! + \enum QCameraExposure::ExposureMode + + \value ExposureManual Manual mode. + \value ExposureAuto Automatic mode. + \value ExposureNight Night mode. + \value ExposureBacklight Backlight exposure mode. + \value ExposureSpotlight Spotlight exposure mode. + \value ExposureSports Spots exposure mode. + \value ExposureSnow Snow exposure mode. + \value ExposureBeach Beach exposure mode. + \value ExposureLargeAperture Use larger aperture with small depth of field. + \value ExposureSmallAperture Use smaller aperture. + \value ExposurePortrait Portrait exposure mode. + \value ExposureModeVendor The base value for device specific exposure modes. +*/ + +/*! + \enum QCameraExposure::MeteringMode + + \value MeteringAverage Center weighted average metering mode. + \value MeteringSpot Spot metering mode. + \value MeteringMatrix Matrix metering mode. +*/ + +/*! + \property QCameraExposure::flashReady + \brief Indicates if the flash is charged and ready to use. + \since 1.1 +*/ + +/*! + \fn void QCameraExposure::flashReady(bool ready) + + Signal the flash \a ready status has changed. + \since 1.1 +*/ + +/*! + \fn void QCameraExposure::apertureChanged(qreal value) + + Signal emitted when aperature changes to \a value. + \since 1.1 +*/ + +/*! + \fn void QCameraExposure::apertureRangeChanged() + + Signal emitted when aperature range has changed. + \since 1.1 +*/ + + +/*! + \fn void QCameraExposure::shutterSpeedRangeChanged() + + Signal emitted when the shutter speed range has changed. + \since 1.1 +*/ + + +/*! + \fn void QCameraExposure::isoSensitivityChanged(int value) + + Signal emitted when sensitivity changes to \a value. + \since 1.1 +*/ + +/*! + \fn void QCameraExposure::exposureCompensationChanged(qreal value) + + Signal emitted when the exposure compensation changes to \a value. + \since 1.1 +*/ + +#include "moc_qcameraexposure.cpp" +QT_END_NAMESPACE |