/*

* 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:  Audio Stream Test Component

*

*/

#include "InputStreamer.h"

const TInt CInputStreamer::KRecorderActionStop = 3;

const TInt CInputStreamer::KSchedulerStop = 4;

CInputStreamer::CInputStreamer(CStifLogger *aLogger)

	:	CStreamerBase(aLogger) ,  iAlreadyClosed(EFalse) , iRecording(EFalse)

{

}

void CInputStreamer::ConstructL()

{

    iMdaAudioInputStream = CMdaAudioInputStream::NewL(*this);

}

CInputStreamer* CInputStreamer::NewL(CStifLogger *aLogger, TInt aId)

{

	CInputStreamer *_self = NewLC(aLogger, aId);

	CleanupStack::Pop(_self);

	return _self;

}

CInputStreamer* CInputStreamer::NewLC(CStifLogger *aLogger, TInt aId)

{

	CInputStreamer *_self = new(ELeave)CInputStreamer(aLogger);

	CleanupStack::PushL(_self);

	_self->ConstructL();

	_self->SetId(aId);

	return _self;

}

void CInputStreamer::ConstructL(TInt aPriority, TMdaPriorityPreference aPref)

{

	iMdaAudioInputStream = CMdaAudioInputStream::NewL(*this, aPriority, aPref);

}

CInputStreamer* CInputStreamer::NewL(TInt aPriority, TMdaPriorityPreference aPref,

                                     CStifLogger *aLogger, TInt aId)

{

	CInputStreamer *_self = NewLC(aPriority, aPref, aLogger, aId);

	CleanupStack::Pop(_self);

	return _self;

}

CInputStreamer* CInputStreamer::NewLC(TInt aPriority, TMdaPriorityPreference aPref,

                                      CStifLogger *aLogger, TInt aId)

{

	CInputStreamer *_self = new(ELeave)CInputStreamer(aLogger);

	CleanupStack::PushL(_self);

	_self->ConstructL(aPriority, aPref);

	_self->SetId(aId);

	return _self;

}

CInputStreamer::~CInputStreamer()

{

	delete iMdaAudioInputStream;

	delete iSettings;

	TInt Before = iBuffers.Count();

	iBuffers.ResetAndDestroy();

	iBuffers.Close();

	iLogger->Log(_L("%d) Items in buffer (%d), there were (%d)") , iId, iBuffers.Count() , Before);

	iMdaAudioInputStream = NULL;

}

void CInputStreamer::SetAudioPropertiesL(TInt aSampleRate, TInt aChannels)

{

	iLogger->Log(_L("%d) CInputStreamer::SetAudioPropertiesL(rate=%d, chan=%d)") , iId, aSampleRate, aChannels);

	iMdaAudioInputStream->SetAudioPropertiesL(aSampleRate, aChannels);

}

void CInputStreamer::SetPriority(TInt aPriority, TMdaPriorityPreference aPref)

{

	iLogger->Log(_L("%d) CInputStreamer::SetPriority(%d, %d)") , iId, aPriority, aPref);

	iMdaAudioInputStream->SetPriority(aPriority, aPref);

}

TInt CInputStreamer::GetBalanceL()

{

	TInt retVal = iMdaAudioInputStream->GetBalanceL();

	iLogger->Log(_L("%d) CInputStreamer::GetBalanceL() , result=(%d)") , iId, retVal);

	return retVal;

}

void CInputStreamer::SetBalanceL(TInt aBalance)

{

	iLogger->Log(_L("%d) CInputStreamer::SetBalanceL(%d)") , iId, aBalance);

	iMdaAudioInputStream->SetBalanceL(aBalance);

}

void CInputStreamer::SetGain(const TInt aNewGain) { iMdaAudioInputStream->SetGain(aNewGain); }

TInt CInputStreamer::GetMaxGain() { return iMdaAudioInputStream->MaxGain(); }

TInt CInputStreamer::GetGain() { return iMdaAudioInputStream->Gain(); }

void CInputStreamer::Stop()

{

	iLogger->Log(_L("%d) CInputStreamer::Stop()") , iId);

	iRecording=EFalse;

	iState=EStopped;

	iMdaAudioInputStream->Stop();

}

TFourCC CInputStreamer::GetDataType()

{

	TFourCC retVal = iMdaAudioInputStream->DataType();

	iLogger->Log(_L("%d) CInputStreamer::GetDataType() , result=(%d)") , iId, retVal.FourCC());

	return retVal;

}

void CInputStreamer::SetDataTypeL(TFourCC aDataType)

{

	iLogger->Log(_L("%d) CInputStreamer::SetDataTypeL(%d)") , iId, aDataType.FourCC());

	iMdaAudioInputStream->SetDataTypeL(aDataType);

}

void CInputStreamer::GetSupportedBitRatesL(RArray<TInt>& aSupportedBitRates)

{

    iMdaAudioInputStream->GetSupportedBitRatesL(aSupportedBitRates);

}

TInt CInputStreamer::BitRateL()

