// Copyright (c) 1997-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 <f32file.h>
#include <e32std.h>
#include <mmf/server/mmfdes.h>
#include <mmf/server/mmfdatabuffer.h>
#include <mmf/common/mmfpaniccodes.h>

void Panic(TMMFDescriptorPanicCode aPanicCode)
	{
	_LIT(KMMFDescriptorPanicCategory, "MMFDescriptor");
	User::Panic(KMMFDescriptorPanicCategory, aPanicCode);
	}

/**
Protected constructor.

Sets the offset to zero.
*/
CMMFDescriptor::CMMFDescriptor( ) : CMMFClip( KUidMmfDescriptorSource, KUidMmfDescriptorSink ) 
	{
	}

/**
Destructor.

The default implementation closes the descriptor thread.
*/
CMMFDescriptor::~CMMFDescriptor()
	{
	iDesThread.Close() ;
	}

/**
Constructs a CMMFDescriptor MDataSource.

@return A pointer to a new CMMFDescriptor.
*/
MDataSource* CMMFDescriptor::NewSourceL( )
	{
	CMMFDescriptor* self = new (ELeave) CMMFDescriptor( ) ;
	return STATIC_CAST( MDataSource*, self ) ;
	}

/**
Constructs a CMMFDescriptor MDataSink.

@return A pointer to a new CMMFDescriptor.
*/
MDataSink* CMMFDescriptor::NewSinkL( )
	{
	CMMFDescriptor* self = new (ELeave) CMMFDescriptor( ) ;
	return STATIC_CAST( MDataSink*, self ) ;
	}

/**
Performs source construction dependant on the source construction
initialisation data aInitData.

@param  aInitData
        The TPckgC<TMMFDescriptorParams> descriptor package containing the descriptor and the thread 
        ID for the descriptor.
*/
void CMMFDescriptor::ConstructSourceL( const TDesC8& aInitData )
	{
	ConstructL( aInitData ) ;
	}


/***
Sets how much of the underlying descriptor will be used, up	to the underlying descriptor's maximum
length.

@param  aSize
        The size of the descriptor.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise
        another of the system-wide error codes.
*/
TInt CMMFDescriptor::SetSize( TInt aSize )
	{
	//[ precondition aSize >= 0
	// precondition sSize < MaxSize()
	// iDes is not null]
	 if(!iDes )
		 return KErrNotReady;

     if( aSize > MaxLength() )
		 return KErrOverflow;

	 if( aSize < 0 )
		 return KErrUnderflow;

	 // [ actually do the work ]
	 iDes->SetLength( aSize );

	 //[ assert the post condition
	 // aSize == Length()
	 // descriptor is still ok]
     ASSERT( aSize == iDes->Length());
	 ASSERT( iDes );

	 return KErrNone;
	}


/**
Performs sink construction dependant on the sink construction initialisation data aInitData.

@param  aInitData
        The TPckgC<TMMFDescriptorParams> descriptor package containing
        the descriptor and the thread ID for the descriptor.
*/
void CMMFDescriptor::ConstructSinkL( const TDesC8& aInitData )
	{
	ConstructL( aInitData ) ;
	}

void CMMFDescriptor::ConstructL( const TDesC8& aInitData )
	{
	TMMFDescriptorParams params;
	TPckgC<TMMFDescriptorParams> config(params);
	if (aInitData.Length() < config.Length())
		User::Leave(KErrGeneral);
	config.Set(aInitData);
	iDes = STATIC_CAST( TDes8*, config().iDes);
	User::LeaveIfError( iDesThread.Open( config().iDesThreadId ) );
	}


