/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Implementation of CMPXImageUtil.

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <s32mem.h>

#include <bitmaptransforms.h>

#include <mda/common/video.h>

#include <eikenv.h>

#include <MetaDataUtility.h>

#include <MetaDataFieldContainer.h>

#include <mpxuser.h>

#include <mpxlog.h>

#include "mpximageutil.h"

// CONSTANTS

const TInt KMPXBitmapBufferGranularity = 1024;

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CMPXImageUtil* CMPXImageUtil::NewL()

    {

    MPX_FUNC( "CMPXImageUtil::NewL" );

    CMPXImageUtil* self = new ( ELeave ) CMPXImageUtil();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self ); 

    return self; 

    }

// -----------------------------------------------------------------------------

// C++ constructor can NOT contain any code that might leave.

// -----------------------------------------------------------------------------

//

CMPXImageUtil::CMPXImageUtil() :

    iOperation( EIdle )

    {

    MPX_FUNC( "CMPXImageUtil::CMPXImageUtil" );

    }

// -----------------------------------------------------------------------------

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CMPXImageUtil::ConstructL()

    {

    MPX_FUNC( "CMPXImageUtil::ConstructL" );

    User::LeaveIfError( iFs.Connect() );

    // this is needed in order to create CFbsBitmap instances and it has to be 

    // done before instantiating the bitmap scaler

    User::LeaveIfError( RFbsSession::Connect( iFs ) );

    iScaler = CBitmapScaler::NewL();

    }

// -----------------------------------------------------------------------------

// Destructor

// -----------------------------------------------------------------------------

//

CMPXImageUtil::~CMPXImageUtil()

    {

    MPX_FUNC( "CMPXImageUtil::~CMPXImageUtil" );

    delete iDecoder; 

    delete iEncoder; 

    delete iScaler;

    if (RFbsSession::GetSession())

        {

        RFbsSession::Disconnect();

        }    

    iFs.Close();

    }

// -----------------------------------------------------------------------------

// CMPXImageUtil::ExtractL

// Synchronous method.

// -----------------------------------------------------------------------------

//

HBufC8* CMPXImageUtil::ExtractL( const TDesC& aUri )

    {

    MPX_FUNC( "CMPXImageUtil::ExtractL" );

    HBufC8* ret( NULL );

    CMetaDataUtility* metaDataUtil = CMetaDataUtility::NewL();

    CleanupStack::PushL( metaDataUtil );

    RArray<TMetaDataFieldId> wantedFields;

    CleanupClosePushL( wantedFields );

    wantedFields.AppendL( EMetaDataJpeg );

    metaDataUtil->OpenFileL( aUri, wantedFields );

    const CMetaDataFieldContainer& metaCont = metaDataUtil->MetaDataFieldsL();

    TPtrC data = metaCont.Field( EMetaDataJpeg );

    if ( data.Length() )

        {

        // if no album art return NULL

        ret = MPXUser::Alloc8L( data );       

        }

    CleanupStack::PopAndDestroy( &wantedFields );

    CleanupStack::PopAndDestroy( metaDataUtil );

    return ret;    

    }

// -----------------------------------------------------------------------------

// CMPXImageUtil::Decode 

// -----------------------------------------------------------------------------

//

void CMPXImageUtil::Decode(

    TRequestStatus& aStatus, 

    const TDesC& aSourceJPGFile, 

    CFbsBitmap& aDestBMP, 

    TSize aSize, 

    TDisplayMode aDisplayMode /* = EColor64K */)

    {

    MPX_FUNC( "CMPXImageUtil::Decode" );

    TRAPD( err, DoDecodeL( aStatus, aSourceJPGFile, aDestBMP, aSize, aDisplayMode ) );

    if ( err )

        {

        TRequestStatus* status = &aStatus;      

        User::RequestComplete( status, err );

        }

    }

// -----------------------------------------------------------------------------

// Starts to decode an image from a buffer. 

// -----------------------------------------------------------------------------

//

void CMPXImageUtil::Decode(

    TRequestStatus& aStatus,

    const TDesC8& aJPGData, 

    CFbsBitmap& aDestBMP,     

    TSize aSize, 

    TDisplayMode aDisplayMode /* = EColor64K */)

    {

    MPX_FUNC( "CMPXImageUtil::Decode" );

    TRAPD( err, DoDecodeL( aStatus, aJPGData, aDestBMP, aSize, aDisplayMode ) );

    if ( err )

        {

        TRequestStatus* status = &aStatus;      

        User::RequestComplete( status, err );

        }

    }

// -----------------------------------------------------------------------------

// CMPXImageUtil::Encode

// Converts a BMP to a JPG.

// -----------------------------------------------------------------------------

//

