diff -r 000000000000 -r bb31fbe78861 aaclc_enc/ariaaclcencmmfcodec/src/ariaaclcencmmfcodec.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/aaclc_enc/ariaaclcencmmfcodec/src/ariaaclcencmmfcodec.cpp Fri Jul 23 16:58:44 2010 +0100 @@ -0,0 +1,816 @@ +/* +* Copyright (c) 2009 Aricent and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "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: +* Aricent - initial contribution. +* +* Contributors: +* +* Description: +* Implementation of member functions of Plugin class +* (CAriAacLCEncMmfCodec). +* +*/ + +#include +#include + +#include "ariaaclcencwrapper.h" +#include "ariaaclcencmmfcodec.h" +#include "ariaaclcencmmfcodec_uid.hrh" +#include "ariprint.h" + +const TUint KMinDstLen = 6144; +const TUint KMinBytesInput = 4096; + +const TUint KFlagSet = 1; +const TUint KFlagNotSet = 0; +const TUint KNoOfSamples = 1024; +const TUint KDefaultChannels = 1; +const TUint KDefaultOutputBitrate = 16000; +const TUint KDefaultSamplingFrequency = 8000; +const TUint KDefaultFormat = 0; + + +// -------------------------------------------------------------------------- +// Two-phased constructor. +// Creates an instance of CAriAacLCEncMmfCodec. +// Instance is not left on cleanup stack. +// -------------------------------------------------------------------------- +// +CMMFCodec* CAriAacLCEncMmfCodec::NewL() + { + PRINT_ENTRY; + + CAriAacLCEncMmfCodec* self = new ( ELeave ) CAriAacLCEncMmfCodec(); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + + PRINT_EXIT; + return ( CMMFCodec* )self; + } + + +// -------------------------------------------------------------------------- +// Destructor;Destroys the encoder instance and any internal buffers +// -------------------------------------------------------------------------- +// +CAriAacLCEncMmfCodec::~CAriAacLCEncMmfCodec() + { + PRINT_ENTRY; + + if ( iInternalInputBuffer ) + { + delete iInternalInputBuffer; + iInternalInputBuffer = NULL; + } + if ( iInternalOutputBuffer ) + { + delete iInternalOutputBuffer; + iInternalOutputBuffer = NULL; + } + if ( iCodec ) + { + delete iCodec; + iCodec = NULL; + } + + iConfigured = EFalse; + PRINT_EXIT; + } + + +// -------------------------------------------------------------------------- +// From class CMMFCodec. +// The function sets codec configuration. +// value used for aConfigType must be KUidMmfCodecAudioSettings +// (defined in include\mmf\plugins\mmfCodecImplementationUIDs.hrh) +// +// -------------------------------------------------------------------------- +// +void CAriAacLCEncMmfCodec::ConfigureL( TUid /* aConfigType */, + const TDesC8& aParam ) + { + PRINT_ENTRY; + + if ( !iConfigured ) + { + TInt numberOfChannels = 0; + TInt samplingFrequency = 0; + TInt outputFormat = 0; + TInt outputBitRate = 0; + TInt flags = 0; + TInt fillBuffer = 0; + TInt offset = 0; + + Mem::Copy( &outputBitRate, aParam.Ptr() + offset, sizeof( TUint ) ); + offset += sizeof( TUint ); + + Mem::Copy( &samplingFrequency, aParam.Ptr() + offset, + sizeof( TUint ) ); + offset += sizeof( TUint ); + + Mem::Copy( &flags, aParam.Ptr() + offset, sizeof( TUint ) ); + offset += sizeof( TUint ); + + Mem::Copy( &numberOfChannels, aParam.Ptr() + offset, + sizeof( TUint ) ); + offset += sizeof( TUint ); + + Mem::Copy( &outputFormat, aParam.Ptr() + offset, sizeof( TUint ) ); + offset += sizeof( TUint ); + + Mem::Copy( &fillBuffer, aParam.Ptr() + offset, sizeof( TUint ) ); + offset += sizeof( TUint ); + + if ( ( flags != 0 && flags != 1 ) || + ( fillBuffer != 0 && fillBuffer != 1 ) ) + { + User::Leave( KErrArgument ); + } + + iParam.iNumberOfChannels = ( TUint )numberOfChannels; + iParam.iOutputBitRate = ( TUint )outputBitRate; + iParam.iOutputFormat = ( TOutputFormat )outputFormat; + iParam.iSamplingFrequency = ( TUint )samplingFrequency; + + PRINT_MSG( LEVEL_HIGH, + ( "NumberOfChannels: %d", iParam.iNumberOfChannels ) ); + PRINT_MSG( LEVEL_HIGH, + ( "OutputBitRate: %d", iParam.iOutputBitRate ) ); + PRINT_MSG( LEVEL_HIGH, + ( "OutputFormat: %d", iParam.iOutputFormat ) ); + PRINT_MSG( LEVEL_HIGH, + ( "SamplingFrequenc: %d", iParam.iSamplingFrequency ) ); + PRINT_MSG( LEVEL_HIGH, + ( "FillBuffer: %d", iFillBuffer ) ); + + User::LeaveIfError( iCodec->Reset( &iParam ) ); + + iSrclenToProcess = sizeof( TInt16 ) * KNoOfSamples * + iParam.iNumberOfChannels; + if ( fillBuffer == KFlagSet ) + { + iFillBuffer = ETrue; + } + else + { + iFillBuffer = EFalse; + } + iConfigured = ETrue; + + } + + PRINT_EXIT; + } + +// --------------------------------------------------------------------------- +// From class CMMFCodec. +// This function is used to flush out status information when a +// reposition occurs. +// This is used if the codec requires resetting prior to use. +// --------------------------------------------------------------------------- +// +void CAriAacLCEncMmfCodec::ResetL() + { + PRINT_ENTRY; + User::LeaveIfError( iCodec->Reset( &iParam ) ); + PRINT_EXIT; + } + + +// -------------------------------------------------------------------------- +// From class CMMFCodec. +// This function is used to encode the given source and fill the destination +// buffer with the encode data. +// The buffers can be of any size. Since the buffers can be of any size +// there is no guarantee that all the source buffer can be processed to fill +// the destination buffer or that the all the source buffer may be processed +// before the destination is full. Therefore the ProcessL needs to return a +// TCodecProcessResult returing the number of source bytes processed and the +// number of destination bytes processed along with a process result code +// defined thus: +// - EProcessComplete: the codec processed all the source data into the +// sink buffer +// - EProcessIncomplete: the codec filled sink buffer before all the source +// buffer +// was processed +// - EDstNotFilled: the codec processed the source buffer but the sink +// buffer was not filled +// - EEndOfData: the codec detected the end data - all source data is +// processed but sink may not be full +// - EProcessError: the codec process error condition +// +// The ProcessL should start processing the source buffer from the iPosition +// data member of the source data and start filling the destination buffer +// from its iPosition. +// ------------------------------------------------------------------------- +// +TCodecProcessResult CAriAacLCEncMmfCodec::ProcessL( const CMMFBuffer& aSrc, + CMMFBuffer& aDst ) + { + PRINT_ENTRY; + + // total decoded bytes added to the dst buffer + TInt totalDstBytesAdded = 0; + // total src bytes added to the internal src buffer + TInt totalSrcBytesCopied = 0; + TInt internalInputBufferLen = 0; + // temporary variable to use for copying the sorce or destination data + TInt numberOfBytesCopied; + + + /** + * Process the dst buffer, update the dstBufferPos and check + * whether dst buffer is NULL or not. + */ + CMMFDataBuffer* dst = static_cast( &aDst ); + const TInt dstMaxLen = dst->Data().MaxLength(); + TUint8* dstPtr = const_cast( dst->Data().Ptr() ); + TInt dstBufferPos = dst->Position(); + + /** + * Process the src buffer, update srcbuffer length, position and + * flag for last frame. check whether src buffer is NULL or not + * and check src buffer contains any data + */ + const CMMFDataBuffer* src = static_cast( &aSrc ); + TUint8* srcPtr = const_cast ( src->Data().Ptr() ); + TInt srcBufferLen = src->Data().Length(); + TInt srcBufferPos = src->Position(); + TBool lastFrame = src->LastBuffer(); + + PRINT_MSG( LEVEL_HIGH, ( "Src Buffer Pos: %d",srcBufferPos ) ); + PRINT_MSG( LEVEL_HIGH, ( "Dst Buffer Pos: %d",dstBufferPos ) ); + PRINT_MSG( LEVEL_HIGH, ( "Residue in internal output buffer: %d", + iInternalOutputBufferResidueLen - iInternalOutputBufferPos ) ); + PRINT_MSG( LEVEL_HIGH, ( "Residue in internal input buffer: %d", + iInternalInputBufferResidueLen ) ); + + TInt srcBufferRemainingBytes = 0; + srcBufferRemainingBytes = srcBufferLen - srcBufferPos - + totalSrcBytesCopied; + TInt totRemainingSrc = srcBufferRemainingBytes + + iInternalInputBufferResidueLen; + if ( ( iInternalOutputBufferResidueLen - iInternalOutputBufferPos == 0 ) + && ( totRemainingSrc < iSrclenToProcess ) && ( lastFrame ) ) + { + totalSrcBytesCopied = 0; + iInternalOutputBufferResidueLen = 0; + iInternalInputBufferResidueLen = 0; + iInternalOutputBufferPos = 0; + PRINT_EXIT; + return Result( TCodecProcessResult::EEndOfData, + totalSrcBytesCopied, totalDstBytesAdded ); + } + + /** + * if any destination bytes from internal destination buffer is not + * given to the dst buffer from the previous call, give it to the + * dst buffer. After this block, it ensures that no bytes are remaining + * in the internal destination buffer. + */ + if ( iInternalOutputBufferResidueLen - iInternalOutputBufferPos > 0 ) + { + numberOfBytesCopied = CopyToDstBuffer( dst, totalDstBytesAdded ); + + if ( iInternalOutputBufferResidueLen - iInternalOutputBufferPos > 0 ) + + { + PRINT_EXIT; + return Result( TCodecProcessResult::EProcessIncomplete, + totalSrcBytesCopied, totalDstBytesAdded ); + } + else + { + if ( lastFrame && ( srcBufferLen - srcBufferPos == 0 ) && + ( iInternalInputBufferResidueLen == 0 ) ) + { + totalSrcBytesCopied = 0; + iInternalOutputBufferResidueLen = 0; + iInternalInputBufferResidueLen = 0; + iInternalOutputBufferPos = 0; + PRINT_EXIT; + return Result( TCodecProcessResult::EEndOfData, + totalSrcBytesCopied, totalDstBytesAdded ); + } + iInternalOutputBufferPos = 0; + iInternalOutputBufferResidueLen = 0; + } + } + TInt dstBufferRemainingBytes = 0; + dstBufferRemainingBytes = dstMaxLen - dstBufferPos - totalDstBytesAdded; + if ( dstBufferRemainingBytes == 0 ) + { + PRINT_EXIT; + return Result( TCodecProcessResult::EProcessIncomplete, + totalSrcBytesCopied, totalDstBytesAdded ); + } + + + + + //generate header for ADIF and Raw encoded formats + if ( !iHeaderGenerated ) + { + if ( ( iParam.iOutputFormat == EFormatADIF ) || + ( iParam.iOutputFormat == EFormatRaw ) ) + { + TInt retval = KErrNone; + TInt headerLen = KMinDstLen; + retval = iCodec->GetHeader( iInternalOutputBuffer,headerLen ); + + /** + * Fill Destination Buffer + */ + + iInternalOutputBufferResidueLen = headerLen; + numberOfBytesCopied = CopyToDstBuffer( dst, totalDstBytesAdded ); + dstBufferRemainingBytes -= numberOfBytesCopied; + + iHeaderGenerated = ETrue; + if ( ( iInternalOutputBufferResidueLen - + iInternalOutputBufferPos > 0 ) || + dstBufferRemainingBytes == 0 ) + { + totalSrcBytesCopied = 0; + PRINT_EXIT; + return Result( + TCodecProcessResult::EProcessIncomplete, + totalSrcBytesCopied, totalDstBytesAdded ); + } + } + else + { + iHeaderGenerated = ETrue; + } + } + + TInt newSrcCopied = 0; + /** + * copy the src buffer data into the internal buffer till internal buffer + * holds minimum bytes to process i.e KMinBytesInput. After this block, it + * ensures that internal source buffer holds KMinBytesInput. + * if it is a last frame, treat remaining residual buffer as internal + * buffer. + */ + if ( ( iSrclenToProcess - iInternalInputBufferResidueLen > 0 ) && + ( srcBufferLen - srcBufferPos > 0 ) ) + { + numberOfBytesCopied = CopyFromSrcBuffer( src, totalSrcBytesCopied ); + newSrcCopied = numberOfBytesCopied; + } + + if ( iSrclenToProcess > iInternalInputBufferResidueLen ) + { + if ( !lastFrame ) + { + PRINT_EXIT; + return Result( TCodecProcessResult::EDstNotFilled, + srcBufferLen - srcBufferPos, totalDstBytesAdded ); + } + else + { + totalSrcBytesCopied = 0; + iInternalOutputBufferResidueLen = 0; + iInternalInputBufferResidueLen = 0; + iInternalOutputBufferPos = 0; + PRINT_EXIT; + return Result( TCodecProcessResult::EEndOfData, + totalSrcBytesCopied, totalDstBytesAdded ); + } + } + + srcBufferRemainingBytes = srcBufferLen - srcBufferPos - + totalSrcBytesCopied; + + if ( lastFrame && ( ( iSrclenToProcess > iInternalInputBufferResidueLen ) + && ( iSrclenToProcess > srcBufferRemainingBytes ) ) + && ( iInternalOutputBufferResidueLen - + iInternalOutputBufferPos == 0 ) ) + { + totalSrcBytesCopied = 0; + iInternalOutputBufferResidueLen = 0; + iInternalInputBufferResidueLen = 0; + iInternalOutputBufferPos = 0; + PRINT_EXIT; + return Result( TCodecProcessResult::EEndOfData, + totalSrcBytesCopied, totalDstBytesAdded ); + } + + + if ( iInternalOutputBufferResidueLen - iInternalOutputBufferPos == 0 ) + { + iInternalOutputBufferResidueLen = 0; + iInternalOutputBufferPos = 0; + } + /** + * process the src buffer till destination buffer or source buffer or + * both buffers are exhausted. + */ + do + { + + srcBufferRemainingBytes = srcBufferLen - srcBufferPos - + totalSrcBytesCopied; + dstBufferRemainingBytes = dstMaxLen - dstBufferPos - + totalDstBytesAdded; + TInt internalInputBufferPos = 0; + + /** + * initialize the variables like srcUsed and dstLen accordingly. + * call Encode. + */ + TInt srcUsed = iSrclenToProcess; + TInt dstLen = KMinDstLen; + TInt16* tempIn = NULL; + tempIn = ( TInt16* ) ( ( iInternalInputBuffer + + internalInputBufferPos ) ); + TInt error = iCodec->Encode( tempIn, srcUsed, iInternalOutputBuffer, + dstLen ); + if ( error != KErrNone ) + { + iInternalInputBufferResidueLen = 0; + totalSrcBytesCopied = srcBufferLen; + PRINT_ERR( error ); + return Result( + TCodecProcessResult::EProcessError, + totalSrcBytesCopied, totalDstBytesAdded + dstBufferPos ); + } + + /** + * Fill Destination Buffer + */ + PRINT_MSG( LEVEL_HIGH, ( "dstLen: %d",dstLen ) ); + iInternalOutputBufferResidueLen = dstLen; + numberOfBytesCopied = CopyToDstBuffer( dst, totalDstBytesAdded ); + dstBufferRemainingBytes -= numberOfBytesCopied; + + /*** + * Fill Source Buffer if FillBuffer flag is true + */ + internalInputBufferPos += srcUsed ; + ShiftData( internalInputBufferPos, 0 ); + + if ( iFillBuffer ) + { + numberOfBytesCopied = CopyFromSrcBuffer( src, + totalSrcBytesCopied ); + srcBufferRemainingBytes -= numberOfBytesCopied; + } + + /*** + * check four conditions if else for src and if else for dst + */ + // src has available bytes + TInt totSrcUsed = 0; + if ( ( iSrclenToProcess > srcBufferRemainingBytes ) && + ( iSrclenToProcess > iInternalInputBufferResidueLen ) && + ( lastFrame ) ) + { + iInternalOutputBufferResidueLen = 0; + iInternalInputBufferResidueLen = 0; + iInternalOutputBufferPos = 0; + PRINT_EXIT; + return Result( TCodecProcessResult::EEndOfData, + totalSrcBytesCopied, totalDstBytesAdded ); + } + + if ( srcBufferRemainingBytes > 0 || iInternalInputBufferResidueLen >= + iSrclenToProcess ) + { + if ( dstBufferRemainingBytes > 0 ) + { + if ( !iFillBuffer ) + { + totSrcUsed = srcBufferPos + srcUsed; + totalSrcBytesCopied = newSrcCopied; + PRINT_EXIT; + return Result( + TCodecProcessResult::EProcessIncomplete, + totalSrcBytesCopied, totalDstBytesAdded ); + } + } + else + { + PRINT_EXIT; + return Result( + TCodecProcessResult::EProcessIncomplete, + totalSrcBytesCopied, totalDstBytesAdded ); + } + + } + else + { + if ( dstBufferRemainingBytes > 0 ) + { + if ( lastFrame ) + { + if ( iInternalInputBufferResidueLen >= iSrclenToProcess ) + { + if ( !iFillBuffer ) + { + totSrcUsed = srcBufferPos + srcUsed; + totalSrcBytesCopied = newSrcCopied; + PRINT_EXIT; + return Result( + TCodecProcessResult::EProcessIncomplete, + totalSrcBytesCopied, totalDstBytesAdded ); + } + } + else + { + iInternalOutputBufferResidueLen = 0; + iInternalInputBufferResidueLen = 0; + iInternalOutputBufferPos = 0; + PRINT_EXIT; + return Result( TCodecProcessResult::EEndOfData, + totalSrcBytesCopied, totalDstBytesAdded ); + } + } + else + { + PRINT_EXIT; + return Result( TCodecProcessResult::EDstNotFilled, + totalSrcBytesCopied, totalDstBytesAdded ); + } + } + else + { + if ( iInternalOutputBufferResidueLen - + iInternalOutputBufferPos > 0 ) + { + PRINT_EXIT; + return Result( TCodecProcessResult::EProcessIncomplete, + totalSrcBytesCopied, totalDstBytesAdded ); + } + else + { + if( lastFrame && (iInternalInputBufferResidueLen == 0 ) ) + + { + iInternalOutputBufferResidueLen = 0; + iInternalInputBufferResidueLen = 0; + iInternalOutputBufferPos = 0; + PRINT_EXIT; + return Result( TCodecProcessResult::EEndOfData, + totalSrcBytesCopied, totalDstBytesAdded ); + } + else + { + PRINT_EXIT; + return Result( + TCodecProcessResult::EProcessComplete, + totalSrcBytesCopied, totalDstBytesAdded ); + } + } + } + } + }while ( 1 ); + } + + +// -------------------------------------------------------------------------- +// Default constructor for performing 1st stage construction. +// Should not contain any code that could leave. +// -------------------------------------------------------------------------- +// +CAriAacLCEncMmfCodec::CAriAacLCEncMmfCodec() + { + PRINT_ENTRY; + iCodec = NULL; + iConfigured = EFalse; + iHeaderGenerated = EFalse; + iSrclenToProcess = 0; + iFillBuffer = EFalse; + iInternalInputBufferResidueLen = 0; + iInternalOutputBufferResidueLen = 0; + iInternalOutputBufferPos = 0; + iInternalInputBuffer = NULL; + iInternalOutputBuffer = NULL; + //default parameters + iParam.iNumberOfChannels = KDefaultChannels; + iParam.iOutputBitRate = KDefaultOutputBitrate; + iParam.iOutputFormat = EFormatRaw; + iParam.iSamplingFrequency = KDefaultSamplingFrequency; + iParam.iTurnOnPns = KFlagSet; + iParam.iTurnOnTns = KFlagSet; + iParam.iVersionInfo = KFlagNotSet; + PRINT_EXIT; +} + + +// -------------------------------------------------------------------------- +// Second phase of the two-phased constructor. +// Creates an instance of encoder +// -------------------------------------------------------------------------- +// +void CAriAacLCEncMmfCodec::ConstructL() + { + PRINT_ENTRY; + iCodec = CAriAacLCEncWrapper::NewL(); + + iInternalInputBuffer = ( TUint8* ) User::AllocZL( KMinBytesInput ); + iInternalOutputBuffer = ( TUint8* ) User::AllocZL( KMinDstLen ); + + PRINT_MSG( LEVEL_HIGH, ( "Default NumberOfChannels: %d", + iParam.iNumberOfChannels ) ); + PRINT_MSG( LEVEL_HIGH, ( "Default OutputBitRate: %d", + iParam.iOutputBitRate ) ); + PRINT_MSG( LEVEL_HIGH, ( "Default OutputFormat: %d", + iParam.iOutputFormat ) ); + + PRINT_MSG( LEVEL_HIGH, ( "Default SamplingFrequency: %d", + iParam.iSamplingFrequency ) ); + + //Reset encoder with default parameters + User::LeaveIfError( iCodec->Reset( &iParam ) ); + + iSrclenToProcess = sizeof( TInt16 ) * KNoOfSamples * + iParam.iNumberOfChannels; + PRINT_EXIT; + } + + +//---------------------------------------------------------------------------- +// Updates the result of the processing +//---------------------------------------------------------------------------- +// +TCodecProcessResult CAriAacLCEncMmfCodec::Result( + TCodecProcessResult::TCodecProcessResultStatus aStatus, + TInt aSrcBytesConsumed, TInt aDstBytesAdded ) + { + PRINT_ENTRY; + TCodecProcessResult result; + + result.iDstBytesAdded = aDstBytesAdded; + result.iSrcBytesProcessed = aSrcBytesConsumed; + + switch ( aStatus ) + { + case TCodecProcessResult::EProcessComplete: + result.iStatus = TCodecProcessResult::EProcessComplete; + break; + case TCodecProcessResult::EProcessIncomplete: + result.iStatus = TCodecProcessResult::EProcessIncomplete; + break; + case TCodecProcessResult::EEndOfData: + result.iStatus = TCodecProcessResult::EEndOfData; + break; + case TCodecProcessResult::EDstNotFilled: + result.iStatus = TCodecProcessResult::EDstNotFilled; + break; + case TCodecProcessResult::EProcessError: + result.iStatus = TCodecProcessResult::EProcessError; + break; + default: + result.iStatus = TCodecProcessResult::EProcessError; + break; + } + PRINT_MSG( LEVEL_HIGH, ( "result.iSrcBytesProcessed = %d", + result.iSrcBytesProcessed ) ); + PRINT_MSG( LEVEL_HIGH, ( "result.iDstBytesAdded = %d", + result.iDstBytesAdded ) ); + PRINT_MSG( LEVEL_HIGH, ( "result.iStatus = %d", + result.iStatus ) ); + PRINT_EXIT; + return result; + } + +//---------------------------------------------------------------------------- +// Copy the bytes to destination buffer from the internal buffer +// first checks whether the number of bytes to be copied is lesser of the +// destination buffer reamining bytes and internal input internal remaining +// remaining bytes and then copies that many bytes. +//---------------------------------------------------------------------------- +// + TInt CAriAacLCEncMmfCodec::CopyToDstBuffer( CMMFDataBuffer* aDst, + TInt &aDstBytesConsumed ) + { + PRINT_ENTRY; + TInt numberOfBytesToBeCopied; + const TInt dstMaxLen = aDst->Data().MaxLength(); + TUint8* dstPtr = const_cast( aDst->Data().Ptr() ); + TInt dstBufferPos = aDst->Position(); + + TInt dstBufferRemainingBytes = dstMaxLen + - dstBufferPos + - aDstBytesConsumed; + TInt internalOutputBufferRemainingBytes = + iInternalOutputBufferResidueLen + - iInternalOutputBufferPos; + + if ( internalOutputBufferRemainingBytes > dstBufferRemainingBytes ) + { + numberOfBytesToBeCopied = dstBufferRemainingBytes; + } + else + { + numberOfBytesToBeCopied = internalOutputBufferRemainingBytes; + iInternalOutputBufferResidueLen = 0; + } + + Mem::Copy( dstPtr + dstBufferPos + aDstBytesConsumed, + iInternalOutputBuffer + iInternalOutputBufferPos, + numberOfBytesToBeCopied ); + + if( iInternalOutputBufferResidueLen ) + { + iInternalOutputBufferPos += dstBufferRemainingBytes; + } + else + { + iInternalOutputBufferPos = 0; + } + + aDstBytesConsumed += numberOfBytesToBeCopied; + aDst->Data().SetLength( dstBufferPos + aDstBytesConsumed ); + PRINT_EXIT; + return numberOfBytesToBeCopied; + } + +//--------------------------------------------------------------------------- +// Copy the bytes from the source buffer to the internal input buffer. +// first it checks number of bytes to be copied is lesser of the source buffer +// remaining bytes or internal input buffer remaining bytes and then copies +// that many bytes. +//--------------------------------------------------------------------------- +// + TInt CAriAacLCEncMmfCodec::CopyFromSrcBuffer( const CMMFDataBuffer* aSrc, + TInt &aSrcBytesConsumed ) + { + PRINT_ENTRY; + TInt numberOfBytesToBeCopied; + TUint8* srcPtr = const_cast ( aSrc->Data().Ptr() ); + TInt srcBufferLen = aSrc->Data().Length(); + TInt srcBufferPos = aSrc->Position(); + + TInt srcBufferRemainingBytes = srcBufferLen - srcBufferPos + - aSrcBytesConsumed; + + TInt internalInputBufferRemaingBytes = KMinBytesInput + - iInternalInputBufferResidueLen; + + if ( internalInputBufferRemaingBytes > srcBufferRemainingBytes ) + { + numberOfBytesToBeCopied = srcBufferRemainingBytes; + } + else + { + numberOfBytesToBeCopied = internalInputBufferRemaingBytes; + } + + Mem::Copy( iInternalInputBuffer + iInternalInputBufferResidueLen, + srcPtr + srcBufferPos + aSrcBytesConsumed, + numberOfBytesToBeCopied ); + + iInternalInputBufferResidueLen += numberOfBytesToBeCopied; + aSrcBytesConsumed += numberOfBytesToBeCopied; + PRINT_EXIT; + return numberOfBytesToBeCopied; + } + +//--------------------------------------------------------------------------- +// Moves the data of the internal input buffer to the start position +//--------------------------------------------------------------------------- +// +void CAriAacLCEncMmfCodec::ShiftData( TInt aFromPos, TInt aToPos ) + { + PRINT_ENTRY; + for ( TInt i = aFromPos; i < ( iInternalInputBufferResidueLen - + aFromPos ); i++ ) + { + iInternalInputBuffer[i] = + iInternalInputBuffer[i + aFromPos]; + } + iInternalInputBufferResidueLen -= aFromPos; + PRINT_EXIT; + } + +// -------------------------------------------------------------------------- +// Exported proxy for instantiation method resolution +// Define the interface UIDs +// -------------------------------------------------------------------------- +// +const TImplementationProxy ImplementationTable[] = +{ + IMPLEMENTATION_PROXY_ENTRY( KUidAacLCEncMmfImplUid, + CAriAacLCEncMmfCodec::NewL ) +}; + +EXPORT_C const TImplementationProxy* ImplementationGroupProxy( + TInt& aTableCount ) +{ +PRINT_ENTRY; + aTableCount = sizeof( ImplementationTable ) / + sizeof( TImplementationProxy ); + + PRINT_EXIT; + return ImplementationTable; +}