hwc_utils.cpp revision 50ecfc494bed848dfde487e002863e0fbba5f711
1/* 2 * Copyright (C) 2010 The Android Open Source Project 3 * Copyright (C) 2012, The Linux Foundation All rights reserved. 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18#include <sys/ioctl.h> 19#include <EGL/egl.h> 20#include <cutils/properties.h> 21#include <gralloc_priv.h> 22#include <fb_priv.h> 23#include <overlay.h> 24#include "hwc_utils.h" 25#include "hwc_mdpcomp.h" 26#include "mdp_version.h" 27#include "external.h" 28#include "QService.h" 29 30namespace qhwc { 31 32// Opens Framebuffer device 33static void openFramebufferDevice(hwc_context_t *ctx) 34{ 35 hw_module_t const *module; 36 if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module) == 0) { 37 framebuffer_open(module, &(ctx->mFbDev)); 38 private_module_t* m = reinterpret_cast<private_module_t*>( 39 ctx->mFbDev->common.module); 40 //xres, yres may not be 32 aligned 41 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].stride = m->finfo.line_length / 42 (m->info.xres/8); 43 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xres = m->info.xres; 44 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].yres = m->info.yres; 45 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xdpi = ctx->mFbDev->xdpi; 46 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].ydpi = ctx->mFbDev->ydpi; 47 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].vsync_period = 48 1000000000l / ctx->mFbDev->fps; 49 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].fd = openFb(HWC_DISPLAY_PRIMARY); 50 } 51} 52 53void initContext(hwc_context_t *ctx) 54{ 55 openFramebufferDevice(ctx); 56 overlay::Overlay::initOverlay(); 57 ctx->mOverlay = overlay::Overlay::getInstance(); 58 ctx->mQService = qService::QService::getInstance(ctx); 59 ctx->mMDP.version = qdutils::MDPVersion::getInstance().getMDPVersion(); 60 ctx->mMDP.hasOverlay = qdutils::MDPVersion::getInstance().hasOverlay(); 61 ctx->mMDP.panel = qdutils::MDPVersion::getInstance().getPanelType(); 62 ctx->mExtDisplay = new ExternalDisplay(ctx); 63 for (uint32_t i = 0; i < HWC_NUM_DISPLAY_TYPES; i++) 64 ctx->mLayerCache[i] = new LayerCache(); 65 MDPComp::init(ctx); 66 67 pthread_mutex_init(&(ctx->vstate.lock), NULL); 68 pthread_cond_init(&(ctx->vstate.cond), NULL); 69 ctx->vstate.enable = false; 70 71 ALOGI("Initializing Qualcomm Hardware Composer"); 72 ALOGI("MDP version: %d", ctx->mMDP.version); 73} 74 75void closeContext(hwc_context_t *ctx) 76{ 77 if(ctx->mOverlay) { 78 delete ctx->mOverlay; 79 ctx->mOverlay = NULL; 80 } 81 82 if(ctx->mFbDev) { 83 framebuffer_close(ctx->mFbDev); 84 ctx->mFbDev = NULL; 85 close(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].fd); 86 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].fd = -1; 87 } 88 89 if(ctx->mExtDisplay) { 90 delete ctx->mExtDisplay; 91 ctx->mExtDisplay = NULL; 92 } 93 94 pthread_mutex_destroy(&(ctx->vstate.lock)); 95 pthread_cond_destroy(&(ctx->vstate.cond)); 96} 97 98 99void dumpsys_log(android::String8& buf, const char* fmt, ...) 100{ 101 va_list varargs; 102 va_start(varargs, fmt); 103 buf.appendFormatV(fmt, varargs); 104 va_end(varargs); 105} 106 107static inline bool isAlphaScaled(hwc_layer_1_t const* layer) { 108 int dst_w, dst_h, src_w, src_h; 109 110 hwc_rect_t displayFrame = layer->displayFrame; 111 hwc_rect_t sourceCrop = layer->sourceCrop; 112 113 dst_w = displayFrame.right - displayFrame.left; 114 dst_h = displayFrame.bottom - displayFrame.top; 115 116 src_w = sourceCrop.right - sourceCrop.left; 117 src_h = sourceCrop.bottom - sourceCrop.top; 118 119 if(((src_w != dst_w) || (src_h != dst_h))) { 120 if(layer->blending != HWC_BLENDING_NONE) 121 return true; 122 } 123 return false; 124} 125 126void setListStats(hwc_context_t *ctx, 127 const hwc_display_contents_1_t *list, int dpy) { 128 129 ctx->listStats[dpy].numAppLayers = list->numHwLayers - 1; 130 ctx->listStats[dpy].fbLayerIndex = list->numHwLayers - 1; 131 ctx->listStats[dpy].yuvCount = 0; 132 ctx->listStats[dpy].yuvIndex = -1; 133 ctx->listStats[dpy].skipCount = 0; 134 ctx->listStats[dpy].needsAlphaScale = false; 135 136 for (size_t i = 0; i < list->numHwLayers; i++) { 137 hwc_layer_1_t const* layer = &list->hwLayers[i]; 138 private_handle_t *hnd = (private_handle_t *)layer->handle; 139 140 if(list->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET) { 141 continue; 142 //We disregard FB being skip for now! so the else if 143 } else if (isSkipLayer(&list->hwLayers[i])) { 144 ctx->listStats[dpy].skipCount++; 145 } 146 147 if(!ctx->listStats[dpy].needsAlphaScale) 148 ctx->listStats[dpy].needsAlphaScale = isAlphaScaled(layer); 149 150 if (UNLIKELY(isYuvBuffer(hnd))) { 151 ctx->listStats[dpy].yuvCount++; 152 ctx->listStats[dpy].yuvIndex = i; 153 } 154 } 155} 156 157 158static inline void calc_cut(float& leftCutRatio, float& topCutRatio, 159 float& rightCutRatio, float& bottomCutRatio, int orient) { 160 if(orient & HAL_TRANSFORM_FLIP_H) { 161 swap(leftCutRatio, rightCutRatio); 162 } 163 if(orient & HAL_TRANSFORM_FLIP_V) { 164 swap(topCutRatio, bottomCutRatio); 165 } 166 if(orient & HAL_TRANSFORM_ROT_90) { 167 //Anti clock swapping 168 float tmpCutRatio = leftCutRatio; 169 leftCutRatio = topCutRatio; 170 topCutRatio = rightCutRatio; 171 rightCutRatio = bottomCutRatio; 172 bottomCutRatio = tmpCutRatio; 173 } 174} 175 176bool isSecuring(hwc_context_t* ctx) { 177 if((ctx->mMDP.version < qdutils::MDSS_V5) && 178 (ctx->mMDP.version > qdutils::MDP_V3_0) && 179 ctx->mSecuring) { 180 return true; 181 } 182 return false; 183} 184 185 186//Crops source buffer against destination and FB boundaries 187void calculate_crop_rects(hwc_rect_t& crop, hwc_rect_t& dst, 188 const int fbWidth, const int fbHeight, int orient) { 189 int& crop_l = crop.left; 190 int& crop_t = crop.top; 191 int& crop_r = crop.right; 192 int& crop_b = crop.bottom; 193 int crop_w = crop.right - crop.left; 194 int crop_h = crop.bottom - crop.top; 195 196 int& dst_l = dst.left; 197 int& dst_t = dst.top; 198 int& dst_r = dst.right; 199 int& dst_b = dst.bottom; 200 int dst_w = abs(dst.right - dst.left); 201 int dst_h = abs(dst.bottom - dst.top); 202 203 float leftCutRatio = 0.0f, rightCutRatio = 0.0f, topCutRatio = 0.0f, 204 bottomCutRatio = 0.0f; 205 206 if(dst_l < 0) { 207 leftCutRatio = (float)(0.0f - dst_l) / (float)dst_w; 208 dst_l = 0; 209 } 210 if(dst_r > fbWidth) { 211 rightCutRatio = (float)(dst_r - fbWidth) / (float)dst_w; 212 dst_r = fbWidth; 213 } 214 if(dst_t < 0) { 215 topCutRatio = (float)(0 - dst_t) / (float)dst_h; 216 dst_t = 0; 217 } 218 if(dst_b > fbHeight) { 219 bottomCutRatio = (float)(dst_b - fbHeight) / (float)dst_h; 220 dst_b = fbHeight; 221 } 222 223 calc_cut(leftCutRatio, topCutRatio, rightCutRatio, bottomCutRatio, orient); 224 crop_l += crop_w * leftCutRatio; 225 crop_t += crop_h * topCutRatio; 226 crop_r -= crop_w * rightCutRatio; 227 crop_b -= crop_h * bottomCutRatio; 228} 229 230bool isExternalActive(hwc_context_t* ctx) { 231 return ctx->dpyAttr[HWC_DISPLAY_EXTERNAL].isActive; 232} 233 234int hwc_sync(hwc_context_t *ctx, hwc_display_contents_1_t* list, int dpy) { 235 int ret = 0; 236 struct mdp_buf_sync data; 237 int acquireFd[MAX_NUM_LAYERS]; 238 int count = 0; 239 int releaseFd = -1; 240 int fbFd = -1; 241 bool swapzero = false; 242 data.flags = MDP_BUF_SYNC_FLAG_WAIT; 243 data.acq_fen_fd = acquireFd; 244 data.rel_fen_fd = &releaseFd; 245 char property[PROPERTY_VALUE_MAX]; 246 if(property_get("debug.egl.swapinterval", property, "1") > 0) { 247 if(atoi(property) == 0) 248 swapzero = true; 249 } 250 251 //Accumulate acquireFenceFds 252 for(uint32_t i = 0; i < list->numHwLayers; i++) { 253 if((list->hwLayers[i].compositionType == HWC_OVERLAY || 254 list->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET) && 255 list->hwLayers[i].acquireFenceFd != -1 ){ 256 if(UNLIKELY(swapzero)) 257 acquireFd[count++] = -1; 258 else 259 acquireFd[count++] = list->hwLayers[i].acquireFenceFd; 260 } 261 } 262 263 data.acq_fen_fd_cnt = count; 264 fbFd = ctx->dpyAttr[dpy].fd; 265 266 //Waits for acquire fences, returns a release fence 267 if(LIKELY(!swapzero)) 268 ret = ioctl(fbFd, MSMFB_BUFFER_SYNC, &data); 269 if(ret < 0) { 270 ALOGE("ioctl MSMFB_BUFFER_SYNC failed, err=%s", 271 strerror(errno)); 272 } 273 274 for(uint32_t i = 0; i < list->numHwLayers; i++) { 275 if((list->hwLayers[i].compositionType == HWC_OVERLAY || 276 list->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET)) { 277 //Close the acquireFenceFds 278 if(list->hwLayers[i].acquireFenceFd > 0) { 279 close(list->hwLayers[i].acquireFenceFd); 280 list->hwLayers[i].acquireFenceFd = -1; 281 } 282 //Populate releaseFenceFds. 283 if(UNLIKELY(swapzero)) 284 list->hwLayers[i].releaseFenceFd = -1; 285 else 286 list->hwLayers[i].releaseFenceFd = dup(releaseFd); 287 } 288 } 289 if(UNLIKELY(swapzero)){ 290 list->retireFenceFd = -1; 291 close(releaseFd); 292 } else { 293 list->retireFenceFd = releaseFd; 294 } 295 return ret; 296} 297 298void LayerCache::resetLayerCache(int num) { 299 for(uint32_t i = 0; i < MAX_NUM_LAYERS; i++) { 300 hnd[i] = NULL; 301 } 302 numHwLayers = num; 303} 304 305void LayerCache::updateLayerCache(hwc_display_contents_1_t* list) { 306 307 int numFbLayers = 0; 308 int numCacheableLayers = 0; 309 310 canUseLayerCache = false; 311 //Bail if geometry changed or num of layers changed 312 if(list->flags & HWC_GEOMETRY_CHANGED || 313 list->numHwLayers != numHwLayers ) { 314 resetLayerCache(list->numHwLayers); 315 return; 316 } 317 318 for(uint32_t i = 0; i < list->numHwLayers; i++) { 319 //Bail on skip layers 320 if(list->hwLayers[i].flags & HWC_SKIP_LAYER) { 321 resetLayerCache(list->numHwLayers); 322 return; 323 } 324 325 if(list->hwLayers[i].compositionType == HWC_FRAMEBUFFER) { 326 numFbLayers++; 327 if(hnd[i] == NULL) { 328 hnd[i] = list->hwLayers[i].handle; 329 } else if (hnd[i] == 330 list->hwLayers[i].handle) { 331 numCacheableLayers++; 332 } else { 333 hnd[i] = NULL; 334 return; 335 } 336 } else { 337 hnd[i] = NULL; 338 } 339 } 340 if(numFbLayers == numCacheableLayers) 341 canUseLayerCache = true; 342 343 //XXX: The marking part is separate, if MDP comp wants 344 // to use it in the future. Right now getting MDP comp 345 // to use this is more trouble than it is worth. 346 markCachedLayersAsOverlay(list); 347} 348 349void LayerCache::markCachedLayersAsOverlay(hwc_display_contents_1_t* list) { 350 //This optimization only works if ALL the layer handles 351 //that were on the framebuffer didn't change. 352 if(canUseLayerCache){ 353 for(uint32_t i = 0; i < list->numHwLayers; i++) { 354 if (list->hwLayers[i].handle && 355 list->hwLayers[i].handle == hnd[i] && 356 list->hwLayers[i].compositionType != HWC_FRAMEBUFFER_TARGET) 357 { 358 list->hwLayers[i].compositionType = HWC_OVERLAY; 359 } 360 } 361 } 362 363} 364 365};//namespace 366