diff -r e1e28b0273b0 -r 93fff7023be8 EngSrc/IEBitmapLoader.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/EngSrc/IEBitmapLoader.cpp	Fri Oct 15 10:18:29 2010 +0900
@@ -0,0 +1,700 @@
+/*
+* Copyright (c) 2009 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: Juha Kauppinen, Mika Hokkanen
+* 
+* Description: Photo Browser
+*
+*/
+// Include files
+#include <hal.h> 
+#include "IEBitmapLoader.h"
+#include "IEFileLoader.h"
+#include "IEEngineUtils.h"
+
+_LIT8(KMimeMbm, "image/x-epoc-mbm");
+_LIT8(KMimeJpeg, "image/jpeg");
+
+#define USE_EXIF_TN
+#define USE_EXIF_TN_CROP
+//#define USE_EXIF_TN_EXT_CROP
+
+#ifdef USE_EXIF_TN
+#include <iclextjpegapi.h>  // For CExtJpegDecoder
+#endif
+
+const TInt KMemoryThresholdForSuperZoom = 12*1024;
+
+
+// ============================ MEMBER FUNCTIONS =========================== \\
+
+CIEBitmapLoader* CIEBitmapLoader::NewL(RFs& aFileServer, MBitmapLoaderObserver& aBitmapLoaderObserver, RCriticalSection* aCritical)
+{
+ 	CIEBitmapLoader* self = new (ELeave) CIEBitmapLoader(aFileServer, aBitmapLoaderObserver, aCritical);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop();
+	return self;
+}
+
+CIEBitmapLoader::~CIEBitmapLoader()
+    {
+    DP0_IMAGIC(_L("CIEBitmapLoader::~CIEBitmapLoader++"));
+  	if(iImageDecoder)
+  	    {
+  	    iImageDecoder->Cancel();
+		delete iImageDecoder;
+		iImageDecoder = NULL;	
+        }
+  	
+    if (iExifBitmap)
+        {
+        delete iExifBitmap;
+        iExifBitmap = NULL;
+        }
+#ifdef DECODE_FROM_BUFFER    
+    if(iSourceData) 
+        {
+        delete iSourceData;
+        iSourceData = NULL;
+        }
+#endif
+    DP0_IMAGIC(_L("CIEBitmapLoader::~CIEBitmapLoader--"));
+  	}
+ 
+CIEBitmapLoader::CIEBitmapLoader(RFs& aFileServer, MBitmapLoaderObserver& aBitmapLoaderObserver, RCriticalSection* aCritical)
+    //:CActive(EPriorityLow),    
+    :CActive(EPriorityStandard),
+    //:CActive(EPriorityUserInput),
+    //:CActive(CActive::EPriorityHigh),
+    iFileServer(aFileServer), 
+    iBitmapLoaderObserver(aBitmapLoaderObserver),
+#ifdef DECODE_FROM_BUFFER    
+    iSourceData(NULL), 
+#endif        
+    iCritical(aCritical)
+    {
+    }
+
+void CIEBitmapLoader::ConstructL()
+    {
+	CActiveScheduler::Add(this);
+	iExifTn = NULL;
+	iImageDecoder = NULL;
+	iImageArrayMode = EImages;
+	iOutputBitmap = NULL;
+	iExifBitmap = NULL;
+#ifdef GET_DECODER_UID
+	decoderUid = CIEEngineUtils::GetImageDecoderUid();	
+#else
+	decoderUid = KNullUid;
+#endif
+    }
+
+void CIEBitmapLoader::CropImageL(CFbsBitmap* aOutput, CFbsBitmap* aInput) const
+    {
+    const TInt KMaxScanLine = 320 * 3;
+    TSize inputSize = aInput->SizeInPixels();
+    TSize outputSize = aOutput->SizeInPixels();
+    TDisplayMode mode = aOutput->DisplayMode();
+    
+    // need to have same display mode and output cannot be bigger
+    if (mode != aInput->DisplayMode() || 
+        outputSize.iWidth > inputSize.iWidth ||
+        outputSize.iHeight > inputSize.iHeight)
+        User::Leave(KErrNotSupported);
+
+    TInt len = CFbsBitmap::ScanLineLength(outputSize.iWidth, mode);
+    TBuf8<KMaxScanLine> buf;
+    if (len > KMaxScanLine)
+        {
+        User::Leave(KErrOverflow);
+        }
+    
+    TPoint point((inputSize.iWidth - outputSize.iWidth + 1) / 2,
+                 (inputSize.iHeight - outputSize.iHeight + 1) / 2);
+    for (TInt i = 0;i < outputSize.iHeight;i++, point.iY++)
+        {
+        aInput->GetScanLine(buf, point, outputSize.iWidth, mode);
+        aOutput->SetScanLine(buf, i);
+        }
+    }
+
+void CIEBitmapLoader::RunL()
+    {
+    DP0_IMAGIC(_L("CIEBitmapLoader::RunL++"));
+    
+    SetPriority(EPriorityStandard);
+    iThumbRes = ENotDefined;
+	TInt error = iStatus.Int();
+	
+	DP1_IMAGIC(_L("CIEBitmapLoader::RunL - Error: %d"),error);
+	
+	if(iImageDecoder)
+	    {
+        delete iImageDecoder;
+        iImageDecoder = NULL;   
+	    }
+	
+#ifdef DECODE_FROM_BUFFER    
+    if(iSourceData) 
+        {
+        delete iSourceData;
+        iSourceData = NULL;
+        }
+#endif
+	
+#ifdef USE_EXIF_TN
+    if (iExifTn)
+        {
+        delete iExifTn;
+        iExifTn = NULL;
+        }   
+	
+	if(iUseExifTn && iImageData && error == KErrNone) 
+	    {
+	    iImageData->SetImageReady(EExifThumb, ETrue);
+	    
+	    // Crop exif thumbnail
+	    if (iExifBitmap && iOutputBitmap)
+	        {
+	        TRAP(error, CropImageL(iOutputBitmap, iExifBitmap));
+	        }
+	    }
+
+	if (iExifBitmap)
+	    {
+	    delete iExifBitmap;
+	    iExifBitmap = NULL;
+	    }
+	
+    iOutputBitmap = NULL;
+#endif
+    
+	iBitmapLoaderObserver.BitmapsLoadedL(error);
+	
+	DP0_IMAGIC(_L("CIEBitmapLoader::RunL--"));
+    }
+
+void CIEBitmapLoader::DoCancel()
+    {
+    }
+
+TInt CIEBitmapLoader::RunError(TInt aError)
+    {
+    DP1_IMAGIC(_L("CIEBitmapLoader::RunError - Error: %d"),aError);
+    
+    return KErrNone;
+    }
+
+void CIEBitmapLoader::GetOneBitmapL(CImageData* aImageData, CFbsBitmap* aBitmap, TThumbSize aThumbRes)
+    {
+    DP0_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL++"));
+    DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - TN res: %d"), aThumbRes);
+
+    ASSERT(iImageDecoder == NULL);    
+    
+    iThumbRes = aThumbRes;
+    TBool thumbnailExists = ETrue;
+    //TBool isFileJpg = ETrue;
+    iUseExifTn = EFalse;
+    iImageData = aImageData;
+    iOutputBitmap = aBitmap;
+    
+#ifdef USE_EXIF_TN    
+    CExtJpegDecoder* extImageDecoder = NULL;
+#endif    
+    
+    TFileName fileName;
+    if(aThumbRes == EFullSize)
+        {
+        if(iImageData->IsImageReady(EFullSize))
+            {
+            //SetPriority(EPriorityUserInput);
+            iImageData->GetFileName(fileName, EFullSize);
+            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - filename: %S"), &fileName);
+            }
+        else
+            {
+            //If TN is not ready we just return
+            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - TN res: %d, not found"), aThumbRes);
+            thumbnailExists = EFalse;
+            //iBitmapLoaderObserver.BitmapsLoadedL(KErrNotFound);
+            User::Leave(KErrNotFound);
+            return;
+            }
+        }
+    else if(aThumbRes == ESize128x128)
+        {
+#ifdef USE_64X64_BITMAP_TN
+        //isFileJpg = EFalse;
+        iImageData->GetFileName(fileName, ESize128x128);
+        DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - filename: %S"), &fileName);
+        TInt error = aBitmap->Load(fileName);
+        if (error == KErrNone)
+            {
+            SetPriority(EPriorityUserInput);
+            SetActive();
+            TRequestStatus* status = &iStatus;
+            User::RequestComplete(status, KErrNone);
+            return;
+            }
+        
+#ifdef USE_EXIF_TN
+        else if(iImageData->IsImageReady(EFullSize))
+            {
+            iUseExifTn = ETrue;
+            iImageData->GetFileName(fileName, EFullSize);
+            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - filename: %S"), &fileName);
+            }
+#endif
+        else
+            {
+            //If TN is not ready we just return
+            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - TN res: %d, not found"), aThumbRes);
+            thumbnailExists = EFalse;     
+            iImageData->SetImageReady(EExifThumb, EFalse);
+            User::Leave(KErrNotFound);
+            return;
+            }
+#else
+        if(iImageData->IsImageReady(ESize128x128))
+            {
+            SetPriority(EPriorityUserInput);
+            //isFileJpg = EFalse;
+            iImageData->GetFileName(fileName, ESize128x128);
+            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - filename: %S"), &fileName);
+            }
+#ifdef USE_EXIF_TN
+        //else if(iImageData->IsImageReady((TThumbSize)(EFullSize|EExifThumb)))
+        else if(iImageData->IsImageReady(EExifThumb))
+            {
+            SetPriority(EPriorityUserInput);
+            iUseExifTn = ETrue;
+            iImageData->GetFileName(fileName, EFullSize);
+            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - filename: %S"), &fileName);
+            }
+#endif
+        else
+            {
+            //If TN is not ready we just return
+            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - TN res: %d, not found"), aThumbRes);
+            
+            thumbnailExists = EFalse;
+            iImageData->SetImageReady(EExifThumb, EFalse);
+            //iBitmapLoaderObserver.BitmapsLoadedL(KErrNotFound);
+            User::Leave(KErrNotFound);
+            return;
+            }
+#endif
+        }
+    
+    else if(aThumbRes == ESize512x512)
+        {
+        if(iImageData->IsImageReady(ESize512x512))
+            {
+            iImageData->GetFileName(fileName, ESize512x512);
+            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - filename: %S"), &fileName);
+            }
+        else
+            {
+            //If TN is not ready we just return
+            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - TN res: %d, not found"), aThumbRes);
+            thumbnailExists = EFalse;
+            iImageData->SetImageReady(EExifThumb, EFalse);
+            User::Leave(KErrNotFound);
+            return;
+            }
+        }
+    else if(aThumbRes == ESize32x32)
+        {
+        if(iImageData->IsImageReady(ESize32x32))
+            {
+            //isFileJpg = EFalse;
+            iImageData->GetFileName(fileName, ESize32x32);
+            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - filename: %S"), &fileName);
+            TInt error = aBitmap->Load(fileName);
+            if (error == KErrNone)
+                {
+                SetPriority(EPriorityUserInput);
+                SetActive();
+                TRequestStatus* status = &iStatus;
+                User::RequestComplete(status, KErrNone);
+                return;
+                }
+            }
+#ifdef USE_EXIF_TN
+        else if(iImageData->IsImageReady(EFullSize))
+            {
+            iUseExifTn = ETrue;
+            iImageData->GetFileName(fileName, EFullSize);
+            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - filename: %S"), &fileName);
+            }
+#endif
+        else
+            {
+            //If TN is not ready we just return
+            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - TN res: %d, not found"), aThumbRes);
+            thumbnailExists = EFalse;     
+            iImageData->SetImageReady(EExifThumb, EFalse);
+            User::Leave(KErrNotFound);
+            return;
+            }
+        }
+            
+    if(thumbnailExists)
+        {
+        TInt error = KErrNone;
+        
+#ifdef USE_EXIF_TN
+        if (iUseExifTn)
+            {
+            ASSERT(iExifTn == NULL);
+            TRAP(error, iExifTn = CIEEngineUtils::ReadExifThumbnailL(iFileServer, fileName));
+        
+            DP0_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - create decoder"));
+            if (error == KErrNone)
+                {
+                DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL data size: %d"), iExifTn->Length());
+                TRAP(error, extImageDecoder = CExtJpegDecoder::DataNewL(iFileServer, *iExifTn, /*KMimeJpeg,*/ CImageDecoder::EOptionNone));
+                iImageDecoder = extImageDecoder;
+                }
+            else
+                {
+                DP0_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - no exif thumb"));
+                iImageData->SetImageReady(EExifThumb, EFalse);
+                }
+
+            DP2_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - Image exif thumb decoder - TN res: %d, error: %d"), aThumbRes, error);
+            }
+        else
+#endif
+            {
+            DP0_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - create decoder"));
+            /*CExtJpegDecoder * extImageDecoder;
+            TRAP(error, iImageDecoder = extImageDecoder = CExtJpegDecoder::FileNewL(
+                    CExtJpegDecoder::EHwImplementation,
+                    iFileServer, 
+                    fileName,
+                    CImageDecoder::EPreferFastDecode));*/
+#ifdef DECODE_FROM_BUFFER    
+            if(iSourceData) 
+                {
+                delete iSourceData;
+                iSourceData = NULL;
+                }
+            
+            RFile jpgFile;
+            TInt fileSize;
+            
+            User::LeaveIfError(jpgFile.Open(iFileServer, fileName, EFileRead));
+            jpgFile.Size(fileSize);
+            iSourceData = HBufC8::NewL(fileSize);
+            
+            TPtr8 buffer = iSourceData->Des();
+            
+            jpgFile.Read(buffer, fileSize);
+            
+            jpgFile.Close();
+            
+            iImageDecoder = CImageDecoder::DataNewL(
+                    iFileServer, 
+                    *iSourceData, 
+                    //CImageDecoder::EOptionNone,
+                    CImageDecoder::TOptions(CImageDecoder::EPreferFastDecode|CImageDecoder::EOptionAlwaysThread),
+                    KNullUid, 
+                    KNullUid, 
+                    decoderUid);
+#else
+            TRAP(error, iImageDecoder = CImageDecoder::FileNewL(
+                    iFileServer, 
+                    fileName,
+                    //CImageDecoder::EPreferFastDecode,
+                    CImageDecoder::TOptions(CImageDecoder::EPreferFastDecode|CImageDecoder::EOptionAlwaysThread),
+                    KNullUid,
+                    KNullUid,
+                    decoderUid));
+#endif
+            }
+
+        if(error != KErrNone)
+            {
+            DP2_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - Image Decoder - TN res: %d, error: %d"), aThumbRes, error);
+            delete iImageDecoder;
+            iImageDecoder = NULL; 
+
+#ifdef USE_EXIF_TN
+            if (iExifTn)
+                {
+                delete iExifTn;
+                iExifTn = NULL;
+                }
+#endif
+//            iBitmapLoaderObserver.BitmapsLoadedL(error);
+            User::Leave(error);
+            return;
+            }
+        
+        TFrameInfo frameInfo = iImageDecoder->FrameInfo();
+        if(aThumbRes == ESize128x128)
+            iImageDecoder->SetDecoderThreadPriority(/*EPriorityNormal*/EPriorityMuchMore);
+        else
+            iImageDecoder->SetDecoderThreadPriority(EPriorityLess);
+        
+        
+#ifdef _IMAGIC_DEBUG
+        TInt mem = 0;
+        TInt ret = HAL::Get(HALData::EMemoryRAMFree, mem);
+#endif
+        DP0_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - #1"));        
+        TSize frameSize = frameInfo.iFrameCoordsInPixels.Size();
+        //If we are loading full resolution image, we have to create smaller target bitmap 
+        //to save memory and to improve speed of further image processing
+        if(aThumbRes == EFullSize)
+            {
+            TInt mem = 0;
+            TInt ret = HAL::Get(HALData::EMemoryRAMFree, mem);
+            if(mem < KMemoryThresholdForSuperZoom*1024)
+                {
+                //User::Leave(KErrNoMemory);
+#ifdef USE_OOM            	
+                ROomMonitorSession oomMonitor;
+                oomMonitor.Connect();
+                TInt errorCode = oomMonitor.RequestFreeMemory( 1024*KMemoryThresholdForSuperZoom );
+                
+                if ( errorCode != KErrNone )
+                    {
+                    // try one more time 
+                    errorCode = oomMonitor.RequestFreeMemory( 1024*KMemoryThresholdForSuperZoom );
+                    }
+                oomMonitor.Close();
+#endif                
+                }
+                
+            
+            //TSize tgtSize(1024, 1024);
+            //DP0_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - #3"));
+            //TargetDecodingSize(tgtSize, frameSizue);
+            if(frameSize.iHeight >= 1024 || frameSize.iWidth >= 1024)
+                {
+                frameSize.iHeight = Min(1024, iBitmapLoaderObserver.GetGleMaxRes());
+                frameSize.iWidth = Min(1024, iBitmapLoaderObserver.GetGleMaxRes());
+                }
+            else
+                {
+                frameSize.iHeight=512;
+                frameSize.iWidth=512;
+                }
+            }   
+        
+        // Crop thumbnail if aspect ratio is not same as full size image
+#ifdef USE_EXIF_TN
+#ifdef USE_EXIF_TN_CROP
+        if (iUseExifTn)
+            {
+#ifdef USE_EXIF_TN_EXT_CROP              
+            TInt cap;
+            TRAP(error, cap = extImageDecoder->CapabilitiesL());
+            if (error == KErrNone && cap & CExtJpegDecoder::ECapCropping)
+#endif                
+                {
+                TReal aspectRatio = aImageData->GetAspectRatio();
+                TReal thumbAspectRatio = TReal(frameSize.iWidth) / frameSize.iHeight; 
+            
+                // calculate final frame size
+                //if (frameSize.iWidth / frameSize.iHeight != size.iWidth / size.iHeight)
+                if (thumbAspectRatio != aspectRatio)
+                    {
+                    TRect finalFrameRect;
+                    finalFrameRect.SetSize(frameSize);
+                    if (thumbAspectRatio < aspectRatio)
+                        {
+                        TInt h = frameSize.iWidth / aspectRatio;
+                        h += h & 1;
+                        finalFrameRect.SetHeight(h);
+                        }
+                    else
+                        {
+                        TInt w = frameSize.iHeight * aspectRatio;
+                        w += w & 1;
+                        finalFrameRect.SetWidth(w);
+                        }
+                    
+                    finalFrameRect.Move(
+                            (frameSize.iWidth - finalFrameRect.Width() + 1) / 2,
+                            (frameSize.iHeight - finalFrameRect.Height() + 1) / 2);
+#ifdef USE_EXIF_TN_EXT_CROP                    
+                    TRAP(error, extImageDecoder->SetCroppingL(finalFrameRect));
+#else         
+                    // Create temporal bitmap
+                    iExifBitmap = new CFbsBitmap;
+                    if (iExifBitmap == NULL)
+                        error = KErrGeneral;
+                    else
+                        error = iExifBitmap->Create(frameSize, frameInfo.iFrameDisplayMode);
+                    aBitmap = iExifBitmap;                 
+#endif
+                    // Reduce final image size
+                    if (error == KErrNone)
+                        {
+                        frameSize.iWidth = finalFrameRect.Width();
+                        frameSize.iHeight = finalFrameRect.Height();
+                        }                    
+                    }
+                }
+            }
+#endif        
+#endif        
+        
+        if (error == KErrNone)
+            {
+#ifdef USE_RGBA
+            error = iOutputBitmap->Create(frameSize, EColor16MU);
+#else
+            error = iOutputBitmap->Create(frameSize, frameInfo.iFrameDisplayMode);
+#endif
+            }
+        
+        if (error == KErrNone)
+            {
+#ifdef USE_EXIF_TN
+            /*if(iUseExifTn)
+                {
+                TRAP(error, iExifDecoder->Convert(&iStatus, *aBitmap));
+                }
+            else*/
+#endif
+                {
+                TRAP(error, iImageDecoder->Convert(&iStatus, *aBitmap));
+                }
+            }
+        
+        if(error != KErrNone)
+            {
+            DP2_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - Image Decoder convert - TN res: %d, error: %d"), aThumbRes, error);
+            delete iImageDecoder;
+            iImageDecoder = NULL; 
+            //aImageData->iGridData.iCorrupted = ETrue;//mika. added 03.06. maybe not good idea????????
+            User::Leave(error);
+            return;
+            }
+        else
+            {
+            DP1_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL - Decoding started TN res: %d"), aThumbRes);
+            
+            if(!IsActive())
+                SetActive();
+            }
+        }
+    
+    DP0_IMAGIC(_L("CIEBitmapLoader::GetOneBitmapL--"));
+    }
+
+/**
+Opens file and creates file pointer
+@param aFileName The specified file to open
+@return imageInMemoryPtr A Pointer to iImageInMemory
+@leave System-wide error codes
+*/  
+/*TPtr8 CIEBitmapLoader::LoadImageIntoMemoryLC(const TDesC& aFileName)
+    {
+    RFile file;
+    TInt fileSize = 0;
+
+    // Open the file for decoding
+    User::LeaveIfError(file.Open(iFileServer, aFileName, EFileRead));
+    file.Size(fileSize);    
+
+    //HBufC8* imageInMemory = HBufC8::NewMaxLC(fileSize);
+    HBufC8* imageInMemory = HBufC8::NewMaxL(fileSize);
+    TPtr8 imageInMemoryPtr = imageInMemory->Des();
+    if(file.SubSessionHandle())
+        {
+        User::LeaveIfError(file.Read(imageInMemoryPtr));    
+        }
+        
+    file.Close();
+
+    return imageInMemoryPtr;
+    }*/
+
+void CIEBitmapLoader::TargetDecodingSize(TSize aTgtSize, TSize& aSrcSize)
+    {
+    DP0_IMAGIC(_L("CIEBitmapLoader::TargetDecodingSize++"));
+    
+    DP2_IMAGIC(_L("CIEBitmapLoader::TargetDecodingSize - Tgt size.iHeigth: %d, Tgt size.iWidth: %d"),aTgtSize.iHeight, aTgtSize.iWidth);
+    DP2_IMAGIC(_L("CIEBitmapLoader::TargetDecodingSize - Src size.iHeigth: %d, Src size.iWidth: %d"),aSrcSize.iHeight, aSrcSize.iWidth);
+    
+    // up to 32 times downscale in scaler
+    for (TInt i = 0;i < 5;i++)
+        {
+        if (aSrcSize.iWidth < aTgtSize.iWidth * 2 ||
+            aSrcSize.iHeight < aTgtSize.iHeight * 2) 
+            {
+            break;
+            }
+            
+            aSrcSize.iWidth >>= 1;
+            aSrcSize.iHeight >>= 1;
+        }
+    
+    // Check that we do not create odd resolution size thumbnail
+    if(aSrcSize.iHeight & 1)
+        aSrcSize.iHeight++;
+    if(aSrcSize.iWidth & 1)
+        aSrcSize.iWidth++;
+    
+    DP2_IMAGIC(_L("CIEBitmapLoader::TargetDecodingSize - Src size.iHeigth: %d, Src size.iWidth: %d"),aSrcSize.iHeight, aSrcSize.iWidth);
+     
+    DP0_IMAGIC((_L("CIEBitmapLoader::TargetDecodingSize--")));
+    }
+
+
+void CIEBitmapLoader::CancelFullSizeLoading()
+    {
+    //Cancel only if full resolution loading was on
+    DP0_IMAGIC(_L("CIEBitmapLoader::CancelFullSizeLoading++"));
+    if(iThumbRes == EFullSize)
+        {
+        DP0_IMAGIC(_L("CIEBitmapLoader::CancelFullSizeLoading 1"));        
+        if(iImageDecoder)
+            {
+            iImageDecoder->Cancel();
+            delete iImageDecoder;
+            iImageDecoder = NULL;   
+            }
+        DP0_IMAGIC(_L("CIEBitmapLoader::CancelFullSizeLoading 2"));
+        if(IsActive())
+            {
+            Cancel();
+            DP0_IMAGIC(_L("CIEBitmapLoader::CancelFullSizeLoading 21"));
+            iBitmapLoaderObserver.BitmapsLoadedL(KErrCancel);
+            }
+#ifdef DECODE_FROM_BUFFER    
+        if(iSourceData) 
+            {
+            DP0_IMAGIC(_L("CIEBitmapLoader::CancelFullSizeLoading 3"));
+            delete iSourceData;
+            iSourceData = NULL;
+            }
+#endif
+        DP0_IMAGIC(_L("CIEBitmapLoader::CancelFullSizeLoading 4"));
+        }
+        DP0_IMAGIC(_L("CIEBitmapLoader::CancelFullSizeLoading--"));
+    }
+
+void CIEBitmapLoader::SetImageDataMode(TImageArrayMode aMode)
+    {
+    iImageArrayMode = aMode;
+    }
+
+
+// EOF