/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Helper class for CCamConfiguration

*

*/

#include "camlogging.h"

#include "camconfigurationutility.h"

#include "camconfigurationconstants.h"

// ---------------------------------------------------------------------------

// CamConfigurationUtility::PhotoSizeIndex

// ---------------------------------------------------------------------------

//

TInt

CamConfigurationUtility::PhotoSizeIndex( TInt aWidth, TInt aHeight )

  {

  TInt index = KErrNotFound;

  for( TInt i=0; i<ECamPhotoSizeLast; i++ )

    {

    if( KCamPhotoSizes[i].iWidth == aWidth &&

        KCamPhotoSizes[i].iHeight == aHeight )

      {   

      index = i;

      break;

      }

    }

  return index;  

  } 

// ---------------------------------------------------------------------------

// CamConfigurationUtility::VideoSizeIndex

// ---------------------------------------------------------------------------

//  

TInt

CamConfigurationUtility::VideoSizeIndex( TInt aWidth, TInt aHeight )

  {

  TInt index = KErrNotFound;

  for( TInt i=0; i<ECamVideoResolutionLast; i++ )

    {

    if( KCamVideoSizes[i].iWidth == aWidth &&

        KCamVideoSizes[i].iHeight == aHeight )

      {   

      index = i;

      break;

      }

    }

  return index;  

  }   

// ---------------------------------------------------------------------------

// CamConfigurationUtility::AdjustPrintQualities

// ---------------------------------------------------------------------------

//

void

CamConfigurationUtility::AdjustPrintQualities( RArray<TCamImageQualityData>& aPhotoQualities )  

  {

  TInt n = aPhotoQualities.Count();

  //TInt numPrint = 0;

  //TInt lastPrintIndex = KErrNotFound;

  for( int i=0; i<n; i++ )

    {

    TCamImageQuality& quality( aPhotoQualities[i].iPhotoQualitySetting.iPhotoQualityId );

    quality = static_cast<TCamImageQuality>( i );

    }

    /*

    if( EImageQualityPrint == quality )

      {        

      if( !numPrint )

        {

        // This is the first print quality, so it should be print high

        quality = EImageQualityPrintHigh;        

        }

      numPrint++;

      lastPrintIndex = i;          

      }          

    }  

  if( numPrint > 2 )

    {

    // There ECamQualityPrintHigh and more than one EImageQualityPrint

    // Change last of them to ECamImageQualityPrintLow

    aPhotoQualities[lastPrintIndex].iPhotoQualitySetting.iPhotoQualityId

          = EImageQualityPrintLow;  

    }  

  */         

  }

// ---------------------------------------------------------------------------

// CamConfigurationUtility::SetVideoQualityLevels

// ---------------------------------------------------------------------------

// 

void

CamConfigurationUtility::SetVideoQualityLevels( RArray<TCamVideoQualityData>& aOrderedArray )

  {

  TInt n = aOrderedArray.Count();

  // Set quality setting values for each quality

  // Only 3 or 5 qualities are supported

  if( n==3 )

    {  

    aOrderedArray[0].iQualitySetting = ECamVideoQualityHigh;

    aOrderedArray[1].iQualitySetting = ECamVideoQualityNormalHigh;  

    aOrderedArray[2].iQualitySetting = ECamVideoQualitySharing;    

    aOrderedArray[2].iQualitySettings.iVideoLength = ECamVideoClipShort;

    }

  else

  if( n==5 )

    {

    aOrderedArray[0].iQualitySetting = ECamVideoQualityHigh;

    aOrderedArray[1].iQualitySetting = ECamVideoQualityNormalHigh; 

    aOrderedArray[2].iQualitySetting = ECamVideoQualityNormal;  

    aOrderedArray[3].iQualitySetting = ECamVideoQualityNormalLow; 

    aOrderedArray[4].iQualitySetting = ECamVideoQualitySharing;        

    aOrderedArray[4].iQualitySettings.iVideoLength = ECamVideoClipShort;    

    }

  else

    {

    PRINT1( _L("Camera <> CamConfigurationUtility::SetVideoQualityLevels - Invalid number of levels (%d)"), n ); 

    User::Panic( KCamConfigPanicId, ECamConfigPanicInvalidNumberOfQualities );    

    }  

  // Set quality level for iQualitySettings. This is just the 

  // quality's index in the array.

  for( TInt i=0; i<n; i++ )

    {

    aOrderedArray[i].iQualitySettings.iQualityLevel = i;  

    }

  }  

// ---------------------------------------------------------------------------

// CamConfigurationUtility::AddToArrayL

// ---------------------------------------------------------------------------

//  

void

CamConfigurationUtility::AddToArrayL( TInt aValue, RArray<TInt>& aArray )

  {

  if( aArray.Find( aValue ) == KErrNotFound )

    {

    aArray.AppendL( aValue );  

    }    

  }

// ---------------------------------------------------------------------------

// CamConfigurationUtility::VideoResolution

// ---------------------------------------------------------------------------

//   

TInt 

CamConfigurationUtility::VideoResolution( TInt aWidth, TInt aHeight )

  {

  RDebug::Print( _L("VideoResolution( %d, %d) "), aWidth, aHeight );

  for( TInt i=0; i<ECamVideoResolutionLast; i++ )

    {

    if( KCamVideoSizes[i].iWidth == aWidth &&

        KCamVideoSizes[i].iHeight == aHeight )

      {   

      return KCamVideoSizes[i].iVideoRes;

      }

    }

  User::Panic( KCamConfigPanicId, ECamConfigPanicNoVideoRes );

  return KErrNotSupported;

  }