void CMPXImageUtil::Encode(

    TRequestStatus& aStatus,

    const CFbsBitmap& aSourceBMP,

    HBufC8*& aDestJPG )

    {

    MPX_FUNC( "CMPXImageUtil::Encode" );

    TRAPD( err, DoEncodeL( aStatus, aSourceBMP, aDestJPG ) );

    if ( err )

        {

        TRequestStatus* status = &aStatus;      

        User::RequestComplete( status, err );

        }

    }

// -----------------------------------------------------------------------------

// CMPXImageUtil::Scale

// Scales a BMP to a specified size.

// -----------------------------------------------------------------------------

//

void CMPXImageUtil::Scale(

    TRequestStatus& aStatus,

    CFbsBitmap& aSrcBMP, 

    CFbsBitmap& aDestBMP,

    TSize aSize,     

    TDisplayMode aDisplayMode /* = EColor64K */)

    {    

    MPX_FUNC( "CMPXImageUtil::Scale" );

    TRAPD( err, DoScaleL( aStatus, aSrcBMP, aDestBMP, aSize, aDisplayMode ) );

    if ( err )

        {

        TRequestStatus* status = &aStatus;      

        User::RequestComplete( status, err );

        }

    }

// -----------------------------------------------------------------------------

// CMPXImageUtil::BitmapL

// -----------------------------------------------------------------------------

//

CFbsBitmap* CMPXImageUtil::BitmapL(

    const TDesC8& aBMPData)

    {

    MPX_FUNC( "CMPXImageUtil::BitmapL" );

    CFbsBitmap* bitmap = new ( ELeave ) CFbsBitmap;

    CleanupStack::PushL( bitmap );

    RDesReadStream stream( aBMPData );

    CleanupClosePushL( stream );

    stream >> *bitmap;

    CleanupStack::PopAndDestroy( &stream );

    CleanupStack::Pop( bitmap );

    return bitmap;

    }

// -----------------------------------------------------------------------------

// CMPXImageUtil::BitmapDataL

// -----------------------------------------------------------------------------

//

HBufC8* CMPXImageUtil::BitmapDataL(

    const CFbsBitmap& aBMP)

    {

    MPX_FUNC("CMPXImageUtil::BitmapDataL");

    CBufBase* buffer = CBufSeg::NewL( KMPXBitmapBufferGranularity );

    CleanupStack::PushL( buffer );

    RBufWriteStream stream( *buffer );

    CleanupClosePushL( stream );

    stream << aBMP;

    stream.CommitL();

    CleanupStack::PopAndDestroy( &stream );

    TInt length( buffer->Size() );

    HBufC8* data = HBufC8::NewL( length );

    TPtr8 ptr( data->Des() );

    buffer->Read( 0, ptr, length );

    CleanupStack::PopAndDestroy( buffer );

    return data;

    }

// -----------------------------------------------------------------------------

// CMPXImageUtil::CancelRequest

// Cancel Asynch requests

// -----------------------------------------------------------------------------

//

void CMPXImageUtil::CancelRequest()

    {

    MPX_FUNC( "CMPXImageUtil::CancelRequest" );

    switch ( iOperation )

        {

        case EDecoding:

            {

            if( iDecoder )

                {

                iDecoder->Cancel();

                delete iDecoder;

                iDecoder = NULL;

                }

            break;

            }

        case EEncoding:

            {

            if( iEncoder )

                {

                iEncoder->Cancel();

                delete iEncoder;

                iEncoder = NULL;

                }

            break;

            }

        case EScaling:

            {

            if( iScaler )

                {

                iScaler->Cancel();

                }

            break;

            }

        default: 

            {

            // No Asynchronous events are taking place, do nothing.

            break;

            }

        }

    }

// -----------------------------------------------------------------------------

// CMPXImageUtil::DoDecodeL

// -----------------------------------------------------------------------------

//

void CMPXImageUtil::DoDecodeL(

    TRequestStatus& aStatus, 

    const TDesC& aSourceJPGFile, 

    CFbsBitmap& aDestBMP, 

    TSize aSize,    

    TDisplayMode aDisplayMode /* = EColor64K */)

    {

    MPX_FUNC( "CMPXImageUtil::DoDecodeL" );

    delete iDecoder; 

    iDecoder = NULL;

    // create the decoder

    iDecoder = CImageDecoder::FileNewL( iFs, aSourceJPGFile );

    // Get image size

    const TFrameInfo& frameInfo = iDecoder->FrameInfo();

    TSize bitmapSize = frameInfo.iOverallSizeInPixels;

    bitmapSize = OptimalLoadingSize( bitmapSize, aSize );

    User::LeaveIfError( aDestBMP.Create( bitmapSize, aDisplayMode ) ); 

    // start conversion to bitmap

    iOperation = EDecoding;

    iDecoder->Convert( &aStatus, aDestBMP );

    }