/** 
Loads aBuffer from iDes.

File read is asynchronous.  CReadRequest is created to respond to completion.

@param  aBuffer
        The buffer to be filled from the descriptor.
@param  aConsumer
        The data sink consumer of the buffer.
@param  aMediaId
        Not used.
*/
void CMMFDescriptor::FillBufferL( CMMFBuffer* aBuffer, MDataSink* aConsumer, TMediaId /*aMediaId*/  ) 
	{
	// Current position in Descriptor is iOffset.

	// Read from iDes in iDesThread into Des in aBuffer.

	// Assume that the amount to be read is the size of the buffer descriptor
	// Should check that there is sufficient data in the source buffer
	// If there is not enough to fill the target then copy what there is
	// How should the function deal with no data in the source buffer?

	// Use of a single iOffset will preclude use by more than one client (use ReadBufferL())
	if (CMMFBuffer::IsSupportedDataBuffer(aBuffer->Type()))
		{
		TDes8& bufferDes = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();

		//if request size is set, use it, else use max length of buffer
		TInt targetMaxLength = aBuffer->RequestSize() ? aBuffer->RequestSize() : bufferDes.MaxLength();

		//ensure RequestSize was within bounds
		if(targetMaxLength > bufferDes.MaxLength())
			targetMaxLength = bufferDes.MaxLength();

		TInt sourceLengthRemaining = iDes->Length() - iOffset;
		if ( ( sourceLengthRemaining - targetMaxLength ) > 0 )
			{
			bufferDes = iDes->Mid(iOffset,targetMaxLength);
			iOffset += targetMaxLength;
			}
		else if (sourceLengthRemaining > 0)
			{
			bufferDes = iDes->Mid(iOffset,sourceLengthRemaining);
			iOffset += sourceLengthRemaining;
			aBuffer->SetLastBuffer(ETrue);
			}
		else
			{
			bufferDes.SetLength(0);
			aBuffer->SetLastBuffer(ETrue);
			}

		aConsumer->BufferFilledL( aBuffer ) ;
		}
	else
		User::Leave(KErrNotSupported);
	}

/**
Empties aBuffer into iDes.

@param  aBuffer
        The buffer to be written to the descriptor.
@param  aSupplier
        The data source supplier of the buffer.
@param  aMediaId
        The Media ID.
*/
void CMMFDescriptor::EmptyBufferL( CMMFBuffer* aBuffer, MDataSource* aSupplier, TMediaId /*aMediaId*/ )
	{
	// Does the buffer type need to be checked?

	// Assume that the amount to be read is the size of the buffer descriptor
	// Should check that there is sufficient data in the source buffer
	// If there is not enough to fill the target then copy what there is
	// How should the function deal with no data in the source buffer?
	if (CMMFBuffer::IsSupportedDataBuffer(aBuffer->Type()))
		{
		TDes8& bufferDes = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();

		TInt sourceLength = bufferDes.Length() ;	
		TInt targetLength = iDes->MaxLength() - iDes->Length();
		if ( targetLength>0 )
			{
			if (sourceLength>targetLength)
				{
				sourceLength = targetLength;
				bufferDes.SetLength(targetLength);
				}

			iDes->Append(bufferDes) ;
			}
		else
			bufferDes.SetLength(0);

		aSupplier->BufferEmptiedL( aBuffer ) ;
		}
	else
		User::Leave(KErrNotSupported);
	}

/** 
Loads aLength number of bytes into aBuffer from specified point in iDes.

@param  aLength
        The number of bytes to be read into buffer.
@param  aBuffer
        The buffer to be filled from the descriptor.
@param  aPosition
        The offset into the descriptor at which to start reading.
@param  aConsumer
        The data sink consumer of the buffer
*/
void CMMFDescriptor::ReadBufferL(TInt aLength, CMMFBuffer* aBuffer, TInt aPosition, MDataSink* aConsumer)
	{
	if (!aBuffer)
		User::Leave(KErrArgument);

	if (CMMFBuffer::IsSupportedDataBuffer(aBuffer->Type()))
		{
		TDes8& bufferDes = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();

		if (aLength>bufferDes.MaxLength())
			User::Leave(KErrOverflow);

		if ((aLength<0) || (aPosition<0))
			User::Leave(KErrArgument);

		TInt sourceLength = iDes->Length() ;

		//ensure not trying to read more than is available
		if(aPosition + aLength > sourceLength)
			aLength = sourceLength - aPosition;

		if (aLength>0)
			{
			TPtrC8 srcPtr(iDes->Mid(aPosition,aLength));
			bufferDes.Copy(srcPtr.Ptr(),aLength);
			}
		else
			bufferDes.SetLength(0);

		//have we read all the available data
		if(aPosition + aLength >= sourceLength)
			aBuffer->SetLastBuffer(ETrue);

		if (aConsumer)
			aConsumer->BufferFilledL(aBuffer);
		}
	else
		User::Leave(KErrNotSupported);
	}

