imageconverterengine.cpp

这个源代码是symbian下实现图片旋转及缩放的例子代码。对图片处理时有帮助。

/*
* ============================================================================
*  Name     : CImageConverterEngine from ImageConverterEngine.cpp
*  Part of  : ImageConverter
*  Created  : May 14, 2006 by Forum Nokia
*  Implementation notes:
*     Handles all ICL interaction. Implemented as a separate class/engine
*     for the sake of clarity of the example.
*  Version  : 2.0
*  Copyright: Nokia Corporation
* ============================================================================
*/

#include "ImageConverterEngine.h"

#include <fbs.h>
#include <ImageConversion.h>
#include <BitmapTransforms.h>

const TInt KMaxInfoMsgLength = 50;

CImageConverterEngine* CImageConverterEngine::NewL( 
    MConverterController* aController )
    {
    CImageConverterEngine* self = 
        new(ELeave) CImageConverterEngine( aController );
    CleanupStack::PushL( self );
	
    self->ConstructL();

    CleanupStack::Pop(self);
    return self; 
    }

CImageConverterEngine::CImageConverterEngine( 
    MConverterController* aController ) : 
    CActive( EPriorityStandard ), iController( aController )
    {
    }

void CImageConverterEngine::ConstructL()
    {
    User::LeaveIfError( iFs.Connect() );
    iRotator = CBitmapRotator::NewL();
    iScaler = CBitmapScaler::NewL();
    CActiveScheduler::Add( this );
    }

CImageConverterEngine::~CImageConverterEngine()
    {
    Cancel();
    delete iImageEncoder; 
    delete iImageDecoder; // CImageDecoder must be deleted before the 
    iFs.Close();          //   related RFs is closed, 
    delete iBitmap;		  //   otherwise a related thread might panic	
    delete iRotator;
    delete iScaler;
    }

void CImageConverterEngine::StartToDecodeL( TFileName& aFileName )
    {
    delete iImageDecoder; iImageDecoder = NULL;
    delete iBitmap; iBitmap = NULL;

    // create the decoder
    iImageDecoder = CImageDecoder::FileNewL( iFs, aFileName );
	
    // create the destination bitmap
    iBitmap = new (ELeave) CFbsBitmap();
    iBitmap->Create( iImageDecoder->FrameInfo().iOverallSizeInPixels,
                     iImageDecoder->FrameInfo().iFrameDisplayMode ); 

    // start conversion to bitmap
    iState = EDecoding;
    iImageDecoder->Convert( &iStatus, *iBitmap );
    SetActive();
    }

void CImageConverterEngine::StartToEncodeL( 
    TFileName& aFileName, TUid aImageType, TUid aImageSubType )
    {
    if (iImageEncoder)
        {
        delete iImageEncoder; 
        iImageEncoder = NULL;
        }

    // create the encoder
    iImageEncoder = CImageEncoder::FileNewL( iFs, aFileName, 
        CImageEncoder::EOptionNone, aImageType, aImageSubType );

    iState = EEncoding;
    iImageEncoder->Convert( &iStatus, *iBitmap );
    SetActive();
    }

void CImageConverterEngine::DoCancel()
    {
    if( iState == EDecoding )
        {
        iImageDecoder->Cancel();
        }
    else if( iState == EEncoding )
        {
        iImageEncoder->Cancel();
        }
    else if( iState == ERotating )
        {
        iRotator->Cancel();
        }
    else if( iState == EScaling )
        {
        iScaler->Cancel();
        }
    else
        {
        // State is EIdle, do nothing
        }
    }
	

void CImageConverterEngine::RunL()
    {
    switch( iState ) 
        {
        case EDecoding:
            {
            if( iStatus == KErrNone ) 
                {
                iState = EIdle;
                _LIT(KImageReady, "Image ready");
                iController->NotifyCompletion( KErrNone, KImageReady );
                break;
                }
            else if( iStatus == KErrUnderflow ) 
                {
                iImageDecoder->ContinueConvert( &iStatus );
                SetActive();
                break;
                }
            else if ( iStatus == KErrCorrupt )
                {
                iState = EIdle;
                _LIT(KImageCorrupt, "Image file corrupted");
                iController->NotifyCompletion( KErrCorrupt, KImageCorrupt );
                break;
                }
            else
                {
                // Unknown error
                _LIT( KErrorMsg, "Error while opening image:%d" );
                TBuf<KMaxInfoMsgLength> buf;
                buf.Format( KErrorMsg, iStatus.Int() );
                iController->NotifyCompletion( iStatus.Int(), KErrorMsg );
                break;
                }
            }
        case EEncoding:
            {
            _LIT(KImageSaved, "Image saved");
            iState = EIdle;
            iController->NotifyCompletion( iStatus.Int(), KImageSaved);
            break;
            }
        case ERotating:
        case EScaling:
        default:
            {
            iState = EIdle;
            iController->NotifyCompletion( iStatus.Int(), KNullDesC );
            }
        }   
    }

TInt CImageConverterEngine::RunError(TInt /*aError*/)   
    {
    // Our RunL does not contain any method calls that would leave, so this method
    // should never be called.
    return KErrNone;
    }

void CImageConverterEngine::GetEncoderImageTypesL( 
    RImageTypeDescriptionArray& aImageTypeArray )
    {
    CImageEncoder::GetImageTypesL( aImageTypeArray );
    }

CFrameInfoStrings* CImageConverterEngine::GetImageInfoL()
    {
    // notice that the information is returned from the original image
    //  hence the scaling of the bitmap does not affect the info until
    //  the bitmap is encoded back to image file and opened again
    if( iImageDecoder )
        {
        return( iImageDecoder->FrameInfoStringsL() );
        }
    else
        {
        return NULL ;
        }
    }

void CImageConverterEngine::Rotate( TDirection aDirection )
    {
    if (iState != EIdle)
        {
        // Do nothing, if we are in the middle of processing a previous command
        return;
        }
		
    if( aDirection == EClockwise90 ) 
        {
        iRotator->Rotate( &iStatus, *iBitmap, 
            CBitmapRotator::ERotation90DegreesClockwise );	
        }
    else 
        { 
        // 270 clockwise == 90 anticlockwise
        iRotator->Rotate( &iStatus, *iBitmap, 
            CBitmapRotator::ERotation270DegreesClockwise );	
        }

    iState = ERotating;
    SetActive();
    }

void CImageConverterEngine::Scale( TInt aPercent )
    {
    if (iState != EIdle)
        {
        // Do nothing, if we are in the middle of processing a previous command			
        return;
        }
		
    TReal32 multiplier; 

    multiplier = aPercent/(TReal32)100.0;

    TInt newWidth = (TInt)(iBitmap->SizeInPixels().iWidth * multiplier);
    TInt newHeight = (TInt)(iBitmap->SizeInPixels().iHeight * multiplier);
		
    // the maintain aspect ratio is by default set to true
    iScaler->Scale( &iStatus, *iBitmap, TSize(newWidth,newHeight) );

    iState = EScaling;
    SetActive();
    }
	
CFbsBitmap* CImageConverterEngine::GetBitmap()
    {
    return iBitmap;
    }