/*

* Copyright (c) 2003, 2004 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:  The core service class for handling Exif v2.2 File Format.

*

*/

// INCLUDE FILES

#include "ExifIfd.h"

#include "ExifCore.h"

#include "ExifReadImpl.h"

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

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

// CExifCore::CExifCore

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CExifCore::CExifCore()

    {

    }

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

// CExifCore::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CExifCore::ConstructL()

    {

    CreateIfdL( EIfd0 );

    CreateIfdL( EIfdExif);

    }

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

// CExifCore::NewL

// Two-phased constructor.

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

//

CExifCore* CExifCore::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();    

    return self;

    }

// Destructor

CExifCore::~CExifCore()

    {

    for ( TUint i = 0; i < KIfdNo; ++i )

        {

        if ( iIfdArray[i] )

            {

            delete iIfdArray[i];

            }

        }

    }

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

// CExifCore::InsertTagL

// Inserts the given tag into the specified IFD structure.

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

//

void CExifCore::InsertTagL( TExifIfdType aIfdType, CExifTagImpl* aExifTag, TBool aCheckValidity )

    {

    LOGTEXT3( _L( "ExifLib: CExifCore::InsertTagL() entering: aIfdType=0x%x, aCheckValidity=%d" ), aIfdType, aCheckValidity);

    switch ( aIfdType )

        {

        case EIfd0:

        case EIfdExif:

        case EIfd1:

        case EIfdGps:

        case EIfdIntOp:

            if ( aCheckValidity && ( !TagIsValid( aExifTag->TagInfo(), aIfdType ) ) )

                {

                LOGTEXT( _L( "ExifLib: CExifCore::InsertTagL() Leaving: KErrNotSupported" ));

                User::Leave( KErrNotSupported );

                }

            if ( !iIfdArray[aIfdType] )

                {

                // Since a new IFD should be created, 6 bytes more than tag

                // size is required. 

                // Check if it exceeds 64K bytes after insertion.

                if ( App1Size() + aExifTag->Size() + 6 > KMaxApp1Size )

                    {

                    LOGTEXT( _L( "ExifLib: CExifCore::InsertTagL() Leaving: KErrOverflow (>KMaxApp1Size)1" ));

                    User::Leave( KErrOverflow );

                    }

                CreateIfdL( aIfdType ); 

                TRAPD( error, iIfdArray[aIfdType]->InsertTagL( aExifTag, aCheckValidity ) );

                if ( error != KErrNone )

                    {

                    delete( iIfdArray[aIfdType] );

                    iIfdArray[aIfdType] = 0;

                    LOGTEXT2( _L( "ExifLib: CExifCore::InsertTagL() Leaving: error=%d" ), error );

                    User::Leave( error );

                    }

                }

            else

                {

                // Check if it exceeds 64K bytes after insertion.

                if ( !( TagExists( aExifTag->Id(), aIfdType ) ) && 

                    ( App1Size() + aExifTag->Size() > KMaxApp1Size ) )

                    {

                    LOGTEXT( _L( "ExifLib: CExifCore::InsertTagL() Leaving: KErrOverflow (>KMaxApp1Size)2" ));

                    User::Leave( KErrOverflow );

                    }

                iIfdArray[aIfdType]->InsertTagL( aExifTag, aCheckValidity );

                }

            break;

        default:

            {

            LOGTEXT( _L( "ExifLib: CExifCore::InsertTagL() Leaving: KErrArgument" ));

            User::Leave( KErrArgument );

            }

        }

    }

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

// CExifCore::SetTagDataL

// Sets the given 8-bit integer to the data of tag specified by the given tag ID

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

//

void CExifCore::SetTagDataL( TUint16 aTagId, TInt8 aTagData )

    {

    CExifTag::TExifTagDataType tagType = CExifTag::ETagUndefined;

    // Total tag data size = 1 bytes.

    TUint32 tagCount = 1;

    TExifIfdType ifdType = EIfdExif;

    HBufC8* buffer = HBufC8::NewL( 1 );

    CleanupStack::PushL( buffer );

    buffer->Des().SetLength( 1 );

    switch ( aTagId )

        {

        case KIdFileSource:

            break;

        default:

            {

            LOGTEXT2( _L( "ExifLib: CExifCore::SetTagDataL() Leave( KErrNotSupported ) aTagId=0x%x" ), aTagId);

            User::Leave( KErrNotSupported );

            }

        }

    *REINTERPRET_CAST( TInt8*, CONST_CAST( TUint8*, buffer->Ptr() ) ) 

        = aTagData;

    CExifTagImpl* tag = CExifTagImpl::NewL( aTagId, tagType, tagCount, buffer, ETrue );

    CleanupStack::Pop( buffer );

    CleanupStack::PushL( tag );

    InsertTagL( ifdType, tag, ETrue );

    CleanupStack::Pop();

    }

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

