/*

* 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 modifier API implementation

*

*/

// INCLUDE FILES

#include "ExifModifyImpl.h"

#include "ExifReadImpl.h"

#include "ExifTagImpl.h"

#include "ExifCore.h"

#include "ExifCommon.h"

// ============================ CLASS CExifModify ==============================

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

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

// CExifModify::NewL

// Two-phased constructor.

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

//

EXPORT_C CExifModify* CExifModify::NewL( 

    const TDesC8& aExifData, 

    CExifModify::TOperationMode aOperationMode )

    {

    return CExifModifyImpl::NewL( aExifData, STATIC_CAST( TBool, 

        aOperationMode ), CExifModify::ENoOptions );

    }

EXPORT_C CExifModify* CExifModify::NewL( 

    const TDesC8& aExifData, 

    CExifModify::TOperationMode aOperationMode,

    TUint aExifModifyOption )

    {

    return CExifModifyImpl::NewL( aExifData, STATIC_CAST( TBool, 

        aOperationMode ), aExifModifyOption );

    }

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

// CExifModify::NewL

// Two-phased constructor.

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

//

EXPORT_C CExifModify* CExifModify::NewL()

    {

    return CExifModifyImpl::NewL();

    }

// Destructor

CExifModify::~CExifModify()

    {

    }

// ============================ CLASS CExifModifyImpl ==========================

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

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

// CExifModifyImpl::CExifModifyImpl

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

// might leave.

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

//

CExifModifyImpl::CExifModifyImpl()

    {

    }

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

// CExifModifyImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CExifModifyImpl::ConstructL( const TDesC8& aInData, TBool aCreate, TUint aExifModifyOption )

    {

    iExifModifyOption = aExifModifyOption;

    TUint readOption = CExifRead::ENoOptions;

    if ( aExifModifyOption & CExifModify::ENoJpegParsing )

        {

        readOption |= CExifRead::EFastJpegParsing;

        }

    if ( aExifModifyOption & CExifModify::ENoTagChecking )

        {

        readOption |= CExifRead::ENoTagChecking;

        }

    iExifRead = CExifReadImpl::NewL( aInData, aCreate, readOption );

    iExifCore = iExifRead->iExifCore; 

    if ( !aCreate )

        {

        if ( iExifCore->IfdExists( EIfdGps ) )

            {

            iExifCore->SetTagDataL( KIdGpsVersion, KGpsVersion );

            }

        }

    iExifCore->SetTagDataL( KIdExifVersion, KExifVersion );

    iExifCore->SetTagDataL( KIdFlashPixVersion, KFlashPixVersion );

    // Keep some data from the beginning, middle and end for cross-checking.

    iCrossCheckLength = aInData.Length();

    iCrossCheckBegin = TExifCommon::Uint32L( 

        CONST_CAST( TUint8*, aInData.Ptr() ) );

    iCrossCheckMiddle = TExifCommon::Uint32L( 

        CONST_CAST( TUint8*, aInData.Ptr() ) + aInData.Length() / 2 );

    iCrossCheckEnd = TExifCommon::Uint32L( 

        CONST_CAST( TUint8*, aInData.Ptr() ) + aInData.Length() - 5 );

    User::LeaveIfError( iExifCore->Finalize() );

    }

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

// CExifModifyImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CExifModifyImpl::ConstructL()

    {

    iExifModifyOption = CExifModify::ENoOptions;

    iExifRead = CExifReadImpl::NewL();

    iExifCore = iExifRead->iExifCore; 

    iExifCore->SetTagDataL( KIdExifVersion, KExifVersion );

    iExifCore->SetTagDataL( KIdFlashPixVersion, KFlashPixVersion );

    // No cross-checking since there is no input data.

    iCrossCheckLength = 0;

    User::LeaveIfError( iExifCore->Finalize() );

    }

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

// CExifModifyImpl::NewL

// Two-phased constructor.

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

//

CExifModifyImpl* CExifModifyImpl::NewL( const TDesC8& aExifData, TBool aCreate, TUint aExifModifyOption )

    {

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

    CleanupStack::PushL( self ); 

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

    CleanupStack::Pop();

    return self;

    }

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

// CExifModifyImpl::NewL

// Two-phased constructor.

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

//

