/*
* Copyright (c) 2008-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 <openmax/il/common/omxilspecversion.h>
#include <openmax/il/loader/omxilcomponentif.h>
#include <openmax/il/loader/omxilsymbiancomponentif.h>

#include "comxilclockcomponent.h"
#include "comxilclockoutputport.h"
#include "comxilclockprocessingfunction.h"
#include "comxilclockconfigmanager.h"
#include "clockpanics.h"
#include "omxilclock.hrh"

_LIT8(KSymbianOmxILClockNameDes, KCompNameSymbianOmxILClock);
_LIT8(KSymbianOmxILClockRoleDes, KRoleSymbianOmxILClock);

OMXIL_COMPONENT_ECOM_ENTRYPOINT(KUidSymbianOmxILClock);

OMX_ERRORTYPE SymbianErrorToOmx(TInt aError);

// Component Entry Point
OMX_ERRORTYPE OMX_ComponentInit(OMX_HANDLETYPE aComponent)
	{
	TInt err = COmxILClockComponent::CreateComponent(aComponent);
	return SymbianErrorToOmx(err);
	}

TInt COmxILClockComponent::CreateComponent(OMX_HANDLETYPE hComponent)
	{
	COmxILClockComponent* self = new COmxILClockComponent();

	if (!self)
		{
		return KErrNoMemory;
		}

	TRAPD(error, self->ConstructL(hComponent));
	if(error != KErrNone)
		{
		delete self;
		}
	return error;
	}

COmxILClockComponent::COmxILClockComponent()
	{
	// nothing to do
	}

void COmxILClockComponent::ConstructL(OMX_HANDLETYPE hComponent)
	{
    COmxILComponent::ConstructL(hComponent);

	// use synchronous callback manager since BufferDoneNotifications must be serviced at precise times 
    MOmxILCallbackNotificationIf* callbackNotificationIf=CreateCallbackManagerL(COmxILComponent::EOutofContext);

    COmxILClockProcessingFunction* pProcessingFunction = COmxILClockProcessingFunction::NewL(*callbackNotificationIf, *this);
    RegisterProcessingFunction(pProcessingFunction);
    
    CreatePortManagerL(COmxILComponent::ENonBufferSharingPortManager,
		TOmxILSpecVersion(),	        // OMX Version
		0,						// The number of audio ports in this component
		0,						// The starting audio port index
		0,						// The number of image ports in this component
		0,						// The starting image port index
		0,						// The number of video ports in this component
		0,						// The starting video port index
		KNumPorts,				// The number of other ports in this component
		0,						// The starting other port index
		OMX_FALSE				// Process the time port buffer as usual in port manager
		);


	RPointerArray<TDesC8> roleList;
	CleanupClosePushL(roleList);
	roleList.AppendL(&KSymbianOmxILClockRoleDes);
	COmxILClockConfigManager* configManager = COmxILClockConfigManager::NewL(KSymbianOmxILClockNameDes, 
							TOmxILSpecVersion(), roleList, *(static_cast<COmxILClockProcessingFunction*>(pProcessingFunction)));
	RegisterConfigurationManager(configManager);
	CleanupStack::PopAndDestroy(&roleList);
	
	for(TInt portIndex = 0; portIndex < KNumPorts; portIndex++)
		{
		AddPortL();
		}

	InitComponentL();
	}

COmxILClockComponent::~COmxILClockComponent()
	{
	iPorts.Reset();
	}
	
void COmxILClockComponent::AddPortL()
	{
	TOmxILSpecVersion omxIlVersion;
	TOmxILCommonPortData portData(
			omxIlVersion, 
			iPorts.Count(),										// port index
			OMX_DirOutput,
			4,													// minimum number of buffers
			sizeof(OMX_TIME_MEDIATIMETYPE),						// minimum buffer size, in bytes
			OMX_PortDomainOther,
			OMX_FALSE,											// do not need contigious buffers
			1,													// byte alignment
			// Clock being buffer supplier allows it to send notifications to clients without
			// waiting for clients to pass their buffers after a state transition
			OMX_BufferSupplyOutput,
			COmxILPort::KBufferMarkPropagationPortNotNeeded		
			);

	RArray<OMX_OTHER_FORMATTYPE> supportedOtherFormats;

	CleanupClosePushL(supportedOtherFormats);
	supportedOtherFormats.AppendL(OMX_OTHER_FormatTime);

	COmxILClockOutputPort* port = COmxILClockOutputPort::NewL(portData, supportedOtherFormats,
															*(static_cast<COmxILClockProcessingFunction*>(GetProcessingFunction())));
	CleanupStack::PopAndDestroy(&supportedOtherFormats);
	CleanupStack::PushL(port);
    User::LeaveIfError(AddPort(port, OMX_DirOutput));
    CleanupStack::Pop(port);
	iPorts.AppendL(port);
	}

/**
 * Returns true iff the specified port is currently enabled.
 */
TBool COmxILClockComponent::PortEnabled(TInt aPortIndex) const
	{
	return iPorts[aPortIndex]->IsEnabled();
	}

/**
 * Returns the number of buffers as configured in the port definition.
 */
TInt COmxILClockComponent::PortBufferCount(TInt aPortIndex) const
	{
	return iPorts[aPortIndex]->BufferCount();
	}

OMX_ERRORTYPE SymbianErrorToOmx(TInt aError)
	{
	switch(aError)
		{
	case KErrNone:
		return OMX_ErrorNone;
	case KErrNoMemory:
		return OMX_ErrorInsufficientResources;
	case KErrArgument:
		return OMX_ErrorUnsupportedSetting;
	case KErrNotSupported:
		return OMX_ErrorUnsupportedIndex;
	case KErrNotReady:
		return OMX_ErrorIncorrectStateOperation;
	default:
#ifdef _DEBUG
		// Panic in a debug build. It will make people think about how the error should be handled.
		Panic(EUndefinedErrorCode);
#endif
		return OMX_ErrorUndefined;
		}
	}