/*
* Copyright (c) 2009-2010 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 <hash.h>
#include "omxiltestmd5sinkprocessingfunction.h"
#include "omxiltestmd5sinkconfigmanager.h"
#include <openmax/il/common/omxilcallbacknotificationif.h>
#include "omxiltestmd5sinkconst.h"

enum { KMsgQueueSize = 10 };

COmxILTestMD5SinkProcessingFunction* COmxILTestMD5SinkProcessingFunction::NewL(MOmxILCallbackNotificationIf& aCallbacks)
	{
	COmxILTestMD5SinkProcessingFunction* self = new (ELeave) COmxILTestMD5SinkProcessingFunction(aCallbacks);
	CleanupStack::PushL(self);
	self->ConstructL(aCallbacks);
	CleanupStack::Pop(self);
	return self;
	}

COmxILTestMD5SinkProcessingFunction::COmxILTestMD5SinkProcessingFunction(MOmxILCallbackNotificationIf& aCallbacks)
: COmxILProcessingFunction(aCallbacks)
	{
	}

void COmxILTestMD5SinkProcessingFunction::ConstructL(MOmxILCallbackNotificationIf& aCallback)
	{
	iMD5Active = CMD5Active::NewL(aCallback);
	iFlushHandler = CFlushActive::NewL(*iMD5Active);
	}

COmxILTestMD5SinkProcessingFunction::~COmxILTestMD5SinkProcessingFunction()
	{
    delete iFlushHandler;
	delete iMD5Active;
	}

void COmxILTestMD5SinkProcessingFunction::SetConfigManager(COmxILTestMD5SinkConfigManager* aConfigManager)
	{
	iMD5Active->SetConfigManager(aConfigManager);
	}

OMX_ERRORTYPE COmxILTestMD5SinkProcessingFunction::StateTransitionIndication(TStateIndex /*aNewState*/)
	{
    return OMX_ErrorNone;
	}

OMX_ERRORTYPE COmxILTestMD5SinkProcessingFunction::BufferFlushingIndication(TUint32 aPortIndex, OMX_DIRTYPE aDirection)
	{
    if ((aPortIndex != OMX_ALL) && ((aPortIndex != KMD5SINK_OPB0PORT_INDEX) || (aDirection != OMX_DirInput)))
        {
        return OMX_ErrorNone;
        }
    
    iFlushHandler->Flush();
    
	return OMX_ErrorNone;
	}

OMX_ERRORTYPE COmxILTestMD5SinkProcessingFunction::ParamIndication(OMX_INDEXTYPE /*aParamIndex*/,
													const TAny* /*apComponentParameterStructure*/)
	{
	return OMX_ErrorNone;
	}

OMX_ERRORTYPE COmxILTestMD5SinkProcessingFunction::ConfigIndication(OMX_INDEXTYPE /*aConfigIndex*/,
												 const TAny* /*apComponentConfigStructure*/)
	{
	return OMX_ErrorNone;
	}

OMX_ERRORTYPE COmxILTestMD5SinkProcessingFunction::BufferIndication(OMX_BUFFERHEADERTYPE* apBufferHeader,
																OMX_DIRTYPE aDirection)			
	{
	__ASSERT_ALWAYS(aDirection == OMX_DirInput, User::Invariant());
	return iMD5Active->DeliverBuffer(apBufferHeader);
	}

OMX_BOOL COmxILTestMD5SinkProcessingFunction::BufferRemovalIndication(OMX_BUFFERHEADERTYPE* apBufferHeader, OMX_DIRTYPE aDirection)
	{
	__ASSERT_ALWAYS(aDirection == OMX_DirInput, User::Invariant());
	return iMD5Active->RemoveBuffer(apBufferHeader);
	}

///////////////////////////////////////////////////////////////////////////////////////////

