/*

* Copyright (c) 2007 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:  Class definition for the frame table functions.

 *

*/

//  INCLUDES

#include "FrameTable.h"

#include "DebugMacros.h"

#include <e32debug.h>

// CONSTANTS

const TInt KLowResPeriodMs = 1000; // approximate interval for entries stored in low res table is 1 sec

const TInt KHighResLengthMs = 5000; // approximate cummulative Length of the enteries stored in the high res table is 5 sec

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

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

// CFrameTable::CFrameTable

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CFrameTable::CFrameTable()

    {

    }

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

// CFrameTable::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CFrameTable::ConstructL()

    {

    DP0(_L("CFrameTable::ConstructL"));

    SetSourceReference(0,0);

    }

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

// CFrameTable::NewL

// Two-phased constructor.

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

//

EXPORT_C CFrameTable* CFrameTable::NewL()

    {

    DP0(_L("CFrameTable::NewL"));

    CFrameTable* self = new(ELeave) CFrameTable;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CFrameTable::~CFrameTable

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

//

EXPORT_C CFrameTable::~CFrameTable()

    {

    DP0(_L("CFrameTable::~CFrameTable"));

    iFrameTable.Close();

    iLowResFrameTable.Close();

    }

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

// CFrameTable::InitFrameTable

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

//

EXPORT_C TInt CFrameTable::InitFrameTable(TInt aSampleRate, TInt aSamplesPerFrame)

    { // this is only intended to be used at the very beginning of play since it clears the table

    DP2(_L("CFrameTable::InitFrameTable aSampleRate[%d], aSamplesPerFrame[%d]"), aSampleRate, aSamplesPerFrame);

    TInt status = KErrNone;

    ResetTable();

    iSampleRate = aSampleRate;

    iSamplesPerFrame = aSamplesPerFrame;

    if ((iSampleRate> 0) && (iSamplesPerFrame> 0))

        {

        iMsecPerFrame = (iSamplesPerFrame*1000)/iSampleRate;

        iFramesPerLowResInterval = ((iSampleRate*KLowResPeriodMs/1000) / iSamplesPerFrame);

        iLowResIntervalMs = (iSamplesPerFrame*1000*iFramesPerLowResInterval)/iSampleRate;

        }

    else

        {

        status = KErrArgument;

        }

    return status;

    }

//  0   1   2   3   4

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

// CFrameTable::SubmitTableEntry

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

//

// The table will always have contiguous frames in it.

EXPORT_C TInt CFrameTable::SubmitTableEntry(TUint aPos)

    {

    DP2(_L("CFrameTable::SubmitTableEntry aPos[%u], event pos[%u]"), aPos, iPosEventMs);

    TInt status = KErrNone;

    TBufRefPosEntry lastEntry;

    lastEntry.iPos = 0;

    TBufRefPosEntry bufRefPos;

    TUint frameNum;

    TUint pos = aPos+iOffset; // pos = absolute position (not including any header)

    if (aPos> 0)

        {

        iCurrentFrameCount++; // not a total frame count, but count from last reference set

        DP1(_L("CFrameTable::SubmitTableEntry iCurrentFrameCount[%u]"), iCurrentFrameCount);

        }

    TUint numEntries = iFrameTable.Count(); // this table will stay short - seeking backward resets it

    if (numEntries == 0)

        { // table gets reset if seeking in source

        bufRefPos.iPos = pos;

        bufRefPos.iFrameNum = iFrameNum; // first frame num is 0 so calculations for time 0 would point to frame 0

        status = iFrameTable.Append(bufRefPos);

        ASSERT(status == KErrNone);

        numEntries = 1;

        DP2(_L("CFrameTable::SubmitTableEntry init pos[%u] framenum[%u]"), pos, iFrameNum);

        }

    else

        {

        lastEntry = iFrameTable[numEntries-1];

        if (pos> lastEntry.iPos)

            {

            frameNum = lastEntry.iFrameNum + 1;

            bufRefPos.iPos = pos;

            bufRefPos.iFrameNum = frameNum;

            DP3 (_L ("CFrameTable::SubmitTableEntry, new entry iPos[%u], iFrameNum[%u], cnt[%u]"), bufRefPos.iPos, bufRefPos.iFrameNum, numEntries+1);

            status = iFrameTable.Append(bufRefPos);

            ASSERT(status == KErrNone);

            if(!iOkToShrink)

                {

                if( iFrameTable.Count() >= ( KHighResLengthMs / iMsecPerFrame ) )

                    {

                    DP0(_L("CFrameTable::SubmitTableEntry iOkToShrink = ETrue now"));

                    iOkToShrink = ETrue;

                    }

                }

            else

                {

                iFrameTable.Remove(0);

                }

            }

        else

            {

            status = KErrArgument;

            }

        }

    if (status == KErrNone)

        {

        SubmitLowResTableEntry(bufRefPos); // do this before events are detected below

        // total average bitrate - not instantaneous bitrate - used for duration calculation

        if (pos> iLastBytePos)

            { // don't recalculate if we rewind

            iLastBytePos = pos; // pos is absolute position - relative to the start of actual data content (not file start - no metadata) as set by the user. User maintains metadata offsets.

            TUint totalTimeMs = bufRefPos.iFrameNum*iMsecPerFrame; // total time in the table

                DP1(_L("CFrameTable::SubmitTableEntry totalTimeMs[%u]"), totalTimeMs);

            if (totalTimeMs> 0)

                {

                // cast calculation to TIn64 or it could lose precision

                TUint64 p = pos;

                p = p*8*1000;

                TUint64 t = totalTimeMs;

                iAvgBitrate = p/t;

                }

            }

        }

    // need to convert current position to time

    TInt currentTimeMs = iCurrentFrameCount*iMsecPerFrame + iTimeRefMs; // current time position being played

    DP3(_L("CFrameTable::SubmitTableEntry current calculated time ms[%u] iCurrentFrameCount[%u] timeref[%u]"), currentTimeMs, iCurrentFrameCount, iTimeRefMs);

    if (iPosEventMs> 0)

        { // used for seeking

        if (currentTimeMs >= iPosEventMs)

            {

            iPosEventMs = 0;

            DP0(_L("CFrameTable::SubmitTableEntry handle event pos reached"));

            iEventPos = pos;

            iObserver->HandleFrameTableEvent(EPosReached);

            }

        }

    if (iPlayWindowEndPosEventMs> 0)

        {

        if (currentTimeMs >= iPlayWindowEndPosEventMs)

            {

            iPlayWindowEndPosEventMs = 0;

            DP0(_L("CFrameTable::SubmitTableEntry handle event play window end pos reached"));

            iObserver->HandleFrameTableEvent(EPlayWindowEndPosReached);

            }

        }

    if (iIntervalEvent> 0)

        {

        if (iIntervalRef == 0)

            {

            iIntervalRef = currentTimeMs;

            }

        if ((currentTimeMs - iIntervalRef) >= iIntervalEvent)

            {

            iIntervalRef = currentTimeMs;

            iObserver->HandleFrameTableEvent(EDecodeInterval);

            }

        }

    DP1 (_L ("CFrameTable::SubmitTableEntry, avgBitRate[%u]"), iAvgBitrate);

    return status;

    }

TInt CFrameTable::SubmitLowResTableEntry(TBufRefPosEntry& aEntry)

    {

    TInt status = KErrNone;

    TBufRefPosEntry lastEntry;

    TUint numEntries = iLowResFrameTable.Count();

    if (numEntries == 0)

        {

        status = iLowResFrameTable.Append(aEntry);

        ASSERT(status == KErrNone);

        return status;

        }

    lastEntry = iLowResFrameTable[numEntries-1];

    ASSERT(aEntry.iFrameNum <= lastEntry.iFrameNum + iFramesPerLowResInterval);

    // note that 0 position table entries can be submitted to the table before it is initialized.

    // If this happens, iFramesPerLowResInterval would still be 0 and the same entry might be appended again

    // so we have a check to make sure that doesn't happen.

    if ((aEntry.iFrameNum == lastEntry.iFrameNum + iFramesPerLowResInterval) && 

        (iFramesPerLowResInterval != 0))

        {

        DP3 (_L ("CFrameTable::SubmitLowResTableEntry, new entry aEntry.iFrameNum[%u], lastEntry.iFrameNum[%u], iFramesPerLowResInterval[%u]"), aEntry.iFrameNum, lastEntry.iFrameNum, iFramesPerLowResInterval);

        DP3 (_L ("CFrameTable::SubmitLowResTableEntry, new entry iPos[%u], iFrameNum[%u], cnt[%u]"), aEntry.iPos, aEntry.iFrameNum, numEntries+1);

        status = iLowResFrameTable.Append(aEntry);

        ASSERT(status == KErrNone);

        }

    else

        {

        status = KErrArgument;

        }

    return status;

    }

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

// CFrameTable::FindFramePosFromTime