/*

* Copyright (c) 2009 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:  

*

*/

#include <kern_priv.h>

#include <piprofiler/ProfilerGenericClassesKrn.h>

/*

 *	

 *	Class CProfilerSamplerBase implementation

 *

 */

inline DProfilerSamplerBase::DProfilerSamplerBase()

    {

    }

inline DProfilerSamplerBase::~DProfilerSamplerBase()

    {

    }

/*

 *	

 *	Class CProfilerSampleBuffer implementation

 *

 */

inline DProfilerSampleBuffer::DProfilerSampleBuffer(TUint8* aBuffer, 

											TUint8* aDblBuffer, 

											TUint32 aBufferSize )

    {

	LOGSTRING3("CProfilerSampleBuffer::CProfilerSampleBuffer AtFirst: b:0x%x db:0x%x",aBuffer,aDblBuffer);

	// make sure the alignment is right

	if((((TUint32)aBuffer) %4) != 0)

	    aBuffer += (4-(((TUint32)aBuffer)%4));

	if((((TUint32)aDblBuffer) %4) != 0)

	    aDblBuffer += (4-(((TUint32)aDblBuffer)%4));

	LOGSTRING3("CProfilerSampleBuffer::CProfilerSampleBuffer b:0x%x db:0x%x",aBuffer,aDblBuffer);

	iBufStruct = (TProfilerSampleBufStruct*)aBuffer;

	iDblBufStruct = (TProfilerSampleBufStruct*)aDblBuffer;

	LOGSTRING3("CProfilerSampleBuffer::CProfilerSampleBuffer bufStruct rem:0x%x dbuStruct rem:0x%x",

						&iBufStruct->iSampleRemainder,&iDblBufStruct->iSampleRemainder);

	iBufferDataSize = aBufferSize-4;

	iBufferRealSize = aBufferSize;

	ClearBuffer();

    }

inline DProfilerSampleBuffer::~DProfilerSampleBuffer()

    {

    }

inline TInt DProfilerSampleBuffer::AddSample(TUint8* aSample, TUint32 aLength)

    {

	TUint32 bytesTotal;

	// check whether the buffer status is

	switch (iBufferStatus)

	    {

		case DProfilerSampleBuffer::BufferOk:

			// add the data normally to the buffer

			bytesTotal = iBytesWritten+aLength;

			if(bytesTotal < iBufferDataSize)

			    {

				memcpy((&(iBufStruct->iDataStart))+iBytesWritten,aSample,aLength);

				iBytesWritten+=aLength;

				return 0;

			    }

			else

			    {

				// the sample does not fit to the buffer

				// first copy as much data as we can fit to the first buffer

				memcpy((&(iBufStruct->iDataStart))+iBytesWritten,aSample,fitsToBuffer);

				iBytesWritten = iBufferDataSize;

				// ->switch to the double buffer

				iBufferStatus = DProfilerSampleBuffer::BufferCopyAsap;

				iBufStruct = iDblBufStruct;

				iDblBufStruct = tmpPtr;

				iDblBytesWritten = iBytesWritten;

				// and this is the remainder of a sample

				// that will be copied to the new buffer

				// just in a while

				iBufStruct->iSampleRemainder = remaining;

				// now that the buffers have been switched

				// add the rest of the sample to the buffer

				aSample+=fitsToBuffer;

				// there should be room - in case the single sample

				// is smaller than the whole buffer! so we don't

				// bother to check

				memcpy((&(iBufStruct->iDataStart)),aSample,remaining);

				iBytesWritten = remaining;

				return 0;

			    }

		case DProfilerSampleBuffer::BufferCopyAsap:

			// no difference to the BufferOk case

			// unless the double buffer gets filled

			// before the data has been copied

			// add the data normally to the buffer

			bytesTotal = iBytesWritten+aLength;

			if(bytesTotal < iBufferDataSize)

			    {

				memcpy((&(iBufStruct->iDataStart))+iBytesWritten,aSample,aLength);

				iBytesWritten+=aLength;

				return 0;

			    }

			else

			    {

				// the double buffer is now also full - there is no

				// place to put the data -> we have to waste it!

				// this is an indication of a too small buffer size

				iBufferStatus = DProfilerSampleBuffer::BufferFull;

				return -1;

			    }

		case DProfilerSampleBuffer::BufferBeingCopied:

			// no difference to the BufferCopyAsap case

			bytesTotal = iBytesWritten+aLength;

			if(bytesTotal < iBufferDataSize)

			    {

				memcpy((&(iBufStruct->iDataStart))+iBytesWritten,aSample,aLength);

				iBytesWritten+=aLength;

				return 0;

			    }

			else

			    {

				// the double buffer is now also full - there is no

				// place to put the data -> we have to waste it!

				// this is an indication of a too small buffer size

				// don't change the state to CProfilerSampleBuffer::BufferFull, since it is

				// already being copied

				return -1;

			    }

		case DProfilerSampleBuffer::BufferFull:

			// the buffer is still full, there is noting we can do

			// about it -> return

			return -1;

		default:

			return -1;

	    }

    }

