/*
* Copyright (c) 2010 Ixonos Plc.
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the "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:
* Ixonos Plc
*
* Description:  
*
*/



// INCLUDE FILES
#include    <eikenv.h>
#include    <bautils.h>
#include    <imageconversion.h>

#include    "JpegRotatorImpl.h"
#include    "JpegRotator.h"
#include    "CJpRotate.h"

//  debug log
#include "imageeditordebugutils.h"

// for timing log. It is separate, because other logging
// would affect performance
#include    <flogger.h>

// CONSTANTS
const TInt KDefaultSaveBuffer = 1048576;  // 16384

//=============================================================================
CJpegRotatorImpl * CJpegRotatorImpl::NewL (RFs& aFsSession)
{
	CJpegRotatorImpl * self = new (ELeave) CJpegRotatorImpl (aFsSession);
	CleanupStack::PushL (self);
	self->ConstructL();
	CleanupStack::Pop(); // self
	return self;
}

//=============================================================================
CJpegRotatorImpl::~CJpegRotatorImpl ()
{

    if (iRotator)
    {
        delete iRotator;
    }

    if (iCallBack)
    {
        iCallBack->Cancel();
        delete iCallBack;
    }
    
}

//=============================================================================
void CJpegRotatorImpl::Cleanup ()
{
    LOG( KJpegRotatorLogFile, "CJpegRotatorImpl::Cleanup");

    iSourceFileName = KNullDesC();
    iTargetFileName = KNullDesC();
    iRotationMode = CJpegRotator::ERotModeCounterClockwise;
    iCallerStatus = NULL;
    iSourceImageSize.SetSize(0,0);
    iHandleExifData = ETrue;
    iCancelled = EFalse;

#if defined (LOG_TIMING)
    iLosslessMode = EFalse;
#endif
}

//=============================================================================
void CJpegRotatorImpl::Cancel ()
{
    if (iRotator)
    {
        iRotator->Cancel();    
    }
    
	iCancelled = ETrue;
}

//=============================================================================
void CJpegRotatorImpl::PrepareRotateFileL (
    const TDesC& aSourceFileName,
    const TDesC& aTargetFileName,
    CJpegRotator::TRotationMode aRotationMode,
    TBool aHandleExifData)
{
    LOG( KJpegRotatorLogFile, "CJpegRotatorImpl::PrepareRotateFileL");

#if defined (LOG_TIMING)
    iStartTime.UniversalTime();
#endif

    // Reset old values
    Cleanup();

    // Check that the source file exists
    if ( !BaflUtils::FileExists (iFsSession, aSourceFileName) )
    {
        User::Leave (KErrNotFound);
    }
    // Check that the target file does not exist
    if ( BaflUtils::FileExists (iFsSession, aTargetFileName) )
    {
        User::Leave (KErrAlreadyExists);
    }
    // Check that the target path exists
    TParsePtrC parse (aTargetFileName);
    if ( !BaflUtils::FolderExists (iFsSession, parse.DriveAndPath()) )
    {
        User::Leave (KErrPathNotFound);
    }

    // Check & store the rotate parameter
    if ( CJpegRotator::ERotModeCounterClockwise == aRotationMode )
    {
        iRotationMode = CJpegRotator::ERotModeCounterClockwise;
    }
    else if ( CJpegRotator::ERotModeClockwise == aRotationMode )
    {
        iRotationMode = CJpegRotator::ERotModeClockwise;
    }
    else if ( CJpegRotator::ERotMode180 == aRotationMode )
    {
        iRotationMode = CJpegRotator::ERotMode180;
    }
    else
    {
        User::Leave (KErrArgument);
    }


    // Store the source file name and set target name
    iSourceFileName = aSourceFileName;
    iTargetFileName = aTargetFileName;
    iHandleExifData = aHandleExifData;

    // Store the JPEG quality factor etc.
    GetSourceImagePropertiesL ( iSourceFileName );
}

//=============================================================================
void CJpegRotatorImpl::StartAsyncRotate (TRequestStatus& aStatus, TBool aForceLossyMode)
{
    LOG( KJpegRotatorLogFile, "CJpegRotatorImpl::StartAsyncRotate");

    // Use lossless rotate if possible
    if( !aForceLossyMode && IsLosslessRotatePossible() )
    {
        StartAsyncLosslessRotate (aStatus);
    }

    else 
    {
        aStatus = KRequestPending;
        iCallerStatus = &aStatus;

        iCb = TCallBack(CJpegRotatorImpl::AsyncLosslessRotate, this);
          
        iCallBack = new CAsyncCallBack (iCb, CActive::EPriorityStandard);
                
        if (iCallBack)
        {
        	iCallBack->CallBack();        	
        }
        else
        {
        	FinishAsyncRotate (KErrNoMemory); 
        }

    }
    
}

