/*

* 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:  Exif v2.2 file format reader/parser API implementation

*

*/

// INCLUDE FILES

#include "ExifReadImpl.h"

#include "ExifCore.h"

#include "ExifEndian.h"

#include "ExifCommon.h"

#include "ExifTagImpl.h"

// ============================ CLASS CExifRead ================================

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

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

// CExifRead::NewL

// Two-phased constructor.

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

//

EXPORT_C CExifRead* CExifRead::NewL( const TDesC8& aExifData )

    {

    return CExifReadImpl::NewL( aExifData, EFalse, CExifRead::ENoOptions );

    }

EXPORT_C CExifRead* CExifRead::NewL( const TDesC8& aExifData, TUint aExifReadOption )

    {

    return CExifReadImpl::NewL( aExifData, EFalse, aExifReadOption );

    }

// Destructor

CExifRead::~CExifRead()

    {

    }

// ============================ CLASS CExifReadImpl ============================

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

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

// CExifReadImpl::CExifReadImpl

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

// might leave.

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

//

CExifReadImpl::CExifReadImpl()

    {

    }

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

// CExifReadImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CExifReadImpl::ConstructL( const TDesC8& aExifData, TBool aCreate, TUint aExifReadOption )

    {

    LOGTEXT3( _L( "ExifLib: CExifReadImpl::ConstructL() entering: aCreate=%x, aExifReadOption=0x%x" ), aCreate, aExifReadOption );

    iExifReadOption = aExifReadOption;

    iExifCore = CExifCore::NewL();

    iReader = CExifEndianBase::NewBaseL( aExifData.Ptr(), aExifData.Length(), 

            !aCreate );

    if ( aCreate )

        {

        ParseJpegDataL();

        }

    else

        {

        ParseExifFormatL();

        if ( !(iExifReadOption & CExifRead::ENoTagChecking ) &&

            !iExifCore->IsValid() )

            {

            LOGTEXT( _L( "ExifLib: CExifReadImpl::ConstructL() Leaving KErrNotSupported" ));

            User::Leave( KErrNotSupported );

            }

        }

    LOGTEXT( _L( "ExifLib: CExifReadImpl::ConstructL() returning" ));

    }

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

// CExifReadImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CExifReadImpl::ConstructL()

    {

    iExifReadOption = CExifRead::ENoOptions;

    iExifCore = CExifCore::NewL();

    }

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

// CExifReadImpl::NewL

// Two-phased constructor.

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

//

CExifReadImpl* CExifReadImpl::NewL( const TDesC8& aExifData, TBool aCreate, TUint aExifReadOption )

    {

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

    CleanupStack::PushL( self ); 

    self->ConstructL( aExifData, aCreate, aExifReadOption );

    CleanupStack::Pop();

    return self;

    }

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

// CExifReadImpl::NewL

// Two-phased constructor.

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

//

