/*

* Copyright (c) 2008 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 "log.h"

#include "comxil3gpdemuxeraudiooutputport.h"

#include "comxil3gpdemuxerprocessingfunction.h"

#include "taudioformat.h"

// TODO: Possibly add other mime types, for now only AAC handled

_LIT8(KMimeTypeAudioAac, "audio/aac");

_LIT(K3GPDemuxerAudioPortPanic, "COmxIL3GPDemuxerVideoOutputPort");

COmxIL3GPDemuxerAudioOutputPort* COmxIL3GPDemuxerAudioOutputPort::NewL(const TOmxILCommonPortData& aCommonPortData,

                                                                       COmxIL3GPDemuxerProcessingFunction& aProcessingFunction)

	{

	DEBUG_PRINTF(_L8("COmxIL3GPDemuxerAudioOutputPort::NewL"));

	// TODO this array must be left empty, to be removed from the audio port constructor

	COmxIL3GPDemuxerAudioOutputPort* self = new(ELeave) COmxIL3GPDemuxerAudioOutputPort(aProcessingFunction);

	CleanupStack::PushL(self);

	self->ConstructL(aCommonPortData);

	CleanupStack::Pop(self);

	return self;

	}

void COmxIL3GPDemuxerAudioOutputPort::ConstructL(const TOmxILCommonPortData& aCommonPortData)

	{

    RArray<OMX_AUDIO_CODINGTYPE> supportedCodings;

    CleanupClosePushL(supportedCodings);

    supportedCodings.AppendL(OMX_AUDIO_CodingAAC);

    COmxILAudioPort::ConstructL(aCommonPortData, supportedCodings);

    CleanupStack::PopAndDestroy(&supportedCodings);

    OMX_PARAM_PORTDEFINITIONTYPE& paramPortDefinition=GetParamPortDefinition();

	// We have to finish with iParamPortDefinition

    paramPortDefinition.eDomain = OMX_PortDomainAudio;

    paramPortDefinition.format.audio.pNativeRender = 0;

	// TODO: Possible add in the future other mime types that can be handled by

	// this audio port... for now only AAC Check

	// COmxILAudioPort::iParamAudioPortFormat.nIndex and use

	// COmxILAudioPort::iSupportedAudioFormats[iParamAudioPortFormat.nIndex]

	iMimeTypeBuf.CreateL(KMimeTypeAudioAac(), KMimeTypeAudioAac().Length() + 1);

	TUint8* pTUint = const_cast<TUint8*>(iMimeTypeBuf.PtrZ());

	paramPortDefinition.format.audio.cMIMEType = reinterpret_cast<OMX_STRING>(pTUint);

	paramPortDefinition.format.audio.bFlagErrorConcealment = OMX_FALSE;

	paramPortDefinition.format.audio.eEncoding = OMX_AUDIO_CodingAAC;

	}

COmxIL3GPDemuxerAudioOutputPort::COmxIL3GPDemuxerAudioOutputPort(COmxIL3GPDemuxerProcessingFunction& aProcessingFunction) 

:	iProcessingFunction(&aProcessingFunction)

	{

	DEBUG_PRINTF(_L8("COmxIL3GPDemuxerAudioOutputPort::COmxIL3GPDemuxerAudioOutputPort"));

	}

COmxIL3GPDemuxerAudioOutputPort::~COmxIL3GPDemuxerAudioOutputPort()

	{

	DEBUG_PRINTF(_L8("COmxIL3GPDemuxerAudioOutputPort::~COmxIL3GPDemuxerAudioOutputPort"));

	iMimeTypeBuf.Close();

	}

OMX_ERRORTYPE COmxIL3GPDemuxerAudioOutputPort::GetLocalOmxParamIndexes(RArray<TUint>& aIndexArray) const

	{

	DEBUG_PRINTF(_L8("COmxIL3GPDemuxerAudioOutputPort::GetLocalOmxParamIndexes"));

	OMX_ERRORTYPE omxRetValue = COmxILAudioPort::GetLocalOmxParamIndexes(aIndexArray);		

	if (omxRetValue != OMX_ErrorNone)

		{

		return omxRetValue;

		}

	TInt err = aIndexArray.InsertInOrder(OMX_IndexParamNumAvailableStreams);

	// Note that index duplication is OK.

	if (err == KErrNone || err == KErrAlreadyExists)

		{

		err = aIndexArray.InsertInOrder(OMX_IndexParamActiveStream);

		}

	if (err != KErrNone && err != KErrAlreadyExists)

		{

		return OMX_ErrorInsufficientResources;

		}

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxIL3GPDemuxerAudioOutputPort::GetLocalOmxConfigIndexes(RArray<TUint>& aIndexArray) const

	{

	return COmxILAudioPort::GetLocalOmxConfigIndexes(aIndexArray);

	}

OMX_ERRORTYPE COmxIL3GPDemuxerAudioOutputPort::GetParameter(OMX_INDEXTYPE aParamIndex,

                                                            TAny* apComponentParameterStructure) const

	{

	DEBUG_PRINTF(_L8("COmxIL3GPDemuxerAudioOutputPort::GetParameter"));

	switch(aParamIndex)

		{		

		case OMX_IndexParamNumAvailableStreams:

			{

			OMX_PARAM_U32TYPE* u32Type = reinterpret_cast<OMX_PARAM_U32TYPE*>(apComponentParameterStructure);

			u32Type->nU32 = iProcessingFunction->NumAvailableStreams(COmxIL3GPDemuxer::EPortIndexAudioOutput);

			return OMX_ErrorNone;

			}

		case OMX_IndexParamActiveStream:

			{

			OMX_PARAM_U32TYPE* u32Type = reinterpret_cast<OMX_PARAM_U32TYPE*>(apComponentParameterStructure);

			u32Type->nU32 = iProcessingFunction->ActiveStream(COmxIL3GPDemuxer::EPortIndexAudioOutput);

			return OMX_ErrorNone;

			}

		default:

			{

			return COmxILAudioPort::GetParameter(aParamIndex, apComponentParameterStructure);

			}

		}

	}

OMX_ERRORTYPE COmxIL3GPDemuxerAudioOutputPort::SetParameter(OMX_INDEXTYPE aParamIndex,

                                                            const TAny* apComponentParameterStructure,

                                                            TBool& aUpdateProcessingFunction)

	{

	DEBUG_PRINTF(_L8("COmxIL3GPDemuxerAudioOutputPort::SetParameter"));

	switch(aParamIndex)

		{		

		case OMX_IndexParamActiveStream:

			{

			const OMX_PARAM_U32TYPE* u32Type = reinterpret_cast<const OMX_PARAM_U32TYPE*>(apComponentParameterStructure);

			return iProcessingFunction->SetActiveStream(COmxIL3GPDemuxer::EPortIndexAudioOutput, u32Type->nU32);

			}

		default:

			{

			return COmxILAudioPort::SetParameter(aParamIndex, apComponentParameterStructure, aUpdateProcessingFunction);

			}

		}

	}

OMX_ERRORTYPE COmxIL3GPDemuxerAudioOutputPort::SetFormatInPortDefinition(

	const OMX_PARAM_PORTDEFINITIONTYPE& aPortDefinition,

	TBool& /*aUpdateProcessingFunction*/)

	{

	DEBUG_PRINTF(_L8("COmxIL3GPDemuxerAudioOutputPort::SetFormatInPortDefinition"));

	if (aPortDefinition.nBufferCountActual > KMaxAudioBuffers)

		{

		return OMX_ErrorBadParameter;

		}

	GetParamPortDefinition().format.audio = aPortDefinition.format.audio;

	return OMX_ErrorNone;

	}

TBool COmxIL3GPDemuxerAudioOutputPort::IsTunnelledPortCompatible(const OMX_PARAM_PORTDEFINITIONTYPE& /*aPortDefinition*/) const

	{

	DEBUG_PRINTF(_L8("COmxIL3GPDemuxerAudioOutputPort::IsTunnelledPortCompatible"));

	// This function only gets called on input ports, so panic if this is ever called

	User::Panic(K3GPDemuxerAudioPortPanic, KErrGeneral);

	return EFalse; // to keep compiler happy

	}

void COmxIL3GPDemuxerAudioOutputPort::FormatDetected(const TAudioFormat& aFormat)

	{

	GetParamPortDefinition().format.audio.eEncoding = aFormat.iCoding;

	}

OMX_AUDIO_CODINGTYPE COmxIL3GPDemuxerAudioOutputPort::AudioFormat()

	{

	return GetParamPortDefinition().format.audio.eEncoding;

	}

/** Returns the number of buffers configured on this port. */

TInt COmxIL3GPDemuxerAudioOutputPort::BufferCount() const

	{

	return GetParamPortDefinition().nBufferCountActual;

	}