// Copyright (c) 2005-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 <mdf/mdfpuconfig.h>
#include "omxcomponentbody.h"
#include <omxprocessingunit.h>
#include <omxinputport.h>
#include <omxoutputport.h>
#include <mmf/server/taskconfig.h>
/**
Default constructor.
*/
EXPORT_C COmxProcessingUnit::COmxProcessingUnit()
{
}
/**
Destructor.
*/
EXPORT_C COmxProcessingUnit::~COmxProcessingUnit()
{
delete iBody;
}
/**
Safe constructing method.
@param aComponentName The name of the component to be contructed.
@param aProcessingUnitObserver Reference to the obsever for this Processing Unit.
*/
EXPORT_C void COmxProcessingUnit::ConstructL(const TDesC8& aComponentName, const MMdfProcessingUnitObserver& aProcessingUnitObserver)
{
iBody = CBody::NewL(aComponentName, *this, this, aProcessingUnitObserver);
}
/**.
@see CMdfProcessingUnit::Create
*/
EXPORT_C TInt COmxProcessingUnit::Create(const MMdfProcessingUnitObserver& /* aProcessingUnitObserver */)
{
return KErrNotSupported;
}
/**.
@see CMdfProcessingUnit::GetInputPorts
*/
EXPORT_C TInt COmxProcessingUnit::GetInputPorts(RPointerArray<MMdfInputPort>& aComponentInputPorts)
{
return iBody->GetInputPorts(aComponentInputPorts);
}
/**
@see CMdfProcessingUnit::GetOutputPorts
*/
EXPORT_C TInt COmxProcessingUnit::GetOutputPorts(RPointerArray<MMdfOutputPort>& aComponentOutputPorts)
{
return iBody->GetOutputPorts(aComponentOutputPorts);
}
/**
@see CMdfProcessingUnit::Initialize
@see MMdfProcessingUnitObserver::InitializeComplete()
*/
EXPORT_C void COmxProcessingUnit::Initialize()
{
iBody->Initialize();
}
/**
@see CMdfProcessingUnit::Execute
*/
EXPORT_C void COmxProcessingUnit::Execute()
{
iBody->Execute();
}
/**
@see CMdfProcessingUnit::State
*/
EXPORT_C TProcessingUnitState COmxProcessingUnit::State()
{
return iBody->State();
}
/**
@see CMdfProcessingUnit::Configure
*/
EXPORT_C TInt COmxProcessingUnit::Configure(const TPuConfig& aConfig)
{
return iBody->Configure(aConfig);
}
/**
@see CMdfProcessingUnit::GetConfig
*/
EXPORT_C TInt COmxProcessingUnit::GetConfig(TPuConfig& aConfig)
{
return iBody->GetConfig(aConfig);
}
/**
@see CMdfProcessingUnit::Pause
*/
EXPORT_C TInt COmxProcessingUnit::Pause()
{
return iBody->Pause();
}
/**
@see CMdfProcessingUnit::Stop
*/
EXPORT_C void COmxProcessingUnit::Stop()
{
iBody->Stop();
}
EXPORT_C TInt COmxProcessingUnit::MopcEventHandler(OMX_HANDLETYPE aComponent, OMX_EVENTTYPE aEvent, TUint32 aData1,
TUint32 aData2, TAny* aExtraInfo)
{
return iBody->EventHandler(aComponent, aEvent, aData1, aData2, aExtraInfo);
}
/**
@see CMdfProcessingUnit::CreateCustomInterface
*/
EXPORT_C TInt COmxProcessingUnit::CreateCustomInterface(TUid aUid)
{
return iBody->CreateCustomInterface(aUid);
}
/**
@see CMdfProcessingUnit::CustomInterface
*/
EXPORT_C TAny* COmxProcessingUnit::CustomInterface(TUid aUid)
{
return iBody->CustomInterface(aUid);
}
/**
Add an input port to the component
@param aInputPort A pointer to the input port
@return KErrNone if successful or one of the system wide error codes
*/
EXPORT_C TInt COmxProcessingUnit::AddInputPort(MMdfInputPort* aInputPort)
{
return iBody->AddInputPort(aInputPort);
}
/**
Add an output port to the component
@param aOutputPort A pointer to the output port
@return KErrNone if successful or one of the system wide error codes
*/
EXPORT_C TInt COmxProcessingUnit::AddOutputPort(MMdfOutputPort* aOutputPort)
{
return iBody->AddOutputPort(aOutputPort);
}
/**
Return the observer interface for the component
@return The observer interface
*/
EXPORT_C const MMdfProcessingUnitObserver* COmxProcessingUnit::Observer()
{
return iBody->Observer();
}
/**
Sets the internal PU State
@param aPuState The internal state of the component
*/
EXPORT_C void COmxProcessingUnit::SetPuState(TProcessingUnitState aPuState)
{
iBody->SetPuState(aPuState);
}
// Calls to OmxComponent
/**
Requests a current parameter from the OpenMAX Processing Unit.
@param aParamIndex The index of the structure to be filled.
@param aComponentParameterStructure A pointer to structure to be filled by the component.
@return An error code indicating if the function call was successful.
KErrNone on success, otherwise another of the system-wide error codes.
*/
EXPORT_C TInt COmxProcessingUnit::OmxGetParameter(OMX_INDEXTYPE aParamIndex, TAny* aComponentParameterStructure)
{
return iBody->GetParameter(aParamIndex, aComponentParameterStructure);
}
/**
Instructs the OpenMAX Processing Unit to use the buffer passed in the function's argument.
@param aBuffer The buffer to be used.
@param aPortIndex The port that the given buffer should be associated with.
@return An error code indicating if the function call was successful. KErrNone
on success, otherwise another of the system-wide error codes.
*/
EXPORT_C TInt COmxProcessingUnit::OmxUseBuffer(CMMFBuffer* aBuffer, TUint32 aPortIndex)
{
return iBody->UseBuffer(aBuffer, aPortIndex);
}
/**
Instructs the OpenMAX Processing Unit to allocate a buffer. Ownership is transferred to the caller.
@param aPortIndex The Port Index that the new buffer is associated with.
@param aSizeBytes The size of the buffer to be allocated, in bytes.
@return A pointer to the newly created buffer.
*/
EXPORT_C CMMFBuffer* COmxProcessingUnit::OmxAllocateBufferL(TUint32 aPortIndex, TUint32 aSizeBytes)
{
return iBody->AllocateBufferL(aPortIndex, aSizeBytes);
}
/**
Instructs the OpenMAX Processing Unit to free the buffer passed in the function's argument.
@param aBuffer The buffer to be freed
@return An error code indicating if the function call was successful. KErrNone
on success, otherwise another of the system-wide error codes.
*/
EXPORT_C TInt COmxProcessingUnit::OmxFreeBuffer(CMMFBuffer* aBuffer)
{
return iBody->FreeBuffer(aBuffer);
}
/**
Sends an full buffer to an input port of a component.
@param aBuffer The buffer to be emptied.
@param aObserver The observer of the input port that is to be notified.
@return An error code indicating if the function call was successful. KErrNone
on success, otherwise another of the system-wide error codes.
*/
EXPORT_C TInt COmxProcessingUnit::OmxEmptyThisBuffer(const CMMFBuffer* aBuffer, MOmxInputPortCallbacks* aObserver)
{
return iBody->EmptyThisBuffer(aBuffer, aObserver);
}
/**
Sends an empty buffer to an output port of a component.
@param aBuffer The buffer to be filled.
@param aObserver The observer of the output port that is to be notified.
@return An error code indicating if the function call was successful. KErrNone
on success, otherwise another of the system-wide error codes.
*/
EXPORT_C TInt COmxProcessingUnit::OmxFillThisBuffer(CMMFBuffer* aBuffer, MOmxOutputPortCallbacks* aObserver)
{
return iBody->FillThisBuffer(aBuffer, aObserver);
}
/**
Sends a command to the OpenMAX Processing Unit.
@param aCmd The command for the component to execute.
@param aParam1 The parameter for the command to be executed.
@param aCmdData A pointer to the data for the command.
@return An error code indicating if the function call was successful.
KErrNone on success, otherwise another of the system-wide error codes.
*/
EXPORT_C TInt COmxProcessingUnit::OmxSendCommand(OMX_COMMANDTYPE aCmd, TUint32 aParam1, TAny* aCmdData)
{
return iBody->SendCommand(aCmd, aParam1, aCmdData);
}
/**
Sends a parameter from the OpenMAX Processing Unit.
@param aParamIndex The index of the structure to be sent.
@param aComponentParameterStructure A pointer to structure to be used by the component.
@return An error code indicating if the function call was successful.
KErrNone on success, otherwise another of the system-wide error codes.
*/
EXPORT_C TInt COmxProcessingUnit::OmxSetParameter(OMX_INDEXTYPE aParamIndex, TAny* aComponentParameterStructure)
{
return iBody->SetParameter(aParamIndex, aComponentParameterStructure);
}