examples/Multimedia/MmfExSinkSource/Mmfdes.cpp

/*
Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.
* Neither the name of Nokia Corporation nor the names of its contributors
  may be used to endorse or promote products derived from this software
  without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Description:  
*/




#include <f32file.h>
#include <e32std.h>
#include <mmfdatabuffer.h>

#include "mmfexdes.h"
#include "MmfExSinkSourceUIDs.hrh"

// Panic function
void Panic(TMMFExDescriptorPanicCode aPanicCode)
        {
        _LIT(KMMFExDescriptorPanicCategory, "MMFExDescriptor");
        User::Panic(KMMFExDescriptorPanicCategory, aPanicCode);
        }

//
// CMMFExDescriptor
//

// Plugin implementation UIDs
const TUid KDescriptorSourceUIDObject   = {KDescriptorSourceUID};
const TUid KDescriptorSinkUIDObject     = {KDescriptorSinkUID};

// Constructor
CMMFExDescriptor::CMMFExDescriptor( ) : CMMFClip( TUid(KDescriptorSourceUIDObject), TUid(KDescriptorSinkUIDObject )) 
        {
        iOffset = 0 ;
        }

// Destructor
CMMFExDescriptor::~CMMFExDescriptor()
        {
        iDesThread.Close() ;
        }

// Factory function for source plug-in
MDataSource* CMMFExDescriptor::NewSourceL( )
        {
        CMMFExDescriptor* self = new (ELeave) CMMFExDescriptor( ) ;
        return STATIC_CAST( MDataSource*, self ) ;
        }
        
// Factory function for sink plug-in
MDataSink* CMMFExDescriptor::NewSinkL( )
        {
        CMMFExDescriptor* self = new (ELeave) CMMFExDescriptor( ) ;
        return STATIC_CAST( MDataSink*, self ) ;
        }

// MDataSource factory
// aInitData is a packaged TMMFExDescriptorParams
void CMMFExDescriptor::ConstructSourceL( const TDesC8& aInitData )
        {
        ConstructL( aInitData ) ;
        }

// MDataSink factory
// aInitData is a packaged TMMFExDescriptorParams
void CMMFExDescriptor::ConstructSinkL( const TDesC8& aInitData )
        {
        ConstructL( aInitData ) ;
        }

// Construction helper
// aInitData is a packaged TMMFExDescriptorParams
void CMMFExDescriptor::ConstructL( const TDesC8& aInitData ) 
        {
        // get descriptor to which to read/write, and the thread 
        // to which it belongs
        TMMFExDescriptorParams params;
        TPckgC<TMMFExDescriptorParams> config(params);
        config.Set(aInitData);
        iDes = STATIC_CAST( TDes8*, config().iDes);
        User::LeaveIfError( iDesThread.Open( config().iDesThreadId ) );
        }


// From MDataSource

TFourCC CMMFExDescriptor::SourceDataTypeCode(TMediaId /*aMediaId*/) 
        {
        return iSourceFourCC ;
        }

// Fills a buffer from the source descriptor
void CMMFExDescriptor::FillBufferL( CMMFBuffer* aBuffer, MDataSink* aConsumer, TMediaId /*aMediaId*/  ) 
        {
        // Current position in Descriptor is iOffset.

        // Read from iDes in iDesThread into Des in aBuffer.

        // Assume that the amount to be read is the size of the buffer descriptor
        // Should check that there is sufficient data in the source buffer
        // If there is not enough to fill the target then copy what there is

        // Use of a single iOffset will preclude use by more than one client (use ReadBufferL())
        if ( aBuffer->Type() == KUidMmfDataBuffer  ) 
                {
                TDes8& bufferDes = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();
                TInt targetMaxLength = bufferDes.MaxLength();
                TInt sourceLength = iDes->Length();
                
                if ( ( sourceLength - iOffset - targetMaxLength ) > 0 )
                        {
                        bufferDes = iDes->Mid(iOffset,targetMaxLength);
                        iOffset += targetMaxLength;
                        }
                else
                        bufferDes.SetLength(0);

                // Check if the buffer is the last buffer and if so set the last buffer flag on the CMMFDataBuffer
                TInt requestSize = aBuffer->RequestSize();
                if (requestSize)
                        { // The buffer has a request size  - so assume last buffer if length is less than the request size
                        if (bufferDes.Length() < requestSize)   
                                aBuffer->SetLastBuffer(ETrue);
                        }
                else
                        { // There is no request size so assume last buffer if length is less than the max length
                        if (bufferDes.Length() < bufferDes.MaxLength()) 
                                aBuffer->SetLastBuffer(ETrue);
                        }

                aConsumer->BufferFilledL( aBuffer ) ;
                }
        else
                User::Leave(KErrNotSupported);
        }