CExifModifyImpl* CExifModifyImpl::NewL()

    {

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

    CleanupStack::PushL( self ); 

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CExifModifyImpl::~CExifModifyImpl()

    {

    if ( iExifRead )

        {

        delete iExifRead;

        }

    }

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

// CExifModifyImpl::Reader

// Returns a constant pointer to a CExifRead instance that can be used to 

// parse the associated Exif image.

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

//

const CExifRead* CExifModifyImpl::Reader() const

    {

    return iExifRead;

    }

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

// CExifModifyImpl::SetTagL

// Inserts/Updates the given tag in the specified IFD structure of the Exif data

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

//

void CExifModifyImpl::SetTagL( 

    TExifIfdType aIfdType, 

    TExifTagInfo aExifTagInfo, 

    const TDesC8& aTagData )

    {

    if ( !iExifCore )

        {

        User::Leave( KErrGeneral );

        }

    // Check if ASCII string terminates with NULL character.

    // If not add NULL.

    HBufC8* buffer = NULL;

    if ( ( aExifTagInfo.iDataType == CExifTag::ETagAscii ) && 

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

        {

        ++aExifTagInfo.iDataCount;

        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 = NULL;

    if ( iExifModifyOption & CExifModify::ENoTagChecking )

        {

        tag = CExifTagImpl::NewL( aExifTagInfo, buffer, EFalse );

        }

    else

        {

        tag = CExifTagImpl::NewL( aExifTagInfo, buffer, ETrue );

        }

    CleanupStack::Pop( buffer );

    CleanupStack::PushL( tag );

    switch ( tag->TagInfo().iId )

        {

        case KIdExifIfdPointer:

        case KIdGpsIfdPointer:

        case KIdIntOpIfdPointer:

        case KIdJpegInterchangeFormat:

        case KIdJpegInterchangeFormatLength:

        case KIdExifVersion:

        case KIdGpsVersion:

        case KIdFlashPixVersion:

        case KIdCompression:

            User::Leave( KErrNotSupported );

        default:

            break;

        }

    if ( iExifModifyOption & CExifModify::ENoTagChecking )

        {

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

        }

    else

        {

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

        }

    CleanupStack::Pop( tag );

    if ( aIfdType == EIfdGps )

        {

        iExifCore->SetTagDataL( KIdGpsVersion, KGpsVersion );

        }

    TInt error = iExifCore->Finalize();

    if ( error )

        {

        iExifCore->DeleteTag( aIfdType, aExifTagInfo.iId );

        User::Leave( error );

        }

    }

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

// CExifModifyImpl::DeleteTag

// Removes the tag with the given tag ID from the specified IFD structure in 

// the Exif data.

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

//

TInt CExifModifyImpl::DeleteTag( TExifIfdType aIfdType, TUint16 aTagId )

    {

    if ( !iExifCore )

        {

        return KErrGeneral;

        }

    switch ( aTagId )

        {

        case KIdExifIfdPointer:

        case KIdGpsIfdPointer:

        case KIdIntOpIfdPointer:

        case KIdJpegInterchangeFormat:

        case KIdJpegInterchangeFormatLength:

        case KIdExifVersion:

        case KIdGpsVersion:

        case KIdFlashPixVersion:

        case KIdCompression:

            return KErrNotSupported;

        default:

            if ( !TExifCommon::IsValidTagId( aTagId ) )

                {

                return KErrNotSupported;

                }

        }

    TInt error = iExifCore->DeleteTag( aIfdType, aTagId );

    if ( error )

        {

        return error;

        }

    return iExifCore->Finalize();

    }

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

// CExifModifyImpl::DeleteIfd

// Removes the specified IFD structure and all its tags from the Exif data.

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

//

TInt CExifModifyImpl::DeleteIfd( TExifIfdType aIfdType )

    {

    if ( !iExifCore )

        {

        return KErrGeneral;

        }

    if ( ( aIfdType == EIfd0 ) || ( aIfdType == EIfdExif ) )

        {

        return KErrArgument;

        }

    TInt error = iExifCore->DeleteIfd( aIfdType );

    if ( error )

        {

        return error;

        }

    return iExifCore->Finalize();

    }

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

// CExifModifyImpl::SetThumbnailL

// Inserts/Updates the given thumbnail Jpeg image data into the 1st IFD 

// structure in the Exif data.

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

//

void CExifModifyImpl::SetThumbnailL( const TDesC8& aThumbnailData )

    {

    if ( !iExifCore )

        {

        User::Leave( KErrGeneral );

        }

    TDesC8* data = aThumbnailData.AllocL();

    CleanupStack::PushL( data );

    iExifCore->InsertThumbnailL( data );

    CleanupStack::Pop( data );

    TInt error = iExifCore->Finalize();

    if ( error )

        {

        iExifCore->RemoveThumbnail();

        User::Leave( error );

        }

    }

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

// CExifModifyImpl::RemoveThumbnail

// Removes the thumbnail Jpeg image data from the 1st IFD structure in the Exif 

// data.

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

//

TInt CExifModifyImpl::RemoveThumbnail()

    {

    if ( !iExifCore )

        {

        return KErrGeneral;

        }

    TInt error = iExifCore->RemoveThumbnail();

    if ( error )

        {

        return error;

        }

    return iExifCore->Finalize();

    }

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

// CExifModifyImpl::WriteDataL

// Flushes the Exif data into the given data buffer, and releases the internal 

// structures.

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

//

HBufC8* CExifModifyImpl::WriteDataL( const TDesC8& aInData )

    {

    if ( !iExifCore )

        {

        User::Leave( KErrGeneral );

        }

    // Input Jpeg or Exif data is provided at instantiation (or not)

    TBool inputProvidedEarly = iCrossCheckLength; 

    // Input Jpeg or Exif data is provided for this function (or not)

    TBool inputProvidedLate = aInData.Length();

    if ( inputProvidedEarly )

        {

        if ( inputProvidedLate )

            {

            // Cross-check. Check if content of aInData is identical with 

            // the descriptor provided during instantiation.

            if ( aInData.Length() != iCrossCheckLength )

                {

                User::Leave(KErrArgument);

                }

            TUint32 crossCheck = TExifCommon::Uint32L( 

                CONST_CAST( TUint8*, aInData.Ptr() ) );

            if ( crossCheck != iCrossCheckBegin )

                {

                User::Leave(KErrArgument);

                }

            crossCheck = TExifCommon::Uint32L( 

                CONST_CAST( TUint8*, aInData.Ptr() + aInData.Length() / 2 ) );

            if ( crossCheck != iCrossCheckMiddle )

                {

                User::Leave(KErrArgument);

                }

            crossCheck = TExifCommon::Uint32L( 

                CONST_CAST( TUint8*, aInData.Ptr() + aInData.Length() - 5 ) );

            if ( crossCheck != iCrossCheckEnd )

                {

                User::Leave(KErrArgument);

                }

            }

        }

    else

        {

        if ( inputProvidedLate )

            {

            iExifRead->ParseJpegDataL( aInData );

            }

        }

    User::LeaveIfError( iExifCore->Finalize() );    

    if ( !iExifCore->IsValid() )

        {

        User::Leave( KErrNotReady );

        }

    TUint totalSize = 0;

    if ( inputProvidedLate )

        {

        iExifCore->SetDataStartPtr( CONST_CAST( TUint8*, aInData.Ptr() ) );

        totalSize = iExifCore->TotalSize();

        }

    else

        {

        totalSize = iExifCore->App1Size() + 2;

        }

    // Allocation amount is even for 2-byte alignment

    HBufC8* exifData = HBufC8::NewLC( totalSize + ( totalSize % 2 ) );

    exifData->Des().SetLength( totalSize + ( totalSize % 2 ) );

    TUint pos = 0;

    if ( inputProvidedLate )

        {

        iExifCore->WriteJpegHeaderL( exifData, pos );

        iExifCore->WriteExifDataL( exifData, pos );

        TPtr8 ptr( CONST_CAST( TUint8*, exifData->Ptr() ) + pos, 

            iExifCore->JpegSize() );

        User::LeaveIfError( iExifCore->GetJpegData( ptr ) );

        }

    else

        {

        iExifCore->WriteExifDataL( exifData, pos );

        }

    exifData->Des().SetLength( totalSize );

    CleanupStack::Pop();

    return exifData;

    }

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

// CExifModifyImpl::SetImageDescriptionL

// Inserts/Updates given ImageDescription in the Exif data.

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

//

void CExifModifyImpl::SetImageDescriptionL( const TDesC8& aImageDescription )

    {

    if ( !iExifCore )

        {

        User::Leave( KErrGeneral );

        }

    iExifCore->SetTagDataL( KIdImageDescription, aImageDescription );

    }

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

// CExifModifyImpl::SetMakeL

// Inserts/Updates given Make in the Exif data.

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

//

void CExifModifyImpl::SetMakeL( const TDesC8& aMake )

    {

    if ( !iExifCore )

        {

        User::Leave( KErrGeneral );

        }

    iExifCore->SetTagDataL( KIdMake, aMake );

    }

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

// CExifModifyImpl::SetModelL

// Inserts/Updates given Model in the Exif data.

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

//

void CExifModifyImpl::SetModelL( const TDesC8& aModel )

    {

    if ( !iExifCore )

        {

        User::Leave( KErrGeneral );

        }

    iExifCore->SetTagDataL( KIdModel, aModel );

    }

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

// CExifModifyImpl::SetOrientationL

// Inserts/Updates given Orientation in the Exif data.

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

//

void CExifModifyImpl::SetOrientationL( TUint16 aOrientation )

    {