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