1 /*

     2 * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 

    19 /**

    20  @file

    21  @internalComponent

    22 */

    23 

    24 #include <openmax/il/khronos/v1_x/OMX_Audio.h>

    25 

    26 #include <d32soundsc.h>

    27 

    28 #include "log.h"

    29 #include <openmax/il/common/omxilcallbacknotificationif.h>

    30 #include <openmax/il/common/omxilclockcomponentcmdsif.h>

    31 #include <openmax/il/extensions/omxilsymbianaudiopcmextensions.h>

    32 #include "omxilpcmrendererprocessingfunction.h"

    33 

    34 const TInt COmxILPcmRendererProcessingFunction::CPFHelper::KMaxMsgQueueEntries;

    35 

    36 COmxILPcmRendererProcessingFunction*

    37 COmxILPcmRendererProcessingFunction::NewL(MOmxILCallbackNotificationIf& aCallbacks, 

    38 										MOmxILClockComponentCmdsIf& aClientClockPort)

    39 	{

    40     DEBUG_PRINTF(_L8("COmxILPcmRendererProcessingFunction::NewL"));

    41 

    42 	COmxILPcmRendererProcessingFunction* self =

    43 		new (ELeave)COmxILPcmRendererProcessingFunction(aCallbacks, aClientClockPort);

    44 	CleanupStack::PushL(self);

    45 	self->ConstructL();

    46 	CleanupStack::Pop(self);

    47 	return self;

    48 

    49 	}

    50 

    51 void

    52 COmxILPcmRendererProcessingFunction::ConstructL()

    53 	{

    54     DEBUG_PRINTF(_L8("COmxILPcmRendererProcessingFunction::ConstructL"));

    55 

    56     iAudioDevice = CAudioDevice::NewL(*this);

    57     iPFHelper = CPFHelper::NewL(*iAudioDevice);

    58 	}

    59 

    60 COmxILPcmRendererProcessingFunction::COmxILPcmRendererProcessingFunction(

    61 	MOmxILCallbackNotificationIf& aCallbacks, 

    62 	MOmxILClockComponentCmdsIf& aClientClockPort)

    63 	:

    64 	COmxILProcessingFunction(aCallbacks),

    65 	iClientClockPortPtr(&aClientClockPort)

    66 	{

    67     DEBUG_PRINTF(_L8("COmxILPcmRendererProcessingFunction::COmxILPcmRendererProcessingFunction"));

    68 

    69 	}

    70 

    71 COmxILPcmRendererProcessingFunction::~COmxILPcmRendererProcessingFunction()

    72 	{

    73     DEBUG_PRINTF(_L8("COmxILPcmRendererProcessingFunction::~COmxILPcmRendererProcessingFunction"));

    74 

    75 	// Check in case the Sound Device has not been closed. That would happen in

    76 	// an scenario where the component is not being deleted in an orderer way.

    77 	if(iAudioDevice && iPFHelper &&

    78 	   (iState == OMX_StateInvalid   ||

    79 	    iState == OMX_StateExecuting ||

    80 	    iState == OMX_StatePause))

    81 		{

    82 		// Ignore error if the following call fails

    83 		iPFHelper->CloseDeviceOnError();

    84 		}

    85 

    86 	// Buffer headers are not owned by the processing function

    87     iBuffersToEmpty.Close();

    88     iBuffersEmptied.Close();

    89     delete iAudioDevice;

    90     delete iPFHelper;

    91 	}

    92 

    93 

    94 OMX_ERRORTYPE

    95 COmxILPcmRendererProcessingFunction::StateTransitionIndication(TStateIndex aNewState)

    96 	{

    97     DEBUG_PRINTF(_L8("COmxILPcmRendererProcessingFunction::StateTransitionIndication"));

    98 

    99     OMX_ERRORTYPE err = OMX_ErrorNone;

   100 	switch(aNewState)

   101 		{

   102 	case EStateExecuting:

   103 		{

   104 		DEBUG_PRINTF(_L8("StateTransitionIndication : OMX_StateExecuting"));

   105 		if (iPFHelper->Execute() != KErrNone)

   106 			{

   107 			return OMX_ErrorInsufficientResources;

   108 			}

   109 		}

   110 		break;

   111 	case EStateInvalid:

   112 		{

   113 		DEBUG_PRINTF(_L8("StateTransitionIndication : OMX_StateInvalid"));

   114 		if (iPFHelper->Stop() != KErrNone)

   115 			{ // InsufficientResources to stop???

   116 			return OMX_ErrorInsufficientResources;

   117 			}

   118 		}

   119 		break;

   120 	case EStatePause:

   121 		{

   122 		DEBUG_PRINTF(_L8("StateTransitionIndication : OMX_StatePause"));

   123 		err = iAudioDevice->MoveToPausedState();

   124 		}

   125 		break;

   126 	case EStateIdle:

   127 		{

   128 		DEBUG_PRINTF(_L8("StateTransitionIndication : OMX_StateIdle"));

   129 		iBuffersToEmpty.Reset();

   130 		if (iPFHelper->Stop() != KErrNone)

   131 			{ // InsufficientResources to stop???

   132 			return OMX_ErrorInsufficientResources;

   133 			}

   134 		}

   135 		break;

   136 	case EStateLoaded:

   137 	case EStateWaitForResources:

   138 		{

   139 		DEBUG_PRINTF(_L8("StateTransitionIndication : OMX_StateLoaded, OMX_StateWaitForResources"));

   140 		if (iPFHelper->Stop() != KErrNone)

   141 			{ // InsufficientResources to stop???

   142 			return OMX_ErrorInsufficientResources;

   143 			}

   144 		}

   145 		break;

   146 	case ESubStateLoadedToIdle:

   147 		{

   148 		DEBUG_PRINTF(_L8("StateTransitionIndication : ESubStateLoadedToIdle"));

   149 		if (iPFHelper->OpenDevice() != KErrNone)

   150 			{

   151 			return OMX_ErrorInsufficientResources;

   152 			}

   153 		}

   154 		break;

   155 	case ESubStateIdleToLoaded:

   156 		{

   157 		DEBUG_PRINTF(_L8("StateTransitionIndication : ESubStateIdleToLoaded"));

   158 		if (iPFHelper->CloseDevice() != KErrNone)

   159 			{ // InsufficientResources to close???

   160 			return OMX_ErrorInsufficientResources;

   161 			}

   162 		}

   163 		break;

   164 	case ESubStateExecutingToIdle:

   165 	case ESubStatePauseToIdle:

   166 		{

   167 		// Ignore these transitions...

   168 		return OMX_ErrorNone;

   169 		}

   170 	default:

   171 		{

   172 		// Always ASSERT; This would be a problem in the framework.

   173 		ASSERT(0);

   174 		return OMX_ErrorIncorrectStateTransition;

   175 		}

   176 		};

   177 

   178 	return err;

   179 

   180 	}

   181 

   182 

   183 OMX_ERRORTYPE

   184 COmxILPcmRendererProcessingFunction::BufferFlushingIndication(

   185 	TUint32 aPortIndex,

   186 	OMX_DIRTYPE aDirection)

   187 	{

   188     DEBUG_PRINTF2(_L8("COmxILPcmRendererProcessingFunction::BufferFlushingIndication : aPortIndex[%d]"), aPortIndex);

   189 

   190     if ((aPortIndex == OMX_ALL && aDirection == OMX_DirMax) ||

   191 		(aPortIndex == KPCMRENDERER_APB0PORT_INDEX && aDirection == OMX_DirInput))

   192 		{

   193 		// If we are currently processing a buffer then cancel

   194 		if (iPFHelper->CancelDevice() != KErrNone)

   195 			{

   196 			return OMX_ErrorInsufficientResources;

   197 			}

   198 

   199 		// Send BufferDone notifications for each emptied buffer...

   200 		FlushBufferList(iBuffersEmptied);

   201 

   202 	    // Send BufferDone notifications for each pending buffer...

   203 		FlushBufferList(iBuffersToEmpty);

   204 		

   205 		return OMX_ErrorNone;

   206 		}

   207 	else if (aPortIndex == KPCMRENDERER_OPB0PORT_INDEX && aDirection == OMX_DirInput)

   208 		{

   209 		// Since the clock port buffers are returned immediately, 

   210 		// there's nothing to flush for the port

   211 		return OMX_ErrorNone;

   212 		}

   213 	else

   214 		{

   215 		// Always ASSERT; This would be a problem in the framework.

   216 		ASSERT(0);

   217 		return OMX_ErrorBadParameter;

   218 		}

   219 	}

   220 

   221 void

   222 COmxILPcmRendererProcessingFunction::FlushBufferList(

   223 	RPointerArray<OMX_BUFFERHEADERTYPE>& aBufferList)

   224 	{

   225     DEBUG_PRINTF2(_L8("COmxILPcmRendererProcessingFunction::FlushBufferList : [%s]"),

   226 				  &aBufferList == &iBuffersToEmpty ? "iBuffersToEmpty" : "iBuffersEmptied");

   227 

   228 	const TUint bufferCount = aBufferList.Count();

   229 	OMX_BUFFERHEADERTYPE* pBufferHeader = 0;

   230 	// We know there is only one input port...

   231 	OMX_DIRTYPE portDirection = OMX_DirInput;

   232 

   233 	for (TUint i=0; i<bufferCount; ++i)

   234 		{

   235 		pBufferHeader = aBufferList[i];

   236 		pBufferHeader->nFilledLen = 0;

   237 		iCallbacks.

   238 			BufferDoneNotification(

   239 				pBufferHeader,

   240 				pBufferHeader->nInputPortIndex,

   241 				portDirection

   242 				);

   243 		}

   244 

   245 	// Empty buffer list...

   246 	aBufferList.Reset();

   247 

   248 	}

   249 

   250 

   251 OMX_ERRORTYPE

   252 COmxILPcmRendererProcessingFunction::ParamIndication(

   253 	OMX_INDEXTYPE aParamIndex,

   254 	const TAny* apComponentParameterStructure)

   255 	{

   256     DEBUG_PRINTF(_L8("COmxILPcmRendererProcessingFunction::ParamIndication"));

   257 

   258     OMX_ERRORTYPE err = OMX_ErrorNone;

   259     switch(aParamIndex)

   260 	{

   261 	case OMX_IndexParamAudioPcm:

   262 		{

   263 		const OMX_AUDIO_PARAM_PCMMODETYPE* pPcmProfile

   264 			= static_cast<const OMX_AUDIO_PARAM_PCMMODETYPE*>(

   265 				apComponentParameterStructure);

   266 

   267 		if((pPcmProfile->nChannels == 1 || pPcmProfile->nChannels == 2) &&

   268 		  (pPcmProfile->eNumData == OMX_NumericalDataSigned) &&

   269 		  (pPcmProfile->eEndian == OMX_EndianBig) &&

   270 		  (pPcmProfile->bInterleaved == OMX_TRUE) &&

   271 		  (pPcmProfile->nBitPerSample == 16) &&

   272 		  ((pPcmProfile->nSamplingRate == 8000)  ||

   273 		   (pPcmProfile->nSamplingRate == 11025) ||

   274 		   (pPcmProfile->nSamplingRate == 12000) ||

   275 		   (pPcmProfile->nSamplingRate == 16000) ||

   276 		   (pPcmProfile->nSamplingRate == 22050) ||

   277 		   (pPcmProfile->nSamplingRate == 24000) ||

   278 		   (pPcmProfile->nSamplingRate == 32000) ||

   279 		   (pPcmProfile->nSamplingRate == 44100) ||

   280 		   (pPcmProfile->nSamplingRate == 48000)) &&

   281 		  (pPcmProfile->ePCMMode == OMX_AUDIO_PCMModeLinear) &&

   282 		  (pPcmProfile->eChannelMapping[0] == OMX_AUDIO_ChannelLF) &&

   283 		  (pPcmProfile->eChannelMapping[1] == OMX_AUDIO_ChannelRF))

   284 			{

   285 			if (iPFHelper->ParamIndication(pPcmProfile) != KErrNone)

   286 				{

   287 				err = OMX_ErrorInsufficientResources;

   288 				}

   289 			}

   290 		else

   291 			{

   292 			err = OMX_ErrorBadParameter;

   293 			}

   294 		}

   295 		break;

   296 	default:

   297 		{

   298 		// Ignore other port param changes...

   299 		}

   300 	};

   301 

   302 	return err;

   303 

   304 	}

   305 

   306 OMX_ERRORTYPE

   307 COmxILPcmRendererProcessingFunction::ConfigIndication(OMX_INDEXTYPE aConfigIndex,

   308 													  const TAny* apComponentConfigStructure)

   309 	{

   310     DEBUG_PRINTF2(_L8("COmxILPcmRendererProcessingFunction::ConfigIndication %X"), aConfigIndex);

   311 

   312     OMX_ERRORTYPE err = OMX_ErrorNone;

   313     switch(aConfigIndex)

   314 	{

   315 	case OMX_SymbianIndexConfigAudioPcmVolumeRamp:

   316 		{

   317 		const OMX_SYMBIAN_AUDIO_CONFIG_PCM_VOLUMERAMP*

   318 			pPcmVolumeRamp

   319 			= static_cast<

   320 			const OMX_SYMBIAN_AUDIO_CONFIG_PCM_VOLUMERAMP*>(

   321 					apComponentConfigStructure);

   322 

   323 		if (iPFHelper->SetVolumeRamp(pPcmVolumeRamp->nRampDuration) != KErrNone)

   324 			{

   325 			err = OMX_ErrorInsufficientResources;

   326 			}

   327 		}

   328 		break;

   329 

   330 	case OMX_IndexConfigAudioVolume:

   331 		{

   332 		const OMX_AUDIO_CONFIG_VOLUMETYPE* pVolumeType

   333 			= static_cast<const OMX_AUDIO_CONFIG_VOLUMETYPE*>(

   334 					apComponentConfigStructure);

   335 

   336         if (pVolumeType->bLinear == OMX_TRUE)

   337             {

   338             // Some configuration structures contain read-only fields. The 

   339             // OMX_SetConfig method will preserve read-only fields in configuration

   340             // structures that contain them, and shall not generate an error when 

   341             // the caller attempts to change the value of a read-only field.

   342             err = OMX_ErrorNone;

   343             break;

   344             }

   345 			

   346 		if ((pVolumeType->sVolume.nValue <= pVolumeType->sVolume.nMax) &&

   347 		   (pVolumeType->sVolume.nValue >= pVolumeType->sVolume.nMin))

   348 			{

   349 			if (iPFHelper->SetVolume(pVolumeType->sVolume.nValue) != KErrNone)

   350 				{

   351 				err = OMX_ErrorInsufficientResources;

   352 				}

   353 			}

   354 		else

   355 			{

   356 			err = OMX_ErrorBadParameter;

   357 			}

   358 		}

   359 		break;

   360 

   361 	case OMX_IndexConfigAudioMute:

   362 		{

   363 		const OMX_AUDIO_CONFIG_MUTETYPE* pVolumeType

   364 		= static_cast<const OMX_AUDIO_CONFIG_MUTETYPE*>(

   365 				apComponentConfigStructure);

   366 

   367 		if (iPFHelper->SetMuted(pVolumeType->bMute) != KErrNone)

   368 			{

   369 			err = OMX_ErrorInsufficientResources;

   370 			}

   371 		}

   372 		break;

   373 

   374 	default:

   375 		{

   376 		// Ignore other port config changes...

   377 		}

   378 	};

   379 

   380 	return err;

   381 

   382 	}

   383 

   384 OMX_ERRORTYPE

   385 COmxILPcmRendererProcessingFunction::BufferIndication(

   386 	OMX_BUFFERHEADERTYPE* apBufferHeader,

   387 	OMX_DIRTYPE aDirection)

   388 	{

   389     DEBUG_PRINTF2(_L8("COmxILPcmRendererProcessingFunction::BufferIndication : [%X]"), apBufferHeader);

   390 

   391 	if (aDirection != OMX_DirInput)

   392 		{

   393 		return OMX_ErrorBadParameter;

   394 		}

   395     

   396 	if (iBuffersToEmpty.Append(apBufferHeader) != KErrNone)

   397 		{

   398 		return OMX_ErrorInsufficientResources;

   399 		}

   400 

   401 	// If we are not in an executing state or if the audio device is busy, delay playing back the buffer

   402 	if (iState != OMX_StateExecuting || iAudioDevice->IsActive())

   403 		{

   404 		return OMX_ErrorNone;

   405 		}

   406 				

   407 	if (iPFHelper->BufferIndication() != KErrNone)

   408 		{

   409 		return OMX_ErrorInsufficientResources;

   410 		}

   411 

   412 	return OMX_ErrorNone;

   413 	}

   414 

   415 OMX_ERRORTYPE COmxILPcmRendererProcessingFunction::MediaTimeIndication(const OMX_TIME_MEDIATIMETYPE& aMediaTimeType)

   416 	{

   417 	// Received a requested media time notification.

   418 	DEBUG_PRINTF5(_L8("MediaTimeIndication : eUpdateType = %d eState = %d xScale = %d nMediaTimestamp = %d "), 

   419 						aMediaTimeType.eUpdateType, aMediaTimeType.eState, aMediaTimeType.xScale, aMediaTimeType.nMediaTimestamp);

   420 	

   421 	iPFHelper->MediaTimeIndication(aMediaTimeType);

   422 	return OMX_ErrorNone;

   423 	}

   424 

   425 OMX_BOOL

   426 COmxILPcmRendererProcessingFunction::BufferRemovalIndication(

   427 	OMX_BUFFERHEADERTYPE* apBufferHeader,

   428 	OMX_DIRTYPE /* aDirection */)

   429 	{

   430     DEBUG_PRINTF2(_L8("COmxILPcmRendererProcessingFunction::BufferRemovalIndication : BUFFER [%X]"), apBufferHeader);

   431 

   432     TBool headerDeletionResult = ETrue;

   433     // Check if the buffer we want to remove is the one is being currently processed

   434     if (iAudioDevice->IsActive() && iAudioDevice->GetCurrentBuffer() == apBufferHeader)

   435 		{

   436 		if (iPFHelper->CancelDevice() != KErrNone)

   437 			{

   438 			return OMX_FALSE;

   439 			}

   440 

   441 		// if you cancel the audio device then you send the buffer to the other end of the tunnel

   442 		// so you shouldn't say that you had the buffer in the processing function in this situation.

   443 		headerDeletionResult = EFalse;

   444 		}

   445     else

   446 		{

   447 		TInt headerIndexInArray = KErrNotFound;

   448 		if (KErrNotFound !=

   449 			(headerIndexInArray =

   450 			 iBuffersToEmpty.Find(apBufferHeader)))

   451 			{

   452 			iBuffersToEmpty.Remove(headerIndexInArray);

   453 			}

   454 		else if(KErrNotFound !=

   455 				(headerIndexInArray =

   456 				 iBuffersEmptied.Find(apBufferHeader)))

   457 			{

   458 			iBuffersEmptied.Remove(headerIndexInArray);

   459 			}

   460 		else

   461 			{

   462 			headerDeletionResult = EFalse;

   463 			}

   464 		}

   465 

   466     DEBUG_PRINTF2(_L8("BufferRemovalIndication : Removal result [%s]"), (headerDeletionResult ? "YES" : "NO"));

   467     return (headerDeletionResult ? OMX_TRUE : OMX_FALSE);

   468 	}

   469 

   470 TInt

   471 COmxILPcmRendererProcessingFunction::GetBytesPlayed() const

   472 	{

   473 	return iAudioDevice->GetBytesPlayed();

   474 	}

   475 

   476 

   477 COmxILPcmRendererProcessingFunction::CAudioDevice* COmxILPcmRendererProcessingFunction::CAudioDevice::NewL(COmxILPcmRendererProcessingFunction& aParent)

   478 	{

   479 	CAudioDevice* self = new (ELeave) CAudioDevice(aParent);

   480 	CleanupStack::PushL(self);

   481 	self->ConstructL();

   482 	CleanupStack::Pop(self);

   483 	return self;

   484 	}

   485 

   486 COmxILPcmRendererProcessingFunction::CAudioDevice::CAudioDevice(COmxILPcmRendererProcessingFunction& aParent)

   487 : CActive(EPriorityUserInput),

   488   iParent(aParent),

   489   iSampleRate(KDefaultSampleRate),

   490   iChannels(KDefaultNumberChannels),

   491   iEncoding(KDefaultEncoding),

   492   iVolume(KDefaultVolume),

   493   iMuted(KDefaultMuted),

   494   iBufferSize(KBufferSize),

   495   iClockStateRunning(EFalse),

   496   iPausedClockViaScale(EFalse),

   497   iIsStartTimeFlagSet(EFalse)

   498 	{

   499 	CActiveScheduler::Add(this);

   500 	}

   501 

   502 

   503 void COmxILPcmRendererProcessingFunction::CAudioDevice::ConstructL()

   504     {

   505 	iCachedPlayBuffer.CreateL(0);

   506 	}

   507 

   508 COmxILPcmRendererProcessingFunction::CAudioDevice::~CAudioDevice()

   509 	{

   510 	delete iPeriodic;

   511 	Cancel();

   512 	iCachedPlayBuffer.Close();

   513 	}

   514 

   515 void COmxILPcmRendererProcessingFunction::CAudioDevice::RunL()

   516 	{

   517 	DEBUG_PRINTF(_L8("CAudioDevice::RunL : "));

   518 	if (iStatus != KErrNone)

   519 		{

   520 		switch(iStatus.Int())

   521 			{

   522 		case KErrUnderflow:

   523 			DEBUG_PRINTF(_L8("CAudioDevice::RunL : KErrUnderflow"));

   524 			iParent.iCallbacks.ErrorEventNotification(OMX_ErrorUnderflow);

   525 			break;

   526 

   527 		case KErrOverflow:

   528 			DEBUG_PRINTF(_L8("CAudioDevice::RunL : KErrOverflow"));

   529 			iParent.iCallbacks.ErrorEventNotification(OMX_ErrorOverflow);

   530 			break;

   531 

   532 		default:

   533 			DEBUG_PRINTF2(_L8("CAudioDevice::RunL : [%d] -> OMX_ErrorHardware"), iStatus.Int());

   534 			iParent.iCallbacks.ErrorEventNotification(OMX_ErrorHardware);

   535 			};

   536 		}

   537 

   538 	ASSERT(iCurrentBuffer);

   539 	// Update the last value of bytes played...

   540 	iLastBytesPlayedValue = iSoundDevice.BytesPlayed();

   541 

   542 	// Return the emptied buffer to the IL Client or the tunnelled

   543 	// component..

   544 	SignalBufferCompletion(iCurrentBuffer);

   545 	iCurrentBuffer = 0;

   546 		

   547 	// Make sure to clear the aggregated cache buffer, if it was used

   548 	iCachedPlayBuffer.Zero();

   549 	}

   550 

   551 void COmxILPcmRendererProcessingFunction::CAudioDevice::SignalBufferCompletion(

   552 	OMX_BUFFERHEADERTYPE* apCurrentBuffer)

   553 	{

   554 	DEBUG_PRINTF2(_L8("CAudioDevice::SignalBufferCompletion : BUFFER = [%X]"), apCurrentBuffer);

   555 

   556 	iParent.iBuffersEmptied.Append(apCurrentBuffer);

   557 

   558 	// Process the queue only if in executing state...

   559 	if (iParent.iState == OMX_StateExecuting)

   560 		{

   561 		const TUint bufferCount = iParent.iBuffersEmptied.Count();

   562 		OMX_BUFFERHEADERTYPE* pBufferHeader = 0;

   563 		for (TUint i=0; i<bufferCount; ++i)

   564 			{

   565 			pBufferHeader = iParent.iBuffersEmptied[i];

   566 			TBool lastBuffer = EFalse;

   567 			if (pBufferHeader->nFlags & OMX_BUFFERFLAG_EOS)

   568 				{

   569 				lastBuffer = ETrue;

   570 				}

   571 

   572 			pBufferHeader->nFilledLen = 0;

   573 			iParent.iCallbacks.BufferDoneNotification(pBufferHeader,

   574 													  pBufferHeader->nInputPortIndex,

   575 													  OMX_DirInput);

   576 			if (lastBuffer)

   577 				{

   578 				pBufferHeader->nFlags |= OMX_BUFFERFLAG_EOS;

   579 				// propagate the EOS flag

   580 				iParent.iCallbacks.EventNotification(

   581 					OMX_EventBufferFlag,

   582 					KPCMRENDERER_APB0PORT_INDEX,

   583 					pBufferHeader->nFlags,

   584 					NULL);

   585 				}

   586 			}

   587 

   588 		// Empty list...

   589 		iParent.iBuffersEmptied.Reset();

   590 		}

   591 

   592 	if (iParent.iBuffersToEmpty.Count() > 0)

   593 		{

   594 		DEBUG_PRINTF2(_L8("CAudioDevice::RunL : iBuffersToEmpty.Count = [%d]"),

   595 					  iParent.iBuffersToEmpty.Count());

   596 		iParent.iPFHelper->BufferIndication();

   597 		}		

   598 		

   599 	}

   600 

   601 

   602 TBool COmxILPcmRendererProcessingFunction::CAudioDevice::ConstructAndStartUpdateTimer()

   603     {

   604     // Need this check if:

   605     // - The component state transitions from Execution-Idle-Execution

   606     // - The Clock's state transitions from Running-Stop-Running

   607     if (iPeriodic == NULL)

   608         {

   609         iPeriodic = CPeriodic::New(EPriorityStandard);

   610         

   611         if (iPeriodic == NULL)

   612             {

   613             iParent.iCallbacks.ErrorEventNotification(OMX_ErrorInsufficientResources);

   614             return EFalse;

   615             }

   616         }

   617     

   618     StartUpdateTimer();

   619     

   620     return ETrue;

   621     }

   622 

   623 

   624 void COmxILPcmRendererProcessingFunction::CAudioDevice::ProcessNextBuffer()

   625 	{

   626 	if (iParent.iBuffersToEmpty.Count() == 0)

   627 		return;

   628 

   629 	// To implement A/V Sync, we should start playing only once the clock component gives the appopriate command

   630 	// If the clock component is not available, we start playing immediately

   631 	// Since the PCM Renderer supplies the reference clock, we make sure to initialise the clock component with

   632 	// the reference when we receive the first buffer

   633 	

   634 	if (!iParent.iClientClockPortPtr->IsClockComponentAvailable())

   635 		{

   636 		PlayData();

   637 		return;

   638 		}

   639 

   640 	OMX_BUFFERHEADERTYPE* bufferPtr = iParent.iBuffersToEmpty[0];

   641 	

   642 	TBool bufferHasStartTime = bufferPtr->nFlags & OMX_BUFFERFLAG_STARTTIME;

   643 	

   644     if (!iClockStateRunning)

   645         {

   646         if (!bufferHasStartTime)

   647             {

   648             // Connected with the Clock but OMX_BUFFERFLAG_STARTTIME isn't set; simply queue the buffer

   649             return;

   650             }

   651         else

   652             {

   653             OMX_ERRORTYPE err = iParent.iClientClockPortPtr->SetStartTime(static_cast<OMX_TICKS>(bufferPtr->nTimeStamp));

   654             

   655             if (err == OMX_ErrorNone)

   656                 {

   657                 // Clear the returning buffer's flag

   658                 bufferPtr->nFlags &= ~OMX_BUFFERFLAG_STARTTIME;

   659                 }

   660             else

   661                 {

   662                 // NOTE: If the Clock is not in OMX_TIME_ClockStateWaitingForStartTime,

   663                 //       currently SetStartTime will return OMX_ErrorIncorrectStateOperation

   664                 

   665                 // It is not the PCM renderer to flag a Clock component error;

   666                 // therefore, ignore the error.

   667                 // 

   668                 // As the Clock is not in OMX_TIME_ClockStateRunning state, the Renderer needs  

   669                 // to keep the OMX_BUFFERFLAG_STARTTIME in the first buffer until the Clock 

   670                 // moves into OMX_TIME_ClockStateWaitingForStartTime or OMX_TIME_ClockStateRunning

   671                 // state

   672                 DEBUG_PRINTF2(_L8("CAudioDevice::ProcessNextBuffer SetStartTime() return %d"), err);

   673                 }

   674             

   675             // Update the iStartMediaTime

   676             iParent.iStartMediaTime = static_cast<OMX_TICKS>(bufferPtr->nTimeStamp);

   677             iIsStartTimeFlagSet = ETrue;

   678             }

   679         } // (!iClockStateRunning)

   680     else

   681 		{

   682         if (bufferHasStartTime)

   683             {

   684             // The Clock moves straight into OMX_TIME_ClockStateRunning state,

   685             // clear the returning buffer's flag.

   686             bufferPtr->nFlags &= ~OMX_BUFFERFLAG_STARTTIME;

   687             }

   688         

   689         if (!iPlayData)

   690             {

   691             // Not allowed to render audio. This could be due to:

   692             //  - The renderer is waiting for a time completion notification from the Clock;

   693             return;

   694             }

   695 		

   696 		if (!iIsStartTimeFlagSet)

   697 		    {

   698 		    // As the StartTimeFlag is not mandatory; therefore it might be missing from the first audio buffer

   699 		    // In such a case, we use the first buffer's timestamp as the StartMediaTime.

   700 		    //

   701 		    // NOTE: Since the Clock is running, calling SetStartTime() to the Clock is meaningless

   702 		    

   703 		    // Update the iStartMediaTime

   704 		    iParent.iStartMediaTime = static_cast<OMX_TICKS>(bufferPtr->nTimeStamp);

   705 		    iIsStartTimeFlagSet = ETrue;

   706 		    

   707             // Cross checking the Clock's media timestamp with iStartMediaTime to see 

   708             // data can be rendered straight away 

   709             if (!CanPlayNow())

   710                 {

   711                 return;

   712                 }

   713             

   714             if (!ConstructAndStartUpdateTimer())

   715                 {

   716                 return;

   717                 }

   718 		    }

   719 		

   720 		DEBUG_PRINTF3(_L8("ProcessNextBuffer : iStartMediaTime = %d nTimeStamp = %d"), 

   721 	            I64LOW(iParent.iStartMediaTime), I64LOW(bufferPtr->nTimeStamp));

   722 		

   723 		if (!iPausedClockViaScale)	//if clock scale is zero then we are effectively paused

   724 			{

   725 			PlayData();

   726 			}

   727 		} // else

   728 	}

   729 

   730 

   731 void COmxILPcmRendererProcessingFunction::CAudioDevice::PlayData()

   732 	{

   733 	DEBUG_PRINTF(_L8("COmxILPcmRendererProcessingFunction::CAudioDevice::PlayData()++"));

   734 	if (iParent.iBuffersToEmpty.Count() == 0 || iSoundDevice.Handle() == 0 || IsActive())

   735 		{

   736 		DEBUG_PRINTF(_L8("COmxILPcmRendererProcessingFunction::CAudioDevice::PlayData() nothing to play, or there is an outstanding request"));

   737 		return;

   738 		}

   739 

   740 	iCurrentBuffer = iParent.iBuffersToEmpty[0];

   741 

   742 	iParent.iBuffersToEmpty.Remove(0);

   743 

   744 	CMMFDataBuffer* mmfSrcBuffer = static_cast<CMMFDataBuffer*>(iCurrentBuffer->pInputPortPrivate);

   745 	mmfSrcBuffer->Data().SetLength(iCurrentBuffer->nFilledLen);

   746 

   747 	// Attenuate the amplitude of the samples if volume ramping has been changed

   748 	if (iRampAudioSample)

   749 		{

   750 		iRampAudioSample = RampAudio(mmfSrcBuffer);

   751 		}

   752 

   753 	// First, check whether the buffer length is sufficient not to cause underflows in the device driver

   754 	TBool isFilledLengthSufficient = IsBufferLengthSufficient(iCurrentBuffer->nFilledLen);

   755 	// This variable defines whether we should send the data to the driver directly, or append it to an aggregated buffer

   756 	// We append the buffer instead of sending it directly, if (i) the buffer is too small, or (ii)  we have already aggregated something.

   757 	TBool appendBuffer = (!isFilledLengthSufficient || iCachedPlayBuffer.Length() > 0) ? ETrue : EFalse;

   758 	if (!appendBuffer)

   759 		{

   760 		SendBufferToSoundDevice(mmfSrcBuffer->Data());

   761 		}

   762 	else

   763 		{

   764 		// Check if we need to allocate the cached buffer

   765 		if (iCachedPlayBuffer.MaxLength() == 0)

   766 			{

   767 			// The RMdaDevSound shim allocates the shared chunk according to the maxLength of the descriptor it receives

   768 			// For this reason, we must allocate our buffer conservatively, otherwise the chunk may be insufficient and the RMdaDevSound shim will panic			

   769 			TInt err = iCachedPlayBuffer.ReAlloc(GetMinBufferLength() + iCurrentBuffer->nAllocLen);

   770 			if  (err != KErrNone)

   771 				{

   772 				iParent.iCallbacks.ErrorEventNotification(OMX_ErrorInsufficientResources);

   773 				return;

   774 				}

   775 			}

   776 		

   777 		iCachedPlayBuffer.Append(mmfSrcBuffer->Data());

   778 				

   779 		// If we have sufficient length aggregated, play the cached buffer

   780 		// Also if this is the last buffer, we have to play it now, there's nothing left to cache

   781 		if (IsBufferLengthSufficient(iCachedPlayBuffer.Length()) || iCurrentBuffer->nFlags & OMX_BUFFERFLAG_EOS)

   782 			{

   783 			SendBufferToSoundDevice(iCachedPlayBuffer);

   784 			}

   785 		// If not, make sure to notify that we notify that the buffer is done for the OMX tunnnel, so that the port will be able to reuse it

   786 		else

   787 			{

   788 			SignalBufferCompletion(iCurrentBuffer);

   789 			iCurrentBuffer = NULL;

   790 			}

   791 		}

   792 	}

   793 

   794 void COmxILPcmRendererProcessingFunction::CAudioDevice::SendBufferToSoundDevice(TDes8& aBuffer) 

   795 	{

   796 	ASSERT(!IsActive());

   797 	iStatus = KRequestPending;

   798 	DEBUG_PRINTF2(_L8("COmxILPcmRendererProcessingFunction::CAudioDevice::SendBufferToSoundDevice() PlayData [%d]"), aBuffer.Length());

   799 	iSoundDevice.PlayData(iStatus, aBuffer);

   800 	if (iResumeAfterNextPlay)

   801 		{

   802 		iResumeAfterNextPlay = EFalse;

   803 		iSoundDevice.ResumePlaying();

   804 		}

   805 	SetActive();				

   806 	}

   807 	

   808 TInt COmxILPcmRendererProcessingFunction::CAudioDevice::GetMinBufferLength() const

   809 	{

   810 	TInt minBufSize = KMinBufferMilliseconds * iSampleRate * iChannels / 1000;

   811 	if (iEncoding == RMdaDevSound::EMdaSoundEncoding16BitPCM)

   812 		{

   813 		minBufSize *= 2; // All other encodings use 1 byte per sample

   814 		}

   815 	return minBufSize;

   816 	}

   817 	

   818 TBool COmxILPcmRendererProcessingFunction::CAudioDevice::IsBufferLengthSufficient(TInt aBufferLength) const

   819 	{

   820 	return aBufferLength >= GetMinBufferLength() ? ETrue : EFalse;

   821 	}

   822 

   823 

   824 void COmxILPcmRendererProcessingFunction::CAudioDevice::ProcessMediaTimeIndication(OMX_TIME_MEDIATIMETYPE& aMediaTimeType)

   825 	{

   826 	switch (aMediaTimeType.eUpdateType)

   827 		{

   828 		case OMX_TIME_UpdateClockStateChanged:

   829 			{

   830 			HandleClockStateChanged(aMediaTimeType);

   831 			}

   832 			break;

   833 			

   834 		case OMX_TIME_UpdateRequestFulfillment:

   835 			{

   836 			// As the Clock was using another earlier start time;

   837 			// it is time for the PCM renderer to start playing the audio.

   838 			iPlayData = ETrue;

   839 			PlayData();

   840 			

   841 			if (!ConstructAndStartUpdateTimer())

   842 			    {

   843 			    return;

   844 			    }

   845 			}

   846 			break;

   847 			

   848 		case OMX_TIME_UpdateScaleChanged:

   849 			{

   850 			HandleClockScaleChanged(aMediaTimeType);

   851 			}

   852 			break;

   853 			

   854 		default:

   855 			{

   856 			// Do nothing here

   857 			}

   858 		}

   859 	}

   860 

   861 

   862 void COmxILPcmRendererProcessingFunction::CAudioDevice::StartUpdateTimer()

   863 	{

   864 	if (!iIsStartTimeFlagSet)

   865 		{

   866 		DEBUG_PRINTF(_L8("COmxILPcmRendererProcessingFunction::CAudioDevice::StartUpdateTimer() iIsStartTimeFlagSet == EFalse!!"));

   867 		return;

   868 		}

   869 	

   870 	// In case the timer already started

   871 	ASSERT(iPeriodic);

   872 	iPeriodic->Cancel();

   873 	

   874 	TCallBack callback(UpdateClockMediaTime, this);

   875 	

   876 	// Start updating the Clock comp. every KPcmRendererTimePlayedDelay

   877 	iPeriodic->Start(KPcmRendererTimePlayedDelay, KPcmRendererTimePlayedDelay, callback);

   878 	}

   879 

   880 

   881 TBool COmxILPcmRendererProcessingFunction::CAudioDevice::CanPlayNow()

   882     {

   883     if (iParent.iState != OMX_StateExecuting)

   884         {

   885         return EFalse;

   886         }

   887     

   888     if (iClockMediaTime < iParent.iStartMediaTime)

   889         {

   890         // Once all required Clock's clients have responded, the clock component starts 

   891         // the media clock using the earliest client start time.

   892         // Therefore, start playing the audio only when such time comes; send a time

   893         // completion request to the Clock component

   894         OMX_ERRORTYPE err = iParent.iClientClockPortPtr->MediaTimeRequest(NULL, iParent.iStartMediaTime, 0);

   895         

   896         if (err != OMX_ErrorNone)

   897             {

   898             DEBUG_PRINTF2(_L8("CAudioDevice::CanPlayNow() MediaTimeRequest() return %d"), err);

   899             }

   900         

   901         // Indicate that processing a new buffer should not trigger a false start on playback.

   902         iPlayData = EFalse;

   903         return EFalse;

   904         }

   905     else if (iClockMediaTime > iParent.iStartMediaTime)

   906         {

   907         // NOTE: The spec. states that the clock should use the minimum of the received start times

   908         //       Therefore the Clock should NOT jump forwards with timestamp greater than the PCM

   909         //       Renderer iStartMediaTime 

   910         DEBUG_PRINTF3(_L8("CanPlayNow() nMediaTimestamp(%d) > iStartMediaTime(%d) IGNORE this use case"), 

   911                 I64LOW(iClockMediaTime), I64LOW(iParent.iStartMediaTime));

   912         

   913         // However if the Clock sends out a timestamp greater than the buffer's timestamp

   914         // drop the buffers that fall outside the Clock specified MediaTimestamp;

   915         

   916         OMX_BUFFERHEADERTYPE* bufferPtr = iParent.iBuffersToEmpty[0];

   917         iParent.iBuffersToEmpty.Remove(0);

   918         SignalBufferCompletion(bufferPtr);

   919         bufferPtr = NULL;

   920         

   921         // Since the iStartMediaTime doesn't make sense anymore, reset iIsStartTimeFlagSet until the buffer's timestamp 

   922         // is within the the Clock's Media timestamp

   923         iIsStartTimeFlagSet = EFalse;

   924         return EFalse;

   925         }

   926     

   927     return ETrue;

   928     }

   929 

   930 

   931 void COmxILPcmRendererProcessingFunction::CAudioDevice::HandleClockStateChanged(const OMX_TIME_MEDIATIMETYPE& aMediaTimeType)

   932 	{	

   933 	switch (aMediaTimeType.eState)

   934 	    {

   935 	    case OMX_TIME_ClockStateRunning:

   936 	        {

   937 	        iClockMediaTime = aMediaTimeType.nMediaTimestamp;

   938 	        

   939 	        // There are two possibilities:

   940 	        // case 1 - The clock goes straight into running and the PCM renderer processes the  

   941 	        //          StateChanged notification prior the audio buffer

   942 	         

   943 	        if (iIsStartTimeFlagSet)

   944 	            {

   945 	            // OR

   946 	            // case 2 - The PCM recieves the audio buffer, and the clock StateChanged notification

   947 	            // comes later

   948 	            

   949 	            // Clear the returning buffer's flag.

   950 	            iParent.iBuffersToEmpty[0]->nFlags &= ~OMX_BUFFERFLAG_STARTTIME;

   951 	            

   952 	            // Cross checking the Clock's media timestamp with iStartMediaTime to see 

   953 	            // data can be rendered straight away

   954 	            if (!CanPlayNow())

   955 	                {

   956 	                break;

   957 	                }

   958 	            

   959 	            // Start playing the audio and start updating the Clock media time regularly 

   960 	            PlayData();

   961 

   962 	            if (!ConstructAndStartUpdateTimer())

   963 	                {

   964 	                return;

   965 	                }

   966 	            }

   967 			else if ((!iClockStateRunning) && (iParent.iState == OMX_StateExecuting))

   968 				{

   969 				// The clock has gone to running but no start time flag was received. This would

   970 				// indicate that the client moved it straight from stopped to running. As we may

   971 				// have received buffers while in stopped state, we need to start processing

   972 				// them now.

   973                 DEBUG_PRINTF(_L8("HandleClockStateChanged() Gone to running without start time flag set"));

   974 				iClockStateRunning = ETrue;

   975 				ProcessNextBuffer();

   976 				}

   977 	        

   978 	        // Otherwise, the queue is empty;

   979 	        //

   980 	        // NOTE: When !iIsStartTimeFlagSet && !iClockStateRunning would drop the incoming buffers;

   981 	        //       if the first buffer does not have the OMX_BUFFERFLAG_STARTTIME set

   982 	        }

   983 	        break;

   984 	    

   985         case OMX_TIME_ClockStateWaitingForStartTime:

   986             {

   987             if (iClockStateRunning)

   988                 {

   989                 DEBUG_PRINTF(_L8("HandleClockStateChanged() OMX_TIME_ClockStateRunning -> OMX_TIME_ClockStateWaitingForStartTime IGNORED!!"));

   990                 }

   991             else

   992                 {

   993                 // Let's try to process buffers (if any).

   994                 ProcessNextBuffer();

   995                 }

   996             }

   997             break;

   998 

   999         case OMX_TIME_ClockStateStopped:

  1000             {

  1001             if (iClockStateRunning)

  1002                 {

  1003                 // The Clock was in "Running" state but not anymore; stop the audio

  1004                 if (IsActive())

  1005                     {

  1006                     Cancel();

  1007                     }

  1008                 else

  1009                     {

  1010                     DoCancel();

  1011                     }

  1012 

  1013                 iPlayData = ETrue;

  1014                 if (iIsStartTimeFlagSet)

  1015                     {

  1016                     iIsStartTimeFlagSet = EFalse;

  1017                     iPeriodic->Cancel();

  1018                     }

  1019                 }

  1020             

  1021             // Otherwise, ignore other possibilities

  1022             }

  1023             

  1024             break;

  1025          

  1026         default:

  1027             {

  1028             DEBUG_PRINTF2(_L8("HandleClockStateChanged() aMediaTimeType.eState = %d IGNORED!!"), aMediaTimeType.eState);

  1029             }

  1030          break;

  1031 	    }

  1032    

  1033 	iClockStateRunning = (aMediaTimeType.eState == OMX_TIME_ClockStateRunning) ? ETrue : EFalse;

  1034 	}	

  1035 

  1036 

  1037 void COmxILPcmRendererProcessingFunction::CAudioDevice::HandleClockScaleChanged(const OMX_TIME_MEDIATIMETYPE& aMediaTimeType)

  1038 	{

  1039 	if (aMediaTimeType.xScale == 0)

  1040 		{

  1041 		PauseAudio();

  1042 		iPausedClockViaScale = ETrue;

  1043         DEBUG_PRINTF2(_L8("HandleClockScaleChanged() pausing iPausedClockViaScale = %d"), iPausedClockViaScale);

  1044  		}

  1045 	else if (aMediaTimeType.xScale == 0x10000)

  1046 		{

  1047 		// The scale is a Q16 value

  1048 		iPausedClockViaScale = EFalse;

  1049 		DEBUG_PRINTF2(_L8("HandleClockScaleChanged() resuming iPausedClockViaScale = %d"), iPausedClockViaScale);

  1050 

  1051 		// If we are active then there is an outstanding PlayData() request so we need to call ResumePlaying().

  1052 		// However calling ResumePlaying() without an outstanding PlayData() request can cause the TimePLayed() API

  1053 		// to go awry, so we should defer calling ResumePlaying() until the next PlayData() call.

  1054 		if (IsActive())

  1055 			{

  1056 			iSoundDevice.ResumePlaying();

  1057 			}

  1058 		else

  1059 			{

  1060 			iResumeAfterNextPlay = ETrue;

  1061 			}

  1062 		iParent.iPFHelper->BufferIndication();	//handles the race condition where both 1) iSoundDevice was paused after the last PlayData() completed and before it was passed any data & 2) BufferIndication()s came in for all the IL buffers while in this paused state

  1063 		StartUpdateTimer();

  1064 		}

  1065 

  1066 	// TODO: Handle the rest of the scale values

  1067 

  1068 	}

  1069 

  1070 

  1071 void COmxILPcmRendererProcessingFunction::CAudioDevice::DoCancel()

  1072 	{

  1073 	if (iSoundDevice.Handle() != 0)

  1074 		{

  1075 		iSoundDevice.CancelPlayData();

  1076 		iSoundDevice.FlushPlayBuffer();

  1077 		}

  1078 	

  1079 	if (iCurrentBuffer)

  1080 	    {

  1081 		iCurrentBuffer->nFilledLen = 0;

  1082 		

  1083 		iParent.iCallbacks.BufferDoneNotification(iCurrentBuffer,

  1084 		        iCurrentBuffer->nInputPortIndex,

  1085 		        OMX_DirInput);

  1086 		

  1087 		iCachedPlayBuffer.Zero();

  1088 		iCurrentBuffer = NULL;

  1089 		}

  1090 	}

  1091 

  1092 

  1093 OMX_ERRORTYPE COmxILPcmRendererProcessingFunction::CAudioDevice::OpenDevice()

  1094 	{

  1095 	OMX_ERRORTYPE err = OMX_ErrorNone;

  1096 	if(!iSoundDevice.Handle())

  1097 		{

  1098 		if(KErrNone != iSoundDevice.Open(KSoundScTxUnit0))

  1099 			{

  1100 			err = OMX_ErrorHardware;

  1101 			}

  1102 		}

  1103 	return err;

  1104 	}

  1105 

  1106 OMX_ERRORTYPE COmxILPcmRendererProcessingFunction::CAudioDevice::CloseDevice()

  1107 	{

  1108 	OMX_ERRORTYPE err = OMX_ErrorNone;

  1109 	if(iSoundDevice.Handle())

  1110 		{

  1111 		iSoundDevice.Close();

  1112 		iResumeAfterNextPlay = EFalse;

  1113 		}

  1114 	return err;

  1115 	}

  1116 

  1117 OMX_ERRORTYPE COmxILPcmRendererProcessingFunction::CAudioDevice::Execute()

  1118 	{

  1119 	if(!iSoundDevice.Handle())

  1120 		{

  1121 		if(KErrNone != iSoundDevice.Open())

  1122 			{

  1123 			return OMX_ErrorHardware;

  1124 			}

  1125 		}

  1126 

  1127 	if(iParent.iState == OMX_StatePause)

  1128 		{

  1129 		// Now we can send BufferDone notifications for each emptied

  1130 		// buffer...

  1131 		iParent.FlushBufferList(iParent.iBuffersEmptied);

  1132 		// If we are active then there is an outstanding PlayData() request so we need to call ResumePlaying().

  1133 		// However calling ResumePlaying() without an outstanding PlayData() request can cause the TimePLayed() API

  1134 		// to go awry, so we should defer calling ResumePlaying() until the next PlayData() call.