// CExifCore::SetTagDataL

// Sets the given 16-bit unsigned integer to the data of a tag specified by the 

// given tag ID.

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

//

void CExifCore::SetTagDataL( TUint16 aTagId, TUint16 aTagData )

    {

    CExifTag::TExifTagDataType tagType = CExifTag::ETagShort;

    // Total tag data size = 2 bytes.

    // Since tag data type is 2-byte type, tagCount = 1.

    TUint32 tagCount = 1;

    TExifIfdType ifdType = EIfdExif;

    HBufC8* buffer = HBufC8::NewL( 2 );

    buffer->Des().SetLength( 2 );

    CleanupStack::PushL( buffer );

    switch ( aTagId )

        {

        case KIdCompression:

        case KIdOrientation:

        case KIdResolutionUnit:

        case KIdYCbCrPositioning:

            ifdType = EIfd0;

            break;

        case KIdFlash:

        case KIdColorSpace:

        case KIdExposureMode:

        case KIdWhiteBalance:

        case KIdSceneCaptureType:

        case KIdExposureProgram:

        case KIdMeteringMode:

        case KIdLightSource:

        case KIdContrast:

        case KIdSaturation:

        case KIdSharpness:

        case KIdCustomRendered:

        case KIdGainControl:

            break;

        default:

            {

            LOGTEXT2( _L( "ExifLib: CExifCore::SetTagDataL() Leave( KErrNotSupported ) 16 aTagId=0x%x" ), aTagId);

            User::Leave( KErrNotSupported );

            }

        }

    TExifCommon::SetUint16( CONST_CAST( TUint8*, buffer->Ptr() ), aTagData );

    CExifTagImpl* tag = CExifTagImpl::NewL( aTagId, tagType, tagCount, buffer, ETrue );

    CleanupStack::Pop( buffer );

    CleanupStack::PushL( tag );

    InsertTagL( ifdType, tag, ETrue );

    CleanupStack::Pop();

    }

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

// CExifCore::SetTagDataL

// Sets the given 32-bit integer to the data of tag specified by given tag ID

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

//

void CExifCore::SetTagDataL( TUint16 aTagId, TUint32 aTagData )

    {

    CExifTag::TExifTagDataType tagType = CExifTag::ETagLong;

    // Total tag data size = 4 bytes.

    // If the tag data type is one of 4-byte types, tagCount = 1.

    // If the tag data type is one of 1-byte types, tagCount = 4.

    TUint32 tagCount = 1;

    TExifIfdType ifdType = EIfdExif;

    HBufC8* buffer = HBufC8::NewL(4 ); 

    buffer->Des().SetLength(4 );

    CleanupStack::PushL( buffer );

    switch ( aTagId )

        {

        case KIdExifIfdPointer:

        case KIdGpsIfdPointer:

            ifdType = EIfd0;

            break;

        case KIdIntOpIfdPointer:

        case KIdPixelXDimension:

        case KIdPixelYDimension:

            break;

        case KIdComponentsConfiguration:

        case KIdExifVersion:

        case KIdFlashPixVersion:

            tagType = CExifTag::ETagUndefined;

            tagCount = 4;

            break;

        case KIdGpsVersion:

            tagType = CExifTag::ETagByte;

            tagCount = 4;

            ifdType = EIfdGps;

            break;

        default:

            {

            LOGTEXT2( _L( "ExifLib: CExifCore::SetTagDataL() Leave( KErrNotSupported ) 32 aTagId=0x%x" ), aTagId);

            User::Leave( KErrNotSupported );

            }

        }

    TExifCommon::SetUint32( CONST_CAST( TUint8*, buffer->Ptr() ), aTagData );

    CExifTagImpl* tag = CExifTagImpl::NewL( aTagId, tagType, tagCount, buffer, ETrue );

    CleanupStack::Pop( buffer );

    CleanupStack::PushL( tag );

    InsertTagL( ifdType, tag, ETrue );

    CleanupStack::Pop();

    }

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

// CExifCore::SetTagDataL

// Sets the given data buffer to the data of a tag specified by the given tag ID

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

//