CMD5Active* CMD5Active::NewL(MOmxILCallbackNotificationIf& aCallback)
	{
	CMD5Active* self = new(ELeave) CMD5Active(aCallback);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CMD5Active::CMD5Active(MOmxILCallbackNotificationIf& aCallback):
CActive(CActive::EPriorityStandard),
iCallback(aCallback)
	{
	CActiveScheduler::Add(this);
	}

void CMD5Active::ConstructL()
	{
	iMD5 = CMD5::NewL();
	User::LeaveIfError(iBuffers.CreateLocal(KMsgQueueSize));
	iBuffers.NotifyDataAvailable(iStatus);
	SetActive();
	}

CMD5Active::~CMD5Active()
	{
	Cancel();
	delete iMD5;
	}

void CMD5Active::SetConfigManager(COmxILTestMD5SinkConfigManager* aConfigManager)
	{
	iConfigManager = aConfigManager;
	}

OMX_ERRORTYPE CMD5Active::DeliverBuffer(OMX_BUFFERHEADERTYPE* aBuffer)
	{
	TInt aErr = iBuffers.Send(aBuffer);
	if(aErr == KErrNone)
		{
		return OMX_ErrorNone;
		}
	else if(aErr == KErrOverflow)
		{
		return OMX_ErrorInsufficientResources;
		}
	else
		{
		return OMX_ErrorUndefined;
		}
	}

OMX_BOOL CMD5Active::RemoveBuffer(OMX_BUFFERHEADERTYPE* aBuffer)
	{
	TBool removed = EFalse;
	TRAPD(err, removed = RemoveFromQueueL(iBuffers, aBuffer));
	if(err)
		{
		User::Invariant();
		}
	return removed ? OMX_TRUE : OMX_FALSE;
	}

TBool CMD5Active::RemoveFromQueueL(RMsgQueue<OMX_BUFFERHEADERTYPE*>& aQueue, OMX_BUFFERHEADERTYPE* aBufferHeader)
	{
	TBool removed = EFalse;
	RMsgQueue<OMX_BUFFERHEADERTYPE*> tempQueue;
	User::LeaveIfError(tempQueue.CreateLocal(KMsgQueueSize));
	OMX_BUFFERHEADERTYPE* bufferHeader = NULL;
	while(aQueue.Receive(bufferHeader) != KErrUnderflow)
		{
		if(bufferHeader != aBufferHeader)
			{
			__ASSERT_ALWAYS(tempQueue.Send(bufferHeader) == KErrNone, User::Invariant());
			}
		else
			{
			removed = ETrue;
			}
		}
	while(tempQueue.Receive(bufferHeader) != KErrUnderflow)
		{
		__ASSERT_ALWAYS(aQueue.Send(bufferHeader) == KErrNone, User::Invariant());
		}
	tempQueue.Close();
	return removed;
	}

void CMD5Active::RunL()
	{
	OMX_BUFFERHEADERTYPE* aBuff;
	// may have an empty queue despite being notified if a RemoveBuffer() occured in the meantime
	if(iBuffers.Receive(aBuff) != KErrUnderflow)
		{	
		// hash the buffer
		TPtrC8 aDes(aBuff->pBuffer + aBuff->nOffset, aBuff->nFilledLen);
		TPtrC8 aHash = iMD5->Hash(aDes);
		iConfigManager->SetHash(aHash);
		aBuff->nFilledLen = 0;
		OMX_U32 flags = aBuff->nFlags;
		iCallback.BufferDoneNotification(aBuff, KMD5SINK_OPB0PORT_INDEX, OMX_DirInput);
		if(flags)
			{
			iCallback.EventNotification(OMX_EventBufferFlag, 0, flags, NULL);
			}
		}	
	iBuffers.NotifyDataAvailable(iStatus);
	SetActive();
	}

void CMD5Active::FlushHeaders()
    {
    OMX_BUFFERHEADERTYPE* aBuff;
    
    while(iBuffers.Receive(aBuff) == KErrNone)
        {   
        aBuff->nFilledLen = 0;
        iCallback.BufferDoneNotification(aBuff, KMD5SINK_OPB0PORT_INDEX, OMX_DirInput);
        }
    }

void CMD5Active::DoCancel()
	{
	iBuffers.CancelDataAvailable();
	}

///////////////////////////////////////////////////////////////////////////////////////////

CFlushActive* CFlushActive::NewL(CMD5Active& aBufferHandler)
    {
    CFlushActive* self = new (ELeave) CFlushActive(aBufferHandler);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

CFlushActive::CFlushActive(CMD5Active& aBufferHandler):
CActive(CActive::EPriorityHigh),    // Higher priority than CMD5Active to ensure we run before them when the Active Scheduler is picking who to run next
iBufferHandler(aBufferHandler)
    {
    CActiveScheduler::Add(this);
    iRunLContext = RThread();
    iStatus = KRequestPending;
    SetActive();
    }

void CFlushActive::ConstructL()
    {
    User::LeaveIfError(iWaitSemaphore.CreateLocal(0));
    }

CFlushActive::~CFlushActive()
    {
    Cancel();
    iRunLContext.Close();
    iWaitSemaphore.Close(); 
    }

void CFlushActive::Flush()
    {
    RThread currentContext;
    if (currentContext.Id() == iRunLContext.Id())
        {
        // The same context so cannot be running concurrently with CMD5Active::RunL() so safe to drain buffer queue
        iBufferHandler.FlushHeaders();
        return;
        }
    
    // Different thread to the one in which the Active objects are running,
    TRequestStatus* selfStatus = &iStatus;
    iRunLContext.RequestComplete(selfStatus, KErrNone);
    iWaitSemaphore.Wait();
    }
     
void CFlushActive::RunL()
    {
    // Now sure we are not running concurrently with CMD5Active::RunL()
    iBufferHandler.FlushHeaders();
    iStatus = KRequestPending;
    SetActive();
    iWaitSemaphore.Signal();
    }

void CFlushActive::DoCancel()
    {
    iWaitSemaphore.Signal();    // Only happens as part of deletion so irrelevant whether we are blocked or not
    TRequestStatus* selfStatus = &iStatus;
    User::RequestComplete(selfStatus, KErrNone);
    }