/*

* Copyright (c) 2008 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:  Image metadata resolver class in Memory manager component

*

*/

#include <e32std.h>

#include <ExifModify.h>

#include <ExifTag.h> 

#include <exifutility.h>

#include <ExifRead.h> 

#include "msdebug.h"

#include "cmmmimagemetadataresolver.h"

const TUint16 KIdFNumber = 0x829D;

const TUint16 KIdFocalLength = 0x920A;

const TUint16 KIdFocalLength35mmFilm = 0xA405;

const TUint16 KIdFocalPlaneResolutionUnit = 0xA210;

const TUint16 KIdFocalPlaneXResolution = 0xA20E;

const TUint16 KIdFocalPlaneYResolution = 0xA20F;

const TUint32 KDefaultPixelsPerResolutionUnitNumerator = 99;

const TUint32 KDefaultPixelsPerResolutionUnitDenominator = 66;

const TUint16 KDefaultYCbCrPositioningCentered = 1;

const TUint16 KDefaultColorSpace_sRGB = 1;

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

// CCmMmImageMetadataResolver::NewL

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

//

CCmMmImageMetadataResolver* CCmMmImageMetadataResolver::NewL( 

    RFs& aFileSession )

    {

    LOG(_L("[MEMORY MNGR]\t CCmMmImageMetadataResolver::NewL() start"));

    CCmMmImageMetadataResolver* self = 

        CCmMmImageMetadataResolver::NewLC( aFileSession );

    CleanupStack::Pop( self );

    LOG(_L("[MEMORY MNGR]\t CCmMmImageMetadataResolver::NewL() end"));

    return self;

    }

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

// CCmMmImageMetadataResolver::NewLC

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

//

CCmMmImageMetadataResolver* CCmMmImageMetadataResolver::NewLC( 

    RFs& aFileSession )

    {

    LOG(_L("[MEMORY MNGR]\t CCmMmImageMetadataResolver::NewLC() start"));

    CCmMmImageMetadataResolver* self = 

        new ( ELeave ) CCmMmImageMetadataResolver( aFileSession );

    CleanupStack::PushL( self );

    self->ConstructL();

    LOG(_L("[MEMORY MNGR]\t CCmMmImageMetadataResolver::NewLC() end"));

    return self;

    }

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

// C++ destructor

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

//

CCmMmImageMetadataResolver::~CCmMmImageMetadataResolver()

    {

    LOG(_L("[MEMORY MNGR]\t CCmMmImageMetadataResolver::~CCmMmImageMetadataResolver() start"));

    delete iExifOrig;

    LOG(_L("[MEMORY MNGR]\t CCmMmImageMetadataResolver::~CCmMmImageMetadataResolver() end"));

    }

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

// CCmMmImageMetadataResolver::CaptureOrginalMetadataL

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

//

void CCmMmImageMetadataResolver::CaptureOrginalMetadataL( 

    const TDesC& aOrigFileName )

    {

    RFile orig;

    User::LeaveIfError( orig.Open( iFileSession, aOrigFileName, EFileRead ) );    

    CleanupClosePushL( orig );        

    TInt size = 0;

    orig.Size(size);

    delete iExifOrig;

    iExifOrig = NULL;

    iExifOrig = HBufC8::NewL( size );

    TPtr8 bufferDes( iExifOrig->Des() );

    User::LeaveIfError( orig.Read( bufferDes ) );

    CleanupStack::PopAndDestroy();    

    }

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

// CCmMmImageMetadataResolver::ResolveMetadataL

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

//