/**
Loads aBuffer from specified point in iDes

@param  aBuffer
        The buffer to be filled from the descriptor.
@param  aPosition
        The offset into the descriptor at which to start reading.
@param  aConsumer
        The data sink consumer of the buffer.
*/
void CMMFDescriptor::ReadBufferL(CMMFBuffer* aBuffer, TInt aPosition, MDataSink* aConsumer)
	{
	if (!aBuffer)
		User::Leave(KErrArgument);

	if (aPosition<0)
		User::Leave(KErrArgument);

	if (CMMFBuffer::IsSupportedDataBuffer(aBuffer->Type()))
		{
		TDes8& bufferDes = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();
		//if request size is set, use it, else use max length of buffer
		TUint copyLength = aBuffer->RequestSize() ? aBuffer->RequestSize() : bufferDes.MaxLength();

		ReadBufferL(copyLength, aBuffer, aPosition, aConsumer);
		}
	else
		User::Leave(KErrNotSupported);
	}

 /** 
Loads aBuffer from specified point in iDes.  Note that this is a synchronous read.

@param  aBuffer
        The buffer to be filled from the descriptor.
@param  aPosition
        The offset into the descriptor at which to start reading.
*/
void CMMFDescriptor::ReadBufferL(CMMFBuffer* aBuffer, TInt aPosition)
	{
	ReadBufferL(aBuffer, aPosition, NULL);
	}

/**
Empties aBuffer into iDes at specified location.

@param  aBuffer
        The data buffer containing bytes to be written.
@param  aPosition
        The offset into the descriptor at which to start writing.
@param  aSupplier
        The data source to be notified when the write has been completed.
*/
void CMMFDescriptor::WriteBufferL(CMMFBuffer* aBuffer, TInt aPosition, MDataSource* aSupplier) 
	{
	if (CMMFBuffer::IsSupportedDataBuffer(aBuffer->Type()))
		{
		TDes8& bufferDes = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();

		WriteBufferL(bufferDes.Length(), aBuffer, aPosition, aSupplier);
		}
	else
		User::Leave(KErrNotSupported);
	}

/**
Empties aLength bytes from aBuffer into iDes at specified location.

@param  aLength
        The number of bytes to be emptied from buffer.
@param  aBuffer
        The data buffer containing bytes to be written.
@param  aPosition
        The offset into the descriptor at which to start writing.
@param  aSupplier
        The data source to be notified when the write has been completed.

@leave  KErrNotReady
        If SinkPrimeL() and SinkThreadLogon() have not been called.
@leave  KErrArgument
        If aLength<0 or aPosition<0 or aSupplier is NULL.
@leave  KErrNotSupported 
        If aBuffer is not of type KMMFDataBuffer.
*/
void CMMFDescriptor::WriteBufferL(TInt aLength, CMMFBuffer* aBuffer, TInt aPosition, MDataSource* aSupplier)
	{
	if (CMMFBuffer::IsSupportedDataBuffer(aBuffer->Type()))
		{
		TDes8& bufferDes = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();

		if (aLength>bufferDes.Length() || (aLength<0) || (aPosition<0))
			User::Leave(KErrArgument);

		TInt sourceLength = aLength;
		TPtr8 bufferPtr(((sourceLength) ? &bufferDes[0] : NULL), sourceLength, sourceLength);
		TInt targetLength = iDes->MaxLength() - aPosition;
		if (targetLength>0 && sourceLength > 0)
			{
			if (sourceLength>targetLength)
				User::Leave(KErrOverflow);

			if ((iDes->Length() - aPosition) > 0)
				{
				TInt bytesToReplace = iDes->Length() - aPosition;
				if (sourceLength > bytesToReplace) 
					{
					TPtrC8 replaceBuf = bufferPtr.Left(bytesToReplace);
					TPtrC8 appendBuf = bufferPtr.Right(sourceLength-bytesToReplace);
					iDes->Replace(aPosition, bytesToReplace, replaceBuf);
					iDes->Append(appendBuf);
					} 
				else
					iDes->Replace(aPosition, sourceLength, bufferPtr);

				} 
			else
				iDes->Append(bufferPtr.Ptr(),sourceLength);
			}
		else if (targetLength<0)
			User::Leave(KErrArgument);
		else if (aLength != 0)
			User::Leave(KErrOverflow);

		if (aSupplier)
			aSupplier->BufferEmptiedL(aBuffer);
		}
	else
		User::Leave(KErrNotSupported);
	}