// -----------------------------------------------------------------------------

// CMPXImageUtil::DoDecodeL

// -----------------------------------------------------------------------------

//

void CMPXImageUtil::DoDecodeL(

    TRequestStatus& aStatus, 

    const TDesC8& aSourceJPG, 

    CFbsBitmap& aDestBMP,     

    TSize aSize,    

    TDisplayMode aDisplayMode /* = EColor64K */)

    {

    MPX_FUNC( "CMPXImageUtil::DoDecodeL" );

    delete iDecoder; 

    iDecoder = NULL;

    // create the decoder

    iDecoder = CImageDecoder::DataNewL( iFs, aSourceJPG );

    // Get image size

    const TFrameInfo& frameInfo = iDecoder->FrameInfo();

    TSize bitmapSize = frameInfo.iOverallSizeInPixels;

    bitmapSize = OptimalLoadingSize( bitmapSize, aSize );

    // create the destination bitmap

    User::LeaveIfError( aDestBMP.Create( bitmapSize, aDisplayMode ) ); 

    // start conversion to bitmap

    iOperation = EDecoding;

    iDecoder->Convert( &aStatus, aDestBMP );

    }

// -----------------------------------------------------------------------------

// CMPXImageUtil::DoEncodeL

// -----------------------------------------------------------------------------

//

void CMPXImageUtil::DoEncodeL(

    TRequestStatus& aStatus, 

    const CFbsBitmap& aSourceBMP, 

    HBufC8*& aDestJPG)

    {

    MPX_FUNC( "CMPXImageUtil::DoEncodeL" );

    // Encode as JPEG

    delete iEncoder;

    iEncoder = NULL;

    iEncoder = CImageEncoder::DataNewL(

        aDestJPG, CImageEncoder::EOptionNone, KImageTypeJPGUid );

    iOperation = EEncoding;

    iEncoder->Convert( &aStatus, aSourceBMP );        

    }

// -----------------------------------------------------------------------------

// CMPXImageUtil::DoScaleL

// -----------------------------------------------------------------------------

//

void CMPXImageUtil::DoScaleL(

    TRequestStatus& aStatus, 

    CFbsBitmap& aSourceBMP, 

    CFbsBitmap& aDestBMP,

    TSize aSize, 

    TDisplayMode aDisplayMode /* = EColor64K */)

    {

    MPX_FUNC( "CMPXImageUtil::DoScaleL" );

    // create the destination bitmap

    User::LeaveIfError( aDestBMP.Create( aSize, aDisplayMode ) );

    // if TBool aMaintainAspectRatio = ETrue, then the image may not have be

    // 95x95.  If TBool aMaintainAspectRatio = EFalse, the image may appear

    // to be stretched, as the aspect ratio is not maintained.

    iOperation = EScaling;

    iScaler->Scale( &aStatus, aSourceBMP, aDestBMP, ETrue );

    }

// -----------------------------------------------------------------------------

// Determines optimum loading size for the bitmap.

// -----------------------------------------------------------------------------

TSize CMPXImageUtil::OptimalLoadingSize(

    const TSize& aOriginalSize,

    const TSize& aNeededSize )

    {

    TSize size = AdjustSize( aOriginalSize, aNeededSize );

    // Find max scaling factor which won't make image smaller than target size

    TInt shift = 3;

    while (shift && ( ( aOriginalSize.iWidth >> shift ) < size.iWidth || 

        ( aOriginalSize.iHeight >> shift ) < size.iHeight ) )

        {

        shift--;

        }

    TInt round = ( 1 << shift ) - 1;  // Used to "round up" the scaled values

    TSize loadSize( ( aOriginalSize.iWidth + round ) >> shift,

        ( aOriginalSize.iHeight + round ) >> shift );

    return loadSize;

    }

// -----------------------------------------------------------------------------

// CMPXImageUtil::AdjustSize

// -----------------------------------------------------------------------------

//

TSize CMPXImageUtil::AdjustSize(

    const TSize& aSourceSize,

    const TSize& aTargetSize )

    {

    TSize size( aTargetSize );

    if ( aTargetSize.iHeight * aSourceSize.iWidth < 

        aTargetSize.iWidth * aSourceSize.iHeight )

        {

        // Source has taller aspect than target so reduce target width

        size.iWidth = ( aTargetSize.iHeight * aSourceSize.iWidth ) / 

            aSourceSize.iHeight;

        }

    else

        {

        // Source has wider aspect than target so reduce target height

        size.iHeight = ( aTargetSize.iWidth * aSourceSize.iHeight ) / 

            aSourceSize.iWidth;

        }

    return size;        

    }

//  End of File