diff options
author | Daniel Levin <dendy@ti.com> | 2012-11-28 21:19:11 +0200 |
---|---|---|
committer | Daniel Levin <dendy@ti.com> | 2012-12-04 15:41:23 +0200 |
commit | b5434c2ebc47f25246b211f0a86bab1faf097cb2 (patch) | |
tree | 1374716354c9eaccc9db8145aa37e374fff79716 /hwc | |
parent | cf614ea4fd9ebc303d6314016d7e226fa7cd1966 (diff) | |
parent | f5142f536846e9a26182af7c0b2b0578fb72dc10 (diff) | |
download | hardware_ti_omap4-b5434c2ebc47f25246b211f0a86bab1faf097cb2.zip hardware_ti_omap4-b5434c2ebc47f25246b211f0a86bab1faf097cb2.tar.gz hardware_ti_omap4-b5434c2ebc47f25246b211f0a86bab1faf097cb2.tar.bz2 |
Merge branch 'p-jb-mr0-release-hwc' into d-jb-mr1-release
Conflicts:
hwc/hwc.c
Change-Id: Ice74d3e62a2d6ccadb2d4333f0acc39d6366e0e7
Signed-off-by: Daniel Levin <dendy@ti.com>
Diffstat (limited to 'hwc')
-rw-r--r-- | hwc/Android.mk | 11 | ||||
-rw-r--r-- | hwc/hal_public.h | 21 | ||||
-rw-r--r-- | hwc/hwc.c | 1054 | ||||
-rw-r--r-- | hwc/rgz_2d.c | 1676 | ||||
-rw-r--r-- | hwc/rgz_2d.h | 290 |
5 files changed, 2921 insertions, 131 deletions
diff --git a/hwc/Android.mk b/hwc/Android.mk index c6a2eae..60b421d 100644 --- a/hwc/Android.mk +++ b/hwc/Android.mk @@ -1,4 +1,3 @@ -# HWC under heavy development and should not be included in builds for now LOCAL_PATH := $(call my-dir) # HAL module implementation, not prelinked and stored in @@ -7,8 +6,9 @@ include $(CLEAR_VARS) LOCAL_PRELINK_MODULE := false LOCAL_ARM_MODE := arm LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/../vendor/lib/hw -LOCAL_SHARED_LIBRARIES := liblog libEGL libcutils libutils libhardware libhardware_legacy libz -LOCAL_SRC_FILES := hwc.c +LOCAL_SHARED_LIBRARIES := liblog libEGL libcutils libutils libhardware libhardware_legacy libz \ + libion +LOCAL_SRC_FILES := hwc.c rgz_2d.c LOCAL_STATIC_LIBRARIES := libpng LOCAL_MODULE_TAGS := optional @@ -16,6 +16,11 @@ LOCAL_MODULE_TAGS := optional LOCAL_MODULE := hwcomposer.omap4 LOCAL_CFLAGS := -DLOG_TAG=\"ti_hwc\" LOCAL_C_INCLUDES += external/libpng external/zlib + +LOCAL_C_INCLUDES += \ + $(LOCAL_PATH)/../edid/inc +LOCAL_SHARED_LIBRARIES += libedid + # LOG_NDEBUG=0 means verbose logging enabled # LOCAL_CFLAGS += -DLOG_NDEBUG=0 include $(BUILD_SHARED_LIBRARY) diff --git a/hwc/hal_public.h b/hwc/hal_public.h index 3d64c4c..a7dfb08 100644 --- a/hwc/hal_public.h +++ b/hwc/hal_public.h @@ -164,4 +164,25 @@ typedef struct IMG_buffer_format_public_t } IMG_buffer_format_public_t; +/* + * These are vendor specific pixel formats, by (informal) convention IMGTec + * formats start from the top of the range, TI formats start from the bottom + */ +#define HAL_PIXEL_FORMAT_BGRX_8888 0x1FF +#define HAL_PIXEL_FORMAT_TI_NV12 0x100 +#define HAL_PIXEL_FORMAT_TI_UNUSED 0x101 /* Free for use */ +#define HAL_PIXEL_FORMAT_TI_NV12_1D 0x102 + +#ifndef GRALLOC_USAGE_SYSTEM_HEAP +#define GRALLOC_USAGE_SYSTEM_HEAP GRALLOC_USAGE_PRIVATE_0 +#else +#error GRALLOC_USAGE_SYSTEM_HEAP should only be defined by hal_public.h +#endif + +#ifndef GRALLOC_USAGE_PHYS_CONTIG +#define GRALLOC_USAGE_PHYS_CONTIG GRALLOC_USAGE_PRIVATE_1 +#else +#error GRALLOC_USAGE_PHYS_CONTIG should only be defined by hal_public.h +#endif #endif /* HAL_PUBLIC_H */ + @@ -25,6 +25,7 @@ #include <linux/omapfb.h> #include <sys/mman.h> #include <sys/resource.h> +#include <stdbool.h> #include <cutils/properties.h> #include <cutils/log.h> @@ -35,8 +36,15 @@ #include <EGL/egl.h> #include <hardware_legacy/uevent.h> #include <png.h> +#include <utils/Timers.h> #include <system/graphics.h> +#include <ui/S3DFormat.h> +#include <edid_parser.h> + +#include <linux/bltsville.h> + +#define MAX_HWC_LAYERS 32 #define ASPECT_RATIO_TOLERANCE 0.02f @@ -50,15 +58,18 @@ #define DIV_ROUND_UP(a, b) (((a) + (b) - 1) / (b)) #include <video/dsscomp.h> +#include <video/omap_hwc.h> #include "hal_public.h" +#include "rgz_2d.h" + +#include <linux/ion.h> +#include <linux/omap_ion.h> +#include <ion/ion.h> #define MAX_HW_OVERLAYS 4 #define NUM_NONSCALING_OVERLAYS 1 -#define HAL_PIXEL_FORMAT_BGRX_8888 0x1FF -#define HAL_PIXEL_FORMAT_TI_NV12 0x100 -#define HAL_PIXEL_FORMAT_TI_NV12_PADDED 0x101 -#define MAX_TILER_SLOT (16 << 20) +#define NUM_EXT_DISPLAY_BACK_BUFFERS 2 struct ext_transform_t { __u8 rotation : 3; /* 90-degree clockwise rotations */ @@ -94,6 +105,11 @@ struct omap4_hwc_ext { __u32 yres; float m[2][3]; /* external transformation matrix */ hwc_rect_t mirror_region; /* region of screen to mirror */ + + bool s3d_enabled; + bool s3d_capable; + enum S3DLayoutType s3d_type; + enum S3DLayoutOrder s3d_order; }; typedef struct omap4_hwc_ext omap4_hwc_ext_t; @@ -103,6 +119,17 @@ enum { EXT_HFLIP = (1 << 2), /* flip l-r on output (after rotation) */ }; +enum bltpolicy { + BLTPOLICY_DISABLED = 0, + BLTPOLICY_DEFAULT = 1, /* Default blit policy */ + BLTPOLICY_ALL, /* Test mode to attempt to blit all */ +}; + +enum bltmode { + BLTMODE_PAINT = 0, /* Attempt to blit layer by layer */ + BLTMODE_REGION = 1, /* Attempt to blit layers via regions */ +}; + /* ARGB image */ struct omap4_hwc_img { int width; @@ -119,6 +146,22 @@ struct omap4_hwc_module { }; typedef struct omap4_hwc_module omap4_hwc_module_t; +struct counts { + unsigned int possible_overlay_layers; + unsigned int composited_layers; + unsigned int scaled_layers; + unsigned int RGB; + unsigned int BGR; + unsigned int NV12; + unsigned int dockable; + unsigned int protected; + + unsigned int max_hw_overlays; + unsigned int max_scaling_overlays; + unsigned int mem; + unsigned int s3d; +}; + struct omap4_hwc_device { /* static data */ hwc_composer_device_1_t base; @@ -138,26 +181,47 @@ struct omap4_hwc_device { int flags_rgb_order; int flags_nv12_only; + float upscaled_nv12_limit; + int on_tv; /* using a tv */ int force_sgx; omap4_hwc_ext_t ext; /* external mirroring data */ int idle; - int ovls_blending; - /* composition data */ - struct dsscomp_setup_dispc_data dsscomp_data; + float primary_m[2][3]; /* internal transformation matrix */ + int primary_transform; + int primary_rotation; + hwc_rect_t primary_region; + buffer_handle_t *buffers; int use_sgx; int swap_rb; - unsigned int post2_layers; + unsigned int post2_layers; /* Buffers used with DSS pipes*/ + unsigned int post2_blit_buffers; /* Buffers used with blit */ int ext_ovls; /* # of overlays on external display for current composition */ int ext_ovls_wanted; /* # of overlays that should be on external display for current composition */ int last_ext_ovls; /* # of overlays on external/internal display for last composition */ int last_int_ovls; + + enum S3DLayoutType s3d_input_type; + enum S3DLayoutOrder s3d_input_order; + + enum bltmode blt_mode; + enum bltpolicy blt_policy; + + int blit_flags; + int blit_num; + struct omap_hwc_data comp_data; /* This is a kernel data structure */ + struct rgz_blt_entry blit_ops[RGZ_MAX_BLITS]; + struct counts stats; + int ion_fd; + struct ion_handle *ion_handles[2]; + }; typedef struct omap4_hwc_device omap4_hwc_device_t; #define HAL_FMT(f) ((f) == HAL_PIXEL_FORMAT_TI_NV12 ? "NV12" : \ + (f) == HAL_PIXEL_FORMAT_TI_NV12_1D ? "NV12" : \ (f) == HAL_PIXEL_FORMAT_YV12 ? "YV12" : \ (f) == HAL_PIXEL_FORMAT_BGRX_8888 ? "xRGB32" : \ (f) == HAL_PIXEL_FORMAT_RGBX_8888 ? "xBGR32" : \ @@ -171,6 +235,34 @@ typedef struct omap4_hwc_device omap4_hwc_device_t; (f) == OMAP_DSS_COLOR_RGB16 ? "RGB565" : "??") static int debug = 0; +static int debugpost2 = 0; +static int debugblt = 0; +static rgz_t grgz; +static struct bvsurfgeom gscrngeom; + +static void showfps(void) +{ + static int framecount = 0; + static int lastframecount = 0; + static nsecs_t lastfpstime = 0; + static float fps = 0; + char value[PROPERTY_VALUE_MAX]; + + property_get("debug.hwc.showfps", value, "0"); + if (!atoi(value)) { + return; + } + + framecount++; + if (!(framecount & 0x7)) { + nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC); + nsecs_t diff = now - lastfpstime; + fps = ((framecount - lastframecount) * (float)(s2ns(1))) / diff; + lastfpstime = now; + lastframecount = framecount; + ALOGI("%d Frames, %f FPS", framecount, fps); + } +} static void dump_layer(hwc_layer_1_t const* l) { @@ -241,7 +333,7 @@ static void dump_printf(struct dump_buf *buf, const char *fmt, ...) static void dump_set_info(omap4_hwc_device_t *hwc_dev, hwc_display_contents_1_t* list) { - struct dsscomp_setup_dispc_data *dsscomp = &hwc_dev->dsscomp_data; + struct dsscomp_setup_dispc_data *dsscomp = &hwc_dev->comp_data.dsscomp_data; char logbuf[1024]; struct dump_buf log = { .buf = logbuf, @@ -255,7 +347,14 @@ static void dump_set_info(omap4_hwc_device_t *hwc_dev, hwc_display_contents_1_t* dump_printf(&log, " "); hwc_layer_1_t *layer = &list->hwLayers[i]; IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle; - dump_printf(&log, "%p:%s,", handle, layer->compositionType == HWC_OVERLAY ? "DSS" : "SGX"); + if (hwc_dev->post2_blit_buffers) { + if ((i + 1) < hwc_dev->post2_layers) + dump_printf(&log, "%p:%s,", handle, "DSS"); + else + dump_printf(&log, "%p:%s,", handle, "BV2D"); + } + else + dump_printf(&log, "%p:%s,", handle, layer->compositionType == HWC_OVERLAY ? "DSS" : "SGX"); if ((layer->flags & HWC_SKIP_LAYER) || !handle) { dump_printf(&log, "SKIP"); continue; @@ -286,6 +385,13 @@ static void dump_set_info(omap4_hwc_device_t *hwc_dev, hwc_display_contents_1_t* dump_printf(&log, " "); dump_printf(&log, "%p", hwc_dev->buffers[i]); } + if (hwc_dev->post2_blit_buffers) { + dump_printf(&log, "} B{"); + for (i = hwc_dev->post2_layers; + i < hwc_dev->post2_blit_buffers + hwc_dev->post2_layers; i++) { + dump_printf(&log, "%p ", hwc_dev->buffers[i]); + } + } dump_printf(&log, "}%s\n", hwc_dev->use_sgx ? " swap" : ""); ALOGD("%s", log.buf); @@ -302,7 +408,7 @@ static int omap4_hwc_is_valid_format(int format) case HAL_PIXEL_FORMAT_BGRA_8888: case HAL_PIXEL_FORMAT_BGRX_8888: case HAL_PIXEL_FORMAT_TI_NV12: - case HAL_PIXEL_FORMAT_TI_NV12_PADDED: + case HAL_PIXEL_FORMAT_TI_NV12_1D: return 1; default: @@ -310,6 +416,17 @@ static int omap4_hwc_is_valid_format(int format) } } +static __u32 get_s3d_layout_type(hwc_layer_1_t *layer) +{ + return (layer->flags & S3DLayoutTypeMask) >> S3DLayoutTypeShift; +} + +static __u32 get_s3d_layout_order(hwc_layer_1_t *layer) +{ + return (layer->flags & S3DLayoutOrderMask) >> S3DLayoutOrderShift; +} + + static int scaled(hwc_layer_1_t *layer) { int w = WIDTH(layer->sourceCrop); @@ -318,7 +435,9 @@ static int scaled(hwc_layer_1_t *layer) if (layer->transform & HWC_TRANSFORM_ROT_90) swap(w, h); - return WIDTH(layer->displayFrame) != w || HEIGHT(layer->displayFrame) != h; + /* An S3D layer also needs scaling due to subsampling */ + return WIDTH(layer->displayFrame) != w || HEIGHT(layer->displayFrame) != h + || get_s3d_layout_type(layer) != eMono; } static int is_protected(hwc_layer_1_t *layer) @@ -342,6 +461,21 @@ static int is_RGB(IMG_native_handle_t *handle) return 0; } } +static int get_rgb_bpp(IMG_native_handle_t *handle) +{ + switch(handle->iFormat) + { + case HAL_PIXEL_FORMAT_BGRA_8888: + case HAL_PIXEL_FORMAT_BGRX_8888: + case HAL_PIXEL_FORMAT_RGBX_8888: + case HAL_PIXEL_FORMAT_RGBA_8888: + return 32; + case HAL_PIXEL_FORMAT_RGB_565: + return 16; + default: + return 0; + } +} static int is_BGR_format(int format) { @@ -364,13 +498,32 @@ static int is_NV12(IMG_native_handle_t *handle) switch(handle->iFormat) { case HAL_PIXEL_FORMAT_TI_NV12: - case HAL_PIXEL_FORMAT_TI_NV12_PADDED: + case HAL_PIXEL_FORMAT_TI_NV12_1D: return 1; default: return 0; } } +static int is_upscaled_NV12(omap4_hwc_device_t *hwc_dev, hwc_layer_1_t *layer) +{ + if (!layer) + return 0; + + IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle; + if (!is_NV12(handle)) + return 0; + + 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 * hwc_dev->upscaled_nv12_limit || + HEIGHT(layer->displayFrame) >= h * hwc_dev->upscaled_nv12_limit); +} + static int dockable(hwc_layer_1_t *layer) { IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle; @@ -419,7 +572,7 @@ omap4_hwc_setup_layer_base(struct dss2_ovl_cfg *oc, int index, int format, int b break; case HAL_PIXEL_FORMAT_TI_NV12: - case HAL_PIXEL_FORMAT_TI_NV12_PADDED: + case HAL_PIXEL_FORMAT_TI_NV12_1D: oc->color_mode = OMAP_DSS_COLOR_NV12; bits_per_pixel = 8; oc->cconv = ctbl_bt601_5; @@ -661,10 +814,25 @@ crop_to_rect(struct dss2_ovl_cfg *cfg, struct hwc_rect vis_rect) } static void +omap4_hwc_apply_transform(float transform[2][3],struct dss2_ovl_cfg *oc) +{ + float x, y, w, h; + + /* display position */ + x = transform[0][0] * oc->win.x + transform[0][1] * oc->win.y + transform[0][2]; + y = transform[1][0] * oc->win.x + transform[1][1] * oc->win.y + transform[1][2]; + w = transform[0][0] * oc->win.w + transform[0][1] * oc->win.h; + h = transform[1][0] * oc->win.w + transform[1][1] * oc->win.h; + oc->win.x = m_round(w > 0 ? x : x + w); + oc->win.y = m_round(h > 0 ? y : y + h); + oc->win.w = m_round(w > 0 ? w : -w); + oc->win.h = m_round(h > 0 ? h : -h); +} + +static void omap4_hwc_adjust_ext_layer(omap4_hwc_ext_t *ext, struct dss2_ovl_info *ovl) { struct dss2_ovl_cfg *oc = &ovl->cfg; - float x, y, w, h; /* crop to clone region if mirroring */ if (!ext->current.docking && @@ -673,15 +841,7 @@ omap4_hwc_adjust_ext_layer(omap4_hwc_ext_t *ext, struct dss2_ovl_info *ovl) return; } - /* display position */ - x = ext->m[0][0] * oc->win.x + ext->m[0][1] * oc->win.y + ext->m[0][2]; - y = ext->m[1][0] * oc->win.x + ext->m[1][1] * oc->win.y + ext->m[1][2]; - w = ext->m[0][0] * oc->win.w + ext->m[0][1] * oc->win.h; - h = ext->m[1][0] * oc->win.w + ext->m[1][1] * oc->win.h; - oc->win.x = m_round(w > 0 ? x : x + w); - oc->win.y = m_round(h > 0 ? y : y + h); - oc->win.w = m_round(w > 0 ? w : -w); - oc->win.h = m_round(h > 0 ? h : -h); + omap4_hwc_apply_transform(ext->m, oc); /* combining transformations: F^a*R^b*F^i*R^j = F^(a+b)*R^(j+b*(-1)^i), because F*R = R^(-1)*F */ oc->rotation += (oc->mirror ? -1 : 1) * ext->current.rotation; @@ -690,33 +850,28 @@ omap4_hwc_adjust_ext_layer(omap4_hwc_ext_t *ext, struct dss2_ovl_info *ovl) oc->mirror = !oc->mirror; } -static struct dsscomp_dispc_limitations { - __u8 max_xdecim_2d; - __u8 max_ydecim_2d; - __u8 max_xdecim_1d; - __u8 max_ydecim_1d; - __u32 fclk; - __u8 max_downscale; - __u8 min_width; - __u16 integer_scale_ratio_limit; - __u16 max_width; - __u16 max_height; -} limits = { - .max_xdecim_1d = 16, - .max_xdecim_2d = 16, - .max_ydecim_1d = 16, - .max_ydecim_2d = 2, - .fclk = 170666666, - .max_downscale = 4, - .min_width = 2, - .integer_scale_ratio_limit = 2048, - .max_width = 2048, - .max_height = 2048, -}; +static struct dsscomp_platform_info limits; + +static void +omap4_hwc_adjust_primary_display_layer(omap4_hwc_device_t *hwc_dev, struct dss2_ovl_info *ovl) +{ + struct dss2_ovl_cfg *oc = &ovl->cfg; + + if (crop_to_rect(&ovl->cfg, hwc_dev->primary_region) != 0) { + ovl->cfg.enabled = 0; + return; + } + + omap4_hwc_apply_transform(hwc_dev->primary_m, oc); + + /* combining transformations: F^a*R^b*F^i*R^j = F^(a+b)*R^(j+b*(-1)^i), because F*R = R^(-1)*F */ + oc->rotation += (oc->mirror ? -1 : 1) * hwc_dev->primary_rotation; + oc->rotation &= 3; +} static int omap4_hwc_can_scale(__u32 src_w, __u32 src_h, __u32 dst_w, __u32 dst_h, int is_2d, - struct dsscomp_display_info *dis, struct dsscomp_dispc_limitations *limits, - __u32 pclk) + struct dsscomp_display_info *dis, struct dsscomp_platform_info *limits, + __u32 pclk, void *handle) { __u32 fclk = limits->fclk / 1000; __u32 min_src_w = DIV_ROUND_UP(src_w, is_2d ? limits->max_xdecim_2d : limits->max_xdecim_1d); @@ -739,12 +894,16 @@ static int omap4_hwc_can_scale(__u32 src_w, __u32 src_h, __u32 dst_w, __u32 dst_ /* for manual panels pclk is 0, and there are no pclk based scaling limits */ if (!pclk) - return !(dst_w * limits->max_downscale < min_src_w); + return !(dst_w < src_w / limits->max_downscale / (is_2d ? limits->max_xdecim_2d : limits->max_xdecim_1d)); /* :HACK: limit horizontal downscale well below theoretical limit as we saw display artifacts */ if (dst_w * 4 < src_w) return 0; + if (handle) + if (get_rgb_bpp(handle) == 32 && src_w > 1280 && dst_w * 3 < src_w) + return 0; + /* max horizontal downscale is 4, or the fclk/pixclk */ if (fclk > pclk * limits->max_downscale) fclk = pclk * limits->max_downscale; @@ -771,7 +930,7 @@ static int omap4_hwc_can_scale_layer(omap4_hwc_device_t *hwc_dev, hwc_layer_1_t /* NOTE: layers should be able to be scaled externally since framebuffer is able to be scaled on selected external resolution */ return omap4_hwc_can_scale(src_w, src_h, dst_w, dst_h, is_NV12(handle), &hwc_dev->fb_dis, &limits, - hwc_dev->fb_dis.timings.pixel_clock); + hwc_dev->fb_dis.timings.pixel_clock, handle); } static int omap4_hwc_is_valid_layer(omap4_hwc_device_t *hwc_dev, @@ -789,7 +948,7 @@ static int omap4_hwc_is_valid_layer(omap4_hwc_device_t *hwc_dev, if (!is_NV12(handle)) { if (layer->transform) return 0; - if (mem1d(handle) > MAX_TILER_SLOT) + if (mem1d(handle) > limits.tiler1d_slot_size) return 0; } @@ -837,10 +996,11 @@ static __u32 add_scaling_score(__u32 score, static int omap4_hwc_set_best_hdmi_mode(omap4_hwc_device_t *hwc_dev, __u32 xres, __u32 yres, float xpy) { + int dis_ix = hwc_dev->on_tv ? 0 : 1; struct _qdis { struct dsscomp_display_info dis; struct dsscomp_videomode modedb[32]; - } d = { .dis = { .ix = 1 } }; + } d = { .dis = { .ix = dis_ix } }; omap4_hwc_ext_t *ext = &hwc_dev->ext; d.dis.modedb_len = sizeof(d.modedb) / sizeof(*d.modedb); @@ -872,6 +1032,9 @@ static int omap4_hwc_set_best_hdmi_mode(omap4_hwc_device_t *hwc_dev, __u32 xres, __u32 ext_width = d.dis.width_in_mm; __u32 ext_height = d.dis.height_in_mm; + if (d.modedb[i].vmode & FB_VMODE_INTERLACED) + mode_yres /= 2; + if (d.modedb[i].flag & FB_FLAG_RATIO_4_3) { ext_width = 4; ext_height = 3; @@ -888,10 +1051,10 @@ static int omap4_hwc_set_best_hdmi_mode(omap4_hwc_device_t *hwc_dev, __u32 xres, /* we need to ensure that even TILER2D buffers can be scaled */ if (!d.modedb[i].pixclock || - d.modedb[i].vmode || + (d.modedb[i].vmode & ~FB_VMODE_INTERLACED) || !omap4_hwc_can_scale(xres, yres, ext_fb_xres, ext_fb_yres, 1, &d.dis, &limits, - 1000000000 / d.modedb[i].pixclock)) + 1000000000 / d.modedb[i].pixclock, NULL)) continue; /* prefer CEA modes */ @@ -917,7 +1080,7 @@ static int omap4_hwc_set_best_hdmi_mode(omap4_hwc_device_t *hwc_dev, __u32 xres, } } if (~best) { - struct dsscomp_setup_display_data sdis = { .ix = 1, }; + struct dsscomp_setup_display_data sdis = { .ix = dis_ix }; sdis.mode = d.dis.modedb[best]; ALOGD("picking #%d", best); /* only reconfigure on change */ @@ -932,10 +1095,9 @@ static int omap4_hwc_set_best_hdmi_mode(omap4_hwc_device_t *hwc_dev, __u32 xres, get_max_dimensions(xres, yres, xpy, d.dis.timings.x_res, d.dis.timings.y_res, ext_width, ext_height, &ext_fb_xres, &ext_fb_yres); if (!d.dis.timings.pixel_clock || - d.dis.mgr.interlaced || !omap4_hwc_can_scale(xres, yres, ext_fb_xres, ext_fb_yres, 1, &d.dis, &limits, - d.dis.timings.pixel_clock)) { + d.dis.timings.pixel_clock, NULL)) { ALOGW("DSS scaler cannot support HDMI cloning"); return -1; } @@ -948,20 +1110,6 @@ static int omap4_hwc_set_best_hdmi_mode(omap4_hwc_device_t *hwc_dev, __u32 xres, return 0; } -struct counts { - unsigned int possible_overlay_layers; - unsigned int composited_layers; - unsigned int scaled_layers; - unsigned int RGB; - unsigned int BGR; - unsigned int NV12; - unsigned int dockable; - unsigned int protected; - - unsigned int max_hw_overlays; - unsigned int max_scaling_overlays; - unsigned int mem; -}; static void gather_layer_statistics(omap4_hwc_device_t *hwc_dev, struct counts *num, hwc_display_contents_1_t *list) { @@ -971,14 +1119,32 @@ static void gather_layer_statistics(omap4_hwc_device_t *hwc_dev, struct counts * for (i = 0; list && i < list->numHwLayers; i++) { hwc_layer_1_t *layer = &list->hwLayers[i]; IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle; + __u32 s3d_layout_type = get_s3d_layout_type(layer); layer->compositionType = HWC_FRAMEBUFFER; if (omap4_hwc_is_valid_layer(hwc_dev, layer, handle)) { + + if (s3d_layout_type != eMono) { + /* For now we can only handle 1 S3D layer, skip any additional ones */ + if (num->s3d > 0 || !hwc_dev->ext.dock.enabled || !hwc_dev->ext.s3d_capable) { + layer->flags |= HWC_SKIP_LAYER; + continue; + } else if (num->s3d == 0) { + /* For now, S3D layer is made a dockable layer to trigger docking logic. */ + if (!dockable(layer)) { + num->dockable++; + } + num->s3d++; + hwc_dev->s3d_input_type = s3d_layout_type; + hwc_dev->s3d_input_order = get_s3d_layout_order(layer); + } + } + num->possible_overlay_layers++; /* NV12 layers can only be rendered on scaling overlays */ - if (scaled(layer) || is_NV12(handle)) + if (scaled(layer) || is_NV12(handle) || hwc_dev->primary_transform) num->scaled_layers++; if (is_BGR(handle)) @@ -997,6 +1163,7 @@ static void gather_layer_statistics(omap4_hwc_device_t *hwc_dev, struct counts * num->mem += mem1d(handle); } } + hwc_dev->stats = *num; } static void decide_supported_cloning(omap4_hwc_device_t *hwc_dev, struct counts *num) @@ -1015,6 +1182,11 @@ static void decide_supported_cloning(omap4_hwc_device_t *hwc_dev, struct counts /* reserve just a video pipeline for HDMI if docking */ hwc_dev->ext_ovls = (num->dockable || ext->force_dock) ? 1 : 0; + + if (num->s3d && (hwc_dev->ext.s3d_type != hwc_dev->s3d_input_type)) { + /* S3D layers are dockable, and they need two overlays */ + hwc_dev->ext_ovls += 1; + } num->max_hw_overlays -= max(hwc_dev->ext_ovls, hwc_dev->last_ext_ovls); /* use mirroring transform if we are auto-switching to docking mode while mirroring*/ @@ -1049,16 +1221,21 @@ static void decide_supported_cloning(omap4_hwc_device_t *hwc_dev, struct counts /* if mirroring, we are limited by both internal and external overlays. However, ext_ovls is always <= MAX_HW_OVERLAYS / 2 <= max_hw_overlays */ - if (hwc_dev->ext_ovls && ext->current.enabled && !ext->current.docking) + if (!num->protected && hwc_dev->ext_ovls && ext->current.enabled && !ext->current.docking) num->max_hw_overlays = hwc_dev->ext_ovls; - num->max_scaling_overlays = num->max_hw_overlays - nonscaling_ovls; + /* If FB is not same resolution as LCD don't use GFX pipe line*/ + if (hwc_dev->primary_transform) { + num->max_hw_overlays -= NUM_NONSCALING_OVERLAYS; + num->max_scaling_overlays = num->max_hw_overlays; + } else + num->max_scaling_overlays = num->max_hw_overlays - nonscaling_ovls; } static int can_dss_render_all(omap4_hwc_device_t *hwc_dev, struct counts *num) { omap4_hwc_ext_t *ext = &hwc_dev->ext; - int on_tv = ext->on_tv && ext->current.enabled; + int on_tv = hwc_dev->on_tv || (ext->on_tv && ext->current.enabled); int tform = ext->current.enabled && (ext->current.rotation || ext->current.hflip); return !hwc_dev->force_sgx && @@ -1069,9 +1246,10 @@ static int can_dss_render_all(omap4_hwc_device_t *hwc_dev, struct counts *num) num->scaled_layers <= num->max_scaling_overlays && num->NV12 <= num->max_scaling_overlays && /* fits into TILER slot */ - num->mem <= MAX_TILER_SLOT && + num->mem <= limits.tiler1d_slot_size && /* we cannot clone non-NV12 transformed layers */ - (!tform || num->NV12 == num->possible_overlay_layers) && + (!tform || (num->NV12 == num->possible_overlay_layers) || + (num->NV12 && ext->current.docking)) && /* HDMI cannot display BGR */ (num->BGR == 0 || (num->RGB == 0 && !on_tv) || !hwc_dev->flags_rgb_order); } @@ -1082,8 +1260,9 @@ static inline int can_dss_render_layer(omap4_hwc_device_t *hwc_dev, IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle; omap4_hwc_ext_t *ext = &hwc_dev->ext; - int on_tv = ext->on_tv && ext->current.enabled; - int tform = ext->current.enabled && (ext->current.rotation || ext->current.hflip); + int cloning = ext->current.enabled && (!ext->current.docking || (handle!=NULL ? dockable(layer) : 0)); + int on_tv = hwc_dev->on_tv || (ext->on_tv && cloning); + int tform = cloning && (ext->current.rotation || ext->current.hflip); return omap4_hwc_is_valid_layer(hwc_dev, layer, handle) && /* cannot rotate non-NV12 layers on external display */ @@ -1103,7 +1282,7 @@ static inline int display_area(struct dss2_ovl_info *o) } static int clone_layer(omap4_hwc_device_t *hwc_dev, int ix) { - struct dsscomp_setup_dispc_data *dsscomp = &hwc_dev->dsscomp_data; + struct dsscomp_setup_dispc_data *dsscomp = &hwc_dev->comp_data.dsscomp_data; omap4_hwc_ext_t *ext = &hwc_dev->ext; int ext_ovl_ix = dsscomp->num_ovls - hwc_dev->post2_layers; struct dss2_ovl_info *o = &dsscomp->ovls[dsscomp->num_ovls]; @@ -1118,8 +1297,21 @@ static int clone_layer(omap4_hwc_device_t *hwc_dev, int ix) { /* reserve overlays at end for other display */ o->cfg.ix = MAX_HW_OVERLAYS - 1 - ext_ovl_ix; o->cfg.mgr_ix = 1; - o->addressing = OMAP_DSS_BUFADDR_OVL_IX; - o->ba = ix; + /* + * Here the assumption is that overlay0 is the one attached to FB. + * Hence this clone_layer call is for FB cloning (provided use_sgx is true). + */ + /* For the external displays whose transform is the same as + * that of primary display, ion_handles would be NULL hence + * the below logic doesn't execute. + */ + if (ix == 0 && hwc_dev->ion_handles[sync_id%2] && hwc_dev->use_sgx) { + o->addressing = OMAP_DSS_BUFADDR_ION; + o->ba = (int)hwc_dev->ion_handles[sync_id%2]; + } else { + o->addressing = OMAP_DSS_BUFADDR_OVL_IX; + o->ba = ix; + } /* use distinct z values (to simplify z-order checking) */ o->cfg.zorder += hwc_dev->post2_layers; @@ -1130,7 +1322,7 @@ static int clone_layer(omap4_hwc_device_t *hwc_dev, int ix) { } static int clone_external_layer(omap4_hwc_device_t *hwc_dev, int ix) { - struct dsscomp_setup_dispc_data *dsscomp = &hwc_dev->dsscomp_data; + struct dsscomp_setup_dispc_data *dsscomp = &hwc_dev->comp_data.dsscomp_data; omap4_hwc_ext_t *ext = &hwc_dev->ext; /* mirror only 1 external layer */ @@ -1170,6 +1362,152 @@ static int clone_external_layer(omap4_hwc_device_t *hwc_dev, int ix) { return clone_layer(hwc_dev, ix); } + +const char hdmiS3DTypePath[] = "/sys/devices/platform/omapdss/display1/s3d_type"; +const char hdmiS3DEnablePath[] = "/sys/devices/platform/omapdss/display1/s3d_enable"; + +static void +omap4_hwc_s3d_hdmi_enable(omap4_hwc_device_t *hwc_dev, bool enable) +{ + size_t bytesWritten; + char data; + int fd; + + if (hwc_dev->ext.s3d_enabled == enable) { + return; + } + + if (enable) { + char type[2]; + + switch(hwc_dev->ext.s3d_type) { + case eSideBySide: + snprintf(type, sizeof(type), "%d", HDMI_SIDE_BY_SIDE_HALF); + break; + case eTopBottom: + snprintf(type, sizeof(type), "%d", HDMI_TOPBOTTOM); + break; + default: + return; + } + + fd = open(hdmiS3DTypePath, O_WRONLY); + if (fd < 0) { + ALOGE("Failed to open sysfs %s", hdmiS3DTypePath); + return; + } + bytesWritten = write(fd, type, sizeof(type)); + close(fd); + + if (bytesWritten != sizeof(type)) { + ALOGE("Failed to write (%s) to sysfs %s", type, hdmiS3DTypePath); + return; + } + } + data = enable ? '1' : '0'; + + fd = open(hdmiS3DEnablePath, O_WRONLY); + if (fd < 0) { + ALOGE("Failed to open sysfs %s", hdmiS3DEnablePath); + return; + } + bytesWritten = write(fd, &data, 1); + close(fd); + + if (bytesWritten != 1) { + ALOGE("Failed to write(%d) to sysfs %s", enable, hdmiS3DEnablePath); + return; + } + + hwc_dev->ext.s3d_enabled = enable; +} + +static void +omap4_hwc_adjust_ext_s3d_layer(omap4_hwc_device_t *hwc_dev, + struct dss2_ovl_info *ovl, + bool leftView) +{ + struct dss2_ovl_cfg *oc = &ovl->cfg; + float x, y, w, h; + + switch (hwc_dev->s3d_input_type) { + case eSideBySide: + oc->crop.w = oc->crop.w/2; + if ((leftView && hwc_dev->s3d_input_order == eRightViewFirst) || + (!leftView && hwc_dev->s3d_input_order == eLeftViewFirst)) { + oc->crop.x = oc->crop.x + oc->crop.w; + } + break; + case eTopBottom: + oc->crop.h = oc->crop.h/2; + if ((leftView && hwc_dev->s3d_input_order == eRightViewFirst) || + (!leftView && hwc_dev->s3d_input_order == eLeftViewFirst)) { + oc->crop.y = oc->crop.y + oc->crop.h; + } + break; + default: + /* Should never fall here! */ + ALOGE("Unsupported S3D layer type!"); + break; + } + + switch (hwc_dev->ext.s3d_type) { + case eSideBySide: + oc->win.w = oc->win.w/2; + if ((leftView && hwc_dev->ext.s3d_order == eRightViewFirst) || + (!leftView && hwc_dev->ext.s3d_order == eLeftViewFirst)) { + oc->win.x = oc->win.x/2 + hwc_dev->ext.xres/2; + } else { + oc->win.x = oc->win.x/2; + } + break; + case eTopBottom: + oc->win.h = oc->win.h/2; + if ((leftView && hwc_dev->ext.s3d_order == eRightViewFirst) || + (!leftView && hwc_dev->ext.s3d_order == eLeftViewFirst)) { + oc->win.y = oc->win.y/2 + hwc_dev->ext.yres/2; + } else { + oc->win.y = oc->win.y/2; + } + break; + default: + /* Currently unhandled!!! */ + ALOGE("Unsupported S3D display type!"); + break; + } +} + +static int +clone_s3d_external_layer(omap4_hwc_device_t *hwc_dev, int ix_s3d) +{ + struct dsscomp_setup_dispc_data *dsscomp = &hwc_dev->comp_data.dsscomp_data; + int r; + + /* S3D layers are forced into docking layers. If the display layout and + * the layer layout don't match, we have to use 2 overlay pipelines */ + r = clone_external_layer(hwc_dev, ix_s3d); + if (r) { + ALOGE("Failed to clone s3d layer (%d)", r); + return r; + } + + r = clone_layer(hwc_dev, ix_s3d); + if (r) { + ALOGE("Failed to clone s3d layer (%d)", r); + return r; + } + + if (dsscomp->num_ovls < 2) { + ALOGE("Number of overlays is inconsistent (%d)", dsscomp->num_ovls); + return -EINVAL; + } + + omap4_hwc_adjust_ext_s3d_layer(hwc_dev, &dsscomp->ovls[dsscomp->num_ovls - 1], true); + omap4_hwc_adjust_ext_s3d_layer(hwc_dev, &dsscomp->ovls[dsscomp->num_ovls - 2], false); + + return 0; +} + static int setup_mirroring(omap4_hwc_device_t *hwc_dev) { omap4_hwc_ext_t *ext = &hwc_dev->ext; @@ -1214,6 +1552,173 @@ static void check_sync_fds(size_t numDisplays, hwc_display_contents_1_t** displa } } +static void blit_reset(omap4_hwc_device_t *hwc_dev, int flags) +{ + hwc_dev->blit_flags = 0; + hwc_dev->blit_num = 0; + hwc_dev->post2_blit_buffers = 0; + hwc_dev->comp_data.blit_data.rgz_items = 0; + + /* We want to maintain the rgz dirty region data if there are no geometry changes */ + if (flags & HWC_GEOMETRY_CHANGED) + rgz_release(&grgz); +} + +static int blit_layers(omap4_hwc_device_t *hwc_dev, hwc_display_contents_1_t *list, int bufoff) +{ + /* Do not blit if this frame will be composed entirely by the GPU */ + if (!list || hwc_dev->force_sgx) + goto err_out; + + int rgz_in_op; + int rgz_out_op; + + switch (hwc_dev->blt_mode) { + case BLTMODE_PAINT: + rgz_in_op = RGZ_IN_HWCCHK; + rgz_out_op = RGZ_OUT_BVCMD_PAINT; + break; + case BLTMODE_REGION: + default: + rgz_in_op = RGZ_IN_HWC; + rgz_out_op = RGZ_OUT_BVCMD_REGION; + break; + } + + rgz_in_params_t in = { + .op = rgz_in_op, + .data = { + .hwc = { + .dstgeom = &gscrngeom, + .layers = list->hwLayers, + .layerno = list->numHwLayers + } + } + }; + + /* + * This means if all the layers marked for the FRAMEBUFFER cannot be + * blitted, do not blit, for e.g. SKIP layers + */ + if (rgz_in(&in, &grgz) != RGZ_ALL) + goto err_out; + + unsigned int i, count = 0; + for (i = 0; i < list->numHwLayers; i++) { + if (list->hwLayers[i].compositionType != HWC_OVERLAY) { + count++; + } + } + + rgz_out_params_t out = { + .op = rgz_out_op, + .data = { + .bvc = { + .dstgeom = &gscrngeom, + .noblend = 0, + } + } + }; + + if (rgz_out(&grgz, &out) != 0) { + ALOGE("Failed generating blits"); + goto err_out; + } + + /* This is a special situation where the regionizer decided no blits are + * needed for this frame but there are blit buffers to synchronize with. Can + * happen only if the regionizer is enabled otherwise it's likely a bug + */ + if (rgz_out_op != RGZ_OUT_BVCMD_REGION && out.data.bvc.out_blits == 0 && out.data.bvc.out_nhndls > 0) { + ALOGE("Regionizer invalid output blit_num %d, post2_blit_buffers %d", out.data.bvc.out_blits, out.data.bvc.out_nhndls); + goto err_out; + } + + hwc_dev->blit_flags |= HWC_BLT_FLAG_USE_FB; + hwc_dev->blit_num = out.data.bvc.out_blits; + hwc_dev->post2_blit_buffers = out.data.bvc.out_nhndls; + for (i = 0; i < hwc_dev->post2_blit_buffers; i++) { + //ALOGI("blit buffers[%d] = %p", bufoff, out.data.bvc.out_hndls[i]); + hwc_dev->buffers[bufoff++] = out.data.bvc.out_hndls[i]; + } + + struct rgz_blt_entry *res_blit_ops = (struct rgz_blt_entry *) out.data.bvc.cmdp; + memcpy(hwc_dev->comp_data.blit_data.rgz_blts, res_blit_ops, sizeof(*res_blit_ops) * out.data.bvc.cmdlen); + ALOGI_IF(debugblt, "blt struct sz %d", sizeof(*res_blit_ops) * out.data.bvc.cmdlen); + ALOGE_IF(hwc_dev->blit_num != out.data.bvc.cmdlen,"blit_num != out.data.bvc.cmdlen, %d != %d", hwc_dev->blit_num, out.data.bvc.cmdlen); + + /* all layers will be rendered without SGX help either via DSS or blitter */ + for (i = 0; i < list->numHwLayers; i++) { + if (list->hwLayers[i].compositionType != HWC_OVERLAY) { + list->hwLayers[i].compositionType = HWC_OVERLAY; + //ALOGI("blitting layer %d", i); + list->hwLayers[i].hints &= ~HWC_HINT_TRIPLE_BUFFER; + } + list->hwLayers[i].hints &= ~HWC_HINT_CLEAR_FB; + } + return 1; + +err_out: + rgz_release(&grgz); + return 0; +} + +void debug_post2(omap4_hwc_device_t *hwc_dev, int nbufs) +{ + if (!debugpost2) + return; + struct dsscomp_setup_dispc_data *dsscomp = &hwc_dev->comp_data.dsscomp_data; + int i; + for (i=0; i<nbufs; i++) { + ALOGI("buf[%d] hndl %p", i, hwc_dev->buffers[i]); + } + for (i=0; i < dsscomp->num_ovls; i++) { + ALOGI("ovl[%d] ba %d", i, dsscomp->ovls[i].ba); + } +} + +static int free_tiler2d_buffers(omap4_hwc_device_t *hwc_dev) +{ + int i; + + for (i = 0 ; i < NUM_EXT_DISPLAY_BACK_BUFFERS; i++) { + ion_free(hwc_dev->ion_fd, hwc_dev->ion_handles[i]); + hwc_dev->ion_handles[i] = NULL; + } + return 0; +} + +static int allocate_tiler2d_buffers(omap4_hwc_device_t *hwc_dev) +{ + int ret, i; + size_t stride; + + if (hwc_dev->ion_fd < 0) { + ALOGE("No ion fd, hence can't allocate tiler2d buffers"); + return -1; + } + + for (i = 0; i < NUM_EXT_DISPLAY_BACK_BUFFERS; i++) { + if (hwc_dev->ion_handles[i]) + return 0; + } + + for (i = 0 ; i < NUM_EXT_DISPLAY_BACK_BUFFERS; i++) { + ret = ion_alloc_tiler(hwc_dev->ion_fd, hwc_dev->fb_dev->base.width, hwc_dev->fb_dev->base.height, + TILER_PIXEL_FMT_32BIT, 0, &hwc_dev->ion_handles[i], &stride); + if (ret) + goto handle_error; + + ALOGI("ion handle[%d][%p]", i, hwc_dev->ion_handles[i]); + } + return 0; + +handle_error: + free_tiler2d_buffers(hwc_dev); + return -1; +} + + static int omap4_hwc_prepare(struct hwc_composer_device_1 *dev, size_t numDisplays, hwc_display_contents_1_t** displays) { @@ -1223,7 +1728,7 @@ static int omap4_hwc_prepare(struct hwc_composer_device_1 *dev, size_t numDispla hwc_display_contents_1_t* list = displays[0]; // ignore displays beyond the first omap4_hwc_device_t *hwc_dev = (omap4_hwc_device_t *)dev; - struct dsscomp_setup_dispc_data *dsscomp = &hwc_dev->dsscomp_data; + struct dsscomp_setup_dispc_data *dsscomp = &hwc_dev->comp_data.dsscomp_data; struct counts num = { .composited_layers = list ? list->numHwLayers : 0 }; unsigned int i, ix; @@ -1235,10 +1740,6 @@ static int omap4_hwc_prepare(struct hwc_composer_device_1 *dev, size_t numDispla decide_supported_cloning(hwc_dev, &num); - /* Disable the forced SGX rendering if there is only one layer */ - if (hwc_dev->force_sgx && num.composited_layers <= 1) - hwc_dev->force_sgx = 0; - /* phase 3 logic */ if (can_dss_render_all(hwc_dev, &num)) { /* All layers can be handled by the DSS -- don't use SGX for composition */ @@ -1251,11 +1752,33 @@ static int omap4_hwc_prepare(struct hwc_composer_device_1 *dev, size_t numDispla } /* setup pipes */ - dsscomp->num_ovls = hwc_dev->use_sgx; int z = 0; int fb_z = -1; int scaled_gfx = 0; int ix_docking = -1; + int ix_s3d = -1; + + int blit_all = 0; + blit_reset(hwc_dev, list ? list->flags : 0); + + /* If the SGX is used or we are going to blit something we need a framebuffer + * and a DSS pipe + */ + int needs_fb = hwc_dev->use_sgx; + + if (hwc_dev->blt_policy == BLTPOLICY_ALL) { + /* Check if we can blit everything */ + blit_all = blit_layers(hwc_dev, list, 0); + if (blit_all) { + needs_fb = 1; + hwc_dev->use_sgx = 0; + } + } + + /* If a framebuffer is needed, begin using VID1 for DSS overlay layers, + * we need GFX for FB + */ + dsscomp->num_ovls = needs_fb ? 1 /*VID1*/ : 0 /*GFX*/; /* set up if DSS layers */ unsigned int mem_used = 0; @@ -1269,23 +1792,28 @@ static int omap4_hwc_prepare(struct hwc_composer_device_1 *dev, size_t numDispla (!hwc_dev->force_sgx || /* render protected and dockable layers via DSS */ is_protected(layer) || + is_upscaled_NV12(hwc_dev, layer) || (hwc_dev->ext.current.docking && hwc_dev->ext.current.enabled && dockable(layer))) && - mem_used + mem1d(handle) < MAX_TILER_SLOT && + mem_used + mem1d(handle) <= limits.tiler1d_slot_size && /* can't have a transparent overlay in the middle of the framebuffer stack */ !(is_BLENDED(layer) && fb_z >= 0)) { /* render via DSS overlay */ mem_used += mem1d(handle); layer->compositionType = HWC_OVERLAY; + /* + * This hint will not be used in vanilla ICS, but maybe in + * JellyBean, it is useful to distinguish between blts and true + * overlays + */ + layer->hints |= HWC_HINT_TRIPLE_BUFFER; /* clear FB above all opaque layers if rendering via SGX */ if (hwc_dev->use_sgx && !is_BLENDED(layer)) layer->hints |= HWC_HINT_CLEAR_FB; - /* see if any of the (non-backmost) overlays are doing blending */ - else if (is_BLENDED(layer) && i > 0) - hwc_dev->ovls_blending = 1; hwc_dev->buffers[dsscomp->num_ovls] = layer->handle; + //ALOGI("dss buffers[%d] = %p", dsscomp->num_ovls, hwc_dev->buffers[dsscomp->num_ovls]); omap4_hwc_setup_layer(hwc_dev, &dsscomp->ovls[dsscomp->num_ovls], @@ -1295,12 +1823,12 @@ static int omap4_hwc_prepare(struct hwc_composer_device_1 *dev, size_t numDispla handle->iWidth, handle->iHeight); - dsscomp->ovls[dsscomp->num_ovls].cfg.ix = dsscomp->num_ovls; + dsscomp->ovls[dsscomp->num_ovls].cfg.ix = dsscomp->num_ovls + hwc_dev->primary_transform; dsscomp->ovls[dsscomp->num_ovls].addressing = OMAP_DSS_BUFADDR_LAYER_IX; dsscomp->ovls[dsscomp->num_ovls].ba = dsscomp->num_ovls; /* ensure GFX layer is never scaled */ - if (dsscomp->num_ovls == 0) { + if ((dsscomp->num_ovls == 0) && (!hwc_dev->primary_transform)) { scaled_gfx = scaled(layer) || is_NV12(handle); } else if (scaled_gfx && !scaled(layer) && !is_NV12(handle)) { /* swap GFX layer with this one */ @@ -1315,6 +1843,10 @@ static int omap4_hwc_prepare(struct hwc_composer_device_1 *dev, size_t numDispla display_area(&dsscomp->ovls[dsscomp->num_ovls]) > display_area(&dsscomp->ovls[ix_docking]))) ix_docking = dsscomp->num_ovls; + /* remember the ix for s3d layer */ + if (get_s3d_layout_type(layer) != eMono) { + ix_s3d = dsscomp->num_ovls; + } dsscomp->num_ovls++; z++; } else if (hwc_dev->use_sgx) { @@ -1334,15 +1866,31 @@ static int omap4_hwc_prepare(struct hwc_composer_device_1 *dev, size_t numDispla if (scaled_gfx) dsscomp->ovls[0].cfg.ix = dsscomp->num_ovls; - if (hwc_dev->use_sgx) { + if (hwc_dev->blt_policy == BLTPOLICY_DEFAULT) { + if (hwc_dev->use_sgx) { + if (blit_layers(hwc_dev, list, dsscomp->num_ovls == 1 ? 0 : dsscomp->num_ovls)) { + hwc_dev->use_sgx = 0; + } + } + } + + /* If the SGX is not used and there is blit data we need a framebuffer and + * a DSS pipe well configured for it + */ + if (needs_fb) { /* assign a z-layer for fb */ if (fb_z < 0) { - if (num.composited_layers) + if (!hwc_dev->blt_policy != BLTPOLICY_DISABLED && num.composited_layers) ALOGE("**** should have assigned z-layer for fb"); fb_z = z++; } - - hwc_dev->buffers[0] = NULL; + /* + * This is needed because if we blit all we would lose the handle of + * the first layer + */ + if (hwc_dev->use_sgx) { + hwc_dev->buffers[0] = NULL; + } omap4_hwc_setup_layer_base(&dsscomp->ovls[0].cfg, fb_z, hwc_dev->fb_dev->base.format, 1, /* FB is always premultiplied */ @@ -1351,14 +1899,34 @@ static int omap4_hwc_prepare(struct hwc_composer_device_1 *dev, size_t numDispla dsscomp->ovls[0].cfg.pre_mult_alpha = 1; dsscomp->ovls[0].addressing = OMAP_DSS_BUFADDR_LAYER_IX; dsscomp->ovls[0].ba = 0; + dsscomp->ovls[0].cfg.ix = hwc_dev->primary_transform; } /* mirror layers */ hwc_dev->post2_layers = dsscomp->num_ovls; omap4_hwc_ext_t *ext = &hwc_dev->ext; - if (ext->current.enabled && hwc_dev->ext_ovls) { - if (ext->current.docking && ix_docking >= 0) { + if (ext->current.enabled && ((!num.protected && hwc_dev->ext_ovls) || + (hwc_dev->ext_ovls_wanted && hwc_dev->ext_ovls >= hwc_dev->ext_ovls_wanted))) { + if (ext->current.docking && ix_s3d >= 0) { + if (clone_s3d_external_layer(hwc_dev, ix_s3d) == 0) { + dsscomp->ovls[dsscomp->num_ovls - 2].cfg.zorder = z++; + dsscomp->ovls[dsscomp->num_ovls - 1].cfg.zorder = z++; + /* For now, show only the left view of an S3D layer + * in the local display while we have hdmi attached */ + switch (hwc_dev->s3d_input_type) { + case eSideBySide: + dsscomp->ovls[ix_s3d].cfg.crop.w = dsscomp->ovls[ix_s3d].cfg.crop.w/2; + break; + case eTopBottom: + dsscomp->ovls[ix_s3d].cfg.crop.h = dsscomp->ovls[ix_s3d].cfg.crop.h/2; + break; + default: + ALOGE("Unsupported S3D input type"); + break; + } + } + } else if (ext->current.docking && ix_docking >= 0) { if (clone_external_layer(hwc_dev, ix_docking) == 0) dsscomp->ovls[dsscomp->num_ovls - 1].cfg.zorder = z++; } else if (ext->current.docking && ix_docking < 0 && ext->force_dock) { @@ -1387,6 +1955,17 @@ static int omap4_hwc_prepare(struct hwc_composer_device_1 *dev, size_t numDispla } } } + + /* Apply transform for primary display */ + if (hwc_dev->primary_transform) + for (i = 0; i < dsscomp->num_ovls; i++) { + if(dsscomp->ovls[i].cfg.mgr_ix == 0) + omap4_hwc_adjust_primary_display_layer(hwc_dev, &dsscomp->ovls[i]); + } + + + omap4_hwc_s3d_hdmi_enable(hwc_dev, ix_s3d >= 0); + ext->last = ext->current; if (z != dsscomp->num_ovls || dsscomp->num_ovls > MAX_HW_OVERLAYS) @@ -1416,6 +1995,14 @@ static int omap4_hwc_prepare(struct hwc_composer_device_1 *dev, size_t numDispla hwc_dev->ext_ovls = dsscomp->num_ovls - hwc_dev->post2_layers; } + /* + * Whilst the mode of the display is being changed drop compositions to the + * display + */ + if (ext->last_mode == 0 && hwc_dev->on_tv) { + dsscomp->num_ovls = 0; + } + if (debug) { ALOGD("prepare (%d) - %s (comp=%d, poss=%d/%d scaled, RGB=%d,BGR=%d,NV12=%d) (ext=%s%s%ddeg%s %dex/%dmx (last %dex,%din)\n", dsscomp->sync_id, @@ -1477,7 +2064,7 @@ static int omap4_hwc_set(struct hwc_composer_device_1 *dev, sur = list->sur; } omap4_hwc_device_t *hwc_dev = (omap4_hwc_device_t *)dev; - struct dsscomp_setup_dispc_data *dsscomp = &hwc_dev->dsscomp_data; + struct dsscomp_setup_dispc_data *dsscomp = &hwc_dev->comp_data.dsscomp_data; int err = 0; int invalidate; @@ -1485,7 +2072,8 @@ static int omap4_hwc_set(struct hwc_composer_device_1 *dev, omap4_hwc_reset_screen(hwc_dev); - invalidate = hwc_dev->ext_ovls_wanted && !hwc_dev->ext_ovls; + invalidate = hwc_dev->ext_ovls_wanted && (hwc_dev->ext_ovls < hwc_dev->ext_ovls_wanted) && + (hwc_dev->stats.protected || !hwc_dev->ext_ovls); if (debug) dump_set_info(hwc_dev, list); @@ -1510,10 +2098,42 @@ static int omap4_hwc_set(struct hwc_composer_device_1 *dev, if (hwc_dev->force_sgx > 0) hwc_dev->force_sgx--; + hwc_dev->comp_data.blit_data.rgz_flags = hwc_dev->blit_flags; + hwc_dev->comp_data.blit_data.rgz_items = hwc_dev->blit_num; + int omaplfb_comp_data_sz = sizeof(hwc_dev->comp_data) + + (hwc_dev->comp_data.blit_data.rgz_items * sizeof(struct rgz_blt_entry)); + + + unsigned int nbufs = hwc_dev->post2_layers; + if (hwc_dev->post2_blit_buffers) { + /* + * We don't want to pass a NULL entry in the Post2, but we need to + * fix up buffer handle array and overlay indexes to account for + * this + */ + nbufs += hwc_dev->post2_blit_buffers - 1; + + if (hwc_dev->post2_layers > 1) { + unsigned int i, j; + for (i = 0; i < nbufs; i++) { + hwc_dev->buffers[i] = hwc_dev->buffers[i+1]; + } + for (i = 1, j= 1; j < hwc_dev->post2_layers; i++, j++) { + dsscomp->ovls[j].ba = i; + } + } + } + ALOGI_IF(debugblt && hwc_dev->blt_policy != BLTPOLICY_DISABLED, + "Post2, blits %d, ovl_buffers %d, blit_buffers %d sgx %d", + hwc_dev->blit_num, hwc_dev->post2_layers, hwc_dev->post2_blit_buffers, + hwc_dev->use_sgx); + + debug_post2(hwc_dev, nbufs); err = hwc_dev->fb_dev->Post2((framebuffer_device_t *)hwc_dev->fb_dev, hwc_dev->buffers, - hwc_dev->post2_layers, - dsscomp, sizeof(*dsscomp)); + nbufs, + dsscomp, omaplfb_comp_data_sz); + showfps(); } hwc_dev->last_ext_ovls = hwc_dev->ext_ovls; hwc_dev->last_int_ovls = hwc_dev->post2_layers; @@ -1534,7 +2154,7 @@ err_out: static void omap4_hwc_dump(struct hwc_composer_device_1 *dev, char *buff, int buff_len) { omap4_hwc_device_t *hwc_dev = (omap4_hwc_device_t *)dev; - struct dsscomp_setup_dispc_data *dsscomp = &hwc_dev->dsscomp_data; + struct dsscomp_setup_dispc_data *dsscomp = &hwc_dev->comp_data.dsscomp_data; struct dump_buf log = { .buf = buff, .buf_len = buff_len, @@ -1548,17 +2168,22 @@ static void omap4_hwc_dump(struct hwc_composer_device_1 *dev, char *buff, int bu struct dss2_ovl_cfg *cfg = &dsscomp->ovls[i].cfg; dump_printf(&log, " layer %d:\n", i); - dump_printf(&log, " enabled: %s\n", - cfg->enabled ? "true" : "false"); - dump_printf(&log, " buff: %p %dx%d stride: %d\n", - hwc_dev->buffers[i], cfg->width, cfg->height, cfg->stride); - dump_printf(&log, " src: (%d,%d) %dx%d\n", - cfg->crop.x, cfg->crop.y, cfg->crop.w, cfg->crop.h); - dump_printf(&log, " dst: (%d,%d) %dx%d\n", - cfg->win.x, cfg->win.y, cfg->win.w, cfg->win.h); - dump_printf(&log, " ix: %d\n", cfg->ix); - dump_printf(&log, " zorder: %d\n\n", cfg->zorder); - } + dump_printf(&log, " enabled:%s buff:%p %dx%d stride:%d\n", + cfg->enabled ? "true" : "false", hwc_dev->buffers[i], + cfg->width, cfg->height, cfg->stride); + dump_printf(&log, " src:(%d,%d) %dx%d dst:(%d,%d) %dx%d ix:%d zorder:%d\n", + cfg->crop.x, cfg->crop.y, cfg->crop.w, cfg->crop.h, + cfg->win.x, cfg->win.y, cfg->win.w, cfg->win.h, + cfg->ix, cfg->zorder); + } + + if (hwc_dev->blt_policy != BLTPOLICY_DISABLED) { + dump_printf(&log, " bltpolicy: %s, bltmode: %s\n", + hwc_dev->blt_policy == BLTPOLICY_DEFAULT ? "default" : + hwc_dev->blt_policy == BLTPOLICY_ALL ? "all" : "unknown", + hwc_dev->blt_mode == BLTMODE_PAINT ? "paint" : "regionize"); + } + dump_printf(&log, "\n"); } static void free_png_image(omap4_hwc_device_t *hwc_dev, struct omap4_hwc_img *img) @@ -1688,6 +2313,9 @@ static int omap4_hwc_device_close(hw_device_t* device) close(hwc_dev->hdmi_fb_fd); if (hwc_dev->fb_fd >= 0) close(hwc_dev->fb_fd); + if (hwc_dev->ion_fd >= 0) + ion_close(hwc_dev->ion_fd); + /* pthread will get killed when parent process exits */ pthread_mutex_destroy(&hwc_dev->lock); free(hwc_dev); @@ -1722,12 +2350,103 @@ err_out: return err; } +static void set_primary_display_transform_matrix(omap4_hwc_device_t *hwc_dev) +{ + /* create primary display translation matrix */ + hwc_dev->fb_dis.ix = 0;/*Default display*/ + + int ret = ioctl(hwc_dev->dsscomp_fd, DSSCIOC_QUERY_DISPLAY, &hwc_dev->fb_dis); + if (ret) + ALOGE("failed to get display info (%d): %m", errno); + + int lcd_w = hwc_dev->fb_dis.timings.x_res; + int lcd_h = hwc_dev->fb_dis.timings.y_res; + int orig_w = hwc_dev->fb_dev->base.width; + int orig_h = hwc_dev->fb_dev->base.height; + hwc_rect_t region = {.left = 0, .top = 0, .right = orig_w, .bottom = orig_h}; + hwc_dev->primary_region = region; + hwc_dev->primary_rotation = ((lcd_w > lcd_h) ^ (orig_w > orig_h)) ? 1 : 0; + hwc_dev->primary_transform = ((lcd_w != orig_w)||(lcd_h != orig_h)) ? 1 : 0; + + ALOGI("transforming FB (%dx%d) => (%dx%d) rot%d", orig_w, orig_h, lcd_w, lcd_h, hwc_dev->primary_rotation); + + /* reorientation matrix is: + m = (center-from-target-center) * (scale-to-target) * (mirror) * (rotate) * (center-to-original-center) */ + + memcpy(hwc_dev->primary_m, m_unit, sizeof(m_unit)); + m_translate(hwc_dev->primary_m, -(orig_w >> 1), -(orig_h >> 1)); + m_rotate(hwc_dev->primary_m, hwc_dev->primary_rotation); + if (hwc_dev->primary_rotation & 1) + swap(orig_w, orig_h); + m_scale(hwc_dev->primary_m, orig_w, lcd_w, orig_h, lcd_h); + m_translate(hwc_dev->primary_m, lcd_w >> 1, lcd_h >> 1); +} + + + +static void handle_s3d_hotplug(omap4_hwc_ext_t *ext, int state) +{ + struct edid_t *edid = NULL; + if (state) { + int fd = open("/sys/devices/platform/omapdss/display1/edid", O_RDONLY); + if (!fd) + return; + uint8_t edid_data[EDID_SIZE]; + size_t bytes_read = read(fd, edid_data, EDID_SIZE); + close(fd); + if (bytes_read < EDID_SIZE) + return; + if (edid_parser_init(&edid, edid_data)) + return; + } + + ext->s3d_enabled = false; + ext->s3d_capable = false; + ext->s3d_type = eMono; + ext->s3d_order = eLeftViewFirst; + + if (edid) { + ext->s3d_capable = edid_s3d_capable(edid); + /* For now assume Side-by-Side half support applies to all modes */ + ext->s3d_type = eSideBySide; + ext->s3d_order = eLeftViewFirst; + edid_parser_deinit(edid); + } +} + + static void handle_hotplug(omap4_hwc_device_t *hwc_dev) { omap4_hwc_ext_t *ext = &hwc_dev->ext; __u8 state = ext->hdmi_state; + /* Ignore external HDMI logic if the primary display is HDMI */ + if (hwc_dev->on_tv) { + ALOGI("Primary display is HDMI - skip clone/dock logic"); + + if (state) { + __u32 xres = hwc_dev->fb_dev->base.width; + __u32 yres = hwc_dev->fb_dev->base.height; + if (omap4_hwc_set_best_hdmi_mode(hwc_dev, xres, yres, ext->lcd_xpy)) { + ALOGE("Failed to set HDMI mode"); + } + set_primary_display_transform_matrix(hwc_dev); + + ioctl(hwc_dev->fb_fd, FBIOBLANK, FB_BLANK_UNBLANK); + + if (hwc_dev->procs && hwc_dev->procs->invalidate) { + hwc_dev->procs->invalidate(hwc_dev->procs); + } + } else + ext->last_mode = 0; + + return; + } + pthread_mutex_lock(&hwc_dev->lock); + + handle_s3d_hotplug(ext, state); + ext->dock.enabled = ext->mirror.enabled = 0; if (state) { /* check whether we can clone and/or dock */ @@ -1744,7 +2463,7 @@ static void handle_hotplug(omap4_hwc_device_t *hwc_dev) ext->dock.rotation = atoi(value) & EXT_ROTATION; ext->dock.hflip = (atoi(value) & EXT_HFLIP) > 0; ext->dock.docking = 1; - property_get("persist.hwc.mirroring.transform", value, hwc_dev->fb_dev->base.height > hwc_dev->fb_dev->base.width ? "3" : "0"); + property_get("persist.hwc.mirroring.transform", value, hwc_dev->fb_dis.timings.y_res > hwc_dev->fb_dis.timings.x_res ? "3" : "0"); ext->mirror.rotation = atoi(value) & EXT_ROTATION; ext->mirror.hflip = (atoi(value) & EXT_HFLIP) > 0; ext->mirror.docking = 0; @@ -1771,8 +2490,19 @@ static void handle_hotplug(omap4_hwc_device_t *hwc_dev) } else ext->mirror.enabled = 0; } + /* Allocate backup buffers for FB rotation + * This is required only if the FB tranform is different from that + * of the external display and the FB is not in TILER2D space + */ + if (ext->mirror.rotation && (limits.fbmem_type != DSSCOMP_FBMEM_TILER2D)) + allocate_tiler2d_buffers(hwc_dev); + } else { ext->last_mode = 0; + if (ext->mirror.rotation && (limits.fbmem_type != DSSCOMP_FBMEM_TILER2D)) { + /* free tiler 2D buffer on detach */ + free_tiler2d_buffers(hwc_dev); + } } ALOGI("external display changed (state=%d, mirror={%s tform=%ddeg%s}, dock={%s tform=%ddeg%s%s}, tv=%d", state, ext->mirror.enabled ? "enabled" : "disabled", @@ -1866,7 +2596,7 @@ static void *omap4_hwc_hdmi_thread(void *data) if (hwc_dev->idle) { if (hwc_dev->procs) { pthread_mutex_lock(&hwc_dev->lock); - invalidate = !hwc_dev->force_sgx && hwc_dev->ovls_blending; + invalidate = hwc_dev->last_int_ovls > 1 && !hwc_dev->force_sgx; if (invalidate) { hwc_dev->force_sgx = 2; } @@ -1994,6 +2724,18 @@ static int omap4_hwc_device_open(const hw_module_t* module, const char* name, hwc_dev->base.common.tag = HARDWARE_DEVICE_TAG; hwc_dev->base.common.version = HWC_DEVICE_API_VERSION_1_0; + + char value[PROPERTY_VALUE_MAX]; + property_get("ro.product.board", value, ""); + if (strncmp("blaze", value, PROPERTY_VALUE_MAX) == 0) { + ALOGI("Revert to legacy HWC API for fake vsync"); + hwc_dev->base.common.version = HWC_DEVICE_API_VERSION_0_2; + } + + if (strncmp("panda5", value, PROPERTY_VALUE_MAX) == 0) { + ALOGI("Revert to legacy HWC API for fake vsync"); + hwc_dev->base.common.version = HWC_DEVICE_API_VERSION_0_2; + } hwc_dev->base.common.module = (hw_module_t *)module; hwc_dev->base.common.close = omap4_hwc_device_close; hwc_dev->base.prepare = omap4_hwc_prepare; @@ -2013,9 +2755,9 @@ static int omap4_hwc_device_open(const hw_module_t* module, const char* name, goto done; } - hwc_dev->hdmi_fb_fd = open("/dev/graphics/fb1", O_RDWR); - if (hwc_dev->hdmi_fb_fd < 0) { - ALOGE("failed to open hdmi fb (%d)", errno); + int ret = ioctl(hwc_dev->dsscomp_fd, DSSCIOC_QUERY_PLATFORM, &limits); + if (ret) { + ALOGE("failed to get platform limits (%d): %m", errno); err = -errno; goto done; } @@ -2042,20 +2784,51 @@ static int omap4_hwc_device_open(const hw_module_t* module, const char* name, goto done; } - hwc_dev->buffers = malloc(sizeof(buffer_handle_t) * MAX_HW_OVERLAYS); + /* Allocate the maximum buffers that we can receive from HWC */ + hwc_dev->buffers = malloc(sizeof(buffer_handle_t) * MAX_HWC_LAYERS); if (!hwc_dev->buffers) { err = -ENOMEM; goto done; } - int ret = ioctl(hwc_dev->dsscomp_fd, DSSCIOC_QUERY_DISPLAY, &hwc_dev->fb_dis); + ret = ioctl(hwc_dev->dsscomp_fd, DSSCIOC_QUERY_DISPLAY, &hwc_dev->fb_dis); if (ret) { ALOGE("failed to get display info (%d): %m", errno); err = -errno; goto done; } - hwc_dev->ext.lcd_xpy = (float) hwc_dev->fb_dis.width_in_mm / hwc_dev->fb_dis.timings.x_res / - hwc_dev->fb_dis.height_in_mm * hwc_dev->fb_dis.timings.y_res; + + hwc_dev->ion_fd = ion_open(); + if (hwc_dev->ion_fd < 0) { + ALOGE("failed to open ion driver (%d)", errno); + } + + int i; + for (i = 0; i < NUM_EXT_DISPLAY_BACK_BUFFERS; i++) { + hwc_dev->ion_handles[i] = NULL; + } + + /* use default value in case some of requested display parameters missing */ + hwc_dev->ext.lcd_xpy = 1.0; + if (hwc_dev->fb_dis.timings.x_res && hwc_dev->fb_dis.height_in_mm) { + hwc_dev->ext.lcd_xpy = (float) + hwc_dev->fb_dis.width_in_mm / hwc_dev->fb_dis.timings.x_res / + hwc_dev->fb_dis.height_in_mm * hwc_dev->fb_dis.timings.y_res; + } + + if (hwc_dev->fb_dis.channel == OMAP_DSS_CHANNEL_DIGIT) { + ALOGI("Primary display is HDMI"); + hwc_dev->on_tv = 1; + } else { + hwc_dev->hdmi_fb_fd = open("/dev/graphics/fb1", O_RDWR); + if (hwc_dev->hdmi_fb_fd < 0) { + ALOGE("failed to open hdmi fb (%d)", errno); + err = -errno; + goto done; + } + } + + set_primary_display_transform_matrix(hwc_dev); if (pipe(hwc_dev->pipe_fds) == -1) { ALOGE("failed to event pipe (%d): %m", errno); @@ -2078,7 +2851,6 @@ static int omap4_hwc_device_open(const hw_module_t* module, const char* name, /* get debug properties */ /* see if hwc is enabled at all */ - char value[PROPERTY_VALUE_MAX]; property_get("debug.hwc.rgb_order", value, "1"); hwc_dev->flags_rgb_order = atoi(value); property_get("debug.hwc.nv12_only", value, "0"); @@ -2121,6 +2893,32 @@ static int omap4_hwc_device_open(const hw_module_t* module, const char* name, ALOGI("omap4_hwc_device_open(rgb_order=%d nv12_only=%d)", hwc_dev->flags_rgb_order, hwc_dev->flags_nv12_only); + int gc2d_fd = open("/dev/gcioctl", O_RDWR); + if (gc2d_fd < 0) { + ALOGI("Unable to open gc-core device (%d), blits disabled", errno); + hwc_dev->blt_policy = BLTPOLICY_DISABLED; + } else { + property_get("persist.hwc.bltmode", value, "1"); + hwc_dev->blt_mode = atoi(value); + property_get("persist.hwc.bltpolicy", value, "1"); + hwc_dev->blt_policy = atoi(value); + ALOGI("blitter present, blits mode %d, blits policy %d", hwc_dev->blt_mode, hwc_dev->blt_policy); + close(gc2d_fd); + + if (rgz_get_screengeometry(hwc_dev->fb_fd, &gscrngeom, + hwc_dev->fb_dev->base.format) != 0) { + err = -EINVAL; + goto done; + } + } + + property_get("persist.hwc.upscaled_nv12_limit", value, "2."); + sscanf(value, "%f", &hwc_dev->upscaled_nv12_limit); + if (hwc_dev->upscaled_nv12_limit < 0. || hwc_dev->upscaled_nv12_limit > 2048.) { + ALOGW("Invalid upscaled_nv12_limit (%s), setting to 2.", value); + hwc_dev->upscaled_nv12_limit = 2.; + } + done: if (err && hwc_dev) { if (hwc_dev->dsscomp_fd >= 0) diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c new file mode 100644 index 0000000..96c4374 --- /dev/null +++ b/hwc/rgz_2d.c @@ -0,0 +1,1676 @@ +/* + * 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> + +#ifndef RGZ_TEST_INTEGRATION +#include <cutils/log.h> +#include <cutils/properties.h> +#include <hardware/hwcomposer.h> +#include "hal_public.h" +#else +#include "hwcomposer.h" +#include "buffer_handle.h" +#define ALIGN(x,a) (((x) + (a) - 1L) & ~((a) - 1L)) +#define HW_ALIGN 32 +#endif + +#include "rgz_2d.h" + +#ifdef RGZ_TEST_INTEGRATION +extern void BVDump(const char* prefix, const char* tab, const struct bvbltparams* parms); +#define BVDUMP(p,t,parms) BVDump(p, t, parms) +#define HANDLE_TO_BUFFER(h) handle_to_buffer(h) +#define HANDLE_TO_STRIDE(h) handle_to_stride(h) +#else +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) +#endif +#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 */ +#ifndef RGZ_TEST_INTEGRATION +#define OUTP ALOGI +#define OUTE ALOGE +#else +#define OUTP(...) { printf(__VA_ARGS__); printf("\n"); fflush(stdout); } +#define OUTE OUTP +#define ALOGD_IF(debug, ...) { if (debug) OUTP(__VA_ARGS__); } +#endif + +#define IS_BVCMD(params) (params->op == RGZ_OUT_BVCMD_REGION || params->op == RGZ_OUT_BVCMD_PAINT) + +/* Number of framebuffers to track */ +#define RGZ_NUM_FB 2 + +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_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_t *layer); + +int debug = 0; +struct rgz_blts blts; +/* Represents a screen sized background layer */ +static hwc_layer_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_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_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_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; + unsigned int i; + (void)rgz; + + rgz_blts_init(&blts); + + /* Begin from index 1 to remove the background layer from the output */ + for (i = 1; i < rgz->rgz_layerno; i++) { + rv = rgz_hwc_layer_blit(params, &rgz->rgz_layers[i]); + if (rv) { + OUTE("bvdirect_paint: error in layer %d: %d", i, rv); + dump_all(rgz->rgz_layers, rgz->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_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; +} + +static void rgz_set_dst_data(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); + + /* 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 = screen_geom->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); +} + +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 is_src2) +{ + hwc_layer_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->orientation = rgz_get_orientation(hwc_layer->transform); + srcgeom->virtstride = HANDLE_TO_STRIDE(handle); + if (hwc_layer->transform & HAL_TRANSFORM_ROT_90) + swap(srcgeom->width, srcgeom->height); + + /* 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); +} + +/* + * 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; +} + +/* + * Configure the scaling mode according to the layer format + */ +static void rgz_cfg_scale_mode(struct rgz_blt_entry* e, hwc_layer_t *layer) +{ + /* + * TODO: Revisit scaling mode assignment later, output between GPU and GC320 + * seem different + */ + IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle; + e->bp.scalemode = is_NV12(handle->iFormat) ? 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_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; + + rgz_set_src_data(params, rgz_src1, &tmp_rect, e, 0); + rgz_set_dst_data(params, &tmp_rect, e); + rgz_set_clip_rect(params, subregion_rect, e); + + 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_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; + + rgz_set_src_data(params, rgz_src1, &tmp_rect, e, 0); + rgz_set_dst_data(params, &tmp_rect, e); + rgz_set_clip_rect(params, subregion_rect, e); + + 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_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); + e->bp.flags |= rgz_get_flip_flags(hwc_src2->transform, 1); + rgz_set_src_data(params, rgz_src2, subregion_rect, e, 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_dst_data(params, &clear_rect, e); + rgz_set_clip_rect(params, &clear_rect, e); +} + +static int rgz_out_bvcmd_paint(rgz_t *rgz, rgz_out_params_t *params) +{ + int rv = 0; + params->data.bvc.out_blits = 0; + params->data.bvc.out_nhndls = 0; + rgz_blts_init(&blts); + rgz_out_clrdst(params, NULL); + + unsigned int i, j; + + /* Begin from index 1 to remove the background layer from the output */ + for (i = 1, j = 0; i < rgz->rgz_layerno; i++) { + rgz_layer_t *rgz_layer = &rgz->rgz_layers[i]; + hwc_layer_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(rgz->rgz_layers, rgz->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_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_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; +} + +static int rgz_bswap(int *a, int *b) +{ + if (*a > *b) { + int tmp = *b; + *b = *a; + *a = tmp; + return 1; + } + return 0; +} + +/* + * Simple bubble sort on an array + */ +static void rgz_bsort(int *a, int len) +{ + int i, s; + + do { + s=0; + for (i=0; i+1<len; i++) { + if (rgz_bswap(&a[i], &a[i+1])) + s = 1; + } + } while (s); +} + +/* + * 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 int rgz_hwc_layer_sortbyy(rgz_layer_t *ra, int rsz, int *out, int *width, int screen_height) +{ + int outsz = 0; + int i; + *width = 0; + for (i = 0; i < rsz; i++) { + hwc_layer_t *layer = ra[i].hwc_layer; + /* Maintain regions inside display boundaries */ + int top = layer->displayFrame.top; + int bottom = layer->displayFrame.bottom; + out[outsz++] = max(0, top); + out[outsz++] = min(bottom, screen_height); + int right = layer->displayFrame.right; + *width = *width > right ? *width : right; + } + rgz_bsort(out, outsz); + return outsz; +} + +static int rgz_hwc_intersects(blit_rect_t *a, hwc_rect_t *b) +{ + return ((a->bottom > b->top) && (a->top < b->bottom) && + (a->right > b->left) && (a->left < b->right)); +} + +static void rgz_gen_blitregions(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; + for (l = 0; l < hregion->nlayers; l++) { + hwc_layer_t *layer = hregion->rgz_layers[l]->hwc_layer; + /* Make sure the subregion is not outside the boundaries of the screen */ + int left = layer->displayFrame.left; + int right = layer->displayFrame.right; + offsets[noffsets++] = max(0, left); + offsets[noffsets++] = min(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_t *layer = hregion->rgz_layers[l]->hwc_layer; + if (rgz_hwc_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_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_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 void rgz_handle_dirty_region(rgz_t *rgz, int reset_counters) +{ + unsigned int i; + for (i = 0; i < rgz->rgz_layerno; i++) { + rgz_layer_t *rgz_layer = &rgz->rgz_layers[i]; + void *new_handle; + + /* + * We don't care about the handle for background and layers with the + * clear fb hint, but we want to maintain a layer state for dirty + * region handling. + */ + if (i == 0 || rgz_layer->buffidx == -1) + new_handle = (void*)0x1; + else + new_handle = (void*)rgz_layer->hwc_layer->handle; + + if (reset_counters || new_handle != rgz_layer->dirty_hndl) { + rgz_layer->dirty_count = RGZ_NUM_FB; + rgz_layer->dirty_hndl = new_handle; + } else + rgz_layer->dirty_count -= rgz_layer->dirty_count ? 1 : 0; + + } +} + +static int rgz_in_hwccheck(rgz_in_params_t *p, rgz_t *rgz) +{ + hwc_layer_t *layers = p->data.hwc.layers; + 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++) { + /* + * Workaround: If a NV12 layer is present in the list, don't even try + * to blit. There is a performance degradation while playing video and + * using GC at the same time. + */ + IMG_native_handle_t *handle = (IMG_native_handle_t *)layers[l].handle; + if (!(layers[l].flags & HWC_SKIP_LAYER) && handle && is_NV12(handle->iFormat)) + return -1; + + 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_layer_t *rgz_layer = &rgz->rgz_layers[0]; + rgz_layer->hwc_layer = &bg_layer; + + 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 = &rgz->rgz_layers[possible_blit+1]; + rgz_layer->hwc_layer = &layers[l]; + 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 = &rgz->rgz_layers[possible_blit+1]; + rgz_layer->buffidx = -1; + rgz_layer->hwc_layer = &layers[l]; + possible_blit++; + } + } + } + + if (!possible_blit || possible_blit != candidates) { + return -1; + } + + unsigned int blit_layers = possible_blit + 1; /* Account for background layer */ + int reset_dirty_counters = rgz->rgz_layerno != blit_layers ? 1 : 0; + /* + * The layers we are going to blit differ in number from the previous frame, + * we can't trust anymore the region data, calculate it again + */ + if (reset_dirty_counters) + rgz_delete_region_data(rgz); + + rgz->state |= RGZ_STATE_INIT; + rgz->rgz_layerno = blit_layers; + + rgz_handle_dirty_region(rgz, reset_dirty_counters); + + return RGZ_ALL; +} + +static int rgz_in_hwc(rgz_in_params_t *p, rgz_t *rgz) +{ + int yentries[RGZ_SUBREGIONMAX]; + int dispw; /* widest layer */ + int screen_width = p->data.hwc.dstgeom->width; + int screen_height = p->data.hwc.dstgeom->height; + + if (!(rgz->state & RGZ_STATE_INIT)) { + OUTE("rgz_process started with bad state"); + return -1; + } + + /* If there is already region data avoid parsing it again */ + if (rgz->state & RGZ_REGION_DATA) { + return 0; + } + + int layerno = rgz->rgz_layerno; + + /* Find the horizontal regions */ + rgz_layer_t *rgz_layers = rgz->rgz_layers; + int ylen = rgz_hwc_layer_sortbyy(rgz_layers, layerno, yentries, &dispw, screen_height); + + 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), layerno); + int i, j; + 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 < layerno; j++) { + hwc_layer_t *layer = rgz_layers[j].hwc_layer; + if (rgz_hwc_intersects(&hregions[i].rect, &layer->displayFrame)) { + int l = hregions[i].nlayers++; + hregions[i].rgz_layers[l] = &rgz_layers[j]; + } + } + } + + /* Calculate blit regions */ + for (i = 0; i < rgz->nhregions; i++) { + rgz_gen_blitregions(&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_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_layer_list_t* list, int csv) +{ + size_t i; + for (i = 0; i < list->numHwLayers; i++) { + hwc_layer_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; + } +} + +/* + * The loadbltsville fn is only needed for testing, the bltsville shared + * libraries aren't planned to be used directly in production code here + */ +static BVFN_MAP bv_map; +static BVFN_BLT bv_blt; +static BVFN_UNMAP bv_unmap; +#ifndef RGZ_TEST_INTEGRATION +gralloc_module_t const *gralloc; +#endif +#define BLTSVILLELIB "libbltsville_cpu.so" + +#ifdef RGZ_TEST_INTEGRATION +static int loadbltsville(void) +{ + void *hndl = dlopen(BLTSVILLELIB, RTLD_LOCAL | RTLD_LAZY); + if (!hndl) { + OUTE("Loading bltsville failed"); + return -1; + } + bv_map = (BVFN_MAP)dlsym(hndl, "bv_map"); + bv_blt = (BVFN_BLT)dlsym(hndl, "bv_blt"); + bv_unmap = (BVFN_UNMAP)dlsym(hndl, "bv_unmap"); + if(!bv_blt || !bv_map || !bv_unmap) { + OUTE("Missing bltsville fn %p %p %p", bv_map, bv_blt, bv_unmap); + return -1; + } + OUTP("Loaded %s", BLTSVILLELIB); + +#ifndef RGZ_TEST_INTEGRATION + hw_module_t const* module; + int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module); + if (err != 0) { + OUTE("Loading gralloc failed"); + return -1; + } + gralloc = (gralloc_module_t const *)module; +#endif + return 0; +} +#else +static int loadbltsville(void) { + return 0; +} +#endif + +#ifndef RGZ_TEST_INTEGRATION +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; +} + +#endif + +extern void BVDump(const char* prefix, const char* tab, const struct bvbltparams* parms); + +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) +{ + static int loaded = 0; + if (!loaded) + loaded = loadbltsville() ? : 1; /* attempt load once */ + + hwc_layer_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; +} + +/* + * Calculate the src rectangle on the basis of the layer display, source crop + * and subregion rectangles. Additionally any rotation will be taken in + * account. The resulting rectangle is written in res_rect. + */ +static void rgz_get_src_rect(hwc_layer_t* layer, blit_rect_t *subregion_rect, blit_rect_t *res_rect) +{ + IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle; + int res_left = 0; + int res_top = 0; + int delta_left; + int delta_top; + int res_width; + int res_height; + + /* + * 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. If there is a transform, adjust the width and height + * accordingly to match the rotated buffer geometry. + */ + if (rgz_hwc_scaled(layer)) { + delta_top = 0; + delta_left = 0; + res_width = WIDTH(layer->sourceCrop); + res_height = HEIGHT(layer->sourceCrop); + if (layer->transform & HAL_TRANSFORM_ROT_90) + swap(res_width , res_height); + } else { + delta_top = subregion_rect->top - layer->displayFrame.top; + delta_left = subregion_rect->left - layer->displayFrame.left; + res_width = WIDTH(*subregion_rect); + res_height = HEIGHT(*subregion_rect); + } + + /* + * Calculate the top, left offset from the source cropping rectangle + * depending on the rotation + */ + switch(layer->transform) { + case 0: + res_left = layer->sourceCrop.left + delta_left; + res_top = layer->sourceCrop.top + delta_top; + break; + case HAL_TRANSFORM_ROT_90: + res_left = handle->iHeight - layer->sourceCrop.bottom + delta_left; + res_top = layer->sourceCrop.left + delta_top; + break; + case HAL_TRANSFORM_ROT_180: + res_left = handle->iWidth - layer->sourceCrop.right + delta_left; + res_top = handle->iHeight - layer->sourceCrop.bottom + delta_top; + break; + case HAL_TRANSFORM_ROT_270: + res_left = layer->sourceCrop.top + delta_left; + res_top = handle->iWidth - layer->sourceCrop.right + delta_top; + break; + default: + OUTE("Invalid transform value %d", layer->transform); + } + + /* Resulting rectangle has the subregion dimensions */ + res_rect->left = res_left; + res_rect->top = res_top; + res_rect->right = res_left + res_width; + res_rect->bottom = res_top + res_height; +} + +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) +{ + static int loaded = 0; + if (!loaded) + loaded = loadbltsville() ? : 1; /* attempt load once */ + + 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, 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]->hwc_layer == &bg_layer) { + 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 == -1) { + 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 first_batchflags = 0; + if (!rgz_hwc_scaled(hregion->rgz_layers[lix]->hwc_layer) && + !rgz_hwc_scaled(hregion->rgz_layers[s2lix]->hwc_layer)) { + e = rgz_hwc_subregion_blend(params, rect, hregion->rgz_layers[lix], + hregion->rgz_layers[s2lix]); + first_batchflags |= BVBATCH_SRC2; + } else { + /* Return index to the first operation and make a copy of the first layer */ + lix = s2lix; + e = rgz_hwc_subregion_copy(params, rect, hregion->rgz_layers[lix]); + first_batchflags |= BVBATCH_OP | BVBATCH_SRC2; + } + rgz_batch_entry(e, BVFLAG_BATCH_BEGIN, 0); + + /* Rest of layers blended with FB */ + int first = 1; + while((lix = get_layer_ops_next(hregion, sidx, lix)) != -1) { + int batchflags = 0; + e = rgz_hwc_subregion_blend(params, rect, hregion->rgz_layers[lix], NULL); + if (first) { + first = 0; + batchflags |= first_batchflags; + } + /* + * TODO: This will work when scaling is introduced, however we need + * to think on a better way to optimize this. + */ + batchflags |= BVBATCH_SRC1 | BVBATCH_SRC1RECT_ORIGIN| BVBATCH_SRC1RECT_SIZE | + BVBATCH_DSTRECT_ORIGIN | BVBATCH_DSTRECT_SIZE | BVBATCH_SRC2RECT_ORIGIN | + BVBATCH_SRC2RECT_SIZE | BVBATCH_SCALE; + 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)) + return -1; + } + } + + int rv = 0; + + if (IS_BVCMD(params)) { + unsigned int j; + params->data.bvc.out_nhndls = 0; + /* Begin from index 1 to remove the background layer from the output */ + for (j = 1, i = 0; j < rgz->rgz_layerno; j++) { + rgz_layer_t *rgz_layer = &rgz->rgz_layers[j]; + /* We don't need the handles for layers marked as -1 */ + if (rgz_layer->buffidx == -1) + continue; + hwc_layer_t *layer = rgz_layer->hwc_layer; + params->data.bvc.out_hndls[i++] = 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_layer_list_t* list, int dispw, int disph) +{ + if (!list) /* A NULL composition list can occur */ + return; + +#ifndef RGZ_TEST_INTEGRATION + 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); +#else + char regiondump[] = ""; + int dumplayers = 1; + int dumpregions = 0; +#endif + 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); + /* Always set to 0, src buffers will contain rotation values as needed */ + 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; + } +} + diff --git a/hwc/rgz_2d.h b/hwc/rgz_2d.h new file mode 100644 index 0000000..44867b8 --- /dev/null +++ b/hwc/rgz_2d.h @@ -0,0 +1,290 @@ +/* + * 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. + */ +#define RGZ_INPUT_MAXLAYERS (RGZ_MAXLAYERS - 1) + +/* + * 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_t *layers; + struct bvsurfgeom *dstgeom; +}; + +typedef struct rgz_in_params { + int op; /* See RGZ_IN_* */ + union { + struct rgz_in_hwc hwc; + } data; +} rgz_in_params_t; + +/* + * 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_layer_list_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_t *hwc_layer; + int buffidx; + int dirty_count; + void* dirty_hndl; +} rgz_layer_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; + unsigned int rgz_layerno; + rgz_layer_t rgz_layers[RGZ_MAXLAYERS]; +}; + +#endif /* __RGZ_2D__ */ |