/*

 * 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 CEdidParserBase class.

 *

 */

#include "trace.h"

#include "edidparserbase.h"

#include "cea861edidparser.h"

#include "traceediddata.h"

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

// CEdidParserBase::CEdidParserBase

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

//

CEdidParserBase::CEdidParserBase() :

    iNumberOfExtensionBlocks( 0 )

    {

    FUNC_LOG;

    }

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

// CEdidParserBase::ConstructL

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

//

void CEdidParserBase::ConstructL( const TDesC8& aBinaryData )

    {

    FUNC_LOG;

    //Check if it is EDID data

    if( !IsEdidData( aBinaryData ) )

        {

        // Not EDID data

        User::Leave( KErrNotSupported );

        }

    iRawData = HBufC8::NewL( aBinaryData.Length() );

    TPtr8 rawPtr = iRawData->Des();

    rawPtr.Copy( aBinaryData );

    // Make a copy of base EDID data

    Mem::Copy( &iBaseEdidData, rawPtr.Ptr(), KEdidParserSizeOfEdidBlock );

    TRACE_EDID_DATA( *this );

    }

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

// CEdidParserBase::NewL

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

//

EXPORT_C CEdidParserBase* CEdidParserBase::NewL( const TDesC8& aBinaryData )

    {

    FUNC_LOG;

    CEdidParserBase* self = CEdidParserBase::NewLC( aBinaryData );

    CleanupStack::Pop( self );

    return self;

    }

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

// CEdidParserBase::NewLC

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

//

EXPORT_C CEdidParserBase* CEdidParserBase::NewLC( const TDesC8& aBinaryData )

    {

    FUNC_LOG;

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

    CleanupStack::PushL( self );

    self->ConstructL( aBinaryData );

    return self;

    }

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

// CEdidParserBase::CEdidParserBase

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

//

CEdidParserBase::~CEdidParserBase()

    {

    FUNC_LOG;

    delete iRawData;

    }

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

// CEdidParserBase::IsEdidData

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

//

EXPORT_C TBool CEdidParserBase::IsEdidData( const TDesC8& aBinaryData )

    {

    FUNC_LOG;

    INFO_1( "TBool CEdidParserBase::IsEdidData: aBinaryData length: %d", aBinaryData.Length() );

    TBool edidData = EFalse;

    // Check the length

    if( aBinaryData.Length() >= KEdidParserSizeOfEdidBlock )

        {

        for( int ii = 0; ii < KEdidParserSizeOfEdidHeader; ii++ )

            {

            if( aBinaryData[ii] != KBaseEdidHeader[ii] )

                {

                    // Not a valid EDID header

                ERROR_1( KErrArgument, "TBool CEdidParserBase::IsEdidData: Not a valid EDID header: %d", ii );

                return EFalse;

                }

            }

        edidData = ETrue;

        }

    return edidData;

    }

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

// CEdidParserBase::GetManufacturerCode

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

//

EXPORT_C void CEdidParserBase::GetManufacturerCode( TDes& aCode )

    {

    FUNC_LOG;

    if( aCode.Length() < KEdidParserManufacturerCodeLength )

        {

        //return;

        }

    TUint16 data = iBaseEdidData.iVendorProductInfo.iManufacturerCode;

    // Manufacturer codes are also called the ISA (Industry Standard Architecture)

    // Plug and Play Device Identifier (PNPID). They are based on 5 bit compressed

    // ASCII codes

    // bits 14-10: first letter (01h='A', 02h='B',..)

    // bits 9-5: second letter

    // bits 4-0: third letter

    // Convert to big endian

    data = ( ( data >> 8 ) & 0xff ) + ( ( data << 8 ) & 0xff00 );

    // Get ASCII codes

    TChar asciicode;

    asciicode = ( ( data >> 10 ) & 0x1f ) + 'A' - 1;

    aCode.Append( asciicode );

    asciicode = ( ( data >> 5 ) & 0x1f ) + 'A' - 1;

    aCode.Append( asciicode );

    asciicode = ( data & 0x1f ) + 'A' - 1;

    aCode.Append( asciicode );

    }

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

// CEdidParserBase::GetProductId

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

//

EXPORT_C void CEdidParserBase::GetProductId( TDes& aCode )

    {

    FUNC_LOG;

    aCode.AppendFormat( _L( "%04x" ), iBaseEdidData.iVendorProductInfo.iProductId );

    }

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

// CEdidParserBase::GetManufactureWeek

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

//

EXPORT_C TUint8 CEdidParserBase::GetManufactureWeek()

    {

    FUNC_LOG;

    return iBaseEdidData.iVendorProductInfo.iWeek;

    }

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

// CEdidParserBase::GetManufactureYear

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

//