//=============================================================================
void CJpegRotatorImpl::StartAsyncLosslessRotate (TRequestStatus& aStatus)
{
    LOG( KJpegRotatorLogFile, "CJpegRotatorImpl::StartAsyncLosslessRotate");

    aStatus = KRequestPending;
    iCallerStatus = &aStatus;
    
    iCb = TCallBack(CJpegRotatorImpl::AsyncLosslessRotate, this);
    // Create the callback utility used with the asynchronous version of rotate
	iCallBack = new CAsyncCallBack (iCb, CActive::EPriorityStandard);
	
    if (iCallBack)
    {
    	iCallBack->CallBack();        	
    }
    else
    {
    	FinishAsyncRotate (KErrNoMemory); 
    }

}

//=============================================================================
TInt CJpegRotatorImpl::AsyncRotate (TAny* /*aThis*/)
{
    LOG( KJpegRotatorLogFile, "CJpegRotatorImpl::AsyncRotate");
 /*
    // In the asynchronous version, trap the rest of the functions 
    // to make sure that the caller's TRequestStatus is always 
    // completed, also in case of failures.
    CJpegRotatorImpl* impl = static_cast<CJpegRotatorImpl*>(aThis);

    // Rotate-in-one-go, lossy mode
    TRAPD (err, impl->DoRotateL());
    if (err == KErrNone)
    {
        TRAP (err, impl->SaveImageL())
    }
    impl->FinishAsyncRotate (err);
*/
    return KErrNotSupported;
}

//=============================================================================
TInt CJpegRotatorImpl::AsyncLosslessRotate (TAny* aThis)
{
    LOG( KJpegRotatorLogFile, "CJpegRotatorImpl::AsyncLosslessRotate");

    // In the asynchronous version, trap the rest of the functions 
    // to make sure that the caller's TRequestStatus is always 
    // completed, also in case of failures.
    CJpegRotatorImpl* impl = static_cast<CJpegRotatorImpl*>(aThis);

    // Rotate-in-one-go
    TRAPD (err, impl->DoLosslessRotateL());

    impl->FinishAsyncRotate (err);    

    return KErrNone;
}

//=============================================================================
void CJpegRotatorImpl::FinishAsyncRotate (TInt aError)
{
    LOGFMT( KJpegRotatorLogFile, "CJpegRotatorImpl::FinishAsyncRotate (error: %d)", aError);

	if( !iCancelled )
	{
		User::RequestComplete (iCallerStatus, aError);
	}
	else
	{
		Cleanup();
	}

    PostRotate();
}

//=============================================================================
void CJpegRotatorImpl::DoRotateL ()
{
    User::Leave(KErrNotSupported);
}

//=============================================================================
void CJpegRotatorImpl::DoLosslessRotateL ()
{
    LOG( KJpegRotatorLogFile, "CJpegRotatorImpl::DoLosslessRotateL");

    iLosslessMode = ETrue;

#if defined (LOG_TIMING)
    iSavingStartTime.UniversalTime();
#endif

	//	Load JPEG file to source file buffer

	RFile srcfile;
	CleanupClosePushL (srcfile);
	User::LeaveIfError ( srcfile.Open (iFsSession, iSourceFileName, EFileRead) );

	TInt sourcebufsize;
	User::LeaveIfError ( srcfile.Size(sourcebufsize) );
	TInt targetbufsize = (TInt)(1.2 * sourcebufsize);

    TInt saveBufferSize = KDefaultSaveBuffer;
    if (targetbufsize < saveBufferSize)
    {
        saveBufferSize = targetbufsize;
    }
    
    CleanupStack::PopAndDestroy();

	RFile trgfile;
	User::LeaveIfError ( trgfile.Replace (iFsSession, iTargetFileName, EFileRead) );
    CleanupClosePushL (trgfile);
  	
    CJpRotate* rotator = CJpRotate::NewLC(iFsSession, &trgfile, saveBufferSize);

	rotator->SetCallBack( this );

    switch ( iRotationMode )
    {
        case CJpegRotator::ERotModeCounterClockwise:
        {
            rotator->RotateL( iSourceFileName, true, false, false );
            break;
        }
        case CJpegRotator::ERotMode180:
        {
            rotator->RotateL( iSourceFileName, false, true, true );
            break;
        }
        case CJpegRotator::ERotModeClockwise:
        default:
        {
            rotator->RotateL( iSourceFileName, true, true, true );
            break;
        }
       
    }

    CleanupStack::PopAndDestroy(2);

    LOG( KJpegRotatorLogFile, "\t...DoLosslessRotateL: Done.");

}