// called by MDataSink to pass back emptied buffer to the source
void CMMFExDescriptor::BufferEmptiedL( CMMFBuffer* /*aBuffer*/ )
        {
        // not supported in this plug-in
        __ASSERT_DEBUG(EFalse, Panic(EMMFDescriptorPanicBufferEmptiedLNotSupported));
        }

// tests if the plug-in can create a source buffer
TBool CMMFExDescriptor::CanCreateSourceBuffer()
        {
        // this can't: it needs a descriptor from another thread
        return EFalse ;
        }

// creates a source buffer
CMMFBuffer* CMMFExDescriptor::CreateSourceBufferL(  TMediaId /*aMediaId*/, TBool& /*aReference*/ )
        {
        // is not supported in this plug-in
        User::Leave(KErrNotSupported);
        return NULL;
        }


// from MDataSink

// gets sink codec type
TFourCC CMMFExDescriptor::SinkDataTypeCode(TMediaId /*aMediaId*/) 
        {
        return iSinkFourCC ;
        }

// Empties supplied buffer into the sink descriptor 
void CMMFExDescriptor::EmptyBufferL( CMMFBuffer* aBuffer, MDataSource* aSupplier, TMediaId /*aMediaId*/ )
        {
        // Current position in Descriptor is iOffset.

        // Assume that the amount to be read is the size of the buffer descriptor
        // Should check that there is sufficient data in the source buffer
        // If there is not enough to fill the target then copy what there is

        // Use of a single iOffset will preclude use by more than one client (use ReadBufferL())

        if ( aBuffer->Type() == KUidMmfDataBuffer  ) 
                {
                TDes8& bufferDes = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();

                TInt sourceLength = bufferDes.Length() ;        
                TInt targetLength = iDes->MaxLength() - iOffset;
                if ( targetLength>0 )
                        {
                        if (sourceLength>targetLength)
                                {
                                sourceLength = targetLength;
                                bufferDes.SetLength(targetLength);
                                }

                        iDes->Append(bufferDes) ;

                        iOffset += sourceLength ;
                        }
                else
                        bufferDes.SetLength(0);

                aSupplier->BufferEmptiedL( aBuffer ) ;
                }
        }

// called by MDataSource to pass back full buffer to the sink
void CMMFExDescriptor::BufferFilledL( CMMFBuffer* /*aBuffer*/ )
        {
        // not supported in this plug-in
        __ASSERT_DEBUG(EFalse, Panic(EMMFDescriptorPanicBufferFilledLNotSupported));
        }

// tests if the plug-in can create a sink buffer
TBool CMMFExDescriptor::CanCreateSinkBuffer()
        {
        // this can't: it needs a descriptor from another thread        
        return EFalse ;
        }

// creates a sink buffer
CMMFBuffer* CMMFExDescriptor::CreateSinkBufferL( TMediaId /*aMediaId*/ , TBool& /*aReference*/)
        {
        // not supported in this plug-in
        User::Leave(KErrNotSupported);
        return NULL;
        }

// from CMMFClip

// Loads aBuffer with specified amount of data from a specified point in the source descriptor 
void CMMFExDescriptor::ReadBufferL(TInt aLength, CMMFBuffer* aBuffer, TInt aPosition, MDataSink* aConsumer)
        {
        if (aBuffer->Type() == KUidMmfDataBuffer) 
                {
                TDes8& bufferDes = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();

                if (aLength>bufferDes.MaxLength())
                        User::Leave(KErrOverflow);

                if ((aLength<0) || (aPosition<0))
                        User::Leave(KErrArgument);

                ReadBufferL(aBuffer, aPosition, aConsumer);
                }
        else
                User::Leave(KErrNotSupported);
        }

