1 /*

     2 * Copyright (c) 2007 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:  Implementation of Camera image encoder

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 #include <imageconversion.h>

    22 #include <ExifRead.h>

    23 #include <ecam.h> // MCameraBuffer

    24 

    25 #include <eikenv.h>

    26 

    27 #include "camlogging.h"

    28 #include "camfilesaveutility.h"

    29 #include "cambuffershare.h"

    30 

    31 #include "camimageencoder.h"

    32 

    33 // ===========================================================================

    34 // Local constants

    35 

    36 // Encoding flags

    37 static const CImageEncoder::TOptions KConversionOptions =

    38   CImageEncoder::EOptionAlwaysThread;

    39 

    40 // Other constants

    41 static const TInt KImageIndex = 0;

    42 static const TInt KPriority   = CActive::EPriorityHigh;

    43 

    44 _LIT8( KMimeTypeDesc8, "image/jpeg" );

    45 

    46 

    47 // ===========================================================================

    48 // public constructor and destructor

    49 

    50 // ---------------------------------------------------------------------------

    51 // 2-phase constructor

    52 // ---------------------------------------------------------------------------

    53 //

    54 CCamImageEncoder* 

    55 CCamImageEncoder::NewL( MCamImageEncoderObserver& aObserver )

    56   {

    57   CCamImageEncoder* self = 

    58       new (ELeave) CCamImageEncoder( aObserver );

    59 

    60   CleanupStack::PushL( self );

    61   self->ConstructL();

    62   CleanupStack::Pop( self );

    63 

    64   return self;  

    65   }

    66 

    67 // ---------------------------------------------------------------------------

    68 // Destructor

    69 // ---------------------------------------------------------------------------

    70 //

    71 CCamImageEncoder::~CCamImageEncoder()

    72   {

    73   PRINT( _L("Camera => ~CCamImageEncoder") );

    74   Cancel();

    75 

    76   ReleaseEncoder();

    77   SetInputBuffer( NULL );

    78 

    79   PRINT( _L("Camera <= ~CCamImageEncoder") );

    80   }

    81 

    82 // ===========================================================================

    83 // public methods

    84 

    85 // ---------------------------------------------------------------------------

    86 // StartConversionL

    87 // ---------------------------------------------------------------------------

    88 //

    89 void

    90 CCamImageEncoder::StartConversionL( CCamBufferShare* aBuffer )

    91   {

    92   PRINT( _L("Camera => CCamImageEncoder::StartConversionL") );

    93 

    94   // Cancel any previous action

    95   Cancel();

    96 

    97   ReleaseEncoder();

    98 

    99   if( aBuffer

   100    && aBuffer->SharedBuffer() )   

   101     {

   102     // Store the bitmap data. 

   103     // Need to release old buffer and reserve given one.

   104     SetInputBuffer( aBuffer );

   105 

   106     PRINT( _L("Camera <> CCamImageEncoder: Creating encoder..") );

   107     iEncoder = CImageEncoder::DataNewL( iEncodedData, 

   108                                         KMimeTypeDesc8(), 

   109                                         KConversionOptions );

   110 

   111     PRINT( _L("Camera <> CCamImageEncoder: get source bitmap..") );

   112     MCameraBuffer* buffer( iSharedInput->SharedBuffer()   );

   113     CFbsBitmap&    bitmap( buffer->BitmapL( KImageIndex ) );

   114 

   115 

   116     PRINT( _L("Camera <> CCamImageEncoder: start conversion..") );

   117     iEncoder->Convert( &iStatus, bitmap );

   118     SetActive();

   119     }

   120   else

   121     {

   122     PRINT( _L("Camera <> CCamImageEncoder: No bitmap provided, leave..") );

   123     User::Leave( KErrNotFound );    

   124     }

   125 

   126   PRINT( _L("Camera <= CCamImageEncoder::StartConversionL") );

   127   }

   128 

   129 

   130 // ===========================================================================

   131 // from CActive

   132 

   133 // ---------------------------------------------------------------------------

   134 // virtual DoCancel

   135 // ---------------------------------------------------------------------------

   136 //

   137 void 

   138 CCamImageEncoder::DoCancel()

   139   {

   140   PRINT( _L("Camera => CCamImageEncoder::DoCancel") );

   141 

   142   if( iEncoder )

   143     {

   144     iEncoder->Cancel();

   145     }

   146 

   147   ReleaseEncoder();

   148   SetInputBuffer( NULL );

   149 

   150   PRINT( _L("Camera <= CCamImageEncoder::DoCancel") );

   151   }

   152 

   153 

   154 // ---------------------------------------------------------------------------

   155 // virtual RunL

   156 // ---------------------------------------------------------------------------

   157 //

   158 void 

   159 CCamImageEncoder::RunL()

   160   {

   161   PRINT1( _L("Camera => CCamImageEncoder::RunL, iStatus:%d"), iStatus.Int() );

   162 

   163   switch( iStatus.Int() )

   164     {

   165     case KErrNone :

   166       {

   167       SetInputBuffer( NULL );

   168 

   169       // Notify observer

   170       NotifyObserver( KErrNone );

   171       

   172       // Source data and encoder not needed anymore

   173       ReleaseEncoder();

   174       

   175       break;

   176       }

   177     case KErrCancel :

   178     default :

   179       {

   180       User::Leave( iStatus.Int() );

   181       break;

   182       }

   183     }

   184 

   185   PRINT( _L("Camera <= CCamImageEncoder::RunL") );

   186   }

   187 

   188 

   189 // ---------------------------------------------------------------------------

   190 // virtual RunError

   191 // ---------------------------------------------------------------------------

   192 //

   193 TInt 

   194 CCamImageEncoder::RunError( TInt aError )

   195   {

   196   PRINT1( _L("Camera <= CCamImageEncoder::RunError(%d)"), aError );

   197 

   198   ReleaseEncoder();

   199   SetInputBuffer( NULL );

   200 

   201   // Leave has occurred in RunL.

   202   // Notify observer with error and NULL data.

   203   NotifyObserver( aError );

   204 

   205   PRINT( _L("Camera <= CCamImageEncoder::RunError") );

   206   return KErrNone;

   207   }

   208 

   209 

   210 // ===========================================================================

   211 // Private methods

   212 

   213 // ---------------------------------------------------------------------------

   214 // SetInputBuffer

   215 // ---------------------------------------------------------------------------

   216 //

   217 void

   218 CCamImageEncoder::SetInputBuffer( CCamBufferShare* aBuffer )

   219   {

   220   if( iSharedInput )

   221     {

   222     iSharedInput->Release();

   223     iSharedInput = NULL;

   224     }

   225 

   226   iSharedInput = aBuffer;

   227 

   228   if( iSharedInput )

   229     {

   230     iSharedInput->Reserve();

   231     }

   232   }

   233 

   234 void 

   235 CCamImageEncoder::ReleaseEncoder()

   236   {

   237   delete iEncoder;

   238   iEncoder = NULL;

   239 

   240   delete iEncodedData;

   241   iEncodedData = NULL;

   242   }

   243 

   244 

   245 // ---------------------------------------------------------------------------

   246 // NotifyObservers

   247 // ---------------------------------------------------------------------------

   248 //

   249 void

   250 CCamImageEncoder::NotifyObserver( TInt aStatus )

   251   {

   252   iObserver.ImageEncoded( aStatus, iEncodedData );

   253   iEncodedData = NULL;  // Ownership to observer

   254   }

   255 

   256 // ===========================================================================

   257 // private constructors

   258 

   259 // ---------------------------------------------------------------------------

   260 // 2nd phase constructor

   261 // ---------------------------------------------------------------------------

   262 //

   263 void

   264 CCamImageEncoder::ConstructL()

   265   {

   266   CActiveScheduler::Add( this );

   267   }

   268 

   269 // ---------------------------------------------------------------------------

   270 // 1st phase constructor

   271 // ---------------------------------------------------------------------------

   272 //

   273 CCamImageEncoder::CCamImageEncoder( MCamImageEncoderObserver& aObserver )

   274   : CActive  ( KPriority ),

   275     iObserver( aObserver )

   276   {

   277   }

   278 

   279 // end of file