void CCmMmImageMetadataResolver::ResolveMetadataL(

    const TDesC& aShrinkedFileName )

    {

    RFile shrinked;

    User::LeaveIfError( 

        shrinked.Open( iFileSession, aShrinkedFileName, EFileRead|EFileWrite ) );

    CleanupClosePushL( shrinked );         

    // 1. Read Exif image from the file to a buffer...

    TInt sizeS = 0;

    shrinked.Size(sizeS);

    HBufC8* exifShrinked = HBufC8::NewL( sizeS );

    CleanupStack::PushL( exifShrinked );

    TPtr8 bufferDesS( exifShrinked->Des() );

    User::LeaveIfError( shrinked.Read( bufferDesS ) );

    CExifModify* modify = NULL;

    CExifRead* read = NULL;

    TRAPD( err1, read = CExifRead::NewL( iExifOrig->Des() ) );

    User::LeaveIfError( err1 );

    // 2. Instantiate Exif modifier in EModify mode...

    TRAPD( err, modify = CExifModify::NewL( exifShrinked->Des() ) );

    if(err == KErrCorrupt)

        {

        modify = CExifModify::NewL( exifShrinked->Des(), CExifModify::ECreate );

        }

    CleanupStack::PushL(modify);

    // If exif info fails, there is nothing we can do

    TRAP_IGNORE( FillExifL( *read, *modify ) );         

    // 4. Get the modified Exif image...

    // If zero length descriptor is given instead of exif->Des(), then only the

    // Exif meta data is returned

    TInt pos = 0;

    User::LeaveIfError( shrinked.Seek( ESeekStart, pos ) );    

    HBufC8* modifiedExif = NULL;

    TRAPD( err2, modifiedExif = modify->WriteDataL( exifShrinked->Des() ) );

    /* Process the modified Exif data */

    if( modifiedExif && !err2 )

        {

        shrinked.Write( *modifiedExif, modifiedExif->Des().Length() );

        }    

    delete modifiedExif;

    modifiedExif = NULL;

    // 5. Delete the modifier instance...

    CleanupStack::PopAndDestroy( modify );

    CleanupStack::PopAndDestroy( exifShrinked );

    CleanupStack::PopAndDestroy(); 

    delete iExifOrig;

    iExifOrig = NULL; 

    }

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

// C++ constructor

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

//

CCmMmImageMetadataResolver::CCmMmImageMetadataResolver( RFs& aFileSession ) 

    : iFileSession( aFileSession )

    {

    LOG(_L("[MEMORY MNGR]\t CCmMmImageMetadataResolver::CCmMmImageMetadataResolver() start"));

    LOG(_L("[MEMORY MNGR]\t CCmMmImageMetadataResolver::CCmMmImageMetadataResolver() end"));

    }

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

// CCmMmImageMetadataResolver::ConstructL

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

//

void CCmMmImageMetadataResolver::ConstructL()

    {

    LOG(_L("[MEMORY MNGR]\t CCmMmImageMetadataResolver::ConstructL() start"));

    LOG(_L("[MEMORY MNGR]\t CCmMmImageMetadataResolver::ConstructL() end"));

    }

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

// CCmMmImageMetadataResolver::FillExifL

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

//

