/*

 * Copyright (c) 2008,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:

 * Implementation of CCea861EdidParser class.

 *

 */

#include "cea861edidparser.h"

#include "trace.h"

const TInt KIEEERegistrationID = 0x00000C03;

// ======== LOCAL FUNCTIONS ========

// ======== MEMBER FUNCTIONS ========

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

// CCea861EdidParser::CCea861EdidParser

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

//

CCea861EdidParser::CCea861EdidParser() :

    iParsed( EFalse ),

    iAudioDataBlockSupported( EFalse ),

    iVideoDataBlockSupported( EFalse ),

    iVendorSpecificDataBlockSupported( EFalse ),

    iSpeakerAllocationDataBlockSupported( EFalse )

    {

    FUNC_LOG;

    }

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

// CEdidParserBase::ConstructL

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

//

void CCea861EdidParser::ConstructL( const TExtDataBlock& aData )

    {

    FUNC_LOG;

    iParsedInfo = CCea861ExtEdidInformation::NewL();

    ParseExtensionBlockL( aData );

    }

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

// CEdidParserBase::NewL

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

//

EXPORT_C CCea861EdidParser* CCea861EdidParser::NewL( const TExtDataBlock& aData )

    {

    FUNC_LOG;

    CCea861EdidParser* self = CCea861EdidParser::NewLC( aData );

    CleanupStack::Pop( self );

    return self;

    }

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

// CEdidParserBase::NewLC

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

//

EXPORT_C CCea861EdidParser* CCea861EdidParser::NewLC( const TExtDataBlock& aData )

    {

    FUNC_LOG;

    CCea861EdidParser* self = new ( ELeave ) CCea861EdidParser();

    CleanupStack::PushL( self );

    self->ConstructL( aData );

    return self;

    }

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

// CCea861EdidParser::~CCea861EdidParser

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

//

CCea861EdidParser::~CCea861EdidParser()

    {

    FUNC_LOG;

    delete iParsedInfo;

    }

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

// CCea861EdidParser::ParseExtensionBlockL

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

//

EXPORT_C TInt CCea861EdidParser::ParseExtensionBlockL( const TExtDataBlock& aData )

    {

    FUNC_LOG;

    TInt err( KErrNone );

    TInt index( 0 );

    // Check first byte to see if tag is 0x2.

    // If not return error.

    if( aData[index] != KBit1 )

        {

        return KErrNotSupported;

        }

    iParsedInfo->iExtensionTag = aData[index];

    index++;

    // Check revision

    iParsedInfo->iRevision = aData[index];

    index++;

    switch( iParsedInfo->iRevision )

        {

        case 1:

            err = ReadCeaVersion1L( aData, index );

            break;

        case 2:

            err = ReadCeaVersion2L( aData, index );

            break;

        case 3:

            err = ReadCeaVersion3L( aData, index );

            break;

        default:

            err = KErrNotSupported;

            break;

        }

    if( err == KErrNone )

        {

        iParsed = ETrue;

        }

    return err;

    }

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

// CCea861EdidParser::isExtensionBlockParsed

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

//

EXPORT_C TBool CCea861EdidParser::IsExtensionBlockParsed()

    {

    FUNC_LOG;

    return iParsed;

    }

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

// CCea861EdidParser::GetVIC

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

//

EXPORT_C TInt8 CCea861EdidParser::GetVIC( TUint8 aNumber )

    {

    FUNC_LOG;

    if( !iParsed )

        {

        return KErrNotFound;

        }

    if( IsVideoDataBlockSupported() )

        {

        return KErrNotFound;

        }

    if( iParsedInfo->iShortVideoDescriptors )

        {

        TCEA861VideoDataBlock* cur = iParsedInfo->iShortVideoDescriptors;

        TUint8 count = 0;

        while( cur )

            {

            if( cur->iNative )

                {

                if( count == aNumber )

                    {

                    return cur->iVIC;

                    }

                count++;

                }

            cur = cur->iNext;

            }

        }

    return KErrNotFound;

    }

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