void CExifCore::SetTagDataL( TUint16 aTagId, const TDesC8& aTagData )

    {

    if ( !aTagData.Length() )

        {

        User::Leave( KErrArgument );

        }

    CExifTag::TExifTagDataType tagType = CExifTag::ETagAscii;

    TUint32 tagCount = aTagData.Length();

    TExifIfdType ifdType = EIfd0;

    switch ( aTagId )

        {

        case KIdImageDescription:

        case KIdMake:

        case KIdModel:

        case KIdSoftware:

        case KIdCopyright:

            break;

        case KIdTransferFunction:

            tagType = CExifTag::ETagShort;

            tagCount /= 2;

            break;

        case KIdDateTime:

            break;

        case KIdIsoSpeedRatings:

            tagType = CExifTag::ETagShort;

            tagCount /= 2;

            ifdType = EIfdExif;

            break;

        case KIdDateTimeOriginal:

        case KIdDateTimeDigitized:

        case KIdRelatedSoundFile:

            ifdType = EIfdExif;

            break;

        case KIdMakerNote:

        case KIdUserComment:

            tagType = CExifTag::ETagUndefined;

            ifdType = EIfdExif;

            break;

        default:

            {

            LOGTEXT2( _L( "ExifLib: CExifCore::SetTagDataL() Leave( KErrNotSupported ) C8 aTagId=0x%x" ), aTagId);

            User::Leave( KErrNotSupported );

            }

        }

    // Check if ASCII string terminates with NULL character.

    // If not add NULL.

    HBufC8* buffer = NULL;

    if ( ( tagType == CExifTag::ETagAscii ) && 

        ( aTagData.Ptr()[aTagData.Length() - 1] ) )

        {

        ++tagCount;

        buffer = HBufC8::NewL( aTagData.Length() + 1 );

        buffer->Des().Copy( aTagData );

        *( CONST_CAST( TUint8*, buffer->Des().Ptr() ) + 

            aTagData.Length() ) = NULL;

        buffer->Des().SetLength( aTagData.Length() + 1 );

        }

    else

        {

        buffer = aTagData.AllocL();

        }

    CleanupStack::PushL( buffer );

    CExifTagImpl* tag = CExifTagImpl::NewL( aTagId, tagType, tagCount, buffer, ETrue );

    CleanupStack::Pop();

    CleanupStack::PushL( tag );

    InsertTagL( ifdType, tag, ETrue );

    CleanupStack::Pop();

    }

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

// CExifCore::SetTagDataL

// Sets the given 64-bit (2 x 32-bit ) unsigned integers to the data of a tag 

// specified by the given tag ID.

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

//

void CExifCore::SetTagDataL( 

    TUint16 aTagId, 

    TUint32 aNumerator, 

    TUint32 aDenominator )

    {

    CExifTag::TExifTagDataType tagType = CExifTag::ETagRational;

    // Total tag data size = 8 bytes.

    // Since tag data type is 8-byte type, tagCount = 1.

    TUint32 tagCount = 1;

    TExifIfdType ifdType = EIfd0;

    HBufC8* buffer = HBufC8::NewL( 8 );

    buffer->Des().SetLength( 8 );

    CleanupStack::PushL( buffer );

    switch ( aTagId )

        {

        case KIdXResolution:

        case KIdYResolution:

            break;

        case KIdExposureTime:

        case KIdApertureValue:

        case KIdDigitalZoomRatio:

            ifdType = EIfdExif;

            break;

        default:

            User::Leave( KErrNotSupported );

        }

    TExifCommon::SetUint32( CONST_CAST( TUint8*, buffer->Ptr() ), aNumerator );

    TExifCommon::SetUint32( 

        CONST_CAST( TUint8*, buffer->Ptr() + 4 ), aDenominator );

    CExifTagImpl* tag = CExifTagImpl::NewL( aTagId, tagType, tagCount, buffer, ETrue );

    CleanupStack::Pop( buffer );

    CleanupStack::PushL( tag );

    InsertTagL( ifdType, tag, ETrue );

    CleanupStack::Pop();

    }

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

// CExifCore::SetTagDataL

// Sets the given 64-bit (2 x 32-bit ) integers to the data of a tag specified 

// by the given tag ID.

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

//

void CExifCore::SetTagDataL( 

    TUint16 aTagId, 

    TInt32 aNumerator, 

    TInt32 aDenominator )

    {

    CExifTag::TExifTagDataType tagType = CExifTag::ETagSrational;

    // Total tag data size = 8 bytes.

    // Since tag data type is 8-byte type, tagCount = 1.

    TUint32 tagCount = 1;

    TExifIfdType ifdType = EIfdExif;

    HBufC8* buffer = HBufC8::NewL( 8 );

    buffer->Des().SetLength( 8 );

    CleanupStack::PushL( buffer );

    switch ( aTagId )

        {

        case KIdExposureBiasValue:

        case KIdShutterSpeedValue:

        case KIdBrightnessValue:

            break;

        default:

            User::Leave( KErrNotSupported );

        }

    TExifCommon::SetUint32( CONST_CAST( TUint8*, buffer->Ptr() ), aNumerator );

    TExifCommon::SetUint32( 

        CONST_CAST( TUint8*, buffer->Ptr() + 4 ), aDenominator );

    CExifTagImpl* tag = CExifTagImpl::NewL( aTagId, tagType, tagCount, buffer, ETrue );

    CleanupStack::Pop( buffer );

    CleanupStack::PushL( tag );

    InsertTagL( ifdType, tag, ETrue );

    CleanupStack::Pop();

    }

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

