diff options
author | codeworkx <daniel.hillenbrand@codeworkx.de> | 2012-05-20 12:00:36 +0200 |
---|---|---|
committer | codeworkx <daniel.hillenbrand@codeworkx.de> | 2012-05-20 12:00:36 +0200 |
commit | 62f02ba4f4b7b561aa15408ebd9951600bdd71aa (patch) | |
tree | ac05dc645945a58edbc26e96df1a78ac16f27706 /exynos4/hal/libhwcomposer/SecHWC.cpp | |
parent | e54debb12ecdf92d12acab00a261c0c5a6ef1d64 (diff) | |
download | android_hardware_samsung-62f02ba4f4b7b561aa15408ebd9951600bdd71aa.tar.gz android_hardware_samsung-62f02ba4f4b7b561aa15408ebd9951600bdd71aa.tar.bz2 android_hardware_samsung-62f02ba4f4b7b561aa15408ebd9951600bdd71aa.zip |
exynos: reorganized and updated from insignal
Changes needed on exynos4210 devices:
libcsc -> libseccscapi
libswconverter -> remove
TARGET_HAL_PATH := hardware/samsung/exynos4/hal
TARGET_OMX_PATH := hardware/samsung/exynos/multimedia/openmax
$(call inherit-product, hardware/samsung/exynos4210.mk)
Change-Id: Ic59ef95b85ef37b3f38fb36cf6a364a5414685ee
Diffstat (limited to 'exynos4/hal/libhwcomposer/SecHWC.cpp')
-rw-r--r-- | exynos4/hal/libhwcomposer/SecHWC.cpp | 957 |
1 files changed, 957 insertions, 0 deletions
diff --git a/exynos4/hal/libhwcomposer/SecHWC.cpp b/exynos4/hal/libhwcomposer/SecHWC.cpp new file mode 100644 index 0000000..d2f3ecc --- /dev/null +++ b/exynos4/hal/libhwcomposer/SecHWC.cpp @@ -0,0 +1,957 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * 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. + */ + +/* + * + * @author Rama, Meka(v.meka@samsung.com) + Sangwoo, Park(sw5771.park@samsung.com) + Jamie Oh (jung-min.oh@samsung.com) + * @date 2011-03-11 + * + */ + +#include <cutils/log.h> +#include <cutils/atomic.h> + +#include <EGL/egl.h> + +#include "SecHWCUtils.h" + +#include "gralloc_priv.h" +#ifdef HWC_HWOVERLAY +#include <GLES/gl.h> +#endif +#if defined(BOARD_USES_HDMI) +#include "SecHdmiClient.h" +#include "SecTVOutService.h" + +#include "SecHdmi.h" + +//#define CHECK_EGL_FPS +#ifdef CHECK_EGL_FPS +extern void check_fps(); +#endif + +static int lcd_width, lcd_height; +static int prev_usage = 0; + +#define CHECK_TIME_DEBUG 0 +#define SUPPORT_AUTO_UI_ROTATE +#endif +int testRenderNum =0; + +static int hwc_device_open(const struct hw_module_t* module, const char* name, + struct hw_device_t** device); + +static struct hw_module_methods_t hwc_module_methods = { + open: hwc_device_open +}; + +hwc_module_t HAL_MODULE_INFO_SYM = { + common: { + tag: HARDWARE_MODULE_TAG, + version_major: 1, + version_minor: 0, + id: HWC_HARDWARE_MODULE_ID, + name: "Samsung S5PC21X hwcomposer module", + author: "SAMSUNG", + methods: &hwc_module_methods, + } +}; + +/*****************************************************************************/ + +static void dump_layer(hwc_layer_t const* l) { + LOGD("\ttype=%d, flags=%08x, handle=%p, tr=%02x, blend=%04x, " + "{%d,%d,%d,%d}, {%d,%d,%d,%d}", + 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); +} + +void calculate_rect(struct hwc_win_info_t *win, hwc_layer_t *cur, + sec_rect *rect) +{ + rect->x = cur->displayFrame.left; + rect->y = cur->displayFrame.top; + rect->w = cur->displayFrame.right - cur->displayFrame.left; + rect->h = cur->displayFrame.bottom - cur->displayFrame.top; + + if (rect->x < 0) { + if (rect->w + rect->x > win->lcd_info.xres) + rect->w = win->lcd_info.xres; + else + rect->w = rect->w + rect->x; + rect->x = 0; + } else { + if (rect->w + rect->x > win->lcd_info.xres) + rect->w = win->lcd_info.xres - rect->x; + } + if (rect->y < 0) { + if (rect->h + rect->y > win->lcd_info.yres) + rect->h = win->lcd_info.yres; + else + rect->h = rect->h + rect->y; + rect->y = 0; + } else { + if (rect->h + rect->y > win->lcd_info.yres) + rect->h = win->lcd_info.yres - rect->y; + } +} + +static int set_src_dst_img_rect(hwc_layer_t *cur, + struct hwc_win_info_t *win, + struct sec_img *src_img, + struct sec_img *dst_img, + struct sec_rect *src_rect, + struct sec_rect *dst_rect, + int win_idx) +{ + private_handle_t *prev_handle = (private_handle_t *)(cur->handle); + sec_rect rect; + + /* 1. Set src_img from prev_handle */ + src_img->f_w = prev_handle->width; + src_img->f_h = prev_handle->height; + src_img->w = prev_handle->width; + src_img->h = prev_handle->height; + src_img->format = prev_handle->format; + src_img->base = (uint32_t)prev_handle->base; + src_img->offset = prev_handle->offset; + src_img->mem_id = prev_handle->fd; + src_img->paddr = prev_handle->paddr; + src_img->usage = prev_handle->usage; + src_img->uoffset = prev_handle->uoffset; + src_img->voffset = prev_handle->voffset; + + src_img->mem_type = HWC_VIRT_MEM_TYPE; + + switch (src_img->format) { + case HAL_PIXEL_FORMAT_YV12: /* To support video editor */ + case HAL_PIXEL_FORMAT_YCbCr_420_P: /* To support SW codec */ + case HAL_PIXEL_FORMAT_YCrCb_420_SP: + case HAL_PIXEL_FORMAT_YCbCr_420_SP: + case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP: + case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP: + case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED: + case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_422_SP: + case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_422_SP: + case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_422_I: + case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_422_I: + case HAL_PIXEL_FORMAT_CUSTOM_CbYCrY_422_I: + case HAL_PIXEL_FORMAT_CUSTOM_CrYCbY_422_I: + src_img->f_w = (src_img->f_w + 15) & ~15; + src_img->f_h = (src_img->f_h + 1) & ~1; + break; + default: + src_img->f_w = src_img->w; + src_img->f_h = src_img->h; + break; + } + + /* 2. Set dst_img from window(lcd) */ + calculate_rect(win, cur, &rect); + dst_img->f_w = win->lcd_info.xres; + dst_img->f_h = win->lcd_info.yres; + dst_img->w = rect.w; + dst_img->h = rect.h; + + switch (win->lcd_info.bits_per_pixel) { + case 32: + dst_img->format = HAL_PIXEL_FORMAT_RGBX_8888; + break; + default: + dst_img->format = HAL_PIXEL_FORMAT_RGB_565; + break; + } + + dst_img->base = win->addr[win->buf_index]; + dst_img->offset = 0; + dst_img->mem_id = 0; + dst_img->mem_type = HWC_PHYS_MEM_TYPE; + + /* 3. Set src_rect(crop rect) */ + if (cur->displayFrame.left < 0) { + src_rect->x = + (0 - cur->displayFrame.left) + *(src_img->w) + /(cur->displayFrame.right - cur->displayFrame.left + 1); + if (cur->displayFrame.right + 1 > win->lcd_info.xres) { + src_rect->w = + (cur->sourceCrop.right - cur->sourceCrop.left + 1) - + src_rect->x - + (cur->displayFrame.right - win->lcd_info.xres) + *(src_img->w) + /(cur->displayFrame.right - cur->displayFrame.left + 1); + } else { + src_rect->w = + (cur->sourceCrop.right - cur->sourceCrop.left + 1) - + src_rect->x; + } + } else { + src_rect->x = cur->sourceCrop.left; + if (cur->displayFrame.right + 1 > win->lcd_info.xres) { + src_rect->w = + (cur->sourceCrop.right - cur->sourceCrop.left + 1) - + src_rect->x - + (cur->displayFrame.right - win->lcd_info.xres) + *(src_img->w) + /(cur->displayFrame.right - cur->displayFrame.left + 1); + } else { + src_rect->w = + (cur->sourceCrop.right - cur->sourceCrop.left + 1); + } + } + if (cur->displayFrame.top < 0) { + src_rect->y = + (0 - cur->displayFrame.top) + *(src_img->h) + /(cur->displayFrame.bottom - cur->displayFrame.top + 1); + if (cur->displayFrame.bottom + 1 > win->lcd_info.yres) { + src_rect->h = + (cur->sourceCrop.bottom - cur->sourceCrop.top + 1) - + src_rect->y - + (cur->displayFrame.bottom - win->lcd_info.yres) + *(src_img->h) + /(cur->displayFrame.bottom - cur->displayFrame.top + 1); + } else { + src_rect->h = + (cur->sourceCrop.bottom - cur->sourceCrop.top + 1) - + src_rect->y; + } + } else { + src_rect->y = cur->sourceCrop.top; + if (cur->displayFrame.bottom + 1 > win->lcd_info.yres) { + src_rect->h = + (cur->sourceCrop.bottom - cur->sourceCrop.top + 1) - + src_rect->y - + (cur->displayFrame.bottom - win->lcd_info.yres) + *(src_img->h) + /(cur->displayFrame.bottom - cur->displayFrame.top + 1); + } else { + src_rect->h = + (cur->sourceCrop.bottom - cur->sourceCrop.top + 1); + } + } + + SEC_HWC_Log(HWC_LOG_DEBUG, + "crop information()::" + "sourceCrop left(%d),top(%d),right(%d),bottom(%d)," + "src_rect x(%d),y(%d),w(%d),h(%d)," + "prev_handle w(%d),h(%d)", + cur->sourceCrop.left, + cur->sourceCrop.top, + cur->sourceCrop.right, + cur->sourceCrop.bottom, + src_rect->x, src_rect->y, src_rect->w, src_rect->h, + prev_handle->width, prev_handle->height); + + src_rect->x = SEC_MAX(src_rect->x, 0); + src_rect->y = SEC_MAX(src_rect->y, 0); + src_rect->w = SEC_MAX(src_rect->w, 0); + src_rect->w = SEC_MIN(src_rect->w, prev_handle->width); + src_rect->h = SEC_MAX(src_rect->h, 0); + src_rect->h = SEC_MIN(src_rect->h, prev_handle->height); + + /* 4. Set dst_rect(fb or lcd) + * fimc dst image will be stored from left top corner + */ + dst_rect->x = 0; + dst_rect->y = 0; + dst_rect->w = win->rect_info.w; + dst_rect->h = win->rect_info.h; + + /* Summery */ + SEC_HWC_Log(HWC_LOG_DEBUG, + "set_src_dst_img_rect()::" + "SRC w(%d),h(%d),f_w(%d),f_h(%d),fmt(0x%x)," + "base(0x%x),offset(%d),paddr(0x%X),mem_id(%d),mem_type(%d)=>\r\n" + " DST w(%d),h(%d),f(0x%x),base(0x%x)," + "offset(%d),mem_id(%d),mem_type(%d)," + "rot(%d),win_idx(%d)" + " SRC_RECT x(%d),y(%d),w(%d),h(%d)=>" + "DST_RECT x(%d),y(%d),w(%d),h(%d)", + src_img->w, src_img->h, src_img->f_w, src_img->f_h, src_img->format, + src_img->base, src_img->offset, src_img->paddr, src_img->mem_id, src_img->mem_type, + dst_img->w, dst_img->h, dst_img->format, dst_img->base, + dst_img->offset, dst_img->mem_id, dst_img->mem_type, + cur->transform, win_idx, + src_rect->x, src_rect->y, src_rect->w, src_rect->h, + dst_rect->x, dst_rect->y, dst_rect->w, dst_rect->h); + + return 0; +} + +static int get_hwc_compos_decision(hwc_layer_t* cur, int iter, int win_cnt) +{ + if(cur->flags & HWC_SKIP_LAYER || !cur->handle) { + SEC_HWC_Log(HWC_LOG_DEBUG, "%s::is_skip_layer %d cur->handle %x ", + __func__, cur->flags & HWC_SKIP_LAYER, cur->handle); + + return HWC_FRAMEBUFFER; + } + + private_handle_t *prev_handle = (private_handle_t *)(cur->handle); + int compositionType = HWC_FRAMEBUFFER; + + if (iter == 0) { + /* check here....if we have any resolution constraints */ + if (((cur->sourceCrop.right - cur->sourceCrop.left + 1) < 16) || + ((cur->sourceCrop.bottom - cur->sourceCrop.top + 1) < 8)) + return compositionType; + + if ((cur->transform == HAL_TRANSFORM_ROT_90) || + (cur->transform == HAL_TRANSFORM_ROT_270)) { + if (((cur->displayFrame.right - cur->displayFrame.left + 1) < 4) || + ((cur->displayFrame.bottom - cur->displayFrame.top + 1) < 8)) + return compositionType; + } else if (((cur->displayFrame.right - cur->displayFrame.left + 1) < 8) || + ((cur->displayFrame.bottom - cur->displayFrame.top + 1) < 4)) { + return compositionType; + } + + switch (prev_handle->format) { + case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP: + case HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP: + case HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED: + compositionType = HWC_OVERLAY; + break; + case HAL_PIXEL_FORMAT_YV12: /* YCrCb_420_P */ + case HAL_PIXEL_FORMAT_YCbCr_420_P: + case HAL_PIXEL_FORMAT_YCrCb_420_SP: + case HAL_PIXEL_FORMAT_YCbCr_420_SP: + if ((prev_handle->usage & GRALLOC_USAGE_HWC_HWOVERLAY) && + (cur->blending == HWC_BLENDING_NONE)) + compositionType = HWC_OVERLAY; + else + compositionType = HWC_FRAMEBUFFER; + break; + default: + compositionType = HWC_FRAMEBUFFER; + break; + } + } + +#ifdef SUB_TITLES_HWC + else if ((win_cnt > 0) && + (prev_handle->usage & GRALLOC_USAGE_EXTERNAL_DISP)) { + switch (prev_handle->format) { + case HAL_PIXEL_FORMAT_RGBA_8888: + case HAL_PIXEL_FORMAT_RGBX_8888: + case HAL_PIXEL_FORMAT_BGRA_8888: + case HAL_PIXEL_FORMAT_RGB_888: + case HAL_PIXEL_FORMAT_RGB_565: + case HAL_PIXEL_FORMAT_RGBA_5551: + case HAL_PIXEL_FORMAT_RGBA_4444: + compositionType = HWC_OVERLAY; + break; + default: + compositionType = HWC_FRAMEBUFFER; + break; + } + + SEC_HWC_Log(HWC_LOG_DEBUG, "2nd iter###%s:: compositionType %d bpp %d" + " format %x src[%d %d %d %d] dst[%d %d %d %d] srcImg[%d %d]", + __func__, compositionType, prev_handle->bpp, + prev_handle->format, + cur->sourceCrop.left, cur->sourceCrop.right, + cur->sourceCrop.top, cur->sourceCrop.bottom, + cur->displayFrame.left, cur->displayFrame.right, + cur->displayFrame.top, cur->displayFrame.bottom, + prev_handle->width, prev_handle->height); + } +#endif + + SEC_HWC_Log(HWC_LOG_DEBUG, + "%s::compositionType(%d)=>0:FB,1:OVERLAY \r\n" + " format(0x%x),magic(0x%x),flags(%d),size(%d),offset(%d)" + "b_addr(0x%x),usage(%d),w(%d),h(%d),bpp(%d)", + "get_hwc_compos_decision()", compositionType, + prev_handle->format, prev_handle->magic, prev_handle->flags, + prev_handle->size, prev_handle->offset, prev_handle->base, + prev_handle->usage, prev_handle->width, prev_handle->height, + prev_handle->bpp); + + return compositionType; +} + +static void reset_win_rect_info(hwc_win_info_t *win) +{ + win->rect_info.x = 0; + win->rect_info.y = 0; + win->rect_info.w = 0; + win->rect_info.h = 0; + return; +} + + +static int assign_overlay_window(struct hwc_context_t *ctx, hwc_layer_t *cur, + int win_idx, int layer_idx) +{ + struct hwc_win_info_t *win; + sec_rect rect; + int ret = 0; + + if (NUM_OF_WIN <= win_idx) + return -1; + + win = &ctx->win[win_idx]; + + SEC_HWC_Log(HWC_LOG_DEBUG, + "%s:: left(%d),top(%d),right(%d),bottom(%d),transform(%d)" + "lcd_info.xres(%d),lcd_info.yres(%d)", + "++assign_overlay_window()", + cur->displayFrame.left, cur->displayFrame.top, + cur->displayFrame.right, cur->displayFrame.bottom, cur->transform, + win->lcd_info.xres, win->lcd_info.yres); + + calculate_rect(win, cur, &rect); + + if ((rect.x != win->rect_info.x) || (rect.y != win->rect_info.y) || + (rect.w != win->rect_info.w) || (rect.h != win->rect_info.h)){ + win->rect_info.x = rect.x; + win->rect_info.y = rect.y; + win->rect_info.w = rect.w; + win->rect_info.h = rect.h; + //turnoff the window and set the window position with new conf... + if (window_set_pos(win) < 0) { + SEC_HWC_Log(HWC_LOG_ERROR, "%s::window_set_pos is failed : %s", + __func__, strerror(errno)); + ret = -1; + } + ctx->layer_prev_buf[win_idx] = 0; + } + + win->layer_index = layer_idx; + win->status = HWC_WIN_RESERVED; + + SEC_HWC_Log(HWC_LOG_DEBUG, + "%s:: win_x %d win_y %d win_w %d win_h %d lay_idx %d win_idx %d\n", + "--assign_overlay_window()", + win->rect_info.x, win->rect_info.y, win->rect_info.w, + win->rect_info.h, win->layer_index, win_idx ); + + return 0; +} + +static int hwc_prepare(hwc_composer_device_t *dev, hwc_layer_list_t* list) +{ + struct hwc_context_t* ctx = (struct hwc_context_t*)dev; + int overlay_win_cnt = 0; + int compositionType = 0; + int ret; + + //if geometry is not changed, there is no need to do any work here + if (!list || (!(list->flags & HWC_GEOMETRY_CHANGED))) + return 0; + + //all the windows are free here.... + for (int i = 0 ; i < NUM_OF_WIN; i++) { + ctx->win[i].status = HWC_WIN_FREE; + ctx->win[i].buf_index = 0; + } + + ctx->num_of_hwc_layer = 0; + ctx->num_of_fb_layer = 0; + ctx->num_2d_blit_layer = 0; + + for (int i = 0; i < list->numHwLayers ; i++) { + hwc_layer_t* cur = &list->hwLayers[i]; + + if (overlay_win_cnt < NUM_OF_WIN) { + compositionType = get_hwc_compos_decision(cur, 0, overlay_win_cnt); + + if (compositionType == HWC_FRAMEBUFFER) { + cur->compositionType = HWC_FRAMEBUFFER; + ctx->num_of_fb_layer++; + } else { + ret = assign_overlay_window(ctx, cur, overlay_win_cnt, i); + if (ret != 0) { + LOGE("assign_overlay_window fail, change to frambuffer"); + cur->compositionType = HWC_FRAMEBUFFER; + ctx->num_of_fb_layer++; + continue; + } + + cur->compositionType = HWC_OVERLAY; + cur->hints = HWC_HINT_CLEAR_FB; + overlay_win_cnt++; + ctx->num_of_hwc_layer++; + } + } else { + cur->compositionType = HWC_FRAMEBUFFER; + ctx->num_of_fb_layer++; + } + } + +#ifdef SUB_TITLES_HWC + for (int i = 0; i < list->numHwLayers ; i++) { + if (overlay_win_cnt < NUM_OF_WIN) { + hwc_layer_t* cur = &list->hwLayers[i]; + if (get_hwc_compos_decision(cur, 1, overlay_win_cnt) == HWC_OVERLAY) { + ret = assign_overlay_window(ctx, cur, overlay_win_cnt, i); + if (ret == 0) { + cur->compositionType = HWC_OVERLAY; + cur->hints = HWC_HINT_CLEAR_FB; + overlay_win_cnt++; + ctx->num_of_hwc_layer++; + ctx->num_of_fb_layer--; + ctx->num_2d_blit_layer = 1; + } + } + } + else + break; + } +#endif + +#if defined(BOARD_USES_HDMI) + android::SecHdmiClient *mHdmiClient = android::SecHdmiClient::getInstance(); + mHdmiClient->setHdmiHwcLayer(ctx->num_of_hwc_layer); +#endif + + if (list->numHwLayers != (ctx->num_of_fb_layer + ctx->num_of_hwc_layer)) + SEC_HWC_Log(HWC_LOG_DEBUG, + "%s:: numHwLayers %d num_of_fb_layer %d num_of_hwc_layer %d ", + __func__, list->numHwLayers, ctx->num_of_fb_layer, + ctx->num_of_hwc_layer); + + if (overlay_win_cnt < NUM_OF_WIN) { + //turn off the free windows + for (int i = overlay_win_cnt; i < NUM_OF_WIN; i++) { + window_hide(&ctx->win[i]); + reset_win_rect_info(&ctx->win[i]); + } + } + + return 0; +} + +static int hwc_set(hwc_composer_device_t *dev, + hwc_display_t dpy, + hwc_surface_t sur, + hwc_layer_list_t* list) +{ + struct hwc_context_t *ctx = (struct hwc_context_t *)dev; + int skipped_window_mask = 0; + hwc_layer_t* cur; + struct hwc_win_info_t *win; + int ret; + int pmem_phyaddr; + static int egl_check; + int egl_run = 0; + struct sec_img src_img; + struct sec_img dst_img; + struct sec_rect src_work_rect; + struct sec_rect dst_work_rect; + + memset(&src_img, 0, sizeof(src_img)); + memset(&dst_img, 0, sizeof(dst_img)); + memset(&src_work_rect, 0, sizeof(src_work_rect)); + memset(&dst_work_rect, 0, sizeof(dst_work_rect)); + +#if defined(BOARD_USES_HDMI) + int skip_hdmi_rendering = 0; + int rotVal = 0; +#endif + + if (!list) { + //turn off the all windows + for (int i = 0; i < NUM_OF_WIN; i++) { + window_hide(&ctx->win[i]); + reset_win_rect_info(&ctx->win[i]); + ctx->win[i].status = HWC_WIN_FREE; + } + ctx->num_of_hwc_layer = 0; + + if (sur == NULL && dpy == NULL) + return HWC_EGL_ERROR; + } + + if(ctx->num_of_hwc_layer > NUM_OF_WIN) + ctx->num_of_hwc_layer = NUM_OF_WIN; + + //compose hardware layers here + for (int i = 0; i < ctx->num_of_hwc_layer - ctx->num_2d_blit_layer; i++) { + win = &ctx->win[i]; + if (win->status == HWC_WIN_RESERVED) { + cur = &list->hwLayers[win->layer_index]; + + if (cur->compositionType == HWC_OVERLAY) { + if (ctx->layer_prev_buf[i] == (uint32_t)cur->handle) { + /* + * In android platform, all the graphic buffer are at least + * double buffered (2 or more) this buffer is already rendered. + * It is the redundant src buffer for FIMC rendering. + */ + LOGD("SKIP FIMC rendering for Layer%d", win->layer_index); +#if defined(BOARD_USES_HDMI) + skip_hdmi_rendering = 1; +#endif + continue; + } + ctx->layer_prev_buf[i] = (uint32_t)cur->handle; + // initialize the src & dist context for fimc + set_src_dst_img_rect(cur, win, &src_img, &dst_img, + &src_work_rect, &dst_work_rect, i); + + ret = runFimc(ctx, + &src_img, &src_work_rect, + &dst_img, &dst_work_rect, + cur->transform); + + if (ret < 0) { + SEC_HWC_Log(HWC_LOG_ERROR, "%s::runFimc fail : ret=%d\n", + __func__, ret); + skipped_window_mask |= (1 << i); + continue; + } + + window_pan_display(win); + + win->buf_index = (win->buf_index + 1) % NUM_OF_WIN_BUF; + if (win->power_state == 0) + window_show(win); + } else { + SEC_HWC_Log(HWC_LOG_ERROR, + "%s:: error : layer %d compositionType should have been" + " HWC_OVERLAY ", __func__, win->layer_index); + skipped_window_mask |= (1 << i); + continue; + } + } else { + SEC_HWC_Log(HWC_LOG_ERROR, "%s:: error : window status should have " + "been HWC_WIN_RESERVED by now... ", __func__); + skipped_window_mask |= (1 << i); + continue; + } + } + +#ifdef SUB_TITLES_HWC + if (ctx->num_2d_blit_layer) { + g2d_rect srcRect; + g2d_rect dstRect; + + win = &ctx->win[ctx->num_of_hwc_layer - 1]; + cur = &list->hwLayers[win->layer_index]; + set_src_dst_g2d_rect(cur, win, &srcRect, &dstRect); + ret = runG2d(ctx, &srcRect, &dstRect, + cur->transform); + if (ret < 0) { + SEC_HWC_Log(HWC_LOG_ERROR, "%s::runG2d fail : ret=%d\n", + __func__, ret); + skipped_window_mask |= (1 << (ctx->num_of_hwc_layer - 1)); + goto g2d_error; + } + + window_pan_display(win); + + win->buf_index = (win->buf_index + 1) % NUM_OF_WIN_BUF; + if (win->power_state == 0) + window_show(win); + } + +g2d_error: +#endif + + if (skipped_window_mask) { + //turn off the free windows + for (int i = 0; i < NUM_OF_WIN; i++) { + if (skipped_window_mask & (1 << i)) { + window_hide(&ctx->win[i]); + reset_win_rect_info(&ctx->win[i]); + } + } + } + + if (0 < ctx->num_of_fb_layer) { +#ifdef CHECK_EGL_FPS + check_fps(); +#endif +#ifdef HWC_HWOVERLAY + unsigned char pixels[4]; + glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixels); +#endif + egl_check = 1; + egl_run = 1; + } else { + if (egl_check == 1) { + egl_check = 0; + egl_run = 1; + } + } + + if (egl_run == 1) { + EGLBoolean sucess = eglSwapBuffers((EGLDisplay)dpy, (EGLSurface)sur); + if (!sucess) + return HWC_EGL_ERROR; + } + +#if defined(BOARD_USES_HDMI) + android::SecHdmiClient *mHdmiClient = android::SecHdmiClient::getInstance(); + + if (skip_hdmi_rendering == 1) + return 0; + + if (list == NULL) { + // Don't display unnecessary image + mHdmiClient->setHdmiEnable(0); + return 0; + } else { + mHdmiClient->setHdmiEnable(1); + } + +#ifdef SUPPORT_AUTO_UI_ROTATE + cur = &list->hwLayers[0]; + + if (cur->transform == HAL_TRANSFORM_ROT_90 || cur->transform == HAL_TRANSFORM_ROT_270) + mHdmiClient->setHdmiRotate(270, ctx->num_of_hwc_layer); + else + mHdmiClient->setHdmiRotate(0, ctx->num_of_hwc_layer); +#endif + + // To support S3D video playback (automatic TV mode change to 3D mode) + if (ctx->num_of_hwc_layer == 1) { + if (src_img.usage != prev_usage) + mHdmiClient->setHdmiResolution(DEFAULT_HDMI_RESOLUTION_VALUE); // V4L2_STD_1080P_60 + + if ((src_img.usage & GRALLOC_USAGE_PRIVATE_SBS_LR) || + (src_img.usage & GRALLOC_USAGE_PRIVATE_SBS_RL)) + mHdmiClient->setHdmiResolution(7209601); // V4L2_STD_TVOUT_720P_60_SBS_HALF + else if ((src_img.usage & GRALLOC_USAGE_PRIVATE_TB_LR) || + (src_img.usage & GRALLOC_USAGE_PRIVATE_TB_RL)) + mHdmiClient->setHdmiResolution(1080924); // V4L2_STD_TVOUT_1080P_24_TB + + prev_usage = src_img.usage; + } else { + if ((prev_usage & GRALLOC_USAGE_PRIVATE_SBS_LR) || + (prev_usage & GRALLOC_USAGE_PRIVATE_SBS_RL) || + (prev_usage & GRALLOC_USAGE_PRIVATE_TB_LR) || + (prev_usage & GRALLOC_USAGE_PRIVATE_TB_RL)) + mHdmiClient->setHdmiResolution(DEFAULT_HDMI_RESOLUTION_VALUE); // V4L2_STD_1080P_60 + + prev_usage = 0; + } + + if (ctx->num_of_hwc_layer == 1) { + if ((src_img.format == HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED)|| + (src_img.format == HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP)) { + ADDRS * addr = (ADDRS *)(src_img.base); + + mHdmiClient->blit2Hdmi(src_img.w, src_img.h, + src_img.format, + (unsigned int)addr->addr_y, (unsigned int)addr->addr_cbcr, (unsigned int)addr->addr_cbcr, + 0, 0, + android::SecHdmiClient::HDMI_MODE_VIDEO, + ctx->num_of_hwc_layer); + } else if ((src_img.format == HAL_PIXEL_FORMAT_YCbCr_420_SP) || + (src_img.format == HAL_PIXEL_FORMAT_YCrCb_420_SP) || + (src_img.format == HAL_PIXEL_FORMAT_YCbCr_420_P) || + (src_img.format == HAL_PIXEL_FORMAT_YV12)) { + mHdmiClient->blit2Hdmi(src_img.w, src_img.h, + src_img.format, + (unsigned int)ctx->fimc.params.src.buf_addr_phy_rgb_y, + (unsigned int)ctx->fimc.params.src.buf_addr_phy_cb, + (unsigned int)ctx->fimc.params.src.buf_addr_phy_cr, + 0, 0, + android::SecHdmiClient::HDMI_MODE_VIDEO, + ctx->num_of_hwc_layer); + } else { + LOGE("%s: Unsupported format = %d", __func__, src_img.format); + } + } +#endif + return 0; +} + +static int hwc_device_close(struct hw_device_t *dev) +{ + struct hwc_context_t* ctx = (struct hwc_context_t*)dev; + int ret = 0; + int i; + if (ctx) { + if (destroyFimc(&ctx->fimc) < 0) { + SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyFimc fail", __func__); + ret = -1; + } +#ifdef SUB_TITLES_HWC + if (destroyG2d(&ctx->g2d) < 0) { + SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyG2d() fail", __func__); + ret = -1; + } +#endif + if (destroyMem(&ctx->s3c_mem) < 0) { + SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyMem fail", __func__); + ret = -1; + } + +#ifdef USE_HW_PMEM + if (destroyPmem(&ctx->sec_pmem) < 0) { + SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyPmem fail", __func__); + ret = -1; + } +#endif + for (i = 0; i < NUM_OF_WIN; i++) { + if (window_close(&ctx->win[i]) < 0) + SEC_HWC_Log(HWC_LOG_DEBUG, "%s::window_close() fail", __func__); + } + + free(ctx); + } + return ret; +} + +static int hwc_device_open(const struct hw_module_t* module, const char* name, + struct hw_device_t** device) +{ + int status = 0; + struct hwc_win_info_t *win; + + if (strcmp(name, HWC_HARDWARE_COMPOSER)) + return -EINVAL; + + struct hwc_context_t *dev; + dev = (hwc_context_t*)malloc(sizeof(*dev)); + + /* initialize our state here */ + memset(dev, 0, sizeof(*dev)); + + /* initialize the procs */ + dev->device.common.tag = HARDWARE_DEVICE_TAG; + dev->device.common.version = 0; + dev->device.common.module = const_cast<hw_module_t*>(module); + dev->device.common.close = hwc_device_close; + + dev->device.prepare = hwc_prepare; + dev->device.set = hwc_set; + + *device = &dev->device.common; + + //initializing + memset(&(dev->fimc), 0, sizeof(s5p_fimc_t)); + memset(&(dev->s3c_mem), 0, sizeof(struct s3c_mem_t)); +#ifdef USE_HW_PMEM + memset(&(dev->sec_pmem), 0, sizeof(sec_pmem_t)); +#endif + /* open WIN0 & WIN1 here */ + for (int i = 0; i < NUM_OF_WIN; i++) { + if (window_open(&(dev->win[i]), i) < 0) { + SEC_HWC_Log(HWC_LOG_ERROR, + "%s:: Failed to open window %d device ", __func__, i); + status = -EINVAL; + goto err; + } + } + + if (window_get_global_lcd_info(dev->win[0].fd, &dev->lcd_info) < 0) { + SEC_HWC_Log(HWC_LOG_ERROR, + "%s::window_get_global_lcd_info is failed : %s", + __func__, strerror(errno)); + status = -EINVAL; + goto err; + } + +#if defined(BOARD_USES_HDMI) + lcd_width = dev->lcd_info.xres; + lcd_height = dev->lcd_info.yres; +#endif + + /* initialize the window context */ + for (int i = 0; i < NUM_OF_WIN; i++) { + win = &dev->win[i]; + memcpy(&win->lcd_info, &dev->lcd_info, sizeof(struct fb_var_screeninfo)); + memcpy(&win->var_info, &dev->lcd_info, sizeof(struct fb_var_screeninfo)); + + win->rect_info.x = 0; + win->rect_info.y = 0; + win->rect_info.w = win->var_info.xres; + win->rect_info.h = win->var_info.yres; + + if (window_set_pos(win) < 0) { + SEC_HWC_Log(HWC_LOG_ERROR, "%s::window_set_pos is failed : %s", + __func__, strerror(errno)); + status = -EINVAL; + goto err; + } + + if (window_get_info(win, i) < 0) { + SEC_HWC_Log(HWC_LOG_ERROR, "%s::window_get_info is failed : %s", + __func__, strerror(errno)); + status = -EINVAL; + goto err; + } + + } + +#ifdef USE_HW_PMEM + if (createPmem(&dev->sec_pmem, PMEM_SIZE) < 0) { + SEC_HWC_Log(HWC_LOG_ERROR, "%s::initPmem(%d) fail", __func__, PMEM_SIZE); + } +#endif + + if (createMem(&dev->s3c_mem, 0, 0) < 0) { + SEC_HWC_Log(HWC_LOG_ERROR, "%s::createMem() fail (size=0)", __func__); + status = -EINVAL; + goto err; + } + + //create PP + if (createFimc(&dev->fimc) < 0) { + SEC_HWC_Log(HWC_LOG_ERROR, "%s::creatFimc() fail", __func__); + status = -EINVAL; + goto err; + } + +#ifdef SUB_TITLES_HWC + if (createG2d(&dev->g2d) < 0) { + SEC_HWC_Log(HWC_LOG_ERROR, "%s::createG2d() fail", __func__); + status = -EINVAL; + goto err; + } +#endif + + SEC_HWC_Log(HWC_LOG_DEBUG, "%s:: hwc_device_open: SUCCESS", __func__); + + return 0; + +err: + if (destroyFimc(&dev->fimc) < 0) + SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyFimc() fail", __func__); +#ifdef SUB_TITLES_HWC + if (destroyG2d(&dev->g2d) < 0) + SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyG2d() fail", __func__); +#endif + if (destroyMem(&dev->s3c_mem) < 0) + SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyMem() fail", __func__); + +#ifdef USE_HW_PMEM + if (destroyPmem(&dev->sec_pmem) < 0) + SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyPmem() fail", __func__); +#endif + + for (int i = 0; i < NUM_OF_WIN; i++) { + if (window_close(&dev->win[i]) < 0) + SEC_HWC_Log(HWC_LOG_DEBUG, "%s::window_close() fail", __func__); + } + + return status; +} |