EXPORT_C TUint16 CEdidParserBase::GetManufactureYear()

    {

    FUNC_LOG;

    // Year of manufacture stored in EDID data is "Year of Manufacture - 1990"

    return ( iBaseEdidData.iVendorProductInfo.iYear + KEdidBaseYear );

    }

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

// CEdidParserBase::GetVersion

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

//

EXPORT_C TUint8 CEdidParserBase::GetVersion()

    {

    FUNC_LOG;

    return iBaseEdidData.iVersion;

    }

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

// CEdidParserBase::GetRevision

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

//

EXPORT_C TUint8 CEdidParserBase::GetRevision()

    {

    FUNC_LOG;

    return iBaseEdidData.iRevision;

    }

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

// CEdidParserBase::GetVideoInputDefinition

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

//

EXPORT_C TUint8 CEdidParserBase::GetVideoInputDefinition()

    {

    FUNC_LOG;

    // Analog if bit 7 is 0. Digital if bit 7 is 1

    return ( ( iBaseEdidData.iVideoInputDefinition & KBit7 ) == KBit7 ? 1 : 0 );

    }

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

// CEdidParserBase::GetHorizontalScreenSize

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

//

EXPORT_C TUint8 CEdidParserBase::GetHorizontalScreenSize()

    {

    FUNC_LOG;

    return iBaseEdidData.iScreenSize.iHorizontal;

    }

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

// CEdidParserBase::GetVerticalScreenSize

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

//

EXPORT_C TUint8 CEdidParserBase::GetVerticalScreenSize()

    {

    FUNC_LOG;

    return iBaseEdidData.iScreenSize.iVertical;

    }

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

// CEdidParserBase::GetAspectRatioLandscape

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

//

EXPORT_C TUint8 CEdidParserBase::GetAspectRatioLandscape()

    {

	FUNC_LOG;

    // TEdidAspectRatio contains same values as TEdidScreenSize

    // Horizontal = Landscape 

    return iBaseEdidData.iScreenSize.iHorizontal;

    }

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

// CEdidParserBase::GetAspectRatioPortrait

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

//

EXPORT_C TUint8 CEdidParserBase::GetAspectRatioPortrait()

    {

	FUNC_LOG;

    // TEdidAspectRatio contains same values as TEdidScreenSize

    // Vertical = Portrait 

    return iBaseEdidData.iScreenSize.iVertical;

    }

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

// CEdidParserBase::IsAspectRationUsed

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

//

