mmfenh/enhancedaudioplayerutility/AudioStreaming/AudioStreamingSource/src/S60StreamingSource.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmfenh/enhancedaudioplayerutility/AudioStreaming/AudioStreamingSource/src/S60StreamingSource.cpp Tue Feb 02 01:08:46 2010 +0200
@@ -0,0 +1,379 @@
+/*
+* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: S60 Audio Streaming Data Source Plugin implementation
+*
+*/
+
+#include <mmf/server/mmfdatabuffer.h>
+#include "S60StreamingSourceCustomCommands.h"
+#include "S60StreamingSource.h"
+#include "DataBufferQueueItem.h"
+#include "ReadRequest.h"
+
+
+
+EXPORT_C CS60StreamingSource* CS60StreamingSource::NewL(
+ TUid aType )
+ {
+#ifdef _DEBUG
+ RDebug::Print(_L("CS60StreamingSource::NewL"));
+#endif
+
+ CS60StreamingSource* self = CS60StreamingSource::NewLC(aType);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+EXPORT_C CS60StreamingSource* CS60StreamingSource::NewLC(
+ TUid aType )
+ {
+ CS60StreamingSource* self = new (ELeave) CS60StreamingSource(aType);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ return self;
+ }
+
+
+CS60StreamingSource::CS60StreamingSource(
+ TUid aType)
+ : MDataSource(aType),
+ iHandlingRequest(EFalse),
+ iCurrentRequest(NULL)
+ {
+ }
+
+CS60StreamingSource::~CS60StreamingSource(void)
+ {
+#ifdef _DEBUG
+ RDebug::Print(_L("CS60StreamingSource::~CS60StreamingSource"));
+#endif
+
+ if ( iDataBufferQueue )
+ {
+ CDataBufferQueueItem* item;
+ while ( !iDataBufferQueue->IsEmpty() )
+ {
+ item = iDataBufferQueue->First();
+ iDataBufferQueue->Remove(*item);
+ item->SetMessageStatus(KErrNone);
+ delete item;
+ }
+ delete iDataBufferQueue;
+ }
+
+ if ( iReadRequestQueue )
+ {
+ CReadRequest* item;
+ while ( !iReadRequestQueue->IsEmpty() )
+ {
+ item = iReadRequestQueue->First();
+ iReadRequestQueue->Remove(*item);
+ delete item;
+ }
+ delete iReadRequestQueue;
+ }
+
+ delete iCurrentRequest;
+ }
+
+void CS60StreamingSource::ConstructL (void)
+ {
+ iDataBufferQueue = new(ELeave) TSglQue<CDataBufferQueueItem>(_FOFF(CDataBufferQueueItem, iLink));
+ iReadRequestQueue = new(ELeave) TSglQue<CReadRequest>(_FOFF(CReadRequest, iLink));
+ }
+
+void CS60StreamingSource::ConstructSourceL(
+ const TDesC8& /*aInitData*/ )
+ {
+ }
+
+TUid CS60StreamingSource::DataSourceType() const
+ {
+ const TUid KMmfStreamingSource = {KMmfS60StreamingSourceUid};
+ return KMmfStreamingSource;
+ }
+
+TFourCC CS60StreamingSource::SourceDataTypeCode(
+ TMediaId /*aMediaId*/ )
+ {
+ return KMMFFourCCCodePCM16; // dummy
+ }
+
+TInt CS60StreamingSource::SetSourceDataTypeCode(
+ TFourCC /*aSourceFourCC*/,
+ TMediaId /*aMediaId*/ )
+ {
+ return KErrNotSupported;
+ }
+
+void CS60StreamingSource::FillBufferL(
+ CMMFBuffer* aBuffer,
+ MDataSink* aConsumer,
+ TMediaId /*aMediaId*/ )
+ {
+
+ CMMFDataBuffer* dest = STATIC_CAST( CMMFDataBuffer*, aBuffer );
+ TDes8& destBufferDes = dest->Data();
+ destBufferDes.Zero();
+
+ CReadRequest* request = CReadRequest::NewL(*this, aBuffer, aConsumer);
+ iReadRequestQueue->AddLast(*request);
+
+ aBuffer->SetPosition(0);
+
+ if( !iHandlingRequest && !iReadRequestQueue->IsEmpty())
+ {
+ iHandlingRequest = ETrue;
+ iCurrentRequest = iReadRequestQueue->First();
+ iReadRequestQueue->Remove(*iCurrentRequest);
+ iCurrentRequest->HandleRequest();
+ }
+
+ }
+
+
+void CS60StreamingSource::HandleFillBuffer(
+ CMMFBuffer* aBuffer,
+ MDataSink* aConsumer )
+ {
+
+ if (!iDataBufferQueue->IsEmpty())
+ {
+ iSrcBuffer = iDataBufferQueue->First();
+
+ CMMFDataBuffer* src = iSrcBuffer->GetDataBuffer();
+ CMMFDataBuffer* dest = STATIC_CAST( CMMFDataBuffer*, aBuffer );
+
+ TDes8& srcBufferDes = src->Data();
+ TDes8& destBufferDes = dest->Data();
+
+ TUint srcLength = srcBufferDes.MaxLength() - src->Position();
+ TUint destLength = destBufferDes.MaxLength() - dest->Position();
+
+ RDebug::Print(_L("Src Length [%d] Dest Length [%d] [%x]"),srcLength,destLength,aBuffer);
+ RDebug::Print(_L("Src Position [%d] Dest Position [%d]"),src->Position(),dest->Position());
+
+// if the source data length is bigger than the destination buffer size. Enough for data to be copied
+ if ( srcLength > destLength)
+ {
+ destBufferDes.Append(srcBufferDes.Ptr() + src->Position(), destLength);
+ RDebug::Print(_L("dest->Data().Length() = %d"),dest->Data().Length());
+ src->SetPosition(src->Position() + destLength);
+ aConsumer->BufferFilledL(aBuffer);
+ }
+ else
+ {
+ // At this point source data length is equal or less than destination buffer size.
+ // Copy all data to destination. If src is less then save the dest position.
+ RDebug::Print(_L("Before dest->Data().Length() = %d"),dest->Data().Length());
+
+ destBufferDes.Append(srcBufferDes.Ptr()+ src->Position(), srcLength);
+ RDebug::Print(_L("Before Dest Position [%d]"),dest->Position());
+ RDebug::Print(_L("After dest->Data().Length() = %d"),dest->Data().Length());
+
+ dest->SetPosition(dest->Position() + srcLength);
+
+ if ( src->LastBuffer() )
+ {
+ dest->SetLastBuffer(ETrue);
+ // Dequeue and Delete the source buffer
+ iDataBufferQueue->Remove(*iSrcBuffer);
+ iSrcBuffer->SetMessageStatus(KErrNone);
+ delete iSrcBuffer;
+ iSrcBuffer = NULL;
+ aConsumer->BufferFilledL(aBuffer);
+
+ // Since we already have the last buffer we will
+ // delete all the outstanding read requests
+ while(!iReadRequestQueue->IsEmpty())
+ {
+ CReadRequest* outStandingReq = iReadRequestQueue->First();
+ iReadRequestQueue->Remove(*outStandingReq);
+ delete outStandingReq;
+ }
+
+ }
+ else
+ {
+ iDataBufferQueue->Remove(*iSrcBuffer);
+ iSrcBuffer->SetMessageStatus(KErrNone);
+ delete iSrcBuffer;
+ iSrcBuffer = NULL;
+
+ if(dest->Position() == dest->Data().MaxLength())
+ aConsumer->BufferFilledL(aBuffer);
+ else
+ {
+ CReadRequest* request = CReadRequest::NewL(*this, aBuffer, aConsumer);
+ iReadRequestQueue->AddFirst(*request);
+ }
+ }
+ }
+ }
+ else
+ {
+ RDebug::Print(_L("HandleFillBuffer but iDataBufferQueue->IsEmpty [%d] [%x]"),iDataBufferQueue->IsEmpty(),aBuffer);
+ CReadRequest* request = CReadRequest::NewL(*this, aBuffer, aConsumer);
+ iReadRequestQueue->AddFirst(*request);
+ }
+
+ delete iCurrentRequest;
+ iCurrentRequest = NULL;
+ iHandlingRequest = EFalse;
+
+ if( !iHandlingRequest && !iReadRequestQueue->IsEmpty() && !iDataBufferQueue->IsEmpty())
+ {
+ iHandlingRequest = ETrue;
+ iCurrentRequest = iReadRequestQueue->First();
+ iReadRequestQueue->Remove(*iCurrentRequest);
+ iCurrentRequest->HandleRequest();
+ }
+ }
+
+void CS60StreamingSource::BufferEmptiedL(
+ CMMFBuffer* /*aBuffer*/ )
+ {
+ }//called by MDataSink to pass back emptied buffer to the source
+
+TBool CS60StreamingSource::CanCreateSourceBuffer()
+ {
+ return EFalse;
+ }
+
+CMMFBuffer* CS60StreamingSource::CreateSourceBufferL(
+ TMediaId /*aMediaId*/,
+ TBool &/*aReference*/ )
+ {
+ CMMFBuffer* newBuffer = 0; //dummy
+ return newBuffer;
+ }
+
+CMMFBuffer* CS60StreamingSource::CreateSourceBufferL(
+ TMediaId aMediaId,
+ CMMFBuffer& /*aSinkBuffer*/,
+ TBool &aReference)
+ {
+ return CreateSourceBufferL(aMediaId, aReference);
+ }
+/*
+void CS60StreamingSource::SourcePrimeL()
+ {
+ }
+*/
+void CS60StreamingSource::SourceStopL()
+ {
+ if ( iDataBufferQueue )
+ {
+ CDataBufferQueueItem* item;
+ while ( !iDataBufferQueue->IsEmpty() )
+ {
+ item = iDataBufferQueue->First();
+ iDataBufferQueue->Remove(*item);
+ item->SetMessageStatus(KErrCancel);
+ delete item;
+ }
+ }
+ if ( iReadRequestQueue )
+ {
+ CReadRequest* item;
+ while ( !iReadRequestQueue->IsEmpty() )
+ {
+ item = iReadRequestQueue->First();
+ iReadRequestQueue->Remove(*item);
+ delete item;
+ }
+ }
+
+ }
+
+
+void CS60StreamingSource::SourceCustomCommand(TMMFMessage& aMessage)
+ {
+#if _DEBUG
+ RDebug::Print(_L("CS60StreamingSource::SourceCustomCommand\n"));
+#endif
+
+
+
+ switch(aMessage.Function())
+ {
+ case ECancel:
+ break;
+ case EProcessBuffer:
+ {
+ TPckgBuf<TInt> lastBufferFlagPkg;
+ User::LeaveIfError(aMessage.ReadData2FromClient(lastBufferFlagPkg));
+ TInt lastBuffer = lastBufferFlagPkg();
+ CMMFDataBuffer* buffer = CMMFDataBuffer::NewL(aMessage.SizeOfData1FromClient());
+ User::LeaveIfError(aMessage.ReadData1FromClient(buffer->Data()));
+
+ if ( lastBuffer )
+ buffer->SetLastBuffer(ETrue);
+
+ TInt length = buffer->Data().Length();
+ TInt maxLength = buffer->Data().MaxLength();
+ TDes8& data = buffer->Data();
+
+ CDataBufferQueueItem* item = NULL;
+ TRAPD(err, item = CDataBufferQueueItem::NewL(buffer, aMessage));
+ if (err != KErrNone)
+ aMessage.Complete(err);
+ else
+ iDataBufferQueue->AddLast(*item);
+
+ if( !iHandlingRequest && !iReadRequestQueue->IsEmpty())
+ {
+ iHandlingRequest = ETrue;
+ iCurrentRequest = iReadRequestQueue->First();
+ iReadRequestQueue->Remove(*iCurrentRequest);
+ iCurrentRequest->HandleRequest();
+ }
+
+ break;
+ }
+ default:
+ break;
+ }
+ }
+
+EXPORT_C TBool CS60StreamingSource::IsSeekingSupported()
+ {
+ return EFalse;
+ }
+
+
+EXPORT_C TBool CS60StreamingSource::IsRandomSeekingSupported()
+ {
+ return EFalse;
+ }
+
+// __________________________________________________________________________
+// Exported proxy for instantiation method resolution
+// Define the interface UIDs
+
+
+const TImplementationProxy ImplementationTable[] =
+ {
+ IMPLEMENTATION_PROXY_ENTRY(KMmfS60StreamingSourceUid, CS60StreamingSource::NewL)
+ };
+
+EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
+ {
+ aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
+
+ return ImplementationTable;
+ }
+
+
+