//=============================================================================
void CJpegRotatorImpl::JpRotateStatus( TInt /*aCount*/, TInt /*aTotal*/ )
{
//    LOG( KJpegRotatorLogFile, "CJpegRotatorImpl::JpRotateStatus" );
//    LOGFMT( KJpegRotatorLogFile, "   count: %d", aCount );
//    LOGFMT( KJpegRotatorLogFile, "   total: %d", aTotal );   
}


//=============================================================================
CJpegRotatorImpl::CJpegRotatorImpl (RFs& aFsSession) : 
iFsSession (aFsSession),
iRotator (NULL), 
iHandleExifData (ETrue)
{
}

//=============================================================================
void CJpegRotatorImpl::ConstructL ()
{
    LOG( KJpegRotatorLogFile, "CJpegRotatorImpl::ConstructL");


}

//=============================================================================
void CJpegRotatorImpl::GetSourceImagePropertiesL ( const TDesC& /*aFileName*/ )
{
    /*
    //	Create a new image decoder
    CImageDecoder * decoder = CImageDecoder::FileNewL (iFsSession, aFileName);
    CleanupStack::PushL( decoder );

    //  Get reference to frame image data
    const CFrameImageData & imageData = decoder->FrameData();

    //  Get JPEG quality factor
    iOriginalJpegQualityFactor = KDefaultSavedJpegQuality;
    if ( imageData.ImageDataCount() > 0 )
    {
        iOriginalJpegQualityFactor = ((const TJpegImageData*)imageData.GetImageData(0))->iQualityFactor;
    }

    //  Image resolution
    const TFrameInfo& frameInfo = decoder->FrameInfo();
    iSourceImageSize = frameInfo.iOverallSizeInPixels;

    CleanupStack::PopAndDestroy( decoder );
    */
}

//=============================================================================
void CJpegRotatorImpl::SetJpegCommentL (const TDesC8& /*aComment*/)
{
    LOG( KJpegRotatorLogFile, "CJpegRotatorImpl::SetJpegCommentL");

}

//=============================================================================
void CJpegRotatorImpl::SetExifData (TUint8* /*aExifData*/, TUint /*aDataSize*/)
{
    LOG( KJpegRotatorLogFile, "CJpegRotatorImpl::SetExifData");

}

//=============================================================================
void CJpegRotatorImpl::PostRotate ()
{
#if defined (LOG_TIMING)
/*
    iFinishTime.UniversalTime();

    TInt64 prepareTime = iSavingStartTime.Int64() - iStartTime.Int64();
    TInt64 savingTime = iFinishTime.Int64() - iSavingStartTime.Int64();
    TInt64 totalTime = iFinishTime.Int64() - iStartTime.Int64();

    TBuf<128> text1;
    if (iLosslessMode)
    {
        text1 = _L("Rotating from %S to %S. Lossless rotate was used.");
    }
    else
    {
        text1 = _L("Rotating from %S to %S. Lossy rotate was used.");
    }

	RFileLogger::WriteFormat( 
        KImageEditorLogDir,
        KJpegRotatorTimingLogFile,
        EFileLoggingModeAppend,
        text1, &iSourceFileName, &iTargetFileName 
        );

    RFileLogger::WriteFormat( 
        KImageEditorLogDir,
        KJpegRotatorTimingLogFile,
        EFileLoggingModeAppend,
        _L("\tTime taken (microseconds): %d"),
        totalTime );

	RFileLogger::WriteFormat( 
        KImageEditorLogDir,
        KJpegRotatorTimingLogFile,
        EFileLoggingModeAppend,
        _L( "\tprepare phase: %d"),
        prepareTime );

	RFileLogger::WriteFormat( 
        KImageEditorLogDir,
        KJpegRotatorTimingLogFile,
        EFileLoggingModeAppend,
        _L( "\tsave phase: %d"),
        savingTime );
*/
#endif
}

//=============================================================================
TBool CJpegRotatorImpl::IsLosslessRotatePossible() const
{
    return ETrue;
}


// End of File