// Copyright (c) 2006-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 <fbs.h>

 #include <mmf/server/mmfdatabuffer.h>

 #include "mdfvideodecoderbuffermanager.h"

 #define MDFVIDEODECODERBUFFERMANAGER_DEBUG 1

 #if defined (SYMBIAN_MDFVIDEODECODERBUFFERMANAGER_DEBUG)

 #define DEBUG_PRINT( x ) ( RDebug::Print( x ) )

 #define DEBUG_PRINT2( x,y ) ( RDebug::Print( x,y ) )

 #define DEBUG_PRINT3( x,y,z ) ( RDebug::Print( x,y,z ) )

 #else

 #define DEBUG_PRINT( x )

 #define DEBUG_PRINT2( x,y ) 

 #define DEBUG_PRINT3( x,y,z ) 

 #endif // defined (SYMBIAN_MDFVIDEODECODERBUFFERMANAGER_DEBUG)

 CVideoDataBuffer::CVideoDataBuffer()

 	{

 	}

 TUint CVideoDataBuffer::Length()

 	{

 	return iSize;

 	}

 CVideoDataBuffer* CVideoDataBuffer::NewL(TUint aSize)

 	{

 	CVideoDataBuffer* self = new (ELeave) CVideoDataBuffer;

 	CleanupStack::PushL(self);

 	self->ConstructL(aSize);

 	CleanupStack::Pop(self);

 	return self;

 	}

 void CVideoDataBuffer::ConstructL(TUint aBufferSize)

 	{

 	iSize = aBufferSize;

 	CMMFDescriptorBuffer* buffer = CMMFDescriptorBuffer::NewL(aBufferSize);

 	TDes8& des = buffer->Data();

 	TUint8* ptr = const_cast<TUint8*>(des.Ptr());

 	iVideoInputBuffer.iData.Set(ptr, des.Length(), des.MaxLength());

 	iMmfBuffer = buffer;

 	}

 CVideoDataBuffer::operator CMMFBuffer*()

 	{

 	return iMmfBuffer;

 	}

 CVideoDataBuffer::operator TVideoInputBuffer&()

 	{

 	return iVideoInputBuffer;

 	}

 TBool CVideoDataBuffer::operator== (const CMMFBuffer* aBuffer) const

 	{

 	return (aBuffer == iMmfBuffer); 	

 	}

 TBool CVideoDataBuffer::operator== (const TVideoInputBuffer& aVideoInputBuffer) const

 	{

 	// compare the data pointers

 	return iVideoInputBuffer.iData == aVideoInputBuffer.iData;

 	}

 CVideoDataBuffer::~CVideoDataBuffer()

 	{

 	delete iMmfBuffer;

 	}

 CVideoFrameBuffer::CVideoFrameBuffer(TSize aFrameSize, 

 											TUncompressedVideoFormat aFormat, 

 											TDisplayMode aDisplayMode) 

 	: iRawPtr(0,0),

 	iFrameSize(aFrameSize),

 	iVideoFormat(aFormat),

 	iDisplayMode(aDisplayMode)

 	{

 	}

 CVideoFrameBuffer* CVideoFrameBuffer::NewL(TSize aFrameSize, 

 													TUncompressedVideoFormat aFormat,		

 													TDisplayMode aDisplayMode)

 	{

 	CVideoFrameBuffer* self = new (ELeave) CVideoFrameBuffer(aFrameSize, aFormat, aDisplayMode);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 void CVideoFrameBuffer::SetLastBuffer(TBool aLastBuffer)

 	{

 	iLastBuffer = aLastBuffer;

 	}

 TBool CVideoFrameBuffer::LastBuffer()

 	{

 	return iLastBuffer;

 	}

 void CVideoFrameBuffer::ConstructL()

 	{

 	iFrameBufferSize = CFbsBitmap::ScanLineLength(iFrameSize.iWidth, iDisplayMode) *

 														iFrameSize.iHeight;

 	Mem::FillZ(&iVideoPicture, sizeof(TVideoPicture));

 	if(iVideoFormat.iDataFormat == ERgbFbsBitmap) 

 		{

 		iBitmap = new(ELeave)CFbsBitmap;

 		User::LeaveIfError(iBitmap->Create(iFrameSize, iDisplayMode));				

 		DEBUG_PRINT2(_L("BufferManager: Created bitmap at 0x%08x"), iBitmap);

 		iVideoPicture.iData.iRgbBitmap = iBitmap;

 		iBitmap->LockHeap();

 		TRAPD(err, iMmfBuffer = CMMFPtrBuffer::NewL(TPtr8(reinterpret_cast<TUint8*>(iBitmap->DataAddress()),

 												iFrameBufferSize,

 												iFrameBufferSize)) );

 		iBitmap->UnlockHeap();

 		User::LeaveIfError(err);

 		}

 	else if((iVideoFormat.iDataFormat == ERgbRawData) || (iVideoFormat.iDataFormat == EYuvRawData))

 		{

 		iRawBuffer  = HBufC8::NewMaxL(iFrameBufferSize);

 		iRawPtr.Set(iRawBuffer->Des());

 		iMmfBuffer = CMMFPtrBuffer::NewL(iRawPtr);

 		iVideoPicture.iData.iRawData = &iRawPtr;

 		}

 	iVideoPicture.iData.iDataFormat = iVideoFormat.iDataFormat;

 	iVideoPicture.iData.iDataSize = iFrameSize;

 	}

 CVideoFrameBuffer::operator CMMFBuffer*()

 	{

 	return iMmfBuffer;

 	}

 CVideoFrameBuffer::operator TVideoPicture&()

 	{

 	return iVideoPicture;

 	}

 CVideoFrameBuffer::operator CMMFBuffer&()

 	{

 	return *iMmfBuffer;

 	}

 CVideoFrameBuffer::operator TVideoPicture*()

 	{

 	return &iVideoPicture;

 	}

 void CVideoFrameBuffer::LockFrameBufferHeap()

 	{

 	iBitmap->LockHeap();

 	iHeapLocked = ETrue;

 	}

 void CVideoFrameBuffer::UnlockFrameBufferHeap()

 	{

 	if (iHeapLocked)

 		{

 		iBitmap->UnlockHeap();

 		iHeapLocked = EFalse;

 		}

 	}

 TBool CVideoFrameBuffer::operator== (const CMMFBuffer* aBuffer) const

 	{

 	return (aBuffer == iMmfBuffer); 	

 	}

 TBool CVideoFrameBuffer::operator== (const TVideoPicture& aVideoInputBuffer) const

 	{

 	// compare the data pointers - cheat, it is the same pointer for the bitmap and 

 	// raw data

 	return iVideoPicture.iData.iRawData == aVideoInputBuffer.iData.iRawData;

 	}

 CVideoFrameBuffer::~CVideoFrameBuffer()

 	{

 	UnlockFrameBufferHeap();

 	delete iMmfBuffer;

 	delete iBitmap;

 	delete iRawBuffer;

 	}

 /** 

  Constructs a new instance of CMDFVideoDecoderBufferManager.

  @return    "CMDFVideoDecoderBufferManager*"

             A pointer to the newly constructed CMDFVideoDecoderBufferManager

  */

 CMdfVideoDecoderBufferManager* CMdfVideoDecoderBufferManager::NewL()

 	{

 	CMdfVideoDecoderBufferManager* s = new(ELeave) CMdfVideoDecoderBufferManager;

 	CleanupStack::PushL(s);

 	s->ConstructL();

 	CleanupStack::Pop(s);

 	return (static_cast<CMdfVideoDecoderBufferManager*>(s));

 	}

 CMdfVideoDecoderBufferManager::CMdfVideoDecoderBufferManager()

 	{

 	}

 void CMdfVideoDecoderBufferManager::ConstructL()

 	{

 	RFbsSession::Connect();

 	}

 /**

  Default destructor

  */

 CMdfVideoDecoderBufferManager::~CMdfVideoDecoderBufferManager()

 	{

 	// get rid of input buffers

 	delete iInputBuffer;

 	// cleanup frame buffer arrays	

 	iEmptyFrameBuffers.ResetAndDestroy();

 	iFilledFrameBuffers.ResetAndDestroy();

 	iFrameBuffersInUse.ResetAndDestroy();

 	RFbsSession::Disconnect();

 	DEBUG_PRINT(_L("BufferManager: Closing down"));

 	}

 /** 

  Initializes the decoder buffer manager.

  @param		"const TUncompressedVideoFormat& aFormat"

  			The image format to decode into

  */

 void CMdfVideoDecoderBufferManager::Init(const TUncompressedVideoFormat& aFormat)

 	{

 	DEBUG_PRINT(_L("BufferManager: Initializing"));

 	iFormat = aFormat;

 	// The actual frame size will come from the VOL headers.

 	// Set an initial value for iFrameBufferSize so we can get

 	// the VOL headers themselves.

 	// Also ensure we allow one free output buffer.

 	iFrameBufferSize = 1024; // 1k

 	iMaxFrameBuffers = 1;

 	iInputBufferInUse = EFalse;

 	}

 /** 

  Creates a new empty input buffer.

  @param		"TUint aBufferSize"

  			The requested buffer size.

  @return	"TVideoInputBuffer&"

  			An empty input buffer.

  @leave		May leave with KErrInUse if no input buffer is available, or with KErrNoMemory

  			if a buffer cannot be created or adjusted. 			 			

  */

 CVideoDataBuffer& CMdfVideoDecoderBufferManager::CreateDataBufferL(TUint aBufferSize)

 	{

 	// We use one input buffer and one overflow buffer.

 	// If the app requests another buffer before this one has been processed, then leave.

 	if(iInputBufferInUse) 

 		{

 		User::Leave(KErrInUse);

 		}

 	if(aBufferSize < 1)

 		{

 		User::Leave(KErrArgument);

 		}

 	// Create or adjust the input buffer

 	if(!iInputBuffer) 

 		{

 		iInputBuffer = CVideoDataBuffer::NewL(aBufferSize);

 		}	

 	else if(iInputBuffer->Length() != aBufferSize)

 		{

 		// NB don't use ReAllocL() as it will panic if the buffer is shrinking

 		// Use temp variable		

 		CVideoDataBuffer* tempBuffer = CVideoDataBuffer::NewL(aBufferSize);

 		// Coverity reports a leave_without_push error here because

 		// CVideoDataBuffer contains a frame buffer member which could contain

 		// a CFbsBitmap member which can panic during its destructor. The panic

 		// has a trapped leave and for some reason coverity does not recognise it.

 		// Mark as false positive

 		// coverity[leave_without_push : FALSE]

 		delete iInputBuffer;

 		iInputBuffer = NULL;

 		iInputBuffer = tempBuffer;		

 		}

 	return *iInputBuffer;	

 	}

 void CMdfVideoDecoderBufferManager::ReturnDataBufferL(TVideoInputBuffer& aInputBuffer)

 	{

 	if (!iInputBuffer)

 		{

 		User::Leave(KErrNotFound);

 		}	

 	// if this buffer isn't the input buffer, leave

 	if(! (*iInputBuffer == aInputBuffer) )

 		{

 		User::Leave(KErrNotFound);	

 		}

 	// if the buffer is not in use, leave

 	if(!iInputBufferInUse)

 		{

 		User::Leave(KErrInUse);	

 		}

 	// finished with input buffer - mark it unused

 	iInputBufferInUse = EFalse;

 	}

 CVideoDataBuffer& CMdfVideoDecoderBufferManager::GetDataBufferL()

 	{

 	if (!iInputBuffer)

 		{

 		User::Leave(KErrNotFound);

 		}

 	if (iInputBufferInUse)

 		{

 		User::Leave(KErrInUse);

 		}

 	iInputBufferInUse = ETrue;

 	return *iInputBuffer;

 	}

 /** 

  Gets the number of available input buffers.

  @return	"TInt"

  			The number of available input buffers.

  */

 TInt CMdfVideoDecoderBufferManager::DataBuffersAvailable() const

 	{

 	// this plugin has one input buffer. if it is in use (i.e. the client hasn't been

 	// notified with MdvppNewBuffers()) then return 0.

 	return ((iInputBufferInUse) ? 0 : 1);

 	}

 /** 

  Sets the frame size.

  @param		"const TSize& aSize"

  			The frame size.

  */

 void CMdfVideoDecoderBufferManager::SetFrameSize(const TSize& aSize)

 	{

 	iFrameSize = aSize;

 	}

 /** 

  Gets the frame size.

  @return	"const TSize&"

  			The frame size.

  */

 const TSize& CMdfVideoDecoderBufferManager::FrameSize() const

 	{

 	return iFrameSize;

 	}

 /** 

  Sets the frame buffer size.

  @param		"TInt aSize"

  			The frame buffer size.

  */

 void CMdfVideoDecoderBufferManager::SetFrameBufferSize(TInt aSize)

 	{

 	iFrameBufferSize = aSize;

 	}

 /** 

  Gets the frame buffer size.

  @return	"TInt"

  			The frame buffer size.

  */

 TInt CMdfVideoDecoderBufferManager::FrameBufferSize() const

 	{

 	return iFrameBufferSize;

 	}

 /** 

  Gets the maximum number of frame buffers.

  @return	"TInt"

  			The maximum number of frame buffers.

  */

 TInt CMdfVideoDecoderBufferManager::MaxFrameBuffers() const

 	{

 	return iMaxFrameBuffers;

 	}

 /** 

  Gets the number of available pictures (full output buffers).

  @return	"TInt"

  			The number of available pictures.

  */

 TInt CMdfVideoDecoderBufferManager::FilledFrameBuffersAvailable() const

 	{

 	return ((iFilledFrameBuffers.Count() > 0) ? 1 : 0);

 	}

 /** 

  Gets the number of available frame buffers.

  @return	"TInt"

  			The number of available frame buffers.

  */

 TInt CMdfVideoDecoderBufferManager::EmptyFrameBuffersAvailable() const

 	{

 	return ((iEmptyFrameBuffers.Count() < iMaxFrameBuffers) ? 1 : 0);

 	}

 /** 

  Gets the first available framebuffer

  @return	"TVideoPicture&"

  			A picture.

  @leave		May leave with KErrNotReady if no picture is available. 			

  */

 CVideoFrameBuffer& CMdfVideoDecoderBufferManager::GetEmptyFrameBufferL(TBool aLockHeap)

 	{

 	DEBUG_PRINT2(_L("Get Empty Frame Buffer avail: %d"),iEmptyFrameBuffers.Count());

 	if(iEmptyFrameBuffers.Count() == 0) 

 		{

 		User::Leave(KErrNotReady);

 		}

 	CVideoFrameBuffer* frameBuf = iEmptyFrameBuffers[0];

 	iFrameBuffersInUse.AppendL(frameBuf);

 	iEmptyFrameBuffers.Remove(0);

 	if (aLockHeap)

 		{

 		frameBuf->LockFrameBufferHeap();

 		}

 	return *frameBuf;

 	}

 /** 

  Gets the first available picture (full frame buffer).

  @return	"TVideoPicture&"

  			A picture.

  @leave		May leave with KErrNotReady if no picture is available. 			

  */

 CVideoFrameBuffer& CMdfVideoDecoderBufferManager::GetFilledFrameBufferL(TBool aLockHeap)

 	{

 	DEBUG_PRINT2(_L("Get Filled Frame Buffer avail: %d"),iFilledFrameBuffers.Count());

 	if(iFilledFrameBuffers.Count() == 0) 

 		{		

 		User::Leave(KErrNotReady);

 		}

 	CVideoFrameBuffer* frameBuf = iFilledFrameBuffers[0];

 	iFilledFrameBuffers.Remove(0);

 	iFrameBuffersInUse.AppendL(frameBuf);

 	if (aLockHeap)

 		{

 		frameBuf->LockFrameBufferHeap();

 		}

 	return *frameBuf;

 	}

 /** 

  Gets the last displayed picture.

  Used by Direct Screen Access to redraw.

  @return	"TPictureData&"

  			The last displayed picture.

  @leave		May leave with KErrNotReady if no picture is available. 			

  */

 const TPictureData& CMdfVideoDecoderBufferManager::LastPictureL() const

 	{

 	// it's a union, so we can check either iRgbBitmap or iRawData

 	if(!iLastDisplayedFrame.iRgbBitmap) 

 		{

 		User::Leave(KErrNotReady);

 		}

 	return iLastDisplayedFrame;

 	}

 /** 

  Gets a new empty frame buffer.

  @param		aDisplayMode

  			The display mode of the bitmap to be created.

  @return	"TVideoPicture&"

  			A frame buffer.

  @leave		May leave with KErrNotReady if no frame buffer is available, or if there

  			is no memory to create a new one. 

  */

 CVideoFrameBuffer& CMdfVideoDecoderBufferManager::CreateFrameBufferL(TDisplayMode aDisplayMode) 

 	{

 	CVideoFrameBuffer* frameBuffer = CVideoFrameBuffer::NewL(iFrameSize, iFormat, aDisplayMode);

 	CleanupStack::PushL(frameBuffer);

 	iEmptyFrameBuffers.AppendL(frameBuffer);

 	CleanupStack::Pop(frameBuffer);

 	DEBUG_PRINT2(_L("BufferManager: Created frame buffer; %d buffers in use"), iEmptyFrameBuffers.Count());

 	return *frameBuffer;

 	}

 /** 

  Returns a used picture to the buffer manager for disposal.

  @param		"TVideoPicture* aFrameBuffer"

  			A used picture.

  @param		"TBool aSaveLast"

  			Save this picture as the last displayed (for redraw).

  @leave		May leave with KErrNotFound if the picture does not exist. 			

  */

 void CMdfVideoDecoderBufferManager::ReturnFrameBufferL(TVideoPicture& aFrameBuffer, CVideoFrameBuffer::TFrameBufferState aState)

 	{

 	DEBUG_PRINT(_L("Return Frame Buffer from TVideoPicture"));

 	TInt bufIndex;

 	User::LeaveIfError(bufIndex = FindFrameBuffer(aFrameBuffer));

 	// remove from the list of avaible buffers

 	CVideoFrameBuffer* frameBuf = iFrameBuffersInUse[bufIndex];

 	frameBuf->UnlockFrameBufferHeap();

 	if (aState == CVideoFrameBuffer::EEmptied)

 		{

 		DEBUG_PRINT(_L("Added to empty pool"));

 		iEmptyFrameBuffers.AppendL(frameBuf);

 		}

 	else

 		{

 		DEBUG_PRINT(_L("Added to filled pool"));

 		iFilledFrameBuffers.AppendL(frameBuf);

 		}

 	iFrameBuffersInUse.Remove(bufIndex);

 	}

 void CMdfVideoDecoderBufferManager::ReturnFrameBufferL(CMMFBuffer* aBuffer, 

 									CVideoFrameBuffer::TFrameBufferState aState,

 									TBool aLastBuffer)

 	{

 	DEBUG_PRINT(_L("Return Frame buffer from CMMFBuffer"));

 	TInt bufIndex;

 	User::LeaveIfError(bufIndex = FindFrameBuffer(aBuffer));

 	// remove from the list of avaible buffers

 	CVideoFrameBuffer* frameBuf = iFrameBuffersInUse[bufIndex];

 	frameBuf->SetLastBuffer(aLastBuffer);

 	frameBuf->UnlockFrameBufferHeap();

 	if (aState == CVideoFrameBuffer::EEmptied)

 		{

 		DEBUG_PRINT(_L("Added to empty pool"));

 		iEmptyFrameBuffers.AppendL(frameBuf);

 		}

 	else

 		{

 		DEBUG_PRINT(_L("Added to filled pool"));

 		iFilledFrameBuffers.AppendL(frameBuf);

 		}

 	iFrameBuffersInUse.Remove(bufIndex);

 	}

 // private methods

 TInt CMdfVideoDecoderBufferManager::FindFrameBuffer(const TVideoPicture& aFrameBuffer) const

 	{

 	TInt theCount = iFrameBuffersInUse.Count();

 	TInt found = KErrNotFound;

 	for(TInt i = 0; i < theCount; i++) 

 		{

 		if(*iFrameBuffersInUse[i] == aFrameBuffer) 

 			{

 			found = i;

 			break;

 			}

 		}

 	return found;

 	}

 TInt CMdfVideoDecoderBufferManager::FindFrameBuffer(const CMMFBuffer* aBuffer) const

 	{

 	TInt theCount = iFrameBuffersInUse.Count();

 	TInt found = KErrNotFound;

 	for(TInt i = 0; i < theCount; i++) 

 		{

 		if(*iFrameBuffersInUse[i] == aBuffer) 

 			{

 			found = i;

 			break;

 			}

 		}

 	return found;

 	}

 // end