/** 
Empties aBuffer into iFile at specified location.  Note that this is a synchronous write

@param  aBuffer
        The data buffer containing bytes to be written.
@param  aPosition
        The offset into file at which to start writing.
*/
void CMMFDescriptor::WriteBufferL( CMMFBuffer* aBuffer, TInt aPosition)
	{
	WriteBufferL( aBuffer, aPosition, NULL );
	}

/**
Returns the amount of space available for the clip.

@return The space available in descriptor (difference between length and maxlength).
*/
TInt64 CMMFDescriptor::BytesFree() 
	{
	TInt64 length = iDes->Length() ;
	TInt64 maxLength =  iDes->MaxLength() ;
	return( maxLength - length ) ;
	}

/**
Returns the length of the clip.

@return The length (not max length) of the descriptor.
*/
TInt CMMFDescriptor::Size() 
	{
	TInt length = iDes->Length();
	return(length);
	}

/**
Returns the data type as a fourCC code for the CMMFDescriptor data source.

@param  aMediaId
        The ID of the media for which the codec is obtained.

@return The data type fourCC code.
*/
TFourCC CMMFDescriptor::SourceDataTypeCode(TMediaId /*aMediaId*/) 
	{
	return iSourceFourCC ;
	}

/**
Returns the data type as a fourCC code of the CMMFDescriptor data sink.

Used by MDataSource and MDataSink.

@return The data type fourCC code.
*/
TFourCC CMMFDescriptor::SinkDataTypeCode(TMediaId /*aMediaId*/) 
	{
	return iSinkFourCC ;
	}

/**
CMMFDescriptor as a source is always passive so this function is not supported.

@param  aBuffer
        The emptied buffer.
*/
void CMMFDescriptor::BufferEmptiedL( CMMFBuffer* /*aBuffer*/ )
	{
	Panic(EMMFDescriptorPanicBufferEmptiedLNotSupported);
	}

/**
Tests whether a source buffer can be created.

@return	A boolean indicating if the buffer can be created. EFalse if a CMMFDescriptor cannot create 
        it's own buffer
*/
TBool CMMFDescriptor::CanCreateSourceBuffer()
	{
	return EFalse ;
	}

/**
Creates a source buffer.

@param  aMediaId
        The Media ID.
@param  aReference
        A boolean indicating if MDataSource owns the buffer. ETrue if MDataSource owns the buffer,
        EFalse if the caller owns the buffer.

@return	NULL as a CMMFFile cannot create it's own buffer
*/
CMMFBuffer* CMMFDescriptor::CreateSourceBufferL(  TMediaId /*aMediaId*/, TBool& /*aReference*/ )
	{
	User::Leave(KErrNotSupported);
	return NULL;
	}

/**
CMMFDescriptor as a sink is always passive so this function is not supported.

@param  aBuffer
        The filled buffer.
*/
void CMMFDescriptor::BufferFilledL( CMMFBuffer* /*aBuffer*/ )
	{
	Panic(EMMFDescriptorPanicBufferFilledLNotSupported);
	}

/**
Tests whether a sink buffer can be created.

@return A boolean indicating if the sink buffer can be created. EFalse if a CMMFDescriptor cannot 
        create it's own buffer.
*/
TBool CMMFDescriptor::CanCreateSinkBuffer()
	{
	return EFalse ;
	}

/**
Creates a sink buffer.

@param  aMediaId
        The Media ID.
@param  aReference
        A boolean indicating if MDataSource owns the buffer. ETrue if MDataSource owns the buffer,
        EFalse if the caller owns the buffer.

@return	NULL as a CMMFDescriptor cannot create it's own buffer
 */
CMMFBuffer* CMMFDescriptor::CreateSinkBufferL( TMediaId /*aMediaId*/ , TBool& /*aReference*/)
	{
	User::Leave(KErrNotSupported);
	return NULL;
	}