/*

 * Copyright (c) 2009 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:  EDID data Handler class for HDMI Cable Status FSM.

 *

 */

#include <tvoutconfig.h>

#include <accpolhdmisink.h>

#include <accpolhdmiaudioformat.h>

#include <accpolhdmivideoformat.h>

#include <accpolhdmilatency.h>

#include <accpolhdmispeakerallocation.h>

#include <e32cmn.h>

#include <e32math.h>

#include <accessoriescrkeys.h>

#include <centralrepository.h>

#include "pdeconstants.h"

#include "tvoutconfigforhdmi.h"

#include "edidhandler.h"

#include "edidparserbase.h"

#include "cea861edidparser.h"

#include "multifinitestatemachine.h"

#include "trace.h"

#include "traceediddata.h"

const TReal K16d9 = 1.778;

const TReal K4d3 = 1.333;

const TInt KDefaultCEAMode = E640x480p59_94d60Hz4d3;

const TInt KDefaultCEAModeIndex = 0;

const TInt KDefaultDMTModeIndex = 3;

// Retry Delay for EDID access

const TInt KRetryDelay = 50 * 1000; // 50 milliseconds

// Maximum retry count for EDID access

const TInt KMaxRetryCount = 40;  // 40 * 50ms = 2 Seconds

const TUint16 KDefaultCEAModePhysImgAspRatioNr = 4;

const TUint16 KDefaultCEAModePhysImgAspRatioDr = 3;

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

// Symbian two-phased constructor

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

//