EXPORT_C TBool CEdidParserBase::IsAspectRatioUsed()

    {

    FUNC_LOG;

    // If byte 15h != 00h then byte 16h = Vertical Screen Size in cm.     (Range is 1 cm -> 255 cm)

    // If byte 15h == 00h then byte 16h = Aspect Ratio (Portrait)         (Range is 0.28 : 1 AR -> 0.99 : 1 AR)

    //

    // If byte 16h != 00h then byte 15h = Horizontal Screen Size in cm.   (Range is 1 cm -> 255 cm)

    // If byte 16h == 00h then byte 15h = Aspect Ratio (Landscape)        (Range is 1 : 1 AR -> 3.54 : 1 AR)

    if( ( iBaseEdidData.iScreenSize.iHorizontal == 0 )

        || ( iBaseEdidData.iScreenSize.iVertical == 0 ) )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CEdidParserBase::DisplayTransferCharacteristics

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

//

EXPORT_C TUint8 CEdidParserBase::DisplayTransferCharacteristics()

    {

    FUNC_LOG;

    // Stored Value = (GAMMA x 100) – 100

    return iBaseEdidData.iDisplayTransferCharasteristics;

    }

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

// CEdidParserBase::GetColorCoordinatesRedX

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

//

EXPORT_C TUint16 CEdidParserBase::GetColorCoordinatesRedX()

    {

    FUNC_LOG;

    // Address 19h bits 7&6 are RedX bits 1&0

    // Address 1Bh = RedX bits 9 to 2

    TUint16 ret = iBaseEdidData.iColorCharasteristics[2]; //1Bh

    ret = ret << 2;

    TUint8 add = 0;

    if( iBaseEdidData.iColorCharasteristics[0] & KBit7 )

        {

        add++;

        }

    add = add << 1;

    if( iBaseEdidData.iColorCharasteristics[0] & KBit6 )

        {

        add++;

        }

    ret += add;

    return ret;

    }

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

// CEdidParserBase::GetColorCoordinatesRedY

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

//

EXPORT_C TUint16 CEdidParserBase::GetColorCoordinatesRedY()

    {

    FUNC_LOG;

    // Address 19h bits 5&4 are RedY bits 1&0

    // Address 1Ch = RedY bits 9 to 2

    TUint16 ret = iBaseEdidData.iColorCharasteristics[3]; //1Ch

    ret = ret << 2;

    TUint8 add = 0;

    if( iBaseEdidData.iColorCharasteristics[0] & KBit5 )

        {

        add++;

        }

    add = add << 1;

    if( iBaseEdidData.iColorCharasteristics[0] & KBit4 )

        {

        add++;

        }

    ret += add;

    return ret;

    }

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

// CEdidParserBase::GetColorCoordinatesGreenX

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

//

EXPORT_C TUint16 CEdidParserBase::GetColorCoordinatesGreenX()

    {

    FUNC_LOG;

    // Address 19h bits 3&2 are GreenX bits 1&0

    // Address 1Dh = GreenX bits 9 to 2

    TUint16 ret = iBaseEdidData.iColorCharasteristics[4]; //1Dh

    ret = ret << 2;

    TUint8 add = 0;

    if( iBaseEdidData.iColorCharasteristics[0] & KBit3 )

        {

        add++;

        }

    add = add << 1;

    if( iBaseEdidData.iColorCharasteristics[0] & KBit2 )

        {

        add++;

        }

    ret += add;

    return ret;

    }

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

// CEdidParserBase::GetColorCoordinatesGreenY

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

//

EXPORT_C TUint16 CEdidParserBase::GetColorCoordinatesGreenY()

    {

    FUNC_LOG;

    // Address 19h bits 1&0 are GreenY bits 1&0

    // Address 1Eh = GreenY bits 9 to 2

    TUint16 ret = iBaseEdidData.iColorCharasteristics[5]; //1Dh

    ret = ret << 2;

    TUint8 add = 0;

    if( iBaseEdidData.iColorCharasteristics[0] & KBit1 )

        {

        add++;

        }

    add = add << 1;

    if( iBaseEdidData.iColorCharasteristics[0] & KBit0 )

        {

        add++;

        }

    ret += add;

    return ret;

    }

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

// CEdidParserBase::GetColorCoordinatesBlueX

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

//

EXPORT_C TUint16 CEdidParserBase::GetColorCoordinatesBlueX()

    {

    FUNC_LOG;

    // Address 1Ah bits 7&6 are BlueX bits 1&0

    // Address 1Fh = BlueX bits 9 to 2

    TUint16 ret = iBaseEdidData.iColorCharasteristics[6]; //1Fh

    ret = ret << 2;

    TUint8 add = 0;

    if( iBaseEdidData.iColorCharasteristics[1] & KBit7 )

        {

        add++;

        }

    add = add << 1;

    if( iBaseEdidData.iColorCharasteristics[1] & KBit6 )

        {

        add++;

        }

    ret += add;

    return ret;

    }

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

// CEdidParserBase::GetColorCoordinatesBlueY

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

//

EXPORT_C TUint16 CEdidParserBase::GetColorCoordinatesBlueY()

    {

    FUNC_LOG;

    // Address 1Ah bits 5&4 are BlueY bits 1&0

    // Address 20h = BlueY bits 9 to 2

    TUint16 ret = iBaseEdidData.iColorCharasteristics[7]; //20h

    ret = ret << 2;

    TUint8 add = 0;

    if( iBaseEdidData.iColorCharasteristics[1] & KBit5 )

        {

        add++;

        }

    add = add << 1;

    if( iBaseEdidData.iColorCharasteristics[1] & KBit4 )

        {

        add++;

        }

    ret += add;

    return ret;

    }

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

// CEdidParserBase::GetColorCoordinatesWhiteX

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

//

EXPORT_C TUint16 CEdidParserBase::GetColorCoordinatesWhiteX()

    {

    FUNC_LOG;

    // Address 1Ah bits 3&2 are WhiteX bits 1&0

    // Address 21h = WhiteX bits 9 to 2

    TUint16 ret = iBaseEdidData.iColorCharasteristics[8]; //21h

    ret = ret << 2;

    TUint8 add = 0;

    if( iBaseEdidData.iColorCharasteristics[1] & KBit3 )

        {

        add++;

        }

    add = add << 1;

    if( iBaseEdidData.iColorCharasteristics[1] & KBit2 )

        {

        add++;

        }

    ret += add;

    return ret;

    }

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

// CEdidParserBase::GetColorCoordinatesWhiteY

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

//

EXPORT_C TUint16 CEdidParserBase::GetColorCoordinatesWhiteY()

    {

    FUNC_LOG;

    // Address 1Ah bits 3&2 are WhiteX bits 1&0

    // Address 22h = WhiteX bits 9 to 2

    TUint16 ret = iBaseEdidData.iColorCharasteristics[9]; //22h

    ret = ret << 2;

    TUint8 add = 0;

    if( iBaseEdidData.iColorCharasteristics[1] & KBit1 )

        {

        add++;

        }

    add = add << 1;

    if( iBaseEdidData.iColorCharasteristics[1] & KBit0 )

        {

        add++;

        }

    ret += add;

    return ret;

    }

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

// CEdidParserBase::GetEstablishedTimings1

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

//

EXPORT_C TUint8 CEdidParserBase::GetEstablishedTimings1()