/*
* Copyright (c) 2007-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:  Reads metadata from rtp clip meta header
*
*/

#include "harvesterrtpmetadatareader.h"
#include "harvesterrtpplugin.h"
#include "harvesterlog.h"

_LIT( KTxtSpace, " ");

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

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
CHarvesterRtpMetaDataReader* CHarvesterRtpMetaDataReader::NewL( 
    const TDesC8* aFileBuffer  )
    {
    CHarvesterRtpMetaDataReader* self =
        new( ELeave ) CHarvesterRtpMetaDataReader( aFileBuffer );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CHarvesterRtpMetaDataReader::~CHarvesterRtpMetaDataReader()
    {
    WRITELOG( "CHarvesterRtpMetaDataReader::~CHarvesterRtpMetaDataReader()" );
    delete iMetaData;
    }

// ---------------------------------------------------------------------------
// Read details from meta header
// ---------------------------------------------------------------------------
//
void CHarvesterRtpMetaDataReader::GetClipDetailsL( 
    CHarvesterRtpClipDetails& aDetails )
    {
    WRITELOG( "CHarvesterRtpMetaDataReader::GetClipDetailsL()" );
    
    // Attributes
    TPtrC8 bytes( iDataPtr.Mid( KAttributesPoint, KIntegerBytes ) );
    TUint data( 0 );
    User::LeaveIfError( GetValue( bytes, data ) );

    // Recording quality 
    aDetails.iQuality = 
        ( TUint8 )( ( data >> KQualityFieldShift ) & KMaxTUint8 );
    //Recording ongoing 
    aDetails.iRecOngoing = 
        ( data >> KOngoingFlagShift ) & ETrue;
    // Recording completed 
    aDetails.iRecCompleted = 
        ( data >> KCompletedFlagShift ) & ETrue;
    //Recording failed 
    aDetails.iRecFailed = 
        ( data >> KFailedFlagShift ) & ETrue;
    //Parental rate
    aDetails.iParental =
         ( TUint8 )( ( data >> KParentalFieldShift ) & KMaxTUint8 );
    // Post rule    
    TUint8 postRule = 
        ( TUint8 )( ( data >> KPostRuleFieldShift ) & KMaxTUint8 );
    
    if ( postRule == KContentRightsLockToDevice )
        {
        aDetails.iPostRule = ETrue;
        }
    else
        {
        aDetails.iPostRule = EFalse;
        }
        
    // Duration
    TUint duration( 0 ); 
    TPtrC8 durationBytes ( iDataPtr.Mid( KDurationPoint, KIntegerBytes ) );
    User::LeaveIfError( GetValue( durationBytes, duration ) );
    duration /= 1000; //Convert to seconds 
    aDetails.iDuration = static_cast<TReal32>( duration );
    
    // Title
    GetProgramTitleL( aDetails.iTitle );
    }

// ---------------------------------------------------------------------------
// Default constructor
// ---------------------------------------------------------------------------
//
CHarvesterRtpMetaDataReader::CHarvesterRtpMetaDataReader(
    const TDesC8* aFileBuffer )
    : iMetaTotal( KErrNotFound ),
      iMetaData( NULL ),
      iDataPtr( 0, 0 ),
      iEsgDataPoint ( KErrNotFound ),
      iFileBuffer( aFileBuffer )
    {
    // None
    }

// ---------------------------------------------------------------------------
// 2nd phase constructor
// ---------------------------------------------------------------------------
//
void CHarvesterRtpMetaDataReader::ConstructL()
    {
    WRITELOG( "CHarvesterRtpMetaDataReader::ConstructL()" );
    TPtrC8 bytes;
    
    if ( iFileBuffer 
        && iFileBuffer->Length() > KIntegerBytes )
        {
        // Read whole meta area
        bytes.Set( iFileBuffer->Mid( KMetaLengthPoint, KIntegerBytes ) );
        }        

    TUint value ( 0 );
    User::LeaveIfError( GetValue( bytes, value ) );
    
    iMetaTotal = value;
    
    if ( iMetaTotal > KMaxMetaHeaderLength || iMetaTotal <= 0 )
        {
        //Length not reasonable, metadata corrupted
        WRITELOG( "CHarvesterRtpMetaDataReader - metadata corrupted, leave!" );
        User::Leave( KErrCorrupt );
        }

    iMetaData = HBufC8::NewL( iMetaTotal );
    *iMetaData = iFileBuffer->Mid( KMetaLengthPoint, iMetaTotal );

    iDataPtr.Set( iMetaData->Des() );
            
    // Check that all data exist in meta header
    if ( iDataPtr.Length() < iMetaTotal )
        {
        //Meta header corrupted
        WRITELOG( "CHarvesterRtpMetaDataReader - metaheader corrupted, leave!" );
        User::Leave( KErrCorrupt );
        }

    // ESG data point ( device info point + device info data )
    iEsgDataPoint = KDeviceInfoPoint + KStringLengthBytes +
                    iDataPtr[KDeviceInfoPoint];

    }

// -----------------------------------------------------------------------------
// Reads data with length info of meta header from the clip
// -----------------------------------------------------------------------------
//
void CHarvesterRtpMetaDataReader::ReadStringDataL( 
    const TInt aPosition, 
    TPtrC8& aData )
    {
    WRITELOG( "CHarvesterRtpMetaDataReader::ReadStringDataL()" );

    if ( aPosition < 0 
        || aPosition > iDataPtr.Length() )
        {
        WRITELOG( "CHarvesterRtpMetaDataReader - KErrArgument, leave!" );
        User::Leave( KErrArgument );
        }

    const TInt len( iDataPtr[aPosition] );
    
    if ( len < 0 
        || len > TInt( KMaxTUint8 ) )
        {
        WRITELOG( "CHarvesterRtpMetaDataReader - KErrCorrupt, leave!" );
        User::Leave( KErrCorrupt );
        }
        
    aData.Set( iDataPtr.Mid( aPosition + KStringLengthBytes, len ) );
    }

// -----------------------------------------------------------------------------
// Get value
// -----------------------------------------------------------------------------
//
TInt CHarvesterRtpMetaDataReader::GetValue( 
    const TDesC8& aBytes, 
    TUint& aValue )
    {
    WRITELOG( "CHarvesterRtpMetaDataReader::GetValue()" );
    if ( aBytes.Length() >= KIntegerBytes )
        {
        aValue = ( TUint )( aBytes[0] );
        aValue <<= 8;
        aValue |= ( TUint )( aBytes[1] );
        aValue <<= 8;
        aValue |= ( TUint )( aBytes[2] );
        aValue <<= 8;
        aValue |= ( TUint )( aBytes[3] );
        return KErrNone;
        }

    WRITELOG( "CHarvesterRtpMetaDataReader::GetValue() : KErrUnderFlow!" );
    return KErrUnderflow;
    }

// -----------------------------------------------------------------------------
// Get and format clip title
// -----------------------------------------------------------------------------
//
void CHarvesterRtpMetaDataReader::GetProgramTitleL( TDes& aTitle )
    {
    WRITELOG( "CHarvesterRtpMetaDataReader::GetProgramTitleL()" );
    
    User::LeaveIfError( iEsgDataPoint );
    aTitle.Zero();

    TUint32 totalLength( 0 );
    TPtrC8 service;
    TPtrC8 program;
    
    ReadStringDataL( iEsgDataPoint, service );
    
    totalLength += service.Length();
    totalLength += KSpaceLength;

    // Program name
    const TInt progPos( iEsgDataPoint + KStringLengthBytes + service.Length() );
    ReadStringDataL( progPos, program );
    
    totalLength += program.Length();

    HBufC8* title = HBufC8::NewLC( totalLength );
    title->Des().Append( service.Ptr(), service.Length() );
    title->Des().Append( KTxtSpace );
    title->Des().Append( program.Ptr(), program.Length() ); 
    
    if ( totalLength > KMaxProgramTitle ) 
        {
        //Make title fit in max title length
        TPtrC8 titlePtr( *title );
        aTitle.Copy( titlePtr.Mid( 0 , KMaxProgramTitle ) );
        }
    else
        {
        aTitle.Copy( *title );
        }
                
    CleanupStack::PopAndDestroy( title );
    }