/*

* Copyright (c) 2006-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:  ICY flow reader implementation

*

*/

/* ---------------------------------------------------------------------------

*  Version history:

*  Template version:

*  <ccm_history>

*

*  Version: 2, Tue Feb 28 18:00:00 2008 by Rohit/Kranthi

*  Ref:

*  Setting RawDataTransferredL() into DataTransferTracker for Byte Counter Impl

*

*  </ccm_history>

* ============================================================================

*/

#include <utf.h>

#include "iricyflowreader.h"

#include "irdebug.h"

#include "irmediaenginebuffer.h"

#include "irmetadata.h"

#include "irnetworkbuffer.h"

#include "irstationconnection.h"

#include "irstationdataobserver.h"

#include "irstreamsourceerrors.h"

#include "irnetworkcontroller.h"

const TInt KMaxSongBufferSize = 61440;

const TInt KNoInputBuffers = 60;

const TInt KMaxBufferChunkSize = 1024;

const TInt KMaxSocketBufferSize = 1024;

const TInt KBufferPercentageInc = 1;

const TInt KSixteen = 16;

const TInt KThree=3;

_LIT8( KIRStreamTitle, "StreamTitle='" );

_LIT8( KIRStreamUrl, "StreamUrl='" );

_LIT8( KIRMetaDataEndIdentifier, "';" );

_LIT8( KIRSongDelimiter, " - " );

// masks and prefices used in UTF-8 recognition

const TInt KIRUtf8_2B1stByteMask = 0xE0;

const TInt KIRUtf8_3B1stByteMask = 0xF0;

const TInt KIRUtf8_4B1stByteMask = 0xF8;

const TInt KIRUtf8FollowingByteMask = 0xC0;

const TInt KIRUtf8_2B1stBytePrefix = 0xC0;

const TInt KIRUtf8_3B1stBytePrefix = 0xE0;

const TInt KIRUtf8_4B1stBytePrefix = 0xF0;

const TInt KIRUtf8FollowingBytePrefix = 0x80;

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

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

// CIRIcyFlowReader::NewL

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

//