// CCea861EdidParser::Underscan

//

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

//

EXPORT_C TBool CCea861EdidParser::Underscan()

    {

    FUNC_LOG;

    if( iParsedInfo->UnderscanDataSupported() )

        {

        return iParsedInfo->iUnderscan;

        }

    return EFalse;

    }

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

// CCea861EdidParser::BasicAudio

//

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

//

EXPORT_C TBool CCea861EdidParser::BasicAudio()

    {

    FUNC_LOG;

    if( iParsedInfo->AudioDataSupported() )

        {

        return iParsedInfo->iAudio;

        }

    return EFalse;

    }

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

// CCea861EdidParser::YCbCr444

//

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

//

EXPORT_C TBool CCea861EdidParser::YCbCr444()

    {

    FUNC_LOG;

    if( iParsedInfo->YCbCr444DataSupported() )

        {

        return iParsedInfo->iYCbCr444;

        }

    return EFalse;

    }

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

// CCea861EdidParser::YCbCr422

//

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

//

EXPORT_C TBool CCea861EdidParser::YCbCr422()

    {

    FUNC_LOG;

    if( iParsedInfo->YCbCr422DataSupported() )

        {

        return iParsedInfo->iYCbCr422;

        }

    return EFalse;

    }

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

// CCea861EdidParser::TotalNumberOfNativeFormats

//

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

//

EXPORT_C TUint8 CCea861EdidParser::TotalNumberOfNativeFormats()

    {

    FUNC_LOG;

    return iParsedInfo->TotalNumberOfNativeFormats();

    }

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

// CCea861EdidParser::IsAudioDataBlockSupported

//

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

//

EXPORT_C TBool CCea861EdidParser::IsAudioDataBlockSupported()

    {

    FUNC_LOG;

    return iAudioDataBlockSupported;

    }

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

// CCea861EdidParser::IsVideoDataBlockSupported

//

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

//

EXPORT_C TBool CCea861EdidParser::IsVideoDataBlockSupported()

    {

    FUNC_LOG;

    return iVideoDataBlockSupported;

    }

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

// CCea861EdidParser::IsVideoDataBlockSupported

//

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

//

EXPORT_C TBool CCea861EdidParser::IsVendorSpecificDataBlockSupported()

    {

    FUNC_LOG;

    return iVendorSpecificDataBlockSupported;

    }

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

// CCea861EdidParser::HasIEEERegistration

//

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

//

EXPORT_C TBool CCea861EdidParser::HasIEEERegistration()

    {

    FUNC_LOG;

	if ( iVendorSpecificDataBlockSupported && iParsedInfo->iVendorSpecificData &&

		iParsedInfo->iVendorSpecificData->iIEEE24bitRegistrationIdentifier == KIEEERegistrationID )

		{

		return ETrue;

		}

    return EFalse;

    }

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

// CCea861EdidParser::GetParsedInformation

//

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

//

EXPORT_C CCea861ExtEdidInformation* CCea861EdidParser::GetParsedInformation()

    {

    FUNC_LOG;

    return iParsedInfo;

    }

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

// CCea861EdidParser::IsSpeakerAllocationDataBlockSupported

//

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

//

EXPORT_C TBool CCea861EdidParser::IsSpeakerAllocationDataBlockSupported()

    {

    FUNC_LOG;

    return iSpeakerAllocationDataBlockSupported;

    }

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

// CCea861EdidParser::GetVideoLatency

//

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

//

