1 /*

     2 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "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 *

    14 * Description:  Downscales images when needed

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include "cpimimagescaler.h"

    21 #include "logger.h"

    22 

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

    24 

    25 // -----------------------------------------------------------------------------

    26 // CPIMImageScaler::CPIMImageScaler

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

    28 // might leave.

    29 // -----------------------------------------------------------------------------

    30 //

    31 CPIMImageScaler::CPIMImageScaler() :

    32         CActive(EPriorityStandard), iState(EReady), iError(KErrNone),

    33         iFbsSessionConnected(EFalse)

    34 {

    35     JELOG2(EPim);

    36     // Add object to the active scheduler

    37     CActiveScheduler::Add(this);

    38 }

    39 

    40 // -----------------------------------------------------------------------------

    41 // CPIMImageScaler::ConstructL

    42 // Second phase constructor

    43 // -----------------------------------------------------------------------------

    44 //

    45 void CPIMImageScaler::ConstructL()

    46 {

    47     JELOG2(EPim);

    48     User::LeaveIfError(iFileServer.Connect());

    49 }

    50 

    51 // -----------------------------------------------------------------------------

    52 // CPIMImageScaler::Complete

    53 // Performs various cleanups

    54 // -----------------------------------------------------------------------------

    55 //

    56 void CPIMImageScaler::Complete(TInt aError)

    57 {

    58     JELOG2(EPim);

    59     if (KErrNone == aError)

    60     {

    61         iState = ECompleted;

    62     }

    63     else

    64     {

    65         iError = aError;

    66         iState = EError;

    67     }

    68     iWait->AsyncStop();

    69 }

    70 

    71 // -----------------------------------------------------------------------------

    72 // CPIMImageScaler::NewL

    73 // Two-phased constructor.

    74 // -----------------------------------------------------------------------------

    75 //

    76 CPIMImageScaler* CPIMImageScaler::NewL()

    77 {

    78     JELOG2(EPim);

    79     CPIMImageScaler* self = new(ELeave) CPIMImageScaler;

    80     CleanupStack::PushL(self);

    81     self->ConstructL();

    82     CleanupStack::Pop(self);

    83     return self;

    84 }

    85 

    86 // Destructor

    87 CPIMImageScaler::~CPIMImageScaler()

    88 {

    89     JELOG2(EPim);

    90     delete iImageReader;

    91     delete iImageWriter;

    92     delete iBitmapScaler;

    93     delete iBitmap;

    94     if (iFbsSessionConnected)

    95     {

    96         RFbsSession::Disconnect();

    97     }

    98     delete iImage;

    99     delete iWait;

   100     iFileServer.Close();

   101 }

   102 

   103 // -----------------------------------------------------------------------------

   104 // CPIMImageScaler::ScaleL

   105 // Opens a JPEG image, checks its size and scales to 80x96 if larger.

   106 // -----------------------------------------------------------------------------

   107 //

   108 HBufC8* CPIMImageScaler::ScaleL(TDesC8& aSrcImage)

   109 {

   110     JELOG2(EPim);

   111     __ASSERT_ALWAYS(iState == EReady, User::Leave(KErrNotReady));

   112     // First we create the decoder to read the image

   113     CImageDecoder* imageReader = NULL;

   114     TRAPD(err, imageReader = CImageDecoder::DataNewL(iFileServer, aSrcImage));

   115     if (err == KErrNoMemory)

   116     {

   117         User::Leave(err);

   118     }

   119     else if (err != KErrNone)

   120     {

   121         User::Leave(KErrAbort);

   122     }

   123 

   124     delete iImageReader;

   125     iImageReader = imageReader;

   126     // we create bitmap for the raw image

   127     const TFrameInfo& frameInfo = iImageReader->FrameInfo();

   128     if (!CheckSize(frameInfo.iOverallSizeInPixels))

   129     {

   130         // we don't have to resize

   131         delete iImageReader;

   132         iImageReader = NULL;

   133         return aSrcImage.AllocL();

   134     }

   135 

   136     if (!iFbsSessionConnected)

   137     {

   138         User::LeaveIfError(RFbsSession::Connect());

   139         iFbsSessionConnected = ETrue;

   140     }

   141     if (!iBitmap)

   142     {

   143         iBitmap = new(ELeave) CFbsBitmap;

   144     }

   145     iBitmap->Create(frameInfo.iOverallSizeInPixels, frameInfo.iFrameDisplayMode);

   146 

   147     // We create the encoder as well

   148     CImageEncoder* imageWriter = CImageEncoder::DataNewL(iImage,

   149                                  CImageEncoder::EOptionNone, KImageTypeJPGUid);

   150     delete iImageWriter;

   151     iImageWriter = imageWriter;

   152     // and scaler

   153     if (!iBitmapScaler)

   154     {

   155         iBitmapScaler = CBitmapScaler::NewL();

   156     }

   157     if (!iWait)

   158     {

   159         iWait = new(ELeave) CActiveSchedulerWait;

   160     }

   161 

   162     iState = EOpening;

   163     iImageReader->Convert(&iStatus, *iBitmap);

   164     SetActive();

   165     iWait->Start();

   166 

   167     // These can't be reused

   168     delete iBitmap;

   169     iBitmap = NULL;

   170     delete iImageReader;

   171     iImageReader = NULL;

   172     delete iImageWriter;

   173     iImageWriter = NULL;

   174 

   175     if (ECompleted != iState)

   176     {

   177         if (iState == EError)

   178         {

   179             User::Leave(iError);

   180         }

   181         else

   182         {

   183             User::Leave(KErrUnknown);

   184         }

   185     }

   186     HBufC8* retVal = iImage;

   187     iImage = NULL;

   188     iState = EReady;

   189     return retVal;

   190 }

   191 

   192 // -----------------------------------------------------------------------------

   193 // CPIMImageScaler::CheckSize

   194 // Checks image size and resizes if necessary

   195 // -----------------------------------------------------------------------------

   196 //

   197 TBool CPIMImageScaler::CheckSize(TSize aSize)

   198 {

   199     JELOG2(EPim);

   200     if ((aSize.iHeight > KThumbHeight) || (aSize.iWidth > KThumbWidth))

   201     {

   202         // need to resize

   203         return ETrue;

   204     }

   205     return EFalse;

   206 }

   207 

   208 // -----------------------------------------------------------------------------

   209 // CPIMImageScaler::Encode

   210 // Encodes the image

   211 // -----------------------------------------------------------------------------

   212 //

   213 void CPIMImageScaler::Encode()

   214 {

   215     JELOG2(EPim);

   216     iState = EEncoding;

   217     iImageWriter->Convert(&iStatus, *iBitmap);

   218     SetActive();

   219 }

   220 

   221 // -----------------------------------------------------------------------------

   222 // CPIMImageScaler::RunL

   223 // Active object run method

   224 // -----------------------------------------------------------------------------

   225 //

   226 void CPIMImageScaler::RunL()

   227 {

   228     JELOG2(EPim);

   229     if (iStatus != KErrNone)

   230     {

   231         // Error has occured; inform java

   232         Complete(iStatus.Int());

   233     }

   234     else

   235     {

   236         switch (iState)

   237         {

   238         case EOpening:

   239         {

   240             TSize KThumbSize(KThumbWidth, KThumbHeight);

   241             iState = EScaling;

   242             iBitmapScaler->Scale(&iStatus, *iBitmap, KThumbSize, ETrue);

   243             SetActive();

   244             break;

   245         }

   246         case EScaling:

   247         {

   248             Encode();

   249             break;

   250         }

   251         case EEncoding:

   252         {

   253             Complete(KErrNone);

   254             break;

   255         }

   256         default:

   257         {

   258             // unknown state

   259             __ASSERT_DEBUG(EFalse, User::Invariant());

   260         }

   261         }

   262     }

   263 }

   264 

   265 // -----------------------------------------------------------------------------

   266 // CPIMImageScaler::DoCancel

   267 // Active object cancel method

   268 // -----------------------------------------------------------------------------

   269 void CPIMImageScaler::DoCancel()

   270 {

   271     JELOG2(EPim);

   272     if (iBitmapScaler)

   273     {

   274         iBitmapScaler->Cancel();

   275     }

   276     if (iImageReader)

   277     {

   278         iImageReader->Cancel();

   279     }

   280     if (iImageWriter)

   281     {

   282         iImageWriter->Cancel();

   283     }

   284     iState = EReady;

   285 }

   286 

   287 //  End of File