// Copyright (c) 2007-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:

 //

 /**

  @file

  @internalComponent

 */

 #include <mmf/devvideo/devvideobase.h>

 #include "buffermanager.h"

 #include "videoframebuffer.h"

 #include "rendererutil.h"

 /** Constructor for performing 1st stage construction */

 CRendererBufferManager::CRendererBufferManager(const RChunk& aChunk, TBool aTimed)

 : iChunk(aChunk),

   iTimed(aTimed),

   iAvailBuffers(TVideoFrameBuffer::iOffset), 

   iWaitingBuffers(TVideoFrameBuffer::iOffset), 

   iWaitingBuffersIter(iWaitingBuffers)

 	{}

 /** Destructor.	*/

 CRendererBufferManager::~CRendererBufferManager()

 	{

 	if (iTimed)

 		{

 		iMutex.Close();

 		}

 	iAvailBuffers.Reset();

 	iWaitingBuffers.Reset();

 	iBuffers.ResetAndDestroy();

 	iChunk.Close();

 	}

 /** Two-phased constructor. */

 CRendererBufferManager* CRendererBufferManager::NewL(const RSurfaceManager::TSurfaceInfoV01& aSurfaceInfo, const RArray<TInt>& aBufferOffsets, const RChunk& aChunk, TBool aTimed)

 	{

 	CRendererBufferManager* self = new (ELeave) CRendererBufferManager(aChunk, aTimed);

 	CleanupStack::PushL(self);

 	self->ConstructL(aSurfaceInfo, aBufferOffsets);

 	CleanupStack::Pop(); // self;

 	return self;

 	}

 /** Constructor for performing 2nd stage construction */

 void CRendererBufferManager::ConstructL(const RSurfaceManager::TSurfaceInfoV01& aSurfaceInfo, const RArray<TInt>& aBufferOffsets)

 	{

 	if (iTimed)

 		{

 		User::LeaveIfError(iMutex.CreateLocal());

 		}

 	TUncompressedVideoFormat format = VideoRendererUtil::ConvertUidPixelFormatToUncompressedVideoFormatL(aSurfaceInfo.iPixelFormat);

 	TVideoFrameBuffer* buffer = NULL;

 	for (TInt i = 0; i < aSurfaceInfo.iBuffers; ++i)

 		{

 		buffer = new (ELeave) TVideoFrameBuffer(format, aSurfaceInfo.iStride, i, iChunk, aBufferOffsets[i]);

 		buffer->SetBufferStatus(TVideoFrameBuffer::EAvailable);

 		CleanupStack::PushL(buffer);

 		iBuffers.AppendL(buffer);

 		CleanupStack::Pop(buffer);

 		iAvailBuffers.AddLast(*buffer);

 		}

 	}

 /** Lock buffer table on timed mode */

 void CRendererBufferManager::Lock()

 	{

 	if (iTimed)

 		{

 		iMutex.Wait();

 		}

 	}

 /** Unlock buffer table on timed mode */

 void CRendererBufferManager::Unlock()

 	{

 	if (iTimed)

 		{

 		iMutex.Signal();

 		}

 	}

 /** Get the next available buffer */

 TVideoFrameBuffer* CRendererBufferManager::NextBuffer()

 	{

 	Lock();

 	TVideoFrameBuffer* buffer = NULL;

 	if (!iAvailBuffers.IsEmpty())

 		{

 		buffer = iAvailBuffers.First();

 		__ASSERT_DEBUG(buffer->BufferStatus() == TVideoFrameBuffer::EAvailable,

 				User::Panic(_L("CRBM::NextBuffer"), KErrCorrupt));

 		buffer->SetBufferStatus(TVideoFrameBuffer::EUsedByClient);

 		buffer->DblQueLink().Deque();

 		}

 	Unlock();

 	return buffer;

 	}

 /** Check if a buffer was previously sent to client */

 TBool CRendererBufferManager::BufferUsedByClient(TVideoFrameBuffer* aBuffer)

 	{

 	TVideoFrameBuffer* buffer = iBuffers[aBuffer->BufferId()];

 	if (buffer->BufferStatus() == TVideoFrameBuffer::EUsedByClient && aBuffer == buffer)

 		{

 		return ETrue;

 		}

 	return EFalse;

 	}

 /** Release the buffer for reuse */

 TBool CRendererBufferManager::ReleaseBuffer(TVideoFrameBuffer* aBuffer)

 	{

 	TBool released = EFalse;

 	Lock();

 	if (BufferUsedByClient(aBuffer))

 		{

 		// release the buffer if it was previously sent to client

 		aBuffer->SetBufferStatus(TVideoFrameBuffer::EAvailable);

 		iAvailBuffers.AddLast(*aBuffer);		

 		released = ETrue;

 		}

 	Unlock();

 	return released;

 	}

 /** Received notification that buffer become available */

 void CRendererBufferManager::BufferAvailable(TInt aBufferId)

 	{

 	Lock();

 	TVideoFrameBuffer* buffer = iBuffers[aBufferId];

 	__ASSERT_DEBUG(buffer->BufferStatus() == TVideoFrameBuffer::EWaiting || buffer->BufferStatus() == TVideoFrameBuffer::ESubmitted,

 			User::Panic(_L("CRBM::BufferAvailable"), KErrCorrupt));

 	buffer->SetBufferStatus(TVideoFrameBuffer::EAvailable);

 	buffer->DblQueLink().Deque();

 	iAvailBuffers.AddLast(*buffer);

 	Unlock();

 	}

 /** Get the next waiting buffer to submit

  @param aRemoveFromList If true, mark the buffer as submitted and deque from waiting list

  @param aIsLast ETrue on result if the returned buffer is the last buffer in waiting list

  */

 TVideoFrameBuffer* CRendererBufferManager::WaitingBuffer(TBool aRemoveFromList, TBool& aIsLast)

 	{

 	Lock();

 	TVideoFrameBuffer* buf = NULL;

 	if (iWaitingBuffers.IsEmpty() == EFalse)

 		{

 		buf = iWaitingBuffers.First();

 		__ASSERT_DEBUG(buf->BufferStatus() == TVideoFrameBuffer::EWaiting,

 				User::Panic(_L("CRBM::WaitingBuffer"), KErrCorrupt));

 		aIsLast = iWaitingBuffers.IsLast(buf);

 		if (aRemoveFromList)

 			{

 			buf->SetBufferStatus(TVideoFrameBuffer::ESubmitted);

 			buf->DblQueLink().Deque();

 			}

 		}

 	Unlock();

 	return buf;

 	}

 /** Mark the buffer as submitted and deque from waiting list */

 void CRendererBufferManager::BufferSubmitted(TVideoFrameBuffer* aBuffer)

 	{

 	Lock();

 	__ASSERT_DEBUG(aBuffer->BufferStatus() == TVideoFrameBuffer::EWaiting,

 			User::Panic(_L("CRBM::BufferSubmitted"), KErrArgument));

 	aBuffer->SetBufferStatus(TVideoFrameBuffer::ESubmitted);

 	aBuffer->DblQueLink().Deque();

 	Unlock();

 	}

 /** Return ETrue if the waiting list is empty */

 TBool CRendererBufferManager::WaitingListIsEmpty()

 	{

 	Lock();

 	TBool ret = iWaitingBuffers.IsEmpty();

 	Unlock();

 	return ret;

 	}

 /** 

 Mark a buffer as waiting for update and add to waiting list, return ETrue 

 if rescheduled is needed (i.e. head of waiting list has changed and the list wasn't empty) */

 TBool CRendererBufferManager::UpdateBuffer(TVideoFrameBuffer* aBuffer, const TTime& aTime)

 	{

 	Lock();

 	TBool headChanged = EFalse;

 	if (BufferUsedByClient(aBuffer))

 		{

 		aBuffer->SetBufferStatus(TVideoFrameBuffer::EWaiting);

 		aBuffer->SetPresentationTime(aTime);

 		// add buffer to waiting buffer list according to presentation time

 		if (iWaitingBuffers.IsEmpty())

 			{

 			iWaitingBuffers.AddLast(*aBuffer);

 			}

 		else

 			{

 			TVideoFrameBuffer* buf = iWaitingBuffers.Last();

 			if (aTime >= buf->PresentationTime())

 				{

 				iWaitingBuffers.AddLast(*aBuffer);

 				}

 			else

 				{

 				// client tried to insert a older frame, search for the right position to insert

 				iWaitingBuffersIter.SetToFirst();

 				while ((buf = iWaitingBuffersIter++) != NULL)

 					{

 					if (aTime < buf->PresentationTime())

 						{

 						// Found the slot

 						if (iWaitingBuffers.IsFirst(buf))

 							{

 							iWaitingBuffers.AddFirst(*aBuffer);

 							headChanged = ETrue;

 							}

 						else

 							{

 							aBuffer->DblQueLink().AddBefore(&(buf->DblQueLink()));

 							}

 						}

 					}

 				}

 			}

 		}

 	else

 		{

 		DEBUGPRINT1(_L("CRendererBufferManager::UpdateBuffer receive buffer not usable by client"));

 		__ASSERT_DEBUG(EFalse, User::Panic(_L("CRBM::UpdateBuf"), KErrBadHandle));

 		}

 	Unlock();

 	return headChanged;

 	}