1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "s60camerasettings.h"

    43 

    44 #include <QtCore/qdebug.h>

    45 #ifdef USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER

    46 #include <ecamadvancedsettings.h> // CCameraAdvancedSettings (includes TValueInfo)

    47 #endif

    48 #ifdef USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER

    49 #include <ecamadvsettings.h>   // CCameraAdvancedSettings

    50 #include <ecam/ecamconstants.h>  // TValueInfo

    51 #endif

    52 

    53 

    54 

    55 S60CameraSettings::S60CameraSettings(QObject *parent, CCameraEngine *engine)

    56     : QObject(parent)

    57 {

    58     m_cameraEngine = engine;

    59     queryAdvancedSettingsInfo();

    60 }

    61 

    62 S60CameraSettings::~S60CameraSettings()

    63 {

    64 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

    65     m_advancedSettings = NULL;

    66 #endif

    67 }

    68 

    69 /*

    70  * Queries advanced settings information

    71  * Results are returned to member variable m_advancedSettings

    72  * @return boolean indicating if querying the info was a success

    73  */

    74 bool S60CameraSettings::queryAdvancedSettingsInfo()

    75 {

    76     bool returnValue = false;

    77 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

    78     if (m_cameraEngine) {

    79         m_advancedSettings = NULL;

    80         m_advancedSettings = m_cameraEngine->AdvancedSettings();

    81         if (m_advancedSettings)

    82             returnValue = true;

    83     }

    84 #endif

    85     return returnValue;

    86 }

    87 

    88 void S60CameraSettings::setFocusMode(QCamera::FocusMode mode)

    89 {

    90 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

    91     if (m_advancedSettings) {

    92         switch(mode) {

    93             case QCamera::ManualFocus: // Manual focus mode

    94                 //qDebug() << "Settings: set manual focus";

    95                 m_advancedSettings->SetFocusMode(CCamera::CCameraAdvancedSettings::EFocusModeManual);

    96                 break;

    97             case QCamera::AutoFocus: // One-shot auto focus mode

    98                 //qDebug() << "Settings: set auto focus";

    99                 m_advancedSettings->SetAutoFocusType(CCamera::CCameraAdvancedSettings::EAutoFocusTypeSingle);

   100                 m_advancedSettings->SetFocusMode(CCamera::CCameraAdvancedSettings::EFocusModeAuto);

   101                 break;

   102         }

   103     }

   104 #endif

   105 }

   106 

   107 QCamera::FocusMode S60CameraSettings::focusMode()

   108 {

   109 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   110     if (m_advancedSettings) {

   111         CCamera::CCameraAdvancedSettings::TFocusMode mode = m_advancedSettings->FocusMode();

   112         switch(mode) {

   113             case CCamera::CCameraAdvancedSettings::EFocusModeManual:

   114                 return QCamera::ManualFocus;

   115             case CCamera::CCameraAdvancedSettings::EFocusModeAuto:

   116                 return QCamera::AutoFocus;

   117         }

   118     } 

   119 #else

   120 

   121 #endif

   122 }

   123 

   124 QCamera::FocusModes S60CameraSettings::supportedFocusModes()

   125 {

   126 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   127     TInt supportedModes = 0;

   128     TInt autoFocusTypes = 0;

   129     QCamera::FocusModes modes = QCamera::AutoFocus;

   130     if (m_advancedSettings) {

   131         supportedModes = m_advancedSettings->SupportedFocusModes();

   132         autoFocusTypes = m_advancedSettings->SupportedAutoFocusTypes();

   133         if (supportedModes == 0)

   134             return modes;

   135         if (supportedModes & CCamera::CCameraAdvancedSettings::EFocusModeAuto) {

   136             if (autoFocusTypes & CCamera::CCameraAdvancedSettings::EAutoFocusTypeSingle)

   137                 modes |= QCamera::AutoFocus;

   138             if (autoFocusTypes & CCamera::CCameraAdvancedSettings::EAutoFocusTypeContinuous)

   139                 modes |= QCamera::ContinuousFocus;

   140         }

   141     }

   142     return modes;

   143 #endif

   144 }

   145 

   146 // from MCameraObserver2

   147 void S60CameraSettings::HandleEvent(const TECAMEvent& aEvent)

   148 {

   149 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   150     if (aEvent.iEventType == KUidECamEventCameraSettingExposureLock) {

   151         emit exposureLocked();

   152     } else if (aEvent.iEventType == KUidECamEventCameraSettingAperture) {

   153         emit apertureChanged(aperture());

   154     } else if (aEvent.iEventType == KUidECamEventCameraSettingApertureRange) {

   155         emit apertureRangeChanged();

   156     } else if (aEvent.iEventType == KUidECamEventCameraSettingIsoRate) {

   157         emit isoSensitivityChanged(isoSensitivity());

   158     } else if (aEvent.iEventType == KUidECamEventCameraSettingShutterSpeed) {

   159         emit shutterSpeedChanged(shutterSpeed());

   160     } else if (aEvent.iEventType == KUidECamEventCameraSettingExposureLock) {

   161         emit exposureLocked();

   162     } else if (aEvent.iEventType == KUidECamEventFlashReady) {

   163         emit flashReady(true);

   164     } else if (aEvent.iEventType == KUidECamEventFlashNotReady) {

   165         emit flashReady(false);

   166     }

   167 #endif

   168 }

   169 

   170 void S60CameraSettings::ViewFinderReady(MCameraBuffer& aCameraBuffer,TInt aError)

   171 {

   172     Q_UNUSED(aCameraBuffer);

   173     Q_UNUSED(aError);

   174 }

   175 

   176 void S60CameraSettings::ImageBufferReady(MCameraBuffer& aCameraBuffer,TInt aError)

   177 {

   178     Q_UNUSED(aCameraBuffer);

   179     Q_UNUSED(aError);

   180 }

   181 void S60CameraSettings::VideoBufferReady(MCameraBuffer& aCameraBuffer,TInt aError)

   182 {

   183     Q_UNUSED(aCameraBuffer);

   184     Q_UNUSED(aError);

   185 }

   186 

   187 bool S60CameraSettings::isFlashReady()

   188 {

   189     TBool ready = false;

   190 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   191     if (queryAdvancedSettingsInfo()) {

   192         int i = m_advancedSettings->IsFlashReady(ready);

   193         if (i == KErrNotSupported) {

   194             // TODO: error flash not supported

   195             return false;

   196         }

   197     }

   198 #endif

   199     return ready;

   200 }

   201 

   202 void S60CameraSettings::setExposureCompensation(qreal ev)

   203 {

   204 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   205     if (queryAdvancedSettingsInfo()) {

   206         m_advancedSettings->SetExposureCompensation(ev);

   207     }

   208 #endif

   209 }

   210 

   211 qreal S60CameraSettings::exposureCompensation()

   212 {

   213 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   214     if (queryAdvancedSettingsInfo()) {

   215         return m_advancedSettings->ExposureCompensation();

   216     } else {

   217         return 0;

   218     }

   219 #else

   220     return 0;

   221 #endif

   222 }

   223 

   224 QCamera::MeteringMode S60CameraSettings::meteringMode()

   225 {

   226 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   227     if (queryAdvancedSettingsInfo()) {

   228         CCamera::CCameraAdvancedSettings::TMeteringMode mode = m_advancedSettings->MeteringMode();

   229         switch(mode) {

   230             case CCamera::CCameraAdvancedSettings::EMeteringModeCenterWeighted:

   231                 return QCamera::MeteringAverage;

   232             case CCamera::CCameraAdvancedSettings::EMeteringModeEvaluative:

   233                 return QCamera::MeteringMatrix;

   234             case CCamera::CCameraAdvancedSettings::EMeteringModeSpot:

   235                 return QCamera::MeteringSpot;

   236             default:

   237                 break;

   238         }

   239     }

   240 #else

   241 

   242 #endif

   243 }

   244 

   245 void S60CameraSettings::setMeteringMode(QCamera::MeteringMode mode)

   246 {

   247 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   248     if (queryAdvancedSettingsInfo()) {

   249         switch(mode) {

   250             case QCamera::MeteringAverage:

   251                 m_advancedSettings->SetMeteringMode(CCamera::CCameraAdvancedSettings::EMeteringModeCenterWeighted);

   252                 break;

   253             case QCamera::MeteringMatrix:

   254                 m_advancedSettings->SetMeteringMode(CCamera::CCameraAdvancedSettings::EMeteringModeEvaluative);

   255                 break;

   256             case QCamera::MeteringSpot:

   257                 m_advancedSettings->SetMeteringMode(CCamera::CCameraAdvancedSettings::EMeteringModeSpot);

   258                 break;

   259             default:

   260                 break;

   261         }

   262     }

   263 #endif

   264 }

   265 

   266 QCamera::MeteringModes S60CameraSettings::supportedMeteringModes()

   267 {

   268 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   269     TInt supportedModes = 0;

   270     QCamera::MeteringModes modes = QCamera::MeteringAverage;

   271     if (queryAdvancedSettingsInfo()) {

   272         supportedModes = m_advancedSettings->SupportedMeteringModes();

   273         if (supportedModes == 0) {

   274             emit error(QCamera::NotSupportedFeatureError);

   275             return modes;

   276         } if (supportedModes & CCamera::CCameraAdvancedSettings::EMeteringModeCenterWeighted) {

   277              modes |= QCamera::MeteringAverage;

   278         } if (supportedModes & CCamera::CCameraAdvancedSettings::EMeteringModeEvaluative) {

   279              modes |= QCamera::MeteringMatrix;

   280         } if (supportedModes & CCamera::CCameraAdvancedSettings::EMeteringModeSpot) {

   281              modes |= QCamera::MeteringSpot;

   282         }

   283     }

   284     return modes;

   285 #endif

   286 }

   287 

   288 int S60CameraSettings::isoSensitivity()

   289 {

   290 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   291     if (queryAdvancedSettingsInfo()) {

   292         return m_advancedSettings->IsoRate();

   293     } else {

   294         return 0;

   295     }

   296 #endif

   297 }

   298 

   299 QList<int> S60CameraSettings::supportedIsoSensitivities()

   300 {

   301 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   302     QList<int> isoSentitivities;

   303     if (queryAdvancedSettingsInfo()) {

   304         RArray<TInt> supportedIsoRates;

   305         TRAPD(err, m_advancedSettings->GetSupportedIsoRatesL(supportedIsoRates));

   306         if (err != KErrNone) {

   307             emit error(QCamera::NotSupportedFeatureError);

   308         } else {

   309             for (int i=0; i < supportedIsoRates.Count(); i++) {

   310                 int q = supportedIsoRates[i];

   311                 isoSentitivities.append(q);

   312             }

   313         }

   314         supportedIsoRates.Close();

   315     }

   316     return isoSentitivities;

   317 #endif

   318 }

   319 

   320 void S60CameraSettings::setManualIsoSensitivity(int iso)

   321 {

   322 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   323     if (queryAdvancedSettingsInfo()) {

   324         m_advancedSettings->SetIsoRate(iso);

   325     }

   326 #endif

   327 }

   328 

   329 qreal S60CameraSettings::aperture()

   330 {

   331 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   332     if (queryAdvancedSettingsInfo()) {

   333         return m_advancedSettings->Aperture();

   334     } else {

   335         return -1.0;

   336     }

   337 #endif

   338 }

   339 

   340 QList<qreal> S60CameraSettings::supportedApertures(bool *continuous)

   341 {

   342     Q_UNUSED(continuous);

   343 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   344     QList<qreal> apertures;

   345     if (queryAdvancedSettingsInfo()) {

   346         RArray<TInt> supportedApertures;

   347         TValueInfo info = ENotActive;

   348         TRAPD(err, m_advancedSettings->GetAperturesL(supportedApertures, info));

   349         if (err != KErrNone) {

   350             emit error(QCamera::NotSupportedFeatureError);

   351         } else {

   352             for (int i=0; i < supportedApertures.Count(); i++) {

   353                 qreal q = supportedApertures[i];

   354                 apertures.append(q);

   355             }

   356         }

   357         supportedApertures.Close();

   358     }

   359     return apertures;

   360 #endif

   361 }

   362 

   363 void S60CameraSettings::setManualAperture(qreal aperture)

   364 {

   365 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   366     if (queryAdvancedSettingsInfo()) {

   367         m_advancedSettings->SetAperture(aperture);

   368     }

   369 #endif

   370 }

   371 

   372 void S60CameraSettings::lockExposure(bool lock)

   373 {

   374 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   375     if (queryAdvancedSettingsInfo()) {

   376             m_advancedSettings->SetExposureLockOn(lock);

   377         }

   378 #endif

   379 }

   380 

   381 bool S60CameraSettings::isExposureLocked()

   382 {

   383 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   384     if (queryAdvancedSettingsInfo()) {

   385         return m_advancedSettings->ExposureLockOn();

   386     } else {

   387         return false;

   388     }

   389 #endif

   390 }

   391 

   392 TInt S60CameraSettings::shutterSpeed()

   393 {

   394 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   395     if (queryAdvancedSettingsInfo()) {

   396         return m_advancedSettings->ShutterSpeed();

   397     } else {

   398         return -1.0;

   399     }

   400 #endif

   401 }

   402 

   403 QList<qreal> S60CameraSettings::supportedShutterSpeeds(bool *continuous)

   404 {

   405     Q_UNUSED(continuous);

   406 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   407     QList<qreal> speeds;

   408     if (queryAdvancedSettingsInfo()) {

   409         RArray<TInt> supportedSpeeds;

   410         TValueInfo info = ENotActive;

   411         TRAPD(err, m_advancedSettings->GetShutterSpeedsL(supportedSpeeds, info));

   412         if (err != KErrNone) {

   413             emit error(QCamera::NotSupportedFeatureError);

   414         } else {

   415             for (int i=0; i < supportedSpeeds.Count(); i++) {

   416                 qreal q = supportedSpeeds[i];

   417                 speeds.append(q);

   418             }

   419         }

   420         supportedSpeeds.Close();

   421     }

   422     return speeds;

   423 #endif

   424 }

   425 

   426 void S60CameraSettings::setShutterSpeed(TInt speed)

   427 {

   428 #if (defined(USE_S60_50_ECAM_ADVANCED_SETTINGS_HEADER) || defined(USE_S60_32_ECAM_ADVANCED_SETTINGS_HEADER))

   429     if (queryAdvancedSettingsInfo()) {

   430         m_advancedSettings->SetShutterSpeed(speed);

   431     }

   432 #endif

   433 }

   434