/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "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:

* Ixonos Plc

*

* Description:  

*

*/

#include "vedqualitysettingsapi.h"

const TUint KCameraDisplayID = 2;

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

// Constructor of CVideoQualitySelector

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

//

CVideoQualitySelector::CVideoQualitySelector()

    {

    }

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

// Destructor of CVideoQualitySelector

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

//

CVideoQualitySelector::~CVideoQualitySelector()

    {

    if( iConfigManager )

        {

        delete iConfigManager;

        iConfigManager = 0;

        }

    if( iQualityLevels )

        {

        delete iQualityLevels;

        iQualityLevels = 0;

        }

    }

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

// ConstructL() of CVideoQualitySelector

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

//

void CVideoQualitySelector::ConstructL()

    {

    iConfigManager = CImagingConfigManager::NewL();

    iQualityLevels = new (ELeave) CArrayFixFlat<TUint>(16);

    iConfigManager->GetVideoQualityLevelsL( *iQualityLevels, KCameraDisplayID );

    }

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

// NewL() of CVideoQualitySelector

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

//

CVideoQualitySelector* CVideoQualitySelector::NewL()

    {

    CVideoQualitySelector* self = CVideoQualitySelector::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// NewLC() of CVideoQualitySelector

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

//

CVideoQualitySelector* CVideoQualitySelector::NewLC()

    {

    CVideoQualitySelector* self = new( ELeave ) CVideoQualitySelector;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Get number of defined quality levels.

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

//

TInt CVideoQualitySelector::NumberOfQualityLevels()

    {

    return iQualityLevels->Count();

    }

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

// Get quality set associated with the given level.

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

//

void CVideoQualitySelector::GetVideoQualitySetL( SVideoQualitySet& aSet, TInt aLevel, TBool aAspectRatioWide )

    {

    if ( !aAspectRatioWide )

        {

        GetVideoQualitySetL( aSet, aLevel );

        }

    else

        {

        // NOT READY

        User::Leave( KErrNotSupported );     

        }

    }

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

// Get quality set associated with the given level.

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

//

void CVideoQualitySelector::GetVideoQualitySetL( SVideoQualitySet& aSet, TInt aLevel )

    {

    TVideoQualitySet currentSet;

    switch ( aLevel )

        {

        case EVideoQualityMMS :

            {

            iConfigManager->GetVideoQualitySet( currentSet, CImagingConfigManager::EQualityLow, KCameraDisplayID );

            MapQualitySet( aSet, currentSet );

            }

            break;

        case EVideoQualityNormal :

            {

            iConfigManager->GetVideoQualitySet( currentSet, CImagingConfigManager::EQualityNormal, KCameraDisplayID );

            MapQualitySet( aSet, currentSet );

            }

            break;

        case EVideoQualityHigh :

            {

            iConfigManager->GetVideoQualitySet( currentSet, CImagingConfigManager::EQualityHigh, KCameraDisplayID );

            MapQualitySet( aSet, currentSet );

            }

            break;

        default:

            {

            if ( aLevel < EVideoQualityMin )

                {

                User::Leave( KErrArgument );

                }

            // Map our quality level to config manager's quality level   

            TInt configManagerLevel = aLevel * (CImagingConfigManager::EQualityHigh - CImagingConfigManager::EQualityMin);

            configManagerLevel /= (EVideoQualityHigh - EVideoQualityMin);

            iConfigManager->GetVideoQualitySet( currentSet, configManagerLevel, KCameraDisplayID );

            MapQualitySet( aSet, currentSet );

            }

            break;

        }

    }

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

// Get quality set associated with the given video resolution.

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

//

void CVideoQualitySelector::GetVideoQualitySetL( SVideoQualitySet& aSet, const TSize& aVideoResolution )

    {

    TVideoQualitySet currentSet;

    TInt candidate = -1;

    TInt i;

    // Go through the qualities until a match is found. If several matches, pick the 1st one

    for ( i = iQualityLevels->Count() - 1; i >= 0; i-- ) // Searches from up to down to find higher quality first

        {

        iConfigManager->GetVideoQualitySet( currentSet, iQualityLevels->At( i ), KCameraDisplayID );

        if ( (currentSet.iVideoWidth == aVideoResolution.iWidth) && (currentSet.iVideoHeight == aVideoResolution.iHeight) )

            {

            // We've found a set which matches with the requested size

            if ( candidate == -1 )  // Don't set to worse if already found

                {

                candidate = i;

                }

            if ( (currentSet.iVideoQualitySetLevel == CImagingConfigManager::EQualityLow) ||

                 (currentSet.iVideoQualitySetLevel == CImagingConfigManager::EQualityNormal) ||

                 (currentSet.iVideoQualitySetLevel == CImagingConfigManager::EQualityHigh) )

                {

                // We've found a set which matches also with preferred qualities

                MapQualitySet( aSet, currentSet );

                return;

                }

            }

        }

    if ( candidate >= 0 ) 

        {

        iConfigManager->GetVideoQualitySet( currentSet, iQualityLevels->At( candidate ), KCameraDisplayID );

        MapQualitySet( aSet, currentSet );

        }

    else

        {

        User::Leave( KErrNotSupported );

        }

    }

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

// Get quality set associated with the given video codec MIME-type.

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

//

void CVideoQualitySelector::GetVideoQualitySetL( SVideoQualitySet& aSet, const TPtrC8& aVideoCodecMimeType )

    {

    TVideoQualitySet currentSet;

    TPtrC8 settingsMimeType;

    TInt i;

    for ( i = iQualityLevels->Count() - 1; i >= 0; i-- ) // searches from up to down to find higher quality first

        {

        iConfigManager->GetVideoQualitySet( currentSet, iQualityLevels->At( i ), KCameraDisplayID );

        settingsMimeType.Set(TPtrC8(currentSet.iVideoCodecMimeType));

        if ( settingsMimeType.MatchF( (const TDesC8& )aVideoCodecMimeType ) != KErrNotFound ) 

            {

            // Found a match

            MapQualitySet( aSet, currentSet );

            return;

            }

        }

    User::Leave( KErrNotSupported );

    }

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

// Copies the values from the source set to the target set.

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

//

void CVideoQualitySelector::MapQualitySet( SVideoQualitySet& aTargetSet, TVideoQualitySet& aSourceSet )

    {

    TInt i = 0;

    // Video aspect ratio

    // We don't have wide screen quality sets yet so this is always true

    aTargetSet.iVideoAspectRatioNormal = ETrue;

    // Video file format mime type    

    for ( i = 0; (i < KQSMaxShortStringLength - 1) && (i < KMaxStringLength); i++ )

        {

        aTargetSet.iVideoFileMimeType[i] = aSourceSet.iVideoFileMimeType[i];

        }

    aTargetSet.iVideoFileMimeType[i] = '\0';    // Add null termination

    // Video codec mime type    

    for ( i = 0; (i < KQSMaxLongStringLength - 1) && (i < KMaxStringLength); i++ )

        {

        aTargetSet.iVideoCodecMimeType[i] = aSourceSet.iVideoCodecMimeType[i];

        }

    aTargetSet.iVideoCodecMimeType[i] = '\0';   // Add null termination

    // Video picture width in pixels (luminance)

    aTargetSet.iVideoWidth = aSourceSet.iVideoWidth;

    // Video picture height in pixels (luminance)

    aTargetSet.iVideoHeight = aSourceSet.iVideoHeight;

    // Video framerate in fps

    aTargetSet.iVideoFrameRate = aSourceSet.iVideoFrameRate;

    // Video bitrate in bps

    aTargetSet.iVideoBitRate = aSourceSet.iVideoBitRate;

    // Random access point rate, in pictures per second

    aTargetSet.iRandomAccessRate = aSourceSet.iRandomAccessRate;

    // Audio codec FourCC

    if ( aSourceSet.iAudioFourCCType == TFourCC(' ', 'A', 'M', 'R') )

    {

        // AMR

        aTargetSet.iAudioFourCCType[0] = ' ';

        aTargetSet.iAudioFourCCType[1] = 'A';

        aTargetSet.iAudioFourCCType[2] = 'M';

        aTargetSet.iAudioFourCCType[3] = 'R';

        aTargetSet.iAudioFourCCType[4] = '\0';

    } 

    else if (aSourceSet.iAudioFourCCType == TFourCC(' ', 'A', 'A', 'C') )

    {

        // AAC

        aTargetSet.iAudioFourCCType[0] = ' ';

        aTargetSet.iAudioFourCCType[1] = 'A';

        aTargetSet.iAudioFourCCType[2] = 'A';

        aTargetSet.iAudioFourCCType[3] = 'C';

        aTargetSet.iAudioFourCCType[4] = '\0';

    } 

    else 

        aTargetSet.iAudioFourCCType[0] = '\0';

    // Audio bitrate in bps

    aTargetSet.iAudioBitRate = aSourceSet.iAudioBitRate;

    // Audio sampling rate in Hz

    aTargetSet.iAudioSamplingRate = aSourceSet.iAudioSamplingRate;

    // Number of audio channels

    aTargetSet.iAudioChannels = aSourceSet.iAudioChannels;

    }