a925bb4a9e
Replace old license header with correct one. Change-Id: Ibff8fbea6595bb80f1122d55db2194accd319308 Reviewed-on: http://codereview.qt.nokia.com/1318 Reviewed-by: Jyri Tahtela <jyri.tahtela@nokia.com>
585 lines
19 KiB
C++
585 lines
19 KiB
C++
/****************************************************************************
|
|
**
|
|
** 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 Mobility Components.
|
|
**
|
|
** $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 <QtCore/qstring.h>
|
|
|
|
#include "s60cameraexposurecontrol.h"
|
|
#include "s60cameraservice.h"
|
|
#include "s60imagecapturesession.h"
|
|
|
|
S60CameraExposureControl::S60CameraExposureControl(QObject *parent) :
|
|
QCameraExposureControl(parent)
|
|
{
|
|
}
|
|
|
|
S60CameraExposureControl::S60CameraExposureControl(S60ImageCaptureSession *session, QObject *parent) :
|
|
QCameraExposureControl(parent),
|
|
m_session(0),
|
|
m_service(0),
|
|
m_advancedSettings(0),
|
|
m_exposureMode(QCameraExposure::ExposureAuto),
|
|
m_meteringMode(QCameraExposure::MeteringMatrix)
|
|
{
|
|
m_session = session;
|
|
|
|
connect(m_session, SIGNAL(advancedSettingChanged()), this, SLOT(resetAdvancedSetting()));
|
|
m_advancedSettings = m_session->advancedSettings();
|
|
|
|
if (m_advancedSettings) {
|
|
connect(m_advancedSettings, SIGNAL(apertureChanged()), this, SLOT(apertureChanged()));
|
|
connect(m_advancedSettings, SIGNAL(apertureRangeChanged()), this, SLOT(apertureRangeChanged()));
|
|
connect(m_advancedSettings, SIGNAL(shutterSpeedChanged()), this, SLOT(shutterSpeedChanged()));
|
|
connect(m_advancedSettings, SIGNAL(isoSensitivityChanged()), this, SLOT(isoSensitivityChanged()));
|
|
connect(m_advancedSettings, SIGNAL(evChanged()), this, SLOT(evChanged()));
|
|
}
|
|
}
|
|
|
|
S60CameraExposureControl::~S60CameraExposureControl()
|
|
{
|
|
m_advancedSettings = 0;
|
|
}
|
|
|
|
void S60CameraExposureControl::resetAdvancedSetting()
|
|
{
|
|
m_advancedSettings = m_session->advancedSettings();
|
|
if (m_advancedSettings) {
|
|
connect(m_advancedSettings, SIGNAL(apertureChanged()), this, SLOT(apertureChanged()));
|
|
connect(m_advancedSettings, SIGNAL(apertureRangeChanged()), this, SLOT(apertureRangeChanged()));
|
|
connect(m_advancedSettings, SIGNAL(shutterSpeedChanged()), this, SLOT(shutterSpeedChanged()));
|
|
connect(m_advancedSettings, SIGNAL(isoSensitivityChanged()), this, SLOT(isoSensitivityChanged()));
|
|
connect(m_advancedSettings, SIGNAL(evChanged()), this, SLOT(evChanged()));
|
|
}
|
|
}
|
|
|
|
void S60CameraExposureControl::apertureChanged()
|
|
{
|
|
emit exposureParameterChanged(QCameraExposureControl::Aperture);
|
|
}
|
|
|
|
void S60CameraExposureControl::apertureRangeChanged()
|
|
{
|
|
emit exposureParameterRangeChanged(QCameraExposureControl::Aperture);
|
|
}
|
|
|
|
void S60CameraExposureControl::shutterSpeedChanged()
|
|
{
|
|
emit exposureParameterChanged(QCameraExposureControl::ShutterSpeed);
|
|
}
|
|
|
|
void S60CameraExposureControl::isoSensitivityChanged()
|
|
{
|
|
emit exposureParameterChanged(QCameraExposureControl::ISO);
|
|
}
|
|
|
|
void S60CameraExposureControl::evChanged()
|
|
{
|
|
emit exposureParameterChanged(QCameraExposureControl::ExposureCompensation);
|
|
}
|
|
|
|
QCameraExposure::ExposureMode S60CameraExposureControl::exposureMode() const
|
|
{
|
|
return m_session->exposureMode();
|
|
}
|
|
|
|
void S60CameraExposureControl::setExposureMode(QCameraExposure::ExposureMode mode)
|
|
{
|
|
if (isExposureModeSupported(mode)) {
|
|
m_exposureMode = mode;
|
|
m_session->setExposureMode(m_exposureMode);
|
|
return;
|
|
}
|
|
|
|
m_session->setError(KErrNotSupported, tr("Requested exposure mode is not supported."));
|
|
}
|
|
|
|
bool S60CameraExposureControl::isExposureModeSupported(QCameraExposure::ExposureMode mode) const
|
|
{
|
|
if (m_session->isExposureModeSupported(mode))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
QCameraExposure::MeteringMode S60CameraExposureControl::meteringMode() const
|
|
{
|
|
if (m_advancedSettings)
|
|
return m_advancedSettings->meteringMode();
|
|
|
|
return QCameraExposure::MeteringMode();
|
|
}
|
|
|
|
void S60CameraExposureControl::setMeteringMode(QCameraExposure::MeteringMode mode)
|
|
{
|
|
if (m_advancedSettings) {
|
|
if (isMeteringModeSupported(mode)) {
|
|
m_meteringMode = mode;
|
|
m_advancedSettings->setMeteringMode(mode);
|
|
return;
|
|
}
|
|
}
|
|
|
|
m_session->setError(KErrNotSupported, tr("Requested metering mode is not supported."));
|
|
}
|
|
|
|
bool S60CameraExposureControl::isMeteringModeSupported(QCameraExposure::MeteringMode mode) const
|
|
{
|
|
if (m_advancedSettings)
|
|
return m_advancedSettings->isMeteringModeSupported(mode);
|
|
|
|
return false;
|
|
}
|
|
|
|
bool S60CameraExposureControl::isParameterSupported(ExposureParameter parameter) const
|
|
{
|
|
// Settings supported only if advanced settings available
|
|
if (m_advancedSettings) {
|
|
switch (parameter) {
|
|
case QCameraExposureControl::ISO:
|
|
if (m_advancedSettings->supportedIsoSensitivities().count() > 0)
|
|
return true;
|
|
else
|
|
return false;
|
|
case QCameraExposureControl::Aperture:
|
|
if (m_advancedSettings->supportedApertures().count() > 0)
|
|
return true;
|
|
else
|
|
return false;
|
|
case QCameraExposureControl::ShutterSpeed:
|
|
if (m_advancedSettings->supportedShutterSpeeds().count() > 0)
|
|
return true;
|
|
else
|
|
return false;
|
|
case QCameraExposureControl::ExposureCompensation:
|
|
if (m_advancedSettings->supportedExposureCompensationValues().count() > 0)
|
|
return true;
|
|
else
|
|
return false;
|
|
case QCameraExposureControl::FlashPower:
|
|
case QCameraExposureControl::FlashCompensation:
|
|
return false;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
QVariant S60CameraExposureControl::exposureParameter(ExposureParameter parameter) const
|
|
{
|
|
switch (parameter) {
|
|
case QCameraExposureControl::ISO:
|
|
return QVariant(isoSensitivity());
|
|
case QCameraExposureControl::Aperture:
|
|
return QVariant(aperture());
|
|
case QCameraExposureControl::ShutterSpeed:
|
|
return QVariant(shutterSpeed());
|
|
case QCameraExposureControl::ExposureCompensation:
|
|
return QVariant(exposureCompensation());
|
|
case QCameraExposureControl::FlashPower:
|
|
case QCameraExposureControl::FlashCompensation:
|
|
// Not supported in Symbian
|
|
return QVariant();
|
|
|
|
default:
|
|
// Not supported in Symbian
|
|
return QVariant();
|
|
}
|
|
}
|
|
|
|
QCameraExposureControl::ParameterFlags S60CameraExposureControl::exposureParameterFlags(ExposureParameter parameter) const
|
|
{
|
|
QCameraExposureControl::ParameterFlags flags;
|
|
|
|
/*
|
|
* ISO, ExposureCompensation:
|
|
* - Automatic/Manual
|
|
* - Read/Write
|
|
* - Discrete range
|
|
*
|
|
* Aperture, ShutterSpeed, FlashPower, FlashCompensation:
|
|
* - Not supported
|
|
*/
|
|
switch (parameter) {
|
|
case QCameraExposureControl::ISO:
|
|
case QCameraExposureControl::ExposureCompensation:
|
|
flags |= QCameraExposureControl::AutomaticValue;
|
|
break;
|
|
case QCameraExposureControl::Aperture:
|
|
case QCameraExposureControl::ShutterSpeed:
|
|
case QCameraExposureControl::FlashPower:
|
|
case QCameraExposureControl::FlashCompensation:
|
|
// Do nothing - no flags
|
|
break;
|
|
|
|
default:
|
|
// Do nothing - no flags
|
|
break;
|
|
}
|
|
|
|
return flags;
|
|
}
|
|
|
|
QVariantList S60CameraExposureControl::supportedParameterRange(ExposureParameter parameter) const
|
|
{
|
|
QVariantList valueList;
|
|
|
|
if (m_advancedSettings) {
|
|
switch (parameter) {
|
|
case QCameraExposureControl::ISO: {
|
|
foreach (int iso, m_advancedSettings->supportedIsoSensitivities())
|
|
valueList << QVariant(iso);
|
|
break;
|
|
}
|
|
case QCameraExposureControl::Aperture: {
|
|
foreach (qreal aperture, m_advancedSettings->supportedApertures())
|
|
valueList << QVariant(aperture);
|
|
break;
|
|
}
|
|
case QCameraExposureControl::ShutterSpeed: {
|
|
foreach (qreal shutterSpeed, m_advancedSettings->supportedShutterSpeeds())
|
|
valueList << QVariant(shutterSpeed);
|
|
break;
|
|
}
|
|
case QCameraExposureControl::ExposureCompensation: {
|
|
foreach (qreal ev, m_advancedSettings->supportedExposureCompensationValues())
|
|
valueList << QVariant(ev);
|
|
break;
|
|
}
|
|
case QCameraExposureControl::FlashPower:
|
|
case QCameraExposureControl::FlashCompensation:
|
|
// Not supported in Symbian
|
|
break;
|
|
|
|
default:
|
|
// Not supported in Symbian
|
|
break;
|
|
}
|
|
}
|
|
|
|
return valueList;
|
|
}
|
|
|
|
bool S60CameraExposureControl::setExposureParameter(ExposureParameter parameter, const QVariant& value)
|
|
{
|
|
bool useDefaultValue = false;
|
|
|
|
if (value.isNull())
|
|
useDefaultValue = true;
|
|
|
|
switch (parameter) {
|
|
case QCameraExposureControl::ISO:
|
|
if (useDefaultValue) {
|
|
setAutoIsoSensitivity();
|
|
return false;
|
|
}
|
|
else
|
|
return setManualIsoSensitivity(value.toInt());
|
|
|
|
case QCameraExposureControl::Aperture:
|
|
if (useDefaultValue) {
|
|
setAutoAperture();
|
|
return false;
|
|
}
|
|
else
|
|
return setManualAperture(value.toFloat());
|
|
|
|
case QCameraExposureControl::ShutterSpeed:
|
|
if (useDefaultValue) {
|
|
setAutoShutterSpeed();
|
|
return false;
|
|
}
|
|
else
|
|
return setManualShutterSpeed(value.toFloat());
|
|
|
|
case QCameraExposureControl::ExposureCompensation:
|
|
if (useDefaultValue) {
|
|
setAutoExposureCompensation();
|
|
return false;
|
|
}
|
|
else
|
|
return setManualExposureCompensation(value.toFloat());
|
|
|
|
case QCameraExposureControl::FlashPower:
|
|
return false;
|
|
case QCameraExposureControl::FlashCompensation:
|
|
return false;
|
|
|
|
default:
|
|
// Not supported in Symbian
|
|
return false;
|
|
}
|
|
}
|
|
|
|
QString S60CameraExposureControl::extendedParameterName(ExposureParameter parameter)
|
|
{
|
|
switch (parameter) {
|
|
case QCameraExposureControl::ISO:
|
|
return QLatin1String("ISO Sensitivity");
|
|
case QCameraExposureControl::Aperture:
|
|
return QLatin1String("Aperture");
|
|
case QCameraExposureControl::ShutterSpeed:
|
|
return QLatin1String("Shutter Speed");
|
|
case QCameraExposureControl::ExposureCompensation:
|
|
return QLatin1String("Exposure Compensation");
|
|
case QCameraExposureControl::FlashPower:
|
|
return QLatin1String("Flash Power");
|
|
case QCameraExposureControl::FlashCompensation:
|
|
return QLatin1String("Flash Compensation");
|
|
|
|
default:
|
|
return QString();
|
|
}
|
|
}
|
|
|
|
int S60CameraExposureControl::isoSensitivity() const
|
|
{
|
|
if (m_advancedSettings)
|
|
return m_advancedSettings->isoSensitivity();
|
|
return 0;
|
|
}
|
|
|
|
bool S60CameraExposureControl::isIsoSensitivitySupported(const int iso) const
|
|
{
|
|
if (m_advancedSettings &&
|
|
m_advancedSettings->supportedIsoSensitivities().contains(iso))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
bool S60CameraExposureControl::setManualIsoSensitivity(int iso)
|
|
{
|
|
if (m_advancedSettings) {
|
|
if (isIsoSensitivitySupported(iso)) {
|
|
m_advancedSettings->setManualIsoSensitivity(iso);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void S60CameraExposureControl::setAutoIsoSensitivity()
|
|
{
|
|
if (m_advancedSettings)
|
|
m_advancedSettings->setAutoIsoSensitivity();
|
|
}
|
|
|
|
qreal S60CameraExposureControl::aperture() const
|
|
{
|
|
if (m_advancedSettings)
|
|
return m_advancedSettings->aperture();
|
|
return 0.0;
|
|
}
|
|
|
|
bool S60CameraExposureControl::isApertureSupported(const qreal aperture) const
|
|
{
|
|
if (m_advancedSettings) {
|
|
QList<qreal> supportedValues = m_advancedSettings->supportedApertures();
|
|
if(supportedValues.indexOf(aperture) != -1)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool S60CameraExposureControl::setManualAperture(qreal aperture)
|
|
{
|
|
if (m_advancedSettings) {
|
|
if (isApertureSupported(aperture)) {
|
|
m_advancedSettings->setManualAperture(aperture);
|
|
return true;
|
|
} else {
|
|
QList<qreal> supportedApertureValues = m_advancedSettings->supportedApertures();
|
|
int minAperture = supportedApertureValues.first();
|
|
int maxAperture = supportedApertureValues.last();
|
|
|
|
if (aperture < minAperture) { // Smaller than minimum
|
|
aperture = minAperture;
|
|
} else if (aperture > maxAperture) { // Bigger than maximum
|
|
aperture = maxAperture;
|
|
} else { // Find closest
|
|
int indexOfClosest = 0;
|
|
int smallestDiff = 100000000; // Sensible max diff
|
|
for(int i = 0; i < supportedApertureValues.count(); ++i) {
|
|
if((abs((aperture*100) - (supportedApertureValues[i]*100))) < smallestDiff) {
|
|
smallestDiff = abs((aperture*100) - (supportedApertureValues[i]*100));
|
|
indexOfClosest = i;
|
|
}
|
|
}
|
|
aperture = supportedApertureValues[indexOfClosest];
|
|
}
|
|
m_advancedSettings->setManualAperture(aperture);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void S60CameraExposureControl::setAutoAperture()
|
|
{
|
|
// Not supported in Symbian
|
|
}
|
|
|
|
qreal S60CameraExposureControl::shutterSpeed() const
|
|
{
|
|
if (m_advancedSettings)
|
|
return m_advancedSettings->shutterSpeed();
|
|
return 0.0;
|
|
}
|
|
|
|
bool S60CameraExposureControl::isShutterSpeedSupported(const qreal seconds) const
|
|
{
|
|
if (m_advancedSettings) {
|
|
QList<qreal> supportedValues = m_advancedSettings->supportedShutterSpeeds();
|
|
if(supportedValues.indexOf(seconds) != -1)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool S60CameraExposureControl::setManualShutterSpeed(qreal seconds)
|
|
{
|
|
if (m_advancedSettings) {
|
|
if (isShutterSpeedSupported(seconds)) {
|
|
m_advancedSettings->setManualShutterSpeed(seconds);
|
|
return true;
|
|
} else {
|
|
QList<qreal> supportedShutterSpeeds = m_advancedSettings->supportedShutterSpeeds();
|
|
|
|
if (supportedShutterSpeeds.count() == 0)
|
|
return false;
|
|
|
|
int minShutterSpeed = supportedShutterSpeeds.first();
|
|
int maxShutterSpeed = supportedShutterSpeeds.last();
|
|
|
|
if (seconds < minShutterSpeed) { // Smaller than minimum
|
|
seconds = minShutterSpeed;
|
|
} else if (seconds > maxShutterSpeed) { // Bigger than maximum
|
|
seconds = maxShutterSpeed;
|
|
} else { // Find closest
|
|
int indexOfClosest = 0;
|
|
int smallestDiff = 100000000; // Sensible max diff
|
|
for(int i = 0; i < supportedShutterSpeeds.count(); ++i) {
|
|
if((abs((seconds*100) - (supportedShutterSpeeds[i]*100))) < smallestDiff) {
|
|
smallestDiff = abs((seconds*100) - (supportedShutterSpeeds[i]*100));
|
|
indexOfClosest = i;
|
|
}
|
|
}
|
|
seconds = supportedShutterSpeeds[indexOfClosest];
|
|
}
|
|
m_advancedSettings->setManualShutterSpeed(seconds);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void S60CameraExposureControl::setAutoShutterSpeed()
|
|
{
|
|
// Not supported in Symbian
|
|
}
|
|
|
|
qreal S60CameraExposureControl::exposureCompensation() const
|
|
{
|
|
if (m_advancedSettings)
|
|
return m_advancedSettings->exposureCompensation();
|
|
return 0.0;
|
|
}
|
|
|
|
bool S60CameraExposureControl::isExposureCompensationSupported(const qreal ev) const
|
|
{
|
|
if (m_advancedSettings) {
|
|
QList<qreal> supportedValues = m_advancedSettings->supportedExposureCompensationValues();
|
|
if(supportedValues.indexOf(ev) != -1)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool S60CameraExposureControl::setManualExposureCompensation(qreal ev)
|
|
{
|
|
if (m_advancedSettings) {
|
|
if (isExposureCompensationSupported(ev)) {
|
|
m_advancedSettings->setExposureCompensation(ev);
|
|
return true;
|
|
} else {
|
|
QList<qreal> supportedEVs = m_advancedSettings->supportedExposureCompensationValues();
|
|
|
|
if (supportedEVs.count() == 0)
|
|
return false;
|
|
|
|
int minEV = supportedEVs.first();
|
|
int maxEV = supportedEVs.last();
|
|
|
|
if (ev < minEV) { // Smaller than minimum
|
|
ev = minEV;
|
|
} else if (ev > maxEV) { // Bigger than maximum
|
|
ev = maxEV;
|
|
} else { // Find closest
|
|
int indexOfClosest = 0;
|
|
int smallestDiff = 100000000; // Sensible max diff
|
|
for(int i = 0; i < supportedEVs.count(); ++i) {
|
|
if((abs((ev*100) - (supportedEVs[i]*100))) < smallestDiff) {
|
|
smallestDiff = abs((ev*100) - (supportedEVs[i]*100));
|
|
indexOfClosest = i;
|
|
}
|
|
}
|
|
ev = supportedEVs[indexOfClosest];
|
|
}
|
|
m_advancedSettings->setExposureCompensation(ev);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void S60CameraExposureControl::setAutoExposureCompensation()
|
|
{
|
|
// Not supported in Symbian
|
|
}
|
|
|
|
// End of file
|