/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "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:

* Ixonos Plc

*

* Description: 

*

*/

// INCLUDE FILES

// System includes

// User includes

#include <e32math.h> 

#include "SampleArrayHandler.h"

#include "VideoEditorCommon.h"      // Video Editor UID

#include "VideoEditorDebugUtils.h"

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

CSampleArrayHandler* CSampleArrayHandler::NewL()

    {

    CSampleArrayHandler* self = CSampleArrayHandler::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

CSampleArrayHandler* CSampleArrayHandler::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

void CSampleArrayHandler::ConstructL()

    {

    }

CSampleArrayHandler::CSampleArrayHandler()

    {

    }

CSampleArrayHandler::~CSampleArrayHandler()

    {

    delete [] iVisualization;

    }

void CSampleArrayHandler::SetVisualizationArray(TInt8* aVisualization, TInt aResolution)

    {

    LOG( KVideoEditorLogFile, "CSampleArrayHandler::SetVisualizationArray, In" );

    iVisualization = aVisualization;

    iVisualizationSize = aResolution;

    // for testing

    /*	for (TInt i = 0; i < iVisualizationSize; i++)

    {

    if (i == 127)	

    iVisualization[i] = i - 127;

    else

    iVisualization[i] = i;				

    }

     */

    TInt8 temp = 0; // help variable used in finding the biggest current sample value

    for ( TInt i = 0; i < iVisualizationSize; i++ )

        {

        if ( iVisualization[i] > temp )

            {

            temp = iVisualization[i];

            }

        //LOGFMT2(KVideoEditorLogFile, "CSampleArrayHandler::SetVisualizationArray, SAMPLE[%d]:%d", i, iVisualization[i]);

        }

    iMaxSample = temp;

    iScaleFactor = 1.0; // TReal

    LOG( KVideoEditorLogFile, "CSampleArrayHandler::SetVisualizationArray, Out" );

    }

void CSampleArrayHandler::ScaleAudioVisualization( const TInt8& aNewMaxValue )

    {

    if ( iVisualization && ( aNewMaxValue != iMaxSampleInCurrentScale ))

        {

        iMaxSampleInCurrentScale = aNewMaxValue;

        if ( !Math::IsZero(( TReal64 )iMaxSampleInCurrentScale ))

            {

            iScaleFactor = ( TReal64 )iMaxSampleInCurrentScale / ( TReal64 )iMaxSample; 

            }

        /*

        //for testing

        if (1 > coeff)

        {				

        for (TInt i = 0; i < iVisualizationSize; i++)

        {

        LOGFMT(KVideoEditorLogFile, "before scaling:%d", iVisualization[i]);				

        iVisualization[i] *= coeff;		

        LOGFMT(KVideoEditorLogFile, "after scaling:%d", iVisualization[i]);

        }					

        }*/

        }

    }

TInt8 CSampleArrayHandler::Sample( const TInt aIndex )const

    {

    // must be scaled down in order to fit into screen			

    if ( iScaleFactor < 1 )

        {

        return (( iVisualization[aIndex]* 1000 )*( iScaleFactor* 1000 )) / 1000000;

        }

    else

        {

        return iVisualization[aIndex];

        }

    }

TInt CSampleArrayHandler::Size()const

    {

    return iVisualizationSize;

    }

TInt CSampleArrayHandler::CurrentPoint()const

    {

    return iCurrentIndex;

    }

void CSampleArrayHandler::SetCurrentPoint(const TTimeIntervalMicroSeconds& aCurrentTime)

    {

    iCurrentTime = aCurrentTime;

    iCurrentIndex = ( iCurrentTime.Int64() / 1000 ) / KAudioSampleInterval;

    }

void CSampleArrayHandler::SetCutInPoint(const TTimeIntervalMicroSeconds& aCutInTime)

    {

    iCutInTime = aCutInTime;

    iCutInSampleIndex = ( iCutInTime.Int64() / 1000 ) / KAudioSampleInterval;

    }

void CSampleArrayHandler::SetCutOutPoint(const TTimeIntervalMicroSeconds& aCutOutTime)

    {

    iCutOutTime = aCutOutTime;

    iCutOutSampleIndex = ( iCutOutTime.Int64() / 1000 ) / KAudioSampleInterval;

    }

TBool CSampleArrayHandler::SampleCutted( const TInt aIndex )const

    {

    return ( iCutInSampleIndex < aIndex ) && ( aIndex < iCutOutSampleIndex );

    }

// End of File