1 /*

     2 * Copyright (c) 2004-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:  Class for NGA Drawer.

    15 *

    16 */

    17 

    18 

    19 #ifndef CVTENGDRAWNGA_H

    20 #define CVTENGDRAWNGA_H

    21 

    22 //  INCLUDES

    23 //#include <videorenderer.h>

    24 #include <posting_surface.h>

    25 #include <posting_surface_factory.h>

    26 #include <pixelformats.h>

    27 //#include <videoframebuffer.h>

    28 // GCE Surface

    29 #include "graphics/surfacemanager.h"

    30 #include "graphics/surface.h"

    31 #include "graphics/surfaceupdateclient.h"

    32 

    33 #include "CVtEngRemoteVideo.h"

    34 #include "TVtEngRenderConfigNGA.h"

    35 

    36 // FORWARDS

    37 

    38 class TDisplaySinkParamsNGA;

    39 

    40 // CONSTANTS AND MACROS

    41 const TInt KVtEngMaxSurfaceBuffers = 2;

    42 

    43 NONSHARABLE_CLASS( TVTSurfaceBuffer )

    44     {

    45     public:

    46 

    47     /**

    48     * C++ constructor

    49     */

    50     TVTSurfaceBuffer( TUint8* aBuffer = NULL, TInt aSurfaceNo = KErrNotFound );

    51                

    52     /**

    53     * Returns pointer reference to stored buffer.

    54     */

    55     TUint8* &Buffer();

    56                 

    57     /**

    58     * Returns surface no..

    59     */

    60     TInt SurfaceNo();

    61     

    62     void Set( TUint8* aBuffer, TInt aSurfaceNo );

    63     

    64     void UnSet();

    65                        

    66     private:

    67 

    68     // Pointer's pointer to buffer

    69     TUint8* iBuffer;

    70     TInt iSurfaceBufferNo;

    71     };    

    72 

    73 /**

    74 *  Buffer waiter observer API

    75 *

    76 *  @lib videoteleng.lib

    77 *  @since Series 60 MCL

    78 */

    79 NONSHARABLE_CLASS( MVtEngNGABufferWaiterObserver )

    80     {

    81     public: // New methods

    82 

    83         /**

    84         * Buffer fetched without errors.

    85         * @param aBuffer Pointer to fetched buffer.

    86         */

    87         virtual void BufferReadyL(

    88                 TVTSurfaceBuffer* aBuffer ) = 0;

    89 

    90         /**

    91         * Buffer fetch error.

    92         * @param aError Error code.

    93         */

    94         virtual void FetchError( TInt aError ) = 0;

    95     };

    96 

    97 

    98 /**

    99 *  DNGA drawer

   100 *

   101 *  @lib videoteleng.lib

   102 *  @since Series 60 MCL

   103 */

   104 NONSHARABLE_CLASS( CVtEngDrawNGA ) : 

   105     public CVtEngRemoteVideo::CVtEngDraw,

   106     public MVtEngNGABufferWaiterObserver

   107     {

   108     

   109     public: // constructor and destructor

   110 

   111         /**

   112         * Two-phased constructor.

   113         * @param aObserver call back interface to Display Sink

   114         * @return instance of CVtEngDrawDSA

   115         */

   116         static CVtEngDrawNGA* NewL( MDisplaySinkObserver* aObserver );

   117 

   118         // Destructor

   119         ~CVtEngDrawNGA();

   120 

   121     private: // construction

   122 

   123         /**

   124         * C++ constructor as private.

   125         * @param aObserver callback interface for Display Sink

   126         */

   127         CVtEngDrawNGA( MDisplaySinkObserver* aObserver );

   128 

   129     private: // from CVtEngDraw

   130 

   131         /**

   132         * @see CVtEngDraw::BaseConstructL

   133         */

   134         void BaseConstructL();

   135 

   136         /**

   137         * @see CVtEngDraw::CreateSinkL

   138         */

   139         MDisplaySink* CreateSinkL();

   140 

   141         /**

   142         * @see CVtEngDraw::BaseRefreshL

   143         */

   144         void BaseRefreshL();

   145 

   146         /**

   147         * @see CVtEngDraw::BaseRefreshBitmapsL

   148         */

   149         void BaseRefreshBitmapsL();

   150 

   151         /**

   152         * @see CVtEngDraw::BaseDoCancel

   153         */

   154         void BaseDoCancel();

   155 

   156         /**

   157         * @see CVtEngDraw::BaseVerifyConfigL

   158         */

   159         void BaseVerifyConfigL();

   160 

   161         /**

   162         * @see CVtEngDraw::BaseRestartL

   163         */

   164         void BaseRestartL();

   165 

   166         /**

   167         * @see CVtEngDraw::BaseAbortNow

   168         */

   169         void BaseAbortNow();

   170 

   171         /**

   172         * @see CVtEngDraw::BaseStartDrawL

   173         */

   174         void BaseStartDrawL();

   175 

   176         /**

   177         * @see CVtEngDraw::BaseStopDraw

   178         */

   179         void BaseStopDraw();

   180 

   181         /**

   182         * @see CVtEngDraw::BaseSetConfigL

   183         */

   184         void BaseSetConfigL( const TVtEngRenderConfig& aConfig );

   185 

   186         /**

   187         * @see CVtEngDraw::BaseSetUIForegroundL

   188         */

   189         void BaseSetUIForegroundL( TBool aForeground );

   190 

   191         /**

   192         * @see CVtEngDraw::BaseVideoFrameSizeChangedL

   193         */

   194         void BaseVideoFrameSizeChangedL( const TSize& );

   195 

   196         /**

   197         * @see CVtEngDraw::BaseRequestLastFrame

   198         */        

   199         void BaseRequestLastFrame();

   200         

   201         /**

   202         * @see CVtEngDraw::Config

   203         */

   204         TVtEngRenderConfig& Config();

   205         

   206     private: // New mothod

   207        

   208         /**

   209         * Returns reference to sink.

   210         */

   211         MDisplaySink& DisplaySink();     

   212                

   213         /**

   214         * Base construct implementation

   215         */

   216         void DoBaseConstructL();

   217         

   218         /**

   219         * Base start drawing implementation

   220         */

   221         void DoBaseStartDrawL();             

   222     

   223         /**

   224         * Sets given buffer available to display sink.

   225         */

   226         void SetAvailableToSink( TVTSurfaceBuffer* aBuffer );     

   227         

   228         /**

   229         * Update sink params implementation.

   230         */

   231         void DoUpdateSinkParamsL();

   232 

   233         /**

   234         * Updates sink params.

   235         */

   236         void UpdateSinkParamsL();   

   237 

   238         /**

   239         * Create surface

   240         */        

   241         void CreateSurfaceL();

   242         

   243         /**

   244         * Create surface implementation

   245         */        

   246         void DoCreateSurfaceL();        

   247         

   248         static TInt SurfaceBuffer0Ready(TAny* aAny);

   249         

   250         static TInt SurfaceBuffer1Ready(TAny* aAny);

   251      

   252         TBool DoSurfaceBuffer0Ready();

   253         

   254         TBool DoSurfaceBuffer1Ready();

   255    

   256     public: //from MVtEngNGABufferWaiterObserver

   257     

   258         /**

   259         * @see MVtEngNGABufferWaiterObserver::BufferReadyL

   260         */

   261         void BufferReadyL( TVTSurfaceBuffer* aBuffer );

   262 

   263         /**

   264         * @see MVtEngNGABufferWaiterObserver::FetchError

   265         */

   266         void FetchError( TInt aError );

   267     

   268         

   269     private:

   270         /**

   271         *  @see CActive::RunL

   272         */       

   273         void RunL();

   274         

   275     private: // New functions

   276         /**

   277         * Fills TDisplaySinkParamsNGA struct

   278         */

   279         void GetSinkParams( TDisplaySinkParamsNGA& aSinkParams );

   280         

   281     private: //inner class

   282         

   283         // Buffer class for storing buffer.

   284         NONSHARABLE_CLASS( TVtEngBuffer )

   285             {

   286             public:

   287 

   288                 /**

   289                 * C++ constructor

   290                 */

   291                 TVtEngBuffer();

   292 

   293                 /**

   294                 * Sets buffer

   295                 */

   296                 void Set( TVTSurfaceBuffer* aBuffer );                

   297 

   298                 /**

   299                 * Unsets buffer

   300                 */

   301                 void UnSet();

   302 

   303                 /**

   304                 * Returns ETrue if buffer is set

   305                 */

   306                 TBool IsSet() const;

   307 

   308                 /**

   309                 * Returns pointer reference to stored buffer.

   310                 */

   311                 TVTSurfaceBuffer* &SurfaceBuffer();

   312                 

   313                 /**

   314                 * Returns pointer reference to stored buffer.

   315                 */

   316                 TUint8* &Buffer();

   317                                 

   318             private:

   319 

   320                 // Pointer's pointer to buffer

   321                 TUint8* iBuffer;

   322                 TVTSurfaceBuffer* iSurfaceBuffer;

   323             };    

   324             

   325         // Waiter class for asynchronous events.

   326         NONSHARABLE_CLASS( CVtEngBufferWaiter ) : public CActive

   327             {

   328             public:

   329 

   330                 /**

   331                 * C++ constructor.

   332                 */

   333                 CVtEngBufferWaiter( //CVideoRenderer& aVideoRenderer,

   334                     MVtEngNGABufferWaiterObserver& aObserver );

   335 

   336                 /**

   337                 * Destructor, frees all resources allocated by this instance.

   338                 */

   339                 ~CVtEngBufferWaiter();

   340 

   341                 /**

   342                 * Fetch new buffer (also activates listening).

   343                 */

   344                 TInt FetchBuffer();

   345                 

   346                 /**

   347                 * One SurfaceBuffer is available

   348                 */

   349                 void BufferAvailable(TVTSurfaceBuffer& aBuffer); 

   350 

   351             private: // new methods

   352 

   353                 /**

   354                 * Activate buffer listening (also calls CActive::SetActive()).

   355                 */

   356                 void Activate();

   357 

   358             private: // from CActive

   359 

   360                 /**

   361                 * @see CActive::RunL()

   362                 */

   363                 void RunL();

   364 

   365                 /**

   366                 * @see CActive::DoCancel()

   367                 */

   368                 void DoCancel();

   369 

   370             private: // data

   371 

   372                 // Video frame renderer (not owned)

   373                 //CVideoRenderer* iVideoRenderer;

   374 

   375                 // BufferWaiter observer who gets informed about buffers

   376                 MVtEngNGABufferWaiterObserver* iObserver;      

   377                 

   378                 //Avaiable surface buffers

   379                 TVTSurfaceBuffer* iBuffers[KVtEngMaxSurfaceBuffers];         

   380                 

   381             };

   382             

   383         // Surface Buffer Active Call back.

   384         NONSHARABLE_CLASS( CActiveCallBack ) : public CActive

   385             {

   386             public:

   387                 CActiveCallBack( TCallBack aCallBack, TInt aPriority): CActive(aPriority), iCallBack(aCallBack) 

   388                     {};

   389                 CActiveCallBack();

   390                            

   391             public: // Functions from base classes

   392                 void SetActive() 

   393                     { 

   394                     CActive::SetActive();

   395                     }; 

   396                 void RunL() 

   397                     { 

   398                     iCallBack.CallBack();

   399                     };

   400                 void DoCancel() 

   401                     {};

   402                            

   403             private: // Data

   404                 TCallBack iCallBack;

   405             };

   406 

   407     private: // data        

   408     

   409         //Video frame renderer

   410         //CVideoRenderer *iVideoRenderer;

   411         RSurfaceManager* iSurfaceManager;

   412         RSurfaceUpdateSession iSurfaceUpdateSession;

   413         //Surface pixel format

   414         TUidPixelFormat iSurfaceFormat;

   415         

   416         RChunk* iSurfaceChunk;

   417         

   418         TInt8* iChunkBuffer0;

   419         

   420         TInt8* iChunkBuffer1;

   421         

   422         TVTSurfaceBuffer iSurfaceBuffer0;

   423         

   424         TVTSurfaceBuffer iSurfaceBuffer1;

   425         

   426         //CActiveCallBack* iSurfaceBufferAo0; 

   427         

   428         //CActiveCallBack* iSurfaceBufferAo1;

   429         

   430         CActiveCallBack* iCallBackTable[KVtEngMaxSurfaceBuffers];

   431         

   432         //NGA surface id

   433         TSurfaceId iSurfaceId;

   434         

   435         //NGA surface has created

   436         TBool	iSurfaceCreated;        

   437                

   438         // Buffer waiter instance

   439         CVtEngBufferWaiter* iBufferWaiter;              

   440         

   441         // Surface buffers

   442         TVtEngBuffer

   443             iSurfaceBuffers[ MDisplaySink::EFirstBitmap + KVtEngMaxSurfaceBuffers ];   

   444         

   445         TSglQue<TVtEngBuffer> iWaitingBuffers; // buffers waiting to be submitted

   446         TBool iSubmitPending;

   447 

   448         //configuration

   449         TVtEngRenderConfigNGA iConfig;

   450         

   451     };

   452 

   453 #endif // CVTENGDRAWDSA_H