--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraapp/generic/common/src/camconfiguration.cpp Thu Jan 07 16:18:56 2010 +0200
@@ -0,0 +1,1198 @@
+/*
+* 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: Implementation of Dynamic Configuration
+*
+*/
+
+
+#include <e32debug.h> // RDebug
+#include "camconfiguration.h"
+#include "camconfigurationutility.h"
+#include "imagingconfigmanager.h"
+#include "CamUtility.h"
+#include "camconfigurationconstants.h"
+
+const TInt KReserveedSpace = 160000;
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::CCamConfiguration
+// ---------------------------------------------------------------------------
+//
+CCamConfiguration::CCamConfiguration():
+ iPrimaryCameraDisplayId( KCamPrimaryCameraDisplayId ),
+ iSecondaryCameraDisplayId( KCamSecondaryCameraDisplayId )
+ {
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::~CCamConfiguration
+// ---------------------------------------------------------------------------
+//
+CCamConfiguration::~CCamConfiguration()
+ {
+ // Quality data arrays
+ iPrimaryCameraPhotoQualities.Close();
+ iSecondaryCameraPhotoQualities.Close();
+ iVideoQualities.Close();
+
+ delete iIcm;
+
+ // String data
+ for( TInt i=iStrings8.Count()-1; i>=0; i-- )
+ {
+ HBufC8* str = iStrings8[i];
+ iStrings8.Remove( i );
+ delete str;
+ }
+ iStrings8.Close();
+ for( TInt i=iStrings16.Count()-1; i>=0; i-- )
+ {
+ HBufC16* str = iStrings16[i];
+ iStrings16.Remove( i );
+ delete str;
+ }
+ iStrings16.Close();
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::NewL
+// ---------------------------------------------------------------------------
+//
+CCamConfiguration*
+CCamConfiguration::NewL()
+ {
+ CCamConfiguration* self = new (ELeave) CCamConfiguration;
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::ConstructL
+// ---------------------------------------------------------------------------
+//
+void
+CCamConfiguration::ConstructL()
+ {
+ PRINT( _L("Camera => CCamConfiguration::ConstructL") );
+
+ PRINT( _L("Camera <> CCamConfiguration::ConstructL - Instantiate ICM") );
+ iIcm = CImagingConfigManager::NewL();
+
+ PRINT( _L("Camera <> CCamConfiguration::ConstructL - Init image qualities") );
+ InitializeImageQualitiesL();
+
+ PRINT( _L("Camera <> CCamConfiguration::ConstructL - Init video qualities") );
+ InitializeVideoQualitiesL();
+
+ PRINT( _L("Camera <= CCamConfiguration::ConstructL") );
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::InitializeImageQualitiesL
+// ---------------------------------------------------------------------------
+//
+void
+CCamConfiguration::InitializeImageQualitiesL()
+ {
+ PRINT( _L("Camera => CCamConfiguration::InitializeImageQualitiesL") );
+ TInt totalLevels = iIcm->NumberOfImageQualityLevels();
+
+ CArrayFixFlat<TUint>* levels
+ = new (ELeave) CArrayFixFlat<TUint>( totalLevels );
+ CleanupStack::PushL( levels );
+ TImageQualitySet set;
+ TCamImageQualityData data;
+
+ // Get primary camera levels
+ if( iPrimaryCameraDisplayId )
+ {
+ PRINT( _L("Camera <> CCamConfiguration::InitializeImageQualitiesL *** Primary camera qualities ***") );
+ iIcm->GetImageQualityLevelsL( *levels, iPrimaryCameraDisplayId );
+ TInt numLevels( levels->Count() );
+ PRINT1(_L("Camera <> CCamConfiguration::InitializeImageQualitiesL - Total number of levels: %d"), numLevels );
+
+ for( int i=0; i<numLevels; i++ )
+ {
+ iIcm->GetImageQualitySet( set, levels->At( i ), iPrimaryCameraDisplayId );
+ if( set.iCamcorderVisible > 0 )
+ {
+ PRINT1( _L("Camera <> CCamConfiguration::InitializeImageQualitiesL - Set %d CamcorderVisible"), i );
+
+ InitializeImageQualityL( set, data );
+ AddToOrderedImageQualitiesArrayL( data, iPrimaryCameraPhotoQualities );
+ }
+ }
+ }
+
+ // Adjust print qualities - print => print high/print/print low
+ CamConfigurationUtility::AdjustPrintQualities( iPrimaryCameraPhotoQualities );
+ TInt numQualities = iPrimaryCameraPhotoQualities.Count();
+
+ // Get secondary camera levels
+ if( iSecondaryCameraDisplayId )
+ {
+ PRINT( _L("Camera <> CCamConfiguration::InitializeImageQualitiesL() *** Secondary camera qualities ***") );
+ iIcm->GetImageQualityLevelsL( *levels, iSecondaryCameraDisplayId );
+ TInt numLevels( levels->Count() );
+ PRINT1( _L("Camera <> CCamConfiguration::InitializeImageQualitiesL - Total number of levels: %d"), numLevels );
+
+ for( int i=0; i<numLevels; i++ )
+ {
+ iIcm->GetImageQualitySet( set, levels->At( i ), iSecondaryCameraDisplayId );
+ if( set.iCamcorderVisible > 0 )
+ {
+ PRINT1( _L("Camera <> CCamConfiguration::InitializeImageQualitiesL - Set %d CamcorderVisible"), i );
+
+ InitializeImageQualityL( set, data );
+
+ // Force image quality to secondary
+ // data.iPhotoQualitySetting.iPhotoQualityId = EImageQualitySecondary;
+ data.iPhotoQualitySetting.iPhotoQualityId
+ = static_cast<TCamImageQuality>( numQualities++ );
+ data.iPhotoSize.iQualitySettingId = ECamImageQualitySecondary;
+
+ AddToOrderedImageQualitiesArrayL( data, iSecondaryCameraPhotoQualities );
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy( levels );
+
+ PRINT( _L("Camera <= CCamConfiguration::InitializeImageQualitiesL") );
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::InitializeVideoQualitiesL
+// ---------------------------------------------------------------------------
+//
+void
+CCamConfiguration::InitializeVideoQualitiesL()
+ {
+ PRINT(_L("Camera => CCamConfiguration::InitializeVideoQualitiesL") );
+ TInt totalLevels = iIcm->NumberOfVideoQualityLevels();
+ CArrayFixFlat<TUint>* levels
+ = new (ELeave) CArrayFixFlat<TUint>( totalLevels );
+ CleanupStack::PushL( levels );
+ TVideoQualitySet set;
+
+ // Get primary camera levels
+ if( iPrimaryCameraDisplayId )
+ {
+ iIcm->GetVideoQualityLevelsL( *levels, iPrimaryCameraDisplayId );
+ TInt numLevels( levels->Count() );
+ PRINT1(_L("Camera <> CCamConfiguration::InitializeVideoQualitiesL - Total number of levels: %d"), numLevels );
+
+ for( int i=0; i<numLevels; i++ )
+ {
+ iIcm->GetVideoQualitySet( set, levels->At( i ), iPrimaryCameraDisplayId );
+ if( set.iCamcorderVisible > 0 )
+ {
+ PRINT1(_L("Camera <> CCamConfiguration::InitializeVideoQualitiesL - Set %d CamcorderVisible"), i );
+
+ TCamVideoQualityData data( CreateVideoQualityDataL( set ) );
+ AddToOrderedVideoQualitiesArrayL( data, iVideoQualities );
+ }
+ }
+
+ // Set the video quality values now that we have all data in sorted array
+ CamConfigurationUtility::SetVideoQualityLevels( iVideoQualities );
+ }
+
+ // Secondary camera video qualities from ICM are ignored.
+ // The last primary camera quality is used in seconcary camera as well.
+
+ CleanupStack::PopAndDestroy( levels );
+
+ // Get the average video bitrate scaler
+ TCamcorderMMFPluginSettings mmfPluginSettings;
+ User::LeaveIfError( iIcm->GetCamcorderMMFPluginSettings( mmfPluginSettings ) );
+ iCMRAvgVideoBitRateScaler = mmfPluginSettings.iCMRAvgVideoBitRateScaler;
+
+ PRINT( _L("Camera <= CCamConfiguration::InitializeVideoQualitiesL") );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::InitializeVideoQualitiesL
+// ---------------------------------------------------------------------------
+//
+void
+CCamConfiguration::AddToOrderedImageQualitiesArrayL( TCamImageQualityData& aQuality,
+ RArray<TCamImageQualityData>& aArray )
+ {
+ TBool added = EFalse;
+ TInt numQualities = aArray.Count();
+ TInt numPixels = aQuality.iPhotoSize.iWidth*aQuality.iPhotoSize.iHeight;
+
+ for( TInt i=0; i<numQualities; i++ )
+ {
+ if( aArray[i].iPhotoSize.iWidth*aArray[i].iPhotoSize.iHeight < numPixels )
+ {
+ aArray.InsertL( aQuality, i );
+ added = ETrue;
+ break;
+ }
+ }
+
+ if( !added )
+ {
+ // Item is to be last in the array
+ aArray.AppendL( aQuality );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::AddToOrderedVideoQualitiesArrayL
+// ---------------------------------------------------------------------------
+//
+void
+CCamConfiguration::AddToOrderedVideoQualitiesArrayL( TCamVideoQualityData& aQuality,
+ RArray<TCamVideoQualityData>& aArray )
+ {
+ TBool added( EFalse );
+ const TInt numQualities( aArray.Count() );
+ const TInt currValue( aQuality.iDescription );
+
+ for( TInt i=0; i<numQualities; i++ )
+ {
+ if( aArray[i].iDescription > currValue )
+ {
+ // aQuality should be before quality aArray[i]
+ aArray.InsertL( aQuality, i );
+ added = ETrue;
+ break;
+ }
+ }
+
+ if( !added )
+ {
+ // Item is to be last in the array
+ aArray.AppendL( aQuality );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::InitializeImageQualityL
+// ---------------------------------------------------------------------------
+//
+void
+CCamConfiguration::InitializeImageQualityL( const TImageQualitySet& aSet, TCamImageQualityData& aData )
+ {
+ PRINT3( _L("Camera => CCamConfiguration::InitializeImageQualityL - res: (%d, %d), compression: %d" ),
+ aSet.iImageWidth, aSet.iImageHeight, aSet.iCompressionQuality );
+ // Find out the image quality/resolution id for the set
+ TInt index = KErrNotFound;
+ for( int i=0; i<ECamPhotoSizeLast; i++ )
+ {
+ if( aSet.iImageWidth == KCamPhotoSizes[i].iWidth &&
+ aSet.iImageHeight == KCamPhotoSizes[i].iHeight )
+ {
+ index = i;
+ }
+ }
+
+ // Check that index is valid
+ User::LeaveIfError( index );
+
+ // Copy the photo size data
+ aData.iPhotoSize = KCamPhotoSizes[index];
+
+ // --------------------------------
+ // Photo quality settings
+
+ // Set the photo resulution value, based on photo size value
+ aData.iPhotoQualitySetting.iPhotoResolution
+ = MapPhotoSizeToResolution( aData.iPhotoSize.iSizeId );
+
+ // Jpeg compression
+ aData.iPhotoQualitySetting.iQualityLevel = aSet.iCompressionQuality;
+
+ // Estimated file size
+ aData.iFileSize = aSet.iEstimatedSize;
+
+ // Set correct image quality description, quality id and icons
+ TCamImageType type = CamConfigurationUtility::ImageType( aSet.iCamcorderVisible );
+ aData.iDescription = KCamImageQualityMappings[index][type].iDesc;
+
+ if( ECamPhotoQualityDescLast == aData.iDescription )
+ {
+ // No description defined for this quality => not supported
+ User::Leave( KErrNotSupported );
+ }
+
+ aData.iPhotoQualitySetting.iPhotoQualityId = KCamImageQualityMappings[index][type].iQuality;
+ aData.iQualityIcons = KCamImageIcons[ aData.iDescription ];
+
+ PRINT( _L("Camera <= CCamConfiguration::InitializeImageQualityL") );
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::GetPsiIntArrayL
+// ---------------------------------------------------------------------------
+//
+void
+CCamConfiguration::GetPsiIntArrayL( TCamPsiKey aKey, RArray<TInt>& aArray ) const
+ {
+ PRINT1( _L("Camera => CCamConfiguration::GetPsiIntArrayL Key: %d"), aKey );
+ switch( aKey )
+ {
+ case ECamPsiSupportedStillResolutions:
+ {
+ // Despite the name, returns array of TCamPhotoSizeId
+ // The array contents must be ordered in TCamPhotoSizeId enum order
+ for( TInt i=0; i<ECamPhotoSizeLast; i++ )
+ {
+ AppendIfSupportedL( ECamItemPhotoSize, i, aArray );
+ }
+ break;
+ }
+
+ case ECamPsiJpegDataSizes:
+ {
+ // Jpeg data sizes. Must be in same order as supported still resolutions,
+ // so photo size is used for indexing.
+ for( TInt i=0; i<ECamPhotoSizeLast; i++ )
+ {
+ AppendIfSupportedL( ECamItemPhotoSize, i, aArray, ECamItemPhotoJpegSize );
+ }
+ break;
+ }
+
+ case ECamPsiSequencePostProcessDataSizes:
+ {
+ // Jpeg data sizes. Must be in same order as supported still resolutions,
+ // so photo size is used for indexing.
+ for( TInt i=0; i<ECamPhotoSizeLast; i++ )
+ {
+ AppendIfSupportedL( ECamItemPhotoSize, i, aArray, ECamItemSeqPostProcSize );
+ }
+ break;
+ }
+
+ case ECamPsiSupportedStillQualities:
+ {
+ // This is array for primary camera qualities, so do not include secondary quality.
+ // The results
+ for( TInt i=0; i<ECamImageQualitySecondary; i++ )
+ {
+ AppendIfSupportedL( ECamItemPhotoQuality, i, aArray );
+ }
+ break;
+ }
+
+ case ECamPsiStillQualityIconIds:
+ {
+ // Icon ids. Must be in the same order as ECamPsiSupportedStillQualities,
+ // so that type is used for indexing.
+ // This is array for primary camera qualities, so do not include secondary quality.
+ for( TInt i=0; i<ECamImageQualitySecondary; i++ )
+ {
+ AppendIfSupportedL( ECamItemPhotoQuality, i, aArray, ECamItemSettingsIconId );
+ }
+ break;
+ }
+
+ case ECamPsiPrecapStillQualityIconIds:
+ {
+ // Secondary camera quality is included
+ for( TInt i=0; i<ECamImageQualityLast; i++ )
+ {
+ AppendIfSupportedL( ECamItemPhotoQuality, i, aArray, ECamItemPrecapIconId );
+ }
+ break;
+ }
+
+ case ECamPsiSupportedVideoResolutions:
+ {
+ for( TInt i=0; i<ECamVideoResolutionLast; i++ )
+ {
+ AppendVideoResIfSupportedL( i, aArray );
+ }
+ break;
+ }
+
+ case ECamPsiSupportedVideoQualities:
+ {
+ TInt n = iVideoQualities.Count();
+ for( TInt i=0; i<n; i++ )
+ {
+ aArray.AppendL( iVideoQualities[i].iQualitySetting );
+ }
+ break;
+ }
+
+ case ECamPsiPrecapVideoQualityIconIds:
+ {
+ TInt n = iVideoQualities.Count();
+ for( TInt i=0; i<n; i++ )
+ {
+ aArray.AppendL( iVideoQualities[i].iQualityIcons.iPrecapIconId );
+ aArray.AppendL( iVideoQualities[i].iQualityIcons.iPrecapIconMask );
+ }
+ break;
+ }
+
+ case ECamPsiVideoQualityIconIds:
+ {
+ TInt n = iVideoQualities.Count();
+ for( TInt i=0; i<n; i++ )
+ {
+ aArray.AppendL( iVideoQualities[i].iQualityIcons.iSettingsIconId );
+ aArray.AppendL( iVideoQualities[i].iQualityIcons.iSettingsIconMask );
+ }
+ break;
+ }
+
+ case ECamPsiVideoQualityFileTypeId:
+ {
+ TInt n = iVideoQualities.Count();
+ for( TInt i=0; i<n; i++ )
+ {
+ aArray.AppendL( iVideoQualities[i].iFileTypeIcons.iIconId );
+ aArray.AppendL( iVideoQualities[i].iFileTypeIcons.iMask );
+ }
+ break;
+ }
+
+ default:
+ {
+ PRINT( _L("Camera <> CCamConfiguration::GetPsiIntArrayL - Unknown key!") );
+ User::Panic( KCamConfigPanicId, ECamConfigPanicUnknownKey );
+ }
+
+ }
+ PRINT( _L("Camera <= CCamConfiguration::GetPsiIntArrayL") );
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::AppendIfSupportedL
+// ---------------------------------------------------------------------------
+//
+void
+CCamConfiguration::AppendIfSupportedL( TCamItemType aCheckType, TInt aValue,
+ RArray<TInt>&aArray, TCamItemType aAppendType ) const
+ {
+ TInt n( iPrimaryCameraPhotoQualities.Count() );
+ for( TInt i=0; i<n; i++ )
+ {
+ if( CamConfigurationUtility::IsSupported( aValue, aCheckType,
+ iPrimaryCameraPhotoQualities[i] ) )
+ {
+ if( ECamItemSame == aAppendType )
+ {
+ // Simply append the current value
+ aArray.AppendL( aValue );
+ }
+ else
+ {
+ // Append something else corresponding the item
+ AppendTypeL( aAppendType, aArray, iPrimaryCameraPhotoQualities[i] );
+ }
+
+ return;
+ }
+ }
+
+ n = iSecondaryCameraPhotoQualities.Count();
+ for( TInt i=0; i<n; i++ )
+ {
+ if( CamConfigurationUtility::IsSupported( aValue, aCheckType,
+ iSecondaryCameraPhotoQualities[i] ) )
+ {
+ if( ECamItemSame == aAppendType )
+ {
+ // Simply append the current value
+ aArray.AppendL( aValue );
+ }
+ else
+ {
+ // Append something else corresponding the item
+ AppendTypeL( aAppendType, aArray, iSecondaryCameraPhotoQualities[i] );
+ }
+ return;
+ }
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::AppendTypeL
+// ---------------------------------------------------------------------------
+//
+void
+CCamConfiguration::AppendTypeL( TCamItemType aType, RArray<TInt>&aArray, const TCamImageQualityData& aData )
+ {
+ switch( aType )
+ {
+ case ECamItemSettingsIconId:
+ {
+ aArray.AppendL( aData.iQualityIcons.iSettingsIconId );
+ aArray.AppendL( aData.iQualityIcons.iSettingsIconMask );
+ break;
+ }
+ case ECamItemPrecapIconId:
+ {
+ aArray.AppendL( aData.iQualityIcons.iPrecapIconId );
+ aArray.AppendL( aData.iQualityIcons.iPrecapIconMask );
+ break;
+ }
+ case ECamItemPhotoJpegSize:
+ {
+ aArray.AppendL( aData.iFileSize );
+ break;
+ }
+ case ECamItemSeqPostProcSize:
+ {
+ aArray.AppendL( aData.iFileSize );
+ break;
+ }
+ default:
+ {
+ User::Panic( KCamConfigPanicId, ECamConfigPanicUnknownType );
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::NumImageQualities
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamConfiguration::NumImageQualities() const
+ {
+ TInt count( iPrimaryCameraPhotoQualities.Count() );
+ if( iSecondaryCameraPhotoQualities.Count() > 0 )
+ {
+ // Only one quality currently supported for secondary cam
+ count++;
+ // count += iSecondaryCameraPhotoQualities.Count();
+ }
+
+ return count;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::SecondaryCameraImageQuality
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamConfiguration::MmsImageQuality() const
+ {
+ // As the primary camera image qualities are sorted, MMS quality is the
+ // last one in the qualities array.
+ TInt index = iPrimaryCameraPhotoQualities.Count()-1;
+
+ return index < 0 ?
+ KErrNotFound :
+ iPrimaryCameraPhotoQualities[index].iPhotoQualitySetting.iPhotoQualityId;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::SecondaryCameraImageQuality
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamConfiguration::SecondaryCameraImageQuality() const
+ {
+ if( iSecondaryCameraPhotoQualities.Count() > 0 )
+ {
+ return iSecondaryCameraPhotoQualities[0].iPhotoQualitySetting.iPhotoQualityId;
+ }
+
+ return KErrNotFound;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::ImageQuality
+// ---------------------------------------------------------------------------
+//
+const TCamPhotoQualitySetting&
+CCamConfiguration::ImageQuality( TInt aIndex ) const
+ {
+ const TInt count( iPrimaryCameraPhotoQualities.Count() );
+ if( aIndex >= 0 && aIndex < count )
+ {
+ return iPrimaryCameraPhotoQualities[aIndex].iPhotoQualitySetting;
+ }
+ else
+ {
+ TInt secIndex = aIndex - count;
+ if( secIndex >= 0 &&
+ secIndex < iSecondaryCameraPhotoQualities.Count() )
+ {
+ return iSecondaryCameraPhotoQualities[secIndex].iPhotoQualitySetting;
+ }
+
+ User::Panic( KCamConfigPanicId, ECamConfigPanicNoQuality );
+ return iPrimaryCameraPhotoQualities[0].iPhotoQualitySetting; // Get rid of warning
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::ImageQualityData
+// ---------------------------------------------------------------------------
+//
+const TCamImageQualityData&
+CCamConfiguration::ImageQualityData( TInt aIndex ) const
+ {
+ const TInt count( iPrimaryCameraPhotoQualities.Count() );
+ if( aIndex >= 0 && aIndex < count )
+ {
+ return iPrimaryCameraPhotoQualities[aIndex];
+ }
+ else
+ {
+ TInt secIndex = aIndex - count;
+ if( secIndex >= 0 &&
+ secIndex < iSecondaryCameraPhotoQualities.Count() )
+ {
+ return iSecondaryCameraPhotoQualities[secIndex];
+ }
+
+ User::Panic( KCamConfigPanicId, ECamConfigPanicNoQuality );
+ return iPrimaryCameraPhotoQualities[0]; // Get rid of warning
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::NumVideoQualities
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamConfiguration::NumVideoQualities() const
+ {
+ return iVideoQualities.Count();
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::NumPrimaryImageQualities
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamConfiguration::NumPrimaryImageQualities() const
+ {
+ return iPrimaryCameraPhotoQualities.Count();
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::SecondaryCameraVideoQuality
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamConfiguration::SecondaryCameraVideoQuality() const
+ {
+ // Currently always the last of the video qualities
+ // Currently always the last of the video qualities
+ // As the camera video qualities are sorted, sharing quality is the
+ // last one in the qualities array.
+ TInt index = NumVideoQualities()-1;
+
+ return index < 0 ?
+ KErrNotFound :
+ iVideoQualities[index].iQualitySettings.iQualityLevel;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::VideoQualitySetting
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamConfiguration::VideoQualitySetting( TInt aIndex ) const
+ {
+ return iVideoQualities[aIndex].iQualitySetting;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::VideoQuality
+// ---------------------------------------------------------------------------
+//
+const TVideoQualitySettings&
+CCamConfiguration::VideoQuality( TInt aIndex ) const
+ {
+ return iVideoQualities[aIndex].iQualitySettings;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::MapSupportedQualityToQualityDescriptor
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamConfiguration::MapSupportedQualityToQualityDescriptor( TBool aVideoMode,
+ TInt aQualityVal ) const
+ {
+ if( aVideoMode )
+ {
+ // Video mode
+ TInt n = iVideoQualities.Count();
+ for( TInt i=0; i<n; i++ )
+ {
+ const TCamVideoQualityData& data = iVideoQualities[i];
+ if( aQualityVal == data.iQualitySetting )
+ {
+ return data.iDescription;
+ }
+ }
+
+ // No description found for this quality => Not supported
+ User::Panic( KCamConfigPanicId, ECamConfigPanicNoDescription );
+ return KErrNotSupported;
+ }
+ else
+ {
+ // Image mode
+ TInt n = iPrimaryCameraPhotoQualities.Count();
+ for( TInt i=0; i<n; i++ )
+ {
+ const TCamImageQualityData& data = iPrimaryCameraPhotoQualities[i];
+ if( aQualityVal == data.iPhotoSize.iQualitySettingId )
+ {
+ return data.iDescription;
+ }
+ }
+
+ // No description found for this quality value => Not supported
+ User::Panic( KCamConfigPanicId, ECamConfigPanicNoDescription );
+ return KErrNotSupported;
+ }
+
+ }
+
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::MapPhotoSizeToResolution
+// ---------------------------------------------------------------------------
+//
+TCamImageResolution
+CCamConfiguration::MapPhotoSizeToResolution( TCamPhotoSizeId aSizeId )
+ {
+ for( TInt i=0; i<ECamPhotoSizeLast; i++ )
+ {
+ if( KCamPhotoSizes[i].iSizeId == aSizeId )
+ {
+ return KCamPhotoSizes[i].iResolution;
+ }
+ }
+ // Used as deafult in previous implementation
+ return EImageResolutionMMS;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::MapResolutionToPhotoSize
+// ---------------------------------------------------------------------------
+//
+TCamPhotoSizeId
+CCamConfiguration::MapResolutionToPhotoSize( TCamImageResolution aResolution )
+ {
+ for( TInt i=0; i<ECamPhotoSizeLast; i++ )
+ {
+ if( KCamPhotoSizes[i].iResolution == aResolution )
+ {
+ return KCamPhotoSizes[i].iSizeId;
+ }
+ }
+ // Used as deafult in previous implementation
+ return ECamPhotoSizeVGA;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::ImagesRemaining
+// ---------------------------------------------------------------------------
+//
+TInt
+CCamConfiguration::ImagesRemaining( TCamMediaStorage aStorage,
+ TCamPhotoSizeId aSizeId,
+ TInt aCriticalLevel,
+ TBool /*aBurstActive*/ ) const
+ {
+ // PRINT( _L("Camera => CamUtility::ImagesRemaining") );
+ TInt64 memoryfree = 0;
+
+ // Get the current amount of free memory on the phone.
+ switch ( aStorage )
+ {
+ case ECamMediaStoragePhone:
+ memoryfree
+ = CamUtility::MemoryFree( DriveInfo::EDefaultPhoneMemory,
+ aCriticalLevel );
+ break;
+
+ case ECamMediaStorageCard:
+ PRINT( _L("Camera => CamUtility::ImagesRemaining, ECamMediaStorageCard") );
+ memoryfree
+ = CamUtility::MemoryFree( DriveInfo::EDefaultRemovableMassStorage,
+ aCriticalLevel );
+ break;
+
+ case ECamMediaStorageMassStorage:
+ PRINT( _L("Camera => CamUtility::ImagesRemaining, ECamMediaStorageMassStorage") );
+ memoryfree
+ = CamUtility::MemoryFree( DriveInfo::EDefaultMassStorage,
+ aCriticalLevel );
+ break;
+ default:
+ PRINT( _L("Camera => CamUtility::ImagesRemaining, default") );
+ break;
+ };
+
+ TInt size = 1;
+
+ TInt n=NumImageQualities();
+ for( TInt i=0; i<n; i++ )
+ {
+ const TCamImageQualityData& data( ImageQualityData( i ) );
+ if( aSizeId == data.iPhotoSize.iSizeId )
+ {
+ size = data.iFileSize;
+ }
+ }
+
+ memoryfree -= KReserveedSpace;
+ // In the case of exceptional circumstances, just return zero images remaining.
+ if ( memoryfree <= 0 )
+ {
+ memoryfree = 0; // To handle exceptional situation, just return zero images.
+ }
+
+ TInt64 images = memoryfree / size;
+
+ images = Min( KMaxTInt, images ); // Truncate value to max possible.
+
+ // PRINT1( _L("Camera <= CamUtility::ImagesRemaining %d"), (TInt)images );
+ return static_cast<TInt>( images ); // (nothing greater than TInt)
+ }
+
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::AllocString8L
+// ---------------------------------------------------------------------------
+//
+const TUint8*
+CCamConfiguration::AllocString8L( const TUint8* aData )
+ {
+ TPtrC8 ptr( aData );
+ HBufC8* data = HBufC8::NewLC( ptr.Length() + 1 );
+ data->Des().Copy( ptr );
+ data->Des().Append( '\0' );
+
+ iStrings8.AppendL( data );
+
+ CleanupStack::Pop( data );
+
+ return data->Ptr();
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::AllocString16L
+// ---------------------------------------------------------------------------
+//
+const TUint16*
+CCamConfiguration::AllocString16L( const TUint8* aData )
+ {
+ TPtrC8 ptr( aData );
+ HBufC16* data = HBufC16::NewLC( ptr.Length() + 1 );
+ data->Des().Copy( ptr );
+ data->Des().Append( '\0' );
+
+ iStrings16.AppendL( data );
+
+ CleanupStack::Pop( data );
+
+ return data->Ptr();
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::CreateVideoQualityDataL
+// ---------------------------------------------------------------------------
+//
+TCamVideoQualityData
+CCamConfiguration::CreateVideoQualityDataL( const TVideoQualitySet& aSet )
+ {
+ PRINT3( _L("Camera => CCamConfiguration::CreateVideoQualityDataL - res: (%d, %d), video bitrate: %d" ),
+ aSet.iVideoWidth, aSet.iVideoHeight, aSet.iVideoBitRate );
+
+ TInt resIndex( CamConfigurationUtility::VideoSizeIndex(
+ aSet.iVideoWidth, aSet.iVideoHeight ) );
+ if( resIndex < 0 )
+ {
+ User::Panic( KCamConfigPanicId, ECamConfigPanicNoVideoRes );
+ }
+
+ TCamVideoQualityDescription descType
+ = CamConfigurationUtility::VideoDescId( aSet.iCamcorderVisible );
+
+ TInt videoType = CamConfigurationUtility::VideoType( aSet.iVideoFileMimeType );
+
+ // Convert FourCC value from TFourCC to asciiz string
+ const TInt KFourCCLength = 5; // 4 characters + '\0'
+ TText8 fourCCBuf[KFourCCLength ];
+ TPtr8 fourCC( fourCCBuf, KFourCCLength );
+ aSet.iAudioFourCCType.FourCC( &fourCC );
+ fourCC.Append( '\0' );
+
+ // Initialized as here to avoid const_casts for the text pointers
+ TCamVideoQualityData data =
+ {
+ // TVideoQualitySettings:
+ {
+ 0, // iQualityLevel - defined later
+ KCamVideoSizes[resIndex].iCamVideoRes, // iVideoResolution
+ aSet.iVideoFrameRate, // iVideoFrameRate
+ aSet.iVideoBitRate, // iVideoBitRate
+ aSet.iAudioBitRate, // iAudioBitRate
+ AllocString8L( aSet.iVideoFileMimeType ), // iVideoMimeType
+ AllocString16L( aSet.iPreferredSupplier ), // iPreferredSupplier
+ AllocString8L( aSet.iVideoCodecMimeType ), // iVideoCodec
+ AllocString8L( fourCCBuf ), // iAudioCodec
+ CamConfigurationUtility::VideoType( aSet.iVideoFileMimeType ), // iVideoFileType
+ ECamVideoClipMax // iVideoLength - changed later if necessary
+ },
+
+ KCamVideoSizes[resIndex].iCamVideoRes, // iVideoResolution
+ ECamVideoQualitySharing, // iQualitySetting - replaced later
+ descType, // iDescription
+ KCamVideoIcons[descType],
+ KCamVideoTypeIcons[videoType]
+ };
+
+ PRINT( _L("Camera <= CCamConfiguration::CreateVideoQualityDataL" ) );
+ return data;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::AppendVideoResIfSupportedL
+// ---------------------------------------------------------------------------
+//
+void
+CCamConfiguration::AppendVideoResIfSupportedL( TInt aValue, RArray<TInt>&aArray ) const
+ {
+ TInt n( iVideoQualities.Count() );
+ for( TInt i=0; i<n; i++ )
+ {
+ if( iVideoQualities[i].iVideoResolution == aValue )
+ {
+ aArray.AppendL( aValue );
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::CMRAvgVideoBitRateScaler
+// ---------------------------------------------------------------------------
+//
+TReal
+CCamConfiguration::CMRAvgVideoBitRateScaler() const
+ {
+ return iCMRAvgVideoBitRateScaler;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::GetRequiredImageQualityIndex
+// ---------------------------------------------------------------------------
+//
+TInt CCamConfiguration::GetRequiredImageQualityIndex( const TSize& aResolution ) const
+ {
+ TInt QualityIndex = 0;
+ TInt MaxCount = NumPrimaryImageQualities();
+ TCamImageQualityData QData;
+ for ( TInt i = 0; i < MaxCount; i++ )
+ {
+ QData = ImageQualityData( i );
+ if ( QData.iPhotoSize.iWidth == aResolution.iWidth
+ && QData.iPhotoSize.iHeight == aResolution.iHeight )
+ {
+ QualityIndex = i;
+ }
+ }
+ return QualityIndex;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::MapRequiredResolutionToActualResolutionPhoto
+// ---------------------------------------------------------------------------
+//
+TSize CCamConfiguration::MapRequiredResolutionToActualResolutionPhoto( const TSize& aRequiredResolution ) const {
+ PRINT2(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionPhoto aRequiredResolution: (%d,%d)"), aRequiredResolution.iWidth, aRequiredResolution.iHeight );
+ TInt MaxCount = NumPrimaryImageQualities();
+ TCamImageQualityData QData;
+ TSize Reso( 0, 0 );
+ TBool found = EFalse;
+ for ( TInt i = 0; i < MaxCount; i++ )
+ {
+ QData = ImageQualityData( i );
+ PRINT3(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionPhoto index: %d PhotoSize: (%d,%d)"), i,QData.iPhotoSize.iWidth, QData.iPhotoSize.iHeight );
+ if ( QData.iPhotoSize.iWidth == aRequiredResolution.iWidth
+ && QData.iPhotoSize.iHeight == aRequiredResolution.iHeight )
+ {
+ Reso = aRequiredResolution;
+ found = ETrue;
+ }
+ }
+ if ( !found && aRequiredResolution != TSize(0,0) ) { // TSize(0,0) should be returned the same as it means the mms quality
+ TInt referenceQuality = aRequiredResolution.iWidth*aRequiredResolution.iHeight;
+ TInt currentQuality = 0;
+ TInt closestMatch = Abs(referenceQuality-currentQuality);
+ PRINT1(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionPhoto closestMatch: (%d)"), closestMatch );
+ TInt currentMatch = 0;
+ for ( TInt i = 0; i < MaxCount; i++ )
+ {
+ QData = ImageQualityData( i );
+ PRINT3(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionPhoto index: %d PhotoSize: (%d,%d)"), i, QData.iPhotoSize.iWidth, QData.iPhotoSize.iHeight );
+ currentQuality = QData.iPhotoSize.iWidth*QData.iPhotoSize.iHeight;
+ currentMatch = Abs(referenceQuality-currentQuality);
+ PRINT1(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionPhoto currentMatch: (%d)"), currentMatch );
+ if ( currentMatch < closestMatch )
+ {
+ Reso.SetSize( QData.iPhotoSize.iWidth, QData.iPhotoSize.iHeight );
+ closestMatch = currentMatch;
+ }
+ }
+ }
+ PRINT2(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionPhoto return resolution: (%d,%d)"), Reso.iWidth, Reso.iHeight );
+ return Reso;
+}
+
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::GetRequiredVideoQualityIndex
+// ---------------------------------------------------------------------------
+//
+TInt CCamConfiguration::GetRequiredVideoQualityIndex( const TSize& aResolution ) const
+ {
+ PRINT2(_L("Camera <=> CCamConfiguration::GetRequiredVideoQualityIndex aResolution: (%d,%d)"), aResolution.iWidth, aResolution.iHeight );
+ TInt QualityIndex = 0;
+ TInt MaxCount = NumVideoQualities();
+ PRINT1(_L("Camera <=> CCamConfiguration::GetRequiredVideoQualityIndex MaxCount: %d"), MaxCount );
+ TCamVideoQualityData QData;
+ TSize VideoResolution(0,0);
+ //for ( TInt i = 0; i < MaxCount; i++ )
+ for ( TInt i = MaxCount-1; i >= 0; i-- )
+ {
+ QData = iVideoQualities[i];
+ VideoResolution = CamConfigurationUtility::CamVideoResolution( QData.iVideoResolution );
+ PRINT3(_L("Camera <=> CCamConfiguration::GetRequiredVideoQualityIndex index: %d VideoResolution: (%d,%d)"), i, VideoResolution.iWidth, VideoResolution.iHeight );
+ if ( VideoResolution.iWidth == aResolution.iWidth
+ && VideoResolution.iHeight == aResolution.iHeight )
+ {
+ QualityIndex = i;
+ }
+ }
+ PRINT1(_L("Camera <=> CCamConfiguration::GetRequiredVideoQualityIndex return: %d"), QualityIndex );
+ return QualityIndex;
+ }
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::MapRequiredResolutionToActualResolutionVideo
+// ---------------------------------------------------------------------------
+//
+TSize CCamConfiguration::MapRequiredResolutionToActualResolutionVideo( const TSize& aRequiredResolution ) const {
+ PRINT2(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionVideo aRequiredResolution: (%d,%d)"), aRequiredResolution.iWidth, aRequiredResolution.iHeight );
+ TInt MaxCount = NumVideoQualities();
+ TCamVideoQualityData QData;
+ TSize Reso( 0, 0 );
+ TBool found = EFalse;
+ TSize VideoResolution(0,0);
+ for ( TInt i = 0; i < MaxCount; i++ )
+ {
+ QData = iVideoQualities[i];
+ VideoResolution = CamConfigurationUtility::CamVideoResolution( QData.iVideoResolution );
+ PRINT3(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionVideo index: %d VideoResolution: (%d,%d)"), i, VideoResolution.iWidth, VideoResolution.iHeight );
+ if ( VideoResolution.iWidth == aRequiredResolution.iWidth
+ && VideoResolution.iHeight == aRequiredResolution.iHeight )
+ {
+ Reso = aRequiredResolution;
+ found = ETrue;
+ }
+ }
+ if ( !found && aRequiredResolution != TSize(0,0) ) { // TSize(0,0) should be returned the same as it means the mms quality
+ TInt referenceQuality = aRequiredResolution.iWidth*aRequiredResolution.iHeight;
+ TInt currentQuality = 0;
+ TInt closestMatch = Abs(referenceQuality-currentQuality);
+ PRINT1(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionVideo closestMatch: (%d)"), closestMatch );
+ TInt currentMatch = 0;
+ for ( TInt i = 0; i < MaxCount; i++ )
+ {
+ QData = iVideoQualities[i];
+ VideoResolution = CamConfigurationUtility::CamVideoResolution( QData.iVideoResolution );
+ PRINT3(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionVideo index: %d VideoResolution: (%d,%d)"), i, VideoResolution.iWidth, VideoResolution.iHeight );
+ currentQuality = VideoResolution.iWidth*VideoResolution.iHeight;
+ currentMatch = Abs(referenceQuality-currentQuality);
+ PRINT1(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionVideo currentMatch: (%d)"), currentMatch );
+ if ( currentMatch < closestMatch )
+ {
+ Reso.SetSize( VideoResolution.iWidth, VideoResolution.iHeight );
+ closestMatch = currentMatch;
+ }
+ }
+ }
+ PRINT2(_L("Camera <=> CCamConfiguration::MapRequiredResolutionToActualResolutionVideo return resolution: (%d,%d)"), Reso.iWidth, Reso.iHeight );
+ return Reso;
+}
+
+// ---------------------------------------------------------------------------
+// CCamConfiguration::GetDefaultVideoQualityFromIcmL
+// ---------------------------------------------------------------------------
+//
+TCamVideoQualitySettings CCamConfiguration::GetDefaultVideoQualityFromIcmL()
+ {
+ PRINT(_L("Camera => CCamConfiguration::GetDefaultVideoQualityFromIcmL") );
+ TInt totalLevels = iIcm->NumberOfVideoQualityLevels();
+ CArrayFixFlat<TUint>* levels
+ = new (ELeave) CArrayFixFlat<TUint>( totalLevels );
+ CleanupStack::PushL( levels );
+ TVideoQualitySet set;
+ TVideoQualitySet temp;
+
+ if( iPrimaryCameraDisplayId )
+ {
+ iIcm->GetVideoQualityLevelsL( *levels, iPrimaryCameraDisplayId );
+ TInt numLevels( levels->Count() );
+ PRINT1(_L("Camera <> CCamConfiguration::GetDefaultVideoQualityFromIcmL - Total number of levels: %d"), numLevels );
+
+ iIcm->GetVideoQualitySet( set, levels->At( 0 ), iPrimaryCameraDisplayId );
+
+ for( int i=1; i<numLevels; i++ )
+ {
+ iIcm->GetVideoQualitySet( temp, levels->At( i ), iPrimaryCameraDisplayId );
+ if( temp.iCamcorderVisible > 0 && temp.iVideoQualitySetLevel > set.iVideoQualitySetLevel )
+ {
+ set = temp;
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( levels );
+
+ TInt count = iVideoQualities.Count();
+ TCamVideoQualityDescription descType
+ = CamConfigurationUtility::VideoDescId( set.iCamcorderVisible );
+ for(TInt i = 0; i < count; i++)
+ {
+ if(iVideoQualities[i].iDescription == descType )
+ {
+ PRINT( _L("Camera <= CCamConfiguration::GetDefaultVideoQualityFromIcmL") );
+ return iVideoQualities[i].iQualitySetting;
+ }
+ }
+
+ // In normal case application should not come to here
+ // If could not find the exact video qulity setting, just return WidescreenHigh
+ // Should be fixed in other product
+ return ECamVideoQualityNormalHigh;
+ }
+
+// End of file
+