1 /*

     2 * Copyright (c) 2010 Ixonos Plc.

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - Initial contribution

    11 *

    12 * Contributors:

    13 * Ixonos Plc

    14 *

    15 * Description:  

    16 *

    17 */

    18 

    19 

    20 

    21 #include <imageconversion.h>

    22 #include <eikenv.h>

    23 #include <bautils.h>

    24 

    25 #include "imageeditordebugutils.h"

    26 #include "commondefs.h"

    27 #include "ImageEditorError.h"

    28 #include "ImageEditorImageHandler.h"

    29 

    30 //=============================================================================

    31 EXPORT_C CImageEditorImageHandler * CImageEditorImageHandler::NewL ()

    32 {

    33 	CImageEditorImageHandler * self = new (ELeave) CImageEditorImageHandler;

    34 	CleanupStack::PushL(self);

    35 	self->ConstructL ();

    36 	CleanupStack::Pop(); // self

    37 	return self;

    38 }

    39 

    40 //=============================================================================

    41 EXPORT_C CImageEditorImageHandler::~CImageEditorImageHandler ()

    42 {

    43 	CleanupConverters();

    44 }	

    45 

    46 //=============================================================================

    47 EXPORT_C void CImageEditorImageHandler::LoadImageAsyncL (

    48 	const TDesC &		aFileName,

    49 	CFbsBitmap *&		aBitmap,

    50 	TRequestStatus *	aStatus

    51 	)

    52 {

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

    54 

    55 	//	Clean up old converters

    56 	CleanupConverters();

    57 

    58 	//	Create a new image decoder

    59 	iImageDecoder = CImageDecoder::FileNewL (

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

    61 		aFileName

    62 		);

    63 

    64 	//	Create the bitmap for containing the decoded image

    65     TFrameInfo frame_info = iImageDecoder->FrameInfo();

    66     CFbsBitmap * bitmap = new (ELeave) CFbsBitmap;

    67     CleanupStack::PushL (bitmap);

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

    69     if (err != KErrNone)

    70         {

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

    72         User::Leave(KSIEEInternalNonRecoverable);

    73         }

    74     CleanupStack::Pop(); // bitmap

    75     aBitmap = bitmap;

    76 

    77 	//	Start decoding

    78 	iImageDecoder->Convert (aStatus, *aBitmap);

    79 }

    80 

    81 //=============================================================================

    82 EXPORT_C void CImageEditorImageHandler::ContinueLoading (TRequestStatus * aStatus)

    83 {

    84     iImageDecoder->ContinueConvert (aStatus);

    85 }

    86 

    87 //=============================================================================

    88 EXPORT_C void CImageEditorImageHandler::SaveImageAsyncL (

    89 	const TDesC	&		aFileName,

    90 	const CFbsBitmap &		aBitmap,

    91 	const TInt			aImageQuality,

    92 	TRequestStatus *	aStatus

    93 	)

    94 {

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

    96 	//	Clean up old converters

    97 	CleanupConverters();

    98 

    99 	//	Get MIME type based in file extension

   100 	CFileExtensionMIMEType * mime = GetMIMETypeL (aFileName);

   101 

   102 	//	Create a new image decoder for MIME type mime

   103 	iImageEncoder = CImageEncoder::FileNewL (

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

   105 		aFileName,

   106 		mime->MIMEType()

   107 		);

   108 	

   109 	CFrameImageData * frame = GetFrameImageDataL (

   110 		mime->FileExtension(),

   111 		aImageQuality

   112 		);

   113 

   114 	//	Start encoding

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

   116 

   117 }

   118 

   119 //=============================================================================

   120 EXPORT_C TInt CImageEditorImageHandler::GetJpegQualityFactorL (

   121     const TDesC & aFileName

   122 	)

   123 {

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

   125 

   126 	//	Clean up old converters

   127 	CleanupConverters();

   128 

   129 	//	Create a new image decoder

   130 	iImageDecoder = CImageDecoder::FileNewL (

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

   132 		aFileName

   133 		);

   134 

   135     //  Get reference to frame image data

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

   137 

   138     //  Get JPEG quality factor

   139     TInt qualityfactor = 100;

   140     if ( image_data.ImageDataCount() > 0 )

   141     {

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

   143     }

   144 

   145 	//	Clean up old converters

   146 	CleanupConverters();

   147 

   148     return qualityfactor;

   149 }

   150 

   151 //=============================================================================

   152 EXPORT_C TInt CImageEditorImageHandler::RenameImage (

   153 	const TDesC	&		aFileNameSrc,

   154 	const TDesC	&		aFileNameDst

   155 	) const

   156 {

   157 	return BaflUtils::RenameFile (

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

   159 		aFileNameSrc, 

   160 		aFileNameDst, 

   161 		0

   162 		);

   163 }

   164 

   165 //=============================================================================

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

   167 {

   168 	return BaflUtils::DeleteFile (

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

   170 		aFileName,

   171 		0

   172 		);

   173 }

   174 

   175 //=============================================================================

   176 EXPORT_C void CImageEditorImageHandler::CleanupConverters()

   177 {

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

   179 

   180 	if (iImageDecoder)

   181 	{

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

   183 

   184 		iImageDecoder->Cancel();

   185 		delete iImageDecoder;

   186 		iImageDecoder = NULL;

   187 	}

   188 	if (iImageEncoder)

   189 	{

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

   191 

   192 		iImageEncoder->Cancel();

   193 		delete iImageEncoder;

   194 		iImageEncoder = NULL;

   195 	}

   196 }

   197 

   198 //=============================================================================

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

   200 {

   201     _LIT8 (KMimeJpeg, "image/jpeg");

   202 

   203     TBuf8<256> mime;

   204     

   205     RFs fs;

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

   207     CleanupClosePushL(fs);

   208     

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

   210 

   211 	CleanupStack::PopAndDestroy();

   212 	

   213 #ifdef ENABLE_DEBUGLOG

   214     TBuf16 <100> mime16;

   215     mime16.Copy(mime);

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

   217 #endif

   218 

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

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

   221 }

   222 

   223 //=============================================================================

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

   225 {

   226     //	Clean up old converters

   227     CleanupConverters();

   228 

   229     TRAPD (err,

   230         //	Create a new image decoder

   231         iImageDecoder = CImageDecoder::FileNewL (

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

   233         aFileName

   234         );

   235     );

   236     CleanupConverters();

   237     if (err != KErrNone)

   238     {

   239         return EFalse;

   240     }

   241     else

   242     {

   243         return ETrue;

   244     }

   245 }

   246 

   247 //=============================================================================

   248 CImageEditorImageHandler::CImageEditorImageHandler ()

   249 {

   250 

   251 }

   252 

   253 //=============================================================================

   254 void CImageEditorImageHandler::ConstructL ()

   255 {

   256 

   257 }

   258 

   259 

   260 //=============================================================================

   261 CFileExtensionMIMEType * CImageEditorImageHandler::GetMIMETypeL (

   262 	const TDesC &	aFileName

   263 	)

   264 {	

   265 

   266 	//	Extract the file extension from aFullFileName

   267 	TParsePtrC fileparser (aFileName);

   268 	TBuf<12> ext;

   269 	if (fileparser.ExtPresent())

   270 	{

   271 		ext.Append (fileparser.Ext());

   272 	}

   273 

   274 	//	Get all supported mime types with file extensions

   275 	RFileExtensionMIMETypeArray mimes;

   276 	iImageEncoder->GetFileTypesL (mimes);

   277 

   278 	//	Get correct mime type based on file extension

   279 	CFileExtensionMIMEType * ret = 0;

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

   281 	{

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

   283 		{

   284 			ret = mimes[i];

   285 			mimes.Remove(i);

   286 			break;

   287 		}

   288 	}

   289 

   290 	//	Delete pointer array

   291 	mimes.ResetAndDestroy();

   292 	

   293 	return ret;

   294 }

   295 

   296 //=============================================================================

   297 CFrameImageData * CImageEditorImageHandler::GetFrameImageDataL (

   298 	const TDesC &		aExt,

   299 	const TInt			aQuality

   300 	) const

   301 {

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

   303     

   304 	CFrameImageData * frameData = CFrameImageData::NewL();

   305 	CleanupStack::PushL (frameData);

   306 

   307 	if (aExt.CompareF (KJpegExtension))

   308 	{

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

   310 		data->iQualityFactor = (100 - aQuality);

   311 		data->iSampleScheme = TJpegImageData::EColor422;

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

   313 	}

   314 	else if (aExt.CompareF (KBmpExtension))

   315 	{

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

   317 		data->iBitsPerPixel = 24;

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

   319 	}

   320 	else

   321 	{

   322 

   323 	}

   324 

   325 	CleanupStack::Pop(); //	frameData

   326 	return frameData;

   327 }

   328 

   329 // End of File