diff options
Diffstat (limited to 'hwc/rgz_2d.c')
| -rwxr-xr-x | hwc/rgz_2d.c | 1997 |
1 files changed, 0 insertions, 1997 deletions
diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c deleted file mode 100755 index ac4be96..0000000 --- a/hwc/rgz_2d.c +++ /dev/null @@ -1,1997 +0,0 @@ -/* - * 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. - */ -#include <stdio.h> -#include <stdlib.h> -#include <errno.h> -#include <time.h> -#include <assert.h> -#include <strings.h> -#include <dlfcn.h> - -#include <fcntl.h> -#include <sys/mman.h> -#include <linux/fb.h> -#include <linux/bltsville.h> -#include <video/dsscomp.h> -#include <video/omap_hwc.h> - -#include <cutils/log.h> -#include <cutils/properties.h> -#include <hardware/hwcomposer.h> - -#include "hwc_dev.h" - -static int rgz_handle_to_stride(IMG_native_handle_t *h); -#define BVDUMP(p,t,parms) -#define HANDLE_TO_BUFFER(h) NULL -/* Needs to be meaningful for TILER & GFX buffers and NV12 */ -#define HANDLE_TO_STRIDE(h) rgz_handle_to_stride(h) -#define DSTSTRIDE(dstgeom) dstgeom->virtstride - -/* Borrowed macros from hwc.c vvv - consider sharing later */ -#define min(a, b) ( { typeof(a) __a = (a), __b = (b); __a < __b ? __a : __b; } ) -#define max(a, b) ( { typeof(a) __a = (a), __b = (b); __a > __b ? __a : __b; } ) -#define swap(a, b) do { typeof(a) __a = (a); (a) = (b); (b) = __a; } while (0) - -#define WIDTH(rect) ((rect).right - (rect).left) -#define HEIGHT(rect) ((rect).bottom - (rect).top) - -#define is_RGB(format) ((format) == HAL_PIXEL_FORMAT_BGRA_8888 || (format) == HAL_PIXEL_FORMAT_RGB_565 || (format) == HAL_PIXEL_FORMAT_BGRX_8888) -#define is_BGR(format) ((format) == HAL_PIXEL_FORMAT_RGBX_8888 || (format) == HAL_PIXEL_FORMAT_RGBA_8888) -#define is_NV12(format) ((format) == HAL_PIXEL_FORMAT_TI_NV12 || (format) == HAL_PIXEL_FORMAT_TI_NV12_PADDED) - -#define HAL_PIXEL_FORMAT_BGRX_8888 0x1FF -#define HAL_PIXEL_FORMAT_TI_NV12 0x100 -#define HAL_PIXEL_FORMAT_TI_NV12_PADDED 0x101 -/* Borrowed macros from hwc.c ^^^ */ -#define is_OPAQUE(format) ((format) == HAL_PIXEL_FORMAT_RGB_565 || (format) == HAL_PIXEL_FORMAT_RGBX_8888 || (format) == HAL_PIXEL_FORMAT_BGRX_8888) - -/* OUTP the means for grabbing diagnostic data */ -#define OUTP ALOGI -#define OUTE ALOGE - -#define IS_BVCMD(params) (params->op == RGZ_OUT_BVCMD_REGION || params->op == RGZ_OUT_BVCMD_PAINT) - -#define RECT_INTERSECTS(a, b) (((a).bottom > (b).top) && ((a).top < (b).bottom) && ((a).right > (b).left) && ((a).left < (b).right)) - -/* Buffer indexes used to distinguish background and layers with the clear fb hint */ -#define RGZ_BACKGROUND_BUFFIDX -2 -#define RGZ_CLEARHINT_BUFFIDX -1 - -struct rgz_blts { - struct rgz_blt_entry bvcmds[RGZ_MAX_BLITS]; - int idx; -}; - - -static int rgz_hwc_layer_blit(rgz_out_params_t *params, rgz_layer_t *rgz_layer); -static void rgz_blts_init(struct rgz_blts *blts); -static void rgz_blts_free(struct rgz_blts *blts); -static struct rgz_blt_entry* rgz_blts_get(struct rgz_blts *blts, rgz_out_params_t *params); -static int rgz_blts_bvdirect(rgz_t* rgz, struct rgz_blts *blts, rgz_out_params_t *params); -static void rgz_get_src_rect(hwc_layer_1_t* layer, blit_rect_t *subregion_rect, blit_rect_t *res_rect); -static int hal_to_ocd(int color); -static int rgz_get_orientation(unsigned int transform); -static int rgz_get_flip_flags(unsigned int transform, int use_src2_flags); -static int rgz_hwc_scaled(hwc_layer_1_t *layer); - -int debug = 0; -struct rgz_blts blts; -/* Represents a screen sized background layer */ -static hwc_layer_1_t bg_layer; - -static void svgout_header(int htmlw, int htmlh, int coordw, int coordh) -{ - OUTP("<svg xmlns=\"http://www.w3.org/2000/svg\"" - "width=\"%d\" height=\"%d\"" - "viewBox=\"0 0 %d %d\">", - htmlw, htmlh, coordw, coordh); -} - -static void svgout_footer(void) -{ - OUTP("</svg>"); -} - -static void svgout_rect(blit_rect_t *r, char *color, char *text) -{ - OUTP("<rect x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" fill=\"%s\" " - "fill-opacity=\"%f\" stroke=\"black\" stroke-width=\"1\" />", - r->left, r->top, r->right - r->left, r->bottom - r->top, color, 1.0f); - - if (!text) - return; - - OUTP("<text x=\"%d\" y=\"%d\" style=\"font-size:30\" fill=\"black\">%s" - "</text>", - r->left, r->top + 40, text); -} - -static int empty_rect(blit_rect_t *r) -{ - return !r->left && !r->top && !r->right && !r->bottom; -} - -static int get_top_rect(blit_hregion_t *hregion, int subregion, blit_rect_t **routp) -{ - int l = hregion->nlayers - 1; - do { - *routp = &hregion->blitrects[l][subregion]; - if (!empty_rect(*routp)) - break; - } - while (--l >= 0); - return l; -} - -/* - * The idea here is that we walk the layers from front to back and count the - * number of layers in the hregion until the first layer which doesn't require - * blending. - */ -static int get_layer_ops(blit_hregion_t *hregion, int subregion, int *bottom) -{ - int l = hregion->nlayers - 1; - int ops = 0; - *bottom = -1; - do { - if (!empty_rect(&hregion->blitrects[l][subregion])) { - ops++; - *bottom = l; - hwc_layer_1_t *layer = &hregion->rgz_layers[l]->hwc_layer; - IMG_native_handle_t *h = (IMG_native_handle_t *)layer->handle; - if ((layer->blending != HWC_BLENDING_PREMULT) || is_OPAQUE(h->iFormat)) - break; - } - } - while (--l >= 0); - return ops; -} - -static int get_layer_ops_next(blit_hregion_t *hregion, int subregion, int l) -{ - while (++l < hregion->nlayers) { - if (!empty_rect(&hregion->blitrects[l][subregion])) - return l; - } - return -1; -} - -static int svgout_intersects_display(blit_rect_t *a, int dispw, int disph) -{ - return ((a->bottom > 0) && (a->top < disph) && - (a->right > 0) && (a->left < dispw)); -} - -static void svgout_hregion(blit_hregion_t *hregion, int dispw, int disph) -{ - char *colors[] = {"red", "orange", "yellow", "green", "blue", "indigo", "violet", NULL}; - int b; - for (b = 0; b < hregion->nsubregions; b++) { - blit_rect_t *rect; - (void)get_top_rect(hregion, b, &rect); - /* Only generate SVG for subregions intersecting the displayed area */ - if (!svgout_intersects_display(rect, dispw, disph)) - continue; - svgout_rect(rect, colors[b % 7], NULL); - } -} - -static void rgz_out_svg(rgz_t *rgz, rgz_out_params_t *params) -{ - if (!rgz || !(rgz->state & RGZ_REGION_DATA)) { - OUTE("rgz_out_svg invoked with bad state"); - return; - } - blit_hregion_t *hregions = rgz->hregions; - svgout_header(params->data.svg.htmlw, params->data.svg.htmlh, - params->data.svg.dispw, params->data.svg.disph); - int i; - for (i = 0; i < rgz->nhregions; i++) { - - OUTP("<!-- hregion %d (subcount %d)-->", i, hregions[i].nsubregions); - svgout_hregion(&hregions[i], params->data.svg.dispw, - params->data.svg.disph); - } - svgout_footer(); -} - -/* XXX duplicate of hwc.c version */ -static void dump_layer(hwc_layer_1_t const* l, int iserr) -{ -#define FMT(f) ((f) == HAL_PIXEL_FORMAT_TI_NV12 ? "NV12" : \ - (f) == HAL_PIXEL_FORMAT_BGRX_8888 ? "xRGB32" : \ - (f) == HAL_PIXEL_FORMAT_RGBX_8888 ? "xBGR32" : \ - (f) == HAL_PIXEL_FORMAT_BGRA_8888 ? "ARGB32" : \ - (f) == HAL_PIXEL_FORMAT_RGBA_8888 ? "ABGR32" : \ - (f) == HAL_PIXEL_FORMAT_RGB_565 ? "RGB565" : "??") - - OUTE("%stype=%d, flags=%08x, handle=%p, tr=%02x, blend=%04x, {%d,%d,%d,%d}, {%d,%d,%d,%d}", - iserr ? ">> " : " ", - l->compositionType, l->flags, l->handle, l->transform, l->blending, - l->sourceCrop.left, - l->sourceCrop.top, - l->sourceCrop.right, - l->sourceCrop.bottom, - l->displayFrame.left, - l->displayFrame.top, - l->displayFrame.right, - l->displayFrame.bottom); - if (l->handle) { - IMG_native_handle_t *h = (IMG_native_handle_t *)l->handle; - OUTE("%s%d*%d(%s)", - iserr ? ">> " : " ", - h->iWidth, h->iHeight, FMT(h->iFormat)); - OUTE("hndl %p", l->handle); - } -} - -static void dump_all(rgz_layer_t *rgz_layers, unsigned int layerno, unsigned int errlayer) -{ - unsigned int i; - for (i = 0; i < layerno; i++) { - hwc_layer_1_t *l = &rgz_layers[i].hwc_layer; - OUTE("Layer %d", i); - dump_layer(l, errlayer == i); - } -} - -static int rgz_out_bvdirect_paint(rgz_t *rgz, rgz_out_params_t *params) -{ - int rv = 0; - int i; - (void)rgz; - - rgz_blts_init(&blts); - - /* Begin from index 1 to remove the background layer from the output */ - rgz_fb_state_t *cur_fb_state = &rgz->cur_fb_state; - for (i = 1; i < cur_fb_state->rgz_layerno; i++) { - rv = rgz_hwc_layer_blit(params, &cur_fb_state->rgz_layers[i]); - if (rv) { - OUTE("bvdirect_paint: error in layer %d: %d", i, rv); - dump_all(cur_fb_state->rgz_layers, cur_fb_state->rgz_layerno, i); - rgz_blts_free(&blts); - return rv; - } - } - rgz_blts_bvdirect(rgz, &blts, params); - rgz_blts_free(&blts); - return rv; -} - -static void rgz_set_async(struct rgz_blt_entry *e, int async) -{ - e->bp.flags = async ? e->bp.flags | BVFLAG_ASYNC : e->bp.flags & ~BVFLAG_ASYNC; -} - -static void rgz_get_screen_info(rgz_out_params_t *params, struct bvsurfgeom **screen_geom) -{ - *screen_geom = params->data.bvc.dstgeom; -} - -static int rgz_is_blending_disabled(rgz_out_params_t *params) -{ - return params->data.bvc.noblend; -} - -static void rgz_get_displayframe_rect(hwc_layer_1_t *layer, blit_rect_t *res_rect) -{ - res_rect->left = layer->displayFrame.left; - res_rect->top = layer->displayFrame.top; - res_rect->bottom = layer->displayFrame.bottom; - res_rect->right = layer->displayFrame.right; -} - -/* - * Returns a clock-wise rotated view of the inner rectangle relative to - * the outer rectangle. The inner rectangle must be contained in the outer - * rectangle and coordinates must be relative to the top,left corner of the outer - * rectangle. - */ -static void rgz_get_rotated_view(blit_rect_t *outer_rect, blit_rect_t *inner_rect, - blit_rect_t *res_rect, int orientation) -{ - int outer_width = WIDTH(*outer_rect); - int outer_height = HEIGHT(*outer_rect); - int inner_width = WIDTH(*inner_rect); - int inner_height = HEIGHT(*inner_rect); - int delta_top = inner_rect->top - outer_rect->top; - int delta_left = inner_rect->left - outer_rect->left; - - /* Normalize the angle */ - orientation = (orientation % 360) + 360; - - /* - * Calculate the top,left offset of the inner rectangle inside the outer - * rectangle depending on the tranformation value. - */ - switch(orientation % 360) { - case 0: - res_rect->left = delta_left; - res_rect->top = delta_top; - break; - case 180: - res_rect->left = outer_width - inner_width - delta_left; - res_rect->top = outer_height - inner_height - delta_top; - break; - case 90: - res_rect->left = outer_height - inner_height - delta_top; - res_rect->top = delta_left; - break; - case 270: - res_rect->left = delta_top; - res_rect->top = outer_width - inner_width - delta_left; - break; - default: - OUTE("Invalid transform value %d", orientation); - } - - if (orientation % 180) - swap(inner_width, inner_height); - - res_rect->right = res_rect->left + inner_width; - res_rect->bottom = res_rect->top + inner_height; -} - -static void rgz_get_src_rect(hwc_layer_1_t* layer, blit_rect_t *subregion_rect, blit_rect_t *res_rect) -{ - if (rgz_hwc_scaled(layer)) { - /* - * If the layer is scaled we use the whole cropping rectangle from the - * source and just move the clipping rectangle for the region we want to - * blit, this is done to prevent any artifacts when blitting subregions of - * a scaled layer. - */ - res_rect->top = layer->sourceCrop.top; - res_rect->left = layer->sourceCrop.left; - res_rect->bottom = layer->sourceCrop.bottom; - res_rect->right = layer->sourceCrop.right; - return; - } - - blit_rect_t display_frame; - rgz_get_displayframe_rect(layer, &display_frame); - - /* - * Get the rotated subregion rectangle with respect to the display frame. - * In order to get this correctly we need to take in account the HWC - * orientation is clock-wise so to return to the 0 degree view we need to - * rotate counter-clock wise the orientation. For example, if the - * orientation is 90 we need to rotate -90 to return to a 0 degree view. - */ - int src_orientation = 0 - rgz_get_orientation(layer->transform); - rgz_get_rotated_view(&display_frame, subregion_rect, res_rect, src_orientation); - - /* - * In order to translate the resulting rectangle relative to the cropping - * rectangle the only thing left is account for the offset (result is already - * rotated). - */ - res_rect->left += layer->sourceCrop.left; - res_rect->right += layer->sourceCrop.left; - res_rect->top += layer->sourceCrop.top; - res_rect->bottom += layer->sourceCrop.top; -} - -/* - * Convert a destination geometry and rectangle to a specified rotated view. - * Since clipping rectangle is relative to the destination geometry it will be - * rotated as well. - */ -static void rgz_rotate_dst(struct rgz_blt_entry* e, int dst_orientation) -{ - struct bvsurfgeom *dstgeom = &e->dstgeom; - struct bvrect *dstrect = &e->bp.dstrect; - struct bvrect *cliprect = &e->bp.cliprect; - - /* - * Create a rectangle that represents the destination geometry (outter - * rectangle), destination and clipping rectangles (inner rectangles). - */ - blit_rect_t dstgeom_r; - dstgeom_r.top = dstgeom_r.left = 0; - dstgeom_r.bottom = dstgeom->height; - dstgeom_r.right = dstgeom->width; - - blit_rect_t dstrect_r; - dstrect_r.top = dstrect->top; - dstrect_r.left = dstrect->left; - dstrect_r.bottom = dstrect->top + dstrect->height; - dstrect_r.right = dstrect->left + dstrect->width; - - blit_rect_t cliprect_r; - cliprect_r.top = cliprect->top; - cliprect_r.left = cliprect->left; - cliprect_r.bottom = cliprect->top + cliprect->height; - cliprect_r.right = cliprect->left + cliprect->width; - - /* Get the CW rotated view of the destination rectangle */ - blit_rect_t res_rect; - rgz_get_rotated_view(&dstgeom_r, &dstrect_r, &res_rect, dst_orientation); - dstrect->left = res_rect.left; - dstrect->top = res_rect.top; - dstrect->width = WIDTH(res_rect); - dstrect->height = HEIGHT(res_rect); - - rgz_get_rotated_view(&dstgeom_r, &cliprect_r, &res_rect, dst_orientation); - cliprect->left = res_rect.left; - cliprect->top = res_rect.top; - cliprect->width = WIDTH(res_rect); - cliprect->height = HEIGHT(res_rect); - - if (dst_orientation % 180) - swap(e->dstgeom.width, e->dstgeom.height); -} - -static void rgz_set_dst_data(rgz_out_params_t *params, blit_rect_t *subregion_rect, - struct rgz_blt_entry* e, int dst_orientation) -{ - struct bvsurfgeom *screen_geom; - rgz_get_screen_info(params, &screen_geom); - - /* omaplfb is in charge of assigning the correct dstdesc in the kernel */ - e->dstgeom.structsize = sizeof(struct bvsurfgeom); - e->dstgeom.format = screen_geom->format; - e->dstgeom.width = screen_geom->width; - e->dstgeom.height = screen_geom->height; - e->dstgeom.orientation = dst_orientation; - e->dstgeom.virtstride = DSTSTRIDE(screen_geom); - - e->bp.dstrect.left = subregion_rect->left; - e->bp.dstrect.top = subregion_rect->top; - e->bp.dstrect.width = WIDTH(*subregion_rect); - e->bp.dstrect.height = HEIGHT(*subregion_rect); - - /* Give a rotated buffer representation of the destination if requested */ - if (e->dstgeom.orientation) - rgz_rotate_dst(e, dst_orientation); -} - -/* Convert a source geometry and rectangle to a specified rotated view */ -static void rgz_rotate_src(struct rgz_blt_entry* e, int src_orientation, int is_src2) -{ - struct bvsurfgeom *srcgeom = is_src2 ? &e->src2geom : &e->src1geom; - struct bvrect *srcrect = is_src2 ? &e->bp.src2rect : &e->bp.src1rect; - - /* - * Create a rectangle that represents the source geometry (outter rectangle), - * source rectangle (inner rectangle). - */ - blit_rect_t srcgeom_r; - srcgeom_r.top = srcgeom_r.left = 0; - srcgeom_r.bottom = srcgeom->height; - srcgeom_r.right = srcgeom->width; - - blit_rect_t srcrect_r; - srcrect_r.top = srcrect->top; - srcrect_r.left = srcrect->left; - srcrect_r.bottom = srcrect->top + srcrect->height; - srcrect_r.right = srcrect->left + srcrect->width; - - /* Get the CW rotated view of the source rectangle */ - blit_rect_t res_rect; - rgz_get_rotated_view(&srcgeom_r, &srcrect_r, &res_rect, src_orientation); - - srcrect->left = res_rect.left; - srcrect->top = res_rect.top; - srcrect->width = WIDTH(res_rect); - srcrect->height = HEIGHT(res_rect); - - if (src_orientation % 180) - swap(srcgeom->width, srcgeom->height); -} - -static void rgz_set_src_data(rgz_out_params_t *params, rgz_layer_t *rgz_layer, - blit_rect_t *subregion_rect, struct rgz_blt_entry* e, int src_orientation, - int is_src2) -{ - hwc_layer_1_t *hwc_layer = &rgz_layer->hwc_layer; - struct bvbuffdesc *srcdesc = is_src2 ? &e->src2desc : &e->src1desc; - struct bvsurfgeom *srcgeom = is_src2 ? &e->src2geom : &e->src1geom; - struct bvrect *srcrect = is_src2 ? &e->bp.src2rect : &e->bp.src1rect; - IMG_native_handle_t *handle = (IMG_native_handle_t *)hwc_layer->handle; - - srcdesc->structsize = sizeof(struct bvbuffdesc); - srcdesc->length = handle->iHeight * HANDLE_TO_STRIDE(handle); - srcdesc->auxptr = (void*)rgz_layer->buffidx; - srcgeom->structsize = sizeof(struct bvsurfgeom); - srcgeom->format = hal_to_ocd(handle->iFormat); - srcgeom->width = handle->iWidth; - srcgeom->height = handle->iHeight; - srcgeom->virtstride = HANDLE_TO_STRIDE(handle); - - /* Find out what portion of the src we want to use for the blit */ - blit_rect_t res_rect; - rgz_get_src_rect(hwc_layer, subregion_rect, &res_rect); - srcrect->left = res_rect.left; - srcrect->top = res_rect.top; - srcrect->width = WIDTH(res_rect); - srcrect->height = HEIGHT(res_rect); - - /* Give a rotated buffer representation of this source if requested */ - if (src_orientation) { - srcgeom->orientation = src_orientation; - rgz_rotate_src(e, src_orientation, is_src2); - } else - srcgeom->orientation = 0; -} - -/* - * Set the clipping rectangle, if part of the subregion rectangle is outside - * the boundaries of the destination, remove only the out-of-bounds area - */ -static void rgz_set_clip_rect(rgz_out_params_t *params, blit_rect_t *subregion_rect, - struct rgz_blt_entry* e) -{ - struct bvsurfgeom *screen_geom; - rgz_get_screen_info(params, &screen_geom); - - blit_rect_t clip_rect; - clip_rect.left = max(0, subregion_rect->left); - clip_rect.top = max(0, subregion_rect->top); - clip_rect.bottom = min(screen_geom->height, subregion_rect->bottom); - clip_rect.right = min(screen_geom->width, subregion_rect->right); - - e->bp.cliprect.left = clip_rect.left; - e->bp.cliprect.top = clip_rect.top; - e->bp.cliprect.width = WIDTH(clip_rect); - e->bp.cliprect.height = HEIGHT(clip_rect); -} - -/* - * Configures blit entry to set src2 is the same as the destination - */ -static void rgz_set_src2_is_dst(rgz_out_params_t *params, struct rgz_blt_entry* e) -{ - /* omaplfb is in charge of assigning the correct src2desc in the kernel */ - e->src2geom = e->dstgeom; - e->src2desc.structsize = sizeof(struct bvbuffdesc); - e->src2desc.auxptr = (void*)HWC_BLT_DESC_FB_FN(0); - e->bp.src2rect = e->bp.dstrect; -} - -static int rgz_is_layer_nv12(hwc_layer_1_t *layer) -{ - IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle; - return is_NV12(handle->iFormat); -} - -/* - * Configure the scaling mode according to the layer format - */ -static void rgz_cfg_scale_mode(struct rgz_blt_entry* e, hwc_layer_1_t *layer) -{ - /* - * TODO: Revisit scaling mode assignment later, output between GPU and GC320 - * seem different - */ - e->bp.scalemode = rgz_is_layer_nv12(layer) ? BVSCALE_9x9_TAP : BVSCALE_BILINEAR; -} - -/* - * Copies src1 into the framebuffer - */ -static struct rgz_blt_entry* rgz_hwc_subregion_copy(rgz_out_params_t *params, - blit_rect_t *subregion_rect, rgz_layer_t *rgz_src1) -{ - struct rgz_blt_entry* e = rgz_blts_get(&blts, params); - hwc_layer_1_t *hwc_src1 = &rgz_src1->hwc_layer; - e->bp.structsize = sizeof(struct bvbltparams); - e->bp.op.rop = 0xCCCC; /* SRCCOPY */ - e->bp.flags = BVFLAG_CLIP | BVFLAG_ROP; - e->bp.flags |= rgz_get_flip_flags(hwc_src1->transform, 0); - rgz_set_async(e, 1); - - blit_rect_t tmp_rect; - if (rgz_hwc_scaled(hwc_src1)) { - rgz_get_displayframe_rect(hwc_src1, &tmp_rect); - rgz_cfg_scale_mode(e, hwc_src1); - } else - tmp_rect = *subregion_rect; - - int src1_orientation = rgz_get_orientation(hwc_src1->transform); - int dst_orientation = 0; - - if (rgz_is_layer_nv12(hwc_src1)) { - /* - * Leave NV12 as 0 degree and rotate destination instead, this is done - * because of a GC limitation. Rotate destination CW. - */ - dst_orientation = 360 - src1_orientation; - src1_orientation = 0; - } - - rgz_set_src_data(params, rgz_src1, &tmp_rect, e, src1_orientation, 0); - rgz_set_clip_rect(params, subregion_rect, e); - rgz_set_dst_data(params, &tmp_rect, e, dst_orientation); - - if((e->src1geom.format == OCDFMT_BGR124) || - (e->src1geom.format == OCDFMT_RGB124) || - (e->src1geom.format == OCDFMT_RGB16)) - e->dstgeom.format = OCDFMT_BGR124; - - return e; -} - -/* - * Blends two layers and write the result in the framebuffer, src1 must be the - * top most layer while src2 is the one behind. If src2 is NULL means src1 will - * be blended with the current content of the framebuffer. - */ -static struct rgz_blt_entry* rgz_hwc_subregion_blend(rgz_out_params_t *params, - blit_rect_t *subregion_rect, rgz_layer_t *rgz_src1, rgz_layer_t *rgz_src2) -{ - struct rgz_blt_entry* e = rgz_blts_get(&blts, params); - hwc_layer_1_t *hwc_src1 = &rgz_src1->hwc_layer; - e->bp.structsize = sizeof(struct bvbltparams); - e->bp.op.blend = BVBLEND_SRC1OVER; - e->bp.flags = BVFLAG_CLIP | BVFLAG_BLEND; - e->bp.flags |= rgz_get_flip_flags(hwc_src1->transform, 0); - rgz_set_async(e, 1); - - blit_rect_t tmp_rect; - if (rgz_hwc_scaled(hwc_src1)) { - rgz_get_displayframe_rect(hwc_src1, &tmp_rect); - rgz_cfg_scale_mode(e, hwc_src1); - } else - tmp_rect = *subregion_rect; - - int src1_orientation = rgz_get_orientation(hwc_src1->transform); - int dst_orientation = 0; - - if (rgz_is_layer_nv12(hwc_src1)) { - /* - * Leave NV12 as 0 degree and rotate destination instead, this is done - * because of a GC limitation. Rotate destination CW. - */ - dst_orientation = 360 - src1_orientation; - src1_orientation = 0; - } - - rgz_set_src_data(params, rgz_src1, &tmp_rect, e, src1_orientation, 0); - rgz_set_clip_rect(params, subregion_rect, e); - rgz_set_dst_data(params, &tmp_rect, e, dst_orientation); - - if (rgz_src2) { - /* - * NOTE: Due to an API limitation it's not possible to blend src1 and - * src2 if both have scaling, hence only src1 is used for now - */ - hwc_layer_1_t *hwc_src2 = &rgz_src2->hwc_layer; - if (rgz_hwc_scaled(hwc_src2)) - OUTE("src2 layer %p has scaling, this is not supported", hwc_src2); - /* - * We shouldn't receive a NV12 buffer as src2 at this point, this is an - * invalid parameter for the blend request - */ - if (rgz_is_layer_nv12(hwc_src2)) - OUTE("invalid input layer, src2 layer %p is NV12", hwc_src2); - e->bp.flags |= rgz_get_flip_flags(hwc_src2->transform, 1); - int src2_orientation = rgz_get_orientation(hwc_src2->transform); - rgz_set_src_data(params, rgz_src2, subregion_rect, e, src2_orientation, 1); - } else - rgz_set_src2_is_dst(params, e); - - return e; -} - -/* - * Clear the destination buffer, if rect is NULL means the whole screen, rect - * cannot be outside the boundaries of the screen - */ -static void rgz_out_clrdst(rgz_out_params_t *params, blit_rect_t *rect) -{ - struct rgz_blt_entry* e = rgz_blts_get(&blts, params); - e->bp.structsize = sizeof(struct bvbltparams); - e->bp.op.rop = 0xCCCC; /* SRCCOPY */ - e->bp.flags = BVFLAG_CLIP | BVFLAG_ROP; - rgz_set_async(e, 1); - - struct bvsurfgeom *screen_geom; - rgz_get_screen_info(params, &screen_geom); - - e->src1desc.structsize = sizeof(struct bvbuffdesc); - e->src1desc.length = 4; /* 1 pixel, 32bpp */ - /* - * With the HWC we don't bother having a buffer for the fill we'll get the - * OMAPLFB to fixup the src1desc and stride if the auxiliary pointer is -1 - */ - e->src1desc.auxptr = (void*)-1; - e->src1geom.structsize = sizeof(struct bvsurfgeom); - e->src1geom.format = OCDFMT_RGBA24; - e->bp.src1rect.left = e->bp.src1rect.top = e->src1geom.orientation = 0; - e->src1geom.height = e->src1geom.width = e->bp.src1rect.height = e->bp.src1rect.width = 1; - - blit_rect_t clear_rect; - if (rect) { - clear_rect.left = rect->left; - clear_rect.top = rect->top; - clear_rect.right = rect->right; - clear_rect.bottom = rect->bottom; - } else { - clear_rect.left = clear_rect.top = 0; - clear_rect.right = screen_geom->width; - clear_rect.bottom = screen_geom->height; - } - - rgz_set_clip_rect(params, &clear_rect, e); - rgz_set_dst_data(params, &clear_rect, e, 0); -} - -static int rgz_out_bvcmd_paint(rgz_t *rgz, rgz_out_params_t *params) -{ - int rv = 0; - int i, j; - params->data.bvc.out_blits = 0; - params->data.bvc.out_nhndls = 0; - rgz_blts_init(&blts); - rgz_out_clrdst(params, NULL); - - /* Begin from index 1 to remove the background layer from the output */ - rgz_fb_state_t *cur_fb_state = &rgz->cur_fb_state; - for (i = 1, j = 0; i < cur_fb_state->rgz_layerno; i++) { - rgz_layer_t *rgz_layer = &cur_fb_state->rgz_layers[i]; - hwc_layer_1_t *l = &rgz_layer->hwc_layer; - - //OUTP("blitting meminfo %d", rgz->rgz_layers[i].buffidx); - - /* - * See if it is needed to put transparent pixels where this layer - * is located in the screen - */ - if (rgz_layer->buffidx == -1) { - struct bvsurfgeom *scrgeom = params->data.bvc.dstgeom; - blit_rect_t srcregion; - srcregion.left = max(0, l->displayFrame.left); - srcregion.top = max(0, l->displayFrame.top); - srcregion.bottom = min(scrgeom->height, l->displayFrame.bottom); - srcregion.right = min(scrgeom->width, l->displayFrame.right); - rgz_out_clrdst(params, &srcregion); - continue; - } - - rv = rgz_hwc_layer_blit(params, rgz_layer); - if (rv) { - OUTE("bvcmd_paint: error in layer %d: %d", i, rv); - dump_all(cur_fb_state->rgz_layers, cur_fb_state->rgz_layerno, i); - rgz_blts_free(&blts); - return rv; - } - params->data.bvc.out_hndls[j++] = l->handle; - params->data.bvc.out_nhndls++; - } - - /* Last blit is made sync to act like a fence for the previous async blits */ - struct rgz_blt_entry* e = &blts.bvcmds[blts.idx-1]; - rgz_set_async(e, 0); - - /* FIXME: we want to be able to call rgz_blts_free and populate the actual - * composition data structure ourselves */ - params->data.bvc.cmdp = blts.bvcmds; - params->data.bvc.cmdlen = blts.idx; - - if (params->data.bvc.out_blits >= RGZ_MAX_BLITS) { - rv = -1; - // rgz_blts_free(&blts); // FIXME - } - return rv; -} - -static float getscalew(hwc_layer_1_t *layer) -{ - int w = WIDTH(layer->sourceCrop); - int h = HEIGHT(layer->sourceCrop); - - if (layer->transform & HWC_TRANSFORM_ROT_90) - swap(w, h); - - return ((float)WIDTH(layer->displayFrame)) / (float)w; -} - -static float getscaleh(hwc_layer_1_t *layer) -{ - int w = WIDTH(layer->sourceCrop); - int h = HEIGHT(layer->sourceCrop); - - if (layer->transform & HWC_TRANSFORM_ROT_90) - swap(w, h); - - return ((float)HEIGHT(layer->displayFrame)) / (float)h; -} - -/* - * Simple bubble sort on an array, ascending order - */ -static void rgz_bsort(int *a, int len) -{ - int i, j; - for (i = 0; i < len; i++) { - for (j = 0; j < i; j++) { - if (a[i] < a[j]) { - int temp = a[i]; - a[i] = a[j]; - a[j] = temp; - } - } - } -} - -/* - * Leave only unique numbers in a sorted array - */ -static int rgz_bunique(int *a, int len) -{ - int unique = 1; - int base = 0; - while (base + 1 < len) { - if (a[base] == a[base + 1]) { - int skip = 1; - while (base + skip < len && a[base] == a[base + skip]) - skip++; - if (base + skip == len) - break; - int i; - for (i = 0; i < skip - 1; i++) - a[base + 1 + i] = a[base + skip]; - } - unique++; - base++; - } - return unique; -} - -static void rgz_gen_blitregions(rgz_t *rgz, blit_hregion_t *hregion, int screen_width) -{ -/* - * 1. Get the offsets (left/right positions) of each layer within the - * hregion. Assume that layers describe the bounds of the hregion. - * 2. We should then be able to generate an array of rects - * 3. Each layer will have a different z-order, for each z-order - * find the intersection. Some intersections will be empty. - */ - - int offsets[RGZ_SUBREGIONMAX]; - int noffsets=0; - int l, r; - - /* - * Add damaged region, then all layers. We are guaranteed to not go outside - * of offsets array boundaries at this point. - */ - offsets[noffsets++] = rgz->damaged_area.left; - offsets[noffsets++] = rgz->damaged_area.right; - - for (l = 0; l < hregion->nlayers; l++) { - hwc_layer_1_t *layer = &hregion->rgz_layers[l]->hwc_layer; - /* Make sure the subregion is not outside the boundaries of the screen */ - offsets[noffsets++] = max(0, layer->displayFrame.left); - offsets[noffsets++] = min(layer->displayFrame.right, screen_width); - } - rgz_bsort(offsets, noffsets); - noffsets = rgz_bunique(offsets, noffsets); - hregion->nsubregions = noffsets - 1; - bzero(hregion->blitrects, sizeof(hregion->blitrects)); - for (r = 0; r + 1 < noffsets; r++) { - blit_rect_t subregion; - subregion.top = hregion->rect.top; - subregion.bottom = hregion->rect.bottom; - subregion.left = offsets[r]; - subregion.right = offsets[r+1]; - - ALOGD_IF(debug, " sub l %d r %d", - subregion.left, subregion.right); - for (l = 0; l < hregion->nlayers; l++) { - hwc_layer_1_t *layer = &hregion->rgz_layers[l]->hwc_layer; - if (RECT_INTERSECTS(subregion, layer->displayFrame)) { - - hregion->blitrects[l][r] = subregion; - - ALOGD_IF(debug, "hregion->blitrects[%d][%d] (%d %d %d %d)", l, r, - hregion->blitrects[l][r].left, - hregion->blitrects[l][r].top, - hregion->blitrects[l][r].right, - hregion->blitrects[l][r].bottom); - } - } - } -} - -static int rgz_hwc_scaled(hwc_layer_1_t *layer) -{ - int w = WIDTH(layer->sourceCrop); - int h = HEIGHT(layer->sourceCrop); - - if (layer->transform & HWC_TRANSFORM_ROT_90) - swap(w, h); - - return WIDTH(layer->displayFrame) != w || HEIGHT(layer->displayFrame) != h; -} - -static int rgz_in_valid_hwc_layer(hwc_layer_1_t *layer) -{ - IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle; - if ((layer->flags & HWC_SKIP_LAYER) || !handle) - return 0; - - if (is_NV12(handle->iFormat)) - return handle->iFormat == HAL_PIXEL_FORMAT_TI_NV12; - - /* FIXME: The following must be removed when GC supports vertical/horizontal - * buffer flips, please note having a FLIP_H and FLIP_V means 180 rotation - * which is supported indeed - */ - if (layer->transform) { - int is_flipped = !!(layer->transform & HWC_TRANSFORM_FLIP_H) ^ !!(layer->transform & HWC_TRANSFORM_FLIP_V); - if (is_flipped) { - ALOGE("Layer %p is flipped %d", layer, layer->transform); - return 0; - } - } - - switch(handle->iFormat) { - case HAL_PIXEL_FORMAT_BGRX_8888: - case HAL_PIXEL_FORMAT_RGBX_8888: - case HAL_PIXEL_FORMAT_RGB_565: - case HAL_PIXEL_FORMAT_RGBA_8888: - case HAL_PIXEL_FORMAT_BGRA_8888: - break; - default: - return 0; - } - return 1; -} - -/* Reset dirty region data and state */ -static void rgz_delete_region_data(rgz_t *rgz){ - if (!rgz) - return; - if (rgz->hregions) - free(rgz->hregions); - rgz->hregions = NULL; - rgz->nhregions = 0; - rgz->state &= ~RGZ_REGION_DATA; -} - -static rgz_fb_state_t* get_prev_fb_state(rgz_t *rgz) -{ - return &rgz->fb_states[rgz->fb_state_idx]; -} - -static rgz_fb_state_t* get_next_fb_state(rgz_t *rgz) -{ - rgz->fb_state_idx = (rgz->fb_state_idx + 1) % RGZ_NUM_FB; - return &rgz->fb_states[rgz->fb_state_idx]; -} - -static void rgz_add_to_damaged_area(rgz_in_params_t *params, rgz_layer_t *rgz_layer, - blit_rect_t *damaged_area) -{ - struct bvsurfgeom *screen_geom = params->data.hwc.dstgeom; - hwc_layer_1_t *layer = &rgz_layer->hwc_layer; - - blit_rect_t screen_rect; - screen_rect.left = screen_rect.top = 0; - screen_rect.right = screen_geom->width; - screen_rect.bottom = screen_geom->height; - - /* Ignore the layer rectangle if it doesn't intersect the screen */ - if (!RECT_INTERSECTS(screen_rect, layer->displayFrame)) - return; - - /* Clip the layer rectangle to the screen geometry */ - blit_rect_t layer_rect; - rgz_get_displayframe_rect(layer, &layer_rect); - layer_rect.left = max(0, layer_rect.left); - layer_rect.top = max(0, layer_rect.top); - layer_rect.right = min(screen_rect.right, layer_rect.right); - layer_rect.bottom = min(screen_rect.bottom, layer_rect.bottom); - - /* Then add the rectangle to the damage area */ - if (empty_rect(damaged_area)) { - /* Adding for the first time */ - damaged_area->left = layer_rect.left; - damaged_area->top = layer_rect.top; - damaged_area->right = layer_rect.right; - damaged_area->bottom = layer_rect.bottom; - } else { - /* Grow current damaged area */ - damaged_area->left = min(damaged_area->left, layer_rect.left); - damaged_area->top = min(damaged_area->top, layer_rect.top); - damaged_area->right = max(damaged_area->right, layer_rect.right); - damaged_area->bottom = max(damaged_area->bottom, layer_rect.bottom); - } -} - -/* Search a layer with the specified identity in the passed array */ -static rgz_layer_t* rgz_find_layer(rgz_layer_t *rgz_layers, int rgz_layerno, - uint32_t layer_identity) -{ - int i; - for (i = 0; i < rgz_layerno; i++) { - rgz_layer_t *rgz_layer = &rgz_layers[i]; - /* Ignore background layer, it has no identity */ - if (rgz_layer->buffidx == RGZ_BACKGROUND_BUFFIDX) - continue; - if (rgz_layer->identity == layer_identity) - return rgz_layer; - } - return NULL; -} - -/* Determines if two layers with the same identity have changed its own window content */ -static int rgz_has_layer_content_changed(rgz_layer_t *cur_rgz_layer, rgz_layer_t *prev_rgz_layer) -{ - hwc_layer_1_t *cur_hwc_layer = &cur_rgz_layer->hwc_layer; - hwc_layer_1_t *prev_hwc_layer = &prev_rgz_layer->hwc_layer; - - /* The background has no identity and never changes */ - if (cur_rgz_layer->buffidx == RGZ_BACKGROUND_BUFFIDX && - prev_rgz_layer->buffidx == RGZ_BACKGROUND_BUFFIDX) - return 0; - - if (cur_rgz_layer->identity != prev_rgz_layer->identity) { - OUTE("%s: Invalid input, layer identities differ (current=%d, prev=%d)", - __func__, cur_rgz_layer->identity, prev_rgz_layer->identity); - return 1; - } - - /* If the layer has the clear fb hint we don't care about the content */ - if (cur_rgz_layer->buffidx == RGZ_CLEARHINT_BUFFIDX && - prev_rgz_layer->buffidx == RGZ_CLEARHINT_BUFFIDX) - return 0; - - /* Check if the layer content has changed */ - if (cur_hwc_layer->handle != prev_hwc_layer->handle || - cur_hwc_layer->transform != prev_hwc_layer->transform || - cur_hwc_layer->sourceCrop.top != prev_hwc_layer->sourceCrop.top || - cur_hwc_layer->sourceCrop.left != prev_hwc_layer->sourceCrop.left || - cur_hwc_layer->sourceCrop.bottom != prev_hwc_layer->sourceCrop.bottom || - cur_hwc_layer->sourceCrop.right != prev_hwc_layer->sourceCrop.right) - return 1; - - return 0; -} - -/* Determines if two layers with the same identity have changed their screen position */ -static int rgz_has_layer_frame_moved(rgz_layer_t *cur_rgz_layer, rgz_layer_t *target_rgz_layer) -{ - hwc_layer_1_t *cur_hwc_layer = &cur_rgz_layer->hwc_layer; - hwc_layer_1_t *target_hwc_layer = &target_rgz_layer->hwc_layer; - - if (cur_rgz_layer->identity != target_rgz_layer->identity) { - OUTE("%s: Invalid input, layer identities differ (current=%d, target=%d)", - __func__, cur_rgz_layer->identity, target_rgz_layer->identity); - return 1; - } - - if (cur_hwc_layer->displayFrame.top != target_hwc_layer->displayFrame.top || - cur_hwc_layer->displayFrame.left != target_hwc_layer->displayFrame.left || - cur_hwc_layer->displayFrame.bottom != target_hwc_layer->displayFrame.bottom || - cur_hwc_layer->displayFrame.right != target_hwc_layer->displayFrame.right) - return 1; - - return 0; -} - -static void rgz_handle_dirty_region(rgz_t *rgz, rgz_in_params_t *params, - rgz_fb_state_t* prev_fb_state, rgz_fb_state_t* target_fb_state) -{ - /* Reset damaged area */ - bzero(&rgz->damaged_area, sizeof(rgz->damaged_area)); - - int i; - rgz_fb_state_t *cur_fb_state = &rgz->cur_fb_state; - - for (i = 0; i < cur_fb_state->rgz_layerno; i++) { - rgz_layer_t *cur_rgz_layer = &cur_fb_state->rgz_layers[i]; - rgz_layer_t *prev_rgz_layer = NULL; - int layer_changed = 0; - - if (i == 0) { - /* - * Background is always zero, no need to search for it. If the previous state - * is empty reset the dirty count for the background layer. - */ - if (prev_fb_state->rgz_layerno) - prev_rgz_layer = &prev_fb_state->rgz_layers[0]; - } else { - /* Find out if this layer was present in the previous frame */ - prev_rgz_layer = rgz_find_layer(prev_fb_state->rgz_layers, - prev_fb_state->rgz_layerno, cur_rgz_layer->identity); - } - - /* Check if the layer is new or if the content changed from the previous frame */ - if (prev_rgz_layer && !rgz_has_layer_content_changed(cur_rgz_layer, prev_rgz_layer)) { - /* Copy previous dirty count */ - cur_rgz_layer->dirty_count = prev_rgz_layer->dirty_count; - cur_rgz_layer->dirty_count -= cur_rgz_layer->dirty_count ? 1 : 0; - } else - cur_rgz_layer->dirty_count = RGZ_NUM_FB; - - /* If the layer is new, redraw the layer area */ - if (!prev_rgz_layer) { - rgz_add_to_damaged_area(params, cur_rgz_layer, &rgz->damaged_area); - continue; - } - - /* Nothing more to do with the background layer */ - if (i == 0) - continue; - - /* Find out if the layer is present in the target frame */ - rgz_layer_t *target_rgz_layer = rgz_find_layer(target_fb_state->rgz_layers, - target_fb_state->rgz_layerno, cur_rgz_layer->identity); - - if (target_rgz_layer) { - /* Find out if the window size and position are different from the target frame */ - if (rgz_has_layer_frame_moved(cur_rgz_layer, target_rgz_layer)) { - /* - * Redraw both layer areas. This will effectively clear the area where - * this layer was in the target frame and force to draw the new layer - * location. - */ - rgz_add_to_damaged_area(params, cur_rgz_layer, &rgz->damaged_area); - rgz_add_to_damaged_area(params, target_rgz_layer, &rgz->damaged_area); - cur_rgz_layer->dirty_count = RGZ_NUM_FB; - } - } else { - /* If the layer is not in the target just draw it's new location */ - rgz_add_to_damaged_area(params, cur_rgz_layer, &rgz->damaged_area); - } - } - - /* - * Add to damage area layers missing from the target frame to the current frame - * ignoring the background - */ - for (i = 1; i < target_fb_state->rgz_layerno; i++) { - rgz_layer_t *target_rgz_layer = &target_fb_state->rgz_layers[i]; - - rgz_layer_t *cur_rgz_layer = rgz_find_layer(cur_fb_state->rgz_layers, - cur_fb_state->rgz_layerno, target_rgz_layer->identity); - - /* Layers present in the target have been handled already in the loop above */ - if (cur_rgz_layer) - continue; - - /* The target layer is not present in the current frame, redraw its area */ - rgz_add_to_damaged_area(params, target_rgz_layer, &rgz->damaged_area); - } -} - -/* Adds the background layer in first the position of the passed fb state */ -static void rgz_add_background_layer(rgz_fb_state_t *fb_state) -{ - rgz_layer_t *rgz_layer = &fb_state->rgz_layers[0]; - rgz_layer->hwc_layer = bg_layer; - rgz_layer->buffidx = RGZ_BACKGROUND_BUFFIDX; - /* Set dummy handle to maintain dirty region state */ - rgz_layer->hwc_layer.handle = (void*) 0x1; -} - -static int rgz_in_hwccheck(rgz_in_params_t *p, rgz_t *rgz) -{ - hwc_layer_1_t *layers = p->data.hwc.layers; - hwc_layer_extended_t *extlayers = p->data.hwc.extlayers; - int layerno = p->data.hwc.layerno; - - rgz->state &= ~RGZ_STATE_INIT; - - if (!layers) - return -1; - - /* For debugging */ - //dump_all(layers, layerno, 0); - - /* - * Store buffer index to be sent in the HWC Post2 list. Any overlay - * meminfos must come first - */ - int l, memidx = 0; - for (l = 0; l < layerno; l++) { - if (layers[l].compositionType == HWC_OVERLAY) - memidx++; - } - - int possible_blit = 0, candidates = 0; - - /* - * Insert the background layer at the beginning of the list, maintain a - * state for dirty region handling - */ - rgz_fb_state_t *cur_fb_state = &rgz->cur_fb_state; - rgz_add_background_layer(cur_fb_state); - - for (l = 0; l < layerno; l++) { - if (layers[l].compositionType == HWC_FRAMEBUFFER) { - candidates++; - if (rgz_in_valid_hwc_layer(&layers[l]) && - possible_blit < RGZ_INPUT_MAXLAYERS) { - rgz_layer_t *rgz_layer = &cur_fb_state->rgz_layers[possible_blit+1]; - rgz_layer->hwc_layer = layers[l]; - rgz_layer->identity = extlayers[l].identity; - rgz_layer->buffidx = memidx++; - possible_blit++; - } - continue; - } - - if (layers[l].hints & HWC_HINT_CLEAR_FB) { - candidates++; - if (possible_blit < RGZ_INPUT_MAXLAYERS) { - /* - * Use only the layer rectangle as an input to regionize when the clear - * fb hint is present, mark this layer to identify it. - */ - rgz_layer_t *rgz_layer = &cur_fb_state->rgz_layers[possible_blit+1]; - rgz_layer->hwc_layer = layers[l]; - rgz_layer->identity = extlayers[l].identity; - rgz_layer->buffidx = RGZ_CLEARHINT_BUFFIDX; - /* Set dummy handle to maintain dirty region state */ - rgz_layer->hwc_layer.handle = (void*) 0x1; - possible_blit++; - } - } - } - - if (!possible_blit || possible_blit != candidates) { - return -1; - } - - rgz->state |= RGZ_STATE_INIT; - cur_fb_state->rgz_layerno = possible_blit + 1; /* Account for background layer */ - - /* Get the target and previous frame geometries */ - rgz_fb_state_t* prev_fb_state = get_prev_fb_state(rgz); - rgz_fb_state_t* target_fb_state = get_next_fb_state(rgz); - - /* Modifiy dirty counters and create the damaged region */ - rgz_handle_dirty_region(rgz, p, prev_fb_state, target_fb_state); - - /* Copy the current geometry to use it in the next frame */ - memcpy(target_fb_state->rgz_layers, cur_fb_state->rgz_layers, sizeof(rgz_layer_t) * cur_fb_state->rgz_layerno); - target_fb_state->rgz_layerno = cur_fb_state->rgz_layerno; - - return RGZ_ALL; -} - -static int rgz_in_hwc(rgz_in_params_t *p, rgz_t *rgz) -{ - int i, j; - int yentries[RGZ_SUBREGIONMAX]; - int dispw; /* widest layer */ - int screen_width = p->data.hwc.dstgeom->width; - int screen_height = p->data.hwc.dstgeom->height; - rgz_fb_state_t *cur_fb_state = &rgz->cur_fb_state; - - if (!(rgz->state & RGZ_STATE_INIT)) { - OUTE("rgz_process started with bad state"); - return -1; - } - - /* - * Figure out if there is enough space to store the top-bottom coordinates - * of each layer including the damaged area - */ - if (((cur_fb_state->rgz_layerno + 1) * 2) > RGZ_SUBREGIONMAX) { - OUTE("%s: Not enough space to store top-bottom coordinates of each layer (max %d, needed %d*2)", - __func__, RGZ_SUBREGIONMAX, cur_fb_state->rgz_layerno + 1); - return -1; - } - - /* Delete the previous region data */ - rgz_delete_region_data(rgz); - - /* - * Find the horizontal regions, add damaged area first which is already - * inside display boundaries - */ - int ylen = 0; - yentries[ylen++] = rgz->damaged_area.top; - yentries[ylen++] = rgz->damaged_area.bottom; - dispw = rgz->damaged_area.right; - - /* Add the top and bottom coordinates of each layer */ - for (i = 0; i < cur_fb_state->rgz_layerno; i++) { - hwc_layer_1_t *layer = &cur_fb_state->rgz_layers[i].hwc_layer; - /* Maintain regions inside display boundaries */ - yentries[ylen++] = max(0, layer->displayFrame.top); - yentries[ylen++] = min(layer->displayFrame.bottom, screen_height); - dispw = dispw > layer->displayFrame.right ? dispw : layer->displayFrame.right; - } - rgz_bsort(yentries, ylen); - ylen = rgz_bunique(yentries, ylen); - - /* at this point we have an array of horizontal regions */ - rgz->nhregions = ylen - 1; - - blit_hregion_t *hregions = calloc(rgz->nhregions, sizeof(blit_hregion_t)); - if (!hregions) { - OUTE("Unable to allocate memory for hregions"); - return -1; - } - rgz->hregions = hregions; - - ALOGD_IF(debug, "Allocated %d regions (sz = %d), layerno = %d", rgz->nhregions, - rgz->nhregions * sizeof(blit_hregion_t), cur_fb_state->rgz_layerno); - - for (i = 0; i < rgz->nhregions; i++) { - hregions[i].rect.top = yentries[i]; - hregions[i].rect.bottom = yentries[i+1]; - /* Avoid hregions outside the display boundaries */ - hregions[i].rect.left = 0; - hregions[i].rect.right = dispw > screen_width ? screen_width : dispw; - hregions[i].nlayers = 0; - for (j = 0; j < cur_fb_state->rgz_layerno; j++) { - hwc_layer_1_t *layer = &cur_fb_state->rgz_layers[j].hwc_layer; - if (RECT_INTERSECTS(hregions[i].rect, layer->displayFrame)) { - int l = hregions[i].nlayers++; - hregions[i].rgz_layers[l] = &cur_fb_state->rgz_layers[j]; - } - } - } - - /* Calculate blit regions */ - for (i = 0; i < rgz->nhregions; i++) { - rgz_gen_blitregions(rgz, &hregions[i], screen_width); - ALOGD_IF(debug, "hregion %3d: nsubregions %d", i, hregions[i].nsubregions); - ALOGD_IF(debug, " : %d to %d: ", - hregions[i].rect.top, hregions[i].rect.bottom); - for (j = 0; j < hregions[i].nlayers; j++) - ALOGD_IF(debug, " %p ", &hregions[i].rgz_layers[j]->hwc_layer); - } - rgz->state |= RGZ_REGION_DATA; - return 0; -} - -/* - * generate a human readable description of the layer - * - * idx, flags, fmt, type, sleft, stop, sright, sbot, dleft, dtop, \ - * dright, dbot, rot, flip, blending, scalew, scaleh, visrects - * - */ -static void rgz_print_layer(hwc_layer_1_t *l, int idx, int csv) -{ - char big_log[1024]; - int e = sizeof(big_log); - char *end = big_log + e; - e -= snprintf(end - e, e, "<!-- LAYER-DAT: %d", idx); - - - e -= snprintf(end - e, e, "%s %p", csv ? "," : " hndl:", - l->handle ? l->handle : NULL); - - e -= snprintf(end - e, e, "%s %s", csv ? "," : " flags:", - l->flags & HWC_SKIP_LAYER ? "skip" : "none"); - - IMG_native_handle_t *handle = (IMG_native_handle_t *)l->handle; - if (handle) { - e -= snprintf(end - e, e, "%s", csv ? ", " : " fmt: "); - switch(handle->iFormat) { - case HAL_PIXEL_FORMAT_BGRA_8888: - e -= snprintf(end - e, e, "bgra"); break; - case HAL_PIXEL_FORMAT_RGB_565: - e -= snprintf(end - e, e, "rgb565"); break; - case HAL_PIXEL_FORMAT_BGRX_8888: - e -= snprintf(end - e, e, "bgrx"); break; - case HAL_PIXEL_FORMAT_RGBX_8888: - e -= snprintf(end - e, e, "rgbx"); break; - case HAL_PIXEL_FORMAT_RGBA_8888: - e -= snprintf(end - e, e, "rgba"); break; - case HAL_PIXEL_FORMAT_TI_NV12: - case HAL_PIXEL_FORMAT_TI_NV12_PADDED: - e -= snprintf(end - e, e, "nv12"); break; - default: - e -= snprintf(end - e, e, "unknown"); - } - e -= snprintf(end - e, e, "%s", csv ? ", " : " type: "); - if (handle->usage & GRALLOC_USAGE_HW_RENDER) - e -= snprintf(end - e, e, "hw"); - else if (handle->usage & GRALLOC_USAGE_SW_READ_MASK || - handle->usage & GRALLOC_USAGE_SW_WRITE_MASK) - e -= snprintf(end - e, e, "sw"); - else - e -= snprintf(end - e, e, "unknown"); - } else { - e -= snprintf(end - e, e, csv ? ", unknown" : " fmt: unknown"); - e -= snprintf(end - e, e, csv ? ", na" : " type: na"); - } - e -= snprintf(end - e, e, csv ? ", %d, %d, %d, %d" : " src: %d %d %d %d", - l->sourceCrop.left, l->sourceCrop.top, l->sourceCrop.right, - l->sourceCrop.bottom); - e -= snprintf(end - e, e, csv ? ", %d, %d, %d, %d" : " disp: %d %d %d %d", - l->displayFrame.left, l->displayFrame.top, - l->displayFrame.right, l->displayFrame.bottom); - - e -= snprintf(end - e, e, "%s %s", csv ? "," : " rot:", - l->transform & HWC_TRANSFORM_ROT_90 ? "90" : - l->transform & HWC_TRANSFORM_ROT_180 ? "180" : - l->transform & HWC_TRANSFORM_ROT_270 ? "270" : "none"); - - char flip[5] = ""; - strcat(flip, l->transform & HWC_TRANSFORM_FLIP_H ? "H" : ""); - strcat(flip, l->transform & HWC_TRANSFORM_FLIP_V ? "V" : ""); - if (!(l->transform & (HWC_TRANSFORM_FLIP_V|HWC_TRANSFORM_FLIP_H))) - strcpy(flip, "none"); - e -= snprintf(end - e, e, "%s %s", csv ? "," : " flip:", flip); - - e -= snprintf(end - e, e, "%s %s", csv ? "," : " blending:", - l->blending == HWC_BLENDING_NONE ? "none" : - l->blending == HWC_BLENDING_PREMULT ? "premult" : - l->blending == HWC_BLENDING_COVERAGE ? "coverage" : "invalid"); - - e -= snprintf(end - e, e, "%s %1.3f", csv ? "," : " scalew:", getscalew(l)); - e -= snprintf(end - e, e, "%s %1.3f", csv ? "," : " scaleh:", getscaleh(l)); - - e -= snprintf(end - e, e, "%s %d", csv ? "," : " visrect:", - l->visibleRegionScreen.numRects); - - if (!csv) { - e -= snprintf(end - e, e, " -->"); - OUTP("%s", big_log); - - size_t i = 0; - for (; i < l->visibleRegionScreen.numRects; i++) { - hwc_rect_t const *r = &l->visibleRegionScreen.rects[i]; - OUTP("<!-- LAYER-VIS: %d: rect: %d %d %d %d -->", - i, r->left, r->top, r->right, r->bottom); - } - } else { - size_t i = 0; - for (; i < l->visibleRegionScreen.numRects; i++) { - hwc_rect_t const *r = &l->visibleRegionScreen.rects[i]; - e -= snprintf(end - e, e, ", %d, %d, %d, %d", - r->left, r->top, r->right, r->bottom); - } - e -= snprintf(end - e, e, " -->"); - OUTP("%s", big_log); - } -} - -static void rgz_print_layers(hwc_display_contents_1_t* list, int csv) -{ - size_t i; - for (i = 0; i < list->numHwLayers; i++) { - hwc_layer_1_t *l = &list->hwLayers[i]; - rgz_print_layer(l, i, csv); - } -} - -static int hal_to_ocd(int color) -{ - switch(color) { - case HAL_PIXEL_FORMAT_BGRA_8888: - return OCDFMT_BGRA24; - case HAL_PIXEL_FORMAT_BGRX_8888: - return OCDFMT_BGR124; - case HAL_PIXEL_FORMAT_RGB_565: - return OCDFMT_RGB16; - case HAL_PIXEL_FORMAT_RGBA_8888: - return OCDFMT_RGBA24; - case HAL_PIXEL_FORMAT_RGBX_8888: - return OCDFMT_RGB124; - case HAL_PIXEL_FORMAT_TI_NV12: - return OCDFMT_NV12; - case HAL_PIXEL_FORMAT_YV12: - return OCDFMT_YV12; - default: - return OCDFMT_UNKNOWN; - } -} - -static BVFN_MAP bv_map; -static BVFN_BLT bv_blt; -static BVFN_UNMAP bv_unmap; - -static int rgz_handle_to_stride(IMG_native_handle_t *h) -{ - int bpp = is_NV12(h->iFormat) ? 0 : (h->iFormat == HAL_PIXEL_FORMAT_RGB_565 ? 2 : 4); - int stride = ALIGN(h->iWidth, HW_ALIGN) * bpp; - return stride; -} - -static int rgz_get_orientation(unsigned int transform) -{ - int orientation = 0; - if ((transform & HWC_TRANSFORM_FLIP_H) && (transform & HWC_TRANSFORM_FLIP_V)) - orientation += 180; - if (transform & HWC_TRANSFORM_ROT_90) - orientation += 90; - - return orientation; -} - -static int rgz_get_flip_flags(unsigned int transform, int use_src2_flags) -{ - /* - * If vertical and horizontal flip flags are set it means a 180 rotation - * (with no flip) is intended for the layer, so we return 0 in that case. - */ - int flip_flags = 0; - if (transform & HWC_TRANSFORM_FLIP_H) - flip_flags |= (use_src2_flags ? BVFLAG_HORZ_FLIP_SRC2 : BVFLAG_HORZ_FLIP_SRC1); - if (transform & HWC_TRANSFORM_FLIP_V) - flip_flags = flip_flags ? 0 : flip_flags | (use_src2_flags ? BVFLAG_VERT_FLIP_SRC2 : BVFLAG_VERT_FLIP_SRC1); - return flip_flags; -} - -static int rgz_hwc_layer_blit(rgz_out_params_t *params, rgz_layer_t *rgz_layer) -{ - hwc_layer_1_t* layer = &rgz_layer->hwc_layer; - blit_rect_t srcregion; - rgz_get_displayframe_rect(layer, &srcregion); - - int noblend = rgz_is_blending_disabled(params); - if (!noblend && layer->blending == HWC_BLENDING_PREMULT) - rgz_hwc_subregion_blend(params, &srcregion, rgz_layer, NULL); - else - rgz_hwc_subregion_copy(params, &srcregion, rgz_layer); - - return 0; -} - -static int rgz_can_blend_together(hwc_layer_1_t* src1_layer, hwc_layer_1_t* src2_layer) -{ - /* If any layer is scaled we cannot blend both layers in one blit */ - if (rgz_hwc_scaled(src1_layer) || rgz_hwc_scaled(src2_layer)) - return 0; - - /* NV12 buffers don't have alpha information on it */ - IMG_native_handle_t *src1_hndl = (IMG_native_handle_t *)src1_layer->handle; - IMG_native_handle_t *src2_hndl = (IMG_native_handle_t *)src2_layer->handle; - if (is_NV12(src1_hndl->iFormat) || is_NV12(src2_hndl->iFormat)) - return 0; - - return 1; -} - -static void rgz_batch_entry(struct rgz_blt_entry* e, unsigned int flag, unsigned int set) -{ - e->bp.flags &= ~BVFLAG_BATCH_MASK; - e->bp.flags |= flag; - e->bp.batchflags |= set; -} - -static int rgz_hwc_subregion_blit(blit_hregion_t *hregion, int sidx, rgz_out_params_t *params, - blit_rect_t *damaged_area) -{ - int lix; - int ldepth = get_layer_ops(hregion, sidx, &lix); - if (ldepth == 0) { - /* Impossible, there are no layers in this region even if the - * background is covering the whole screen - */ - OUTE("hregion %p subregion %d doesn't have any ops", hregion, sidx); - return -1; - } - - /* Determine if this region is dirty */ - int dirty = 0; - blit_rect_t *subregion_rect = &hregion->blitrects[lix][sidx]; - if (RECT_INTERSECTS(*damaged_area, *subregion_rect)) { - /* The subregion intersects the damaged area, draw unconditionally */ - dirty = 1; - } else { - int dirtylix = lix; - while (dirtylix != -1) { - rgz_layer_t *rgz_layer = hregion->rgz_layers[dirtylix]; - if (rgz_layer->dirty_count){ - /* One of the layers is dirty, we need to generate blits for this subregion */ - dirty = 1; - break; - } - dirtylix = get_layer_ops_next(hregion, sidx, dirtylix); - } - } - if (!dirty) - return 0; - - /* Check if the bottom layer is the background */ - if (hregion->rgz_layers[lix]->buffidx == RGZ_BACKGROUND_BUFFIDX) { - if (ldepth == 1) { - /* Background layer is the only operation, clear subregion */ - rgz_out_clrdst(params, &hregion->blitrects[lix][sidx]); - return 0; - } else { - /* No need to generate blits with background layer if there is - * another layer on top of it, discard it - */ - ldepth--; - lix = get_layer_ops_next(hregion, sidx, lix); - } - } - - /* - * See if the depth most layer needs to be ignored. If this layer is the - * only operation, we need to clear this subregion. - */ - if (hregion->rgz_layers[lix]->buffidx == RGZ_CLEARHINT_BUFFIDX) { - ldepth--; - if (!ldepth) { - rgz_out_clrdst(params, &hregion->blitrects[lix][sidx]); - return 0; - } - lix = get_layer_ops_next(hregion, sidx, lix); - } - - int noblend = rgz_is_blending_disabled(params); - - if (!noblend && ldepth > 1) { /* BLEND */ - blit_rect_t *rect = &hregion->blitrects[lix][sidx]; - struct rgz_blt_entry* e; - - int s2lix = lix; - lix = get_layer_ops_next(hregion, sidx, lix); - - /* - * We save a read and a write from the FB if we blend the bottom - * two layers, we can do this only if both layers are not scaled - */ - int prev_layer_scaled = 0; - int prev_layer_nv12 = 0; - int first_batchflags = 0; - rgz_layer_t *rgz_src1 = hregion->rgz_layers[lix]; - rgz_layer_t *rgz_src2 = hregion->rgz_layers[s2lix]; - if (rgz_can_blend_together(&rgz_src1->hwc_layer, &rgz_src2->hwc_layer)) - e = rgz_hwc_subregion_blend(params, rect, rgz_src1, rgz_src2); - else { - /* Return index to the first operation and make a copy of the first layer */ - lix = s2lix; - rgz_src1 = hregion->rgz_layers[lix]; - e = rgz_hwc_subregion_copy(params, rect, rgz_src1); - /* - * First blit is a copy, the rest will be blends, hence the operation - * changed on the second blit. - */ - first_batchflags |= BVBATCH_OP; - prev_layer_nv12 = rgz_is_layer_nv12(&rgz_src1->hwc_layer); - prev_layer_scaled = rgz_hwc_scaled(&rgz_src1->hwc_layer); - } - - /* - * Regardless if the first blit is a copy or blend, src2 may have changed - * on the second blit - */ - first_batchflags |= BVBATCH_SRC2 | BVBATCH_SRC2RECT_ORIGIN | BVBATCH_SRC2RECT_SIZE; - - rgz_batch_entry(e, BVFLAG_BATCH_BEGIN, 0); - - /* Rest of layers blended with FB */ - while((lix = get_layer_ops_next(hregion, sidx, lix)) != -1) { - int batchflags = first_batchflags; - first_batchflags = 0; - rgz_src1 = hregion->rgz_layers[lix]; - - /* Blend src1 into dst */ - e = rgz_hwc_subregion_blend(params, rect, rgz_src1, NULL); - - /* - * NOTE: After the first blit is configured, consequent blits are - * blend operations done with src1 and the destination, that is, - * src2 is the same as dst, any batchflag changed for the destination - * applies to src2 as well. - */ - - /* src1 parameters always change on every blit */ - batchflags |= BVBATCH_SRC1 | BVBATCH_SRC1RECT_ORIGIN| BVBATCH_SRC1RECT_SIZE; - - /* - * If the current/previous layer has scaling, destination rectangles - * likely changed as well as the scaling mode. Clipping rectangle - * remains the same as well as destination geometry. - */ - int cur_layer_scaled = rgz_hwc_scaled(&rgz_src1->hwc_layer); - if (cur_layer_scaled || prev_layer_scaled) { - batchflags |= BVBATCH_DSTRECT_ORIGIN | BVBATCH_DSTRECT_SIZE | - BVBATCH_SRC2RECT_ORIGIN | BVBATCH_SRC2RECT_SIZE | - BVBATCH_SCALE; - } - prev_layer_scaled = cur_layer_scaled; - - /* - * If the current/previous layer is NV12, the destination geometry - * could have been rotated, hence the destination and clipping - * rectangles might have been trasformed to match the rotated - * destination geometry. - */ - int cur_layer_nv12 = rgz_is_layer_nv12(&rgz_src1->hwc_layer); - if (cur_layer_nv12 || prev_layer_nv12) { - batchflags |= BVBATCH_DST | BVBATCH_DSTRECT_ORIGIN | BVBATCH_DSTRECT_SIZE | - BVBATCH_SRC2 | BVBATCH_SRC2RECT_ORIGIN | BVBATCH_SRC2RECT_SIZE | - BVBATCH_CLIPRECT; - } - prev_layer_nv12 = cur_layer_nv12; - - rgz_batch_entry(e, BVFLAG_BATCH_CONTINUE, batchflags); - } - - if (e->bp.flags & BVFLAG_BATCH_BEGIN) - rgz_batch_entry(e, 0, 0); - else - rgz_batch_entry(e, BVFLAG_BATCH_END, 0); - - } else { /* COPY */ - blit_rect_t *rect = &hregion->blitrects[lix][sidx]; - if (noblend) /* get_layer_ops() doesn't understand this so get the top */ - lix = get_top_rect(hregion, sidx, &rect); - rgz_hwc_subregion_copy(params, rect, hregion->rgz_layers[lix]); - } - return 0; -} - -struct bvbuffdesc gscrndesc = { - .structsize = sizeof(struct bvbuffdesc), .length = 0, - .auxptr = MAP_FAILED -}; -struct bvsurfgeom gscrngeom = { - .structsize = sizeof(struct bvsurfgeom), .format = OCDFMT_UNKNOWN -}; - -static void rgz_blts_init(struct rgz_blts *blts) -{ - bzero(blts, sizeof(*blts)); -} - -static void rgz_blts_free(struct rgz_blts *blts) -{ - /* TODO ??? maybe we should dynamically allocate this */ - rgz_blts_init(blts); -} - -static struct rgz_blt_entry* rgz_blts_get(struct rgz_blts *blts, rgz_out_params_t *params) -{ - struct rgz_blt_entry *ne; - if (blts->idx < RGZ_MAX_BLITS) { - ne = &blts->bvcmds[blts->idx++]; - if (IS_BVCMD(params)) - params->data.bvc.out_blits++; - } else { - OUTE("!!! BIG PROBLEM !!! run out of blit entries"); - ne = &blts->bvcmds[blts->idx - 1]; /* Return last slot */ - } - return ne; -} - -static int rgz_blts_bvdirect(rgz_t *rgz, struct rgz_blts *blts, rgz_out_params_t *params) -{ - struct bvbatch *batch = NULL; - int rv = -1; - int idx = 0; - - while (idx < blts->idx) { - struct rgz_blt_entry *e = &blts->bvcmds[idx]; - if (e->bp.flags & BVFLAG_BATCH_MASK) - e->bp.batch = batch; - rv = bv_blt(&e->bp); - if (rv) { - OUTE("BV_BLT failed: %d", rv); - BVDUMP("bv_blt:", " ", &e->bp); - return -1; - } - if (e->bp.flags & BVFLAG_BATCH_BEGIN) - batch = e->bp.batch; - idx++; - } - return rv; -} - -static int rgz_out_region(rgz_t *rgz, rgz_out_params_t *params) -{ - if (!(rgz->state & RGZ_REGION_DATA)) { - OUTE("rgz_out_region invoked with bad state"); - return -1; - } - - rgz_blts_init(&blts); - ALOGD_IF(debug, "rgz_out_region:"); - - if (IS_BVCMD(params)) - params->data.bvc.out_blits = 0; - - int i; - for (i = 0; i < rgz->nhregions; i++) { - blit_hregion_t *hregion = &rgz->hregions[i]; - int s; - ALOGD_IF(debug, "h[%d] nsubregions = %d", i, hregion->nsubregions); - if (hregion->nlayers == 0) { - /* Impossible, there are no layers in this region even if the - * background is covering the whole screen - */ - OUTE("hregion %p doesn't have any ops", hregion); - return -1; - } - for (s = 0; s < hregion->nsubregions; s++) { - ALOGD_IF(debug, "h[%d] -> [%d]", i, s); - if (rgz_hwc_subregion_blit(hregion, s, params, &rgz->damaged_area)) - return -1; - } - } - - int rv = 0; - - if (IS_BVCMD(params)) { - int j; - params->data.bvc.out_nhndls = 0; - rgz_fb_state_t *cur_fb_state = &rgz->cur_fb_state; - /* Begin from index 1 to remove the background layer from the output */ - for (j = 1, i = 0; j < cur_fb_state->rgz_layerno; j++) { - rgz_layer_t *rgz_layer = &cur_fb_state->rgz_layers[j]; - /* We don't need the handles for layers marked as -1 */ - if (rgz_layer->buffidx == -1) - continue; - params->data.bvc.out_hndls[i++] = rgz_layer->hwc_layer.handle; - params->data.bvc.out_nhndls++; - } - - if (blts.idx > 0) { - /* Last blit is made sync to act like a fence for the previous async blits */ - struct rgz_blt_entry* e = &blts.bvcmds[blts.idx-1]; - rgz_set_async(e, 0); - } - - /* FIXME: we want to be able to call rgz_blts_free and populate the actual - * composition data structure ourselves */ - params->data.bvc.cmdp = blts.bvcmds; - params->data.bvc.cmdlen = blts.idx; - if (params->data.bvc.out_blits >= RGZ_MAX_BLITS) - rv = -1; - //rgz_blts_free(&blts); - } else { - rv = rgz_blts_bvdirect(rgz, &blts, params); - rgz_blts_free(&blts); - } - - return rv; -} - -void rgz_profile_hwc(hwc_display_contents_1_t* list, int dispw, int disph) -{ - if (!list) /* A NULL composition list can occur */ - return; - - static char regiondump2[PROPERTY_VALUE_MAX] = ""; - char regiondump[PROPERTY_VALUE_MAX]; - property_get("debug.2dhwc.region", regiondump, "0"); - int dumpregions = strncmp(regiondump, regiondump2, PROPERTY_VALUE_MAX); - if (dumpregions) - strncpy(regiondump2, regiondump, PROPERTY_VALUE_MAX); - else { - dumpregions = !strncmp(regiondump, "all", PROPERTY_VALUE_MAX) && - (list->flags & HWC_GEOMETRY_CHANGED); - static int iteration = 0; - if (dumpregions) - sprintf(regiondump, "iteration %d", iteration++); - } - - char dumplayerdata[PROPERTY_VALUE_MAX]; - /* 0 - off, 1 - human readable, 2 - CSV */ - property_get("debug.2dhwc.dumplayers", dumplayerdata, "0"); - int dumplayers = atoi(dumplayerdata); - if (dumplayers && (list->flags & HWC_GEOMETRY_CHANGED)) { - OUTP("<!-- BEGUN-LAYER-DUMP: %d -->", list->numHwLayers); - rgz_print_layers(list, dumplayers == 1 ? 0 : 1); - OUTP("<!-- ENDED-LAYER-DUMP -->"); - } - - if(!dumpregions) - return; - - rgz_t rgz; - rgz_in_params_t ip = { .data = { .hwc = { - .layers = list->hwLayers, - .layerno = list->numHwLayers } } }; - ip.op = RGZ_IN_HWCCHK; - if (rgz_in(&ip, &rgz) == RGZ_ALL) { - ip.op = RGZ_IN_HWC; - if (rgz_in(&ip, &rgz) == RGZ_ALL) { - OUTP("<!-- BEGUN-SVG-DUMP: %s -->", regiondump); - OUTP("<b>%s</b>", regiondump); - rgz_out_params_t op = { - .op = RGZ_OUT_SVG, - .data = { - .svg = { - .dispw = dispw, .disph = disph, - .htmlw = 450, .htmlh = 800 - } - }, - }; - rgz_out(&rgz, &op); - OUTP("<!-- ENDED-SVG-DUMP -->"); - } - } - rgz_release(&rgz); -} - -int rgz_get_screengeometry(int fd, struct bvsurfgeom *geom, int fmt) -{ - /* Populate Bltsville destination buffer information with framebuffer data */ - struct fb_fix_screeninfo fb_fixinfo; - struct fb_var_screeninfo fb_varinfo; - - ALOGI("Attempting to get framebuffer device info."); - if(ioctl(fd, FBIOGET_FSCREENINFO, &fb_fixinfo)) { - OUTE("Error getting fb_fixinfo"); - return -EINVAL; - } - - if(ioctl(fd, FBIOGET_VSCREENINFO, &fb_varinfo)) { - ALOGE("Error gettting fb_varinfo"); - return -EINVAL; - } - - bzero(&bg_layer, sizeof(bg_layer)); - bg_layer.displayFrame.left = bg_layer.displayFrame.top = 0; - bg_layer.displayFrame.right = fb_varinfo.xres; - bg_layer.displayFrame.bottom = fb_varinfo.yres; - - bzero(geom, sizeof(*geom)); - geom->structsize = sizeof(*geom); - geom->width = fb_varinfo.xres; - geom->height = fb_varinfo.yres; - geom->virtstride = fb_fixinfo.line_length; - geom->format = hal_to_ocd(fmt); - geom->orientation = 0; - return 0; -} - -int rgz_in(rgz_in_params_t *p, rgz_t *rgz) -{ - int rv = -1; - switch (p->op) { - case RGZ_IN_HWC: - rv = rgz_in_hwccheck(p, rgz); - if (rv == RGZ_ALL) - rv = rgz_in_hwc(p, rgz) ? 0 : RGZ_ALL; - break; - case RGZ_IN_HWCCHK: - bzero(rgz, sizeof(rgz_t)); - rv = rgz_in_hwccheck(p, rgz); - break; - default: - return -1; - } - return rv; -} - -void rgz_release(rgz_t *rgz) -{ - if (!rgz) - return; - if (rgz->hregions) - free(rgz->hregions); - bzero(rgz, sizeof(*rgz)); -} - -int rgz_out(rgz_t *rgz, rgz_out_params_t *params) -{ - switch (params->op) { - case RGZ_OUT_SVG: - rgz_out_svg(rgz, params); - return 0; - case RGZ_OUT_BVDIRECT_PAINT: - return rgz_out_bvdirect_paint(rgz, params); - case RGZ_OUT_BVCMD_PAINT: - return rgz_out_bvcmd_paint(rgz, params); - case RGZ_OUT_BVDIRECT_REGION: - case RGZ_OUT_BVCMD_REGION: - return rgz_out_region(rgz, params); - default: - return -1; - } -} - |