inline void DProfilerSampleBuffer::EndSampling()

    {

    LOGSTRING("DProfilerSampleBuffer::EndSampling");

	// this will switch to the dbl buffer even though

	// the buffer is not full, so that data can be copied

	// during this operation, no other buffer

	// operations are allowed

	// ensure that the normal buffer is in use and that the

	// buffer is in normal state ( this procedure is performed only once )

	if(iBufferStatus == DProfilerSampleBuffer::BufferOk)

	    {

		// ->switch to the double buffer

        LOGSTRING("DProfilerSampleBuffer::EndSampling - switching to double buffer");

		iBufferStatus = DProfilerSampleBuffer::BufferCopyAsap;

		iBufStruct = iDblBufStruct;

		iDblBufStruct = tmpPtr;

		iDblBytesWritten = iBytesWritten;

		// there is no new sample so the remainder is

		// zero, (this shouldn't be used anyway)

		iBufStruct->iSampleRemainder = 0;

	    }

    }

inline TUint32 DProfilerSampleBuffer::GetBufferStatus()

    {

	return iBufferStatus;

    }

inline void DProfilerSampleBuffer::ClearBuffer()

    {

	LOGSTRING2("CProfilerSampleBuffer::ClearBuffer - %d",iBufferDataSize);

	// the buffers are of same size

	    {

		ptr1[i] = 0;

		ptr2[i] = 0;

	    }

	iBufStruct->iSampleRemainder = 0;

	iDblBufStruct->iSampleRemainder = 0;

	// written the dblBufStruct

	iBytesWritten = 0;

	iDblBytesWritten = 0;

	iDblBytesRead = 0;

	iBufferStatus = DProfilerSampleBuffer::BufferOk;

    }

inline void DProfilerSampleBuffer::DataCopied()

    {

	iDblBytesRead = 0;

	iDblBytesWritten = 0;

	iBufferStatus = DProfilerSampleBuffer::BufferOk;

    }

/*

 *

 *	Class DProfilerSampleStream implementation

 *

 */

inline DProfilerSampleStream::DProfilerSampleStream()

    {

	LOGSTRING("DProfilerSampleStream::DProfilerSampleStream");

	iCurrentBuffer = 0;

	iPendingRequest = 0;

	iAddingSamples = 0;

	iClient = 0;

    }

inline DProfilerSampleStream::~DProfilerSampleStream()

    {

	LOGSTRING("DProfilerSampleStream::~DProfilerSampleStream");	

    }

inline void DProfilerSampleStream::InsertCurrentClient(DThread* aClient)

    {

	iClient = aClient;

	LOGSTRING2("DProfilerSampleStream::InsertCurrentClient - iClient is 0x%x",iClient);

    }

inline void DProfilerSampleStream::AddSampleBuffer(TBapBuf* aBuffer,TRequestStatus* aStatus)

    {

	if(iCurrentBuffer != 0 || iPendingRequest != 0)

	    {

		return;

	    }

	LOGSTRING3("DProfilerSampleStream::AddSampleBuffer - OK 0x%x,0x%x",aBuffer,aStatus);

	iCurrentBuffer = aBuffer;

	iPendingRequest = aStatus;

	LOGSTRING2("DProfilerSampleStream::AddSampleBuffer - Current Client is 0x%x",iClient);	

    }

inline void DProfilerSampleStream::ReleaseIfPending()

    {

    LOGSTRING("DProfilerSampleStream::ReleaseIfPending - entry");

	if(iCurrentBuffer != 0 && iPendingRequest != 0 && iClient != 0)

	    {

		LOGSTRING("DProfilerSampleStream::ReleaseIfPending - release buffer");

		LOGSTRING2("DProfilerSampleStream::AddSamples - completing request 0x%x",iPendingRequest);

		Kern::RequestComplete(iClient,iPendingRequest,KErrNone);

		iPendingRequest = 0;

		iCurrentBuffer = 0;

	    }

	LOGSTRING("DProfilerSampleStream::ReleaseIfPending - exit");

    }

