/*

* 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

				TUint32 fitsToBuffer = iBufferDataSize-iBytesWritten;

				TUint32 remaining = aLength-fitsToBuffer;

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

				iBytesWritten = iBufferDataSize;

				// ->switch to the double buffer

				iBufferStatus = DProfilerSampleBuffer::BufferCopyAsap;

				TProfilerSampleBufStruct* tmpPtr = iBufStruct;

				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;

				LOGSTRING("DProfilerSampleBuffer::AddSample - double buffer full1!!");

				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

                LOGSTRING("DProfilerSampleBuffer::AddSample - double buffer full2!!");

				// 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

		    LOGSTRING("DProfilerSampleBuffer::AddSample - double buffer full3!!");

			return -1;

		default:

		    LOGSTRING("DProfilerSampleBuffer::AddSample - wrong switch!!");

			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;

		TProfilerSampleBufStruct* tmpPtr = iBufStruct;

		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

	TUint8* ptr1 = (TUint8*)&(iBufStruct->iDataStart);

	TUint8* ptr2 = (TUint8*)&(iDblBufStruct->iDataStart);

	for(TUint32 i=0;i<iBufferDataSize;i++)

	    {

		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)

	    {

		LOGSTRING("DProfilerSampleStream::AddSampleBuffer - ERROR 1");

		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)

    {

	LOGSTRING3("DProfilerSampleStream::AddSamples - entry ID: %d, currentbuffer: 0x%x", aSamplerId,iCurrentBuffer);

	if(iCurrentBuffer != 0)

	    {

		// the following will perform simple mutual exclusion

		iAddingSamples++;

		if(iAddingSamples > 1) 

		    {

			// there is someone else adding samples to the buffer

            LOGSTRING("DProfilerSampleStream::AddSamples - mutex in use");

			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

		TUint8* src = (TUint8*)&(aBuffer.iDblBufStruct->iDataStart);

		src += aBuffer.iDblBytesRead;

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

		// the remaining data in the buffer

		TInt amount = aBuffer.iDblBytesWritten-aBuffer.iDblBytesRead;

		TUint8* dst = realBuf.iBuffer;

		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;

			TInt remainingSpace = realBuf.iBufferSize-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;

		    }

		// free the lock

		iAddingSamples--;

	    }

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

    }

inline TInt DProfilerSampleStream::EndSampling(DProfilerSampleBuffer& aBuffer,TInt aSamplerId)

    {

    LOGSTRING2("DProfilerSampleStream::EndSampling, sampler ID: %d",aSamplerId);

	// switch the buffer to double buffer

	// even though it would not be full yet

	// the switch is done only once / end sampling procedure

	// (Only with BufferOk status)

	aBuffer.EndSampling();

	LOGSTRING2("DProfilerSampleStream::EndSampling, iClient: 0x%x",iClient);

	if(aBuffer.iBufferStatus != DProfilerSampleBuffer::BufferDataEnd)

	    {

		// add these final samples to the client buffer

		AddSamples(aBuffer,aSamplerId);

		// if all data was copied to the buffer, the buffer status is now BufferOk

		if(aBuffer.iBufferStatus != DProfilerSampleBuffer::BufferOk)

		    {

            LOGSTRING("DProfilerSampleStream::EndSampling - more data to copy");

			// there is still more data to copy, the pending request should have been

			// completed in AddSamples(), because the client buffer got filled 

			return 1;

		    }

		else

		    {

			// buffer status was changed to BufferOk in AddSamples() - 

			// this means all data from it could be copied

			// now we have to change the status of the buffer to BufferDataEnd, so

			// we know that the particular buffer has no more data to copy

            LOGSTRING("DProfilerSampleStream::EndSampling - switch to BufferDataEnd");

			aBuffer.iBufferStatus = DProfilerSampleBuffer::BufferDataEnd;

		    }

	    }

	// the buffer was completely emptied to the client buffer, or there was no

	// data to copy to the client side

	LOGSTRING("DProfilerSampleStream::EndSampling - no more data to copy");

	return 0;

    }

inline void DProfilerSampleStream::PerformCopy(TUint8 aSamplerId,TUint8* aSrc,TPtr8* aDst,TInt aOffset,TInt aAmount)

    {

	LOGSTRING2("DProfilerSampleStream::PerformCopy for sampler ID: %d",aSamplerId);	

	LOGSTRING5("DProfilerSampleStream::PerformCopy - 0x%x -> 0x%x - %d - offset: %d",aSrc, aDst, aAmount, aOffset);	

	TUint32 header;

	header = aAmount & 0x00ffffff;

	header += (aSamplerId << 24);

	TPtr8 ptr((TUint8*)&header,4);

	ptr.SetLength(4);

	LOGSTRING2("DProfilerSampleStream::PerformCopy - start header copy HDR = 0x%x",header);	

	// write the header

	Kern::ThreadDesWrite(iClient,(TAny*)aDst,ptr,aOffset,KChunkShiftBy0);

	LOGSTRING2("DProfilerSampleStream::PerformCopy - copied header %d bytes",ptr.Size());	

	aOffset+=4;

	LOGSTRING("DProfilerSampleStream::PerformCopy - start copy");	

	// write the data

	ptr.Set(aSrc,aAmount,aAmount);

	ptr.SetLength(aAmount);

	Kern::ThreadDesWrite(iClient,(TAny*)aDst,ptr,aOffset,KChunkShiftBy0);

	LOGSTRING2("DProfilerSampleStream::PerformCopy - copied data %d bytes",ptr.Size());