1 /*

     2 * Copyright (c) 2005 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:  S60 Audio Streaming Data Source Plugin implementation

    15 *

    16 */

    17 

    18 #include <mmf/server/mmfdatabuffer.h>

    19 #include "S60StreamingSourceCustomCommands.h"

    20 #include "S60StreamingSource.h"

    21 #include "DataBufferQueueItem.h"

    22 #include "ReadRequest.h"

    23 

    24 

    25 

    26 EXPORT_C CS60StreamingSource* CS60StreamingSource::NewL(

    27 	TUid aType )

    28 	{

    29 #ifdef _DEBUG

    30     RDebug::Print(_L("CS60StreamingSource::NewL"));

    31 #endif

    32 

    33 	CS60StreamingSource* self = CS60StreamingSource::NewLC(aType);

    34 	CleanupStack::Pop(self);

    35 	return self;

    36 	}

    37 

    38 EXPORT_C CS60StreamingSource* CS60StreamingSource::NewLC(

    39 	TUid aType )

    40 	{

    41 	CS60StreamingSource* self = new (ELeave) CS60StreamingSource(aType);

    42 	CleanupStack::PushL(self);

    43 	self->ConstructL();

    44 	return self;

    45 	}

    46 

    47 

    48 CS60StreamingSource::CS60StreamingSource(

    49 	TUid aType)

    50 	: MDataSource(aType),

    51 	  iHandlingRequest(EFalse),

    52 	  iCurrentRequest(NULL)

    53 	{

    54 	}

    55 

    56 CS60StreamingSource::~CS60StreamingSource(void)

    57 	{

    58 #ifdef _DEBUG

    59     RDebug::Print(_L("CS60StreamingSource::~CS60StreamingSource"));

    60 #endif

    61 

    62    if ( iDataBufferQueue )

    63         {

    64         CDataBufferQueueItem* item;

    65         while ( !iDataBufferQueue->IsEmpty() )

    66             {

    67             item = iDataBufferQueue->First();

    68             iDataBufferQueue->Remove(*item);

    69             item->SetMessageStatus(KErrNone);

    70             delete item;

    71             }

    72         delete iDataBufferQueue;

    73         }

    74 

    75    if ( iReadRequestQueue )

    76         {

    77         CReadRequest* item;

    78         while ( !iReadRequestQueue->IsEmpty() )

    79             {

    80             item = iReadRequestQueue->First();

    81             iReadRequestQueue->Remove(*item);

    82             delete item;

    83             }

    84         delete iReadRequestQueue;

    85         }

    86 

    87     delete iCurrentRequest;

    88 	}

    89 

    90 void CS60StreamingSource::ConstructL (void)

    91 	{

    92 	iDataBufferQueue = new(ELeave) TSglQue<CDataBufferQueueItem>(_FOFF(CDataBufferQueueItem, iLink));

    93 	iReadRequestQueue = new(ELeave) TSglQue<CReadRequest>(_FOFF(CReadRequest, iLink));

    94 	}

    95 

    96 void CS60StreamingSource::ConstructSourceL(

    97 	const TDesC8& /*aInitData*/ )

    98 	{

    99 	}

   100 

   101 TUid CS60StreamingSource::DataSourceType() const

   102 	{

   103 	const TUid KMmfStreamingSource = {KMmfS60StreamingSourceUid};

   104 	return KMmfStreamingSource;

   105 	}

   106 

   107 TFourCC CS60StreamingSource::SourceDataTypeCode(

   108 	TMediaId /*aMediaId*/ )

   109 	{

   110 	return KMMFFourCCCodePCM16; // dummy

   111 	}

   112 

   113 TInt CS60StreamingSource::SetSourceDataTypeCode(

   114 	TFourCC /*aSourceFourCC*/,

   115 	TMediaId /*aMediaId*/ )

   116 	{

   117 	return KErrNotSupported;

   118 	}

   119 

   120 void CS60StreamingSource::FillBufferL(

   121 	CMMFBuffer* aBuffer,

   122 	MDataSink* aConsumer,

   123 	TMediaId /*aMediaId*/ )

   124 	{

   125 

   126 	CMMFDataBuffer* dest = STATIC_CAST( CMMFDataBuffer*, aBuffer );

   127 	TDes8& destBufferDes = dest->Data();

   128 	destBufferDes.Zero();

   129 

   130 	CReadRequest* request = CReadRequest::NewL(*this, aBuffer, aConsumer);

   131 	iReadRequestQueue->AddLast(*request);

   132 

   133 	aBuffer->SetPosition(0);

   134 

   135 	if( !iHandlingRequest && !iReadRequestQueue->IsEmpty())

   136 		{

   137 		iHandlingRequest = ETrue;

   138 		iCurrentRequest = iReadRequestQueue->First();

   139 		iReadRequestQueue->Remove(*iCurrentRequest);

   140 		iCurrentRequest->HandleRequest();

   141 		}

   142 

   143 	}

   144 

   145 

   146 void CS60StreamingSource::HandleFillBuffer(

   147 	CMMFBuffer* aBuffer,

   148 	MDataSink* aConsumer )

   149 	{

   150 

   151 	if (!iDataBufferQueue->IsEmpty())

   152 		{

   153 		iSrcBuffer = iDataBufferQueue->First();

   154 

   155 		CMMFDataBuffer* src = iSrcBuffer->GetDataBuffer();

   156 		CMMFDataBuffer* dest = STATIC_CAST( CMMFDataBuffer*, aBuffer );

   157 

   158 		TDes8& srcBufferDes = src->Data();

   159 		TDes8& destBufferDes = dest->Data();

   160 

   161 		TUint srcLength = srcBufferDes.MaxLength() - src->Position();

   162 		TUint destLength = destBufferDes.MaxLength() - dest->Position();

   163 

   164 		RDebug::Print(_L("Src Length [%d] Dest Length [%d] [%x]"),srcLength,destLength,aBuffer);

   165 		RDebug::Print(_L("Src Position [%d] Dest Position [%d]"),src->Position(),dest->Position());

   166 

   167 //      if the source data length is bigger than the destination buffer size. Enough for data to be copied

   168 		if ( srcLength > destLength)

   169 			{

   170 			destBufferDes.Append(srcBufferDes.Ptr() + src->Position(), destLength);

   171 			RDebug::Print(_L("dest->Data().Length() = %d"),dest->Data().Length());

   172 			src->SetPosition(src->Position() + destLength);

   173 			aConsumer->BufferFilledL(aBuffer);

   174 			}

   175 		else

   176 			{

   177 			// At this point source data length is equal or less than destination buffer size.

   178 			// Copy all data to destination. If src is less then save the dest position.

   179 			RDebug::Print(_L("Before dest->Data().Length() = %d"),dest->Data().Length());

   180 

   181 			destBufferDes.Append(srcBufferDes.Ptr()+ src->Position(), srcLength);

   182 			RDebug::Print(_L("Before Dest Position [%d]"),dest->Position());

   183 			RDebug::Print(_L("After dest->Data().Length() = %d"),dest->Data().Length());

   184 

   185 			dest->SetPosition(dest->Position() + srcLength);

   186 

   187 			if ( src->LastBuffer() )

   188 				{

   189 				dest->SetLastBuffer(ETrue);

   190 				// Dequeue and Delete the source buffer

   191 				iDataBufferQueue->Remove(*iSrcBuffer);

   192 				iSrcBuffer->SetMessageStatus(KErrNone);

   193 				delete iSrcBuffer;

   194 				iSrcBuffer = NULL;

   195 				aConsumer->BufferFilledL(aBuffer);

   196 

   197 				// Since we already have the last buffer we will

   198 				// delete all the outstanding read requests

   199 				while(!iReadRequestQueue->IsEmpty())

   200 					{

   201 						CReadRequest* outStandingReq = iReadRequestQueue->First();

   202 						iReadRequestQueue->Remove(*outStandingReq);

   203 						delete outStandingReq;

   204 					}

   205 

   206 				}

   207 			else

   208 				{

   209 				iDataBufferQueue->Remove(*iSrcBuffer);

   210 				iSrcBuffer->SetMessageStatus(KErrNone);

   211 				delete iSrcBuffer;

   212 				iSrcBuffer = NULL;

   213 

   214 				if(dest->Position() == dest->Data().MaxLength())

   215 					aConsumer->BufferFilledL(aBuffer);

   216 				else

   217 					{

   218 						CReadRequest* request = CReadRequest::NewL(*this, aBuffer, aConsumer);

   219 						iReadRequestQueue->AddFirst(*request);

   220 					}

   221 				}

   222 			}

   223 		}

   224 	else

   225 		{

   226 		RDebug::Print(_L("HandleFillBuffer but iDataBufferQueue->IsEmpty [%d] [%x]"),iDataBufferQueue->IsEmpty(),aBuffer);

   227 		CReadRequest* request = CReadRequest::NewL(*this, aBuffer, aConsumer);

   228 		iReadRequestQueue->AddFirst(*request);

   229 		}

   230 

   231 	delete iCurrentRequest;

   232 	iCurrentRequest = NULL;

   233 	iHandlingRequest = EFalse;

   234 

   235 	if( !iHandlingRequest && !iReadRequestQueue->IsEmpty() && !iDataBufferQueue->IsEmpty())

   236 		{

   237 		iHandlingRequest = ETrue;

   238 		iCurrentRequest = iReadRequestQueue->First();

   239 		iReadRequestQueue->Remove(*iCurrentRequest);

   240 		iCurrentRequest->HandleRequest();

   241 		}

   242 	}

   243 

   244 void CS60StreamingSource::BufferEmptiedL(

   245 	CMMFBuffer* /*aBuffer*/ )

   246 	{

   247 	}//called by MDataSink to pass back emptied buffer to the source

   248 

   249 TBool CS60StreamingSource::CanCreateSourceBuffer()

   250 	{

   251 	return EFalse;

   252 	}

   253 

   254 CMMFBuffer* CS60StreamingSource::CreateSourceBufferL(

   255 	TMediaId /*aMediaId*/,

   256 	TBool &/*aReference*/ )

   257 	{

   258 	CMMFBuffer* newBuffer = 0; //dummy

   259 	return newBuffer;

   260 	}

   261 

   262 CMMFBuffer* CS60StreamingSource::CreateSourceBufferL(

   263 	TMediaId aMediaId,

   264 	CMMFBuffer& /*aSinkBuffer*/,

   265 	TBool &aReference)

   266 	{

   267 	return CreateSourceBufferL(aMediaId, aReference);

   268 	}

   269 /*

   270 void CS60StreamingSource::SourcePrimeL()

   271 	{

   272 	}

   273 */

   274 void CS60StreamingSource::SourceStopL()

   275 	{

   276     if ( iDataBufferQueue )

   277         {

   278         CDataBufferQueueItem* item;

   279         while ( !iDataBufferQueue->IsEmpty() )

   280             {

   281             item = iDataBufferQueue->First();

   282             iDataBufferQueue->Remove(*item);

   283             item->SetMessageStatus(KErrCancel);

   284             delete item;

   285             }

   286         }

   287    if ( iReadRequestQueue )

   288         {

   289         CReadRequest* item;

   290         while ( !iReadRequestQueue->IsEmpty() )

   291             {

   292             item = iReadRequestQueue->First();

   293             iReadRequestQueue->Remove(*item);

   294             delete item;

   295             }

   296         }

   297 

   298 	}

   299 

   300 

   301 void CS60StreamingSource::SourceCustomCommand(TMMFMessage& aMessage)

   302 	{

   303 #if _DEBUG

   304 	RDebug::Print(_L("CS60StreamingSource::SourceCustomCommand\n"));

   305 #endif

   306 

   307 

   308 

   309 	switch(aMessage.Function())

   310 		{

   311 		case ECancel:

   312 			  	break;

   313 		case EProcessBuffer:

   314 			{

   315 			TPckgBuf<TInt> lastBufferFlagPkg;

   316 			User::LeaveIfError(aMessage.ReadData2FromClient(lastBufferFlagPkg));

   317 			TInt lastBuffer = lastBufferFlagPkg();

   318 			CMMFDataBuffer* buffer = CMMFDataBuffer::NewL(aMessage.SizeOfData1FromClient());

   319 			User::LeaveIfError(aMessage.ReadData1FromClient(buffer->Data()));

   320 

   321 			if ( lastBuffer )

   322 				buffer->SetLastBuffer(ETrue);

   323 

   324 			TInt length = buffer->Data().Length();

   325 			TInt maxLength = buffer->Data().MaxLength();

   326 			TDes8& data = buffer->Data();

   327 

   328 			CDataBufferQueueItem* item = NULL;

   329 			TRAPD(err, item = CDataBufferQueueItem::NewL(buffer, aMessage));

   330 			if (err != KErrNone)

   331 				aMessage.Complete(err);

   332 			else

   333 				iDataBufferQueue->AddLast(*item);

   334 

   335 			if( !iHandlingRequest && !iReadRequestQueue->IsEmpty())

   336 				{

   337 				iHandlingRequest = ETrue;

   338 				iCurrentRequest = iReadRequestQueue->First();

   339 				iReadRequestQueue->Remove(*iCurrentRequest);

   340 				iCurrentRequest->HandleRequest();

   341 				}

   342 

   343 			  break;

   344 			}

   345 		 default:

   346 			  break;

   347 		  }

   348 	}

   349 

   350 EXPORT_C TBool CS60StreamingSource::IsSeekingSupported()

   351 	{

   352 		return EFalse;

   353 	}

   354 

   355 

   356 EXPORT_C TBool CS60StreamingSource::IsRandomSeekingSupported()

   357 	{

   358 		return EFalse;

   359 	}

   360 

   361 // __________________________________________________________________________

   362 // Exported proxy for instantiation method resolution

   363 // Define the interface UIDs

   364 

   365 

   366 const TImplementationProxy ImplementationTable[] =

   367 	{

   368 		IMPLEMENTATION_PROXY_ENTRY(KMmfS60StreamingSourceUid, CS60StreamingSource::NewL)

   369 	};

   370 

   371 EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

   372 	{

   373 	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

   374 

   375 	return ImplementationTable;

   376 	}

   377 

   378 

   379