inline void DProfilerSampleStream::AddSamples(DProfilerSampleBuffer& aBuffer, TInt aSamplerId)

    {

	if(iCurrentBuffer != 0)

	    {

		// the following will perform simple mutual exclusion

		iAddingSamples++;

		if(iAddingSamples > 1) 

		    {

			// there is someone else adding samples to the buffer

			iAddingSamples--;

			return;

		    }

		LOGSTRING("DProfilerSampleStream::AddSamples - reading TBapBuf");

		// use a copy of the client TBapBuf structure during processing

		TBapBuf realBuf;

		TPtr8 ptr((TUint8*)&realBuf,(TInt)sizeof(TBapBuf));

		Kern::ThreadRawRead(iClient,(TAny*)(iCurrentBuffer),(TAny*)&realBuf,sizeof(TBapBuf));

		ptr.SetLength(sizeof(TBapBuf));

		LOGSTRING4("DProfilerSampleStream::AddSamples - read %d bytes from 0x%x of thread 0x%x",ptr.Size(),iCurrentBuffer,iClient);

		LOGSTRING5("DProfilerSampleStream::AddSamples - current buffer 0x%x -> b:0x%x s:%d d:%d",

			&realBuf,

			realBuf.iBuffer,

			realBuf.iBufferSize,

			realBuf.iDataSize);

		// get the address of the source buffer data

		src += aBuffer.iDblBytesRead;

		// the amount of data to copy is the 4 header bytes +

		// the remaining data in the buffer

		LOGSTRING4("DProfilerSampleStream::AddSamples - s:0x%x d:0x%x a:%d",src,dst,amount);

		if(realBuf.iDataSize == 0)

		    {

			LOGSTRING("DProfilerSampleStream::AddSamples - case 1");

			// the buffer is empty

			if(realBuf.iBufferSize >= (amount+4))

			    {

				LOGSTRING("DProfilerSampleStream::AddSamples - case 1.1");

				// the source buffer is smaller or of equal size than the amount of output data

				PerformCopy((TUint8)aSamplerId,src,realBuf.iBufDes,0,amount);

				realBuf.iDataSize += amount+4;

				// the rest of the source buffer was copied at once, so signal the buffer

				aBuffer.DataCopied();

			    }

			else

			    {

				LOGSTRING("DProfilerSampleStream::AddSamples - case 1.2");

				// only a part of the source buffer will fit to the client side buffer

				amount = realBuf.iBufferSize-4;

				PerformCopy((TUint8)aSamplerId,src,realBuf.iBufDes,0,amount);

				realBuf.iDataSize += amount+4;

				// add the amount of bytes read to the source buffer

				aBuffer.iDblBytesRead+=amount;

			    }

		    }

		else

		    {

			LOGSTRING("DProfilerSampleStream::AddSamples - case 2");

			// there is data in the client buffer

			dst += realBuf.iDataSize;

			if( remainingSpace >= (amount+4) )

			    {

				LOGSTRING("DProfilerSampleStream::AddSamples - case 2.1");

				// the source buffer is smaller or of equal size than the amount of output data

				PerformCopy((TUint8)aSamplerId,src,realBuf.iBufDes,realBuf.iDataSize,amount);

				realBuf.iDataSize += (amount+4);

				// the rest of the source buffer was copied at once, so signal the buffer

				aBuffer.DataCopied();

			    }

			else

			    {

				LOGSTRING("DProfilerSampleStream::AddSamples - case 2.2");

				// only a part of the source buffer will fit to the client side buffer

				if(remainingSpace >= 12)

				    {

					LOGSTRING("DProfilerSampleStream::AddSamples - case 2.3");

					amount = remainingSpace-4;

					// there are at least 8 bytes left for data, write it

					PerformCopy((TUint8)aSamplerId,src,realBuf.iBufDes,realBuf.iDataSize,amount);

					realBuf.iDataSize += (amount+4);

					// add the amount of bytes read to the source buffer

					aBuffer.iDblBytesRead+=amount;				

				    }

			    }

		    }

		// copy the data in the modified TBapBuf structure back to the client

		LOGSTRING("DProfilerSampleStream::AddSamples - writing TBapBuf");

		Kern::ThreadDesWrite(iClient,(TAny*)(realBuf.iDes),ptr,0,KChunkShiftBy0,iClient);

		// if the client side buffer is full or nearly full, signal the client

		LOGSTRING("DProfilerSampleStream::AddSamples - data copied");

		if(realBuf.iBufferSize-realBuf.iDataSize < 12)

		    {

			LOGSTRING("DProfilerSampleStream::AddSamples - release buffer");

			LOGSTRING2("DProfilerSampleStream::AddSamples - completing request 0x%x",iPendingRequest);

			Kern::RequestComplete(iClient,iPendingRequest,KErrNone);

			iPendingRequest = 0;

			iCurrentBuffer = 0;

			//iClient = 0;

		    }