// CExifCore::SetThumbnailTagDataL

// Sets the given 16-bit unsigned integer to the data of a thumbnail (IFD1) tag 

// specified by the given tag ID.

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

//

void CExifCore::SetThumbnailTagDataL( TUint16 aTagId, TUint16 aTagData )

    {

    CExifTag::TExifTagDataType tagType = CExifTag::ETagShort;

    TUint32 tagCount = 1;

    HBufC8* buffer = HBufC8::NewL( 2 );

    buffer->Des().SetLength( 2 );

    CleanupStack::PushL( buffer );

    switch ( aTagId )

        {

        case KIdCompression:

        case KIdResolutionUnit:

            break;

        default:

            User::Leave( KErrNotSupported );

        }

    TExifCommon::SetUint16( CONST_CAST( TUint8*, buffer->Ptr() ), aTagData );

    CExifTagImpl* tag = CExifTagImpl::NewL( aTagId, tagType, tagCount, buffer, ETrue );

    CleanupStack::Pop( buffer );

    CleanupStack::PushL( tag );

    InsertTagL( EIfd1, tag, ETrue );

    CleanupStack::Pop();

    }

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

// CExifCore::SetThumbnailTagDataL

// Sets the given 32-bit unsigned integer to the data of a thumbnail (IFD1) tag 

// specified by the given tag ID,

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

//

void CExifCore::SetThumbnailTagDataL( TUint16 aTagId, TUint32 aTagData )

    {

    CExifTag::TExifTagDataType tagType = CExifTag::ETagLong;

    TUint32 tagCount = 1;

    HBufC8* buffer = HBufC8::NewL( 4 );

    buffer->Des().SetLength( 4 );

    CleanupStack::PushL( buffer );

    switch ( aTagId )

        {

        case KIdJpegInterchangeFormat:

        case KIdJpegInterchangeFormatLength:

            break;

        default:

            User::Leave( KErrNotSupported );

        }

    TExifCommon::SetUint32( CONST_CAST( TUint8*, buffer->Ptr() ), aTagData );

    CExifTagImpl* tag = CExifTagImpl::NewL( aTagId, tagType, tagCount, buffer, ETrue );

    CleanupStack::Pop( buffer );

    CleanupStack::PushL( tag );

    InsertTagL( EIfd1, tag, ETrue );

    CleanupStack::Pop();

    }

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

// CExifCore::SetThumbnailTagDataL

// Sets the given 64-bit (2 x 32-bit ) unsigned integers to the data of a 

// thumbnail (IFD1) tag specified by the given tag ID.

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

//

void CExifCore::SetThumbnailTagDataL( 

    TUint16 aTagId, 

    TUint32 aNumerator, 

    TUint32 aDenominator )

    {

    CExifTag::TExifTagDataType tagType = CExifTag::ETagRational;

    TUint32 tagCount = 1;

    HBufC8* buffer = HBufC8::NewL( 8 );

    buffer->Des().SetLength( 8 );

    CleanupStack::PushL( buffer );

    switch ( aTagId )

        {

        case KIdXResolution:

        case KIdYResolution:

            break;

        default:

            User::Leave( KErrNotSupported );

        }

    TExifCommon::SetUint32( CONST_CAST( TUint8*, buffer->Ptr() ), aNumerator );

    TExifCommon::SetUint32( 

        CONST_CAST( TUint8*, buffer->Ptr() + 4 ), aDenominator );

    CExifTagImpl* tag = CExifTagImpl::NewL( aTagId, tagType, tagCount, buffer, ETrue );

    CleanupStack::Pop( buffer );

    CleanupStack::PushL( tag );

    InsertTagL( EIfd1, tag, ETrue );

    CleanupStack::Pop();

    }

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

// CExifCore::GetTagData

// Gets the 8-bit integer data of a tag specified by the given tag ID.

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

//

TInt CExifCore::GetTagData( TUint16 aTagId, TInt8& aTagData ) const

    {

    TExifIfdType ifdType = EIfdExif;

    switch ( aTagId )

        {

        case KIdFileSource:

            break;