diff -r 000000000000 -r bde4ae8d615e os/mm/mmdevicefw/mdf/src/openmax/omxinputport.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/mm/mmdevicefw/mdf/src/openmax/omxinputport.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,270 @@ +// 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 +#include +#include +#include "omxcomponentbody.h" +#include "omxinputportbody.h" + +_LIT(KOmxInputPort, "OmxInputPort"); + +/** +Constructor. +*/ +EXPORT_C COmxInputPort::COmxInputPort() + { + } + +/** +Destructor. +*/ +EXPORT_C COmxInputPort::~COmxInputPort() + { + delete iBody; + } + +/** +Class constructor. +*/ +EXPORT_C void COmxInputPort::ConstructL(TInt aIndex, COmxProcessingUnit* aComponent) + { + __ASSERT_ALWAYS(!iBody, User::Panic(KOmxInputPort, EBodyNotCreated)); + iBody = CBody::NewL(aIndex, aComponent, this); + } + + +/** +Synchronous function used to configure the OpenMAX Input Port. +@param aConfiguration + Holds the configuration parameters for the OpenMAX Input Port. +@return An error code indicating if the function call was successful. KErrNone on success, otherwise + nother of the system-wide error codes. +*/ +EXPORT_C TInt COmxInputPort::MipConfigure(const TPuConfig& aConfig) + { + __ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated)); + return iBody->MipConfigure(aConfig); + } + + +/** +Synchronous method which gets a configuration structure for the OpenMAX Input Port +@param aConfig + The reference to the structure that is to contain the configuration information. +@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 COmxInputPort::MipGetConfig(TPuConfig& aConfig) + { + __ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated)); + return iBody->MipGetConfig(aConfig); + } + + +/** +Synchronous function used to initialise the OpenMAX Input Port. +*/ +EXPORT_C void COmxInputPort::MipInitialize() + { + __ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated)); + iBody->MipInitialize(); + } + + +/** +Synchronous function used to instruct the OpenMAX Input Port to create a buffer. +@param aBufferSize + The size of the buffer to be created. +@return A pointer to the new created buffer. +*/ +EXPORT_C CMMFBuffer* COmxInputPort::MipCreateBuffer(TInt aBufferSize) + { + __ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated)); + return iBody->MipCreateBuffer(aBufferSize); + } + + +/** +Synchronous function used to instruct the OpenMAX Input Port to use the buffer +passed in the function's argument. +@param aBuffer + The buffer to be used by the Input Port. +@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 COmxInputPort::MipUseBuffer(CMMFBuffer& aBuffer) + { + __ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated)); + return iBody->MipUseBuffer(aBuffer); + } + + +/** +Synchronous function used to instruct the OpenMAX Input Port to free the buffer given +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 COmxInputPort::MipFreeBuffer(CMMFBuffer* aBuffer) + { + __ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated)); + return iBody->MipFreeBuffer(aBuffer); + } + + +/** +Synchronous function used to request the set up of a tunnel between this OpenMAX Input Port +and an OpenMAX Output Port. +@param aOutputPortToBeConnectedTo + Reference to the Output Port to be connected to. +@param aTunnelFlags + Control flags for tunneling +@param aSupplierType + Specifies the supplier of the buffers for the tunnel. +@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 COmxInputPort::MipTunnelRequest(const MMdfOutputPort& aOutputPortToBeConnectedTo, + TTunnelFlags& aTunnelFlags, TSupplierType& aSupplierType) + { + __ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated)); + return iBody->MipTunnelRequest(aOutputPortToBeConnectedTo, aTunnelFlags, aSupplierType); + } + + +/** +Asynchronous function used to write data to the OpenMAX Input Port. +@param aBuffer + Reference to the buffer containing data. +*/ +EXPORT_C void COmxInputPort::MipWriteData(CMMFBuffer& aInputBuffer) + { + __ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated)); + iBody->MipWriteData(aInputBuffer); + } + + +/** +Asynchronous function used to disconnect a tunnelled port, and thus stop the data processing. +*/ +EXPORT_C void COmxInputPort::MipDisconnectTunnel() + { + __ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated)); + iBody->MipDisconnectTunnel(); + } + +/** +Asynchronous function used to restart the data processing of a tunnelled port. +*/ +EXPORT_C void COmxInputPort::MipRestartTunnel() + { + __ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated)); + iBody->MipRestartTunnel(); + } + + +/** +Synchronous function used to find out if an OpenMAX Input Port is tunnelled or not. +@return ETrue if the Input Port is tunnelled, EFalse otherwise. +*/ +EXPORT_C TBool COmxInputPort::MipIsTunnelled() const + { + __ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated)); + return iBody->MipIsTunnelled(); + } + + +/** +Synchronous function used to get the OpenMAX Input Port index +@return The OpenMAX Input Port index. +*/ +EXPORT_C TInt COmxInputPort::MipIndex() const + { + __ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated)); + return iBody->MipIndex(); + } + + +/** +Synchronous function used to get the size of the buffer(s) used by the OpenMAX Input Port. +@param The OpenMAX Input Port's buffer size. +*/ +EXPORT_C TUint32 COmxInputPort::MipBufferSize() const + { + return iBody->MipBufferSize(); + } + + +/** +Synchronous function used to set the observer for the OpenMAX Input Port. +@param aOutputPortObserver + The observer of the OpenMAX Input Port. +*/ +EXPORT_C void COmxInputPort::MipSetObserver(const MMdfInputPortObserver& aOutputPortObserver) + { + iBody->MipSetObserver(aOutputPortObserver); + } + +/** +Request extension feature. This is intended to provide additional features. +@param aUid + Used to indicate which interface is required. +@return Standard error code. KErrNotSupported is used to indicate that the particular + plugin is not used. +*/ +EXPORT_C TInt COmxInputPort::MipCreateCustomInterface(TUid aUid) + { + return iBody->MipCreateCustomInterface(aUid); + } + +/** +Return previously created extension. +This returns a custom interface. This should only be used if CreateCustomInterface() has already +been called for the same UID value. This means that any construction for that interface +has already been called, and thus this call cannot fail. +@param aUid + Used to indicate which interface is required. +@return The requested interface, or NULL if not known. +@see MipCreateCustomInterface() +*/ +EXPORT_C TAny* COmxInputPort::MipCustomInterface(TUid aUid) + { + __ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated)); + return MipCustomInterface(aUid); + } + +/** +Synchronous function used to return the observer for the OpenMAx Input Port. +@return Pointer to this class obsever +*/ +EXPORT_C MMdfInputPortObserver* COmxInputPort::Observer() const + { + __ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated)); + return iBody->Observer(); + } + +/** +Synchronous function used to return the OpenMAX Processing Unit this Input Port +belongs to. +@return Pointer to the OpenMAX Processing Unit this Input Port belongs to. +*/ +EXPORT_C COmxProcessingUnit* COmxInputPort::Component() const + { + __ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated)); + return iBody->Component(); + }