compo_rect.h

COMPO source code for reference

/*******************************************************************************

File name   : compo_rect.h

Description : Compositor rectangle  header file

COPYRIGHT (C) STMicroelectronics 2000.

Date               Modification                                     Name
----               ------------                                     ----
02 April 2003        Created                                          TM
*******************************************************************************/

/* Define to prevent recursive inclusion */

#ifndef __COMPO_RECT_H
#define __COMPO_RECT_H


/* Includes ----------------------------------------------------------------- */

#include "stddefs.h"
#include "hal_compo.h"
#include "compo_pool.h"
#ifdef COMPO_USE_EVENT_NOTIFY
#include "stevt.h"
#endif
/* C++ support */
#ifdef __cplusplus
extern "C" {
#endif

/* Exported Constants ------------------------------------------------------- */
/* This is the assumed maximum complexity for a rectangle on the screen.
   If it exceeds this, then we have to malloc memory for the overlay list.*/
#define DEFAULT_COMPLEXITY  10
#define STCOMPO_OVERLAY_BACKGROUND ((stcompo_Overlay_t *) -1)
#define DEFAULT_SCREENRECTS 100
#ifdef COMPO_USE_EVENT_NOTIFY
#define STCOMPO_NB_REGISTERED_EVENTS 1
#endif

/* Overwrite support: default number of slices */
#define SLICES_NUMBER 3

/* Compo trace flags */
/*#define COMPO_ENABLE_VIDEO_SOURCE_TRACE*/

/* Exported Types ----------------------------------------------------------- */

typedef struct stcompo_OverlayParams_s
{
    STCOMPO_OverlayMode_t               Flags;      /* Flags to define which bits are set in structure */
    STGXOBJ_Rectangle_t                 DstRect;    /* Rectangle in which to place image on screen */
    STCOMPO_OverlayHandle_t             Infront;
    STCOMPO_OverlayHandle_t             Behind;
    U8                                  ConstantAlpha;
    U8                                  ConstantAlpha1;
} stcompo_OverlayParams_t;


typedef struct
{
    stcompo_OverlayParams_t     WriteParams;
    stcompo_OverlayParams_t     ReadParams;
    STCOMPO_Handle_t            CompoHandle;
    HALCOMPO_OverlayHandle_t    HalOverlay;          /* Hal overlay */
} stcompo_Overlay_t;


typedef struct stcompo_ScreenRect_s
{
    STGXOBJ_Rectangle_t Rect;                           /* Area of screen this structure covers */
    U32                 Complexity;                     /* Number of overlays using it */
    U32                 TileWidth, TileHeight;          /* Size of destination tile for this rectangle */
    stcompo_Overlay_t** Overlay_pp;                     /* Pointer to a list of overlays - this will
                                                           default to point to Overlays, but if we
                                                           have more overlays interested in this
                                                           rectangle then a new array will be
                                                           malloced for them. */
    stcompo_Overlay_t*  Overlays[DEFAULT_COMPLEXITY];   /* Place to store our overlay information. */
    U32                 SrcSliceNbr;                    /* Correspondent source slice number of the current
                                                           screen rectangle */
    BOOL                ContainVideo;                   /* TRUE when screen rect contains video overlay */
    BOOL                Decomposed;                     /* TRUE when screen rect is already decomposed */
    struct stcompo_ScreenRect_s* NextRect_p;            /* Pointer to the next screen rect in the list */
    struct stcompo_ScreenRect_s* PrevRect_p;            /* Pointer to the previous screen rect in the list */
}   stcompo_ScreenRect_t;

typedef struct
{
    STGXOBJ_Bitmap_t        OutputBitmap;           /* Output bitmap of the compositor */
    U32                     ScreenWidth;
    U32                     ScreenHeight;
    STGXOBJ_Color_t         BackgroundColor;        /* Background color of the compositor */
    stcompo_Overlay_t*      Front_p;                /* Pointer to the Overlay at the Top */
} stcompo_DeviceParams_t;


typedef struct
{
    /* common stuff */
    ST_Partition_t*         CPUPartition_p;

    /* General */
#ifdef ST_OS21
    semaphore_t*            AccessControlSemaphore_p; /* Semaphore used for data structure access control */
#endif
#ifdef ST_OS20
    semaphore_t             AccessControlSemaphore; /* Semaphore used for data structure access control */
#endif

    /* Cache related */
    U32                     CacheBpp;               /* Number of bit per pixel of Cache color format */
    STGXOBJ_Bitmap_t        BlitterCacheBitmap;     /* Bitmap used as Cache */

    /* Composition related */
    BOOL                    ExecutionOn;                  /* TRUE when execution process is active */
    BOOL                    UpdateComposition;            /* TRUE when composition list need to be updated */
    BOOL                    UpdateExecution;              /* TRUE when execution list need to be updated */
    BOOL                    StartExecution;               /* TRUE when nodes list execution can be started  */
    BOOL                    UpdateCompositionCommitted;   /* TRUE when composition list has been committed, Frame field list to be generated */
    BOOL                    UpdateTopFieldComposition;    /* TRUE when composition list has been committed, Top field list to be generated */
    BOOL                    UpdateBottomFieldComposition; /* TRUE when composition list has been committed, Bottom field list to be generated */

    /* Screen rectangle related */
    stcompo_ScreenRect_t*   FirstScreenRect_p;          /* First rectangle of the list */
    stcompo_ScreenRect_t*   LastScreenRect_p;           /* Last rectangle of the list */
    stcompo_ScreenRect_t*   NextScreenRect_p;           /* First free rectangle of the list */
    stcompo_ScreenRect_t*   FirstAllocatedScreenRect_p; /* First allocated rectangle of the list */

    /* Background overlay related */
    stcompo_Overlay_t       BackgroundOverlay;      /*  Background overlay (particular hidden overlay)*/

    /* Pointer to hal composition function */
    void                    (*HalComposeScreen)(HALCOMPO_Handle_t CompoHandle);


    /* Overlay descriptor related */
    U32                     OverlayNumber;                 /* Number of overlay in the Data pool */
    stcompo_DataPoolDesc_t  OverlayDataPool;               /* Data Pool for Overlay descriptors*/
    STCOMPO_OverlayHandle_t LastOverlayDeleted;            /*  Handle of last overlay deleted  */

    /* Protected data */
    stcompo_DeviceParams_t  ReadParams;
    stcompo_DeviceParams_t  WriteParams;

    /* HAL handle */
    HALCOMPO_Handle_t       HalCompoHandle;         /* Handle of the HAL compositor instance */

#ifdef COMPO_USE_EVENT_NOTIFY
	/* Events related*/
    ST_DeviceName_t             EventHandlerName;
    STEVT_Handle_t              EvtHandle;
    STEVT_EventID_t             EventID[STCOMPO_NB_REGISTERED_EVENTS];
#endif

    STCOMPO_CompositionType_t   CompositionType;                /* Composition mode information (Frame/Field) */
    STGXOBJ_MPEGFrame_t         NextPictureToBeDecodedType;     /* Next picture to be decoded type */
    U32                         RemainingGraphicComposition;    /* Number of vsynch graphic nodes composition is allowed */
    BOOL                        StartAnticipation;              /* TRUE when nodes generation anticipation is allowed */

} stcompo_Device_t;

#ifdef COMPO_ENABLE_GEN_STATICS_TRACE
typedef struct
{
    U32                     Nb_GetHWNode_Calls;
    U32                     Nb_SelectFilter_Calls;
    U32                     Nb_VerticalScaling_Calls;
    U32                     Nb_HorizontalScaling_Calls;
    U32                     Nb_ConfigureTarget_Calls;
    U32                     Nb_ConfigureForeground_Calls;
    U32                     Nb_HALCOMPO_OnePassBlend_Calls;
    U32                     Nb_HALCOMPO_BlendRectangle_Calls;
    U32                     Nb_HALCOMPO_CopyRectangle_Calls;
    U32                     Nb_HALCOMPO_FillBlendRectangle_Calls;
    U32                     Nb_HALCOMPO_FillRectangle_Calls;
    U32                     Max_GetHWNode_Time;
    U32                     Max_SelectFilter_Time;
    U32                     Max_VerticalScaling_Time;
    U32                     Max_HorizontalScaling_Time;
    U32                     Max_ConfigureTarget_Time;
    U32                     Max_ConfigureForeground_Time;
    U32                     Max_HALCOMPO_OnePassBlend_Time;
    U32                     Max_HALCOMPO_BlendRectangle_Time;
    U32                     Max_HALCOMPO_CopyRectangle_Time;
    U32                     Max_HALCOMPO_FillBlendRectangle_Time;
    U32                     Max_HALCOMPO_FillRectangle_Time;
    U32                     Global_GetHWNode_Time;
    U32                     Global_SelectFilter_Time;
    U32                     Global_VerticalScaling_Time;
    U32                     Global_HorizontalScaling_Time;
    U32                     Global_ConfigureTarget_Time;
    U32                     Global_ConfigureForeground_Time;
    U32                     Global_HALCOMPO_OnePassBlend_Time;
    U32                     Global_HALCOMPO_BlendRectangle_Time;
    U32                     Global_HALCOMPO_CopyRectangle_Time;
    U32                     Global_HALCOMPO_FillBlendRectangle_Time;
    U32                     Global_HALCOMPO_FillRectangle_Time;
} stcompo_Generation_Calls_Statics_t;
#endif




/* Exported Variables ------------------------------------------------------- */
#ifdef COMPO_ENABLE_GEN_STATICS_TRACE
stcompo_Generation_Calls_Statics_t Generation_Calls_Statics;
#endif

/* Exported Macros ---------------------------------------------------------- */


/* Exported Functions ------------------------------------------------------- */



/* C++ support */
#ifdef __cplusplus
}
#endif

#endif /* #ifndef __COMPO_RECT_H */

/* End of compo_rect.h */