CIRIcyFlowReader* CIRIcyFlowReader::NewL( RSocket& aSocket, CIRStationConnection& aOwner,

	               MIRStationDataObserver& aDataObserver, TChannelInfo& aChannelInfo )

    {

    CIRIcyFlowReader* self = new ( ELeave ) CIRIcyFlowReader( aSocket, aOwner,

    					 aDataObserver, aChannelInfo );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CIRIcyFlowReader::CIRIcyFlowReader

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

//

CIRIcyFlowReader::CIRIcyFlowReader( RSocket& aSocket, CIRStationConnection& aOwner,

	              MIRStationDataObserver& aDataObserver, TChannelInfo& aChannelInfo )

    :CActive( EPriorityStandard ), iSocket( aSocket ), iOwner( aOwner ),

    				 iDataObserver( aDataObserver ),

      iSocketBufferPtr( NULL, 0 ), iChannelInfo( aChannelInfo )

    {

    }

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

// CIRIcyFlowReader::~CIRIcyFlowReader

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

//

CIRIcyFlowReader::~CIRIcyFlowReader()

	{

	Cancel();

	while(!iSinkQ.IsEmpty())

		{

		//Deleting all the entries in sink buffers queue

		iTempBufferHolder = iSinkQ.First();

		iSinkQ.Remove(*iTempBufferHolder);

		delete iTempBufferHolder;

		}

	while(!iSourceQ.IsEmpty())

		{

		//deleting all the entries in source buffers queue

		iTempBufferHolder = iSourceQ.First();

		iSourceQ.Remove(*iTempBufferHolder);

		delete iTempBufferHolder;

		}

	delete[] iSongBuffer;

	delete iSocketBuffer;

	delete iTempSongBuffer;

	delete iTempMetaBuffer;

    delete iMetaData;

	if(iNetworkControllerHandle)

		{

		iNetworkControllerHandle->Close();

		}

	}

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

// CIRIcyFlowReader::ConstructL()

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

//

void CIRIcyFlowReader::ConstructL()

    {

    IRLOG_DEBUG( "CIRIcyFlowReader::ConstructL" );

    iAudioDataOffset = iChannelInfo.iAudioDataOffset;

    TInt f_off = _FOFF( CIRNetworkBuffer, iLink ); //for the buffer queue which is maintained

    iSourceQ.SetOffset( f_off ); 	// It is Queue of buffer given to socket to fill

    iSinkQ.SetOffset( f_off );  // It is Queue of buffer given to media engine

    InitializeBuffersL();

    iMetaData = CIRMetaData::NewL();

    CActiveScheduler::Add( this );

    iNetworkControllerHandle = CIRNetworkController::OpenL();

    IRLOG_DEBUG( "CIRIcyFlowReader::ConstructL - Exiting." );

    }

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

// CIRIcyFlowReader::HandleReceivedDataL

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

//

void CIRIcyFlowReader::HandleReceivedDataL( const TDesC8& aData )

    {

    switch ( iParsingState )

        {

        case EIRReadingAudioData:

            {

            if ( iAudioDataOffset + aData.Length() > iChannelInfo.iMetaInterval )

                {

                // Part of this data contains meta data information already.

                TInt audioDataAmount = iChannelInfo.iMetaInterval - iAudioDataOffset;

                // Only the audio part of the data is added to the song buffer.

                HandleReceivedAudioData( aData.Left( audioDataAmount ) );

                iParsingState = EIRReadingMetaDataLength;

                iAudioDataOffset = 0; // Resets the audio data offset, will start increment again after meta data is handled.

                HandleReceivedDataL( aData.Mid( audioDataAmount ) ); // Recursive call to handle meta data mixed in with this audio data block.

                }

            else // All of it is data is audio data.

                {

                HandleReceivedAudioData( aData );

                }

            break;

            }

        case EIRReadingMetaDataLength:

            {

            // ICY protocol specifies that meta data length is the first byte of the data multiplied by 16.

            iMetaDataLength = aData[0] * KSixteen;

            delete iTempMetaBuffer;

            iTempMetaBuffer = NULL;

            if ( iMetaDataLength > 0 ) // Meta data is provided, so we have to parse it.

                {

                iTempMetaBuffer = HBufC8::NewL( iMetaDataLength );

                iParsingState = EIRReadingMetaData;

                }

            else // No meta data available, so resume reading audio data.

                {

                iParsingState = EIRReadingAudioData;

                }

            if ( aData.Length() > 1 ) // Just to check that the data doesn't only contain the length byte.

                {

                HandleReceivedDataL( aData.Mid( 1 ) ); // Strips off the length byte. Recursive call as data can also contain audio data.

                }

            break;

            }

        case EIRReadingMetaData:

            {

            if ( iTempMetaBuffer->Length() + aData.Length() > iMetaDataLength )

                {

                // All of the meta data block is now received, and part of it is continuation to the audio data.

                TInt metaDataAmount = iMetaDataLength - iTempMetaBuffer->Length();

                HandleReceivedMetaData( aData.Left( metaDataAmount ) );

                ExtractMetadataL(); // Extracts the meta data from the temporary meta data buffer.

                iParsingState = EIRReadingAudioData;

                HandleReceivedDataL( aData.Mid( metaDataAmount ) ); // Strips off the meta data from the descriptor.

                }

            else // All of it is meta data.

                {

                HandleReceivedMetaData( aData );

                }

            break;

            }

        }

    }

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

// CIRIcyFlowReader::HandleReceivedAudioData

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

//

void CIRIcyFlowReader::HandleReceivedAudioData( const TDesC8& aData )

    {

    // Check to see if we've got enough audio data to fill a buffer.

    if ( iTempSongBuffer->Length() + aData.Length() >= KMaxBufferChunkSize )

        {

		// Data contains more audio data than the buffer can handle.

		TInt amountToAdd = KMaxBufferChunkSize - iTempSongBuffer->Length();

		// Enough audio data to fill the buffer is added.

		iTempSongBuffer->Des().Append( aData.Left( amountToAdd ) );

		AddToSinkQueue( *iTempSongBuffer );

		//while loop is written for only if left over amount in aData is 

		//greater then 1024, then it should be again added into SinkQueue

		while(1)

			{

			iTempSongBuffer->Des().Zero();

	 		//calculates the length of the leftover amount to be added

			TInt length = aData.Length() - amountToAdd;

			if(length <= 0)

				{

				break;	

				}

			else if(length >= KMaxBufferChunkSize) //if the left over amount is >= 1024 then add to SinkQueue

				{

				iTempSongBuffer->Des().Append( aData.Mid( amountToAdd,KMaxBufferChunkSize ) );

		 		// updates the amountToAdd value by 1024

				amountToAdd += KMaxBufferChunkSize;

				AddToSinkQueue( *iTempSongBuffer );

				}

			else //if the left over amount is < 1024 then append to tempSongBuffer & break

				{

				// Then the overflowing audio data part is added to the new clean buffer.

				iTempSongBuffer->Des().Append( aData.Mid( amountToAdd ) );

				break;	

				}

			}

        }

    else // There is enough room in the temporary audio buffer to hold all of the data.

        {

        iTempSongBuffer->Des().Append( aData );

        }

    iAudioDataOffset += aData.Length();

    }

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

// CIRIcyFlowReader::HandleReceivedMetaData

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

//

void CIRIcyFlowReader::HandleReceivedMetaData( const TDesC8& aData )

    {

    iTempMetaBuffer->Des().Append( aData );

    }

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

// CIRIcyFlowReader::RunL

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

//

void CIRIcyFlowReader::RunL()

    {

     // Active object request complete handler

    switch ( iStatus.Int() )

        {

        case KErrNone:

            {

			// Byte Counter Impl

			iNetworkControllerHandle->DataTransferTracker().RawDataTransferredL( 0,

					 iSocketBufferPtr.Size(), MIRDataTransferTracker::EIRTransferCategoryAudio);

            HandleReceivedDataL( *iSocketBuffer );

            if ( !iSourceQ.IsEmpty() )

            	{

            	//issue a read on empty buffer

            	IssueRead();

            	}

            else

            	{

            	if( iReBuffering )

            		{

            		//	if rebuffering call continue using sink buffer

            		FillRemainingBuffers();

            		}

            	if( iInitialBuffering )

            		{

            		//  if first time intimate media client to fill the buffer

            		iDataObserver.AudioDataEvent( MIRStationDataObserver::EBufferFilled, KErrNone );

            		iInitialBuffering = EFalse;

            		}

            	}

		 	break;

			}

        case KErrDisconnected:

        	{

        	IRLOG_ERROR( "CIRIcyFlowReader::RunL - KErrDisconnected");

        	iOwner.ConnectionError( KIRStreamSourceDisconnected );

        	}

            break;

        case KErrEof:

        	{

        	IRLOG_INFO( "CIRIcyFlowReader::RunL - KErrEof" );

        	iOwner.ConnectionError( KIRStreamSourceNoResponse );

        	}

        	break;

        default:

        	{

        	IRLOG_ERROR2( "CIRIcyFlowReader::RunL - Error (%d)", iStatus.Int() );

            iOwner.ConnectionError( KIRStreamSourceReadError );

        	}

            break;

        }

    }

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

// CIRIcyFlowReader::DoCancel

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

//

void CIRIcyFlowReader::DoCancel()

    {

    iSocket.CancelRead();

    }

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

// CIRIcyFlowReader::IssueRead

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

//

void CIRIcyFlowReader::IssueRead()

    {

	if( !IsActive() )

		{

	    iSocketBufferPtr.Zero();

	    iSocket.Read( iSocketBufferPtr, iStatus );

	    SetActive();

		}

    }

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

// CIRIcyFlowReader::Start

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

//

void CIRIcyFlowReader::Start()

    {

    IRLOG_INFO( "CIRIcyFlowReader::Start" );

    // Initiate a new read from socket into iBuffer

    iInitialBuffering = ETrue;

    iBufferCounter = 0;

    iPublishStationInfo = ETrue;

	IssueRead();

	IRLOG_DEBUG( "CIRIcyFlowReader::Start - Exiting." );

    }

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

// CIRIcyFlowReader::InitializeBuffersL

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

//

void CIRIcyFlowReader::InitializeBuffersL()

	{

	IRLOG_DEBUG( "CIRIcyFlowReader::InitializeBuffersL" );

	// Allocate the buffer for audio data on heap

	iSongBuffer = new TUint8[KMaxSongBufferSize];

	User::LeaveIfNull( iSongBuffer );

	IRLOG_INFO2( "CIRIcyFlowReader::InitializeBuffersL - Reserved %d bytes of memory", KMaxSongBufferSize );

	TUint8* bufferaddress = iSongBuffer;

	// since sink buffers are not created initially all buffers are filled with data and appended to sink buffer

	// Create buffers ans append to source buffer queue

	for(TInt buffercount = 0; buffercount < KNoInputBuffers; buffercount++ )

		{

		iTempBufferHolder = CIRNetworkBuffer::NewL(bufferaddress,

			KMaxBufferChunkSize);

		iSourceQ.AddLast(*iTempBufferHolder);

		bufferaddress += KMaxBufferChunkSize;

		}

	// Create a buffer for the data read from socket

	iSocketBuffer = HBufC8::NewL( KMaxSocketBufferSize );

	iSocketBufferPtr.Set( iSocketBuffer->Des() );

    iTempSongBuffer = HBufC8::NewL( KMaxSocketBufferSize );

	IRLOG_DEBUG( "CIRIcyFlowReader::InitializeBuffersL - Exiting." );

	}

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

// CIRIcyFlowReader::FillBuffer

// Fills the mediaengine buffer and rebuffers if necessary

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

//

void CIRIcyFlowReader::FillBuffer(TDes8& aInputBuffer)

	{

	FillMediaEngineBuffer(aInputBuffer);

	}

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

// CIRIcyFlowReader::AddToSinkQueue

// Adds the filled buffers to the sink Q so that it can be copied to media

// engine buffer

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

//

void CIRIcyFlowReader::AddToSinkQueue( const TDesC8& aData )

	{

	//call from runL

	//removes the buffer from source queue and put in sink queue

	if( !iSourceQ.IsEmpty() )

		{

		iTempBufferHolder = iSourceQ.First();

		TPtr8 bufferPointer(iTempBufferHolder->Des() ,KMaxBufferChunkSize,

			KMaxBufferChunkSize );

		bufferPointer.Copy(aData);

		iSourceQ.Remove(*iTempBufferHolder);

		iSinkQ.AddLast(*iTempBufferHolder);

		if( iInitialBuffering )

			{

			iBufferCounter += KBufferPercentageInc;

			iDataObserver.AudioDataEvent( MIRStationDataObserver::EBufferPercentage, iBufferCounter );

			}

		}

	}

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

// CIRIcyFlowReader::FillMediaEngineBuffer

// Fills the data into media engine's buffer

// aInputBuffer Buffer into which data is to be filled

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

//

void CIRIcyFlowReader::FillMediaEngineBuffer(const TDes8& aInputBuffer)

	{

	if( !iReBuffering )

		{

		//Determine no of bytes of data to be filled

		TInt copyLength = aInputBuffer.MaxLength();

		// Calculate the no of 1K chunks

		iNoOfChunks = copyLength/KMaxBufferChunkSize;

		// Initiailly remaining chunks to be filled is same as total no of

		// chunks to be filled

		iChunksRemaining = iNoOfChunks;

		IRLOG_DEBUG3( "CIRIcyFlowReader::FillMediaEngineBuffer - Copying %d bytes/%d chunks", copyLength, iNoOfChunks );

		// Store the starting address of buffer into which data is to be

		// copied

		iBufferFillPointer = (TUint8 *)aInputBuffer.Ptr();

		// Start filling of the empty media engine buffers

		FillRemainingBuffers();

		}

	}

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

// CIRIcyFlowReader::FillRemainingBuffers

// Fills the data into media engine's remaining buffers

// called when the stream source runs out of buffers and

// there is a pending request to media engine

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

//

void CIRIcyFlowReader::FillRemainingBuffers()

	{

	TUint8* mediaBufferAddress = iBufferFillPointer;

	TInt chunksFilled = iNoOfChunks - iChunksRemaining;

	mediaBufferAddress += ( chunksFilled * KMaxBufferChunkSize );

	TInt bufferNumber = iChunksRemaining;

	while ( bufferNumber )

		{

		if ( !iSinkQ.IsEmpty() )

			{

			iTempBufferHolder = iSinkQ.First();

			TPtr8 mediaBufferPointer(mediaBufferAddress,KMaxBufferChunkSize,

				KMaxBufferChunkSize );

			mediaBufferPointer.Copy( iTempBufferHolder->Des() ,

				KMaxBufferChunkSize);

			TPtr8 tempBufferPointer(iTempBufferHolder->Des(),

				KMaxBufferChunkSize,KMaxBufferChunkSize );

			tempBufferPointer.Delete(KMaxBufferChunkSize,

				KMaxBufferChunkSize);

			iSinkQ.Remove(*iTempBufferHolder);

			iSourceQ.AddLast(*iTempBufferHolder);

			iChunksRemaining--;

			bufferNumber--;

			iReBuffering = EFalse;

			mediaBufferAddress += KMaxBufferChunkSize;

			//issue  source rebuffering here if source is not empty

			if( !iSourceQ.IsEmpty() )

				{

				IssueRead();

				}

			}

		else

			{

			//rebuffer if sink buffer is empty

			bufferNumber = 0;

			iReBuffering = ETrue;

			//issue  source rebuffering here if source is not empty

			if( !iSourceQ.IsEmpty() )

				{

				IssueRead();

				}

			//break from for loop