/*
* 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/common/omxilclientclockport.h>
#include <openmax/il/loader/omxilsymbiancomponentif.h>
#include "log.h"
#include "omxilpcmrenderer.h"
#include "omxilpcmrendererapb0port.h"
#include "omxilpcmrendererprocessingfunction.h"
#include "omxilpcmrendererconfigmanager.h"
#include "omxilpcmrenderer.hrh"
const TUint8 COmxILPcmRenderer::iComponentVersionMajor;
const TUint8 COmxILPcmRenderer::iComponentVersionMinor;
const TUint8 COmxILPcmRenderer::iComponentVersionRevision;
const TUint8 COmxILPcmRenderer::iComponentVersionStep;
OMXIL_COMPONENT_ECOM_ENTRYPOINT(KUidSymbianOmxILPcmRenderer);
// Component Entry Point
OMX_ERRORTYPE OMX_ComponentInit(OMX_HANDLETYPE aComponent)
{
// This method should be called as a result of a OMX_GetHandle call. Let's
// return something that is consistent with the return codes allowed for
// that API call.
return COmxILComponent::SymbianErrorToGetHandleError(COmxILPcmRenderer::CreateComponent(aComponent));
}
TInt COmxILPcmRenderer::CreateComponent(OMX_HANDLETYPE aComponent)
{
DEBUG_PRINTF(_L8("COmxILPcmRenderer::CreateComponent"));
COmxILPcmRenderer* self = new COmxILPcmRenderer();
if (!self)
{
return KErrNoMemory;
}
TRAPD(err, self->ConstructL(aComponent));
if (err != KErrNone)
{
delete self;
}
return err;
}
void COmxILPcmRenderer::ConstructL(OMX_HANDLETYPE aComponent)
{
DEBUG_PRINTF(_L8("COmxILPcmRenderer::ConstructL"));
// STEP 1: Initialize the data received from the IL Core
COmxILComponent::ConstructL(aComponent);
// STEP 2: Create the call backs manager...
MOmxILCallbackNotificationIf* callbackNotificationIf(0);
#ifdef _OMXIL_PCMRENDERER_INCONTEXT_CALLBACKMANAGER_ON
callbackNotificationIf=CreateCallbackManagerL(COmxILComponent::EInContext);
#else
callbackNotificationIf=CreateCallbackManagerL(COmxILComponent::EOutofContext);
#endif
// STEP 3: Create the PCM renderer-specific Processing Function...
// ...create PCM renderer component Client Clock port
COmxILClientClockPort* clientClockPort = ConstructClientClockPortL();
CleanupStack::PushL(clientClockPort);
COmxILProcessingFunction* pProcessingFunction = COmxILPcmRendererProcessingFunction::NewL(*callbackNotificationIf, *clientClockPort);
RegisterProcessingFunction(pProcessingFunction);
// STEP 4: Create Port manager...
CreatePortManagerL(COmxILComponent::ENonBufferSharingPortManager,
iOmxILVersion, // Component's OMX Version
1, // The number of audio ports in this component
KPCMRENDERER_APB0PORT_INDEX, // 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
1, // The number of other ports in this component
KPCMRENDERER_OPB0PORT_INDEX // The starting other port index
);
// ...create PCM renderer component ports (no OPB0 port)
COmxILPcmRendererAPB0Port* pb0Port = ConstructAPB0PortL();
CleanupStack::PushL(pb0Port);
// .. and add them to the port manager...
User::LeaveIfError(AddPort(pb0Port, OMX_DirInput));
CleanupStack::Pop(); //pb0Port
User::LeaveIfError(AddPort(clientClockPort, OMX_DirInput));
CleanupStack::Pop(); //clientClockPort
// STEP 5: Create the non-port related configuration manager...
RPointerArray<TDesC8> componentRoles;
CleanupClosePushL(componentRoles);
User::LeaveIfError(componentRoles.Append(&KSymbianOmxILPcmRendererRole()));
COmxILConfigManager* pConfigManager = COmxILPcmRendererConfigManager::NewL(
*static_cast<COmxILPcmRendererProcessingFunction*>(pProcessingFunction),
KSymbianOmxILPcmRendererName,
TOmxILVersion(iComponentVersionMajor,
iComponentVersionMinor,
iComponentVersionRevision,
iComponentVersionStep),
componentRoles);
RegisterConfigurationManager(pConfigManager);
CleanupStack::Pop(); // componentRoles
componentRoles.Close(); // Must not destroy pointers
// And finally, let's get everything started
InitComponentL();
}
COmxILPcmRenderer::COmxILPcmRenderer()
:
iOmxILVersion(TOmxILSpecVersion())
{
DEBUG_PRINTF(_L8("COmxILPcmRenderer::COmxILPcmRenderer"));
}
COmxILPcmRenderer::~COmxILPcmRenderer()
{
DEBUG_PRINTF(_L8("COmxILPcmRenderer::~COmxILPcmRenderer"));
}
COmxILPcmRendererAPB0Port* COmxILPcmRenderer::ConstructAPB0PortL() const
{
DEBUG_PRINTF(_L8("COmxILPcmRenderer::ConstructAPB0PortL"));
RArray<OMX_AUDIO_CODINGTYPE> supportedAudioFormats;
CleanupClosePushL(supportedAudioFormats);
supportedAudioFormats.AppendL(OMX_AUDIO_CodingPCM);
OMX_AUDIO_PARAM_PCMMODETYPE paramPcmModeType;
paramPcmModeType.nSize = sizeof(OMX_AUDIO_PARAM_PCMMODETYPE);
paramPcmModeType.nVersion = iOmxILVersion;
paramPcmModeType.nPortIndex = KPCMRENDERER_APB0PORT_INDEX;
paramPcmModeType.nChannels = KDefaultNumberChannels;
paramPcmModeType.eNumData = OMX_NumericalDataSigned;
paramPcmModeType.eEndian = OMX_EndianBig;
paramPcmModeType.bInterleaved = OMX_TRUE;
paramPcmModeType.nBitPerSample = KDefaultBitPerSample;
paramPcmModeType.nSamplingRate = KDefaultSampleRate;
paramPcmModeType.ePCMMode = OMX_AUDIO_PCMModeLinear;
paramPcmModeType.eChannelMapping[0] = OMX_AUDIO_ChannelLF;
paramPcmModeType.eChannelMapping[1] = OMX_AUDIO_ChannelRF;
OMX_AUDIO_CONFIG_VOLUMETYPE configAudioVolume;
configAudioVolume.nSize = sizeof(OMX_AUDIO_CONFIG_VOLUMETYPE);
configAudioVolume.nVersion = iOmxILVersion;
configAudioVolume.nPortIndex = KPCMRENDERER_APB0PORT_INDEX;
configAudioVolume.bLinear = OMX_FALSE;
configAudioVolume.sVolume.nValue = 50;
configAudioVolume.sVolume.nMin = 0;
configAudioVolume.sVolume.nMax = 100;
OMX_AUDIO_CONFIG_MUTETYPE configAudioMute;
configAudioMute.nSize = sizeof(OMX_AUDIO_CONFIG_MUTETYPE);
configAudioMute.nVersion = iOmxILVersion;
configAudioMute.nPortIndex = KPCMRENDERER_APB0PORT_INDEX;
configAudioMute.bMute = OMX_FALSE;
TOmxILCommonPortData portData(iOmxILVersion, // OMX specification version information
KPCMRENDERER_APB0PORT_INDEX,// Port number the structure applies to
OMX_DirInput, // Direction of this port
1, // The minimum number of buffers this port requires
15360, // Minimum size, in bytes, for buffers to be used for this port
OMX_PortDomainAudio, // Domain of the port
OMX_FALSE, // Buffers contiguous requirement (true or false)
0, // Buffer aligment requirements
OMX_BufferSupplyInput, // supplier preference when tunneling between two ports
// This component is a sink component so there's no need to
// propagate buffer marks received on input ports
COmxILPort:: KBufferMarkPropagationPortNotNeeded);
COmxILPcmRendererAPB0Port* apb0Port = COmxILPcmRendererAPB0Port::NewL(portData,
supportedAudioFormats,
paramPcmModeType,
configAudioVolume,
configAudioMute);
CleanupStack::PopAndDestroy(&supportedAudioFormats);
return apb0Port;
}
COmxILClientClockPort* COmxILPcmRenderer::ConstructClientClockPortL() const
{
DEBUG_PRINTF(_L8("COmxILPcmRenderer::ConstructClientClockPortL"));
TOmxILCommonPortData portData(iOmxILVersion,
KPCMRENDERER_OPB0PORT_INDEX, // port index
OMX_DirInput,
4, // minimum number of buffers
sizeof(OMX_TIME_MEDIATIMETYPE), // minimum buffer size, in bytes
OMX_PortDomainOther,
OMX_FALSE, // do not need contigious buffers
0, // byte alignment
OMX_BufferSupplyUnspecified,
COmxILPort::KBufferMarkPropagationPortNotNeeded);
RArray<OMX_OTHER_FORMATTYPE> supportedOtherFormats;
CleanupClosePushL(supportedOtherFormats);
supportedOtherFormats.AppendL(OMX_OTHER_FormatTime);
COmxILClientClockPort* aClientClockPort = COmxILClientClockPort::NewL(portData, supportedOtherFormats);
CleanupStack::PopAndDestroy(&supportedOtherFormats);
return aClientClockPort;
}