// ---------------------------------------------------------------------------

// CamConfigurationUtility::CamVideoResolution

// ---------------------------------------------------------------------------

//  

TInt 

CamConfigurationUtility::CamVideoResolution( TInt aWidth, TInt aHeight )

  {

  RDebug::Print( _L("VideoResolution( %d, %d) "), aWidth, aHeight );

  for( TInt i=0; i<ECamVideoResolutionLast; i++ )

    {

    if( KCamVideoSizes[i].iWidth == aWidth &&

        KCamVideoSizes[i].iHeight == aHeight )

      {   

      return KCamVideoSizes[i].iCamVideoRes;

      }

    }

  User::Panic( KCamConfigPanicId, ECamConfigPanicNoVideoRes );

  return KErrNotSupported;

  } 

// ---------------------------------------------------------------------------

// CamConfigurationUtility::CamVideoResolution

// ---------------------------------------------------------------------------

//  

TSize 

CamConfigurationUtility::CamVideoResolution( TCamVideoResolution aResolution )

  {

  RDebug::Print( _L("VideoResolution( TCamVideoResolution: %d) "), aResolution );

  for( TInt i=0; i<ECamVideoResolutionLast; i++ )

    {

    if( KCamVideoSizes[i].iCamVideoRes == aResolution )

      {   

      return TSize(KCamVideoSizes[i].iWidth, KCamVideoSizes[i].iHeight );

      }

    }

  User::Panic( KCamConfigPanicId, ECamConfigPanicNoVideoRes );

  return TSize(0,0);//KErrNotSupported;

  } 

// ---------------------------------------------------------------------------

// CamConfigurationUtility::VideoType

// ---------------------------------------------------------------------------

//   

TInt 

CamConfigurationUtility::VideoType( const TText8* aMimeType )

  {

  const TPtrC8 mimeType( aMimeType );

  if( mimeType == KCamMimeMp4 )

    {

    return ECamVideoMpeg4;  

    }

  else if( mimeType == KCamMime3gpp )

    {

    return ECamVideoH263;  

    }

   User::Panic( KCamConfigPanicId, ECamConfigPanicNoVideoType );

   return KErrNotSupported;

  }

// ---------------------------------------------------------------------------

// CamConfigurationUtility::VideoDescId

// ---------------------------------------------------------------------------

//

TCamVideoQualityDescription

CamConfigurationUtility::VideoDescId( TInt aQualityValue )

  {

  TCamVideoQualityDescription desc = ECamVideoQualityDescSharing;

  for( TInt i=0; i<ECamVideoQualityDescLast; i++ )

    {

    if( aQualityValue >= KCamVideoQualityMappings[i].iCamcorderVisibleMin )

      {

      desc = KCamVideoQualityMappings[i].iDesc;

      break;  

      }

    } 

  return desc;  

  }

// ---------------------------------------------------------------------------

// CamConfigurationUtility::ImageType

// ---------------------------------------------------------------------------

//    

TCamImageType

CamConfigurationUtility::ImageType( TInt aValue )

  {

  if( aValue >= KCamImageLargeTypeMin )

    {

    return ECamImageTypeLarge;

    }

  else if( aValue >= KCamImageMediumTypeMin )

    {

    return ECamImageTypeMedium;

    }

  else

    {

    return ECamImageTypeSmall;  

    }  

  }

// ---------------------------------------------------------------------------

// CamConfigurationUtility::IsSupported

// ---------------------------------------------------------------------------

//   

TBool 

CamConfigurationUtility::IsSupported( TInt aValue, TCamItemType aItemType, const TCamImageQualityData& aData )

  {

    switch( aItemType )

    {

      case ECamItemPhotoSize:

        {        

        if( aValue == aData.iPhotoSize.iSizeId )

          {

          return ETrue;  

          }        

        break;  

        }

      case ECamItemPhotoQuality:

        {

        if( aValue == aData.iPhotoSize.iQualitySettingId )

          {

          return ETrue;  

          }

        break;  

        }

      default:

        {

        User::Panic( KCamConfigPanicId, ECamConfigPanicInvalidItem );   

        }  

    }

  return EFalse;

  } 

// ---------------------------------------------------------------------------

// CamConfigurationUtility::MapDynamicSettingToSceneSetting

// Get the scene setting id from dynamic setting id.

// ---------------------------------------------------------------------------

//

TInt

CamConfigurationUtility::MapDynamicSettingToSceneSetting( TInt aSettingId )

  {

  switch( aSettingId )

    {

    case ECamSettingItemDynamicVideoWhiteBalance:     // fall through

    case ECamSettingItemDynamicPhotoWhiteBalance:     

        return ECamSettingItemSceneAWBMode;

    case ECamSettingItemDynamicVideoExposure:         // fall through

    case ECamSettingItemDynamicPhotoExposure:         

        return ECamSettingItemSceneEV;

    case ECamSettingItemDynamicVideoFlash:            // fall through

    case ECamSettingItemDynamicPhotoFlash:            

        return ECamSettingItemSceneFlashMode;

    case ECamSettingItemDynamicVideoContrast:         // fall through

    case ECamSettingItemDynamicPhotoContrast:         

        return ECamSettingItemSceneContrast;

    case ECamSettingItemDynamicPhotoImageSharpness:   

        return ECamSettingItemSceneSharpness;

    case ECamSettingItemDynamicVideoLightSensitivity: // fall through

    case ECamSettingItemDynamicPhotoLightSensitivity: 

        return ECamSettingItemSceneISO;

    default:                                          

        return KErrNotFound;

    }

  }

// End of file