CExifReadImpl* CExifReadImpl::NewL()

    {

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

    CleanupStack::PushL( self ); 

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CExifReadImpl::~CExifReadImpl()

    {

    LOGTEXT( _L( "ExifLib: CExifReadImpl::~CExifReadImpl() entering" ) );

    if ( iExifCore )

        {

        delete iExifCore;

        }

    if ( iReader )

        {

        delete iReader;

        }

    LOGTEXT( _L( "ExifLib: CExifReadImpl::~CExifReadImpl() returning" ) );

    }

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

// CExifReadImpl::GetTagL

// Returns the Tag instance that has the specified tag ID from the requested IFD

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

//

const CExifTag* CExifReadImpl::GetTagL( 

    const TExifIfdType aIfdType, 

    const TUint16 aTagId ) const

    {

    if ( !iExifCore )

        {

        User::Leave( KErrGeneral );

        }

    if ( !TExifCommon::IsValidTagId( aTagId ) )

        {

        LOGTEXT( _L( "ExifLib: CExifReadImpl::GetTagL Leave( KErrNotSupported )" ) );

        User::Leave( KErrNotSupported );

        }

    return iExifCore->GetTagL( aIfdType, aTagId );

    }

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

// CExifReadImpl::GetTagIdsL

// Returns the IDs of all the tags that are stored in the Exif data.

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

//

TUint16* CExifReadImpl::GetTagIdsL( 

    const TExifIfdType aIfdType, 

    TInt& aNoTags ) const

    {

    if ( !iExifCore )

        {

        LOGTEXT( _L( "ExifLib: CExifReadImpl::GetTagIdsL Leave( KErrGeneral )" ) );

        User::Leave( KErrGeneral );

        }

    return iExifCore->GetTagIdsL( aIfdType, aNoTags );

    }

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

// CExifReadImpl::GetIfdTypesL

// Returns the types of the IFDs stored in the Exif data.

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

//

TExifIfdType* CExifReadImpl::GetIfdTypesL( TInt& aNoIfd ) const

    {

    if ( !iExifCore )

        {

        LOGTEXT( _L( "ExifLib: CExifReadImpl::GetIfdTypesL Leave( KErrGeneral )" ) );

        User::Leave( KErrGeneral );

        }

    return iExifCore->GetIfdTypesL( aNoIfd );

    }

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

// CExifReadImpl::GetThumbnailL

// Returns pointer to a copy of the thumbnail image data.

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

//

HBufC8* CExifReadImpl::GetThumbnailL() const

    {

    if ( !iExifCore )

        {

        LOGTEXT( _L( "ExifLib: CExifReadImpl::GetThumbnailL Leave( KErrGeneral )" ) );

        User::Leave( KErrGeneral );

        }

    return iExifCore->GetThumbnailL();

    }

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

// CExifReadImpl::IfdExists

// Returns a boolean stating if the queried IFD structure exists in Exif data

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

//

TBool CExifReadImpl::IfdExists( const TExifIfdType aIfdType ) const

    {

    if ( !iExifCore )

        {

        LOGTEXT( _L( "ExifLib: CExifReadImpl::IfdExists return EFalse" ) );

        return EFalse;

        }

    return iExifCore->IfdExists( aIfdType );

    }

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

// CExifReadImpl::TagExists

// Returns a boolean stating if the queried tag exists in the specified IFD 

// structure

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

//

TBool CExifReadImpl::TagExists( 

    const TUint16 aTagId, 

    const TExifIfdType aIfdType ) const

    {

    if ( !iExifCore )

        {

        LOGTEXT( _L( "ExifLib: CExifReadImpl::TagExists return EFalse" ) );

        return EFalse;

        }

    return iExifCore->TagExists( aTagId, aIfdType );

    }

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

// CExifReadImpl::ParseExifFormatL

// Parses the IFD data according to the specified IFD type. 

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

//

void CExifReadImpl::ParseExifFormatL()

    {

    LOGTEXT( _L( "ExifLib: CExifReadImpl::ParseExifFormatL() entering" ) );

    if ( ( !iExifCore ) || ( !iReader ) )

        {

        LOGTEXT( _L( "ExifLib: CExifReadImpl::ParseExifFormatL() Leaving KErrGeneral" ) );

        User::Leave( KErrGeneral );

        }

    TUint32 ifd1Offset = 0;

    ParseIfdL( EIfd0, ifd1Offset );

    TUint32 ifdExifOffset = 0;

    User::LeaveIfError( iExifCore->GetTagData( KIdExifIfdPointer, 

        ifdExifOffset ) ); 

    User::LeaveIfError( iReader->MoveTo( ifdExifOffset ) );

    TUint32 nextIfdOffset = 0;

    ParseIfdL( EIfdExif, nextIfdOffset );

    TUint32 ifdGpsOffset = 0 ;

    if ( !iExifCore->GetTagData( KIdGpsIfdPointer, ifdGpsOffset ) )

        {

        User::LeaveIfError( iReader->MoveTo( ifdGpsOffset ) );

        iExifCore->CreateIfdL( EIfdGps );

        nextIfdOffset = 0;

        ParseIfdL( EIfdGps, nextIfdOffset );

        }

    TUint32 ifdIntOpOffset = 0;

    if ( !iExifCore->GetTagData( KIdIntOpIfdPointer, ifdIntOpOffset ) )

        {

        User::LeaveIfError( iReader->MoveTo( ifdIntOpOffset ) );

        iExifCore->CreateIfdL( EIfdIntOp );

        nextIfdOffset = 0;

        ParseIfdL( EIfdIntOp, nextIfdOffset );

        }

    if ( ifd1Offset )

        {

        User::LeaveIfError( iReader->MoveTo( ifd1Offset ) );

        TRAPD( error, ParseIfdL( EIfd1, nextIfdOffset ) );

        if ( error == KErrNotSupported )

            {

            iExifCore->DeleteIfd( EIfd1 );

            }

        else if ( error == KErrCorrupt && ( iExifReadOption & CExifRead::ENoTagChecking ) )

            {

            iExifCore->DeleteIfd( EIfd1 );

            }

        else

            {

            LOGTEXT2( _L( "ExifLib: CExifReadImpl::ParseExifFormatL() ParseIfdL error=%d" ), error );

            User::LeaveIfError( error );

            }

        }

    // Parse jpeg data only if it is read to buffer    

    if ( !(iExifReadOption & (CExifRead::ENoJpeg)) )

        {

        ParseJpegDataL();

        }

    LOGTEXT( _L( "ExifLib: CExifReadImpl::ParseExifFormatL() returning" ) );

    }

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

// CExifReadImpl::ParseIfdL

// Parses the Jpeg primary image data and initializes the Jpeg primary image 

// structures.

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

//

void CExifReadImpl::ParseIfdL( 

    const TExifIfdType aIfdType, 

    TUint32& aNextIfdOffset )

    {

    LOGTEXT3( _L( "ExifLib: CExifReadImpl::ParseIfdL() entering: aIfdType=0x%x, aNextIfdOffset=0x%x" ), aIfdType, aNextIfdOffset );

    if ( ( !iExifCore ) || ( !iReader ) )

        {

        LOGTEXT( _L( "ExifLib: CExifReadImpl::ParseIfdL() Leaving KErrGeneral" ) );

        User::Leave( KErrGeneral );

        }

    TUint16 noTagsInIfd = 0;

    User::LeaveIfError( iReader->ReadUInt16( noTagsInIfd ) );

    if ( !noTagsInIfd )

        {

        LOGTEXT( _L( "ExifLib: CExifReadImpl::ParseIfdL() Leaving KErrNotSupported" ) );

        User::Leave( KErrNotSupported );

        }

    // Read and create each tag one by one

    TUint32 tagsEndOffset = 0;

    for ( TUint16 i = 0; i < noTagsInIfd; ++i )

        {

        TUint16 tagId = 0;

        TUint16 tagType = 0;

        TUint32 tagCount = 0;

        User::LeaveIfError( ReadTagHeader( tagId, tagType, tagCount ) );

        TUint noBytes = 0;

        if ( ( tagType == CExifTag::ETagByte ) || 

            ( tagType == CExifTag::ETagAscii ) || 

            ( tagType == CExifTag::ETagUndefined ) )

            {

            noBytes = sizeof( TUint8 );

            }

        else if ( ( tagType == CExifTag::ETagLong ) || 

            ( tagType == CExifTag::ETagSlong ) )

            {

            noBytes = sizeof( TUint32 );

            }

        else if ( ( tagType == CExifTag::ETagRational ) || 

            ( tagType == CExifTag::ETagSrational ) )

            {

            noBytes = 2 * sizeof( TUint32 );

            }

        else if ( tagType == CExifTag::ETagShort )

            {

            noBytes = sizeof( TUint16 );

            }

        else

            {

            LOGTEXT( _L( "ExifLib: CExifReadImpl::ParseIfdL() Leaving KErrCorrupt" ) );

            User::Leave( KErrCorrupt );

            }

        LOGTEXT2( _L( "ExifLib: CExifReadImpl::ParseIfdL() noBytes=%d" ), noBytes );

        if ( tagCount > KMaxApp1Size )

            {

            LOGTEXT( _L( "ExifLib: CExifReadImpl::ParseIfdL() Leaving KErrCorrupt (>KMaxApp1Size)" ) );

            User::Leave( KErrCorrupt );

            }

        LOGTEXT2( _L( "ExifLib: CExifReadImpl::ParseIfdL() tagCount=%d" ), tagCount );

        if ( !tagCount )

            {

                if ( noBytes > 4)

                    {

                    LOGTEXT( _L( "ExifLib: CExifReadImpl::ParseIfdL() Leaving KErrCorrupt (noBytes > 4)" ) );

                    User::Leave( KErrCorrupt );

                    }

                tagCount = 4 / noBytes;

            }

        noBytes *= tagCount;

        HBufC8* valueBuffer = HBufC8::NewL( noBytes );

        CleanupStack::PushL( valueBuffer );

        // If real tag data size is smaller than 4 bytes, the data is at the 

        // current position. Otherwise 4-byte pointer to the real data location

        // is kept. The pointer is at current location.

        LOGTEXT2( _L( "ExifLib: CExifReadImpl::ParseIfdL() noBytes=%d" ), noBytes );

        if ( noBytes < 5 )

            {

            iReader->CopyBuffer( tagCount, 

                STATIC_CAST( TUint8, ( noBytes / tagCount ) ), valueBuffer );

            // Skip remaining bytes.

            if ( 4 - noBytes )

                {

                LOGTEXT2( _L( "ExifLib: CExifReadImpl::ParseIfdL() skipping=%d" ), 4 - noBytes );

                iReader->Skip( 4 - noBytes );

                }

            }

        else

            {

            TUint32 valueOffset = 0;

            User::LeaveIfError( iReader->ReadUInt32( valueOffset ) );

            LOGTEXT2( _L( "ExifLib: CExifReadImpl::ParseIfdL() valueOffset=%d" ), valueOffset );

            User::LeaveIfError( iReader->CopyBuffer( valueOffset, tagCount, 

                STATIC_CAST( TUint8, ( noBytes / tagCount ) ), valueBuffer ) );

            LOGTEXT2( _L( "ExifLib: CExifReadImpl::ParseIfdL() tagCount=%d" ), tagsEndOffset );

            if ( tagsEndOffset < ( valueOffset + noBytes ) ) 

                {

                tagsEndOffset = valueOffset + noBytes;

                }

            }

        //

        // Test if unknown tags should just be skipped and delete

        // 

        LOGTEXT2( _L( "ExifLib: CExifReadImpl::ParseIfdL() iExifReadOption=%x" ), iExifReadOption );

        if ( !(iExifReadOption & CExifRead::ENoTagChecking ) && !TExifCommon::IsValidTagId( tagId ) )

            {

            LOGTEXT2( _L( "ExifLib: CExifReadImpl::ParseIfdL() skipping tagId=%x" ), tagId );

            CleanupStack::PopAndDestroy( valueBuffer );

            }

        else // Tag was known

            {

            LOGTEXT2( _L( "ExifLib: CExifReadImpl::ParseIfdL() create new tagId=%x" ), tagId );

            CExifTagImpl* tag = NULL;

            if ( iExifReadOption & CExifRead::ENoTagChecking )

                {

                tag = CExifTagImpl::NewL( tagId, 

                    STATIC_CAST( CExifTag::TExifTagDataType, tagType ), 

                    tagCount, valueBuffer, EFalse );

                }

            else

                {

                tag = CExifTagImpl::NewL( tagId, 

                    STATIC_CAST( CExifTag::TExifTagDataType, tagType ), 

                    tagCount, valueBuffer, ETrue );

                }

            CleanupStack::Pop( valueBuffer );

            CleanupStack::PushL( tag );

            // Ignore case when valid tag is in wrong IFD and ENoTagChecking is set

            if ( !iExifCore->TagIsValid( tag->TagInfo(), aIfdType ) )

                {

                if ( iExifReadOption & CExifRead::ENoTagChecking )

                    {

                    LOGTEXT3( _L( "ExifLib: CExifReadImpl::ParseIfdL() keep tagId=0x%x in wrong aIfdType=0x%x" ), tagId, aIfdType );

                    iExifCore->InsertTagL( aIfdType, tag, EFalse );

                    CleanupStack::Pop( tag );

                    }

                else

                    {

                    LOGTEXT3( _L( "ExifLib: CExifReadImpl::ParseIfdL() skipping tagId=0x%x in wrong aIfdType=0x%x" ), tagId, aIfdType );

                    CleanupStack::PopAndDestroy( tag );

                    }

                }

            else // Tag is in correct IFD

                {

                if ( iExifReadOption & CExifRead::ENoTagChecking )

                    {

                    iExifCore->InsertTagL( aIfdType, tag, EFalse );

                    }

                else

                    {

                    iExifCore->InsertTagL( aIfdType, tag, ETrue );

                    }

                CleanupStack::Pop( tag );

                }

            }

        }

    User::LeaveIfError( iReader->ReadUInt32( aNextIfdOffset ) );

    if ( tagsEndOffset )

        {

        User::LeaveIfError( iReader->MoveTo( tagsEndOffset ) );

        }

    if ( aIfdType == EIfd1 )

        {

        ParseThumbnailL();

        }

    LOGTEXT( _L( "ExifLib: CExifReadImpl::ParseIfdL() returning" ) );

    }

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

// CExifReadImpl::ParseJpegDataL

// Parses the Jpeg primary image data and initializes the Jpeg primary image 

// structures.

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

//

void CExifReadImpl::ParseJpegDataL()

    {

    LOGTEXT( _L( "ExifLib: CExifReadImpl::ParseIfdL() entering" ) );

    if ( ( !iExifCore ) || ( !iReader ) )

        {

        LOGTEXT( _L( "ExifLib: CExifReadImpl::ParseIfdL() Leave( KErrGeneral )" ) );

        User::Leave( KErrGeneral );

        }

    TUint32 jpgStartOffset = 0;

    TUint32 jpgStartOffset2 = 0;

    TUint32 jpgEndOffset = 0;

    TUint32 jpgEndOffset2 = 0;

    TUint32 jpgSofOffset = 0;

    // 1. Find the last 2 EOI markers.

    if ( iReader->LocateJpegMarkerFromEnd( KEoi, jpgEndOffset ) )

        {

        LOGTEXT( _L( "ExifLib: CExifReadImpl::ParseIfdL() Leave( KErrCorrupt )LocateJpegMarkerFromEnd" ) );