TB9.2 Example Applications: examples/Multimedia/MmfExSinkSource/Mmfdes.cpp Source File

00001 // mmfdes.cpp
+00002 //
+00003 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
+00004 // All rights reserved.
+00005 // This component and the accompanying materials are made available
+00006 // under the terms of "Eclipse Public License v1.0"
+00007 // which accompanies this distribution, and is available
+00008 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
+00009 //
+00010 // Initial Contributors:
+00011 // Nokia Corporation - initial contribution.
+00012 //
+00013 // Contributors:
+00014 //
+00015 // Description:
+00016 //
+00017 
+00018 
+00019 
+00020 #include <f32file.h>
+00021 #include <e32std.h>
+00022 #include <mmfdatabuffer.h>
+00023 
+00024 #include "mmfexdes.h"
+00025 #include "MmfExSinkSourceUIDs.hrh"
+00026 
+00027 // Panic function
+00028 void Panic(TMMFExDescriptorPanicCode aPanicCode)
+00029         {
+00030         _LIT(KMMFExDescriptorPanicCategory, "MMFExDescriptor");
+00031         User::Panic(KMMFExDescriptorPanicCategory, aPanicCode);
+00032         }
+00033 
+00034 //
+00035 // CMMFExDescriptor
+00036 //
+00037 
+00038 // Plugin implementation UIDs
+00039 const TUid KDescriptorSourceUIDObject   = {KDescriptorSourceUID};
+00040 const TUid KDescriptorSinkUIDObject     = {KDescriptorSinkUID};
+00041 
+00042 // Constructor
+00043 CMMFExDescriptor::CMMFExDescriptor( ) : CMMFClip( TUid(KDescriptorSourceUIDObject), TUid(KDescriptorSinkUIDObject )) 
+00044         {
+00045         iOffset = 0 ;
+00046         }
+00047 
+00048 // Destructor
+00049 CMMFExDescriptor::~CMMFExDescriptor()
+00050         {
+00051         iDesThread.Close() ;
+00052         }
+00053 
+00054 // Factory function for source plug-in
+00055 MDataSource* CMMFExDescriptor::NewSourceL( )
+00056         {
+00057         CMMFExDescriptor* self = new (ELeave) CMMFExDescriptor( ) ;
+00058         return STATIC_CAST( MDataSource*, self ) ;
+00059         }
+00060         
+00061 // Factory function for sink plug-in
+00062 MDataSink* CMMFExDescriptor::NewSinkL( )
+00063         {
+00064         CMMFExDescriptor* self = new (ELeave) CMMFExDescriptor( ) ;
+00065         return STATIC_CAST( MDataSink*, self ) ;
+00066         }
+00067 
+00068 // MDataSource factory
+00069 // aInitData is a packaged TMMFExDescriptorParams
+00070 void CMMFExDescriptor::ConstructSourceL( const TDesC8& aInitData )
+00071         {
+00072         ConstructL( aInitData ) ;
+00073         }
+00074 
+00075 // MDataSink factory
+00076 // aInitData is a packaged TMMFExDescriptorParams
+00077 void CMMFExDescriptor::ConstructSinkL( const TDesC8& aInitData )
+00078         {
+00079         ConstructL( aInitData ) ;
+00080         }
+00081 
+00082 // Construction helper
+00083 // aInitData is a packaged TMMFExDescriptorParams
+00084 void CMMFExDescriptor::ConstructL( const TDesC8& aInitData ) 
+00085         {
+00086         // get descriptor to which to read/write, and the thread 
+00087         // to which it belongs
+00088         TMMFExDescriptorParams params;
+00089         TPckgC<TMMFExDescriptorParams> config(params);
+00090         config.Set(aInitData);
+00091         iDes = STATIC_CAST( TDes8*, config().iDes);
+00092         User::LeaveIfError( iDesThread.Open( config().iDesThreadId ) );
+00093         }
+00094 
+00095 
+00096 // From MDataSource
+00097 
+00098 TFourCC CMMFExDescriptor::SourceDataTypeCode(TMediaId /*aMediaId*/) 
+00099         {
+00100         return iSourceFourCC ;
+00101         }
+00102 
+00103 // Fills a buffer from the source descriptor
+00104 void CMMFExDescriptor::FillBufferL( CMMFBuffer* aBuffer, MDataSink* aConsumer, TMediaId /*aMediaId*/  ) 
+00105         {
+00106         // Current position in Descriptor is iOffset.
+00107 
+00108         // Read from iDes in iDesThread into Des in aBuffer.
+00109 
+00110         // Assume that the amount to be read is the size of the buffer descriptor
+00111         // Should check that there is sufficient data in the source buffer
+00112         // If there is not enough to fill the target then copy what there is
+00113 
+00114         // Use of a single iOffset will preclude use by more than one client (use ReadBufferL())
+00115         if ( aBuffer->Type() == KUidMmfDataBuffer  ) 
+00116                 {
+00117                 TDes8& bufferDes = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();
+00118                 TInt targetMaxLength = bufferDes.MaxLength();
+00119                 TInt sourceLength = iDes->Length();
+00120                 
+00121                 if ( ( sourceLength - iOffset - targetMaxLength ) > 0 )
+00122                         {
+00123                         bufferDes = iDes->Mid(iOffset,targetMaxLength);
+00124                         iOffset += targetMaxLength;
+00125                         }
+00126                 else
+00127                         bufferDes.SetLength(0);
+00128 
+00129                 // Check if the buffer is the last buffer and if so set the last buffer flag on the CMMFDataBuffer
+00130                 TInt requestSize = aBuffer->RequestSize();
+00131                 if (requestSize)
+00132                         { // The buffer has a request size  - so assume last buffer if length is less than the request size
+00133                         if (bufferDes.Length() < requestSize)   
+00134                                 aBuffer->SetLastBuffer(ETrue);
+00135                         }
+00136                 else
+00137                         { // There is no request size so assume last buffer if length is less than the max length
+00138                         if (bufferDes.Length() < bufferDes.MaxLength()) 
+00139                                 aBuffer->SetLastBuffer(ETrue);
+00140                         }
+00141 
+00142                 aConsumer->BufferFilledL( aBuffer ) ;
+00143                 }
+00144         else
+00145                 User::Leave(KErrNotSupported);
+00146         }
+00147 
+00148 // called by MDataSink to pass back emptied buffer to the source
+00149 void CMMFExDescriptor::BufferEmptiedL( CMMFBuffer* /*aBuffer*/ )
+00150         {
+00151         // not supported in this plug-in
+00152         __ASSERT_DEBUG(EFalse, Panic(EMMFDescriptorPanicBufferEmptiedLNotSupported));
+00153         }
+00154 
+00155 // tests if the plug-in can create a source buffer
+00156 TBool CMMFExDescriptor::CanCreateSourceBuffer()
+00157         {
+00158         // this can't: it needs a descriptor from another thread
+00159         return EFalse ;
+00160         }
+00161 
+00162 // creates a source buffer
+00163 CMMFBuffer* CMMFExDescriptor::CreateSourceBufferL(  TMediaId /*aMediaId*/, TBool& /*aReference*/ )
+00164         {
+00165         // is not supported in this plug-in
+00166         User::Leave(KErrNotSupported);
+00167         return NULL;
+00168         }
+00169 
+00170 
+00171 // from MDataSink
+00172 
+00173 // gets sink codec type
+00174 TFourCC CMMFExDescriptor::SinkDataTypeCode(TMediaId /*aMediaId*/) 
+00175         {
+00176         return iSinkFourCC ;
+00177         }
+00178 
+00179 // Empties supplied buffer into the sink descriptor 
+00180 void CMMFExDescriptor::EmptyBufferL( CMMFBuffer* aBuffer, MDataSource* aSupplier, TMediaId /*aMediaId*/ )
+00181         {
+00182         // Current position in Descriptor is iOffset.
+00183 
+00184         // Assume that the amount to be read is the size of the buffer descriptor
+00185         // Should check that there is sufficient data in the source buffer
+00186         // If there is not enough to fill the target then copy what there is
+00187 
+00188         // Use of a single iOffset will preclude use by more than one client (use ReadBufferL())
+00189 
+00190         if ( aBuffer->Type() == KUidMmfDataBuffer  ) 
+00191                 {
+00192                 TDes8& bufferDes = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();
+00193 
+00194                 TInt sourceLength = bufferDes.Length() ;        
+00195                 TInt targetLength = iDes->MaxLength() - iOffset;
+00196                 if ( targetLength>0 )
+00197                         {
+00198                         if (sourceLength>targetLength)
+00199                                 {
+00200                                 sourceLength = targetLength;
+00201                                 bufferDes.SetLength(targetLength);
+00202                                 }
+00203 
+00204                         iDes->Append(bufferDes) ;
+00205 
+00206                         iOffset += sourceLength ;
+00207                         }
+00208                 else
+00209                         bufferDes.SetLength(0);
+00210 
+00211                 aSupplier->BufferEmptiedL( aBuffer ) ;
+00212                 }
+00213         }
+00214 
+00215 // called by MDataSource to pass back full buffer to the sink
+00216 void CMMFExDescriptor::BufferFilledL( CMMFBuffer* /*aBuffer*/ )
+00217         {
+00218         // not supported in this plug-in
+00219         __ASSERT_DEBUG(EFalse, Panic(EMMFDescriptorPanicBufferFilledLNotSupported));
+00220         }
+00221 
+00222 // tests if the plug-in can create a sink buffer
+00223 TBool CMMFExDescriptor::CanCreateSinkBuffer()
+00224         {
+00225         // this can't: it needs a descriptor from another thread        
+00226         return EFalse ;
+00227         }
+00228 
+00229 // creates a sink buffer
+00230 CMMFBuffer* CMMFExDescriptor::CreateSinkBufferL( TMediaId /*aMediaId*/ , TBool& /*aReference*/)
+00231         {
+00232         // not supported in this plug-in
+00233         User::Leave(KErrNotSupported);
+00234         return NULL;
+00235         }
+00236 
+00237 // from CMMFClip
+00238 
+00239 // Loads aBuffer with specified amount of data from a specified point in the source descriptor 
+00240 void CMMFExDescriptor::ReadBufferL(TInt aLength, CMMFBuffer* aBuffer, TInt aPosition, MDataSink* aConsumer)
+00241         {
+00242         if (aBuffer->Type() == KUidMmfDataBuffer) 
+00243                 {
+00244                 TDes8& bufferDes = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();
+00245 
+00246                 if (aLength>bufferDes.MaxLength())
+00247                         User::Leave(KErrOverflow);
+00248 
+00249                 if ((aLength<0) || (aPosition<0))
+00250                         User::Leave(KErrArgument);
+00251 
+00252                 ReadBufferL(aBuffer, aPosition, aConsumer);
+00253                 }
+00254         else
+00255                 User::Leave(KErrNotSupported);
+00256         }
+00257 
+00258 // Loads aBuffer from a specified point in the source descriptor  
+00259 void CMMFExDescriptor::ReadBufferL(CMMFBuffer* aBuffer, TInt aPosition, MDataSink* aConsumer)
+00260         {
+00261         if (aBuffer->Type() == KUidMmfDataBuffer) 
+00262                 {
+00263                 TDes8& bufferDes = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();
+00264 
+00265                 TInt sourceLength = iDes->Length() ;
+00266                 TInt destinationMaxLength = bufferDes.MaxLength();
+00267                 TInt len = sourceLength - aPosition;
+00268                 if (len > destinationMaxLength)
+00269                         len = destinationMaxLength;
+00270 
+00271                 if (len>0)
+00272                         {
+00273                         TPtrC8 srcPtr(iDes->Mid(aPosition,len));
+00274                         bufferDes.Copy(srcPtr);
+00275                         }
+00276                 else
+00277                         bufferDes.SetLength(0);
+00278 
+00279                 // Check if the buffer is the last buffer and if so set the last buffer flag on the CMMFDataBuffer
+00280                 TInt requestSize = aBuffer->RequestSize();
+00281                 if (requestSize)
+00282                         { // The buffer has a request size  - so assume last buffer if length is less than the request size
+00283                         if (bufferDes.Length() < requestSize)   
+00284                                 aBuffer->SetLastBuffer(ETrue);
+00285                         }
+00286                 else
+00287                         { // There is no request size so assume last buffer if length is less than the max length
+00288                         if (bufferDes.Length() < bufferDes.MaxLength()) 
+00289                                 aBuffer->SetLastBuffer(ETrue);
+00290                         }
+00291 
+00292                 if (aConsumer)
+00293                         aConsumer->BufferFilledL(aBuffer);
+00294                 }
+00295         else
+00296                 User::Leave(KErrNotSupported);
+00297         }
+00298 
+00299 // Loads aBuffer from a specified point in the source descriptor 
+00300 // This is intended for synchronous usage
+00301 void CMMFExDescriptor::ReadBufferL(CMMFBuffer* aBuffer, TInt aPosition)
+00302         {
+00303         ReadBufferL(aBuffer, aPosition, NULL);
+00304         }
+00305 
+00306 // Writes aBuffer at specified location into the sink descriptor
+00307 void CMMFExDescriptor::WriteBufferL(CMMFBuffer* aBuffer, TInt aPosition, MDataSource* aSupplier) 
+00308         {
+00309         if (aBuffer->Type() == KUidMmfDataBuffer)
+00310                 {
+00311                 TDes8& bufferDes = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();
+00312 
+00313                 WriteBufferL(bufferDes.Length(), aBuffer, aPosition, aSupplier);
+00314                 }
+00315         else
+00316                 User::Leave(KErrNotSupported);
+00317         }
+00318 
+00319 // Writes specified length of aBuffer at specified location into the sink descriptor
+00320 void CMMFExDescriptor::WriteBufferL(TInt aLength, CMMFBuffer* aBuffer, TInt aPosition, MDataSource* aSupplier)
+00321         {
+00322         if (aBuffer->Type() == KUidMmfDataBuffer) 
+00323                 {
+00324                 TDes8& bufferDes = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();
+00325 
+00326                 if (aLength>bufferDes.Length() || (aLength<0) || (aPosition<0))
+00327                         User::Leave(KErrArgument);
+00328 
+00329                 TInt sourceLength = aLength;
+00330                 TPtr8 bufferPtr(((sourceLength) ? &bufferDes[0] : NULL), sourceLength, sourceLength);
+00331                 TInt targetLength = iDes->MaxLength() - aPosition;
+00332                 if (targetLength>0 && sourceLength > 0)
+00333                         {
+00334                         if (sourceLength>targetLength)
+00335                                 User::Leave(KErrOverflow);
+00336 
+00337                         if ((iDes->Length() - aPosition) > 0)
+00338                                 {
+00339                                 TInt bytesToReplace = iDes->Length() - aPosition;
+00340                                 if (sourceLength > bytesToReplace) 
+00341                                         {
+00342                                         TPtrC8 replaceBuf = bufferPtr.Left(bytesToReplace);
+00343                                         TPtrC8 appendBuf = bufferPtr.Right(sourceLength-bytesToReplace);
+00344                                         iDes->Replace(aPosition, bytesToReplace, replaceBuf);
+00345                                         iDes->Append(appendBuf);
+00346                                         } 
+00347                                 else
+00348                                         iDes->Replace(aPosition, sourceLength, bufferPtr);
+00349 
+00350                                 } 
+00351                         else if (aPosition == iDes->Length())
+00352                                 iDes->Append(bufferPtr.Ptr(),sourceLength);
+00353                         else
+00354                                 {
+00355                                 iDes->AppendFill(0,aPosition - iDes->Length());
+00356                                 iDes->Append(bufferPtr.Ptr(),sourceLength);
+00357                                 }
+00358                         }
+00359                 else if (targetLength<0)
+00360                         User::Leave(KErrArgument);
+00361                 else if (aLength != 0)
+00362                         User::Leave(KErrOverflow);
+00363 
+00364                 if (aSupplier)
+00365                         aSupplier->BufferEmptiedL(aBuffer);
+00366                 }
+00367         else
+00368                 User::Leave(KErrNotSupported);
+00369         }
+00370 
+00371 // Writes aBuffer at specified location into the sink descriptor
+00372 void CMMFExDescriptor::WriteBufferL( CMMFBuffer* aBuffer, TInt aPosition)
+00373         {
+00374         WriteBufferL( aBuffer, aPosition, NULL );
+00375         }
+00376 
+00377 // Gets the space available in the clip
+00378 TInt64 CMMFExDescriptor::BytesFree() 
+00379         {
+00380         // get difference between length and maxlength
+00381         TInt64 length = iDes->Length() ;
+00382         TInt64 maxLength =  iDes->MaxLength() ;
+00383         return( maxLength - length ) ;
+00384         }
+00385 
+00386 // Gets the size of the clip
+00387 TInt CMMFExDescriptor::Size() 
+00388         {
+00389         // Length (not max length) of descriptor
+00390         TInt length = iDes->Length();
+00391         return(length);
+00392         }
+