// -----------------------------------------------------------------------------
// CMceSrvStream::DecodeAudioL
// -----------------------------------------------------------------------------
//
void CMceSrvStream::DecodeAudioL( RPointerArray<CMceSrvStream>& aStreams,
CMceComAudioStream& aAudio,
CMceMediaManager& aManager )
{
MCEMM_DEBUG("CMceSrvStream::DecodeAudioL(), Entry ");
// First clear all enabled states, those are affected inside codec
// specific decoding
for( TInt i = 0; i < aAudio.CodecCount(); ++i )
{
aAudio.CodecL( i )->SetEnabled( EFalse );
}
for ( TInt j = 0; j < aAudio.CodecCount(); ++j )
{
aAudio.CodecL( j )->DoDecodeAudioL( j,
aStreams,
aAudio,
aManager );
}
if ( aAudio.BoundStream() && aAudio.Binder() )
{
DecodeL( aStreams, aAudio.BoundStreamL(), aManager );
}
MCEMM_DEBUG("CMceSrvStream::DecodeAudioL(), Exit ");
}
void CMceSrvStream::DecodeVideoL( RPointerArray<CMceSrvStream>& aStreams,
CMceComVideoStream& aVideo,
CMceMediaManager& aManager )
{
MCEMM_DEBUG("CMceSrvStream::DecodeVideoL(), Entry ");
for( TInt codecNdx = 0;codecNdx < aVideo.CodecCount();codecNdx++ )
{
aVideo.CodecL( codecNdx )->SetEnabled(
codecNdx == 0 || IS_RECEIVESTREAM( &aVideo ) );
for( TInt sinkNdx = 0 ; sinkNdx < aVideo.Sinks().Count() ; sinkNdx++ )
{
CMceSrvStream* srvStream = NewL( aManager, aVideo,
*aVideo.Source(),
*aVideo.Sinks()[ sinkNdx ],
*aVideo.CodecL( codecNdx ) );
CleanupStack::PushL( srvStream );
MCEMM_DEBUG_STREAM( "CMceSrvStream::DecodeVideoL(): decoded video", *srvStream );
aStreams.AppendL( srvStream );
CleanupStack::Pop( srvStream );
}
}
if ( aVideo.BoundStream() && aVideo.Binder() )
{
DecodeL( aStreams, aVideo.BoundStreamL(), aManager );
}
MCEMM_DEBUG("CMceSrvStream::DecodeVideoL(), Exit ");
}
// ----------------------------------------------------------------------------
// CSIPSubscriptionStateHeader::BaseDecodeL
// ----------------------------------------------------------------------------
//
RPointerArray<CSIPHeaderBase>
CSIPSubscriptionStateHeader::BaseDecodeL(const TDesC8& aValue)
{
CSIPSubscriptionStateHeader* header = DecodeL(aValue);
CleanupStack::PushL(header);
RPointerArray<CSIPHeaderBase> headerArray;
User::LeaveIfError (headerArray.Append(header));
CleanupStack::Pop(header);
return headerArray;
}
void CImageRescaler::RunL()
{
switch( iState )
{
case EStartRescale:
{
// Start rescaling process
DecodeL();
break;
}
case EDecoding:
{
if(iStatus == KErrNone)
{
ScaleL();
}
else if(iStatus == KErrUnderflow)
{
iImageDecoder->ContinueConvert( &iStatus );
SetActive();
}
else
{
// Unknown error
iErr = iStatus.Int();
CompleteRerescale();
}
break;
}
case EEncoding:
{
iErr = iStatus.Int();
CompleteRerescale();
break;
}
case EScaling:
{
EncodeL();
break;
}
default:
{
iErr = KErrGeneral;
CompleteRerescale();
break;
}
}
}
/**
Resize an image synchronously
@param aSourceFile The source path of the file to resize
@param aSourceFile The destination path of the resized image
@leave KErrCompletion The operation completes prematurely
@leave KErrCancel The operation is cancelled
@leave KErrArgument The argumants are wrong
*/
void CImageRescaler::ResizeImageL(const TDesC& aSourceFile, const TDesC& aDestFile)
{
// Synchronous rescaling
// Cancel any current requests
Cancel();
// Reset image file paths
iSourceFile = aSourceFile;
iDestFile = aDestFile;
// Start rescaling
DecodeL();
// Synchronize asynchronous operations (wait loop is finished in RunL when
// image operations are done, or in RunError if an error occurs)
iWait->Start();
// Reset rescaler after request completion
Reset();
User::LeaveIfError(iErr);
}
