/*

* Copyright (c) 2004 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:  The functions in this module implements the common behavior

*                for the audio encoder base class.

*

*/

// INCLUDE FILES

#include	"AdvancedAudioEncoder.h"

#include 	<mmfdatabuffer.h>

#include    "DebugMacros.h"

// CONSTANTS

const TInt KEmptyBuffer        = 1;

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

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

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

// might leave.

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

//

EXPORT_C CAdvancedAudioEncoder::CAdvancedAudioEncoder(TInt aPriority)

    :   CActive(aPriority),

    	iState(EIdle),

        iSharedBuffers(NULL),

        iMMFDevSound(NULL),

        iObserver(NULL)

    {

#ifdef _DEBUG

    RDebug::Print(_L("CAdvancedAudioEncoder::CAdvancedAudioEncoder()"));

#endif

    }

// Destructor

EXPORT_C CAdvancedAudioEncoder::~CAdvancedAudioEncoder()

	{

#ifdef _DEBUG

    RDebug::Print(_L("CAdvancedAudioEncoder::~CAdvancedAudioEncoder()"));

#endif

	}

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

// CAdvancedAudioEncoder::SetDevSound

// Sets the DevSound instance.

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

//

EXPORT_C void CAdvancedAudioEncoder::SetDevSound(

	CMMFDevSound& aDevSound )

	{

	iMMFDevSound = &aDevSound;

	}

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

// CAdvancedAudioEncoder::SetObserver

// Sets the observer instance.

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

//

EXPORT_C void CAdvancedAudioEncoder::SetObserver(

	MAdvancedAudioEncoderObserver& aObserver )

	{

	iObserver = &aObserver;

	}

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

// CAdvancedAudioEncoder::SetSinkBuffers

// Sets the sink buffer for encoding operations.

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

//

EXPORT_C void CAdvancedAudioEncoder::SetSinkBuffers(

	RPointerArray<CMMFDataBuffer>* aBuffers )

	{

	iSharedBuffers = aBuffers;

	}

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

// CAdvancedAudioEncoder::EmptyBuffer

// Request to fill the specified buffer with converted data.

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

//

EXPORT_C void CAdvancedAudioEncoder::EmptyBuffer(

	CMMFBuffer* aBuffer)

	{

#ifdef _DEBUG

//    RDebug::Print(_L("CAdvancedAudioEncoder::EmptyBuffer"));

#endif

	iBufferToEmpty = aBuffer; // store away the buffer

	iState = EEncoding;

	iRequest = KEmptyBuffer;

	Ready(KErrNone);

    SetActive();

	}

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

// CAdvancedAudioEncoder::Stop

// Stops encoding process.

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

//

EXPORT_C void CAdvancedAudioEncoder::Stop()

	{

	DP1(_L("CAdvancedAudioEncoder::Stop start iNextBuffer[%d]"), iNextBuffer);

    // There are 2 situations in which this function is called.

    // First when Devsound has already given a buffer to Encoder to be handled.

    // In which case, one needs to finish handling it by calling HandleEmptyBufferL().

    // Secondly, in a situation where the current shared buffer is being filled (partially full)

    // in which case, the buffer needs to be flushed

	if (iBufferToEmpty && (iState == EEncoding))

		{

	    DP1(_L("CAdvancedAudioEncoder::Stop setting last buffer[%d]"), iBufferToEmpty);

		iBufferToEmpty->SetLastBuffer(ETrue);

		TRAPD(err, HandleEmptyBufferL());

		if ( err )

			{

			DP1(_L("CAdvancedAudioEncoder::Stop err[%d]"), err);

			iState = EIdle;

			iObserver->SendEvent(TMMFEvent(KMMFEventCategoryPlaybackComplete, err));

			}		

        }

	else if (iNextBuffer)

	    { // a record controller may call stop before buffers are initialized

        if (iNextBuffer->Status() == EBeingFilled)

            {

            DP1(_L("CAdvancedAudioEncoder::Stop setting buffer[%d] to EFull"), iNextBuffer);

            iNextBuffer->SetStatus(EFull);

            DP1(_L("CAdvancedAudioEncoder::Stop emptying buffer[%d]"), iNextBuffer);

            iObserver->EmptyBuffer(iNextBuffer);

            }

	    }

	iState = EIdle;

    DP0(_L("CAdvancedAudioEncoder::Stop end"));

	}

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

// CAdvancedAudioEncoder::Ready

// Utility function to post a request complete

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

//

EXPORT_C void CAdvancedAudioEncoder::Ready(

    const TInt aStatus)

    {

    TRequestStatus* stat = &iStatus;

    User::RequestComplete(stat, aStatus);

    }

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

// CDevSoundAudioInput::NextSharedBufferL

// Determine the next available shared buffer from the pool of shared buffers

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

//

EXPORT_C void CAdvancedAudioEncoder::NextSharedBufferL()

	{

	if ( (*iSharedBuffers)[iSharedBufferIndex]->Status() == EAvailable )

		{

		iNextBuffer = (*iSharedBuffers)[iSharedBufferIndex];

		iSharedBufferIndex++;

		if ( iSharedBufferIndex == iSharedBuffers->Count() )

			{

			iSharedBufferIndex = 0;

			}

		}

	else

		{

#ifdef _DEBUG

	    RDebug::Print(_L("CAdvancedAudioEncoder::NextSharedBufferL - KErrOverflow"));

#endif

		User::Leave(KErrOverflow);

		}

	}

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

// CAdvancedAudioEncoder::RunL

// Invoke by the active scheduler when a request completes

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

//

EXPORT_C void CAdvancedAudioEncoder::RunL()

	{

#ifdef _DEBUG

//    RDebug::Print(_L("CAdvancedAudioEncoder::RunL"));

#endif

    switch(iRequest)

		{

		case KEmptyBuffer:

			if ( iState == EEncoding )

				{

				TRAPD(err, HandleEmptyBufferL());

				if ( err )

					{

#ifdef _DEBUG

					RDebug::Print(_L("CAdvancedAudioEncoder::RunL err[%d]"), err);

#endif

					// if error is encountered, the state is reset and event is generated and the recording is stopped.

					//err = KErrDied;

					iState = EIdle;

					iObserver->SendEvent(TMMFEvent(KMMFEventCategoryPlaybackComplete, err));

					}

				}

			break;

		default:

			break;

		};

	}

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

// CAdvancedAudioEncoder::DoCancel

// Cancels the current and any on going requests/tasks.

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

//

EXPORT_C void CAdvancedAudioEncoder::DoCancel()

    {

    }

// End of file