void CCmMmImageMetadataResolver::FillExifL( CExifRead& aRead, CExifModify& aModify )

    {    

    TRAP_IGNORE( aModify.SetImageDescriptionL( *aRead.GetImageDescriptionL() ) );

    TRAP_IGNORE( aModify.SetMakeL( *aRead.GetMakeL() ) );

    TRAP_IGNORE( aModify.SetModelL( *aRead.GetModelL() ) ); 

    TRAP_IGNORE( aModify.SetThumbnailL( *aRead.GetThumbnailL() ) );

    TRAP_IGNORE( aModify.SetTransferFunctionL( *aRead.GetTransferFunctionL() ) );

    TRAP_IGNORE( aModify.SetDateTimeL( *aRead.GetDateTimeL() ) );         

    TRAP_IGNORE( aModify.SetSoftwareL( *aRead.GetSoftwareL() ) );

    TRAP_IGNORE( aModify.SetCopyrightL( *aRead.GetCopyrightL() ) );

    aModify.SetXResolutionL(

        KDefaultPixelsPerResolutionUnitNumerator,

        KDefaultPixelsPerResolutionUnitDenominator );

    aModify.SetYResolutionL( 

        KDefaultPixelsPerResolutionUnitNumerator, 

        KDefaultPixelsPerResolutionUnitDenominator );

    aModify.SetYCbCrPositioningL( KDefaultYCbCrPositioningCentered );

    aModify.SetColorSpaceL( KDefaultColorSpace_sRGB );

    TUint32 uint32Value = 0;

    TUint16 uint16Value = 0;

    HBufC8* textValue = NULL;

    const CExifTag* exifTagInfo = NULL;

    TInt exifError( KErrNone );

    exifError = aRead.GetPixelXDimension( uint32Value );

    if( exifError == KErrNone )

        { 

        TRAP_IGNORE( aModify.SetPixelXDimensionL( uint32Value ) );

        }

    exifError = aRead.GetPixelYDimension( uint32Value );

    if( exifError == KErrNone )

        { 

        TRAP_IGNORE( aModify.SetPixelYDimensionL( uint32Value ) );

        }

    exifError = aRead.GetWhiteBalance( uint16Value );

    if( exifError == KErrNone )

        {

        aModify.SetWhiteBalanceL( uint16Value );

        }

    exifError = aRead.GetFlash( uint16Value );

    if( exifError == KErrNone )

        {

        aModify.SetFlashL( uint16Value );        

        }

    exifError = aRead.GetExposureProgram( uint16Value );

    if( exifError == KErrNone )

        {

        aModify.SetExposureProgramL( uint16Value );

        }

    TRAP( exifError, textValue = aRead.GetUserCommentL() );

    if ( exifError == KErrNone )

        {

        aModify.SetUserCommentL( *textValue );

        }

    TRAP( exifError, textValue = aRead.GetDateTimeOriginalL() );

    if ( exifError == KErrNone )

        {

        aModify.SetDateTimeOriginalL( *textValue );

        }

    TRAP( exifError, textValue = aRead.GetDateTimeDigitizedL() );

    if ( exifError == KErrNone )

        {

        aModify.SetDateTimeDigitizedL( *textValue );

        }

    exifError = aRead.GetOrientation( uint16Value );

    if ( exifError == KErrNone )

        {

        aModify.SetOrientationL( uint16Value );

        }

    exifError = aRead.GetYCbCrPositioning( uint16Value );

    if ( exifError == KErrNone )

        {

        aModify.SetYCbCrPositioningL( uint16Value );

        }

    exifError = aRead.GetResolutionUnit( uint16Value );

    if ( exifError == KErrNone )

        {

        aModify.SetResolutionUnitL( uint16Value );

        }

    TRAP( exifError, textValue = aRead.GetIsoSpeedRatingsL() );

    if ( exifError == KErrNone )

        {

        aModify.SetIsoSpeedRatingsL( *textValue );

        }

    TRAP( exifError, textValue = aRead.GetRelatedSoundFileL() );

    if ( exifError == KErrNone )

        {

        aModify.SetRelatedSoundFileL( *textValue );

        }

    TUint32 exifDenominator = 0;

    exifError = aRead.GetExposureTime( uint32Value, exifDenominator );

    if ( exifError == KErrNone )

        {

        aModify.SetExposureTimeL( uint32Value, exifDenominator );

        }

    exifDenominator = 0;

    exifError = aRead.GetApertureValue( uint32Value, exifDenominator );

    if ( exifError == KErrNone )

        {

        aModify.SetApertureValueL( uint32Value, exifDenominator );

        }        

    exifError = aRead.GetColorSpace( uint16Value );

    if ( exifError == KErrNone )

        {

        aModify.SetColorSpaceL( uint16Value );

        }

    TInt32 exifExposureB = 0;

    TInt32 exifDenominatorB = 0;

    exifError = aRead.GetExposureBiasValue( exifExposureB, exifDenominatorB );

    if ( exifError == KErrNone )

        {

        aModify.SetExposureBiasValueL( exifExposureB, exifDenominatorB );

        }

    exifError = aRead.GetMeteringMode( uint16Value );

    if ( exifError == KErrNone )

        {               

        aModify.SetMeteringModeL( uint16Value );

        }

    exifDenominator = 0;

    exifError = aRead.GetThumbnailXResolution( uint32Value, exifDenominator );

    if ( exifError == KErrNone )

        {        

        aModify.SetThumbnailXResolutionL( uint32Value, exifDenominator );

        }

    exifDenominator = 0;

    exifError = aRead.GetThumbnailYResolution( uint32Value, exifDenominator );

    if ( exifError == KErrNone )

        {        

        aModify.SetThumbnailYResolutionL( uint32Value, exifDenominator );

        } 

    exifError = aRead.GetThumbnailResolutionUnit( uint16Value );

    if ( exifError == KErrNone )

        {

        aModify.SetThumbnailResolutionUnitL( uint16Value );

        }

    TInt32 exifShutterSpeedValue = 0;

    TInt32 exifDenominatorS = 0;

    exifError = aRead.GetShutterSpeedValue( exifShutterSpeedValue, exifDenominatorS );

    if ( exifError == KErrNone )

        {

        aModify.SetShutterSpeedValueL( exifShutterSpeedValue, exifDenominatorS );

        }

    TUint8 exifComponent4th( 0 );

    TUint8 exifComponent3rd( 0 );

    TUint8 exifComponent2nd( 0 );

    TUint8 exifComponent1st( 0 );

    exifError = aRead.GetComponentsConfiguration(

    		exifComponent1st, exifComponent2nd, exifComponent3rd, exifComponent4th );

    if ( exifError == KErrNone )

        {

        aModify.SetComponentsConfigurationL(

        		exifComponent1st, exifComponent2nd, 

        		exifComponent3rd, exifComponent4th );

        }

    TRAP( exifError, exifTagInfo = aRead.GetTagL( EIfdExif, KIdFNumber ) );

    if ( exifError == KErrNone )

        {

        TPtrC8 exifFNumberBuf( exifTagInfo->Data() );

        TExifTagInfo tagInfo( KIdFNumber, CExifTag::ETagRational, 1 );

        aModify.SetTagL( EIfdExif, tagInfo, exifFNumberBuf );

        }

    TRAP( exifError, exifTagInfo = aRead.GetTagL( EIfdExif, KIdFocalLength ) );

    if ( exifError == KErrNone )

        {

        TPtrC8 exifFocalLengthBuf( exifTagInfo->Data() );

        TExifTagInfo tagInfo( KIdFocalLength, CExifTag::ETagRational, 1 );

        TRAP_IGNORE( aModify.SetTagL( EIfdExif, tagInfo, exifFocalLengthBuf ) );

        }

    TRAP( exifError, exifTagInfo = aRead.GetTagL( EIfdExif, KIdFocalLength35mmFilm ) );

    if ( exifError == KErrNone )

        {

        TPtrC8 exifFocal35mmBuf( exifTagInfo->Data() );

        TExifTagInfo tagInfo( KIdFocalLength35mmFilm, CExifTag::ETagRational, 1 );

        TRAP_IGNORE( aModify.SetTagL( EIfdExif, tagInfo, exifFocal35mmBuf ) );

        }                

    TRAP( exifError, exifTagInfo = aRead.GetTagL( EIfdExif, KIdFocalPlaneResolutionUnit ) );

    if ( exifError == KErrNone )

        {

        TPtrC8 exifFocalPlaneResolutionUnitBuf( exifTagInfo->Data() );

        TExifTagInfo tagInfo( KIdFocalPlaneResolutionUnit, CExifTag::ETagShort, 1 );

        TRAP_IGNORE( aModify.SetTagL( EIfdExif, tagInfo, exifFocalPlaneResolutionUnitBuf ) );

        }        

    TRAP( exifError, exifTagInfo = aRead.GetTagL( EIfdExif, KIdFocalPlaneXResolution ) );

    if ( exifError == KErrNone )

        {

        TPtrC8 exifFocalPlaneXResBuf( exifTagInfo->Data() );

        TExifTagInfo tagInfo( KIdFocalPlaneXResolution, CExifTag::ETagRational, 1 );

        TRAP_IGNORE( aModify.SetTagL( EIfdExif, tagInfo, exifFocalPlaneXResBuf ) );

        }

    TRAP( exifError, exifTagInfo = aRead.GetTagL( EIfdExif, KIdFocalPlaneYResolution ) );

    if ( exifError == KErrNone )

        {

        TPtrC8 exifFocalPlaneYResBuf( exifTagInfo->Data() );

        TExifTagInfo tagInfo( KIdFocalPlaneYResolution, CExifTag::ETagRational, 1 );

        TRAP_IGNORE( aModify.SetTagL( EIfdExif, tagInfo, exifFocalPlaneYResBuf ) );

        }

    exifError = aRead.GetLightSource( uint16Value );

    if ( exifError == KErrNone )

        {

        TRAP_IGNORE( aModify.SetLightSourceL( uint16Value ) );

        }

    }

// End of file