1 /*

     2 * Copyright (c) 2006 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:  Video Source subsystem.

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 

    21 #include <e32svr.h>

    22 #include <bautils.h>

    23 #include <imageconversion.h>

    24 #include <cvtimageconverter.h>

    25 #include <RPhCltServer.h>

    26 #include <cphcltimagehandler.h>

    27 #include <w32std.h>

    28 

    29 #include "CVSStillImageDataProvider.h"

    30 #include "CVSDataSourceImp.h"

    31 #include "VSPanic.h"

    32 #include "cvtimagebitmap.h"

    33 #include "CVSMMFDataBuffer.h"

    34 

    35 #include "cmultiframeprovider.h"

    36 

    37 // EXTERNAL FUNCTION PROTOTYPES

    38 

    39 // MACROS

    40 

    41 #ifdef _DEBUG

    42 #    define __IF_DEBUG(t) {RDebug::t;}

    43 #else

    44 #    define __IF_DEBUG(t)

    45 #endif

    46 

    47 // LOCAL CONSTANTS AND MACROS

    48 

    49 static const TInt KMinZoom = 0;

    50 static const TInt KMaxZoom = 0;

    51 static const TInt KMaxDigitalZoom = 0;

    52 static const TReal32 KMinZoomFactor = 0.0;

    53 static const TReal32 KMaxZoomFactor = 0.0;

    54 static const TReal32 KMaxDigitalZoomFactor = 1.0;

    55 static const TInt KNumVideoSizesSupported = 1;

    56 static const TInt KNumVideoFrameSizesSupported = 1;

    57 static const TInt KNumVideoFrameRatesSupported = 1;

    58 static const TInt KMaxFramesPerBufferSupported = 1;

    59 static const TInt KQcifWidth = 176;

    60 static const TInt KQcifHeight = 144;

    61 static const TReal32 KFrameRate = 15.0;

    62 static const TUint32 KVSViewFinderUpdateRate = 1000000/15; // 15 times per second

    63 

    64 // TYPE DEFINITIONS

    65 

    66 // Timer expired callback

    67 

    68 typedef void (CVSStillImageDataProvider::*TTimerElapsed) ();

    69 

    70 // INTERNAL CLASSES

    71 

    72 /**

    73 *  Timer class that calls given callback method when timer request has been

    74 *  completed. If the timer request is cancelled then callback will not be

    75 *  called.

    76 *

    77 *  @lib videosource.lib

    78 */

    79 class CVSFrameRateTimer : public CTimer

    80     {

    81     public: // Constructors and destructor

    82 

    83         /**

    84         * Static factory function to create instance of this class.

    85         * @param "aRequester" ?description

    86         * @exception Can leave with one of the system wide error codes.

    87         * @return Pointer to new instance.

    88         */

    89         static CVSFrameRateTimer* NewL( CVSStillImageDataProvider* aRequester );

    90 

    91     public: // New functions

    92 

    93     public: // Functions from base classes

    94 

    95         /**

    96         * Starts timer request. When timer request has been completed given

    97         * callback method will be called.

    98         * @param "anInterval" Interval after which event is to occur,

    99         * in microseconds.

   100         * @param "aFunction" Callback method that will be called when timer

   101         * request has been completed.

   102         */

   103         void After(

   104             TTimeIntervalMicroSeconds32 anInterval,

   105             TTimerElapsed aFunction  );

   106 

   107     public: // Constructors and destructor

   108 

   109         /**

   110         * Destructor.

   111         */

   112         ~CVSFrameRateTimer();

   113 

   114     protected:  // New functions

   115 

   116     protected:  // Functions from base classes

   117 

   118     private:    // Constructors and destrcutor

   119 

   120         /**

   121         * Constructor.

   122         * @param "aRequester" ?description

   123         */

   124         CVSFrameRateTimer( CVSStillImageDataProvider* aRequester );

   125 

   126     private:    // New functions

   127 

   128     private:    // Functions from base classes

   129 

   130         /**

   131         * From CActive. See CActive for description.

   132         */

   133         void RunL();

   134 

   135     public: // Data

   136 

   137     protected:  // Data

   138 

   139     private:    // Data

   140 

   141         // Pointer to requester (i.e. through which callback call will be made)

   142         CVSStillImageDataProvider* iRequester; // not owned

   143 

   144         // Pointer to callback method.

   145         TTimerElapsed iFunction;

   146     };

   147 

   148 // ============================ MEMBER FUNCTIONS ===============================

   149 

   150 // ============================ CVSFrameRateTimer ==============================

   151 

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

   153 // CVSFrameRateTimer::NewL( CVSStillImageDataProvider* aRequester )

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

   155 //

   156 CVSFrameRateTimer* CVSFrameRateTimer::NewL(

   157     CVSStillImageDataProvider* aRequester )

   158     {

   159     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::NewL() >>"), RThread().Id().operator TUint()));

   160     CVSFrameRateTimer* self = new (ELeave) CVSFrameRateTimer( aRequester );

   161     CleanupStack::PushL( self );

   162     self->ConstructL();

   163     CleanupStack::Pop(); // self

   164     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::NewL() <<"), RThread().Id().operator TUint()));

   165     return self;

   166     }

   167 

   168 // -----------------------------------------------------------------------------

   169 // CVSFrameRateTimer::CVSFrameRateTimer( CVSStillImageDataProvider* aRequester )

   170 // -----------------------------------------------------------------------------

   171 //

   172 CVSFrameRateTimer::CVSFrameRateTimer( CVSStillImageDataProvider* aRequester )

   173 : CTimer( EPriorityStandard ), iRequester( aRequester )

   174     {

   175     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::CVSFrameRateTimer() >>"), RThread().Id().operator TUint()));

   176     // Added to CActiveScheduler in CVSStillImageDataProvider::InitializeL

   177     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::CVSFrameRateTimer() <<"), RThread().Id().operator TUint()));

   178     }

   179 

   180 // -----------------------------------------------------------------------------

   181 // CVSFrameRateTimer::After(

   182 //  TTimeIntervalMicroSeconds32 anInterval, TTimerElapsed aFunction )

   183 // -----------------------------------------------------------------------------

   184 //

   185 void CVSFrameRateTimer::After(

   186     TTimeIntervalMicroSeconds32 anInterval,

   187     TTimerElapsed aFunction )

   188     {

   189     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::After() >>"), RThread().Id().operator TUint()));

   190     if ( iFunction == aFunction )

   191     	{

   192     	if ( !IsActive() )

   193     		{

   194       	iFunction = aFunction;

   195     		CTimer::After( anInterval );

   196     		}

   197     	}

   198     else

   199     	{

   200     	if ( !IsActive() )

   201     		{

   202       	iFunction = aFunction;

   203     		CTimer::After( anInterval );

   204     		}

   205     	else

   206     		{

   207     			User::Panic(_L("VideoSource"),KErrGeneral);

   208     		}

   209     	}

   210     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::After() <<"), RThread().Id().operator TUint()));

   211     }

   212 

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

   214 // CVSFrameRateTimer::~CVSFrameRateTimer()

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

   216 //

   217 CVSFrameRateTimer::~CVSFrameRateTimer()

   218     {

   219     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::~CVSFrameRateTimer() >>"), RThread().Id().operator TUint()));

   220     Cancel();

   221     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::~CVSFrameRateTimer() <<"), RThread().Id().operator TUint()));

   222     }

   223 

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

   225 // CVSFrameRateTimer::RunL()

   226 // -----------------------------------------------------------------------------

   227 //

   228 void CVSFrameRateTimer::RunL()

   229     {

   230     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::RunL() >>"), RThread().Id().operator TUint()));

   231     if( iStatus.Int() == KErrNone )

   232         {

   233         (iRequester->*iFunction)();

   234         }

   235     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::RunL() <<"), RThread().Id().operator TUint()));

   236     }

   237 

   238 // ============================ CVSStillImageDataProvider ===============================

   239 

   240 // -----------------------------------------------------------------------------

   241 // CVSStillImageDataProvider::NewL(

   242 //  MVSDataProviderObserver* aObserver, MVSBufferPool* aPool )

   243 // -----------------------------------------------------------------------------

   244 //

   245 CVSStillImageDataProvider* CVSStillImageDataProvider::NewL(

   246     MVSDataProviderObserver* aObserver,

   247     MVSBufferPool* aPool )

   248     {

   249     __IF_DEBUG(Print(_L("VideoSource: [%d] CVSStillImageDataProvider::NewL() >>"), RThread().Id().operator TUint()));

   250     CVSStillImageDataProvider* self =

   251     new (ELeave) CVSStillImageDataProvider( aObserver, aPool );

   252     CleanupStack::PushL( self );

   253     self->ConstructL();

   254     CleanupStack::Pop( self );

   255     __IF_DEBUG(Print(_L("VideoSource: [%d] CVSStillImageDataProvider::NewL() <<"), RThread().Id().operator TUint()));

   256     return self;

   257     }

   258 

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

   260 // CVSStillImageDataProvider::~CVSStillImageDataProvider()

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

   262 //

   263 CVSStillImageDataProvider::~CVSStillImageDataProvider()

   264     {

   265     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::~CVSStillImageDataProvider() this %x >>"), RThread().Id().operator TUint(), this));

   266     iFs.Close();

   267     delete iVFTimer;

   268     delete iActiveWait;

   269     delete iViewer;

   270     iFreezeCS.Close();

   271     delete iScaled;

   272     ReleaseYUVData();

   273     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::~CVSStillImageDataProvider() this %x <<"), RThread().Id().operator TUint(), this));

   274     }

   275 

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

   277 // CVSStillImageDataProvider::InitializeL( const TDesC8& aInitParams )

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

   279 //

   280 void CVSStillImageDataProvider::InitializeL( const TDesC8& aInitParams )

   281     {

   282     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::InitializeL() >>"), RThread().Id().operator TUint()));

   283 

   284     CommonInitializeL();

   285 

   286     TPckgBuf< TVSStillImageDataProviderParams > pb;

   287     pb.Copy( aInitParams );

   288 

   289     iInitType = pb().iInitialize;

   290     iPSState = EPSInitializing;

   291 

   292     switch( pb().iInitialize )

   293         {

   294         /** Initialize from blank image */

   295         case TVSStillImageDataProviderParams::EInitializeAsBlankImage:

   296             BlankImageInitializeL();

   297             break;

   298 

   299         /** Initialize from General Settings */

   300         case TVSStillImageDataProviderParams::EInitializeFromGeneralSettings:

   301             GeneralSettingsInitializeL( EGSStillImage );

   302             break;

   303 

   304         /** Initilaize from General Settings*/

   305         case TVSStillImageDataProviderParams::EInitializeAsDefaultStillImage:

   306             GeneralSettingsInitializeL( EGSDefaultStillImage );

   307             break;

   308 

   309         /** Initialize from file */

   310         case TVSStillImageDataProviderParams::EInitializeFromFile:

   311             FileImageInitializeL( pb().iFileName );

   312             break;

   313         }

   314 

   315     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::InitializeL() <<"), RThread().Id().operator TUint()));

   316     }

   317 

   318 // -----------------------------------------------------------------------------

   319 // CVSStillImageDataProvider::CommonInitializeL()

   320 // -----------------------------------------------------------------------------

   321 //

   322 void CVSStillImageDataProvider::CommonInitializeL()

   323     {

   324     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::CommonInitializeL() >>"), RThread().Id().operator TUint()));

   325     iVFTimer = CVSFrameRateTimer::NewL( this );

   326     CActiveScheduler::Add( iVFTimer );

   327     iActiveWait = new (ELeave) CVSActiveWait< CVSStillImageDataProvider > ( this );

   328 

   329     //Create viewer

   330     iViewer = CMultiframeProvider::NewL( this , iDisplayMode );

   331     User::LeaveIfError( iFreezeCS.CreateLocal() );

   332 

   333     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::CommonInitializeL() <<"), RThread().Id().operator TUint()));

   334     }

   335 

   336 // -----------------------------------------------------------------------------

   337 // CVSStillImageDataProvider::GeneralSettingsInitializeL()

   338 // -----------------------------------------------------------------------------

   339 //

   340 void CVSStillImageDataProvider::GeneralSettingsInitializeL( const TGeneralSettingsImageType aType )

   341     {

   342     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::GeneralSettingsInitializeL() >>"), RThread().Id().operator TUint()));

   343 		iViewer->IniatializeGSL( aType );

   344     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::GeneralSettingsInitializeL() <<"), RThread().Id().operator TUint()));

   345     }

   346 

   347 // -----------------------------------------------------------------------------

   348 // CVSStillImageDataProvider::BlankImageInitializeL()

   349 // -----------------------------------------------------------------------------

   350 //

   351 void CVSStillImageDataProvider::BlankImageInitializeL()

   352     {

   353     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::BlankImageInitializeL() %x >>"), RThread().Id().operator TUint(), this));

   354 		iViewer->IniatializeBlankL();

   355     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::BlankImageInitializeL() %x <<"), RThread().Id().operator TUint(), this));

   356     }

   357 

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

   359 // CVSStillImageDataProvider::FileImageInitializeL

   360 // -----------------------------------------------------------------------------

   361 //

   362 void CVSStillImageDataProvider::FileImageInitializeL( const TFileName& aFileName )

   363     {

   364     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::FileImageInitializeL(): %S >>"), RThread().Id().operator TUint(), &aFileName ));

   365 		iViewer->InitializeL( &aFileName );

   366     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::FileImageInitializeL() %x <<"), RThread().Id().operator TUint(), this));

   367     }

   368 

   369 

   370 // -----------------------------------------------------------------------------

   371 // CVSStillImageDataProvider::DigitalZoomFactor() const

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

   373 //

   374 TInt CVSStillImageDataProvider::DigitalZoomFactor() const

   375     {

   376     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::DigitalZoomFactor() >>"), RThread().Id().operator TUint()));

   377     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::DigitalZoomFactor() <<"), RThread().Id().operator TUint()));

   378     return KMaxDigitalZoom;

   379     }

   380 

   381 // -----------------------------------------------------------------------------

   382 // CVSStillImageDataProvider::SetDigitalZoomFactorL(

   383 //  TInt /*aDigitalZoomFactor*/ )

   384 // -----------------------------------------------------------------------------

   385 //

   386 void CVSStillImageDataProvider::SetDigitalZoomFactorL(

   387     TInt /*aDigitalZoomFactor*/ )

   388     {

   389     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::SetDigitalZoomFactorL() >>"), RThread().Id().operator TUint()));

   390     User::Leave( KErrNotSupported );

   391     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::SetDigitalZoomFactorL() <<"), RThread().Id().operator TUint()));

   392     }

   393 // -----------------------------------------------------------------------------

   394 // CVSStillImageDataProvider::StartViewFinderBitmapsL( TSize& aSize )

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

   396 //

   397 void CVSStillImageDataProvider::StartViewFinderBitmapsL( TSize& aSize )

   398     {

   399     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StartViewFinderBitmapsL() >>"), RThread().Id().operator TUint()));

   400     __ASSERT_DEBUG( iPSState > EPSUninitialized,

   401         Panic( EVSPanicProviderNotReady ) );

   402     iVFState = EVFPlaying;

   403     iViewer->ClearVFScalingTargetSize();

   404     iTargetSize = aSize;

   405     iViewer->SetVFScalingTargetSize( aSize );

   406     iViewer->ScaleCopy( aSize, ETrue );

   407     iViewer->IncreaseDataConsumer();

   408     iViewer->NextFrame();

   409     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StartViewFinderBitmapsL() <<"), RThread().Id().operator TUint()));

   410     }

   411 

   412 // -----------------------------------------------------------------------------

   413 // CVSStillImageDataProvider::StartViewFinderBitmapsL(

   414 //  TSize& /*aSize*/, TRect& /*aClipRect*/ )

   415 // -----------------------------------------------------------------------------

   416 //

   417 void CVSStillImageDataProvider::StartViewFinderBitmapsL(

   418     TSize& /*aSize*/,

   419     TRect& /*aClipRect*/ )

   420     {

   421     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StartViewFinderBitmapsL() >>"), RThread().Id().operator TUint()));

   422     User::Leave( KErrNotSupported );

   423     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StartViewFinderBitmapsL() <<"), RThread().Id().operator TUint()));

   424     }

   425 

   426 // -----------------------------------------------------------------------------

   427 // CVSStillImageDataProvider::StopViewFinder()

   428 // -----------------------------------------------------------------------------

   429 //

   430 void CVSStillImageDataProvider::StopViewFinder()

   431     {

   432     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StopViewFinder() >>"), RThread().Id().operator TUint()));

   433     // Make sure scaler is cancelled (just in case!)

   434     iViewer->ClearVFScalingTargetSize();

   435     iViewer->DecreaseDataConsumer();

   436     iViewer->SetVFStop();

   437     // No double stopping..

   438     if( iVFState != EVFStopped )

   439         {

   440         iVFState = EVFStopped;

   441         iVFTimer->Cancel();

   442         }

   443     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StopViewFinder() <<"), RThread().Id().operator TUint()));

   444     }

   445 

   446 // -----------------------------------------------------------------------------

   447 // CVSStillImageDataProvider::ViewFinderActive() const

   448 // -----------------------------------------------------------------------------

   449 //

   450 TBool CVSStillImageDataProvider::ViewFinderActive() const

   451     {

   452     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::ViewFinderActive() >>"), RThread().Id().operator TUint()));

   453     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::ViewFinderActive() <<"), RThread().Id().operator TUint()));

   454     return ( iVFState == EVFPlaying );

   455     }

   456 

   457 // -----------------------------------------------------------------------------

   458 // CVSStillImageDataProvider::StartViewFinderDirectL(

   459 //  RWsSession& /*aWs*/, CWsScreenDevice& /*aScreenDevice*/,

   460 //  RWindowBase& /*aWindow*/, TRect& /*aScreenRect*/ )

   461 // -----------------------------------------------------------------------------

   462 //

   463 void CVSStillImageDataProvider::StartViewFinderDirectL(

   464     RWsSession& /*aWs*/,

   465     CWsScreenDevice& /*aScreenDevice*/,

   466     RWindowBase& /*aWindow*/,

   467     TRect& /*aScreenRect*/ )

   468     {

   469     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StartViewFinderDirectL() >>"), RThread().Id().operator TUint()));

   470     User::Leave(KErrNotSupported);

   471     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StartViewFinderDirectL() <<"), RThread().Id().operator TUint()));

   472     }

   473 

   474 // -----------------------------------------------------------------------------

   475 // CVSStillImageDataProvider::StartViewFinderDirectL(

   476 //  RWsSession& /*aWs*/, CWsScreenDevice& /*aScreenDevice*/,

   477 //  RWindowBase& /*aWindow*/, TRect& /*aScreenRect*/, TRect& /*aClipRect*/ )

   478 // -----------------------------------------------------------------------------

   479 //

   480 void CVSStillImageDataProvider::StartViewFinderDirectL(

   481     RWsSession& /*aWs*/,

   482     CWsScreenDevice& /*aScreenDevice*/,

   483     RWindowBase& /*aWindow*/,

   484     TRect& /*aScreenRect*/,

   485     TRect& /*aClipRect*/ )

   486     {

   487     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StartViewFinderDirectL() >>"), RThread().Id().operator TUint()));

   488     User::Leave(KErrNotSupported);

   489     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StartViewFinderDirectL() <<"), RThread().Id().operator TUint()));

   490     }

   491 

   492 // -----------------------------------------------------------------------------

   493 // CVSStillImageDataProvider::ProviderInfo( TVSDataProviderInfo& aInfo )

   494 // -----------------------------------------------------------------------------

   495 //

   496 void CVSStillImageDataProvider::ProviderInfo( TVSDataProviderInfo& aInfo )

   497     {

   498     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::ProviderInfo() >>"), RThread().Id().operator TUint()));

   499     Mem::FillZ( &aInfo, sizeof( aInfo ) );

   500     aInfo.iHardwareVersion = TVersion( 0, 0, 0 );

   501     aInfo.iSoftwareVersion = TVersion( 0, 0, 0 );

   502     aInfo.iOrientation = TCameraInfo::EOrientationUnknown;

   503     aInfo.iOptionsSupported = TCameraInfo::EViewFinderBitmapsSupported    |

   504                               TCameraInfo::EVideoCaptureSupported;

   505     aInfo.iFlashModesSupported = CCamera::EFlashNone;

   506     aInfo.iExposureModesSupported = CCamera::EExposureAuto;

   507     aInfo.iWhiteBalanceModesSupported = CCamera::EWBAuto;

   508     aInfo.iMinZoom = KMinZoom;

   509     aInfo.iMaxZoom = KMaxZoom;

   510     aInfo.iMaxDigitalZoom = KMaxDigitalZoom;

   511     aInfo.iMinZoomFactor = KMinZoomFactor;

   512     aInfo.iMaxZoomFactor = KMaxZoomFactor;

   513     aInfo.iMaxDigitalZoomFactor = KMaxDigitalZoomFactor;

   514     aInfo.iImageFormatsSupported = CCamera::EFormatFbsBitmapColor64K |

   515                                    CCamera::EFormatFbsBitmapColor16M;

   516     aInfo.iNumVideoFrameSizesSupported = KNumVideoSizesSupported;

   517     aInfo.iNumVideoFrameSizesSupported = KNumVideoFrameSizesSupported;

   518     aInfo.iNumVideoFrameRatesSupported = KNumVideoFrameRatesSupported;

   519     aInfo.iVideoFrameFormatsSupported = CCamera::EFormatYUV420Planar;

   520     aInfo.iMaxFramesPerBufferSupported = KMaxFramesPerBufferSupported;

   521     aInfo.iFreezeSupported = EFalse;

   522 

   523     aInfo.iSupportedColorTones =

   524         CCamera::CCameraImageProcessing::EEffectNone;

   525 

   526     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::ProviderInfo() <<"), RThread().Id().operator TUint()));

   527     }

   528 

   529 // -----------------------------------------------------------------------------

   530 // CVSStillImageDataProvider::SetViewFinderMirrorL

   531 // -----------------------------------------------------------------------------

   532 //

   533 void CVSStillImageDataProvider::SetViewFinderMirrorL( TBool /*aMirror*/ )

   534     {

   535     User::Leave( KErrNotSupported );

   536     }

   537 

   538 // -----------------------------------------------------------------------------

   539 // CVSStillImageDataProvider::ViewFinderMirror

   540 // -----------------------------------------------------------------------------

   541 //

   542 TBool CVSStillImageDataProvider::ViewFinderMirror() const

   543     {

   544     return EFalse;

   545     }

   546 

   547 // -----------------------------------------------------------------------------

   548 // CVSStillImageDataProvider::FreezeL

   549 // -----------------------------------------------------------------------------

   550 //

   551 void CVSStillImageDataProvider::FreezeL()

   552     {

   553     User::Leave( KErrNotSupported );

   554     }

   555 

   556 // -----------------------------------------------------------------------------

   557 // CVSStillImageDataProvider::UnfreezeL

   558 // -----------------------------------------------------------------------------

   559 //

   560 void CVSStillImageDataProvider::UnfreezeL()

   561     {

   562     User::Leave( KErrNotSupported );

   563     }

   564 

   565 // -----------------------------------------------------------------------------

   566 // CVSStillImageDataProvider::IsFrozen

   567 // -----------------------------------------------------------------------------

   568 //

   569 TBool CVSStillImageDataProvider::IsFrozen() const

   570     {

   571     return EFalse;

   572     }

   573 

   574 // -----------------------------------------------------------------------------

   575 // CVSStillImageDataProvider::PrimeL

   576 // -----------------------------------------------------------------------------

   577 //

   578 void CVSStillImageDataProvider::PrimeL()

   579     {

   580     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::PrimeL() &%x >>"), RThread().Id().operator TUint(), this));

   581     SourcePrimeL();

   582     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::PrimeL() <<"), RThread().Id().operator TUint()));

   583     }

   584 

   585 // -----------------------------------------------------------------------------

   586 // CVSStillImageDataProvider::FillBufferL(

   587 //  CMMFBuffer* aBuffer, MVTVideoSink* aConsumer, TMediaId aMediaId )

   588 // -----------------------------------------------------------------------------

   589 //

   590 void CVSStillImageDataProvider::FillBufferL(

   591     CMMFBuffer* /*aBuffer*/,

   592     MVTVideoSink* /*aConsumer*/,

   593     TMediaId /*aMediaId*/ )

   594     {

   595     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::FillBufferL() &%x >>"), RThread().Id().operator TUint(),this));

   596     if ( iPSState != EPSPlaying )

   597         {

   598         User::Leave( KErrNotReady );

   599         }

   600     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::FillBufferL() <<"), RThread().Id().operator TUint()));

   601     }

   602 

   603 // -----------------------------------------------------------------------------

   604 // CVSStillImageDataProvider::BufferEmptiedL( CMMFBuffer* /*aBuffer*/ )

   605 // -----------------------------------------------------------------------------

   606 //

   607 void CVSStillImageDataProvider::BufferEmptiedL( CMMFBuffer* /*aBuffer*/ )

   608     {

   609     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::BufferEmptiedL() >>"), RThread().Id().operator TUint()));

   610     User::Leave( KErrNotSupported );

   611     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::BufferEmptiedL() <<"), RThread().Id().operator TUint()));

   612     }

   613 

   614 // -----------------------------------------------------------------------------

   615 // CVSStillImageDataProvider::SourceThreadLogon(

   616 //  MAsyncEventHandler& /*aEventHandler*/ )

   617 // -----------------------------------------------------------------------------

   618 //

   619 TInt CVSStillImageDataProvider::SourceThreadLogon(

   620     MAsyncEventHandler& /*aEventHandler*/ )

   621     {

   622     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::SourceThreadLogon() &%x >>"), RThread().Id().operator TUint(),this));

   623     __ASSERT_DEBUG( iPSState > EPSUninitialized,

   624         Panic( EVSPanicProviderNotReady ) );

   625     TRAPD( err, CreateProtoTimerL() );

   626     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::SourceThreadLogon() <<"), RThread().Id().operator TUint()));

   627     return err;

   628     }

   629 

   630 // -----------------------------------------------------------------------------

   631 // CVSStillImageDataProvider::SourceThreadLogoff()

   632 // -----------------------------------------------------------------------------

   633 //

   634 void CVSStillImageDataProvider::SourceThreadLogoff()

   635     {

   636     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::SourceThreadLogoff() &%x >>"), RThread().Id().operator TUint(),this));

   637     ReleaseProtoTimer();

   638     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::SourceThreadLogoff() <<"), RThread().Id().operator TUint()));

   639     }

   640 

   641 // -----------------------------------------------------------------------------

   642 // CVSStillImageDataProvider::SourcePrimeL()

   643 // -----------------------------------------------------------------------------

   644 //

   645 void CVSStillImageDataProvider::SourcePrimeL()

   646     {

   647     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::SourcePrimeL() &%x >>"), RThread().Id().operator TUint(),this));

   648     iPSState = EPSPrimed;

   649     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::SourcePrimeL() <<"), RThread().Id().operator TUint()));

   650     }

   651 

   652 // -----------------------------------------------------------------------------

   653 // CVSStillImageDataProvider::SourcePlayL()

   654 // -----------------------------------------------------------------------------

   655 //

   656 void CVSStillImageDataProvider::SourcePlayL()

   657     {

   658     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::SourcePlayL() &%x  >>"), RThread().Id().operator TUint(),this));

   659     iPSState = EPSPlaying;

   660     iFrameCount = 0;

   661     ResetStartTime();

   662     iViewer->IncreaseDataConsumer();

   663     iProtoTimer->After( iProtoUpdateRate, &CVSStillImageDataProvider::ProtoTimer );

   664     iViewer->NextFrame();

   665     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::SourcePlayL() <<"), RThread().Id().operator TUint()));

   666     }

   667 

   668 // -----------------------------------------------------------------------------

   669 // CVSStillImageDataProvider::SourcePauseL()

   670 // -----------------------------------------------------------------------------

   671 //

   672 void CVSStillImageDataProvider::SourcePauseL()

   673     {

   674     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::SourcePauseL() &%x >>"), RThread().Id().operator TUint(),this));

   675     if ( iProtoTimer != NULL )

   676     	{

   677     	iProtoTimer->Cancel();

   678     	}

   679     iPSState = EPSPrimed;

   680     iViewer->DecreaseDataConsumer();

   681     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::SourcePauseL() <<"), RThread().Id().operator TUint()));

   682     }

   683 

   684 // -----------------------------------------------------------------------------

   685 // CVSStillImageDataProvider::SourceStopL()

   686 // -----------------------------------------------------------------------------

   687 //

   688 void CVSStillImageDataProvider::SourceStopL()

   689     {

   690     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::SourceStopL() &%x >>"), RThread().Id().operator TUint(),this));

   691     if ( iProtoTimer != NULL )

   692     	{

   693     	iProtoTimer->Cancel();

   694     	}

   695     iPSState = EPSStopped;

   696     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::SourceStopL() <<"), RThread().Id().operator TUint()));

   697     }

   698 

   699 // -----------------------------------------------------------------------------

   700 // CVSStillImageDataProvider::SetFormatL( const TDesC8& aFormat )

   701 // -----------------------------------------------------------------------------

   702 //

   703 void CVSStillImageDataProvider::SetFormatL( const TDesC8& aFormat )

   704     {

   705     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::SetFormatL() &%x >>"), RThread().Id().operator TUint(),this));

   706     if ( aFormat != KVtVideoMIMETypeYUV420 )

   707         {

   708         User::Leave( KErrNotSupported );

   709         }

   710     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::SetFormatL() <<"), RThread().Id().operator TUint()));

   711     }

   712 

   713 // -----------------------------------------------------------------------------

   714 // CVSStillImageDataProvider::SetFrameRateL( TReal32 aFrameRate )

   715 // -----------------------------------------------------------------------------

   716 //

   717 void CVSStillImageDataProvider::SetFrameRateL( TReal32 aFrameRate )

   718     {

   719     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::SetFrameRateL() &%x >>"), RThread().Id().operator TUint(),this));

   720     if ( aFrameRate != KFrameRate )

   721         {

   722         User::Leave( KErrNotSupported );

   723         }

   724     iProtoUpdateRate = static_cast<TInt>( 1000000.0 / aFrameRate );

   725     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::SetFrameRateL() <<"), RThread().Id().operator TUint()));

   726     }

   727 

   728 // -----------------------------------------------------------------------------

   729 // CVSStillImageDataProvider::SetVideoFrameSizeL( const TSize& aSize )

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

   731 //

   732 void CVSStillImageDataProvider::SetVideoFrameSizeL( const TSize& aSize )

   733     {

   734     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::SetVideoFrameSizeL() &%x >>"), RThread().Id().operator TUint(),this));

   735     if( aSize != TSize( KQcifWidth, KQcifHeight ) )

   736         {

   737         User::Leave( KErrNotSupported );

   738         }

   739     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::SetVideoFrameSizeL() <<"), RThread().Id().operator TUint()));

   740     }

   741 

   742 // -----------------------------------------------------------------------------

   743 // CVSStillImageDataProvider::GetVideoFrameSizeL( TSize& aSize ) const

   744 // -----------------------------------------------------------------------------

   745 //

   746 void CVSStillImageDataProvider::GetVideoFrameSizeL( TSize& aSize ) const

   747     {

   748     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::GetVideoFrameSizeL() &%x >>"), RThread().Id().operator TUint(),this));

   749     aSize = TSize( KQcifWidth, KQcifHeight );

   750     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::GetVideoFrameSizeL() <<"), RThread().Id().operator TUint()));

   751     }

   752 

   753 // -----------------------------------------------------------------------------

   754 // CVSStillImageDataProvider::VFTimer()

   755 // -----------------------------------------------------------------------------

   756 //

   757 void CVSStillImageDataProvider::VFTimer()

   758     {

   759     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::VFTimer() >>"), RThread().Id().operator TUint()));

   760     if( iVFState == EVFPlaying )

   761         {

   762         Observer().vsViewFinderFrameReady( iVFBitmap->Bitmap() );

   763         iVFTimer->After( KVSViewFinderUpdateRate, &CVSStillImageDataProvider::VFTimer );

   764         }

   765     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::VFTimer() <<"), RThread().Id().operator TUint()));

   766     }

   767 

   768 // -----------------------------------------------------------------------------

   769 // CVSStillImageDataProvider::ProtoTimer()

   770 // -----------------------------------------------------------------------------

   771 //

   772 void CVSStillImageDataProvider::ProtoTimer()

   773     {

   774     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::ProtoTimer() this %x >>"), RThread().Id().operator TUint(), this));

   775     iFrameCount++;

   776     CVSMMFDataBuffer* buffer = NULL;

   777     TRAPD( err, buffer = BufferPool().GetBufferL( ETrue ) );

   778     if ( err != KErrNone )

   779         {

   780         NotifyError( err );

   781         }

   782     if( buffer )

   783         {

   784         buffer->SetFrameNumber( iFrameCount );

   785         __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::ProtoTimer(): iFrameCount %d"), RThread().Id().operator TUint(), iFrameCount));

   786         buffer->SetTimeToPlay( TimeToPlay() );

   787         __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::ProtoTimer(): SetTimeToPlay() = $%08x:$%08x"), RThread().Id().operator TUint(), I64HIGH( buffer->TimeToPlay().Int64() ), I64LOW( buffer->TimeToPlay().Int64() ) ));

   788        iFreezeCS.Wait();

   789        buffer->Data() = *iYUVBuffer;

   790        iFreezeCS.Signal();

   791        TRAPD( err, Consumer()->BufferFilledL( buffer ) );

   792        if( err != KErrNone )

   793           {

   794           TInt leaveCode = KErrNone;

   795           TRAP( leaveCode, BufferPool().FreeBufferL( buffer ) );

   796           NotifyError( err );

   797           }

   798        }

   799     else

   800         {

   801         __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::ProtoTimer(): GetBufferL() returned NULL"), RThread().Id().operator TUint()));

   802         }

   803     // Just to make sure that we're actually playing. We also check that

   804     // iProtoTimer still exists BECAUSE BufferFilledL() may call

   805     // SourceThreadLogoff() if a switch is pending

   806     if( iProtoTimer && ( iPSState == EPSPlaying ) )

   807         {

   808         iProtoTimer->After( iProtoUpdateRate, &ProtoTimer );

   809         }

   810     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::ProtoTimer() this %x <<"), RThread().Id().operator TUint(), this));

   811     }

   812 

   813 // -----------------------------------------------------------------------------

   814 // CVSStillImageDataProvider::CreateProtoTimerL()

   815 // -----------------------------------------------------------------------------

   816 //

   817 void CVSStillImageDataProvider::CreateProtoTimerL()

   818     {

   819     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::CreateProtoTimerL() >>"), RThread().Id().operator TUint()));

   820     iProtoTimer = CVSFrameRateTimer::NewL( this );

   821     CActiveScheduler::Add( iProtoTimer );

   822     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::CreateProtoTimerL() <<"), RThread().Id().operator TUint()));

   823     }

   824 

   825 // -----------------------------------------------------------------------------

   826 // CVSStillImageDataProvider::ReleaseProtoTimer()

   827 // -----------------------------------------------------------------------------

   828 //

   829 void CVSStillImageDataProvider::ReleaseProtoTimer()

   830     {

   831     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::ReleaseProtoTimer() >>"), RThread().Id().operator TUint()));

   832     delete iProtoTimer;

   833     iProtoTimer = 0;

   834     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::ReleaseProtoTimer() <<"), RThread().Id().operator TUint()));

   835     }

   836 

   837 // -----------------------------------------------------------------------------

   838 // CVSStillImageDataProvider::CreateYUVDataL()

   839 // -----------------------------------------------------------------------------

   840 //

   841 void CVSStillImageDataProvider::CreateYUVDataL()

   842     {

   843     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::CreateYUVDataL() this %x >>"), RThread().Id().operator TUint(), this));

   844     CVSFbsBitmapIYUVConverter* conv =

   845     CVSFbsBitmapIYUVConverter::NewL( iYUVBitMap->Bitmap() );

   846     CleanupStack::PushL( conv );

   847     conv->ProcessL();

   848     iFreezeCS.Wait();

   849     ReleaseYUVData();

   850     iYUVBuffer = conv->YUVData().AllocL();

   851     iFreezeCS.Signal();

   852     CleanupStack::PopAndDestroy(); //  conv

   853     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::CreateYUVDataL() iYUVBuffer %x <<"), RThread().Id().operator TUint(), iYUVBuffer));

   854     }

   855 

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

   857 // CVSStillImageDataProvider::ReleaseYUVData()

   858 // -----------------------------------------------------------------------------

   859 //

   860 void CVSStillImageDataProvider::ReleaseYUVData()

   861     {

   862     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::ReleaseYUVData() >>"), RThread().Id().operator TUint()));

   863     delete iYUVBuffer;

   864     iYUVBuffer = 0;

   865     __IF_DEBUG(Print(_L("VideoSource[%d]: CVSStillImageDataProvider::ReleaseYUVData() <<"), RThread().Id().operator TUint()));

   866     }

   867 

   868 // -----------------------------------------------------------------------------

   869 // CVSStillImageDataProvider::CVSStillImageDataProvider(

   870 //  MVSDataProviderObserver* aObserver )

   871 // -----------------------------------------------------------------------------

   872 //

   873 CVSStillImageDataProvider::CVSStillImageDataProvider(

   874     MVSDataProviderObserver* aObserver,

   875     MVSBufferPool* aPool ) :

   876         CVSDataProvider( aObserver, aPool ), iProtoUpdateRate( 1000000.0 / KFrameRate )

   877     {

   878     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::CVSStillImageDataProvider() >>"), RThread().Id().operator TUint()));

   879     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::CVSStillImageDataProvider() <<"), RThread().Id().operator TUint()));

   880     }

   881 

   882 // -----------------------------------------------------------------------------

   883 // CVSStillImageDataProvider::ConstructL()

   884 // -----------------------------------------------------------------------------

   885 //

   886 void CVSStillImageDataProvider::ConstructL()

   887     {

   888     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::ConstructL() this %x >>"), RThread().Id().operator TUint(), this));

   889     CVSDataProvider::ConstructL();

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

   891     RWsSession wsSession;

   892     User::LeaveIfError( wsSession.Connect() );

   893     CleanupClosePushL( wsSession );

   894     CWsScreenDevice* wsScreenDevice = new ( ELeave ) CWsScreenDevice( wsSession );

   895     CleanupStack::PushL( wsScreenDevice );

   896     User::LeaveIfError( wsScreenDevice->Construct() );

   897     iDisplayMode = wsScreenDevice->DisplayMode();/* = EColor16MU;*/

   898     CleanupStack::PopAndDestroy( 2 ); // wsSession, wsScreenDevice

   899     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::ConstructL() this %x <<"), RThread().Id().operator TUint(), this));

   900     }

   901 

   902 // -----------------------------------------------------------------------------

   903 // CVSStillImageDataProvider::GetVideoFrameSize(

   904 //  TSize& aSize, TInt /*aSizeIndex*/, const TDesC8& aFormat )

   905 // -----------------------------------------------------------------------------

   906 //

   907 void CVSStillImageDataProvider::GetVideoFrameSize(

   908     TSize& aSize,

   909     TInt /*aSizeIndex*/,

   910     const TDesC8& aFormat )

   911     {

   912     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::GetVideoFrameSize() >>"), RThread().Id().operator TUint()));

   913     if ( aFormat == KVtVideoMIMETypeYUV420 )

   914         {

   915         aSize.SetSize( KQcifWidth, KQcifHeight );

   916         }

   917     else

   918         {

   919         aSize.SetSize( 0, 0 );

   920         }

   921     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::GetVideoFrameSize() <<"), RThread().Id().operator TUint()));

   922     }

   923 

   924 // -----------------------------------------------------------------------------

   925 // CVSStillImageDataProvider::GetVideoFrameRate(

   926 //  TReal32& aRate, TInt /*aRateIndex*/, const TDesC8& aFormat,

   927 //  const TSize& aSize )

   928 // -----------------------------------------------------------------------------

   929 //

   930 void CVSStillImageDataProvider::GetVideoFrameRate(

   931     TReal32& aRate,

   932     TInt /*aRateIndex*/,

   933     const TDesC8& aFormat,

   934     const TSize& aSize )

   935     {

   936     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::GetVideoFrameRate() >>"), RThread().Id().operator TUint()));

   937     if ( aFormat == KVtVideoMIMETypeYUV420 &&

   938         aSize == TSize( KQcifWidth, KQcifHeight ) )

   939         {

   940         aRate = KFrameRate;

   941         }

   942     else

   943         {

   944         aRate = 0.0;

   945         }

   946     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::GetVideoFrameRate() <<"), RThread().Id().operator TUint()));

   947     }

   948 

   949 // -----------------------------------------------------------------------------

   950 // CVSStillImageDataProvider::DisplayMode

   951 // -----------------------------------------------------------------------------

   952 //

   953 TDisplayMode CVSStillImageDataProvider::DisplayMode() const

   954 	{

   955 #ifdef _DEBUG

   956     TUint threadId( RThread().Id() );

   957     switch( iDisplayMode )

   958         {

   959         case EColor4K:

   960             RDebug::Print( _L( "VideoSource [%d]: DisplayMode() = EColor4K" ), threadId );

   961             break;

   962         case EColor64K:

   963             RDebug::Print( _L( "VideoSource [%d]: DisplayMode() = EColor64K" ), threadId );

   964             break;

   965         case EColor16M:

   966             RDebug::Print( _L( "VideoSource [%d]: DisplayMode() = EColor16M" ), threadId );

   967             break;

   968         case EColor16MU:

   969             RDebug::Print( _L( "VideoSource [%d]: DisplayMode() = EColor16MU" ), threadId );

   970             break;

   971         default:

   972             RDebug::Print( _L( "VideoSource [%d]: DisplayMode() = %d" ), threadId, iDisplayMode );

   973             break;

   974         }

   975 #endif // _DEBUG

   976     return iDisplayMode;

   977 	}

   978 

   979 // -----------------------------------------------------------------------------

   980 // CVSStillImageDataProvider::SetContrastL

   981 // -----------------------------------------------------------------------------

   982 //

   983 void CVSStillImageDataProvider::SetContrastL(TInt /*aContrast*/)

   984 	{

   985 	__IF_DEBUG(Print(_L("VideoSource [%d]:CVSStillImageDataProvider::SetContrastL() LEAVE"), RThread().Id().operator TUint()));

   986 	User::Leave( KErrNotSupported );

   987 	}

   988 // -----------------------------------------------------------------------------

   989 // CVSStillImageDataProvider::GetContrast

   990 // -----------------------------------------------------------------------------

   991 //

   992 TInt CVSStillImageDataProvider::GetContrast(TInt& /*aContrast*/) const

   993 	{

   994 	return KErrNotSupported;

   995 	}

   996 

   997 // -----------------------------------------------------------------------------

   998 // CVSStillImageDataProvider::SetBrightnessL

   999 // -----------------------------------------------------------------------------

  1000 //

  1001 void CVSStillImageDataProvider::SetBrightnessL(TInt /*aBrightness*/)

  1002 	{

  1003 	__IF_DEBUG(Print(_L("VideoSource [%d]:CVSStillImageDataProvider::SetBrightnessL() LEAVE"), RThread().Id().operator TUint()));

  1004 	User::Leave( KErrNotSupported );

  1005 	}

  1006 // -----------------------------------------------------------------------------

  1007 // CVSStillImageDataProvider::GetBrightness

  1008 // -----------------------------------------------------------------------------

  1009 //

  1010 TInt CVSStillImageDataProvider::GetBrightness(TInt& /*aBrightness*/ ) const

  1011 	{

  1012 	return KErrNotSupported;

  1013 	}

  1014 

  1015 // -----------------------------------------------------------------------------

  1016 // CVSStillImageDataProvider::SetWhiteBalanceL

  1017 // -----------------------------------------------------------------------------

  1018 //

  1019 void CVSStillImageDataProvider::SetWhiteBalanceL( CCamera::TWhiteBalance /*aWhiteBalance*/ )

  1020 	{

  1021 	__IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::SetWhiteBalanceL() LEAVE"), RThread().Id().operator TUint()));

  1022 	User::Leave( KErrNotSupported );

  1023 	}

  1024 // -----------------------------------------------------------------------------

  1025 // CVSStillImageDataProvider::GetWhiteBalance

  1026 // -----------------------------------------------------------------------------

  1027 //

  1028  TInt CVSStillImageDataProvider::GetWhiteBalance(CCamera::TWhiteBalance& /*aWhiteBalance*/) const

  1029 	{

  1030 	return KErrNotSupported;

  1031 	}

  1032 

  1033 // -----------------------------------------------------------------------------

  1034 // CVSStillImageDataProvider::SetColorToneL

  1035 // -----------------------------------------------------------------------------

  1036 //

  1037 void CVSStillImageDataProvider::SetColorToneL( CCamera::CCameraImageProcessing::TEffect /*aValue*/ )

  1038 	{

  1039 	__IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::SetColorToneL() LEAVE"), RThread().Id().operator TUint()));

  1040 	User::Leave( KErrNotSupported );

  1041 	}

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

  1043 // CVSStillImageDataProvider::GetColorTone

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

  1045 //

  1046 TInt CVSStillImageDataProvider::GetColorTone( CCamera::CCameraImageProcessing::TEffect& /*aColorTone*/ ) const

  1047 	{

  1048 	return KErrNotSupported;

  1049 	}

  1050 

  1051 // -----------------------------------------------------------------------------

  1052 // CVSStillImageDataProvider::InitializeReady

  1053 // -----------------------------------------------------------------------------

  1054 //

  1055 void CVSStillImageDataProvider::InitializeReady()

  1056     {

  1057     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::InitializeReady()>> "), RThread().Id().operator TUint()));

  1058     if ( EPSUndoInitializing == iPSState )

  1059         {

  1060         NotifyError(KErrCancel);

  1061         UndoCommonInitialized();

  1062         iPSState = EPSUninitialized;

  1063         }

  1064     else

  1065         {

  1066         iPSState = EPSStopped;

  1067         Observer().vsProviderReady();

  1068         }

  1069     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::InitializeReady()<< "), RThread().Id().operator TUint()));

  1070     }

  1071 

  1072 // -----------------------------------------------------------------------------

  1073 // CVSStillImageDataProvider::RefreshYUVData

  1074 // -----------------------------------------------------------------------------

  1075 //

  1076 void CVSStillImageDataProvider::RefreshYUVData( TImageShareDataBuffer& aYUVBitMap )

  1077 	{

  1078 	__IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::RefreshYUVData()>> "), RThread().Id().operator TUint()));

  1079 		iYUVBitMap = aYUVBitMap.iBitmap;

  1080 		//Create YUV buffer only in play state

  1081 		TRAP_IGNORE ( CreateYUVDataL() );

  1082 		aYUVBitMap.iIsBitmapFree = ETrue;

  1083 		__IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::RefreshYUVData()<< "), RThread().Id().operator TUint()));

  1084 	}

  1085 

  1086 // -----------------------------------------------------------------------------

  1087 // CVSStillImageDataProvider::RefreshViewFinder

  1088 // -----------------------------------------------------------------------------

  1089 //

  1090 void CVSStillImageDataProvider::RefreshViewFinder( TImageShareDataBuffer& aVFBitMap )

  1091     {

  1092     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::RefreshViewFinder()>> "), RThread().Id().operator TUint()));

  1093     iVFBitmap = aVFBitMap.iBitmap;

  1094     aVFBitMap.iIsBitmapFree = ETrue;

  1095     // Allow VF refresh only if size is what

  1096     // has beed aquired and play state is on

  1097     if ( ( iTargetSize == iVFBitmap->Size() ) && ( iVFState == EVFPlaying ) )

  1098         {

  1099         iVFTimer->After( 1, &VFTimer );

  1100         }

  1101     else

  1102         {

  1103         __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::RefreshViewFinder() conditon doesn't match, iVFState[%d] "), RThread().Id().operator TUint(), iVFState));

  1104         }

  1105     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::RefreshViewFinder()<< "), RThread().Id().operator TUint()));

  1106     }

  1107 

  1108 // -----------------------------------------------------------------------------

  1109 // CVSStillImageDataProvider::NotifyImageHandlingError

  1110 // -----------------------------------------------------------------------------

  1111 //

  1112 void CVSStillImageDataProvider::NotifyImageHandlingError( TInt aError )

  1113     {

  1114     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::NotifyImageHandlingError()>> "), RThread().Id().operator TUint()));

  1115     NotifyError( aError );

  1116     if ( ( KErrCancel == aError ) && ( EPSUndoInitializing == iPSState ) )

  1117         {

  1118         UndoCommonInitialized();

  1119         iPSState = EPSUninitialized;

  1120         }

  1121     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::NotifyImageHandlingError()<< "), RThread().Id().operator TUint()));

  1122     }

  1123 

  1124 // -----------------------------------------------------------------------------

  1125 // CVSStillImageDataProvider::CancelInitializing

  1126 // -----------------------------------------------------------------------------

  1127 //

  1128 void CVSStillImageDataProvider::CancelInitializing()

  1129     {

  1130     __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::CancelInitializing()>> "), RThread().Id().operator TUint()));

  1131     if ( iPSState != EPSInitializing )

  1132         {

  1133         __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::CancelInitializing(), iPSState is not valid,%d>> "), RThread().Id().operator TUint(), iPSState));

  1134         return;