EXPORT_C TUint8 CCea861EdidParser::GetVideoLatency()

    {

    FUNC_LOG;

    // Video latency is kept in Vendor Specific Data Block according to

    // HDMISpecification13a.pdf, table 8-6

    TUint8 latency = 0;

    TCEA861VendorSpecificDataBlock* data = iParsedInfo->iVendorSpecificData;

    if( ( !data ) || ( !IsVendorSpecificDataBlockSupported() ) )

        {

        return latency;

        }

    TCEA861VendorSpecificDataBlockPayload* cur = data->iVendorSpecificPayloadStart;

    // According to HDMI spec table 8-6,  index of video latency is 9

    // Start counting from index 4 

    for( TInt ii = 0; ii < 6; ii++ )

        {

        if( !cur )

            {

            break;

            }

        // Byte 8

        else if( ii == 4 )

            {

            // Check if latency field bits are present

            if( !LatencyFieldsPresent( cur->iData ) )

                {

                // Latency fields are not present

                break;

                }

            }

        // Byte 9

        else if( ii == 5 )

            {

            // Get Video_latency byte

            latency = cur->iData;

            }

        cur = cur->iNext;

        }

    // Convert latency in to ms

    latency = LatencyInMs( latency );

    return latency;

    }

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

// CCea861EdidParser::GetAudioLatency

//

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

//

EXPORT_C TUint8 CCea861EdidParser::GetAudioLatency()

    {

    FUNC_LOG;

    // Audio latency is kept in Vendor Specific Data Block according to

    // HDMISpecification13a.pdf, table 8-6

    TUint8 latency = 0;

    TCEA861VendorSpecificDataBlock* data = iParsedInfo->iVendorSpecificData;

    if( ( !data ) || ( !IsVendorSpecificDataBlockSupported() ) )

        {

        return latency;

        }

    TCEA861VendorSpecificDataBlockPayload* cur = data->iVendorSpecificPayloadStart;

    // According to HDMI spec table 8-6,  index of audio latency is 10

    // Start counting from index 4 

    for( TInt ii = 0; ii < 7; ii++ )

        {

        if( !cur )

            {

            break;

            }

        // Byte 8

        else if( ii == 4 )

            {

            // Check if latency field bits are present

            if( !LatencyFieldsPresent( cur->iData ) )

                {

                // Latency fields are not present

                break;

                }

            }

        // Byte 10

        else if( ii == 6 )

            {

            latency = cur->iData;

            }

        cur = cur->iNext;

        }

    // Convert latency in to ms

    latency = LatencyInMs( latency );

    return latency;

    }

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

// CCea861EdidParser::GetInterlacedVideoLatency

//

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

//

EXPORT_C TUint8 CCea861EdidParser::GetInterlacedVideoLatency()

    {

    // Video latency is kept in Vendor Specific Data Block according to

    // HDMISpecification13a.pdf, table 8-6

    TUint8 latency = 0;

    TCEA861VendorSpecificDataBlock* data = iParsedInfo->iVendorSpecificData;

    if( ( !data ) || ( !IsVendorSpecificDataBlockSupported() ) )

        {

        return latency;

        }

    TCEA861VendorSpecificDataBlockPayload* cur = data->iVendorSpecificPayloadStart;

    // According to HDMI spec table 8-6,  index of video latency is 9 or 11

    // Start counting from index 4

    // Start index == 4, video latency == 9 (4 + 5)

    TInt videoLatencyByte = 5;

    for( TInt ii = 0; ii < 8; ii++ )

        {

        if( !cur )

            {

            break;

            }

        // Byte 8

        else if( ii == 4 )

            {

            // Check if latency field bits are present

            TUint8 byte8 = cur->iData;

            if( InterlacedLatencyFieldsPresent( byte8 ) )

                {

                // Interlaced latency fields are present

                // Start index == 4, interlaced video latency == 11 (4 + 7)

                videoLatencyByte = 7;

                }

            else if( !LatencyFieldsPresent( byte8 ) )

                {

                // Latency fields are not present

                break;

                }

            }

        // Byte 9 or Byte 11

        else if( ii == videoLatencyByte )

            {

            // Get Video_latency byte

            latency = cur->iData;

            }

        cur = cur->iNext;

        }

    // Convert latency in to ms

    latency = LatencyInMs( latency );

    return latency;

    }

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

// CCea861EdidParser::GetInterlacedAudioLatency

//

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

//

EXPORT_C TUint8 CCea861EdidParser::GetInterlacedAudioLatency()