/*
* 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 "OutputStreamer.h"
#include "AudioDataSettingsParams.h"

const TInt COutputStreamer::KPlayerActionPlay = 1;
const TInt COutputStreamer::KPlayerActionStop = 3;

COutputStreamer::COutputStreamer(CStifLogger *aLogger)
	: CStreamerBase(aLogger), iAlreadyClosed(EFalse),
      iPlaybackStopped(EFalse)
{ }

void COutputStreamer::ConstructL()
{
	iMdaAudioOutputStream = CMdaAudioOutputStream::NewL(*this);
}

COutputStreamer* COutputStreamer::NewL(CStifLogger *aLogger, TInt aId)
{
	COutputStreamer *_self = NewLC(aLogger, aId);
	CleanupStack::Pop(_self);
	return _self;
}

COutputStreamer* COutputStreamer::NewLC(CStifLogger *aLogger, TInt aId)
{
	COutputStreamer *_self = new(ELeave)COutputStreamer(aLogger);
	CleanupStack::PushL(_self);
	_self->ConstructL();
	_self->SetId(aId);
	return _self;
}

void COutputStreamer::ConstructL(TInt aPriority, TMdaPriorityPreference aPref)
{
	iMdaAudioOutputStream = CMdaAudioOutputStream::NewL(*this, aPriority, aPref);
}

COutputStreamer* COutputStreamer::NewL(TInt aPriority, TMdaPriorityPreference aPref,
                                       CStifLogger *aLogger, TInt aId)
{
	COutputStreamer *_self = NewLC(aPriority, aPref, aLogger, aId);
	CleanupStack::Pop(_self);
	return _self;
}

COutputStreamer* COutputStreamer::NewLC(TInt aPriority, TMdaPriorityPreference aPref,
                                        CStifLogger *aLogger, TInt aId)
{
	COutputStreamer *_self = new(ELeave)COutputStreamer(aLogger);
	CleanupStack::PushL(_self);
	_self->ConstructL(aPriority, aPref);
	_self->SetId(aId);
	return _self;
}

COutputStreamer::~COutputStreamer()
{
	iMdaAudioOutputStream->Stop();
	delete iMdaAudioOutputStream;
	iArrBufferErrors.Close();
	TInt Before = iBuffers.Count();
	iBuffers.ResetAndDestroy();
	iLogger->Log(_L("%d) Items in buffer (%d), there were (%d)") , iId, iBuffers.Count() , Before);
	iMdaAudioOutputStream = NULL;
	iWriteBuffers.ResetAndDestroy();
}

void COutputStreamer::SetAudioPropertiesL(TInt aSampleRate, TInt aChannels)
{
	iLogger->Log(_L("%d) COutputStreamer::SetAudioPropertiesL(rate=%d, chan=%d)") , iId, aSampleRate, aChannels);
	iMdaAudioOutputStream->SetAudioPropertiesL(aSampleRate, aChannels);
}

void COutputStreamer::SetVolume(TInt aVolume)
{
	iLogger->Log(_L("%d) COutputStreamer::SetVolume(%d, %d)") , iId, aVolume);
	iMdaAudioOutputStream->SetVolume(aVolume);
}

TInt COutputStreamer::GetVolume() { return iMdaAudioOutputStream->Volume(); }

TInt COutputStreamer::GetMaxVolume() { return iMdaAudioOutputStream->MaxVolume(); }

void COutputStreamer::SetPriority(TInt aPriority, TMdaPriorityPreference aPref)
{
	iLogger->Log(_L("%d) COutputStreamer::SetPriority(%d, %d)") , iId, aPriority, aPref);
	iMdaAudioOutputStream->SetPriority(aPriority, aPref);
}

void COutputStreamer::AdoptBuffers(RPointerArray<TDes8> &aBuffers )
{
	for (TInt x=0; x<aBuffers.Count() ; ++x)
		{
		iBuffers.Append(aBuffers[x]);
		}
	aBuffers.Reset();
}

void COutputStreamer::StartPlayback(TMdaPackage *aSettings)
{
	iLogger->Log(_L("COutputStreamer::StartPlayback()") );
	iCurrentBuffer=-1;

	iMdaAudioOutputStream->Open(aSettings);
}

RArray<TInt> &COutputStreamer::GetBufferErrors(){return iArrBufferErrors;}

TInt COutputStreamer::DesToBuffers(TDes8 &aDes)
{
	TInt NumChunks = aDes.Length() / KBufferSize;
	TInt remainder = aDes.Length() % KBufferSize;

	TInt x;
	for (x=0 ; x<NumChunks ; ++x)
	{
		TDes8 *tmp = new(ELeave)TBuf8<KBufferSize>;
		CleanupStack::PushL(tmp);
		*tmp=aDes.Mid(x*KBufferSize , KBufferSize);
		if (AppendBuffer(tmp)) { iLogger->Log(_L("Error appending buffer in DesToBuffers")); }
		CleanupStack::Pop(tmp);
	}

	if (remainder > 0)
	{
		TDes8 *tmp = new(ELeave)TBuf8<KBufferSize>;
		CleanupStack::PushL(tmp);
		*tmp=aDes.Mid(x*KBufferSize , remainder);
		tmp->SetLength(remainder);

		if (AppendBuffer(tmp)) { iLogger->Log(_L("Error appending buffer in DesToBuffers")); }
		CleanupStack::Pop(tmp);
	}

	iLogger->Log(_L("COutputStreamer::DesToBuffers # Buffers created - %d"), iWriteBuffers.Count());
	return KErrNone;
}

TInt COutputStreamer::GetBalanceL()
{
	TInt retVal = iMdaAudioOutputStream->GetBalanceL();
	return retVal;
}

void COutputStreamer::SetBalanceL(TInt aBalance)
{
	iMdaAudioOutputStream->SetBalanceL(aBalance);
}

void COutputStreamer::Stop()
{
	iLogger->Log(_L("%d) COutputStreamer::Stop()") , iId);
	iMdaAudioOutputStream->Stop();
}

void COutputStreamer::Exit(TInt aExitCode)
{
	iLogger->Log(_L("%d) COutputStreamer::Exit(%d)"), iId, aExitCode);
	iFinalError = aExitCode;
	if (!iAlreadyClosed)
	{
    	iAlreadyClosed=ETrue;
		CActiveScheduler::Stop();
	}
}

TFourCC COutputStreamer::GetDataType()
{
	TFourCC retVal = iMdaAudioOutputStream->DataType();
	iLogger->Log(_L("%d) COutputStreamer::GetDataType() , result=(%d)") , iId, retVal.FourCC());
	return retVal;
}

void COutputStreamer::SetDataTypeL(TFourCC aAudioType)
{
	iLogger->Log(_L("%d) COutputStreamer::SetDataTypeL(dataType=%d)") , iId, aAudioType.FourCC());
	iMdaAudioOutputStream->SetDataTypeL(aAudioType);
}

// inherited from MMdaAudioOutputStreamCallback
void COutputStreamer::MaoscOpenComplete(TInt aError)
{
	iLogger->Log(_L("%d) COutputStreamer::MaoscOpenComplete(%d)") , iId, aError);
	if (aError || iExitAfterOpen)
	{
		Exit(aError);
		return;
	}

	iLogger->Log(_L("%d) Bytes (%d), Position (%d)") , iId, iMdaAudioOutputStream->GetBytes() , iMdaAudioOutputStream->Position());
	++iCurrentBuffer;
	if (0<=iCurrentBuffer && iCurrentBuffer<=iWriteBuffers.Count() )
	{
		iMdaAudioOutputStream->WriteL( *(iWriteBuffers[iCurrentBuffer]) );
		iLogger->Log(_L("%d) COutputStreamer::MaoscOpenComplete(), writting buffer #(%d)") , iId, iCurrentBuffer);
	}
	//for (TInt i=0; i < iWriteBuffers.Count(); i++)
	//{
	//	iMdaAudioOutputStream->WriteL( *(iWriteBuffers[i]) );
	//}
}

void COutputStreamer::MaoscBufferCopied(TInt aError, const TDesC8 &/*aBuffer*/)
{
	iLogger->Log(_L("%d) COutputStreamer::MaoscBufferCopied(%d)") , iId, aError);
	iArrBufferErrors.Append(aError);
	if (aError)
	{
		return;
	}
	iLogger->Log(_L("%d) Bytes (%d), Position (%d)") , iId, iMdaAudioOutputStream->GetBytes() , iMdaAudioOutputStream->Position());
	++iCurrentBuffer;
	if (0<=iCurrentBuffer && iCurrentBuffer<iWriteBuffers.Count() )
	{
		iMdaAudioOutputStream->WriteL( *(iWriteBuffers[iCurrentBuffer]) );
		iLogger->Log(_L("%d) COutputStreamer::MaoscBufferCopied(), writting buffer #(%d)") , iId, iCurrentBuffer);
	}
	else if (iCurrentBuffer == iWriteBuffers.Count())
	//if (iCurrentBuffer == iWriteBuffers.Count())
	{
		Exit(KErrNone);
	}
}

