/*

* 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 <imageconversion.h>

#include <eikenv.h>

#include <bautils.h>

#include "imageeditordebugutils.h"

#include "commondefs.h"

#include "ImageEditorError.h"

#include "ImageEditorImageHandler.h"

//=============================================================================

EXPORT_C CImageEditorImageHandler * CImageEditorImageHandler::NewL ()

{

	CImageEditorImageHandler * self = new (ELeave) CImageEditorImageHandler;

	CleanupStack::PushL(self);

	self->ConstructL ();

	CleanupStack::Pop(); // self

	return self;

}

//=============================================================================

EXPORT_C CImageEditorImageHandler::~CImageEditorImageHandler ()

{

	CleanupConverters();

}	

//=============================================================================

EXPORT_C void CImageEditorImageHandler::LoadImageAsyncL (

	const TDesC &		aFileName,

	CFbsBitmap *&		aBitmap,

	TRequestStatus *	aStatus

	)

{

    LOG(KImageEditorLogFile, "CImageEditorImageHandler::LoadImageAsyncL()");

	//	Clean up old converters

	CleanupConverters();

	//	Create a new image decoder

	iImageDecoder = CImageDecoder::FileNewL (

		CEikonEnv::Static()->FsSession(), 

		aFileName

		);

	//	Create the bitmap for containing the decoded image

    TFrameInfo frame_info = iImageDecoder->FrameInfo();

    CFbsBitmap * bitmap = new (ELeave) CFbsBitmap;

    CleanupStack::PushL (bitmap);

    TInt err = bitmap->Create (frame_info.iOverallSizeInPixels, EColor16M) ;

    if (err != KErrNone)

        {

        LOG(KImageEditorLogFile, "CImageEditorImageHandler: Failed to create CFbsBitmap");

        User::Leave(KSIEEInternalNonRecoverable);

        }

    CleanupStack::Pop(); // bitmap

    aBitmap = bitmap;

	//	Start decoding

	iImageDecoder->Convert (aStatus, *aBitmap);

}

//=============================================================================

EXPORT_C void CImageEditorImageHandler::ContinueLoading (TRequestStatus * aStatus)

{

    iImageDecoder->ContinueConvert (aStatus);

}

//=============================================================================

EXPORT_C void CImageEditorImageHandler::SaveImageAsyncL (

	const TDesC	&		aFileName,

	const CFbsBitmap &		aBitmap,

	const TInt			aImageQuality,

	TRequestStatus *	aStatus

	)

{

    LOG(KImageEditorLogFile, "CImageEditorImageHandler::SaveImageAsyncL()");

	//	Clean up old converters

	CleanupConverters();

	//	Get MIME type based in file extension

	CFileExtensionMIMEType * mime = GetMIMETypeL (aFileName);

	//	Create a new image decoder for MIME type mime

	iImageEncoder = CImageEncoder::FileNewL (

		CEikonEnv::Static()->FsSession(), 

		aFileName,

		mime->MIMEType()

		);

	CFrameImageData * frame = GetFrameImageDataL (

		mime->FileExtension(),

		aImageQuality

		);

	//	Start encoding

	iImageEncoder->Convert (aStatus, aBitmap, frame);

}

//=============================================================================

EXPORT_C TInt CImageEditorImageHandler::GetJpegQualityFactorL (

    const TDesC & aFileName

	)

{

    LOG(KImageEditorLogFile, "CImageEditorImageHandler::GetJpegQualityFactorL()");

	//	Clean up old converters

	CleanupConverters();

	//	Create a new image decoder

	iImageDecoder = CImageDecoder::FileNewL (

		CEikonEnv::Static()->FsSession(), 

		aFileName

		);

    //  Get reference to frame image data

    const CFrameImageData & image_data = iImageDecoder->FrameData();

    //  Get JPEG quality factor

    TInt qualityfactor = 100;

    if ( image_data.ImageDataCount() > 0 )

    {

        qualityfactor = ((const TJpegImageData*)image_data.GetImageData(0))->iQualityFactor;

    }

	//	Clean up old converters

	CleanupConverters();

    return qualityfactor;

}

//=============================================================================

EXPORT_C TInt CImageEditorImageHandler::RenameImage (

	const TDesC	&		aFileNameSrc,

	const TDesC	&		aFileNameDst

	) const

{

	return BaflUtils::RenameFile (

		CEikonEnv::Static()->FsSession(),

		aFileNameSrc, 

		aFileNameDst, 

		0

		);

}

//=============================================================================

EXPORT_C TInt CImageEditorImageHandler::DeleteImage (const TDesC & aFileName) const

{

	return BaflUtils::DeleteFile (

		CEikonEnv::Static()->FsSession(),

		aFileName,

		0

		);

}

//=============================================================================

EXPORT_C void CImageEditorImageHandler::CleanupConverters()

{

    LOG(KImageEditorLogFile, "CImageEditorImageHandler::CleanupConverters()");

	if (iImageDecoder)

	{

        LOG(KImageEditorLogFile, "CImageEditorImageHandler::CleanupConverters(): cancelling iImageDecoder");

		iImageDecoder->Cancel();

		delete iImageDecoder;

		iImageDecoder = NULL;

	}

	if (iImageEncoder)

	{

        LOG(KImageEditorLogFile, "CImageEditorImageHandler::CleanupConverters(): cancelling iImageEncoder");

		iImageEncoder->Cancel();

		delete iImageEncoder;

		iImageEncoder = NULL;

	}

}

//=============================================================================

EXPORT_C TBool CImageEditorImageHandler::IsRajpegImageL (const TDesC & aFileName) const

{

    _LIT8 (KMimeJpeg, "image/jpeg");

    TBuf8<256> mime;

    RFs fs;

    User::LeaveIfError(fs.Connect());

    CleanupClosePushL(fs);

    CImageDecoder::GetMimeTypeFileL (fs, aFileName, mime);

	CleanupStack::PopAndDestroy();

#ifdef ENABLE_DEBUGLOG

    TBuf16 <100> mime16;

    mime16.Copy(mime);

    LOGFMT(KImageEditorLogFile, "CImageEditorImageHandler::IsRajpegImageL: MIME type: %S", &mime16);

#endif

    // Images with the mime type image/jpeg can be rajpeg images.

    return ( mime.CompareF (KMimeJpeg) == 0 );

}

//=============================================================================

EXPORT_C TBool CImageEditorImageHandler::IsJpegIntact (const TDesC & aFileName)

{

    //	Clean up old converters

    CleanupConverters();

    TRAPD (err,

        //	Create a new image decoder

        iImageDecoder = CImageDecoder::FileNewL (

        CEikonEnv::Static()->FsSession(), 

        aFileName

        );

    );

    CleanupConverters();

    if (err != KErrNone)

    {

        return EFalse;

    }

    else

    {

        return ETrue;

    }

}

//=============================================================================

CImageEditorImageHandler::CImageEditorImageHandler ()

{

}

//=============================================================================

void CImageEditorImageHandler::ConstructL ()

{

}

//=============================================================================

CFileExtensionMIMEType * CImageEditorImageHandler::GetMIMETypeL (

	const TDesC &	aFileName

	)

{	

	//	Extract the file extension from aFullFileName

	TParsePtrC fileparser (aFileName);

	TBuf<12> ext;

	if (fileparser.ExtPresent())

	{

		ext.Append (fileparser.Ext());

	}

	//	Get all supported mime types with file extensions

	RFileExtensionMIMETypeArray mimes;

	iImageEncoder->GetFileTypesL (mimes);

	//	Get correct mime type based on file extension

	CFileExtensionMIMEType * ret = 0;

	for (TInt i = 0; i < mimes.Count(); ++i)

	{

		if (ext == mimes[i]->FileExtension())

		{

			ret = mimes[i];

			mimes.Remove(i);

			break;

		}

	}

	//	Delete pointer array

	mimes.ResetAndDestroy();

	return ret;

}

//=============================================================================

CFrameImageData * CImageEditorImageHandler::GetFrameImageDataL (

	const TDesC &		aExt,

	const TInt			aQuality

	) const

{

    LOG(KImageEditorLogFile, "CImageEditorImageHandler::GetFrameImageDataL()");

	CFrameImageData * frameData = CFrameImageData::NewL();

	CleanupStack::PushL (frameData);

	if (aExt.CompareF (KJpegExtension))

	{

		TJpegImageData * data = new (ELeave) TJpegImageData();

		data->iQualityFactor = (100 - aQuality);

		data->iSampleScheme = TJpegImageData::EColor422;

		frameData->AppendImageData (data);	// ownership transferred

	}

	else if (aExt.CompareF (KBmpExtension))

	{

		TBmpImageData * data = new (ELeave) TBmpImageData();

		data->iBitsPerPixel = 24;

		frameData->AppendImageData (data);	// ownership transferred

	}

	else

	{

	}

	CleanupStack::Pop(); //	frameData

	return frameData;

}

// End of File