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

	}