m_flash = service ? service->requestControl<QCameraFlashControl*>() : 0;
if (m_exposure)
- connect(m_exposure, SIGNAL(exposureParameterChanged(int)), SLOT(parameterChanged(int)));
+ connect(m_exposure, SIGNAL(valueChanged(int)), SLOT(parameterChanged(int)));
// XXX There's no signal for flash mode changed
}
if (!m_exposure)
return 0;
- return m_exposure->exposureParameter(QCameraExposureControl::FlashPower).toInt();
+ return m_exposure->requestedValue(QCameraExposureControl::TorchPower).toInt();
}
/*!
return;
power = qBound(0, power, 100);
- if (this->power() != power) {
- m_exposure->setExposureParameter(QCameraExposureControl::FlashPower, power);
- emit powerChanged();
- }
+ if (this->power() != power)
+ m_exposure->setValue(QCameraExposureControl::TorchPower, power);
}
/* Check for changes in flash power */
//#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
void initControls();
QCameraExposure *q_ptr;
+ template<typename T> T actualExposureParameter(QCameraExposureControl::ExposureParameter parameter, const T &defaultValue) const;
+ template<typename T> T requestedExposureParameter(QCameraExposureControl::ExposureParameter parameter, const T &defaultValue) const;
+ template<typename T> void setExposureParameter(QCameraExposureControl::ExposureParameter parameter, const T &value);
+ void resetExposureParameter(QCameraExposureControl::ExposureParameter parameter);
+
QCamera *camera;
QCameraExposureControl *exposureControl;
QCameraFlashControl *flashControl;
flashControl = qobject_cast<QCameraFlashControl *>(service->requestControl(QCameraFlashControl_iid));
}
if (exposureControl) {
- q->connect(exposureControl, SIGNAL(exposureParameterChanged(int)),
+ q->connect(exposureControl, SIGNAL(actualValueChanged(int)),
q, SLOT(_q_exposureParameterChanged(int)));
- q->connect(exposureControl, SIGNAL(exposureParameterRangeChanged(int)),
+ q->connect(exposureControl, SIGNAL(parameterRangeChanged(int)),
q, SLOT(_q_exposureParameterRangeChanged(int)));
}
q->connect(flashControl, SIGNAL(flashReady(bool)), q, SIGNAL(flashReady(bool)));
}
+template<typename T>
+T QCameraExposurePrivate::actualExposureParameter(QCameraExposureControl::ExposureParameter parameter, const T &defaultValue) const
+{
+ QVariant value = exposureControl ? exposureControl->actualValue(parameter) : QVariant();
+
+ return value.isValid() ? value.value<T>() : defaultValue;
+}
+
+template<typename T>
+T QCameraExposurePrivate::requestedExposureParameter(QCameraExposureControl::ExposureParameter parameter, const T &defaultValue) const
+{
+ QVariant value = exposureControl ? exposureControl->requestedValue(parameter) : QVariant();
+
+ return value.isValid() ? value.value<T>() : defaultValue;
+}
+
+template<typename T>
+void QCameraExposurePrivate::setExposureParameter(QCameraExposureControl::ExposureParameter parameter, const T &value)
+{
+ if (exposureControl)
+ exposureControl->setValue(parameter, QVariant::fromValue<T>(value));
+}
+
+void QCameraExposurePrivate::resetExposureParameter(QCameraExposureControl::ExposureParameter parameter)
+{
+ if (exposureControl)
+ exposureControl->setValue(parameter, QVariant());
+}
+
+
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));
+ << QCameraExposureControl::ExposureParameter(parameter)
+ << exposureControl->actualValue(QCameraExposureControl::ExposureParameter(parameter));
#endif
switch (parameter) {
return d_func()->flashControl ? d_func()->flashControl->isFlashReady() : false;
}
-
/*!
\property QCameraExposure::exposureMode
\brief The exposure mode being used.
QCameraExposure::ExposureMode QCameraExposure::exposureMode() const
{
- return d_func()->exposureControl ? d_func()->exposureControl->exposureMode() : QCameraExposure::ExposureAuto;
+ return d_func()->actualExposureParameter<QCameraExposure::ExposureMode>(QCameraExposureControl::ExposureMode, QCameraExposure::ExposureAuto);
}
void QCameraExposure::setExposureMode(QCameraExposure::ExposureMode mode)
{
- if (d_func()->exposureControl)
- d_func()->exposureControl->setExposureMode(mode);
+ d_func()->setExposureParameter<QCameraExposure::ExposureMode>(QCameraExposureControl::ExposureMode, mode);
}
/*!
bool QCameraExposure::isExposureModeSupported(QCameraExposure::ExposureMode mode) const
{
- return d_func()->exposureControl ?
- d_func()->exposureControl->isExposureModeSupported(mode) : false;
+ if (!d_func()->exposureControl)
+ return false;
+
+ bool continuous = false;
+ return d_func()->exposureControl->supportedParameterRange(QCameraExposureControl::ExposureMode, &continuous)
+ .contains(QVariant::fromValue<QCameraExposure::ExposureMode>(mode));
}
/*!
qreal QCameraExposure::exposureCompensation() const
{
- if (d_func()->exposureControl)
- return d_func()->exposureControl->exposureParameter(QCameraExposureControl::ExposureCompensation).toReal();
- else
- return 0;
+ return d_func()->actualExposureParameter<qreal>(QCameraExposureControl::ExposureCompensation, 0.0);
}
void QCameraExposure::setExposureCompensation(qreal ev)
{
- if (d_func()->exposureControl)
- d_func()->exposureControl->setExposureParameter(QCameraExposureControl::ExposureCompensation, QVariant(ev));
+ d_func()->setExposureParameter<qreal>(QCameraExposureControl::ExposureCompensation, ev);
}
/*!
QCameraExposure::MeteringMode QCameraExposure::meteringMode() const
{
- return d_func()->exposureControl ? d_func()->exposureControl->meteringMode() : QCameraExposure::MeteringMatrix;
+ return d_func()->actualExposureParameter<QCameraExposure::MeteringMode>(QCameraExposureControl::MeteringMode, QCameraExposure::MeteringMatrix);
}
void QCameraExposure::setMeteringMode(QCameraExposure::MeteringMode mode)
{
- if (d_func()->exposureControl)
- d_func()->exposureControl->setMeteringMode(mode);
+ d_func()->setExposureParameter<QCameraExposure::MeteringMode>(QCameraExposureControl::MeteringMode, mode);
}
/*!
QPointF QCameraExposure::spotMeteringPoint() const
{
- return d_func()->exposureControl ? d_func()->exposureControl->exposureParameter(QCameraExposureControl::SpotMeteringPoint).toPointF() : QPointF();
+ return d_func()->exposureControl ? d_func()->exposureControl->actualValue(QCameraExposureControl::SpotMeteringPoint).toPointF() : QPointF();
}
void QCameraExposure::setSpotMeteringPoint(const QPointF &point)
{
if (d_func()->exposureControl)
- d_func()->exposureControl->setExposureParameter(QCameraExposureControl::SpotMeteringPoint, point);
+ d_func()->exposureControl->setValue(QCameraExposureControl::SpotMeteringPoint, point);
}
*/
bool QCameraExposure::isMeteringModeSupported(QCameraExposure::MeteringMode mode) const
{
- return d_func()->exposureControl ? d_func()->exposureControl->isMeteringModeSupported(mode) : false;
+ if (!d_func()->exposureControl)
+ return false;
+
+ bool continuous = false;
+ return d_func()->exposureControl->supportedParameterRange(QCameraExposureControl::MeteringMode, &continuous)
+ .contains(QVariant::fromValue<QCameraExposure::MeteringMode>(mode));
}
int QCameraExposure::isoSensitivity() const
{
- if (d_func()->exposureControl)
- return d_func()->exposureControl->exposureParameter(QCameraExposureControl::ISO).toInt();
+ return d_func()->actualExposureParameter<int>(QCameraExposureControl::ISO, -1);
+}
- return -1;
+/*!
+ Returns the requested ISO sensitivity
+ or -1 if automatic ISO is turned on.
+*/
+int QCameraExposure::requestedIsoSensitivity() const
+{
+ return d_func()->requestedExposureParameter<int>(QCameraExposureControl::ISO, -1);
}
/*!
QList<int> res;
QCameraExposureControl *control = d_func()->exposureControl;
+ bool tmp = false;
+ if (!continuous)
+ continuous = &tmp;
+
if (!control)
return res;
foreach (const QVariant &value,
- control->supportedParameterRange(QCameraExposureControl::ISO)) {
+ control->supportedParameterRange(QCameraExposureControl::ISO, continuous)) {
bool ok = false;
int intValue = value.toInt(&ok);
if (ok)
qWarning() << "Incompatible ISO value type, int is expected";
}
- if (continuous)
- *continuous = control->exposureParameterFlags(QCameraExposureControl::ISO) &
- QCameraExposureControl::ContinuousRange;
-
return res;
}
void QCameraExposure::setManualIsoSensitivity(int iso)
{
- if (d_func()->exposureControl)
- d_func()->exposureControl->setExposureParameter(QCameraExposureControl::ISO, QVariant(iso));
+ d_func()->setExposureParameter<int>(QCameraExposureControl::ISO, iso);
}
/*!
void QCameraExposure::setAutoIsoSensitivity()
{
- if (d_func()->exposureControl)
- d_func()->exposureControl->setExposureParameter(QCameraExposureControl::ISO, QVariant());
+ d_func()->resetExposureParameter(QCameraExposureControl::ISO);
}
/*!
\property QCameraExposure::aperture
\brief Lens aperture is specified as an F number, the ratio of the focal length to effective aperture diameter.
- \sa supportedApertures(), setAutoAperture(), setManualAperture()
+ \sa supportedApertures(), setAutoAperture(), setManualAperture(), requestedAperture()
*/
qreal QCameraExposure::aperture() const
{
- if (d_func()->exposureControl)
- return d_func()->exposureControl->exposureParameter(QCameraExposureControl::Aperture).toReal();
+ return d_func()->actualExposureParameter<qreal>(QCameraExposureControl::Aperture, -1.0);
+}
- return -1.0;
+/*!
+ Returns the requested manual aperture
+ or -1.0 if automatic aperture is turned on.
+*/
+qreal QCameraExposure::requestedAperture() const
+{
+ return d_func()->requestedExposureParameter<qreal>(QCameraExposureControl::Aperture, -1.0);
}
+
/*!
Returns the list of aperture values camera supports.
The apertures list can change depending on the focal length,
QList<qreal> res;
QCameraExposureControl *control = d_func()->exposureControl;
+ bool tmp = false;
+ if (!continuous)
+ continuous = &tmp;
+
if (!control)
return res;
foreach (const QVariant &value,
- control->supportedParameterRange(QCameraExposureControl::Aperture)) {
+ control->supportedParameterRange(QCameraExposureControl::Aperture, continuous)) {
bool ok = false;
qreal realValue = value.toReal(&ok);
if (ok)
qWarning() << "Incompatible aperture value type, qreal is expected";
}
- if (continuous)
- *continuous = control->exposureParameterFlags(QCameraExposureControl::Aperture) &
- QCameraExposureControl::ContinuousRange;
-
return res;
}
void QCameraExposure::setManualAperture(qreal aperture)
{
- if (d_func()->exposureControl)
- d_func()->exposureControl->setExposureParameter(QCameraExposureControl::Aperture, QVariant(aperture));
+ d_func()->setExposureParameter<qreal>(QCameraExposureControl::Aperture, aperture);
}
/*!
void QCameraExposure::setAutoAperture()
{
- if (d_func()->exposureControl)
- d_func()->exposureControl->setExposureParameter(QCameraExposureControl::Aperture, QVariant());
+ d_func()->resetExposureParameter(QCameraExposureControl::Aperture);
}
/*!
qreal QCameraExposure::shutterSpeed() const
{
- if (d_func()->exposureControl)
- return d_func()->exposureControl->exposureParameter(QCameraExposureControl::ShutterSpeed).toReal();
+ return d_func()->actualExposureParameter<qreal>(QCameraExposureControl::ShutterSpeed, -1.0);
+}
- return -1.0;
+/*!
+ Returns the requested manual shutter speed in seconds
+ or -1.0 if automatic shutter speed is turned on.
+*/
+qreal QCameraExposure::requestedShutterSpeed() const
+{
+ return d_func()->requestedExposureParameter<qreal>(QCameraExposureControl::ShutterSpeed, -1.0);
}
/*!
QList<qreal> QCameraExposure::supportedShutterSpeeds(bool *continuous) const
{
QList<qreal> res;
-
QCameraExposureControl *control = d_func()->exposureControl;
+
+ bool tmp = false;
+ if (!continuous)
+ continuous = &tmp;
+
if (!control)
return res;
foreach (const QVariant &value,
- control->supportedParameterRange(QCameraExposureControl::ShutterSpeed)) {
+ control->supportedParameterRange(QCameraExposureControl::ShutterSpeed, continuous)) {
bool ok = false;
qreal realValue = value.toReal(&ok);
if (ok)
qWarning() << "Incompatible shutter speed value type, qreal is expected";
}
- if (continuous)
- *continuous = control->exposureParameterFlags(QCameraExposureControl::ShutterSpeed) &
- QCameraExposureControl::ContinuousRange;
-
return res;
}
void QCameraExposure::setManualShutterSpeed(qreal seconds)
{
- if (d_func()->exposureControl)
- d_func()->exposureControl->setExposureParameter(QCameraExposureControl::ShutterSpeed, QVariant(seconds));
+ d_func()->setExposureParameter<qreal>(QCameraExposureControl::ShutterSpeed, seconds);
}
/*!
void QCameraExposure::setAutoShutterSpeed()
{
- if (d_func()->exposureControl)
- d_func()->exposureControl->setExposureParameter(QCameraExposureControl::ShutterSpeed, QVariant());
+ d_func()->resetExposureParameter(QCameraExposureControl::ShutterSpeed);
}
qreal exposureCompensation() const;
MeteringMode meteringMode() const;
-
bool isMeteringModeSupported(MeteringMode mode) const;
QPointF spotMeteringPoint() const;
void setSpotMeteringPoint(const QPointF &point);
int isoSensitivity() const;
- QList<int> supportedIsoSensitivities(bool *continuous = 0) const;
-
qreal aperture() const;
- QList<qreal> supportedApertures(bool *continuous = 0) const;
-
qreal shutterSpeed() const;
+
+ int requestedIsoSensitivity() const;
+ qreal requestedAperture() const;
+ qreal requestedShutterSpeed() const;
+
+ QList<int> supportedIsoSensitivities(bool *continuous = 0) const;
+ QList<qreal> supportedApertures(bool * continuous = 0) const;
QList<qreal> supportedShutterSpeeds(bool *continuous = 0) const;
public Q_SLOTS:
void setFlashMode(FlashModes mode);
void setExposureMode(ExposureMode mode);
+ void setMeteringMode(MeteringMode mode);
void setExposureCompensation(qreal ev);
- void setMeteringMode(MeteringMode mode);
-
void setManualIsoSensitivity(int iso);
void setAutoIsoSensitivity();
}
/*!
- Destroys the camera control object.
+ Destroys the camera exposure control object.
*/
QCameraExposureControl::~QCameraExposureControl()
{
}
/*!
- \fn QCamera::ExposureMode QCameraExposureControl::exposureMode() const
-
- Returns the exposure mode.
-*/
-
-
-/*!
- \fn void QCameraExposureControl::setExposureMode(QCameraExposure::ExposureMode mode)
-
- Set the exposure mode to \a mode.
-*/
-
-
-/*!
- \fn bool QCameraExposureControl::isExposureModeSupported(QCameraExposure::ExposureMode mode) const
-
- Returns true if the exposure \a mode is supported.
-*/
-
-
-/*!
- \fn QCameraExposure::MeteringMode QCameraExposureControl::meteringMode() const
- Returns the current metering mode.
-*/
-
-/*!
- \fn void QCameraExposureControl::setMeteringMode(QCameraExposure::MeteringMode mode)
-
- Set the metering mode to \a mode.
-*/
-
-/*!
- \fn bool QCameraExposureControl::isMeteringModeSupported(QCameraExposure::MeteringMode mode) const
- Returns true if the metering \a mode is supported.
-*/
-
-/*!
\enum QCameraExposureControl::ExposureParameter
- \value InvalidParameter
- Parameter is invalid.
\value ISO
Camera ISO sensitivity, specified as integer value.
\value Aperture
with 0 value means no flash and 1.0 corresponds to full flash power.
This value is only used in the \l{QCameraExposure::FlashManual}{manual flash mode}.
+ \value TorchPower
+ Manual torch power, specified as qreal value.
+ Accepted power range is [0..1.0],
+ with 0 value means no light and 1.0 corresponds to full torch power.
+
+ This value is only used in the \l{QCameraExposure::FlashTorch}{torch flash mode}.
\value FlashCompensation
Flash compensation, specified as qreal EV value.
\value SpotMeteringPoint
The relative frame coordinate of the point to use for exposure metering
in spot metering mode, specified as a QPointF.
+ \value ExposureMode
+ Camera exposure mode.
+ \value MeteringMode
+ Camera metering mode.
\value ExtendedExposureParameter
The base value for platform specific extended parameters.
For such parameters the sequential values starting from ExtendedExposureParameter shuld be used.
*/
/*!
- \enum QCameraExposureControl::ParameterFlag
- \value AutomaticValue
- Use the automatic values for parameters.
- \value ReadOnly
- Parameters are read only.
- \value ContinuousRange
- Parameters are continuous in their range.
-*/
-
-/*!
\fn QCameraExposureControl::isParameterSupported(ExposureParameter parameter) const
Returns true is exposure \a parameter is supported by backend.
+ \since 5.0
*/
/*!
- \fn QCameraExposureControl::exposureParameter(ExposureParameter parameter) const
+ \fn QCameraExposureControl::requestedValue(ExposureParameter parameter) const
+
+ Returns the requested exposure \a parameter value.
- Returns the exposure \a parameter value, or invalid QVariant() if the value is unknown or not supported.
+ \since 5.0
*/
/*!
- \fn QCameraExposureControl::exposureParameterFlags(ExposureParameter parameter) const
+ \fn QCameraExposureControl::actualValue(ExposureParameter parameter) const
- Returns the properties of exposure \a parameter.
+ Returns the actual exposure \a parameter value, or invalid QVariant() if the value is unknown or not supported.
+
+ The actual parameter value may differ for the requested one if automatic mode is selected or
+ camera supports only limited set of values within the supported range.
+ \since 5.0
*/
/*!
- \fn QCameraExposureControl::supportedParameterRange(ExposureParameter parameter) const
+ \fn QCameraExposureControl::supportedParameterRange(ExposureParameter parameter, bool *continuous = 0) const
Returns the list of supported \a parameter values;
+
+ If the camera supports arbitrary exposure parameter value within the supported range,
+ *\a continuous is set to true, otherwise *\a continuous is set to false.
+
+ \since 5.0
*/
/*!
- \fn bool QCameraExposureControl::setExposureParameter(ExposureParameter parameter, const QVariant& value)
+ \fn bool QCameraExposureControl::setValue(ExposureParameter parameter, const QVariant& value)
Set the exposure \a parameter to \a value.
If a null or invalid QVariant is passed, backend should choose the value automatically,
- and if possible report the actual value to user with QCameraExposureControl::exposureParameter().
+ and if possible report the actual value to user with QCameraExposureControl::actualValue().
Returns true if parameter is supported and value is correct.
+ \since 5.0
*/
/*!
- \fn QCameraExposureControl::extendedParameterName(ExposureParameter parameter)
+ \fn void QCameraExposureControl::requestedValueChanged(int parameter)
- Returns the extended exposure \a parameter name.
+ Signal emitted when the requested exposure \a parameter value has changed,
+ usually in result of setValue() call.
+ \since 5.0
*/
/*!
- \fn void QCameraExposureControl::flashReady(bool ready)
-
- Signal emitted when flash state changes, flash is charged \a ready.
-*/
+ \fn void QCameraExposureControl::actualValueChanged(int parameter)
-/*!
- \fn void QCameraExposureControl::exposureParameterChanged(int parameter)
+ Signal emitted when the actual exposure \a parameter value has changed,
+ usually in result of auto exposure algorithms or manual exposure parameter applied.
- Signal emitted when the exposure \a parameter has changed.
+ \since 5.0
*/
/*!
+ \fn void QCameraExposureControl::parameterRangeChanged(int parameter)
- \fn void QCameraExposureControl::exposureParameterRangeChanged(int parameter)
+ Signal emitted when the supported range of exposure \a parameter values has changed.
- Signal emitted when the exposure \a parameter range has changed.
+ \since 5.0
*/
~QCameraExposureControl();
enum ExposureParameter {
- InvalidParameter = 0,
- ISO = 1,
- Aperture = 2,
- ShutterSpeed = 3,
- ExposureCompensation = 4,
- FlashPower = 5,
- FlashCompensation = 6,
- SpotMeteringPoint = 7,
+ ISO,
+ Aperture,
+ ShutterSpeed,
+ ExposureCompensation,
+ FlashPower,
+ FlashCompensation,
+ TorchPower,
+ SpotMeteringPoint,
+ ExposureMode,
+ MeteringMode,
ExtendedExposureParameter = 1000
};
- enum ParameterFlag {
- AutomaticValue = 0x01,
- ReadOnly = 0x02,
- ContinuousRange = 0x04
- };
- Q_DECLARE_FLAGS(ParameterFlags, ParameterFlag)
-
- virtual QCameraExposure::ExposureMode exposureMode() const = 0;
- virtual void setExposureMode(QCameraExposure::ExposureMode mode) = 0;
- virtual bool isExposureModeSupported(QCameraExposure::ExposureMode mode) const = 0;
-
- virtual QCameraExposure::MeteringMode meteringMode() const = 0;
- virtual void setMeteringMode(QCameraExposure::MeteringMode mode) = 0;
- virtual bool isMeteringModeSupported(QCameraExposure::MeteringMode mode) const = 0;
-
virtual bool isParameterSupported(ExposureParameter parameter) const = 0;
- virtual QVariant exposureParameter(ExposureParameter parameter) const = 0;
- virtual ParameterFlags exposureParameterFlags(ExposureParameter parameter) const = 0;
- virtual QVariantList supportedParameterRange(ExposureParameter parameter) const = 0;
- virtual bool setExposureParameter(ExposureParameter parameter, const QVariant& value) = 0;
+ virtual QVariantList supportedParameterRange(ExposureParameter parameter, bool *continuous) const = 0;
- virtual QString extendedParameterName(ExposureParameter parameter) = 0;
+ virtual QVariant requestedValue(ExposureParameter parameter) const = 0;
+ virtual QVariant actualValue(ExposureParameter parameter) const = 0;
+ virtual bool setValue(ExposureParameter parameter, const QVariant& value) = 0;
Q_SIGNALS:
- void flashReady(bool);
-
- void exposureParameterChanged(int parameter);
- void exposureParameterRangeChanged(int parameter);
+ void requestedValueChanged(int parameter);
+ void actualValueChanged(int parameter);
+ void parameterRangeChanged(int parameter);
protected:
QCameraExposureControl(QObject* parent = 0);
#define QCameraExposureControl_iid "com.nokia.Qt.QCameraExposureControl/1.0"
Q_MEDIA_DECLARE_CONTROL(QCameraExposureControl, QCameraExposureControl_iid)
-Q_DECLARE_OPERATORS_FOR_FLAGS(QCameraExposureControl::ParameterFlags)
+QT_END_NAMESPACE
-Q_MEDIA_ENUM_DEBUG(QCameraExposureControl, ExposureParameter)
+Q_DECLARE_METATYPE(QCameraExposureControl::ExposureParameter)
-QT_END_NAMESPACE
+Q_MEDIA_ENUM_DEBUG(QCameraExposureControl, ExposureParameter)
QT_END_HEADER
cameraExposure->setFlashMode(QCameraExposure::FlashSlowSyncFrontCurtain);
QCOMPARE(cameraExposure->flashMode(), QCameraExposure::FlashSlowSyncFrontCurtain);
+ QVERIFY(!cameraExposure->isMeteringModeSupported(QCameraExposure::MeteringAverage));
+ QVERIFY(cameraExposure->isMeteringModeSupported(QCameraExposure::MeteringSpot));
+ QVERIFY(cameraExposure->isMeteringModeSupported(QCameraExposure::MeteringMatrix));
cameraExposure->setMeteringMode(QCameraExposure::MeteringMatrix);
QCOMPARE(cameraExposure->meteringMode(), QCameraExposure::MeteringMatrix);
+
+ //MeteringAverage is not supported, metering mode should not be changed
cameraExposure->setMeteringMode(QCameraExposure::MeteringAverage);
- QCOMPARE(cameraExposure->meteringMode(), QCameraExposure::MeteringAverage);
+ QCOMPARE(cameraExposure->meteringMode(), QCameraExposure::MeteringMatrix);
+
cameraExposure->setMeteringMode(QCameraExposure::MeteringSpot);
QCOMPARE(cameraExposure->meteringMode(), QCameraExposure::MeteringSpot);
int minIso = cameraExposure->supportedIsoSensitivities().first();
int maxIso = cameraExposure->supportedIsoSensitivities().last();
QVERIFY(cameraExposure->isoSensitivity() > 0);
+ QCOMPARE(cameraExposure->requestedIsoSensitivity(), -1);
QVERIFY(minIso > 0);
QVERIFY(maxIso > 0);
cameraExposure->setManualIsoSensitivity(minIso);
QCOMPARE(cameraExposure->isoSensitivity(), minIso);
cameraExposure->setManualIsoSensitivity(maxIso*10);
QCOMPARE(cameraExposure->isoSensitivity(), maxIso);
+ QCOMPARE(cameraExposure->requestedIsoSensitivity(), maxIso*10);
+
cameraExposure->setManualIsoSensitivity(-10);
QCOMPARE(cameraExposure->isoSensitivity(), minIso);
+ QCOMPARE(cameraExposure->requestedIsoSensitivity(), -10);
cameraExposure->setAutoIsoSensitivity();
QCOMPARE(cameraExposure->isoSensitivity(), 100);
+ QCOMPARE(cameraExposure->requestedIsoSensitivity(), -1);
+ QCOMPARE(cameraExposure->requestedAperture(), -1.0);
qreal minAperture = cameraExposure->supportedApertures().first();
qreal maxAperture = cameraExposure->supportedApertures().last();
QVERIFY(minAperture > 0);
cameraExposure->setAutoAperture();
QVERIFY(cameraExposure->aperture() >= minAperture);
QVERIFY(cameraExposure->aperture() <= maxAperture);
+ QCOMPARE(cameraExposure->requestedAperture(), -1.0);
cameraExposure->setManualAperture(0);
QCOMPARE(cameraExposure->aperture(), minAperture);
+ QCOMPARE(cameraExposure->requestedAperture()+1.0, 1.0);
cameraExposure->setManualAperture(10000);
QCOMPARE(cameraExposure->aperture(), maxAperture);
+ QCOMPARE(cameraExposure->requestedAperture(), 10000.0);
+ cameraExposure->setAutoAperture();
+ QCOMPARE(cameraExposure->requestedAperture(), -1.0);
+ QCOMPARE(cameraExposure->requestedShutterSpeed(), -1.0);
qreal minShutterSpeed = cameraExposure->supportedShutterSpeeds().first();
qreal maxShutterSpeed = cameraExposure->supportedShutterSpeeds().last();
QVERIFY(minShutterSpeed > 0);
cameraExposure->setAutoShutterSpeed();
QVERIFY(cameraExposure->shutterSpeed() >= minShutterSpeed);
QVERIFY(cameraExposure->shutterSpeed() <= maxShutterSpeed);
+ QCOMPARE(cameraExposure->requestedShutterSpeed(), -1.0);
cameraExposure->setManualShutterSpeed(0);
QCOMPARE(cameraExposure->shutterSpeed(), minShutterSpeed);
+ QCOMPARE(cameraExposure->requestedShutterSpeed()+1.0, 1.0);
cameraExposure->setManualShutterSpeed(10000);
QCOMPARE(cameraExposure->shutterSpeed(), maxShutterSpeed);
+ QCOMPARE(cameraExposure->requestedShutterSpeed(), 10000.0);
+
+ cameraExposure->setAutoShutterSpeed();
+ QCOMPARE(cameraExposure->requestedShutterSpeed(), -1.0);
}
void tst_QCamera::testCameraFocus()
m_apertureRanges << 2.8 << 4.0 << 5.6 << 8.0 << 11.0 << 16.0;
m_shutterRanges << 0.001 << 0.01 << 0.1 << 1.0;
m_exposureRanges << -2.0 << 2.0;
- }
-
- ~MockCameraExposureControl() {}
-
- QCameraExposure::FlashModes flashMode() const {return m_flashMode;}
-
- void setFlashMode(QCameraExposure::FlashModes mode)
- {
- if (isFlashModeSupported(mode)) {
- m_flashMode = mode;
- }
- }
-
- bool isFlashModeSupported(QCameraExposure::FlashModes mode) const
- {
- return mode & (QCameraExposure::FlashAuto | QCameraExposure::FlashOff | QCameraExposure::FlashOn);
- }
- bool isFlashReady() const { return true;}
+ QList<QCameraExposure::ExposureMode> exposureModes;
+ exposureModes << QCameraExposure::ExposureAuto << QCameraExposure::ExposureManual << QCameraExposure::ExposureBacklight
+ << QCameraExposure::ExposureNight << QCameraExposure::ExposureSpotlight << QCameraExposure::ExposureSports
+ << QCameraExposure::ExposureSnow << QCameraExposure:: ExposureLargeAperture << QCameraExposure::ExposureSmallAperture
+ << QCameraExposure::ExposurePortrait << QCameraExposure::ExposureModeVendor << QCameraExposure::ExposureBeach;
- QCameraExposure::ExposureMode exposureMode() const { return m_exposureMode; }
+ foreach (QCameraExposure::ExposureMode mode, exposureModes)
+ m_exposureModes << QVariant::fromValue<QCameraExposure::ExposureMode>(mode);
- void setExposureMode(QCameraExposure::ExposureMode mode)
- {
- if (isExposureModeSupported(mode))
- m_exposureMode = mode;
+ m_meteringModes << QVariant::fromValue<QCameraExposure::MeteringMode>(QCameraExposure::MeteringMatrix)
+ << QVariant::fromValue<QCameraExposure::MeteringMode>(QCameraExposure::MeteringSpot);
}
- //Setting the Exposure Mode Supported Enum values
- bool isExposureModeSupported(QCameraExposure::ExposureMode mode) const
- {
- return ( mode == QCameraExposure::ExposureAuto || mode == QCameraExposure::ExposureManual || mode == QCameraExposure::ExposureBacklight ||
- mode == QCameraExposure::ExposureNight || mode == QCameraExposure::ExposureSpotlight ||mode == QCameraExposure::ExposureSports ||
- mode == QCameraExposure::ExposureSnow || mode == QCameraExposure:: ExposureLargeAperture ||mode == QCameraExposure::ExposureSmallAperture ||
- mode == QCameraExposure::ExposurePortrait || mode == QCameraExposure::ExposureModeVendor ||mode == QCameraExposure::ExposureBeach );
- }
+ ~MockCameraExposureControl() {}
bool isParameterSupported(ExposureParameter parameter) const
{
switch (parameter) {
+ case QCameraExposureControl::ExposureMode:
+ case QCameraExposureControl::MeteringMode:
case QCameraExposureControl::ExposureCompensation:
case QCameraExposureControl::ISO:
case QCameraExposureControl::Aperture:
}
}
- QVariant exposureParameter(ExposureParameter parameter) const
+ QVariant requestedValue(ExposureParameter param) const
{
- switch (parameter) {
+ return m_requestedParameters.value(param);
+ }
+
+ QVariant actualValue(ExposureParameter param) const
+ {
+ switch (param) {
+ case QCameraExposureControl::ExposureMode:
+ return QVariant::fromValue<QCameraExposure::ExposureMode>(m_exposureMode);
+ case QCameraExposureControl::MeteringMode:
+ return QVariant::fromValue<QCameraExposure::MeteringMode>(m_meteringMode);
case QCameraExposureControl::ExposureCompensation:
return QVariant(m_exposureCompensation);
case QCameraExposureControl::ISO:
}
}
- QVariantList supportedParameterRange(ExposureParameter parameter) const
+ QVariantList supportedParameterRange(ExposureParameter parameter, bool *continuous) const
{
+ *continuous = false;
+
QVariantList res;
switch (parameter) {
case QCameraExposureControl::ExposureCompensation:
+ *continuous = true;
return m_exposureRanges;
case QCameraExposureControl::ISO:
return m_isoRanges;
case QCameraExposureControl::Aperture:
+ *continuous = true;
return m_apertureRanges;
case QCameraExposureControl::ShutterSpeed:
+ *continuous = true;
return m_shutterRanges;
+ case QCameraExposureControl::ExposureMode:
+ return m_exposureModes;
+ case QCameraExposureControl::MeteringMode:
+ return m_meteringModes;
default:
break;
}
return res;
}
- ParameterFlags exposureParameterFlags(ExposureParameter parameter) const
+ // Added valueChanged and parameterRangeChanged signal
+ bool setValue(ExposureParameter param, const QVariant& value)
{
- ParameterFlags res = 0;
- switch (parameter) {
- case QCameraExposureControl::ExposureCompensation:
- case QCameraExposureControl::Aperture:
- case QCameraExposureControl::ShutterSpeed:
- res |= ContinuousRange;
- default:
- break;
- }
+ if (!isParameterSupported(param))
+ return false;
- return res;
- }
+ if (m_requestedParameters.value(param) != value) {
+ m_requestedParameters.insert(param, value);
+ emit requestedValueChanged(param);
+ }
- // Added exposureParameterChanged and exposureParameterRangeChanged signal
- bool setExposureParameter(ExposureParameter parameter, const QVariant& value)
- {
- switch (parameter) {
+ switch (param) {
+ case QCameraExposureControl::ExposureMode:
+ {
+ QCameraExposure::ExposureMode mode = value.value<QCameraExposure::ExposureMode>();
+ if (mode != m_exposureMode && m_exposureModes.contains(value)) {
+ m_exposureMode = mode;
+ emit actualValueChanged(param);
+ }
+ }
+ break;
+ case QCameraExposureControl::MeteringMode:
+ {
+ QCameraExposure::MeteringMode mode = value.value<QCameraExposure::MeteringMode>();
+ if (mode != m_meteringMode && m_meteringModes.contains(value)) {
+ m_meteringMode = mode;
+ emit actualValueChanged(param);
+ }
+ }
+ break;
case QCameraExposureControl::ExposureCompensation:
{
m_res.clear();
m_res << -4.0 << 4.0;
qreal exposureCompensationlocal = qBound<qreal>(-2.0, value.toReal(), 2.0);
- if (exposureParameter(parameter).toReal() != exposureCompensationlocal) {
+ if (actualValue(param).toReal() != exposureCompensationlocal) {
m_exposureCompensation = exposureCompensationlocal;
- emit exposureParameterChanged(parameter);
+ emit actualValueChanged(param);
}
if (m_exposureRanges.last().toReal() != m_res.last().toReal()) {
m_exposureRanges.clear();
m_exposureRanges = m_res;
- emit exposureParameterRangeChanged(parameter);
+ emit parameterRangeChanged(param);
}
}
break;
m_res.clear();
m_res << 20 << 50;
qreal exposureCompensationlocal = 100*qRound(qBound(100, value.toInt(), 800)/100.0);
- if (exposureParameter(parameter).toReal() != exposureCompensationlocal) {
+ if (actualValue(param).toReal() != exposureCompensationlocal) {
m_isoSensitivity = exposureCompensationlocal;
- emit exposureParameterChanged(parameter);
+ emit actualValueChanged(param);
}
if (m_isoRanges.last().toInt() != m_res.last().toInt()) {
m_isoRanges.clear();
m_isoRanges = m_res;
- emit exposureParameterRangeChanged(parameter);
+ emit parameterRangeChanged(param);
}
}
break;
m_res.clear();
m_res << 12.0 << 18.0 << 20.0;
qreal exposureCompensationlocal = qBound<qreal>(2.8, value.toReal(), 16.0);
- if (exposureParameter(parameter).toReal() != exposureCompensationlocal) {
+ if (actualValue(param).toReal() != exposureCompensationlocal) {
m_aperture = exposureCompensationlocal;
- emit exposureParameterChanged(parameter);
+ emit actualValueChanged(param);
}
if (m_apertureRanges.last().toReal() != m_res.last().toReal()) {
m_apertureRanges.clear();
m_apertureRanges = m_res;
- emit exposureParameterRangeChanged(parameter);
+ emit parameterRangeChanged(param);
}
}
break;
m_res.clear();
m_res << 0.12 << 1.0 << 2.0;
qreal exposureCompensationlocal = qBound<qreal>(0.001, value.toReal(), 1.0);
- if (exposureParameter(parameter).toReal() != exposureCompensationlocal) {
+ if (actualValue(param).toReal() != exposureCompensationlocal) {
m_shutterSpeed = exposureCompensationlocal;
- emit exposureParameterChanged(parameter);
+ emit actualValueChanged(param);
}
if (m_shutterRanges.last().toReal() != m_res.last().toReal()) {
m_shutterRanges.clear();
m_shutterRanges = m_res;
- emit exposureParameterRangeChanged(parameter);
+ emit parameterRangeChanged(param);
}
}
break;
static QRectF valid(0, 0, 1, 1);
if (valid.contains(value.toPointF())) {
m_spot = value.toPointF();
+ emit actualValueChanged(param);
return true;
}
return false;
return false;
}
- emit flashReady(true); // depends on Flashcontrol
-
return true;
}
- QString extendedParameterName(ExposureParameter)
- {
- return QString();
- }
-
- QCameraExposure::MeteringMode meteringMode() const
- {
- return m_meteringMode;
- }
-
- void setMeteringMode(QCameraExposure::MeteringMode mode)
- {
- if (isMeteringModeSupported(mode))
- m_meteringMode = mode;
- }
-
- //Setting the values for metering mode
- bool isMeteringModeSupported(QCameraExposure::MeteringMode mode) const
- {
- return mode == QCameraExposure::MeteringAverage
- || mode == QCameraExposure::MeteringMatrix
- || mode == QCameraExposure::MeteringSpot;
- }
-
private:
qreal m_aperture;
qreal m_shutterSpeed;
qreal m_exposureCompensation;
QCameraExposure::ExposureMode m_exposureMode;
QCameraExposure::FlashModes m_flashMode;
- QVariantList m_isoRanges,m_apertureRanges, m_shutterRanges, m_exposureRanges, m_res;
+ QVariantList m_isoRanges,m_apertureRanges, m_shutterRanges, m_exposureRanges, m_res, m_exposureModes, m_meteringModes;
QPointF m_spot;
+
+ QMap<QCameraExposureControl::ExposureParameter, QVariant> m_requestedParameters;
};
#endif // MOCKCAMERAEXPOSURECONTROL_H
projects / platform / upstream / qtmultimedia.git / commitdiff