CEDIDHandler* CEDIDHandler::NewL( MFSMForBody& aFSM,

    CTVOutConfigForHDMI& aTVOutConfigForHDMI )

    {

    FUNC_LOG;

    CEDIDHandler* self = new ( ELeave ) CEDIDHandler(

            aFSM, aTVOutConfigForHDMI );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CEDIDHandler::~CEDIDHandler()

    {

    FUNC_LOG;

    Cancel();

    delete iDdcPortAccess;

    delete iDataBlockPtr;

    delete iExtensionParserPtr;

    delete iEdidParserPtr;

    iRetryTimer.Close();

    }

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

// FetchEDIDData

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

//

TInt CEDIDHandler::FetchEDIDData()

    {

    FUNC_LOG;

    TInt retVal( KErrNone );

    TUint apiVersion = iDdcPortAccess->ApiVersion();

    if( KDdcAccessVersion != apiVersion )

        {

        INFO_1( "iDdcPortAccess->ApiVersion() returned unsupported version != KDdcAccessVersion: %d", apiVersion );

        retVal = KErrNotSupported;

        }

    else

        {

        iRetryCounter = KErrNone;

        TInt err = KErrNone;

        TRAP( retVal , err = ReadEDIDDataL() );

        if ( err != KErrNone )

            {

            retVal = err;

            }

        }

    INFO_1( "CEDIDHandler::FetchEDIDData() retVal: %d", retVal );

    return retVal;

    }

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

// SetVideoParameters

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

//

TInt CEDIDHandler::SetVideoParameters()

    {

    FUNC_LOG;

    TInt retVal = KErrNone;

    RArray<TTvSettings> analogConfigs;

    RArray<THdmiDviTimings> hdmiConfigs;

    // Set video parameters

    INFO( "--------------------------------------------------------------------" );

    INFO( "SETTING CEA AND DMT TIMINGS:" );

    retVal = SetCeaModes( hdmiConfigs );

    ERROR( retVal, "Failed to set CEA modes" );

    if( KErrNone == retVal )

        {

        retVal = SetDmtModes( hdmiConfigs );

        ERROR( retVal, "Failed to set DMT modes" );

        INFO( "--------------------------------------------------------------------" );

        if( KErrNone == retVal )

            {

            // Filtering out the unsupported modes

            // Logical AND(Sink supported modes AND HW supported modes)

            INFO( "Filtering out the unsupported modes" );

            retVal = FilterAvailableTvConfigList( hdmiConfigs );

            ERROR( retVal, "Failed to filter the TV config list." );

            if( KErrNone == retVal )

                {

                retVal = iTVOutConfigForHDMI.SetAvailableTvConfigList( analogConfigs, hdmiConfigs );

                ERROR( retVal, "Failed to set available TV config list." );

                }            

            }

        }

    // Clean up

    hdmiConfigs.Close();

    analogConfigs.Close();

    return retVal;

    }

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

// GetEDIDDataL

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

//

void CEDIDHandler::ResetData()

    {

    FUNC_LOG;

    delete iDataBlockPtr;

    iDataBlockPtr = NULL;

    delete iEdidParserPtr;

    iEdidParserPtr = NULL;

    delete iExtensionParserPtr;

    iExtensionParserPtr = NULL;

	iCurrentBlock = 0;

	inbrOfExtensions = 0;

    }

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

// CreateHdmiSinkL

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

//

CAccPolHdmiSink* CEDIDHandler::CreateHdmiSinkL()

    {

    FUNC_LOG;

    CAccPolHdmiSink* hdmiSink( NULL );

    if( iExtensionParserPtr && iTVOutConfigForHDMI.GetTvOutConfig() )

        {

        hdmiSink = CAccPolHdmiSink::NewL(

            iExtensionParserPtr->BasicAudio(),

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    return hdmiSink;

    }

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

// CreateHdmiVideoFormatL

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

//

void CEDIDHandler::CreateHdmiVideoFormatL( RAccPolHdmiVideoFormatArray& aHdmiVideoFormatArray )

    {

    FUNC_LOG;

    // Active Video Format object values can be fetched from TvOutConfig interface.

    if( iEdidParserPtr && iTVOutConfigForHDMI.GetTvOutConfig() )

        {

        THdmiDviTimings hdmiDviTimings;

        TInt retVal = iTVOutConfigForHDMI.GetTvOutConfig()->GetConfig(

            hdmiDviTimings );

        if( KErrNone == retVal )

            {

            CAccPolHdmiVideoFormat* hdmiVideoFormat = CAccPolHdmiVideoFormat::NewLC();            

            hdmiVideoFormat->SetCeaFixedMode( hdmiDviTimings.iCeaMode );

            hdmiVideoFormat->SetDmtFixedMode( EDmtFixedModeNone );

            hdmiVideoFormat->SetPixelRepeat( hdmiDviTimings.iPixelRepeat );

            hdmiVideoFormat->SetInterlaced( hdmiDviTimings.iInterlaced );

            aHdmiVideoFormatArray.AppendL( hdmiVideoFormat );

            CleanupStack::Pop( hdmiVideoFormat );

            }

        else

            {

            User::Leave( retVal );

            }

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    }

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

// CreateHdmiLatencyL

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

//

void CEDIDHandler::CreateHdmiLatencyL( RAccPolHdmiLatencyArray& aHdmiLatencyArray )

    {

    FUNC_LOG;

    if( iEdidParserPtr && iExtensionParserPtr )

        {

        // Interlaced audio and video latency

        CAccPolHdmiLatency* hdmiLatency = CAccPolHdmiLatency::NewLC(

            HdmiLatency::KUidInterlacedLatency,

            iExtensionParserPtr->GetInterlacedAudioLatency(),

            iExtensionParserPtr->GetInterlacedVideoLatency() ); 

        aHdmiLatencyArray.AppendL( hdmiLatency );

        CleanupStack::Pop( hdmiLatency );

        // Progressive audio and video latency

        hdmiLatency = CAccPolHdmiLatency::NewLC(

            HdmiLatency::KUidLatency,

            iExtensionParserPtr->GetAudioLatency(),

            iExtensionParserPtr->GetVideoLatency() );

        aHdmiLatencyArray.AppendL( hdmiLatency );

        CleanupStack::Pop( hdmiLatency );

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    }

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

// CreateHdmiAudioFormatL

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

//

void CEDIDHandler::CreateHdmiAudioFormatL( RAccPolHdmiAudioFormatArray& aHdmiAudioFormatArray )

    {

    FUNC_LOG;

    if( iExtensionParserPtr )

        {

        if( iExtensionParserPtr->IsAudioDataBlockSupported() )

            {

            TCEA861AudioDataBlock

                * audioDataBlock =

                    iExtensionParserPtr->GetParsedInformation()->iShortAudioDescriptors;

            while( audioDataBlock )

                {

                    CAccPolHdmiAudioFormat* hdmiAudioFormat =

                        CAccPolHdmiAudioFormat::NewL();

                    CleanupStack::PushL( hdmiAudioFormat );

                    // Set audio format

                    TUid audioFormat;

                    // Map the audio format code defined in 

                    // cea861ediddatatypes.h to accpolhdmiaudioformat.h

                    switch ( audioDataBlock->iAudioFormatCode )

                        {

                        case KAudioFormatCodePCM:

                            {

                            audioFormat = HdmiAudioFormat::KUidFormatPCM16;

                            break;

                            }

                        case KAudioFormatCodeAC3:

                            {

                            audioFormat = HdmiAudioFormat::KUidFormatAC3;

                            break;

                            }

                        case KAudioFormatCodeMPEG1:

                            {

                            audioFormat = HdmiAudioFormat::KUidFormatMPEG1;

                            break;

                            }

                        case KAudioFormatCodeMP3:

                            {

                            audioFormat = HdmiAudioFormat::KUidFormatMP3;

                            break;

                            }

                        case KAudioFormatCodeMPEG2:

                            {

                            audioFormat = HdmiAudioFormat::KUidFormatMPEG2;

                            break;

                            }

                        case KAudioFormatCodeAACLC:

                            {

                            audioFormat = HdmiAudioFormat::KUidFormatAACLC;

                            break;

                            }

                        case KAudioFormatCodeDTS:

                            {

                            audioFormat = HdmiAudioFormat::KUidFormatDTS;

                            break;

                            }

                        case KAudioFormatCodeATRAC:

                            {

                            audioFormat = HdmiAudioFormat::KUidFormatATRAC;

                            break;

                            }

                        case KAudioFormatCodeDSD:

                            {

                            audioFormat = HdmiAudioFormat::KUidFormatDSD;

                            break;

                            }

                        case KAudioFormatCodeEAC3:

                            {

                            audioFormat = HdmiAudioFormat::KUidFormatEAC3;

                            break;

                            }

                        case KAudioFormatCodeDTSHD:

                            {

                            audioFormat = HdmiAudioFormat::KUidFormatDTSHD;

                            break;

                            }

                        case KAudioFormatCodeMLP:

                            {

                            audioFormat = HdmiAudioFormat::KUidFormatMLP;

                            break;

                            }

                        case KAudioFormatCodeDST:

                            {

                            audioFormat = HdmiAudioFormat::KUidFormatDST;

                            break;

                            }

                        case KAudioFormatCodeWMAPRO:

                            {

                            audioFormat = HdmiAudioFormat::KUidFormatWMAPRO;

                            break;

                            }

                        default:

                            {

                            audioFormat.iUid = KAudioFormatCodeNA;

                            break;

                            }

                        }

                    hdmiAudioFormat->SetAudioFormat( audioFormat ); // const TUid aAudioFormat,

                    // Set bit resolution

                    TUint32 bitResolution( CAccPolHdmiAudioFormat::EUnknownBitsPerSample );

                    if( audioDataBlock->iSupport24Bit )

                        {

                        bitResolution |= CAccPolHdmiAudioFormat::EBitsPerSample24;

                        }

                    if( audioDataBlock->iSupport20Bit )

                        {

                        bitResolution |= CAccPolHdmiAudioFormat::EBitsPerSample20;

                        }

                    if( audioDataBlock->iSupport16Bit )

                        {

                        bitResolution |= CAccPolHdmiAudioFormat::EBitsPerSample16;

                        }

                    hdmiAudioFormat->SetBitResolution( bitResolution ); // const TUint32 aBitResolution,

                    hdmiAudioFormat->SetMaxBitResolution( audioDataBlock->iMaxBitrate ); // const TUint32 aMaxBitResolution,

                    hdmiAudioFormat->SetChannelCount( audioDataBlock->iMaxChannels ); // const TUint32 aMaxChannelCount,

                    // Set sample frequency 

                    TUint32 samFreq( CAccPolHdmiAudioFormat::EUnknownFrequency );

                    if( audioDataBlock->iSupport192kHz )

                        {

                        samFreq

                            |= CAccPolHdmiAudioFormat::ESamplingFreq192KHz;

                        }

                    if( audioDataBlock->iSupport176kHz )

                        {

                        samFreq

                            |= CAccPolHdmiAudioFormat::ESamplingFreq176KHz;

                        }

                    if( audioDataBlock->iSupport96kHz )

                        {

                        samFreq

                            |= CAccPolHdmiAudioFormat::ESamplingFreq96KHz;

                        }

                    if( audioDataBlock->iSupport88kHz )

                        {

                        samFreq

                            |= CAccPolHdmiAudioFormat::ESamplingFreq88KHz;

                        }

                    if( audioDataBlock->iSupport48kHz )

                        {

                        samFreq

                            |= CAccPolHdmiAudioFormat::ESamplingFreq48KHz;

                        }

                    if( audioDataBlock->iSupport44kHz )

                        {

                        samFreq

                            |= CAccPolHdmiAudioFormat::ESamplingFreq44KHz;

                        }

                    if( audioDataBlock->iSupport32kHz )

                        {

                        samFreq

                            |= CAccPolHdmiAudioFormat::ESamplingFreq32KHz;

                        }

                    hdmiAudioFormat->SetSamFreq( samFreq ); // const TUint32 aSamFreq,

                    hdmiAudioFormat->SetFormatDependentValue( audioDataBlock->iAudioFormatCodeExtension ); // const TUint32 aFormatDependentValue

                    aHdmiAudioFormatArray.AppendL( hdmiAudioFormat );

                    CleanupStack::Pop( hdmiAudioFormat );

                    audioDataBlock = audioDataBlock->iNext;

                }

            }

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    }

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

// CreateHdmiAudioFormatL

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

//

CAccPolHdmiSpeakerAllocation* CEDIDHandler::CreateHdmiSpeakerAllocationL()

    {

    FUNC_LOG;

    CAccPolHdmiSpeakerAllocation* hdmiSpeakerAllocation( NULL );

    if( iExtensionParserPtr )

        {

        if( iExtensionParserPtr->IsSpeakerAllocationDataBlockSupported() )

            {

            TCEA861SpeakerAllocationData

                * speakerAllocationData =

                    &( iExtensionParserPtr->GetParsedInformation()->iSpeakerAllocationData );

            if( speakerAllocationData )

                {

                hdmiSpeakerAllocation

                    = CAccPolHdmiSpeakerAllocation::NewL( speakerAllocationData->FL_FR(), //const TBool aFrontSpeakers,

                        speakerAllocationData->RL_RR(), //const TBool aRearSpeakers,

                        speakerAllocationData->LFE(), //const TBool aLowFrequencyEffect,

                        speakerAllocationData->FC(), //const TBool aFrontCenter,

                        speakerAllocationData->FCH(), //const TBool aFrontCenterHigh,

                        speakerAllocationData->TC(), //const TBool aTopCenter,

                        speakerAllocationData->RC(), //const TBool aRearCenter,

                        speakerAllocationData->FLC_FRC(), //const TBool aFrontLeftRightCenter,

                        speakerAllocationData->RLC_RRC(), //const TBool aRearLeftRightCenter,

                        speakerAllocationData->FLW_FRW(), //const TBool aFrontWideSpeakers,

                        speakerAllocationData->FLH_FRH() //const TBool aFrontHighSpeakers         

                    );

                }

            }

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    return hdmiSpeakerAllocation;

    }

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

// GetHdcpSupportStatus

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

//

TInt CEDIDHandler::GetHdcpSupportStatus( TBool& aHdcpSupportStatus ) const

    {

    FUNC_LOG;

    TInt retVal( KErrNone );

    if( iTVOutConfigForHDMI.GetTvOutConfig() )

        {

        aHdcpSupportStatus

            = ( iTVOutConfigForHDMI.GetTvOutConfig() )->CopyProtectionStatus();

        }

    else

        {

        retVal = KErrNotFound;

        }

    return retVal;

    }

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

// RunL

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

//

void CEDIDHandler::RunL()

    {

    FUNC_LOG;

    switch ( iRequestID )

        {

        case EDdcReadRequest:

            {