1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // source\server\mmfdatapath.cpp

    15 // 

    16 //

    17 

    18 #include <e32math.h>

    19 #include <mmf/common/mmffourcc.h>

    20 #include <mmf/common/mmfpaniccodes.h>

    21 #include <mmf/server/mmfaudiooutput.h>

    22 #include <mmf/server/mmfaudioinput.h>

    23 #include <mmf/server/mmfdatapath.h>

    24 #include "mmfclientaudiostreamutils.h"

    25 #include <mmf/common/mmfaudio.h>

    26 #include <mmf/plugin/mmfcodecimplementationuids.hrh> // KUidMmfCodecAudioSettings

    27 #include <mmf/server/devsoundstandardcustominterfaces.h>

    28 

    29 const TUid KUidCodecAudioConfig = {KUidMmfCodecAudioSettings};

    30 

    31 void Panic(TMMFDataPathPanicCode aPanicCode, TInt aSourceLineNumber)

    32 	{

    33 	_LIT(KMMFDataPathPanicCategory, "MMFDataPath");

    34 	User::Panic(KMMFDataPathPanicCategory, STATIC_CAST(TInt,aPanicCode) + aSourceLineNumber);

    35 	}

    36 

    37 //all functions are exported form the DLL and are virtual to allow plugins to define there own CMMFDataPaths

    38 

    39 /**

    40 Allocates and constructs a data path.

    41 

    42 Use this function if the codec UID is not already known by CMMFController

    43 and there is no data path ambiguity - ie only one data path is possible.

    44 

    45 Will create codec via fourCC.

    46 

    47 @param  aEventHandler

    48         Installs an event handler to provide message passing between clients and sources/sinks.

    49 

    50 @return Newly constructed data path object.

    51 */

    52 

    53 EXPORT_C CMMFDataPath* CMMFDataPath::NewL(MAsyncEventHandler& aEventHandler)

    54 	{

    55 	CMMFDataPath* self = new(ELeave) CMMFDataPath(TMediaId(), aEventHandler);

    56 	CleanupStack::PushL(self);

    57 	self->ConstructL();

    58 	CleanupStack::Pop();

    59 	return self;

    60 	}

    61 

    62 

    63 /**

    64 Allocates and constructs a data path according to the specified media ID.

    65 

    66 Use this function if the codec UID is not already known by CMMFController

    67 and there is ambiguity with the data path ie. there is more than one possible data path.

    68 

    69 @param  aMediaId

    70         Optional media ID parameter when there are multiple media types.

    71 @param  aEventHandler

    72         Installs an event handler to provide message passing between clients and sources/sinks.

    73 

    74 @return A newly constructed data path object.

    75 */

    76 

    77 EXPORT_C CMMFDataPath* CMMFDataPath::NewL(TMediaId aMediaId, MAsyncEventHandler& aEventHandler)

    78 	{

    79 	CMMFDataPath* self = new(ELeave) CMMFDataPath(aMediaId, aEventHandler);

    80 	CleanupStack::PushL(self);

    81 	self->ConstructL();

    82 	CleanupStack::Pop();

    83 	return self;

    84 	}

    85 

    86 /**

    87 Allocates and constructs a data path according to the specified codec UID.

    88 

    89 Use this function if the codec UID is already known by CMMFController

    90 and there is no data path ambiguity ie. only one data path is possible

    91 will create codec explicitly using the supplied codec Uid

    92 

    93 @param  aCodecUid

    94         Optional mediaID parameter when there are multiple media types

    95 @param  aEventHandler

    96         Installs an event handler to provide message passing between clients and sources/sinks.

    97 

    98 @return A newly constructed data path object.

    99 */

   100 

   101 EXPORT_C CMMFDataPath* CMMFDataPath::NewL(TUid aCodecUid, MAsyncEventHandler& aEventHandler)

   102 	{

   103 	CMMFDataPath* self = new(ELeave) CMMFDataPath(TMediaId(), aEventHandler);

   104 	CleanupStack::PushL(self);

   105 	self->ConstructL(aCodecUid);

   106 	CleanupStack::Pop();

   107 	return self;

   108 	}

   109 

   110 

   111 /**

   112 Allocates and constructs a data path according to the specified codec UID.

   113 

   114 Use this function if the codec UID is already known by CMMFController

   115 and there is ambiguity ie. more than one possible data path.

   116 TMediaId used to select the path.

   117 

   118 @param  aCodecUid

   119 		The codec UID.

   120 @param  aMediaId

   121         Optional mediaID parameter when there are multiple media types.

   122 @param  aEventHandler

   123         Installs an event handler to provide message passing between clients and sources/sinks.

   124 

   125 @return A newly constructed data path object.

   126 */

   127 EXPORT_C CMMFDataPath* CMMFDataPath::NewL(TUid aCodecUid, TMediaId aMediaId, MAsyncEventHandler& aEventHandler)

   128 	{

   129 	CMMFDataPath* self = new(ELeave) CMMFDataPath(aMediaId, aEventHandler);

   130 	CleanupStack::PushL(self);

   131 	self->ConstructL(aCodecUid);

   132 	CleanupStack::Pop();

   133 	return self;

   134 	}

   135 

   136 /**

   137 Standard destructor.

   138 */

   139 

   140 EXPORT_C CMMFDataPath::~CMMFDataPath()

   141 	{

   142 	Cancel();

   143 	delete iCodec;

   144  	DoCleanupBuffers();

   145 

   146 	//log off the source and sink

   147 	if (iDataSource)

   148 		iDataSource->SourceThreadLogoff();

   149 	if (iDataSink)

   150 		iDataSink->SinkThreadLogoff();

   151 

   152 	if (iCompleteCallback)

   153 		{

   154 		iCompleteCallback->Cancel();

   155 		delete iCompleteCallback;

   156 		}

   157 	}

   158 

   159 /**

   160 Deletes buffers if this datapath's sources and sinks own the buffers returned by PrimeL().

   161 Typically if buffers are created asychronously, the datapath doesn't own the buffer

   162 so leaves cleanup handling to the owner sources/sinks.

   163 

   164 Called when source and sink needs to be de-referenced. Sets iDataPathCreated, iSinkCanReceive, 

   165 iSnkBufRef and iSrcBufRef to EFalse; sets iState to EStopped.

   166 */

   167 EXPORT_C void CMMFDataPath::ResetL()

   168 	{

   169 	delete iCodec;

   170 	iCodec = NULL;

   171 	DoCleanupBuffers(); // Delete buffers

   172 	//logoff and dereference source and sink

   173 	if (iDataSource)

   174 		{ iDataSource->SourceThreadLogoff(); iDataSource = NULL; }

   175 	if (iDataSink)

   176 		{ iDataSink->SinkThreadLogoff(); iDataSink = NULL; }

   177 

   178 	// Reset states

   179 	iDataPathCreated = EFalse;

   180 	iState = EStopped;

   181 	iSrcBufRef = EFalse;

   182 	iSnkBufRef = EFalse;

   183 	iPauseCalled = EFalse;

   184 

   185 	delete iCompleteCallback; iCompleteCallback = NULL;

   186 	}

   187 

   188 /**

   189 Delete source and/or sink buffers that are owned by DataPath.

   190 

   191 Ownership indicated by iSrcBufRef and iSnkBufRef.

   192 

   193 Ownership is assigned during buffer allocation within the datapath PrimeL().

   194 */

   195 void CMMFDataPath::DoCleanupBuffers()

   196 	{

   197 	// delete source and/or sink buffer that is owned by DataPath

   198 	if ( !iSrcBufRef && iSourceBuffer )

   199 		{

   200 		delete iSourceBuffer;

   201 		}

   202 	iSourceBuffer = NULL;

   203 	if ( !iSnkBufRef && iSinkBuffer )

   204 		{

   205 		delete iSinkBuffer;

   206 		}

   207 	iSinkBuffer = NULL;

   208 	}

   209 

   210 

   211 /**

   212 Obtain source and/or sink buffer using the synchronous API CreateSourceBufferL() and CreateSinkBufferL().

   213 */

   214 void CMMFDataPath::ObtainSyncBuffersL()

   215 	{

   216 	//Try to create source and sink buffers. If we can't create them synchronously via

   217 	//CreateSourceBufferL and CreateSinkBufferL we will need to obtain them by 

   218 	//asynchronous buffer creation when playing starts.

   219 

   220 	if (iBuffersToUse & ENeedSourceBuffer)

   221 		{

   222 		if (!iSourceBuffer) //we may already have a buffer from a previous initialization

   223 			{

   224 			TRAPD(err, iSourceBuffer = iDataSource->CreateSourceBufferL(iMediaId,*iSinkBuffer, iSrcBufRef));

   225 			if(err != KErrNone && err != KErrNotSupported)

   226 				{

   227 #ifdef _DP_DEBUG

   228 	RDebug::Print(_L("DP::ObtainSyncBuffersL - Leaving %d  (this 0x%x)\n"),err, this);

   229 #endif

   230 				User::Leave(err);

   231 				}

   232 			}

   233 		}

   234 

   235 

   236 	if (iBuffersToUse & ENeedSinkBuffer)

   237 		{

   238 		if (!iSinkBuffer) //we may already have a buffer from a previous initialization

   239 			{

   240 			TRAPD(err, iSinkBuffer = iDataSink->CreateSinkBufferL(iMediaId, iSnkBufRef));

   241 			if(err != KErrNone && err != KErrNotSupported)

   242 				{

   243 #ifdef _DP_DEBUG

   244 	RDebug::Print(_L("DP::ObtainSyncBuffersL - Leaving %d  (this 0x%x)\n"),err, this);

   245 #endif

   246 				User::Leave(err);

   247 				}

   248 			}

   249 		}

   250 

   251 	if (iSourceBuffer && !(iBuffersToUse & ENeedSinkBuffer))

   252 		{//only need one buffer, use source

   253 		iSinkBuffer =iSourceBuffer;

   254 		iSnkBufRef = ETrue; //the sink buffer is not to be deleted

   255 		}

   256 	else if (iSinkBuffer && !(iBuffersToUse & ENeedSourceBuffer))

   257 		{//only need one buffer, use sink

   258 		iSourceBuffer =iSinkBuffer;

   259 		iSrcBufRef = ETrue; //the sink buffer is not to be deleted

   260 		}	

   261 

   262 #ifdef _DP_DEBUG

   263 	RDebug::Print(_L("DP::ObtainSyncBuffersL - DONE  iSourceBuffer=0x%x ref=%d   iSinkBuffer=0x%x ref=%d (this 0x%x)\n"),iSourceBuffer,iSrcBufRef,iSinkBuffer,iSnkBufRef, this);

   264 #endif

   265 	}

   266 

   267 

   268 

   269 

   270 

   271 /**

   272 Constructs a source.

   273 

   274 The default implementation leaves with KErrNotSupported.

   275 

   276 @param  aInitData

   277         The initialisation data.

   278 */

   279 

   280 EXPORT_C void CMMFDataPath::ConstructSourceL( const TDesC8& /*aInitData*/ )

   281 	{

   282 	User::Leave(KErrNotSupported);

   283 	}

   284 

   285 /**

   286 Constructs a sink.

   287 

   288 Overridable constuction specific to this datasource.

   289 

   290 The default implementation leaves with KErrNotSupported.

   291 

   292 @param  aInitData

   293         The initialisation data.

   294 */

   295 EXPORT_C void CMMFDataPath::ConstructSinkL( const TDesC8& /*aInitData*/ )

   296 	{

   297 	User::Leave(KErrNotSupported);

   298 	}

   299 

   300 /**

   301 Takes UID of codec on construction, and if not an NULL codec sets the datapath up for codec instantiation.

   302 

   303 @param  aCodecUid

   304         The UID of the codec.

   305 */

   306 

   307 EXPORT_C void CMMFDataPath::ConstructL(TUid aCodecUid)

   308 	{

   309 	iUseSuppliedCodecUid = EFalse; //initially assume no supplied codec uid

   310 

   311 	if (aCodecUid != KNullUid)

   312 		{//the data path NewL has specified a specific codec

   313 		//create CMMFCodec here

   314 		iCodec = CMMFCodec::NewL(aCodecUid);

   315 		if (iCodec)

   316 			iUseSuppliedCodecUid = ETrue;

   317 		}

   318 

   319 	iSrcBufRef = EFalse;

   320 	iSnkBufRef = EFalse;

   321 	iObtainingAsyncSourceBuffer = EFalse;

   322 	iObtainingAsyncSinkBuffer = EFalse;

   323 	iSourceBufferWithSource = EFalse;

   324 	iSinkBufferWithSink = EFalse;

   325 	}

   326 

   327 

   328 /** 

   329 Adds a data source to the datapath and, if the sink already exists, tries to establish a connection

   330 between the source and sink.

   331 

   332 @param  aSource

   333         The data source to add to the data path.

   334 */

   335 EXPORT_C void CMMFDataPath::AddDataSourceL(MDataSource* aSource)

   336 	{

   337 	if (!iDataSink) iDataSource=aSource; //can't create a data path without the MDataSink as well

   338 	else if (!iUseSuppliedCodecUid) //no supplied uid need to see if we can create codec to establish a data path

   339 		{//we have a data sink as well so check a data path can be established between source&sink

   340 		CreateDataPathL(aSource, iDataSink);

   341 		iDataSource = aSource;

   342 		}

   343 	else //the CMMFController specified the codec uid so must use existing codec

   344 		{//note we are assuming here that the CMMFController knows what it is doing ie the supplied codec uid 

   345 		//can make the appropriate data conversion

   346 		iDataPathCreated = ETrue;

   347 		iDataSource = aSource;

   348 		}

   349 	ClearPlayWindowL() ;

   350 	User::LeaveIfError(iDataSource->SourceThreadLogon(*this));

   351 	}

   352 

   353 

   354 /** 

   355 Adds a data sink to the datapath and, if the source already exists, tries to establish a connection

   356 between the source and sink.

   357 

   358 @param  aSink

   359         The data sink to add to the data path.

   360 */

   361 

   362 EXPORT_C void CMMFDataPath::AddDataSinkL(MDataSink* aSink)

   363 	{

   364 	if (!iDataSource) iDataSink=aSink; //can't create a data path without the MDataSource as well

   365 	else if (!iUseSuppliedCodecUid) //no supplied uid need to see if we can create codec to establish a data path

   366 		{//we have a data source as well so check a media path can be established between source&sink

   367 		CreateDataPathL(iDataSource, aSink);

   368 		iDataSink = aSink;

   369 		}

   370 	else //the CMMFController specified the codec uid so must use existing codec

   371 		{//note we are assuming here that the CMMFController knows what it is doing ie the supplied codec uid 

   372 		//can make the appropriate data conversion

   373 		iDataPathCreated = ETrue;

   374 		iDataSink = aSink;	

   375 		

   376 		//set 4CCs

   377 		iSourceFourCC  = iDataSink->SinkDataTypeCode(iMediaId);//sink because CMMFDataPath is an MDataSink to its MDataSource!

   378 		iSinkFourCC = iDataSource->SourceDataTypeCode(iMediaId);//source because CMMFDataPath is an MDataSource to its MDataSink!

   379 		}

   380 	User::LeaveIfError(iDataSink->SinkThreadLogon(*this));

   381 	}

   382 

   383 

   384 /* 

   385  *  CreateDataPathL 

   386  * 

   387  *  internal function to establish a datapath between the source and sink

   388  *	the data supplied by the sink adn expected by the source are checked and 

   389  *	a codec is instantiated if necessary

   390  *

   391  *	@param	aSource

   392  *	@param	aSink

   393  */

   394 

   395 void CMMFDataPath::CreateDataPathL(MDataSource* aSource, MDataSink* aSink)

   396 	{ //procedure to attempt to match the source to the sink creating a codec if necessary

   397 	// returns ETrue if the datapath could be constructed else false

   398 	//sets iCodec to the appropriate codec.& sets its own iSink/iSource FourCC datatype codes

   399 	iDataPathCreated = EFalse;

   400 	if (aSource && aSink) //have a source and sink

   401 		{ //we have a data source & sink but no codec so try and find one - if required

   402 		TFourCC sourceFourCCCode = aSource->SourceDataTypeCode(iMediaId); //get MDataSource data type fourCC code

   403 		TFourCC sinkFourCCCode = aSink->SinkDataTypeCode(iMediaId); //get MDataSink data type fourCC code

   404 		if ((sourceFourCCCode != sinkFourCCCode) && //MDataSource & MDataSink datatypes are not compatible

   405 			(sourceFourCCCode != KMMFFourCCCodeNULL) && (sinkFourCCCode != KMMFFourCCCodeNULL)) 

   406 			{//we need a codec to make the conversion between the source and the sink

   407 			CMMFCodec* codec = CMMFCodec::NewL(sourceFourCCCode, sinkFourCCCode);

   408 

   409 			if (codec)

   410 				{

   411 				delete iCodec;

   412 				iCodec = codec;

   413 				//data path created ie have source/sink and can match their datatypes

   414 				iDataPathCreated = ETrue;

   415 

   416 				//now we have an source attached we need to configure the codec for sample rate

   417 				//and number of channels

   418 

   419 				//prepare a package to send to a codec

   420 				TMMFAudioConfig audioSettings;

   421 				

   422 				//test for decoder

   423 				if (aSource->DataSourceType() == KUidMmfFormatDecode)

   424 					{

   425 					audioSettings.iSampleRate = static_cast<CMMFFormatDecode*>(aSource)->SampleRate();

   426 					audioSettings.iChannels = static_cast<CMMFFormatDecode*>(aSource)->NumChannels();

   427 					}

   428 

   429 				//package up to send to codec

   430 				TPckgBuf<TMMFAudioConfig> configPackage(audioSettings);

   431 

   432 				//we need to catch User::Leave(KErrNotSupported) as by default most codecs

   433 				//do not support the ConfigureL method.

   434 				TRAPD(err,iCodec->ConfigureL(KUidCodecAudioConfig, configPackage));

   435 				// need to check other error here

   436 				if (err != KErrNone && err != KErrNotSupported)

   437 					{

   438 					User::Leave(err);

   439 					}

   440 				}

   441 			else

   442 				{

   443 				User::Leave( KErrNotSupported ) ; //couldn't find suitable codec

   444 				}

   445 			} //if (sourceFourCCCode != sinkFourCCCode)

   446 		else 

   447 			{ //source & sink fourCC datatypes are the same so no codec is required

   448 			__ASSERT_DEBUG(iCodec == NULL,  Panic(EMMFDataPathPanicProgrammingError,__LINE__)); 			

   449 

   450 			iDataPathCreated = ETrue;

   451 			}

   452 		//can assign FourCC codes for the CMMFDataPath

   453 		iSinkFourCC = sourceFourCCCode; //sink because CMMFDataPath is an MDataSink to its MDataSource!

   454 		iSourceFourCC = sinkFourCCCode; //source because CMMFDataPath is an MDataSource to its MDataSink!

   455 		//If sink & source need its own Prime() done in controller	

   456 		} 

   457 	}

   458 

   459 /**

   460 Clears the specified buffer.

   461 

   462 Pure virtual dummy implementation, not needed by datapath

   463 comes from MDataSink - CMMFData path is a sink to its MDataSource.

   464 

   465 This is only required for an active push MDataSource requesting a buffer empty.

   466 

   467 @param  aBuffer

   468         The buffer to empty.

   469 @param  aSupplier

   470         The MDataSource supplying this buffer.

   471 @param  aMediaId

   472         An optional mediaID parameter when there are multiple buffers arriving of different media types.

   473 

   474 */

   475 EXPORT_C void CMMFDataPath::EmptyBufferL(CMMFBuffer* /* aBuffer */, MDataSource* /*aSupplier*/, TMediaId /*aMediaId*/)

   476 	{

   477 	//not implemented

   478 	}

   479 

   480 

   481 

   482 /* 

   483  *  FillSourceBufferL

   484  * 

   485  *	Function to get data from the datapath's iDataSource

   486  */

   487 

   488 void CMMFDataPath::FillSourceBufferL()

   489 	{

   490 #ifdef _DP_DEBUG

   491 	RDebug::Print(_L("DP::FillSourceBufferL tick-%d   (this 0x%x)\n"),User::TickCount(),this);

   492 #endif

   493 

   494 	__ASSERT_DEBUG((iState == EPlaying || iState == EConverting || iState == ERecording), Panic(EMMFDataPathPanicBadState,__LINE__)); 

   495 

   496 

   497 	// clear the no-more-source flag here (as well as in PlayL()) because 

   498 	// there may have been a re-position since the last call to BufferFilledL()

   499 	iNoMoreSourceData = EFalse;

   500 

   501 	if(!iObtainingAsyncSourceBuffer) 

   502 		{//this is a normal request for data. 

   503 		//If we are getting asynchronous buffers, then can't do this as iSourceBuffer == NULL

   504 		iSourceBuffer->SetFrameNumber(++iCurrentSourceFrameNumber); //so source knows which data to load buffer with

   505 		iSourceBuffer->SetStatus(EBeingFilled);

   506 		iSourceBuffer->SetLastBuffer(EFalse);

   507 		}

   508 

   509 #ifdef _DP_DEBUG

   510 	RDebug::Print(_L("DP asking for buffer %d  - ptr=0x%x   (this 0x%x)\n"), iCurrentSourceFrameNumber, iSourceBuffer,this);	

   511 #endif

   512 

   513 	iSourceBufferWithSource = ETrue;

   514 

   515 	// wait for BufferFilled callback from source. Do this here as some sources cause

   516 	//re-entrancy into data path via BufferFilledL

   517 	ChangeDataPathTransferState(EWaitSource);  

   518 

   519 	iDataSource->FillBufferL(iSourceBuffer, this, iMediaId);

   520 

   521 #ifdef _DP_DEBUG

   522 	RDebug::Print(_L("DP::FillSourceBufferL - DONE tick-%d   (this 0x%x)\n"),User::TickCount(),this);

   523 #endif

   524 	}

   525 

   526 

   527 /** 

   528 Indicates the data source has filled the specified buffer.

   529 

   530 Called by the CMMFDataPath's MDataSource when it has filled the buffer.

   531 

   532 @param aBuffer

   533        A pointer to the filled buffer.

   534 */

   535 EXPORT_C void CMMFDataPath::BufferFilledL(CMMFBuffer* aBuffer)

   536 	{	

   537 #ifdef _DP_DEBUG

   538 	RDebug::Print(_L("DP::BufferFilledL src has filled buffer %d (ptr=0x%x) with %d bytes EoF = %d  tick-%d    (this 0x%x)\n"),aBuffer->FrameNumber(),aBuffer, aBuffer->BufferSize(),aBuffer->LastBuffer(), User::TickCount(),this);

   539 #endif

   540 	

   541 	//This assertion is commented because of PDEF117405

   542 	//state only used if we are passing data

   543 	//__ASSERT_DEBUG((iState == EPlaying || iState == EConverting || iState == ERecording), Panic(EMMFDataPathPanicBadState,__LINE__));

   544 

   545 	__ASSERT_DEBUG((!iNoMoreSourceData), Panic(EMMFDataPathPanicBadState,__LINE__)); 

   546 		

   547 	iSourceBufferWithSource = EFalse;

   548 

   549 	//Has the datapath stopped running, if so were not interested in any callbacks.

   550 	if(iState == EStopped || iState == EPrimed || (iPauseCalled && iState != ERecording))

   551 		{

   552 #ifdef _DP_DEBUG

   553 		RDebug::Print(_L("DP::BufferFilledL called while not expecting callback iState=%d  iPauseCalled=%d  (this 0x%x)\n"),iState, iPauseCalled,this);

   554 #endif

   555 		return;

   556 		}

   557 

   558 #ifdef REPOSITION_SPEEDUP

   559 	// if the source has been re-positioned, then go & get some more source data now

   560 	if (!iObtainingAsyncSourceBuffer && iSourceBuffer->FrameNumber() != iCurrentSourceFrameNumber)

   561 		{

   562 #ifdef _DP_DEBUG

   563 		RDebug::Print(_L("DP::BufferFilledL source was re-positioned re-requesting source data (this 0x%x)\n"),this);

   564 #endif

   565 		ChangeDataPathTransferState(ENeedSourceData);

   566 		return;

   567 		}

   568 #endif //REPOSITION_SPEEDUP

   569 

   570 	//bufer is NULL, indicating no more source data.

   571 	if (!aBuffer)

   572 		{

   573 		//If we only hold a reference to the source buffer, set that to NULL

   574 		if(iSnkBufRef)

   575 			iSourceBuffer = NULL;

   576 

   577 

   578 		iNoMoreSourceData = ETrue;

   579 

   580 		if(!iCodec || //there's only one buffer and that has been returned as NULL, so must be end of data

   581 		  iSinkBufferWithSink) //buffer is with sink, we don't have any more data to put in it, so must be end of data

   582 			{

   583 			ChangeDataPathTransferState(EEndOfData);

   584 			}

   585 		else //sink buffer is with datapath, see if there is anything to send to sink

   586 			ChangeDataPathTransferState(ENeedToMatchSourceToSink);

   587 

   588 #ifdef _DP_DEBUG

   589 		RDebug::Print(_L("DP::BufferFilledL DONE aBuffer==NULL tick-%d (this 0x%x)\n"),User::TickCount(),this);

   590 #endif

   591 		return;

   592 		} 

   593 

   594 	

   595 	//We were waiting for a response from the source to get an asynchronous buffer.

   596 	//We now have it, and we proceed to transfer this data to the sink.

   597 	if	(iObtainingAsyncSourceBuffer)

   598 		{

   599 		iObtainingAsyncSourceBuffer = EFalse;

   600 		}

   601 	

   602 

   603 	aBuffer->SetStatus(EFull);

   604 

   605 	if(iSourceBuffer != aBuffer)

   606 		{//buffer has been changed by the source

   607 		iSourceBuffer = aBuffer;

   608 		if (!(iBuffersToUse & ENeedSinkBuffer))

   609 			{//we only need one buffer and use source

   610 			iSinkBuffer = iSourceBuffer;

   611 			iSnkBufRef = ETrue;

   612 			}

   613 #ifdef _DP_DEBUG

   614 	RDebug::Print(_L("DP::BufferFilledL - iSourceBuffer=0x%x ref=%d   iSinkBuffer=0x%x ref=%d (this 0x%x)\n"),iSourceBuffer,iSrcBufRef,iSinkBuffer,iSnkBufRef, this);

   615 #endif	

   616 		}

   617 	//Is this the last buffer from the source (0 length or LastBuffer flag set)

   618 	//or have reached the end of the play window; we only look at the play window here

   619 	//if we are converting. For conversion we look at the data we have read. This is then passed onto 

   620 	//the source

   621 	if (!iSourceBuffer->BufferSize() || iSourceBuffer->LastBuffer() ||

   622 		(((iState == EConverting) || (iState == EPlaying)) && (iPlayWindowEndPosition < iCachedSourceDuration) && ( InputPosition() >= iPlayWindowEndPosition ))) 

   623 		{

   624 #ifdef _DP_DEBUG

   625 		RDebug::Print(_L("DP::BufferFilledL end of input data  tick-%d   (this 0x%x)\n"),User::TickCount(),this);

   626 		RDebug::Print(_L("iSourceBuffer->BufferSize()=%d\n"),iSourceBuffer->BufferSize());

   627 		RDebug::Print(_L("iSourceBuffer->LastBuffer()=%d\n"),iSourceBuffer->LastBuffer());

   628 		RDebug::Print(_L("InputPosition()=%d  >= iPlayWindowEndPosition=%d\n"),I64INT(InputPosition().Int64()),I64INT(iPlayWindowEndPosition.Int64()));

   629 #endif

   630 		iNoMoreSourceData = ETrue;

   631 		iSourceBuffer->SetLastBuffer(ETrue); //just in-case we are terminating on BufferSize == 0 or play window

   632 		}

   633 

   634 

   635 	if (!iCodec)

   636 		ChangeDataPathTransferState(ESendDataToSink);

   637 	else if(!iSinkBufferWithSink) //sink buffer is with data path, can try to fill it

   638 		ChangeDataPathTransferState(ENeedToMatchSourceToSink);

   639 	//else wait for sink to return buffer BufferEmptied will send us into ENeedToMatchSourceToSink state

   640 

   641 #ifdef _DP_DEBUG

   642 	RDebug::Print(_L("DP::BufferFilledL - DONE tick-%d   (this 0x%x)\n"),User::TickCount(),this);

   643 #endif

   644 	}

   645 

   646 

   647 

   648 

   649 /* 

   650  *  FillSinkBufferL

   651  * 

   652  *	Function to take the data from an already full source buffer and by using

   653  *	a codec if necessary fills the sink buffer

   654  */

   655 

   656 void CMMFDataPath::FillSinkBufferL()

   657 	{

   658 #ifdef _DP_DEBUG

   659 	RDebug::Print(_L("DP::FillSinkBufferL tick-%d   (this 0x%x)\n"),User::TickCount(),this);

   660 #endif

   661 

   662 	//This state is only used if we are passing data

   663 	__ASSERT_DEBUG((iState == EPlaying || iState == EConverting || iState == ERecording), Panic(EMMFDataPathPanicBadState,__LINE__)); 

   664 

   665 	//This state is only used if we have a real codec

   666 	__ASSERT_DEBUG(iCodec, Panic(EMMFDataPathPanicBadState,__LINE__)); 

   667 

   668 

   669 	//The sink buffer is with the sink so we can't fill it.

   670 	//When it has been emptied, this state will be re-entered from BufferEmptiedL

   671 	if(iSinkBufferWithSink)

   672 		{

   673 #ifdef _DP_DEBUG

   674 		RDebug::Print(_L("DP::FillSinkBufferL buffer is in use by SINK - DONE   (this 0x%x)\n"),this);

   675 #endif

   676 		ChangeDataPathTransferState(EWaitSink);  // wait for BufferEmptied callback from sink

   677 		return;

   678 		}

   679 

   680 	//The source buffer is with the source so we can't take data from it.

   681 	//When it has been filled, this state will be re-entered from BufferFilledL

   682 	if(iSourceBufferWithSource)

   683 		{

   684 #ifdef _DP_DEBUG

   685 		RDebug::Print(_L("DP::FillSinkBufferL buffer is in use by SOURCE - DONE   (this 0x%x)\n"),this);

   686 #endif

   687 		ChangeDataPathTransferState(EWaitSource);  // wait for BufferFilled callback from source

   688 		return;

   689 		}

   690 

   691 	//source buffer is NULL, can't be any more data to send.

   692 	//iNoMoreSourceData is set and the source buffer is empty, can't be any more data to send.

   693 	if(!iSourceBuffer || (iNoMoreSourceData && !iSourceBuffer->BufferSize()))

   694 		{

   695 		if(iSinkBuffer->Status() == EBeingFilled)

   696 			{//if we have data in sink buffer, mark it as last buffer and send

   697 			iSinkBuffer->SetLastBuffer(ETrue);

   698 			ChangeDataPathTransferState(ESendDataToSink);

   699 			}

   700 		else //the sink buffer can't have anything in it

   701 			ChangeDataPathTransferState(EEndOfData);

   702 		}

   703 

   704 #ifdef REPOSITION_SPEEDUP

   705 	// if the source has been re-positioned, 

   706 	// speed things up by getting some more source data now

   707 	if(iSourceBuffer && iSourceBuffer->FrameNumber() != iCurrentSourceFrameNumber)

   708 		{

   709 #ifdef _DP_DEBUG

   710 		RDebug::Print(_L("DP::FillSinkBufferL() source was re-positioned re-requesting source data (this 0x%x)\n"),this);

   711 #endif

   712 		ChangeDataPathTransferState(ENeedSourceData);

   713 		return;

   714 		}

   715 #endif //REPOSITION_SPEEDUP

   716 

   717 	iSinkBuffer->SetStatus(EBeingFilled);

   718 	iSinkBuffer->SetLastBuffer(EFalse);

   719 

   720 	//pass buffer to codec for processing

   721 	iCodecProcessResult = iCodec->ProcessL(*iSourceBuffer, *iSinkBuffer);

   722 	//the codec tries to fill the sink buffer to its max length

   723 	//TCodecProcessResult returns the status of the codec Process -

   724 	//this can result in result conditions such as:

   725 	//EProcessComplete - the codec processed all the source data into the sink buffer

   726 	//EProcessIncomplete - the codec filled sink buffer before all the source buffer was processed

   727 	//EDstNotFilled - the codec processed the source buffer but the sink buffer was not filled

   728 	//EEndOfData - the codec detected the end data - all source data in processed but sink may not be full

   729 	//EProcessError - the codec process error condition

   730 

   731 	

   732 	switch (iCodecProcessResult.iStatus)

   733 		{

   734 	case TCodecProcessResult::EProcessComplete:

   735 	//finished procesing source data - all data in sink buffer

   736 		{

   737 #ifdef _DP_DEBUG

   738 		RDebug::Print(_L("CMMFDataPath::FillSinkBufferL codec EProcessComplete   (this 0x%x)\n"),this);

   739 #endif

   740 		iSourceBuffer->SetStatus(EAvailable); //source buffer is now avaialble

   741 		iSinkBuffer->SetStatus(EFull);	//sink buffer is full	

   742 		if (iNoMoreSourceData) 

   743 			iSinkBuffer->SetLastBuffer(ETrue);

   744 		ChangeDataPathTransferState(ESendDataToSink);// the full sink buffer needs to be sent to the sink 

   745 		}

   746 	break;

   747 	case TCodecProcessResult::EProcessIncomplete:

   748 		// the sink was filled before all the src was processed 

   749 		// therefore still send everything to sink 

   750 		//but datapath needs to carry on processing the source buffer before it gets more source data

   751 		//when sink has emptied data path needs to send rest of data

   752 		{

   753 #ifdef _DP_DEBUG

   754 		RDebug::Print(_L("CMMFDataPath::FillSinkBufferL codec EProcessIncomplete   (this 0x%x)\n"),this);

   755 #endif

   756 		TUint sourceBufferPosition = iCodecProcessResult.iSrcBytesProcessed + iSourceBuffer->Position();

   757 		iSourceBuffer->SetPosition(sourceBufferPosition);//update source buffer position

   758 		iSinkBuffer->SetStatus(EFull); //sink & source buffers are both full

   759 		ChangeDataPathTransferState(ESendDataToSink); // the full sink buffer needs to be sent to the sink 

   760 		}

   761 	break;

   762 	case TCodecProcessResult::EDstNotFilled:

   763 		// the destination is not full 

   764 		{

   765 #ifdef _DP_DEBUG

   766 		RDebug::Print(_L("CMMFDataPath::FillSinkBufferL codec EDstNotFilled   (this 0x%x)\n"),this);

   767 #endif

   768 		iSourceBuffer->SetStatus(EAvailable); //source buffer is now available

   769 		TUint sinkBufferPosition = iCodecProcessResult.iDstBytesAdded + iSinkBuffer->Position();

   770 		iSinkBuffer->SetPosition(sinkBufferPosition);//update sink  buffer position (still EBeingFilled)

   771 		// if this was the last source buffer, send what we've got (if anything) 

   772 		// to the sink... EmptySinkBuffer() should then enter EEndOfData state

   773 		if (iNoMoreSourceData)

   774 			{

   775 			iSinkBuffer->SetLastBuffer(ETrue);

   776 			ChangeDataPathTransferState(ESendDataToSink);//send what we've got to the sink - 

   777 			}

   778 		else

   779 			{

   780 			ChangeDataPathTransferState(ENeedSourceData); //need to get more source data to fill sink buffer

   781 			}

   782 		}

   783 	break;	

   784 	case TCodecProcessResult::EEndOfData:

   785 		//no more data - send what we've got to the sink

   786 		//note we can't always rely on this  - in many cases the codec will not know when

   787 		//it has reached the end of data.

   788 		{

   789 #ifdef _DP_DEBUG

   790 		RDebug::Print(_L("CMMFDataPath::FillSinkBufferL codec EEndOfData   (this 0x%x)\n"),this);

   791 #endif

   792 		iSourceBuffer->SetStatus(EAvailable); //source buffer is now avaialble

   793 		iSinkBuffer->SetStatus(EFull);//sink buffer may not really be 'full' but its as full as it going to get

   794 

   795 		//This only occurs where the codec can detect the end of data, but the source can't

   796 		iNoMoreSourceData=ETrue;

   797 		iSinkBuffer->SetLastBuffer(ETrue); 

   798 

   799 		ChangeDataPathTransferState(ESendDataToSink);//send what we've got to the sink - 

   800 		//doesn't matter if sink buffer is not full

   801 		}

   802 	break;

   803 	case TCodecProcessResult::EProcessError:

   804 #ifdef _DP_DEBUG

   805 		RDebug::Print(_L("DP::FillSinkBufferL tick-%d  DONE %d   (this 0x%x)\n"),User::TickCount(), __LINE__,this);

   806 #endif

   807 		User::Leave(KErrCorrupt); //codec process error

   808 	break;

   809 	default:

   810 #ifdef _DP_DEBUG

   811 		RDebug::Print(_L("DP::FillSinkBufferL tick-%d  DONE %d   (this 0x%x)\n"),User::TickCount(), __LINE__,this);

   812 #endif

   813 		User::Leave(KErrCorrupt); //should never get here

   814 		}

   815 #ifdef _DP_DEBUG

   816 	RDebug::Print(_L("DP::FillSinkBufferL - done  tick-%d   (this 0x%x)\n"),User::TickCount(),this);

   817 #endif

   818 	}

   819 

   820 

   821 

   822 /**

   823 Tests whether the data path can create a sink buffer.

   824 

   825 The default implementation returns false.

   826 

   827 @return ETrue if the data path can create a sink buffer. EFalse if the data path cannot create a sink buffer.

   828 */

   829 EXPORT_C TBool CMMFDataPath::CanCreateSinkBuffer()

   830 	{

   831 	return NULL; //CMMFDataPath cannot create buffer

   832 	}

   833 

   834 /**

   835 Creates a sink buffer according to the specifed media ID.

   836 

   837 Intended for synchronous usage (buffers supplied by datapath for an MDataSink).

   838 This method is essentially a dummy implementation of an MDataSink pure virtual.

   839 

   840 The default implementation returns NULL.

   841 

   842 @param  aMediaId

   843         An optional mediaID parameter when there are multiple buffers arriving of different media types.

   844 

   845 @return Returns NULL in this instance as datapath can't create sink buffers

   846 */

   847 EXPORT_C CMMFBuffer* CMMFDataPath::CreateSinkBufferL(TMediaId /*aMediaId*/)

   848 	{//CMMFDataPath can't create buffers

   849 	return NULL;

   850 	}

   851 

   852 /**

   853 Creates a sink buffer according to the specifed media ID and reference.

   854 

   855 Intended for asynchronous usage (buffers supplied by Devsound device).

   856 This method is essentially a dummy implementation of an MDataSink pure virtual.

   857 

   858 The default implementation returns NULL.

   859 

   860 @param  aMediaId

   861         An optional mediaID parameter when there are multiple buffers arriving for different media types.

   862 @param  aReference

   863         A boolean indicating buffer ownership.

   864 

   865 @return	Returns NULL in this instance as datapath can't create sink buffers.

   866 */

   867 EXPORT_C CMMFBuffer* CMMFDataPath::CreateSinkBufferL(TMediaId /*aMediaId*/, TBool& /*aReference*/)

   868 	{//CMMFDataPath can't create buffers

   869 	return NULL;

   870 	}

   871 

   872 /**

   873 Gets the sink's data type for the specified media ID.

   874 

   875 @param  aMediaId

   876         An optional parameter to specifiy the specific stream when datasource contains more than one stream of data

   877 @return The sink's data type.

   878 */

   879 EXPORT_C TFourCC CMMFDataPath::SinkDataTypeCode(TMediaId /*aMediaId*/)

   880 	{

   881 	return(iSinkFourCC);

   882 	}

   883 

   884 /**

   885 Fills the specified buffer.

   886 

   887 Pure virtual dummy implementation, not needed by datapath

   888 comes from MDataSink - CMMFData path is a source to its MDataSink

   889 

   890 Only required for an active pull MDataSink requesting a buffer fill. The default implementation is empty.

   891 

   892 @param  aBuffer

   893         The buffer to fill.

   894 @param  aConsumer

   895         The MDataSink supplying this buffer.

   896 @param  aMediaId

   897         An optional mediaID parameter when there are multiple buffers arriving of different media types

   898 */

   899 EXPORT_C void CMMFDataPath::FillBufferL(CMMFBuffer* /*aBuffer*/, MDataSink* /*aConsumer*/, TMediaId /*aMediaId*/)

   900 	{

   901 	//not implementated

   902 	}

   903 

   904 void CMMFDataPath::SetBuffersAvailable()

   905 	{

   906 	// set source buffer to be available

   907   	if (iSourceBuffer)

   908   		iSourceBuffer->SetStatus(EAvailable);

   909 	// set sink buffer to be available

   910   	if (iSinkBuffer)

   911   		iSinkBuffer->SetStatus(EAvailable);

   912 	}

   913 

   914 void CMMFDataPath::ResetRefBuffers()

   915 	{

   916 #ifdef _DP_DEBUG

   917 	RDebug::Print(_L("DP::ResetRefBuffers iSourceBuffer=0x%x ref=%d   iSinkBuffer=0x%x ref=%d (this 0x%x)\n"),iSourceBuffer,iSrcBufRef,iSinkBuffer,iSnkBufRef, this);

   918 #endif

   919 

   920 	// Reset the buffer pointers to NULL if they are supplied by DevSound

   921 	// We do this because buffers that are not owned by the datapath may not be valid any more.

   922 	if (iSrcBufRef)

   923 		{

   924 		iSourceBuffer = NULL;

   925 		}

   926 	if (iSnkBufRef)

   927 		{

   928 		iSinkBuffer = NULL;

   929 		}

   930 	}

   931 

   932 

   933 

   934 

   935 TInt CMMFDataPath::DetermineBuffersToUseL(void) const

   936 	{

   937 	TInt buffs = ENoBuffers;

   938 	if(iCodec)

   939 		{//Using a real Codec, need both sets of buffers

   940 		if(!iDataSink->CanCreateSinkBuffer() || ! iDataSource->CanCreateSourceBuffer())

   941 			User::Leave(KErrNotSupported);

   942 

   943 		buffs = CMMFDataPath::ENeedSinkBuffer | CMMFDataPath::ENeedSourceBuffer;	

   944 		}

   945 	else //we are using a Null Codec, only need one buffer, but which one?

   946 		{//use buffer from DevSound, if no DevSound (ie, clip to clip), prefer source buffer.

   947 		//If preferring source but it can't create buffers, use sink.

   948 		if ((iDataSink->DataSinkType() == KUidMmfAudioOutput) && (iDataSink->CanCreateSinkBuffer()))

   949 			buffs = ENeedSinkBuffer;

   950 		else if(iDataSource->CanCreateSourceBuffer())

   951 			buffs = ENeedSourceBuffer;

   952 		else if(iDataSink->CanCreateSinkBuffer())

   953 			buffs = ENeedSinkBuffer;

   954 		else

   955 			User::Leave(KErrNotSupported);

   956 		}

   957 	return buffs;

   958 	}

   959 

   960 

   961 

   962 /*

   963  *  InitializeSinkL

   964  *

   965  *	Function to initialize iDataSink before it can start sending data

   966  *	This is a one time prime. This will synchronize DataPath's data driving

   967  *	mechanism with HwDevice implementation.

   968  *

   969  *  This initialisation method detects its attached sources and sinks and makes adjustments to the state machine

   970  *  This avoid the possibility of NULL buffers (not yet returned by an asychronous sink or source) being passed around the MMF

   971  */

   972 

   973 void CMMFDataPath::InitializeSinkL()

   974 	{

   975 #ifdef _DP_DEBUG

   976 	RDebug::Print(_L("DP::InitializeSinkL  iSourceBuffer=0x%x ref=%d   iSinkBuffer=0x%x ref=%d (this 0x%x)\n"),iSourceBuffer,iSrcBufRef,iSinkBuffer,iSnkBufRef, this);

   977 #endif

   978 

   979 	//state only used if we are passing data

   980 	__ASSERT_DEBUG((iState == EPlaying || iState == EConverting || iState == ERecording), Panic(EMMFDataPathPanicBadState,__LINE__));

   981 

   982 	iObtainingAsyncSinkBuffer = EFalse;

   983 

   984 	if (iBuffersToUse & ENeedSinkBuffer)

   985 		{

   986 		//Buffers are initially created in the Prime method. But following a pause, we must re-create 

   987 		//any referenced buffers, so try direct creation.

   988 		//NB: this does mean we are trying this twice, Prime and here

   989 		if (!iSinkBuffer) //we may already have a buffer from a previous initialization

   990 			{

   991 			TRAPD(err, iSinkBuffer = iDataSink->CreateSinkBufferL(iMediaId, iSnkBufRef));

   992 			if(err != KErrNone && err != KErrNotSupported)

   993 				User::Leave(err);

   994 			}

   995 

   996 

   997 		//If buffer has not been supplied via CreateSinkBufferL, 

   998 		//must use asynchronous buffer creation		

   999 		if (!iSinkBuffer) 

  1000 			{

  1001 			iObtainingAsyncSinkBuffer = ETrue;

  1002 			ChangeDataPathTransferState(EWaitSink);  // wait for BufferEmptied callback from sink

  1003 			iDataSink->EmptyBufferL(iSinkBuffer, this, iMediaId);

  1004 			}

  1005 		else

  1006 			{

  1007 			//we have a sink buffer from CreateSinkBufferL

  1008 			iSinkBuffer->SetStatus(EAvailable);

  1009 			

  1010 			if (iBuffersToUse & ENeedSourceBuffer)

  1011 				{//need a source buffer, go get it

  1012 				ChangeDataPathTransferState(EInitializeSource);

  1013 				}

  1014 			else

  1015 				{//only need one buffer, use sink

  1016 				iSourceBuffer = iSinkBuffer;

  1017 				iSrcBufRef = ETrue; //the src buffer is not to be deleted

  1018 

  1019 				ChangeDataPathTransferState(ENeedSourceData); //got all buffers, start getting data

  1020 				}

  1021 			}

  1022 		}

  1023 	else

  1024 		{//don't need a sink buffer, but we need a source one

  1025 		ChangeDataPathTransferState(EInitializeSource);

  1026 		}

  1027 

  1028 #ifdef _DP_DEBUG

  1029 	RDebug::Print(_L("DP::InitializeSinkL - DONE  iSourceBuffer=0x%x ref=%d   iSinkBuffer=0x%x ref=%d (this 0x%x)\n"),iSourceBuffer,iSrcBufRef,iSinkBuffer,iSnkBufRef, this);

  1030 #endif	

  1031 	}

  1032 

  1033 

  1034 /*

  1035  *  InitializeSourceL

  1036  *

  1037  *	Function to initialize iDataSource before it can start sending data

  1038  *	This is a one time prime. This will synchronize DataPath's data driving

  1039  *	mechanism with HwDevice implementation.

  1040  *

  1041  *  This initialisation method detects its attached sources and sinks and makes adjustments to the state machine

  1042  *  This avoid the possibility of NULL buffers (not yet returned by an asychronous sink or source) being passed around the MMF

  1043  */

  1044 

  1045 void CMMFDataPath::InitializeSourceL()

  1046 	{

  1047 #ifdef _DP_DEBUG

  1048 	RDebug::Print(_L("DP::InitializeSourceL -  iSourceBuffer=0x%x ref=%d   iSinkBuffer=0x%x ref=%d (this 0x%x)\n"),iSourceBuffer,iSrcBufRef,iSinkBuffer,iSnkBufRef, this);

  1049 #endif	

  1050 

  1051 	//state only used if we are passing data

  1052 	__ASSERT_DEBUG((iState == EPlaying || iState == EConverting || iState == ERecording), Panic(EMMFDataPathPanicBadState,__LINE__));

  1053 

  1054 	iObtainingAsyncSourceBuffer = EFalse;

  1055 

  1056 	if (iBuffersToUse & ENeedSourceBuffer)

  1057 		{

  1058 		//Buffers are initially created in the Prime method. But following a pause, we must re-create 

  1059 		//any referenced buffers, so try direct creation.

  1060 		//NB: this does mean we are trying this twice, Prime and here.

  1061 		if (!iSourceBuffer) //we may already have a buffer from a previous initialization

  1062 			{

  1063 			TRAPD(err, iSourceBuffer = iDataSource->CreateSourceBufferL(iMediaId,*iSinkBuffer, iSrcBufRef));

  1064 			if(err != KErrNone && err != KErrNotSupported)

  1065 				User::Leave(err);

  1066 			}

  1067 

  1068 

  1069 		//If buffer has not been supplied via CreateSourceBufferL

  1070 		//must use asynchronous buffer creation

  1071 		if (!iSourceBuffer) 

  1072 			{

  1073 			iObtainingAsyncSourceBuffer = ETrue;

  1074 			ChangeDataPathTransferState(ENeedSourceData);			

  1075 			}

  1076 		else

  1077 			{//we have a source buffer from CreateSourceBufferL

  1078 			iSourceBuffer->SetStatus(EAvailable);

  1079 

  1080 			if (!(iBuffersToUse & ENeedSinkBuffer))

  1081 				{//only need one buffer, use sink

  1082 				iSinkBuffer = iSourceBuffer;

  1083 				iSnkBufRef = ETrue;

  1084 				}

  1085 

  1086 			ChangeDataPathTransferState(ENeedSourceData); //got all buffers, start getting data			

  1087 			}

  1088 		}

  1089 	else

  1090 		{//don't need a source buffer, use sinks

  1091 		if(iSinkBuffer)

  1092 			{

  1093 			iSourceBuffer = iSinkBuffer;

  1094 			iSrcBufRef = iSnkBufRef;

  1095 			SetBuffersAvailable();

  1096 			}

  1097 #ifdef _DP_DEBUG

  1098 		else

  1099 			Panic(EMMFDataPathPanicProgrammingError,__LINE__);

  1100 #endif

  1101 		ChangeDataPathTransferState(ENeedSourceData); //got all buffers, start getting data

  1102 

  1103 		

  1104 #ifdef _DP_DEBUG

  1105 	RDebug::Print(_L("DP::InitializeSourceL -  iSourceBuffer=0x%x ref=%d   iSinkBuffer=0x%x ref=%d (this 0x%x)\n"),iSourceBuffer,iSrcBufRef,iSinkBuffer,iSnkBufRef, this);

  1106 #endif			

  1107 		}

  1108 	}

  1109 

  1110 /*

  1111  *  EmptySinkBufferL

  1112  * 

  1113  *	Function to pass a full databuffer to the iDataSink

  1114  */

  1115 void CMMFDataPath::EmptySinkBufferL()

  1116 	{

  1117 #ifdef _DP_DEBUG

  1118 	RDebug::Print(_L("DP::EmptySinkBufferL pass data to sink  tick-%d   (this 0x%x)\n"),User::TickCount(),this);

  1119 	if(iSinkBuffer)

  1120 		RDebug::Print(_L("iSinkBuffer %d contains %d bytes  eof = %d line %d   (this 0x%x)\n"),iSinkBuffer->FrameNumber(), iSinkBuffer->BufferSize(),iSinkBuffer->LastBuffer(),__LINE__,this);		

  1121 #endif

  1122 

  1123 	//Before emptying the sink buffer we need to check it has data to empty - this

  1124 	//may not be the case if there is no more data ie iNoMoreSourceData is true.

  1125 	//In this case we need to check to see if there is any data left in the sink 

  1126 	//buffer, ie the sink buffer is either full or being filled. If there is not any

  1127 	//data in the sink buffer, ie it is not in the state of EBeingFilled or EFull

  1128 	//then there is nothing to empty so the datapath state is set to EEndOfData and

  1129 	//we return from the procedure.

  1130 

  1131 	//state only used if we are passing data

  1132 	__ASSERT_DEBUG((iState == EPlaying || iState == EConverting || iState == ERecording || (iState == EPrimed && iPauseCalled)), Panic(EMMFDataPathPanicBadState,__LINE__)); 

  1133 	__ASSERT_DEBUG(iSinkBuffer &&

  1134 				   ((iSinkBuffer->Status()==EBeingFilled) || (iSinkBuffer->Status()==EFull)),