1 /*

     2 * Copyright (c) 2005 - 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:  Still capture state machine implementation class

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include <hal.h>                    // For getting the display mode

    21 #include <ExifRead.h>

    22 #include "CaeStillStatesActive.h"

    23 #include "CaeImageQueueExtPro.h"

    24 

    25 #ifdef CAE_TEST_VERSION

    26 #include "CaeEngineImpTestErrors.h" // For TEST_VERSION compilation only

    27 #endif

    28 

    29 #include "OstTraceDefinitions.h"

    30 #ifdef OST_TRACE_COMPILER_IN_USE

    31 #include "CaeStillStatesActiveTraces.h"

    32 #endif

    33 

    34 

    35 // ================= MEMBER FUNCTIONS =======================

    36 

    37 

    38 // ---------------------------------------------------------------------------

    39 // CCaeStillStatesActive::CCaeStillStatesActive()

    40 // C++ constructor.

    41 // Adds the object to the Active Scheduler.

    42 // ---------------------------------------------------------------------------

    43 //

    44 CCaeStillStatesActive::CCaeStillStatesActive( 

    45     CCamera& aCamera,

    46     const TCamAppEngineInfo& aInfo,

    47     RArray<TCaeExtensionInterfaceImplItem>& aProcessImageImplList )

    48     : CActive( EPriorityStandard ), 

    49       iCamera( aCamera ),

    50       iInfo( aInfo ),

    51       iProcessImageImplList( aProcessImageImplList ),

    52       iStillInputFormat( CCamera::EFormatFbsBitmapColor16M ), 

    53       iStillOutputFormat( CCamera::EFormatFbsBitmapColor16M ), 

    54       iStillCompressionQuality( KCaeDefaultCompressionQuality ),

    55       iCurrentExtensionIndex( -1 )

    56     {

    57     CActiveScheduler::Add( this );

    58     }

    59 

    60 

    61 // ---------------------------------------------------------------------------

    62 // CCaeStillStatesActive::~CCaeStillStatesActive()

    63 // Destructor. 

    64 // Cancels operation and closes the timer.

    65 // ---------------------------------------------------------------------------

    66 //

    67 CCaeStillStatesActive::~CCaeStillStatesActive()

    68     {

    69     Cancel();

    70 

    71     iDelayedCallTimer.Close();

    72     

    73     DeleteStillBurst(); // Using this removes dependency to still burst class

    74 

    75     CancelAndCleanup();

    76 

    77     // Check that extensions handle flag registration properly

    78     CAE_ASSERT_DEBUG( iRequireFullColorSnapInputImageRefCount == 0 );

    79 

    80     delete iEmptySnapImage;

    81 

    82     delete iStillDecoder;

    83     delete iStillEncoder;

    84 

    85 	delete iSnapBitmap;

    86 	delete iBitmap;

    87 	delete iImageData;

    88 	delete iImageHeaderData;

    89     delete iImageQueueExtPro;

    90     iFs.Close();

    91     }

    92 

    93 

    94 // ---------------------------------------------------------------------------

    95 // CCaeStillStatesActive::NewL()

    96 // Symbian OS two-phased constructor.

    97 // ---------------------------------------------------------------------------

    98 //

    99 CCaeStillStatesActive* CCaeStillStatesActive::NewL( 

   100     CCamera& aCamera,

   101     const TCamAppEngineInfo& aInfo,

   102     RArray<TCaeExtensionInterfaceImplItem>& aProcessImageImplList )

   103     {

   104     CCaeStillStatesActive* self = new( ELeave ) CCaeStillStatesActive( aCamera, aInfo, 

   105         aProcessImageImplList );

   106     CleanupStack::PushL( self );

   107     self->ConstructL();

   108     CleanupStack::Pop( self );

   109     return self;

   110     }

   111 

   112 

   113 // ---------------------------------------------------------------------------

   114 // CCaeStillStatesActive::ConstructL()

   115 // Symbian OS 2nd phase constructor that can leave.

   116 // ---------------------------------------------------------------------------

   117 //

   118 void CCaeStillStatesActive::ConstructL()

   119     {

   120     // Get native screen mode. This can be used as default mode for the snap bitmap.

   121     iSnapImageColorMode = KCaeDefaultDisplayMode;

   122     (void)GetSystemDisplayMode( iSnapImageColorMode );

   123     LOGTEXT2( _L( "Cae: CCaeStillStatesActive::ConstructL(). Use display mode %d for the snap image" ), iSnapImageColorMode );

   124 

   125     // Create still image encoder object, e.g. for JPEG encoding.

   126     iStillEncoder = CCaeStillEncoder::NewL();

   127     iStillEncoder->SetObserver( this );

   128 

   129     // Create still image decoder object, e.g. for JPEG decoding.

   130     iStillDecoder = CCaeStillDecoder::NewL();

   131     iStillDecoder->SetObserver( this );

   132 

   133     // This empty snap image is currently used just for error cases.

   134     iEmptySnapImage = new( ELeave ) CFbsBitmap;

   135 

   136     // Create timer 

   137     iDelayedCallTimer.CreateLocal();

   138     

   139     // Connect to file server.

   140     User::LeaveIfError( iFs.Connect() );

   141 

   142     // Start in normal mode    

   143   	iExtModeActive = EFalse;

   144     iStillPrepared = EFalse;

   145     

   146     // Burst mode VF stopping optimization is not used as default

   147     iBurstModeVFOptimization = EFalse;

   148 

   149     }

   150 

   151 

   152 // ---------------------------------------------------------------------------

   153 // CCaeStillStatesActive::GetSystemDisplayMode()

   154 // In some devices Hal:Get(HAL::EDisplayMode) returns directly TDisplayMode, 

   155 // in other devices it returns a display mode index.

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

   157 //

   158 TBool CCaeStillStatesActive::GetSystemDisplayMode( TDisplayMode& aDisplayMode )

   159     {

   160     TBool found = EFalse;

   161     TInt halInOut = 0;

   162     TInt err = HAL::Get( HAL::EDisplayMode, halInOut );

   163     if (  err == KErrNone )

   164         {       

   165         if ( halInOut >= EColor256)

   166             {

   167             // halInOut contains TDisplayMode

   168             aDisplayMode = (TDisplayMode) halInOut;

   169             found = ETrue;

   170             LOGTEXT( _L( "Cae: CCaeStillStatesActive::GetSystemDisplayMode(). HAL returned a display mode." ) );

   171             }

   172         else

   173             {

   174              // halInOut contains index

   175            LOGTEXT( _L( "Cae: CCaeStillStatesActive::GetSystemDisplayMode(). HAL returned index." ) );

   176             err = HAL::Get( HAL::EDisplayBitsPerPixel, halInOut );

   177             

   178             // Get the color mode. Note: grayscale modes are not supported. 

   179             if (  err == KErrNone )

   180                 {

   181 				switch (halInOut)

   182 					{

   183 				    case 4:

   184 					    aDisplayMode = EColor16;

   185                         found = ETrue;

   186                         break;

   187 			    	case 8:

   188 					    aDisplayMode = EColor256;

   189                         found = ETrue;

   190                         break;

   191 				    case 12:

   192 				    	aDisplayMode = EColor4K;

   193                         found = ETrue;

   194                         break;

   195 				    case 16:

   196 					    aDisplayMode = EColor64K;

   197                         found = ETrue;

   198                         break;

   199 				    case 24:

   200 					    aDisplayMode = EColor16M;

   201                         found = ETrue;

   202                         break;

   203 			    	case 32:

   204 					    aDisplayMode = EColor16MU;

   205                         found = ETrue;

   206                         break;

   207 				    default:

   208 					    break;

   209 					}

   210                 }

   211             }

   212         } 

   213 

   214     #ifdef _DEBUG

   215     if ( err || !found )

   216         {

   217         TBuf<256> text;

   218         text.Format(_L( "Cae: CCaeStillStatesActive::GetSystemDisplayMode(). Cannot get the display mode from HW. Err:%d, found:%d" ), err, found );

   219         LOGTEXT( text );        

   220         }

   221     else

   222         {   

   223         LOGTEXT2( _L( "Cae: CCaeStillStatesActive::GetSystemDisplayMode(). Found the display mode:%d" ), aDisplayMode );

   224         }

   225     #endif

   226 

   227     if ( found && !err && aDisplayMode == EColor16MA )

   228         {

   229         aDisplayMode = EColor16MU;

   230         LOGTEXT2( _L( "Cae: CCaeStillStatesActive::GetSystemDisplayMode(). Display mode EColor16MA changed to EColor16MU (%d)" ), aDisplayMode );

   231         }

   232 

   233     return found;   

   234     }

   235 

   236 // ---------------------------------------------------------------------------

   237 // CCaeStillStatesActive::SetCamAppEngineObserver()

   238 // ---------------------------------------------------------------------------

   239 //

   240 void CCaeStillStatesActive::SetCamAppEngineObserver( MCamAppEngineObserver& aObserver )

   241     {

   242     iCaeObserver = &aObserver;    

   243     }

   244 

   245 

   246 // -----------------------------------------------------------------------------

   247 // CCaeStillStatesActive::SetSnapImageCreation()

   248 // -----------------------------------------------------------------------------

   249 //

   250 void CCaeStillStatesActive::SetSnapImageCreation( 

   251     TBool aCreateSnapImage )

   252     {

   253     iCreateSnapImage = aCreateSnapImage;

   254     }

   255 

   256 // -----------------------------------------------------------------------------

   257 // CCaeStillStatesActive::SetSnapImageSourceL()

   258 // -----------------------------------------------------------------------------

   259 //

   260 void CCaeStillStatesActive::SetSnapImageSourceL( 

   261     CCaeEngine::TSnapImageSource aSnapImageSource )

   262     {

   263     LOGTEXT2( _L( "Cae: CCaeStillStatesActive::SetSnapImageSourceL(). aSnapImageSource=%d" ), aSnapImageSource );

   264     if ( ( aSnapImageSource < 0 ) || 

   265          ( aSnapImageSource > CCaeEngine::ESnapImageSourceThumbnail ) )

   266         {

   267         LOGTEXT( _L( "Cae: CCaeStillStatesActive::SetSnapImageSourceL(). leaving KErrNotSupported" ));

   268         User::Leave( KErrNotSupported );

   269         }

   270 

   271     iSnapImageSource = aSnapImageSource;

   272     }

   273 

   274 

   275 

   276 // -----------------------------------------------------------------------------

   277 // CCaeStillStatesActive::SetSnapImageSizeL()

   278 // -----------------------------------------------------------------------------

   279 //

   280 void CCaeStillStatesActive::SetSnapImageSizeL( 

   281     TSize& aSize )

   282     {

   283     LOGTEXT3( _L( "Cae: CCaeStillStatesActive::SetSnapImageSizeL(). iWidth=%d, iHeight=%d" ), aSize.iWidth, aSize.iHeight );

   284 	// Calc downscaled size.

   285     // Use always the default snap size for the snap image. It is the best compromise 

   286     // between memory usage and image quality.

   287     TSize stepwiseScaledOptimalSize( KCaeDefaultSnapWidth, KCaeDefaultSnapHeight);

   288     CalcDownscaledSnapSize( stepwiseScaledOptimalSize ); 

   289 

   290     // Empty calculated size means that PrepareStillCapture() has not been called.

   291     if ( stepwiseScaledOptimalSize == TSize() ) 

   292         {

   293         LOGTEXT( _L( "Cae: CCaeStillStatesActive::SetSnapImageSizeL(). leaving KErrNotReady (no prepare)" ));

   294 		User::Leave( KErrNotReady ); 

   295         }

   296     else

   297         {

   298         iOptimalSnapImageSize = stepwiseScaledOptimalSize;

   299         // If empty, use the still image size

   300         if ( aSize == TSize() )

   301             {

   302             aSize = iStillFrameSize;

   303             }

   304         iSnapImageSize = aSize;

   305         }

   306     }

   307 

   308 

   309 // -----------------------------------------------------------------------------

   310 // CCaeStillStatesActive::SnapImageSize

   311 // -----------------------------------------------------------------------------

   312 TSize CCaeStillStatesActive::SnapImageSize() const

   313     {

   314     return( iSnapImageSize );

   315     }

   316 

   317 // -----------------------------------------------------------------------------

   318 // CCaeStillStatesActive::StillImageSize

   319 // -----------------------------------------------------------------------------

   320 TSize CCaeStillStatesActive::StillImageSize() const

   321     {

   322     return( iStillFrameSize );

   323     }

   324 

   325 

   326 // -----------------------------------------------------------------------------

   327 // CCaeStillStatesActive::SetSnapImageColorMode

   328 // -----------------------------------------------------------------------------

   329 //

   330 void CCaeStillStatesActive::SetSnapImageColorMode( 

   331     TDisplayMode aMode )

   332     {

   333     iSnapImageColorMode = aMode;

   334     }

   335 

   336 

   337 // -----------------------------------------------------------------------------

   338 // CCaeStillStatesActive::SetJpegQuality

   339 // -----------------------------------------------------------------------------

   340 //

   341 void CCaeStillStatesActive::SetJpegQuality(

   342     TInt aQuality )

   343     {

   344     iStillCompressionQuality = aQuality;

   345     }

   346 

   347 

   348 // -----------------------------------------------------------------------------

   349 // CCaeStillStatesActive::JpegQuality

   350 // -----------------------------------------------------------------------------

   351 //

   352 TInt CCaeStillStatesActive::JpegQuality() const

   353     {

   354     return( iStillCompressionQuality );

   355     }

   356 

   357 

   358 // -----------------------------------------------------------------------------

   359 // CCaeStillStatesActive::SetImageCodecsL

   360 // Sets the specific image codec implementation to be used in decoding and 

   361 // encoding.

   362 // -----------------------------------------------------------------------------

   363 //

   364 void CCaeStillStatesActive::SetImageCodecsL( 

   365 	TUid aDecoderUid, TUid aEncoderUid )

   366     {

   367     iStillEncoder->SetImageCodecL( aEncoderUid );

   368     iStillDecoder->SetImageCodecL( aDecoderUid );

   369     }

   370 

   371         

   372 // -----------------------------------------------------------------------------

   373 // CCaeStillStatesActive::SetViewFinderMode

   374 // -----------------------------------------------------------------------------

   375 //

   376 void CCaeStillStatesActive::SetViewFinderMode(

   377     TBool aIsEnabled )

   378     {

   379     iIsViewFinderEnabled = aIsEnabled;

   380 

   381     // Issue event, if the view finder is stopped, and the state machine is 

   382     // waiting for it. Do not issue the same event twice (it will panic).

   383     if ( !iIsViewFinderEnabled 

   384          && ( iCurrentState == CCaeStillStatesActive::ECaeStateBurstWaitingForViewFinder ) 

   385          && !( IsActive() && ( iStatus == CCaeStillStatesActive::ECaeEventViewFinderForBurstReady ) ) )

   386         {

   387         Event( CCaeStillStatesActive::ECaeEventViewFinderForBurstReady );        

   388         }

   389     }

   390 

   391 

   392 // -----------------------------------------------------------------------------

   393 // CCaeStillStatesActive::IsRunning

   394 // Check if the state is other than ECaeStateNone.

   395 // -----------------------------------------------------------------------------

   396 //

   397 TBool CCaeStillStatesActive::IsRunning() const

   398     {

   399     return( iCurrentState != CCaeStillStatesActive::ECaeStateNone );

   400     }

   401 

   402 

   403 // -----------------------------------------------------------------------------

   404 // CCaeEngineImp::RegisterFlags

   405 // Increment reference counters.

   406 // -----------------------------------------------------------------------------

   407 //

   408 void CCaeStillStatesActive::RegisterFlags( TUint32 aFlags )

   409 	{

   410     if ( aFlags & ECaeExtFlagRequireFullColorSnapInputImage )

   411         { 

   412         CAE_ASSERT_DEBUG( iRequireFullColorSnapInputImageRefCount < KMaxTInt32 );

   413         if ( iRequireFullColorSnapInputImageRefCount < KMaxTInt32 )

   414             {

   415             iRequireFullColorSnapInputImageRefCount++;

   416             }

   417         }

   418 	}

   419 

   420 

   421 // -----------------------------------------------------------------------------

   422 // CCaeEngineImp::DeregisterFlags

   423 // Decrement reference counters.

   424 // -----------------------------------------------------------------------------

   425 //

   426 void CCaeStillStatesActive::DeregisterFlags( TUint32 aFlags )

   427     {

   428     if ( aFlags & ECaeExtFlagRequireFullColorSnapInputImage )

   429         {

   430         CAE_ASSERT_DEBUG( iRequireFullColorSnapInputImageRefCount > 0 );

   431         if ( iRequireFullColorSnapInputImageRefCount > 0 )

   432             {

   433             iRequireFullColorSnapInputImageRefCount--;

   434             }

   435         }

   436     }

   437 

   438 // -----------------------------------------------------------------------------

   439 // CCaeStillStatesActive::PrepareStillCaptureL

   440 // Using cropping only if supported by Camera API impl.

   441 // Calls RetrieveStillSizeIndex() that calls Camera API EnumerateCaptureSizes().

   442 // Calls Camera API PrepareImageCaptureL().

   443 // -----------------------------------------------------------------------------

   444 //

   445 void CCaeStillStatesActive::PrepareStillCaptureL( 

   446     const TSize&      aFrameSize, 

   447     CCamera::TFormat  aFormat, 

   448     const TRect&      aCropRect,

   449     TSize&            aSnapSize )

   450     {

   451     LOGTEXT3( _L( "Cae: CCaeStillStatesActive::PrepareStillCaptureL() entering aFrameSize=(w=%d,h=%d)" ), aFrameSize.iWidth, aFrameSize.iHeight );

   452 

   453     // Handle empty crop rect

   454     TRect cropRect( aCropRect );

   455     if ( cropRect.IsEmpty() )

   456         cropRect = TRect(TPoint(0, 0 ), aFrameSize);

   457 

   458     CCamera::TFormat stillOutputFormat = aFormat;

   459     CCamera::TFormat stillInputFormat = aFormat;

   460 

   461     // Try if this size and format is supported by the Camera API.

   462     TInt sizeIndex = RetrieveStillSizeIndex( aFrameSize, aFormat );

   463     if ( sizeIndex != -1 )

   464         {

   465         stillInputFormat = aFormat;

   466         }

   467     // If the application requires Jpeg we can encode it from bitmap

   468     else if ( aFormat == CCamera::EFormatJpeg )

   469         {

   470         // Try if this size and format KBaseStillInputFormat1 

   471         // is supported by the Camera API.

   472         stillInputFormat = KBaseStillInputFormat1;

   473         sizeIndex = RetrieveStillSizeIndex( aFrameSize, stillInputFormat );

   474         if ( sizeIndex == -1 )

   475             {

   476             // Try if this size and format KBaseStillInputFormat2 

   477             // is supported by the Camera API.

   478             stillInputFormat = KBaseStillInputFormat2;

   479             sizeIndex = RetrieveStillSizeIndex( aFrameSize, stillInputFormat );

   480             if ( sizeIndex == -1 )

   481                 {

   482                 LOGTEXT2( _L( "Cae: CCaeStillStatesActive::PrepareStillCaptureL() leaving KErrNotSupported, stillInputFormat=%d" ), stillInputFormat );

   483                 User::Leave( KErrNotSupported );

   484                 }

   485             }

   486         }

   487     else 

   488         {

   489         LOGTEXT2( _L( "Cae: CCaeStillStatesActive::PrepareStillCaptureL() leaving KErrNotSupported, aFormat=%d" ), aFormat );

   490         User::Leave( KErrNotSupported );

   491         }

   492 

   493     // Prepare still image capturing on Camera API.

   494     if ( !( iInfo.iOptionsSupported & TCameraInfo::EImageClippingSupported ) ) 

   495         {

   496         iCamera.PrepareImageCaptureL( stillInputFormat, sizeIndex );

   497         }

   498     else 

   499         {

   500         iCamera.PrepareImageCaptureL( stillInputFormat, sizeIndex, cropRect );

   501         }

   502 

   503     // Store values 

   504     iStillFrameSize = aFrameSize;

   505     iStillInputFormat = stillInputFormat;

   506     iStillOutputFormat = stillOutputFormat;

   507 

   508     // Calc downscaled size if needed

   509     SetSnapImageSizeL( aSnapSize );     

   510     

   511     // Prepare done

   512     iStillPrepared = ETrue;

   513     

   514     LOGTEXT( _L( "Cae: CCaeStillStatesActive::PrepareStillCaptureL() returning" ) );    

   515     }

   516 

   517 

   518 // -----------------------------------------------------------------------------

   519 // CCaeStillStatesActive::RetrieveStillSizeIndex

   520 // Retrieves/fetches still image size index from Camera API.

   521 // -----------------------------------------------------------------------------

   522 //

   523 TInt CCaeStillStatesActive::RetrieveStillSizeIndex( 

   524     const TSize& aFrameSize, 

   525     CCamera::TFormat aStillDataFormat ) const

   526     {

   527     LOGTEXT( _L( "Cae: CCaeStillStatesActive::RetrieveStillSizeIndex() entering" ) );

   528 

   529     TInt index( -1 );

   530     TInt i( 0 );

   531     TSize size;

   532     while ( ( i < iInfo.iNumImageSizesSupported ) && ( index == -1 ) )

   533         {

   534         iCamera.EnumerateCaptureSizes ( size, i, aStillDataFormat );

   535         if ( size == aFrameSize )

   536             {

   537             index = i;

   538             }

   539         i++;

   540         }

   541 

   542     LOGTEXT( _L( "Cae: CCaeStillStatesActive::RetrieveStillSizeIndex() returning" ) );

   543 

   544     return index;

   545     }

   546 

   547 

   548 // -----------------------------------------------------------------------------

   549 // CCaeStillStatesActive::CalcDownscaledSnapSize

   550 // Calc suitable downscaled snap size. Assumed that integer arithmetic is used 

   551 // also in CImageDecoder class for calculating image scaling to 1/2, 1/4 or 1/8 

   552 // of size (i.e. no rounding). The scaled snap size is not allowed to be smaller

   553 // than given snap size in any dimension. Do not do downscaling if aSnapSize is 

   554 // empty.

   555 // -----------------------------------------------------------------------------

   556 //

   557 void CCaeStillStatesActive::CalcDownscaledSnapSize(

   558     TSize& aSnapSize) const

   559     {

   560     LOGTEXT( _L( "Cae: CCaeStillStatesActive::CalcDownscaledSnapSize() entering" ) );    

   561 

   562     // The new snap image size is equal to frame size by default

   563     TSize newSnapSize = iStillFrameSize;

   564 

   565     // Calculate downscaled snap size

   566     if ( aSnapSize != TSize( 0, 0 ) 

   567         && ( ( iStillInputFormat == CCamera::EFormatExif ) || 

   568              ( iStillInputFormat == CCamera::EFormatJpeg )   ) )

   569         {

   570         // Try scaling to 1/8, 1/4 and 1/2

   571         for  ( TInt divider = 8; divider >= 2;  divider /= 2 ) 

   572             {

   573             TInt scaledWidth = iStillFrameSize.iWidth / divider;

   574             TInt scaledHeight = iStillFrameSize.iHeight / divider;

   575             if ( scaledHeight >= aSnapSize.iHeight && scaledWidth >= aSnapSize.iWidth ) 

   576                 {

   577                 newSnapSize = TSize( scaledWidth, scaledHeight );

   578                 divider = -1; // exit loop

   579                 }

   580             }

   581         }

   582 

   583     // Return new size

   584     aSnapSize = newSnapSize;

   585     LOGTEXT( _L( "Cae: CCaeStillStatesActive::CalcDownscaledSnapSize() returning" ) );    

   586     }

   587 

   588 

   589 // ---------------------------------------------------------------------------

   590 // CCaeStillStatesActive::GetThumbnailL()

   591 // Extracts thumbnail image and its size from Exif image.

   592 // Uses Exif reader to extract the thumbnail and 

   593 // ICL decoder to extract the size.

   594 // ---------------------------------------------------------------------------

   595 //

   596 void CCaeStillStatesActive::GetThumbnailL( 

   597     HBufC8*& aReadThumbnail, 

   598     TSize&   aThumbnailSize )

   599     {

   600     LOGTEXT( _L( "Cae: CCaeStillStatesActive::GetThumbnailL()" ) );    

   601 

   602     if ( iImageData && ( iStillOutputFormat == CCamera::EFormatExif ) )

   603         {

   604         // Instantiate exif reader.

   605         CExifRead* read = NULL;

   606         read = CExifRead::NewL( *iImageData );

   607         CleanupStack::PushL( read );

   608         

   609         // Get thumbnail.

   610         aReadThumbnail = read->GetThumbnailL();

   611         CleanupStack::PopAndDestroy( read );

   612         

   613         // Find out thumbnail size by using ICL decoder.

   614         // Check first that the size is valid.

   615         CImageDecoder* decoder = CImageDecoder::DataNewL( iFs, *aReadThumbnail ); 

   616         TFrameInfo frameInfo = decoder->FrameInfo();

   617         delete decoder;

   618 

   619         if ( frameInfo.iOverallSizeInPixels.iWidth > 0 && 

   620              frameInfo.iOverallSizeInPixels.iHeight > 0 )

   621             {

   622             aThumbnailSize = frameInfo.iOverallSizeInPixels;

   623             LOGTEXT3( _L( "Cae: CCaeStillStatesActive::GetThumbnailL(): extracted %dx%d thumbnail" ), 

   624                 aThumbnailSize.iWidth, aThumbnailSize.iHeight );

   625             }

   626         else

   627             {

   628             LOGTEXT3(_L("Cae: CCaeStillStatesActive::GetThumbnailL(): leaving KErrCorrupt due invalid thumbnail size=(w=%d,h=%d)"), 

   629                 frameInfo.iOverallSizeInPixels.iWidth, frameInfo.iOverallSizeInPixels.iHeight );

   630             delete aReadThumbnail;

   631             aReadThumbnail = NULL;

   632             aThumbnailSize = TSize( 0, 0 );

   633             User::Leave( KErrCorrupt );

   634             }

   635         }

   636     else if ( iImageData && ( iStillOutputFormat != CCamera::EFormatExif ) )

   637         {

   638         // we can't get the thumbnail from exif header if the exif header doesn't exist

   639         LOGTEXT( _L( "Cae: CCaeStillStatesActive::GetThumbnailL() leaving because iStillOutputFormat is not EFormatExif" ) );

   640         User::Leave( KErrNotFound );

   641         }

   642     }

   643 

   644 // ---------------------------------------------------------------------------

   645 // CCaeStillStatesActive::IsBitmapOutput()

   646 // ---------------------------------------------------------------------------

   647 //

   648 TBool CCaeStillStatesActive::IsBitmapOutput()

   649     {

   650     return ( !( ( iStillOutputFormat == CCamera::EFormatJpeg ) 

   651               || ( iStillOutputFormat == CCamera::EFormatExif ) ) );

   652     }

   653 

   654 

   655 // ---------------------------------------------------------------------------

   656 // CCaeStillStatesActive::Event()

   657 // ---------------------------------------------------------------------------

   658 //

   659 void CCaeStillStatesActive::Event( TCaeEvent aEvent, TTimeIntervalMicroSeconds32 aDelay )

   660     {

   661     LOGTEXT2( _L( "Cae: CCaeStillStatesActive::Event(). aEvent=%d" ), aEvent );

   662     CAE_ASSERT_ALWAYS( !IsActive() );

   663 

   664     iDelayedEvent = CCaeStillStatesActive::ECaeEventNone;

   665 

   666     if ( aEvent != CCaeStillStatesActive::ECaeEventEnd )

   667         {

   668         if ( aDelay == TTimeIntervalMicroSeconds32( 0 ) )

   669             {

   670             // Issue request

   671             TRequestStatus* statusPtr = &iStatus;

   672             User::RequestComplete( statusPtr, aEvent );

   673             }

   674         else

   675             {

   676             // Use delayed request

   677             iDelayedCallTimer.After( iStatus, aDelay );

   678             iDelayedEvent = aEvent;

   679             }

   680     	SetActive();

   681         }

   682     else

   683         {

   684         iCurrentState = CCaeStillStatesActive::ECaeStateNone; // The end

   685         if ( ExtModeActive() )

   686             {

   687             // If there are no images in the queue, then extension processing is ended

   688             TInt count = iImageQueueExtPro->ImageCount();

   689             if ( count > 0 )

   690                 {  // Continue and read next image from the queue

   691                 Event( CCaeStillStatesActive::ECaeEventImageQueueExtPro );

   692                 }

   693             }

   694         }

   695     }

   696 

   697 

   698 // ---------------------------------------------------------------------------

   699 // CCaeStillStatesActive::CancelCaptureStill()

   700 // ---------------------------------------------------------------------------

   701 //

   702 void CCaeStillStatesActive::CancelCaptureStill()

   703     {

   704     LOGTEXT( _L( "Cae: CCaeStillStatesActive::CancelCaptureStill()" ) );

   705 

   706     if ( !ExtModeActive() ) // in extension mode capture/cancelling is not possible

   707         {

   708         iStillCancelled = ETrue;

   709         Cancel();

   710         CancelAndCleanup();

   711         }

   712 

   713     }

   714 

   715 

   716 // ---------------------------------------------------------------------------

   717 // CCaeStillStatesActive::Cancel()

   718 // Calls the base class Cancel().

   719 // As calling this is not allowed outside this class, this is a private method

   720 // and it overrides CActive::Cancel(). 

   721 // ---------------------------------------------------------------------------

   722 //

   723 void CCaeStillStatesActive::Cancel()

   724     {

   725     LOGTEXT( _L( "Cae: CCaeStillStatesActive::Cancel()" ) );

   726     CActive::Cancel();

   727     }

   728 

   729 

   730 // ---------------------------------------------------------------------------

   731 // CCaeStillStatesActive::DoCancel()

   732 // Cancel all pending actions. This does not cancel actions that use callback

   733 // for signaling for completion, e.g. image encoding and decoding.

   734 // ---------------------------------------------------------------------------

   735 //

   736 void CCaeStillStatesActive::DoCancel()

   737     {

   738     LOGTEXT( _L( "Cae: CCaeStillStatesActive::DoCancel()" ) );

   739     if ( iStatus == KRequestPending )

   740         {

   741         if ( ( iCurrentState == CCaeStillStatesActive::ECaeStateExtensionsProcessingCapturedImage )

   742              || ( iCurrentState == CCaeStillStatesActive::ECaeStateExtensionsProcessingSnapImage ) 

   743              || ( iCurrentState == CCaeStillStatesActive::ECaeStateExtensionsProcessingStillImage ) )

   744             {

   745             // Cancel extension processing            

   746             CAE_ASSERT_ALWAYS( iCurrentExtensionIndex != -1 );

   747             TAny* interfacePtr = iProcessImageImplList[iCurrentExtensionIndex].iImplPtr;

   748 	        STATIC_CAST( MCaeExtProcessImageInterface*, interfacePtr )->CaeExtensionCancel();   

   749             }

   750         else if ( iDelayedEvent != CCaeStillStatesActive::ECaeEventNone )

   751             {

   752             // Cancel timer

   753             iDelayedCallTimer.Cancel();

   754             iDelayedEvent = CCaeStillStatesActive::ECaeEventNone;

   755             }

   756         else

   757             {

   758             User::Panic( KCaePanicText, ECaePanicInvalidState );

   759             }

   760         }

   761     }

   762 

   763 

   764 // -----------------------------------------------------------------------------

   765 // CCaeStillStatesActive::ErrorRecovery

   766 //

   767 // For still capture recovery: Delete images, cancel and cleanup. Client 

   768 // callbacks should be called also in error cases, except when user has 

   769 // cancelled the action. 

   770 //

   771 // Burst case is handled differently in BurstErrorRecovery().

   772 //

   773 // Note: If ownership is transferred, the image pointers should be NULLed before

   774 // calling the observer method. That is because the observer method can call back

   775 // CancelStill() which tries to delete images. That is no allowed if an image 

   776 // should be owned by the observer.

   777 // -----------------------------------------------------------------------------

   778 //

   779 void CCaeStillStatesActive::ErrorRecovery( TInt aError )

   780     {

   781     LOGTEXT2( _L( "Cae: CCaeStillStatesActive::ErrorRecovery(): %d" ), aError );

   782 

   783     // Check if snap image callback should be called. Do not call it twice.

   784 

   785     if ( ( iCurrentState <= CCaeStillStatesActive::ECaeStateDeliveringSnapImage ) // Callback not yet called

   786          && !iStillCancelled 

   787          && iCreateSnapImage ) 

   788         {

   789         if ( iCurrentState == CCaeStillStatesActive::ECaeStateDecodingCapturedImageToBitmap ) 

   790             {

   791             // Give decoded image to the client even if there is decoding error

   792             iCaeObserver->McaeoSnapImageReady( *iBitmap, aError );

   793 

   794             // Not needed any more. Delete now to free memory.

   795             delete iBitmap;

   796             iBitmap = NULL;

   797             }

   798         else

   799             {

   800             // Give empty snap image to the client

   801             iCaeObserver->McaeoSnapImageReady( *iEmptySnapImage, aError );

   802             }

   803         }

   804 

   805     // Check if still image callback should be called. Do not call it twice.

   806 

   807     if ( ( iCurrentState <= CCaeStillStatesActive::ECaeStateDeliveringStillImage ) // Callback not yet called

   808          && !iStillCancelled )

   809         {

   810         if ( iCurrentState == CCaeStillStatesActive::ECaeStateDecodingCapturedImageToBitmap ) 

   811             {

   812             // Give original image to the client even if there is decoding error.

   813             HBufC8* tmpImageData = iImageData;   

   814             iImageData = NULL; 

   815             iCaeObserver->McaeoStillImageReady( NULL, tmpImageData, aError );

   816             }

   817         else if ( iCurrentState == CCaeStillStatesActive::ECaeStateEncodingToJpeg )

   818             {

   819             // Give original image to the client even if there is encoding error

   820             HBufC8* tmpImageData = iImageData;   

   821             iImageData = NULL; // Ownership tranferred

   822             iCaeObserver->McaeoStillImageReady( NULL, tmpImageData, aError );            

   823             }

   824         else

   825             {

   826             // Give error to the client

   827             iCaeObserver->McaeoStillImageReady( NULL, NULL, aError );

   828             }

   829 

   830         // In burst case, increment delivery counter. 

   831         if ( iStillBurst )

   832             {

   833             iCountOfDeliveredBurstImages++;

   834             }

   835         }

   836 

   837     if ( !iStillCancelled )

   838         {

   839         // Handle still burst

   840         if ( iStillBurst )

   841             {

   842             BurstErrorRecovery( aError );

   843             }

   844         else

   845             {

   846             Cancel();

   847             CancelAndCleanup();

   848             }  

   849         }

   850     }

   851 

   852 

   853 // -----------------------------------------------------------------------------

   854 // CCaeStillStatesActive::CancelAndCleanup

   855 // Cancel all actions and free resources.

   856 // -----------------------------------------------------------------------------

   857 //

   858 void CCaeStillStatesActive::CancelAndCleanup()

   859     {

   860     iDelayedEvent = CCaeStillStatesActive::ECaeEventNone;

   861 

   862     CompleteStillBurst();

   863 

   864     if ( iStillEncoder )

   865         {

   866         iStillEncoder->Cancel();

   867         iStillEncoder->Cleanup(); 

   868         }

   869 

   870     if ( iStillDecoder )

   871         {

   872         iStillDecoder->Cancel();

   873         iStillDecoder->Cleanup();

   874         }    

   875 

   876     // Delete all that is not NULL already. 

   877     delete iSnapBitmap;

   878     iSnapBitmap = NULL;

   879     delete iBitmap;

   880     iBitmap = NULL;

   881     delete iImageData;

   882     iImageData = NULL;

   883     delete iImageHeaderData;

   884     iImageHeaderData = NULL;

   885     if ( iImageQueueExtPro )

   886         {

   887         iImageQueueExtPro->ResetAndDestroyImages();

   888         }    

   889 

   890     iCurrentState = CCaeStillStatesActive::ECaeStateNone;   

   891     }

   892 

   893 // ---------------------------------------------------------------------------

   894 // CCaeStillStatesActive::RunL()

   895 // The main function that receives all events. Simple events are also handled 

   896 // here. For more complex events, specific handler functions are called.

   897 // ---------------------------------------------------------------------------

   898 //

   899 void CCaeStillStatesActive::RunL()

   900     {

   901     LOGTEXT3( _L( "Cae: CCaeStillStatesActive::RunL() entering, iStatus=%d, iCurrentState=%d" ), iStatus.Int(), iCurrentState );

   902 

   903     // Handle external errors 

   904 

   905     if ( iStatus.Int() < 0 )

   906         {

   907         HandleExternalError();

   908         return;

   909         }

   910 

   911     // Handle all state transitions

   912 

   913     switch( iStatus.Int() )

   914         {

   915         case CCaeStillStatesActive::ECaeEventNone:

   916             HandleExternalEvent();

   917             break;

   918 

   919         case CCaeStillStatesActive::ECaeEventStartStillCapture:

   920             CAE_ASSERT_DEBUG( iCurrentState == CCaeStillStatesActive::ECaeStateNone );

   921             HandleStart();

   922             break;

   923 

   924         case CCaeStillStatesActive::ECaeEventImageCaptureReady:

   925             CAE_ASSERT_DEBUG( iCurrentState == CCaeStillStatesActive::ECaeStateCapturing );

   926             HandleImageCaptureReady();

   927             break;

   928 

   929         case CCaeStillStatesActive::ECaeEventBurstImageCaptureReady:

   930             CAE_ASSERT_DEBUG( iCurrentState == CCaeStillStatesActive::ECaeStateCapturingBurst );

   931             iCurrentState = CCaeStillStatesActive::ECaeStateAppendingBurstImage;            

   932             DoAppendCapturedBurstImageToArray();

   933             break;

   934 

   935         case CCaeStillStatesActive::ECaeEventAppendCapturedBurstImageReady:

   936             CAE_ASSERT_DEBUG( iCurrentState == CCaeStillStatesActive::ECaeStateAppendingBurstImage );

   937             HandleAppendCapturedBurstImageReady();            

   938             break;

   939 

   940         case CCaeStillStatesActive::ECaeEventViewFinderForBurstReady:

   941             CAE_ASSERT_DEBUG( iCurrentState == CCaeStillStatesActive::ECaeStateBurstWaitingForViewFinder );

   942             iCurrentState = CCaeStillStatesActive::ECaeStateCapturingBurst;            

   943             DoCaptureStillBurstImage();            

   944             break;

   945 

   946         case CCaeStillStatesActive::ECaeEventBurstCaptureReady:

   947             CAE_ASSERT_DEBUG( iCurrentState == CCaeStillStatesActive::ECaeStateCapturingBurst );

   948             iCurrentState = CCaeStillStatesActive::ECaeStateFetchingNextBurstImage;    

   949             iStatus = CCaeStillStatesActive::ECaeEventNone;

   950             DoFetchNextBurstImage();

   951             break;

   952 

   953         case CCaeStillStatesActive::ECaeEventBurstImageFetchReady:

   954             CAE_ASSERT_DEBUG( iCurrentState == CCaeStillStatesActive::ECaeStateFetchingNextBurstImage );

   955             HandleBurstImageFetchReady();

   956             break;

   957 

   958         case CCaeStillStatesActive::ECaeEventDecodeToBitmapReady:

   959             CAE_ASSERT_DEBUG( iCurrentState == CCaeStillStatesActive::ECaeStateDecodingCapturedImageToBitmap );

   960             HandleDecodeToBitmapReady();

   961             break;

   962 

   963         case CCaeStillStatesActive::ECaeEventExtractExifMetaDataReady:

   964             CAE_ASSERT_DEBUG( iCurrentState == CCaeStillStatesActive::ECaeStateExtractingExifMetaData );

   965             iCurrentState = CCaeStillStatesActive::ECaeStateExtensionsProcessingCapturedImage;         

   966             iStatus = CCaeStillStatesActive::ECaeEventNone;

   967             DoExtensionsProcessCapturedImage();    

   968             break;

   969 

   970         case CCaeStillStatesActive::ECaeEventProcessCapturedImageStepReady:

   971             CAE_ASSERT_DEBUG( iCurrentState == CCaeStillStatesActive::ECaeStateExtensionsProcessingCapturedImage );

   972             iStatus = CCaeStillStatesActive::ECaeEventNone;

   973             DoExtensionsProcessCapturedImage();

   974             break;

   975 

   976         case CCaeStillStatesActive::ECaeEventProcessCapturedImageAllReady:

   977             CAE_ASSERT_DEBUG( iCurrentState == CCaeStillStatesActive::ECaeStateExtensionsProcessingCapturedImage );

   978             HandleProcessCapturedImageAllReady();

   979             break;

   980 

   981         case CCaeStillStatesActive::ECaeEventProcessSnapImageStepReady:

   982             CAE_ASSERT_DEBUG( iCurrentState == CCaeStillStatesActive::ECaeStateExtensionsProcessingSnapImage );

   983             iStatus = CCaeStillStatesActive::ECaeEventNone;

   984             DoExtensionsProcessSnapImage();    

   985             break;

   986 

   987         case CCaeStillStatesActive::ECaeEventProcessSnapImageAllReady:

   988             CAE_ASSERT_DEBUG( iCurrentState == CCaeStillStatesActive::ECaeStateExtensionsProcessingSnapImage );

   989             iCurrentState = CCaeStillStatesActive::ECaeStateDeliveringSnapImage;         

   990             iStatus = CCaeStillStatesActive::ECaeEventNone;

   991             DoDeliverSnapImage();    

   992             break;

   993 

   994         case CCaeStillStatesActive::ECaeEventDeliverSnapImageReady:

   995             CAE_ASSERT_DEBUG( iCurrentState == CCaeStillStatesActive::ECaeStateDeliveringSnapImage );

   996             iCurrentState = CCaeStillStatesActive::ECaeStateExtensionsProcessingStillImage;         

   997             iStatus = CCaeStillStatesActive::ECaeEventNone;

   998             DoExtensionsProcessStillImage();    

   999             break;

  1000 

  1001         case CCaeStillStatesActive::ECaeEventProcessStillImageStepReady:

  1002             CAE_ASSERT_DEBUG( iCurrentState == CCaeStillStatesActive::ECaeStateExtensionsProcessingStillImage );

  1003             iStatus = CCaeStillStatesActive::ECaeEventNone;

  1004             DoExtensionsProcessStillImage();

  1005             break;

  1006 

  1007         case CCaeStillStatesActive::ECaeEventProcessStillImageAllReady:

  1008             CAE_ASSERT_DEBUG( iCurrentState == CCaeStillStatesActive::ECaeStateExtensionsProcessingStillImage );

  1009             HandleProcessStillImageAllReady();

  1010             break;

  1011 

  1012         case CCaeStillStatesActive::ECaeEventEncodeToJpegReady:

  1013              CAE_ASSERT_DEBUG( iCurrentState == CCaeStillStatesActive::ECaeStateEncodingToJpeg );

  1014             HandleEncodeToJpegReady();

  1015             break;

  1016 

  1017         case CCaeStillStatesActive::ECaeEventDeliverStillBurstImageReady:

  1018             // We can end up here from any state, if there occurs an error

  1019             HandleDeliverStillBurstImageReady();

  1020             break;

  1021 

  1022         case CCaeStillStatesActive::ECaeEventImageQueueExtPro:

  1023             CAE_ASSERT_DEBUG( iCurrentState == CCaeStillStatesActive::ECaeStateNone );

  1024             HandleImageQueueExtPro();

  1025             break;

  1026 

  1027         default:

  1028             CAE_ASSERT_DEBUG( iCurrentState != iCurrentState ); // Always false

  1029             break;

  1030         }

  1031 

  1032     LOGTEXT( _L( "Cae: CCaeStillStatesActive::RunL() returning" ) );

  1033     }

  1034 

  1035 

  1036 // ---------------------------------------------------------------------------

  1037 // EVENT HANDLERS

  1038 //

  1039 // Event handlers should decide what is the next state and next action after the 

  1040 // current event. Modes and flags are checked here leaving the actual action 

  1041 // functions as simple as possible. 

  1042 // ---------------------------------------------------------------------------

  1043 

  1044 // -----------------------------------------------------------------------------

  1045 // CCaeStillStatesActive::HandleExternalError

  1046 // -----------------------------------------------------------------------------

  1047 //

  1048 void CCaeStillStatesActive::HandleExternalError() 

  1049     {

  1050     LOGTEXT( _L( "Cae: CCaeStillStatesActive::HandleExternalError()" ));

  1051 

  1052     CAE_ASSERT_DEBUG( ( ( iDelayedEvent != CCaeStillStatesActive::ECaeEventNone )

  1053                        || ( iCurrentState == CCaeStillStatesActive::ECaeStateExtensionsProcessingCapturedImage ) 

  1054                        || ( iCurrentState == CCaeStillStatesActive::ECaeStateExtensionsProcessingSnapImage ) 

  1055                        || ( iCurrentState == CCaeStillStatesActive::ECaeStateExtensionsProcessingStillImage ) ) ); 

  1056          

  1057     // Cancelling delayed event timer is not considered as error, but early completion              

  1058     if ( (iStatus.Int() == KErrCancel ) && ( iDelayedEvent != CCaeStillStatesActive::ECaeEventNone ) )

  1059         {

  1060     	LOGTEXT2( _L( "Cae: CCaeStillStatesActive::HandleExternalError(). Delayed event %d completed early." ), iDelayedEvent);

  1061     	HandleExternalEvent();

  1062         }

  1063     else

  1064     	{

  1065     	ErrorRecovery( iStatus.Int() );                        		

  1066     	}    

  1067 

  1068     }

  1069 

  1070 

  1071 // -----------------------------------------------------------------------------

  1072 // CCaeStillStatesActive::HandleExternalEvent

  1073 // -----------------------------------------------------------------------------

  1074 //

  1075 void CCaeStillStatesActive::HandleExternalEvent() 

  1076     {

  1077     LOGTEXT( _L( "Cae: CCaeStillStatesActive::HandleExternalEvent()" ));

  1078     CAE_ASSERT_DEBUG( ( ( iDelayedEvent != CCaeStillStatesActive::ECaeEventNone )

  1079                        || ( iCurrentState == CCaeStillStatesActive::ECaeStateExtensionsProcessingCapturedImage ) 

  1080                        || ( iCurrentState == CCaeStillStatesActive::ECaeStateExtensionsProcessingSnapImage ) 

  1081                        || ( iCurrentState == CCaeStillStatesActive::ECaeStateExtensionsProcessingStillImage ) ) ); 

  1082 

  1083         

  1084     if ( iDelayedEvent != CCaeStillStatesActive::ECaeEventNone )

  1085         {

  1086         // Timer has finished, issue delayed event now

  1087         Event( iDelayedEvent );

  1088         }

  1089     else          

  1090         {

  1091         switch ( iCurrentState )

  1092             {

  1093             case ECaeStateExtensionsProcessingCapturedImage:

  1094                 Event( CCaeStillStatesActive::ECaeEventProcessCapturedImageStepReady );

  1095                 break;

  1096 

  1097             case ECaeStateExtensionsProcessingSnapImage:

  1098                 Event( CCaeStillStatesActive::ECaeEventProcessSnapImageStepReady );

  1099                 break;

  1100 

  1101             case ECaeStateExtensionsProcessingStillImage:

  1102                 Event( CCaeStillStatesActive::ECaeEventProcessStillImageStepReady );

  1103                 break;

  1104 

  1105             default:

  1106                 CAE_ASSERT_DEBUG( iCurrentState !=  iCurrentState ); // Always false

  1107                 break;

  1108 

  1109             }

  1110         }

  1111     }

  1112 

  1113 

  1114 // ---------------------------------------------------------------------------

  1115 // CCaeStillStatesActive::HandleStart()

  1116 // Start either single or burst image capture.

  1117 // ---------------------------------------------------------------------------

  1118 //

  1119 void CCaeStillStatesActive::HandleStart()

  1120     {

  1121     LOGTEXT( _L( "Cae: CCaeStillStatesActive::HandleStart()" ));

  1122     CAE_ASSERT_ALWAYS( ( iBitmap == NULL ) && ( iSnapBitmap == NULL ) );

  1123     CAE_ASSERT_ALWAYS( ( iImageData == NULL ) && ( iImageHeaderData == NULL ) );

  1124     

  1125     iStatus = CCaeStillStatesActive::ECaeEventNone;

  1126     if ( iStillBurst )

  1127         {               

  1128         iCurrentState = CCaeStillStatesActive::ECaeStateCapturingBurst;            

  1129         DoCaptureStillBurst();

  1130         }

  1131     else

  1132         {

  1133         iCurrentState = CCaeStillStatesActive::ECaeStateCapturing;            

  1134         DoCaptureStill();