void COutputStreamer::MaoscPlayComplete(TInt aError)
{
	iLogger->Log(_L("%d) Bytes (%d), Position (%d)") , iId, iMdaAudioOutputStream->GetBytes() , iMdaAudioOutputStream->Position());
	iLogger->Log(_L("%d) COutputStreamer::MaoscPlayComplete(%d)") , iId, aError);

	// Underflow occurs at end of playback
	if ( (aError == KErrUnderflow) && (iCurrentBuffer == iBuffers.Count()) )
		aError = KErrNone;

	// Stop causes abort
	if (iPlaybackStopped && (aError == KErrCancel))
		aError = KErrNone;

	Exit(aError);
}

// from MEventTarget
TInt COutputStreamer::ExecuteL(CParameters *aParams)
{
	switch (aParams->iAction)
	{
		case KPlayerActionPlay:
			StartPlayback( (static_cast<CAudioDataSettingsParams*>(aParams))->GetSettings() );
			break;
		case KPlayerActionStop:
			iPlaybackStopped = ETrue;
			Stop();
			break;
	}
	return EFalse;
}

TInt COutputStreamer::AppendWriteBuffer(HBufC8 *aBuffer)
{
	return iWriteBuffers.Append(aBuffer);
}

TInt COutputStreamer::LoadAudioFileL(const TFileName &aFileName)
{
	RFs fs;	// file server instance
	RFile audiofile;

	// open fileserver session and file
	User::LeaveIfError(fs.Connect());
	// push into cleanup stack
	CleanupClosePushL(fs);

	// open file
	TInt err = audiofile.Open(fs, aFileName, EFileRead|EFileStream);
	if (err==KErrNone)
	{
		// file opened ok, proceed reading
		TInt fileSize;
		audiofile.Size(fileSize);

		TInt readPos(0);
		TInt bufLen(KBufferSize);
		HBufC8* tmpBuf(NULL);
		while (readPos < fileSize)
		{
			bufLen = Min(KBufferSize,fileSize-readPos);
			tmpBuf = HBufC8::NewL(KBufferSize);
			CleanupStack::PushL(tmpBuf);
			TPtr8 ptr(tmpBuf->Des());
			ptr.Set(const_cast<TUint8*>(ptr.Ptr()),0,bufLen);
			User::LeaveIfError(audiofile.Read(readPos,ptr,bufLen));
			tmpBuf->Des().SetLength(bufLen);
			AppendWriteBuffer(tmpBuf);
			CleanupStack::Pop(tmpBuf);
			readPos += bufLen;
		}
		iLogger->Log(_L("Loading complete!"));
	}
	else
	{
		// failed to open file
		iLogger->Log(_L("Error loading audio sample!"));
	}
	audiofile.Close();
	// pop and destroy resources pushed into stack
	CleanupStack::PopAndDestroy();

	return err;
}