310 lines
8.3 KiB
C
310 lines
8.3 KiB
C
/*
|
|
* Copyright (C) Texas Instruments - http://www.ti.com/
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
#ifndef __RGZ_2D__
|
|
#define __RGZ_2D__
|
|
|
|
#include <linux/bltsville.h>
|
|
|
|
/*
|
|
* Maximum number of layers used to generate subregion rectangles in a
|
|
* horizontal region.
|
|
*/
|
|
#define RGZ_MAXLAYERS 13
|
|
|
|
/*
|
|
* Maximum number of layers the regionizer will accept as input. Account for an
|
|
* additional 'background layer' to generate empty subregion rectangles and
|
|
* a damage region as well.
|
|
*/
|
|
#define RGZ_INPUT_MAXLAYERS (RGZ_MAXLAYERS - 2)
|
|
|
|
/* Number of framebuffers to track */
|
|
#define RGZ_NUM_FB 2
|
|
|
|
/*
|
|
* Regionizer data
|
|
*
|
|
* This is an oqaque structure passed in by the client
|
|
*/
|
|
struct rgz;
|
|
typedef struct rgz rgz_t;
|
|
|
|
/*
|
|
* With an open framebuffer file descriptor get the geometry of
|
|
* the device
|
|
*/
|
|
int rgz_get_screengeometry(int fd, struct bvsurfgeom *geom, int fmt);
|
|
|
|
/*
|
|
* Regionizer input parameters
|
|
*/
|
|
struct rgz_in_hwc {
|
|
int flags;
|
|
int layerno;
|
|
hwc_layer_1_t *layers;
|
|
#ifdef OMAP_ENHANCEMENT_HWC_EXTENDED_API
|
|
hwc_layer_extended_t *extlayers;
|
|
#endif
|
|
struct bvsurfgeom *dstgeom;
|
|
};
|
|
|
|
typedef struct rgz_in_params {
|
|
int op; /* See RGZ_IN_* */
|
|
union {
|
|
struct rgz_in_hwc hwc;
|
|
} data;
|
|
} rgz_in_params_t;
|
|
|
|
#ifdef OMAP_ENHANCEMENT_HWC_EXTENDED_API
|
|
typedef struct rgz_ext_layer_list {
|
|
hwc_layer_extended_t layers[RGZ_INPUT_MAXLAYERS];
|
|
} rgz_ext_layer_list_t;
|
|
#endif
|
|
|
|
/*
|
|
* Validate whether the HWC layers can be rendered
|
|
*
|
|
* Arguments (rgz_in_params_t):
|
|
* op RGZ_IN_HWCCHK
|
|
* data.hwc.layers HWC layer array
|
|
* data.hwc.layerno HWC layer array size
|
|
*
|
|
* Returns:
|
|
* rv = RGZ_ALL, -1 failure
|
|
*/
|
|
#define RGZ_IN_HWCCHK 1
|
|
|
|
/*
|
|
* Regionize the HWC layers
|
|
*
|
|
* This generates region data which can be used with regionizer
|
|
* output function. This call will validate whether all or some of the
|
|
* layers can be rendered.
|
|
*
|
|
* The caller must use rgz_release when done with the region data
|
|
*
|
|
* Arguments (rgz_in_params_t):
|
|
* op RGZ_IN_HWC
|
|
* data.hwc.layers HWC layer array
|
|
* data.hwc.layerno HWC layer array size
|
|
*
|
|
* Returns:
|
|
* rv = RGZ_ALL, -1 failure
|
|
*/
|
|
#define RGZ_IN_HWC 2
|
|
|
|
int rgz_in(rgz_in_params_t *param, rgz_t *rgz);
|
|
|
|
/* This means all layers can be blitted */
|
|
#define RGZ_ALL 1
|
|
|
|
/*
|
|
* Free regionizer resources
|
|
*/
|
|
void rgz_release(rgz_t *rgz);
|
|
|
|
/*
|
|
* Regionizer output operations
|
|
*/
|
|
struct rgz_out_bvcmd {
|
|
void *cmdp;
|
|
int cmdlen;
|
|
struct bvsurfgeom *dstgeom;
|
|
int noblend;
|
|
buffer_handle_t out_hndls[RGZ_INPUT_MAXLAYERS]; /* OUTPUT */
|
|
int out_nhndls; /* OUTPUT */
|
|
int out_blits; /* OUTPUT */
|
|
};
|
|
|
|
struct rgz_out_svg {
|
|
int dispw;
|
|
int disph;
|
|
int htmlw;
|
|
int htmlh;
|
|
};
|
|
|
|
struct rgz_out_bvdirect {
|
|
struct bvbuffdesc *dstdesc;
|
|
struct bvsurfgeom *dstgeom;
|
|
int noblend;
|
|
};
|
|
|
|
typedef struct rgz_out_params {
|
|
int op; /* See RGZ_OUT_* */
|
|
union {
|
|
struct rgz_out_bvcmd bvc;
|
|
struct rgz_out_bvdirect bv;
|
|
struct rgz_out_svg svg;
|
|
} data;
|
|
} rgz_out_params_t;
|
|
|
|
/*
|
|
* Regionizer output commands
|
|
*/
|
|
|
|
/*
|
|
* Output SVG from regionizer
|
|
*
|
|
* rgz_out_params_t:
|
|
*
|
|
* op RGZ_OUT_SVG
|
|
* data.svg.dispw
|
|
* data.svg.disph Display width and height these values will be the
|
|
* viewport dimensions i.e. the logical coordinate space
|
|
* rather than the physical size
|
|
* data.svg.htmlw
|
|
* data.svg.htmlh HTML output dimensions
|
|
*/
|
|
#define RGZ_OUT_SVG 0
|
|
|
|
/*
|
|
* This commands generates bltsville command data structures for HWC which will
|
|
* paint layer by layer
|
|
*
|
|
* rgz_out_params_t:
|
|
*
|
|
* op RGZ_OUT_BVCMD_PAINT
|
|
* data.bvc.cmdp Pointer to buffer with cmd data
|
|
* data.bvc.cmdlen length of cmdp
|
|
* data.bvc.dstgeom bltsville struct describing the destination geometry
|
|
* data.bvc.noblend Test option to disable blending
|
|
* data.bvc.out_hndls Array of buffer handles (OUTPUT)
|
|
* data.bvc.out_nhndls Number of buffer handles (OUTPUT)
|
|
* data.bvc.out_blits Number of blits (OUTPUT)
|
|
*/
|
|
#define RGZ_OUT_BVCMD_PAINT 1
|
|
|
|
/*
|
|
* This commands generates bltsville command data structures for HWC which will
|
|
* render via regions. This will involve a complete redraw of the screen.
|
|
*
|
|
* See RGZ_OUT_BVCMD_PAINT
|
|
*/
|
|
#define RGZ_OUT_BVCMD_REGION 2
|
|
|
|
/*
|
|
* Perform actual blits painting each layer from back to front - this is a test
|
|
* command
|
|
*
|
|
* rgz_out_params_t:
|
|
*
|
|
* op RGZ_OUT_BVDIRECT_PAINT
|
|
* data.bv.dstdesc bltsville struct describing the destination buffer
|
|
* data.bv.dstgeom bltsville struct describing the destination geometry
|
|
* data.bv.list List of HWC layers to blit, only HWC_OVERLAY layers
|
|
* will be rendered
|
|
* data.bv.noblend Test option to disable blending
|
|
*/
|
|
#define RGZ_OUT_BVDIRECT_PAINT 3
|
|
/*
|
|
* Perform actual blits where each blit is a subregion - this is a test mode
|
|
*/
|
|
#define RGZ_OUT_BVDIRECT_REGION 5
|
|
|
|
int rgz_out(rgz_t *rgz, rgz_out_params_t* params);
|
|
|
|
/*
|
|
* Produce instrumented logging of layer data
|
|
*/
|
|
void rgz_profile_hwc(hwc_display_contents_1_t* list, int dispw, int disph);
|
|
|
|
/*
|
|
* ----------------------------------
|
|
* IMPLEMENTATION DETAILS FOLLOW HERE
|
|
* ----------------------------------
|
|
*/
|
|
|
|
/*
|
|
* Regionizer blit data structures
|
|
*/
|
|
typedef struct blit_rect {
|
|
int left, top, right, bottom;
|
|
} blit_rect_t;
|
|
|
|
/*
|
|
* A hregion is a horizontal area generated from the intersection of layers
|
|
* for a given composition.
|
|
*
|
|
* ----------------------------------------
|
|
* | layer 0 |
|
|
* | xxxxxxxxxxxxxxxxxx |
|
|
* | x layer 1 x |
|
|
* | x x |
|
|
* | x xxxxxxxxxxxxxxxxxxx
|
|
* | x x layer 2 x
|
|
* | x x x
|
|
* | xxxxxxxxxx x
|
|
* | x x
|
|
* | x x
|
|
* ---------------------xxxxxxxxxxxxxxxxxxx
|
|
*
|
|
* This can be broken up into a number of horizontal regions:
|
|
*
|
|
* ----------------------------------------
|
|
* | H1 l0 |
|
|
* |-----------xxxxxxxxxxxxxxxxxx---------|
|
|
* | H2 x x |
|
|
* | l0 x l01 x l0 |
|
|
* |-----------x--------xxxxxxxxxxxxxxxxxxx
|
|
* | H3 x x x x
|
|
* | l0 x l01 x l012 x l02 x
|
|
* |-----------xxxxxxxxxxxxxxxxxx---------x
|
|
* | H4 x x
|
|
* | l0 x l02 x
|
|
* ---------------------xxxxxxxxxxxxxxxxxxx
|
|
*
|
|
* Each hregion is just an array of rectangles. By accounting for the layers
|
|
* at different z-order, and hregion becomes a multi-dimensional array e.g. in
|
|
* the diagram above H4 has 2 sub-regions, layer 0 intersects with the first
|
|
* region and layers 0 and 2 intersect with the second region.
|
|
*/
|
|
#define RGZ_SUBREGIONMAX ((RGZ_MAXLAYERS << 1) - 1)
|
|
#define RGZ_MAX_BLITS (RGZ_SUBREGIONMAX * RGZ_SUBREGIONMAX)
|
|
|
|
typedef struct rgz_layer {
|
|
hwc_layer_1_t hwc_layer;
|
|
uint32_t identity;
|
|
int buffidx;
|
|
int dirty_count;
|
|
} rgz_layer_t;
|
|
|
|
typedef struct rgz_fb_state {
|
|
int rgz_layerno;
|
|
rgz_layer_t rgz_layers[RGZ_MAXLAYERS];
|
|
} rgz_fb_state_t;
|
|
|
|
typedef struct blit_hregion {
|
|
blit_rect_t rect;
|
|
rgz_layer_t *rgz_layers[RGZ_MAXLAYERS];
|
|
int nlayers;
|
|
int nsubregions;
|
|
blit_rect_t blitrects[RGZ_MAXLAYERS][RGZ_SUBREGIONMAX]; /* z-order | rectangle */
|
|
} blit_hregion_t;
|
|
|
|
enum { RGZ_STATE_INIT = 1, RGZ_REGION_DATA = 2} ;
|
|
|
|
struct rgz {
|
|
/* All fields here are opaque to the caller */
|
|
blit_hregion_t *hregions;
|
|
int nhregions;
|
|
int state;
|
|
rgz_fb_state_t cur_fb_state;
|
|
int fb_state_idx; /* Target framebuffer index. Points to the fb where the blits will be applied to */
|
|
rgz_fb_state_t fb_states[RGZ_NUM_FB]; /* Storage for previous framebuffer geometry states */
|
|
blit_rect_t damaged_area; /* Area of the screen which will be redrawn unconditionally */
|
|
};
|
|
|
|
#endif /* __RGZ_2D__ */
|