{

    TInt retVal = iMdaAudioInputStream->BitRateL();

	iLogger->Log(_L("%d) CInputStreamer::BitRateL() , result=(%d)") , iId, retVal);

	return retVal;

}

void CInputStreamer::SetBitRateL(TInt aBitRate)

{

	iLogger->Log(_L("%d) CInputStreamer::SetBitRateL(%d)") , iId, aBitRate);

	iMdaAudioInputStream->SetBitRateL(aBitRate);

}

RPointerArray<TDes8> &CInputStreamer::GetBuffers()

{

	return iBuffers;

}

void CInputStreamer::StartRecording()

{

	iLogger->Log(_L("CInputStreamer::StartRecording()") );

	iMdaAudioInputStream->Open(iSettings);

}

void CInputStreamer::Exit(TInt aExitCode)

{

	iLogger->Log(_L("%d) CInputStreamer::Exit(%d)"), iId, aExitCode);

	iFinalError = aExitCode;

	if (!iAlreadyClosed)

	{

		iAlreadyClosed=ETrue;

		CActiveScheduler::Stop();

	    iLogger->Log(_L("%d) Stop Active Scheduler"), iId);

	}

}

void CInputStreamer::SetSettings(TMdaPackage *aSettings)

{

	iSettings=aSettings;

}

void CInputStreamer::MaiscOpenComplete(TInt aError)

{

	iLogger->Log(_L("%d) CInputStreamer::MaiscOpenComplete(%d)") , iId, aError);

	iLogger->Log(_L("Error=(%d)") , aError);

	if (aError || iExitAfterOpen)

		{

		Exit(aError);

		return;

		}

	iState=ERecording;

	if (iState == EClosed)

		{

		iState = EFirstOpenSuccessful;

		}

	else

		{

		iState = EOpen;

		}

	iLogger->Log(_L("%d) MaiscOpenComplete: Bytes (%d), Position (%d)") , iId, iMdaAudioInputStream->GetBytes() ,

	                                                                      iMdaAudioInputStream->Position() );

	iRecording=ETrue;

	++iCurrentBuffer;

	TDes8 *tmp = new(ELeave)TBuf8<KBufferSize>;

	tmp->SetMax();

	CleanupStack::PushL(tmp);

	if (iBuffers.Append(tmp)) { iLogger->Log(_L("Error appending in openComplete")); }

	CleanupStack::Pop(tmp);

	iLogger->Log(_L("%d) CInputStreamer::MaiscOpenComplete(), adding buffer #(%d)") , iId, iCurrentBuffer);

	iMdaAudioInputStream->ReadL( *iBuffers[iBuffers.Count()-1] );

}

void CInputStreamer::MaiscBufferCopied(TInt aError, const TDesC8 &aBuffer)

{

	iLogger->Log(_L("%d) CInputStreamer::MaiscBufferCopied(%d)") , iId, aError);

	iLogger->Log(_L("  Buffer's length=(%d)") , aBuffer.Length() );

	iLogger->Log(_L("Error=(%d)") , aError);

	if (aError)

	{

		iRecording=EFalse;

		if (iState == EStopped)

		    Exit(KErrNone);

		else

		    Exit(aError);

		//TODO: remove previous line when the MaiscRecordComplete callback gets called correctly

		return;

	}

	iLogger->Log(_L("%d) MaiscBufferCopied: Bytes (%d), Position (%d)") , iId, iMdaAudioInputStream->GetBytes() ,

	                                                                      iMdaAudioInputStream->Position() );

	++iCurrentBuffer;

	TDes8 *tmp = new(ELeave)TBuf8<KBufferSize>;

	tmp->SetMax();

	CleanupStack::PushL(tmp);

	if (iBuffers.Append(tmp)) { iLogger->Log(_L("Error appending in openComplete")); }

	CleanupStack::Pop(tmp);

	iLogger->Log(_L("%d) CInputStreamer::MaiscBufferCopied(), Reading buffer #(%d)") , iId, iCurrentBuffer);

	iMdaAudioInputStream->ReadL( *iBuffers[iBuffers.Count()-1] );

}

void CInputStreamer::MaiscRecordComplete(TInt aError)

{

	iLogger->Log(_L("%d) MaiscRecordComplete: Bytes (%d), Position (%d)") , iId, iMdaAudioInputStream->GetBytes() ,

	                                                                        iMdaAudioInputStream->Position() );

	iLogger->Log(_L("%d) CInputStreamer::MaiscRecordComplete(%d)") , iId, aError);

	iLogger->Log(_L("Error=(%d)") , aError);

	iRecording=EFalse;

	Exit(aError);

	return;

}

// Callback from MEventTarget

TInt CInputStreamer::ExecuteL(CParameters *aParams)

{

	switch (aParams->iAction)

	{

		case KRecorderActionStop:

			Stop();

			break;

	    case KSchedulerStop:

			CActiveScheduler::Stop();

			break;

	}

	return EFalse;

}