// Loads aBuffer from a specified point in the source descriptor  
void CMMFExDescriptor::ReadBufferL(CMMFBuffer* aBuffer, TInt aPosition, MDataSink* aConsumer)
        {
        if (aBuffer->Type() == KUidMmfDataBuffer) 
                {
                TDes8& bufferDes = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();

                TInt sourceLength = iDes->Length() ;
                TInt destinationMaxLength = bufferDes.MaxLength();
                TInt len = sourceLength - aPosition;
                if (len > destinationMaxLength)
                        len = destinationMaxLength;

                if (len>0)
                        {
                        TPtrC8 srcPtr(iDes->Mid(aPosition,len));
                        bufferDes.Copy(srcPtr);
                        }
                else
                        bufferDes.SetLength(0);

                // Check if the buffer is the last buffer and if so set the last buffer flag on the CMMFDataBuffer
                TInt requestSize = aBuffer->RequestSize();
                if (requestSize)
                        { // The buffer has a request size  - so assume last buffer if length is less than the request size
                        if (bufferDes.Length() < requestSize)   
                                aBuffer->SetLastBuffer(ETrue);
                        }
                else
                        { // There is no request size so assume last buffer if length is less than the max length
                        if (bufferDes.Length() < bufferDes.MaxLength()) 
                                aBuffer->SetLastBuffer(ETrue);
                        }

                if (aConsumer)
                        aConsumer->BufferFilledL(aBuffer);
                }
        else
                User::Leave(KErrNotSupported);
        }

// Loads aBuffer from a specified point in the source descriptor 
// This is intended for synchronous usage
void CMMFExDescriptor::ReadBufferL(CMMFBuffer* aBuffer, TInt aPosition)
        {
        ReadBufferL(aBuffer, aPosition, NULL);
        }

// Writes aBuffer at specified location into the sink descriptor
void CMMFExDescriptor::WriteBufferL(CMMFBuffer* aBuffer, TInt aPosition, MDataSource* aSupplier) 
        {
        if (aBuffer->Type() == KUidMmfDataBuffer)
                {
                TDes8& bufferDes = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();

                WriteBufferL(bufferDes.Length(), aBuffer, aPosition, aSupplier);
                }
        else
                User::Leave(KErrNotSupported);
        }

// Writes specified length of aBuffer at specified location into the sink descriptor
void CMMFExDescriptor::WriteBufferL(TInt aLength, CMMFBuffer* aBuffer, TInt aPosition, MDataSource* aSupplier)
        {
        if (aBuffer->Type() == KUidMmfDataBuffer) 
                {
                TDes8& bufferDes = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();

                if (aLength>bufferDes.Length() || (aLength<0) || (aPosition<0))
                        User::Leave(KErrArgument);

                TInt sourceLength = aLength;
                TPtr8 bufferPtr(((sourceLength) ? &bufferDes[0] : NULL), sourceLength, sourceLength);
                TInt targetLength = iDes->MaxLength() - aPosition;
                if (targetLength>0 && sourceLength > 0)
                        {
                        if (sourceLength>targetLength)
                                User::Leave(KErrOverflow);

                        if ((iDes->Length() - aPosition) > 0)
                                {
                                TInt bytesToReplace = iDes->Length() - aPosition;
                                if (sourceLength > bytesToReplace) 
                                        {
                                        TPtrC8 replaceBuf = bufferPtr.Left(bytesToReplace);
                                        TPtrC8 appendBuf = bufferPtr.Right(sourceLength-bytesToReplace);
                                        iDes->Replace(aPosition, bytesToReplace, replaceBuf);
                                        iDes->Append(appendBuf);
                                        } 
                                else
                                        iDes->Replace(aPosition, sourceLength, bufferPtr);

                                } 
                        else if (aPosition == iDes->Length())
                                iDes->Append(bufferPtr.Ptr(),sourceLength);
                        else
                                {
                                iDes->AppendFill(0,aPosition - iDes->Length());
                                iDes->Append(bufferPtr.Ptr(),sourceLength);
                                }
                        }
                else if (targetLength<0)
                        User::Leave(KErrArgument);
                else if (aLength != 0)
                        User::Leave(KErrOverflow);

                if (aSupplier)
                        aSupplier->BufferEmptiedL(aBuffer);
                }
        else
                User::Leave(KErrNotSupported);
        }

// Writes aBuffer at specified location into the sink descriptor
void CMMFExDescriptor::WriteBufferL( CMMFBuffer* aBuffer, TInt aPosition)
        {
        WriteBufferL( aBuffer, aPosition, NULL );
        }

// Gets the space available in the clip
TInt64 CMMFExDescriptor::BytesFree() 
        {
        // get difference between length and maxlength
        TInt64 length = iDes->Length() ;
        TInt64 maxLength =  iDes->MaxLength() ;
        return( maxLength - length ) ;
        }

// Gets the size of the clip
TInt CMMFExDescriptor::Size() 
        {
        // Length (not max length) of descriptor
        TInt length = iDes->Length();
        return(length);
        }

---