hwc_utils.cpp revision d9381b134ed518570554296fbfab8fd1175ecdb8
1/* 2 * Copyright (C) 2010 The Android Open Source Project 3 * Copyright (C) 2012-2013, The Linux Foundation All rights reserved. 4 * 5 * Not a Contribution, Apache license notifications and license are retained 6 * for attribution purposes only. 7 * 8 * Licensed under the Apache License, Version 2.0 (the "License"); 9 * you may not use this file except in compliance with the License. 10 * You may obtain a copy of the License at 11 * 12 * http://www.apache.org/licenses/LICENSE-2.0 13 * 14 * Unless required by applicable law or agreed to in writing, software 15 * distributed under the License is distributed on an "AS IS" BASIS, 16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 17 * See the License for the specific language governing permissions and 18 * limitations under the License. 19 */ 20#define HWC_UTILS_DEBUG 0 21#include <sys/ioctl.h> 22#include <linux/fb.h> 23#include <binder/IServiceManager.h> 24#include <EGL/egl.h> 25#include <cutils/properties.h> 26#include <gralloc_priv.h> 27#include <overlay.h> 28#include <overlayRotator.h> 29#include "hwc_utils.h" 30#include "hwc_mdpcomp.h" 31#include "hwc_fbupdate.h" 32#include "mdp_version.h" 33#include "hwc_copybit.h" 34#include "hwc_dump_layers.h" 35#include "external.h" 36#include "hwc_qclient.h" 37#include "QService.h" 38#include "comptype.h" 39 40using namespace qClient; 41using namespace qService; 42using namespace android; 43using namespace overlay; 44using namespace overlay::utils; 45namespace ovutils = overlay::utils; 46 47namespace qhwc { 48 49static int openFramebufferDevice(hwc_context_t *ctx) 50{ 51 struct fb_fix_screeninfo finfo; 52 struct fb_var_screeninfo info; 53 54 int fb_fd = openFb(HWC_DISPLAY_PRIMARY); 55 if(fb_fd < 0) { 56 ALOGE("%s: Error Opening FB : %s", __FUNCTION__, strerror(errno)); 57 return -errno; 58 } 59 60 if (ioctl(fb_fd, FBIOGET_VSCREENINFO, &info) == -1) { 61 ALOGE("%s:Error in ioctl FBIOGET_VSCREENINFO: %s", __FUNCTION__, 62 strerror(errno)); 63 close(fb_fd); 64 return -errno; 65 } 66 67 if (int(info.width) <= 0 || int(info.height) <= 0) { 68 // the driver doesn't return that information 69 // default to 160 dpi 70 info.width = ((info.xres * 25.4f)/160.0f + 0.5f); 71 info.height = ((info.yres * 25.4f)/160.0f + 0.5f); 72 } 73 74 float xdpi = (info.xres * 25.4f) / info.width; 75 float ydpi = (info.yres * 25.4f) / info.height; 76 77#ifdef MSMFB_METADATA_GET 78 struct msmfb_metadata metadata; 79 memset(&metadata, 0 , sizeof(metadata)); 80 metadata.op = metadata_op_frame_rate; 81 82 if (ioctl(fb_fd, MSMFB_METADATA_GET, &metadata) == -1) { 83 ALOGE("%s:Error retrieving panel frame rate: %s", __FUNCTION__, 84 strerror(errno)); 85 close(fb_fd); 86 return -errno; 87 } 88 89 float fps = metadata.data.panel_frame_rate; 90#else 91 //XXX: Remove reserved field usage on all baselines 92 //The reserved[3] field is used to store FPS by the driver. 93 float fps = info.reserved[3] & 0xFF; 94#endif 95 96 if (ioctl(fb_fd, FBIOGET_FSCREENINFO, &finfo) == -1) { 97 ALOGE("%s:Error in ioctl FBIOGET_FSCREENINFO: %s", __FUNCTION__, 98 strerror(errno)); 99 close(fb_fd); 100 return -errno; 101 } 102 103 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].fd = fb_fd; 104 //xres, yres may not be 32 aligned 105 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].stride = finfo.line_length /(info.xres/8); 106 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xres = info.xres; 107 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].yres = info.yres; 108 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xdpi = xdpi; 109 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].ydpi = ydpi; 110 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].vsync_period = 1000000000l / fps; 111 112 //Unblank primary on first boot 113 if(ioctl(fb_fd, FBIOBLANK,FB_BLANK_UNBLANK) < 0) { 114 ALOGE("%s: Failed to unblank display", __FUNCTION__); 115 return -errno; 116 } 117 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].isActive = true; 118 119 return 0; 120} 121 122void initContext(hwc_context_t *ctx) 123{ 124 openFramebufferDevice(ctx); 125 ctx->mMDP.version = qdutils::MDPVersion::getInstance().getMDPVersion(); 126 ctx->mMDP.hasOverlay = qdutils::MDPVersion::getInstance().hasOverlay(); 127 ctx->mMDP.panel = qdutils::MDPVersion::getInstance().getPanelType(); 128 overlay::Overlay::initOverlay(); 129 ctx->mOverlay = overlay::Overlay::getInstance(); 130 ctx->mRotMgr = new RotMgr(); 131 132 //Is created and destroyed only once for primary 133 //For external it could get created and destroyed multiple times depending 134 //on what external we connect to. 135 ctx->mFBUpdate[HWC_DISPLAY_PRIMARY] = 136 IFBUpdate::getObject(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xres, 137 HWC_DISPLAY_PRIMARY); 138 139 // Check if the target supports copybit compostion (dyn/mdp/c2d) to 140 // decide if we need to open the copybit module. 141 int compositionType = 142 qdutils::QCCompositionType::getInstance().getCompositionType(); 143 144 if (compositionType & (qdutils::COMPOSITION_TYPE_DYN | 145 qdutils::COMPOSITION_TYPE_MDP | 146 qdutils::COMPOSITION_TYPE_C2D)) { 147 ctx->mCopyBit[HWC_DISPLAY_PRIMARY] = new CopyBit(); 148 } 149 150 ctx->mExtDisplay = new ExternalDisplay(ctx); 151 152 ctx->mMDPComp[HWC_DISPLAY_PRIMARY] = 153 MDPComp::getObject(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xres, 154 HWC_DISPLAY_PRIMARY); 155 156 for (uint32_t i = 0; i < MAX_DISPLAYS; i++) { 157 ctx->mHwcDebug[i] = new HwcDebug(i); 158 } 159 MDPComp::init(ctx); 160 161 ctx->vstate.enable = false; 162 ctx->vstate.fakevsync = false; 163 ctx->mExtDispConfiguring = false; 164 ctx->mExtOrientation = 0; 165 166 //Right now hwc starts the service but anybody could do it, or it could be 167 //independent process as well. 168 QService::init(); 169 sp<IQClient> client = new QClient(ctx); 170 interface_cast<IQService>( 171 defaultServiceManager()->getService( 172 String16("display.qservice")))->connect(client); 173 174 // Initialize "No animation on external display" related parameters. 175 ctx->deviceOrientation = 0; 176 ctx->mPrevCropVideo.left = ctx->mPrevCropVideo.top = 177 ctx->mPrevCropVideo.right = ctx->mPrevCropVideo.bottom = 0; 178 ctx->mPrevDestVideo.left = ctx->mPrevDestVideo.top = 179 ctx->mPrevDestVideo.right = ctx->mPrevDestVideo.bottom = 0; 180 ctx->mPrevTransformVideo = 0; 181 182 ALOGI("Initializing Qualcomm Hardware Composer"); 183 ALOGI("MDP version: %d", ctx->mMDP.version); 184} 185 186void closeContext(hwc_context_t *ctx) 187{ 188 if(ctx->mOverlay) { 189 delete ctx->mOverlay; 190 ctx->mOverlay = NULL; 191 } 192 193 if(ctx->mRotMgr) { 194 delete ctx->mRotMgr; 195 ctx->mRotMgr = NULL; 196 } 197 198 for(int i = 0; i < MAX_DISPLAYS; i++) { 199 if(ctx->mCopyBit[i]) { 200 delete ctx->mCopyBit[i]; 201 ctx->mCopyBit[i] = NULL; 202 } 203 } 204 205 if(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].fd) { 206 close(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].fd); 207 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].fd = -1; 208 } 209 210 if(ctx->mExtDisplay) { 211 delete ctx->mExtDisplay; 212 ctx->mExtDisplay = NULL; 213 } 214 215 for(int i = 0; i < MAX_DISPLAYS; i++) { 216 if(ctx->mFBUpdate[i]) { 217 delete ctx->mFBUpdate[i]; 218 ctx->mFBUpdate[i] = NULL; 219 } 220 if(ctx->mMDPComp[i]) { 221 delete ctx->mMDPComp[i]; 222 ctx->mMDPComp[i] = NULL; 223 } 224 if(ctx->mHwcDebug[i]) { 225 delete ctx->mHwcDebug[i]; 226 ctx->mHwcDebug[i] = NULL; 227 } 228 } 229 230 231} 232 233 234void dumpsys_log(android::String8& buf, const char* fmt, ...) 235{ 236 va_list varargs; 237 va_start(varargs, fmt); 238 buf.appendFormatV(fmt, varargs); 239 va_end(varargs); 240} 241 242/* Calculates the destination position based on the action safe rectangle */ 243void getActionSafePosition(hwc_context_t *ctx, int dpy, uint32_t& x, 244 uint32_t& y, uint32_t& w, uint32_t& h) { 245 246 // if external supports underscan, do nothing 247 // it will be taken care in the driver 248 if(ctx->mExtDisplay->isCEUnderscanSupported()) 249 return; 250 251 float wRatio = 1.0; 252 float hRatio = 1.0; 253 float xRatio = 1.0; 254 float yRatio = 1.0; 255 256 float fbWidth = ctx->dpyAttr[dpy].xres; 257 float fbHeight = ctx->dpyAttr[dpy].yres; 258 259 float asX = 0; 260 float asY = 0; 261 float asW = fbWidth; 262 float asH= fbHeight; 263 char value[PROPERTY_VALUE_MAX]; 264 265 // Apply action safe parameters 266 property_get("persist.sys.actionsafe.width", value, "0"); 267 int asWidthRatio = atoi(value); 268 property_get("persist.sys.actionsafe.height", value, "0"); 269 int asHeightRatio = atoi(value); 270 // based on the action safe ratio, get the Action safe rectangle 271 asW = fbWidth * (1.0f - asWidthRatio / 100.0f); 272 asH = fbHeight * (1.0f - asHeightRatio / 100.0f); 273 asX = (fbWidth - asW) / 2; 274 asY = (fbHeight - asH) / 2; 275 276 // calculate the position ratio 277 xRatio = (float)x/fbWidth; 278 yRatio = (float)y/fbHeight; 279 wRatio = (float)w/fbWidth; 280 hRatio = (float)h/fbHeight; 281 282 //Calculate the position... 283 x = (xRatio * asW) + asX; 284 y = (yRatio * asH) + asY; 285 w = (wRatio * asW); 286 h = (hRatio * asH); 287 288 return; 289} 290 291/* Calculates the aspect ratio for external based on the primary */ 292void getAspectRatioPosition(hwc_context_t *ctx, int dpy, int orientation, 293 uint32_t& x, uint32_t& y, uint32_t& w, uint32_t& h) { 294 int fbWidth = ctx->dpyAttr[dpy].xres; 295 int fbHeight = ctx->dpyAttr[dpy].yres; 296 297 switch(orientation) { 298 case HAL_TRANSFORM_ROT_90: 299 case HAL_TRANSFORM_ROT_270: 300 x = (fbWidth - (ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xres 301 * fbHeight/ctx->dpyAttr[HWC_DISPLAY_PRIMARY].yres))/2; 302 y = 0; 303 w = (ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xres * 304 fbHeight/ctx->dpyAttr[HWC_DISPLAY_PRIMARY].yres); 305 h = fbHeight; 306 break; 307 default: 308 //Do nothing 309 break; 310 } 311 ALOGD_IF(HWC_UTILS_DEBUG, "%s: Position: x = %d, y = %d w = %d h = %d", 312 __FUNCTION__, x, y, w ,h); 313} 314 315 316bool needsScaling(hwc_context_t* ctx, hwc_layer_1_t const* layer, 317 const int& dpy) { 318 int dst_w, dst_h, src_w, src_h; 319 320 hwc_rect_t displayFrame = layer->displayFrame; 321 hwc_rect_t sourceCrop = layer->sourceCrop; 322 trimLayer(ctx, dpy, layer->transform, sourceCrop, displayFrame); 323 324 dst_w = displayFrame.right - displayFrame.left; 325 dst_h = displayFrame.bottom - displayFrame.top; 326 src_w = sourceCrop.right - sourceCrop.left; 327 src_h = sourceCrop.bottom - sourceCrop.top; 328 329 if(((src_w != dst_w) || (src_h != dst_h))) 330 return true; 331 332 return false; 333} 334 335bool isAlphaScaled(hwc_context_t* ctx, hwc_layer_1_t const* layer, 336 const int& dpy) { 337 if(needsScaling(ctx, layer, dpy) && isAlphaPresent(layer)) { 338 return true; 339 } 340 return false; 341} 342 343bool isAlphaPresent(hwc_layer_1_t const* layer) { 344 private_handle_t *hnd = (private_handle_t *)layer->handle; 345 if(hnd) { 346 int format = hnd->format; 347 switch(format) { 348 case HAL_PIXEL_FORMAT_RGBA_8888: 349 case HAL_PIXEL_FORMAT_BGRA_8888: 350 // In any more formats with Alpha go here.. 351 return true; 352 default : return false; 353 } 354 } 355 return false; 356} 357 358void setListStats(hwc_context_t *ctx, 359 const hwc_display_contents_1_t *list, int dpy) { 360 361 ctx->listStats[dpy].numAppLayers = list->numHwLayers - 1; 362 ctx->listStats[dpy].fbLayerIndex = list->numHwLayers - 1; 363 ctx->listStats[dpy].skipCount = 0; 364 ctx->listStats[dpy].needsAlphaScale = false; 365 ctx->listStats[dpy].preMultipliedAlpha = false; 366 ctx->listStats[dpy].yuvCount = 0; 367 char property[PROPERTY_VALUE_MAX]; 368 ctx->listStats[dpy].extOnlyLayerIndex = -1; 369 ctx->listStats[dpy].isDisplayAnimating = false; 370 371 //reset yuv indices 372 memset(ctx->listStats[dpy].yuvIndices, -1, MAX_NUM_APP_LAYERS); 373 374 for (size_t i = 0; i < (list->numHwLayers - 1); i++) { 375 hwc_layer_1_t const* layer = &list->hwLayers[i]; 376 private_handle_t *hnd = (private_handle_t *)layer->handle; 377 378#ifdef QCOM_BSP 379 if (layer->flags & HWC_SCREENSHOT_ANIMATOR_LAYER) { 380 ctx->listStats[dpy].isDisplayAnimating = true; 381 } 382#endif 383 // continue if i reaches MAX_NUM_APP_LAYERS 384 if(i >= MAX_NUM_APP_LAYERS) 385 continue; 386 387 if(list->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET) { 388 continue; 389 //We disregard FB being skip for now! so the else if 390 } else if (isSkipLayer(&list->hwLayers[i])) { 391 ctx->listStats[dpy].skipCount++; 392 } 393 394 if (UNLIKELY(isYuvBuffer(hnd))) { 395 int& yuvCount = ctx->listStats[dpy].yuvCount; 396 ctx->listStats[dpy].yuvIndices[yuvCount] = i; 397 yuvCount++; 398 399 if((layer->transform & HWC_TRANSFORM_ROT_90) && 400 canUseRotator(ctx)) { 401 if(ctx->mOverlay->isPipeTypeAttached(OV_MDP_PIPE_DMA)) { 402 ctx->isPaddingRound = true; 403 } 404 Overlay::setDMAMode(Overlay::DMA_BLOCK_MODE); 405 } 406 } 407 if(layer->blending == HWC_BLENDING_PREMULT) 408 ctx->listStats[dpy].preMultipliedAlpha = true; 409 410 if(!ctx->listStats[dpy].needsAlphaScale) 411 ctx->listStats[dpy].needsAlphaScale = 412 isAlphaScaled(ctx, layer, dpy); 413 414 if(UNLIKELY(isExtOnly(hnd))){ 415 ctx->listStats[dpy].extOnlyLayerIndex = i; 416 } 417 } 418 if(ctx->listStats[dpy].yuvCount > 0) { 419 if (property_get("hw.cabl.yuv", property, NULL) > 0) { 420 if (atoi(property) != 1) { 421 property_set("hw.cabl.yuv", "1"); 422 } 423 } 424 } else { 425 if (property_get("hw.cabl.yuv", property, NULL) > 0) { 426 if (atoi(property) != 0) { 427 property_set("hw.cabl.yuv", "0"); 428 } 429 } 430 } 431 if(dpy) { 432 //uncomment the below code for testing purpose. 433 /* char value[PROPERTY_VALUE_MAX]; 434 property_get("sys.ext_orientation", value, "0"); 435 // Assuming the orientation value is in terms of HAL_TRANSFORM, 436 // This needs mapping to HAL, if its in different convention 437 ctx->mExtOrientation = atoi(value); */ 438 // Assuming the orientation value is in terms of HAL_TRANSFORM, 439 // This needs mapping to HAL, if its in different convention 440 if(ctx->mExtOrientation) { 441 ALOGD_IF(HWC_UTILS_DEBUG, "%s: ext orientation = %d", 442 __FUNCTION__, ctx->mExtOrientation); 443 if(ctx->mOverlay->isPipeTypeAttached(OV_MDP_PIPE_DMA)) { 444 ctx->isPaddingRound = true; 445 } 446 Overlay::setDMAMode(Overlay::DMA_BLOCK_MODE); 447 } 448 } 449} 450 451 452static void calc_cut(float& leftCutRatio, float& topCutRatio, 453 float& rightCutRatio, float& bottomCutRatio, int orient) { 454 if(orient & HAL_TRANSFORM_FLIP_H) { 455 swap(leftCutRatio, rightCutRatio); 456 } 457 if(orient & HAL_TRANSFORM_FLIP_V) { 458 swap(topCutRatio, bottomCutRatio); 459 } 460 if(orient & HAL_TRANSFORM_ROT_90) { 461 //Anti clock swapping 462 float tmpCutRatio = leftCutRatio; 463 leftCutRatio = topCutRatio; 464 topCutRatio = rightCutRatio; 465 rightCutRatio = bottomCutRatio; 466 bottomCutRatio = tmpCutRatio; 467 } 468} 469 470bool isSecuring(hwc_context_t* ctx, hwc_layer_1_t const* layer) { 471 if((ctx->mMDP.version < qdutils::MDSS_V5) && 472 (ctx->mMDP.version > qdutils::MDP_V3_0) && 473 ctx->mSecuring) { 474 return true; 475 } 476 if (isSecureModePolicy(ctx->mMDP.version)) { 477 private_handle_t *hnd = (private_handle_t *)layer->handle; 478 if(ctx->mSecureMode) { 479 if (! isSecureBuffer(hnd)) { 480 ALOGD_IF(HWC_UTILS_DEBUG,"%s:Securing Turning ON ...", 481 __FUNCTION__); 482 return true; 483 } 484 } else { 485 if (isSecureBuffer(hnd)) { 486 ALOGD_IF(HWC_UTILS_DEBUG,"%s:Securing Turning OFF ...", 487 __FUNCTION__); 488 return true; 489 } 490 } 491 } 492 return false; 493} 494 495bool isSecureModePolicy(int mdpVersion) { 496 if (mdpVersion < qdutils::MDSS_V5) 497 return true; 498 else 499 return false; 500} 501 502//Crops source buffer against destination and FB boundaries 503void calculate_crop_rects(hwc_rect_t& crop, hwc_rect_t& dst, 504 const hwc_rect_t& scissor, int orient) { 505 506 int& crop_l = crop.left; 507 int& crop_t = crop.top; 508 int& crop_r = crop.right; 509 int& crop_b = crop.bottom; 510 int crop_w = crop.right - crop.left; 511 int crop_h = crop.bottom - crop.top; 512 513 int& dst_l = dst.left; 514 int& dst_t = dst.top; 515 int& dst_r = dst.right; 516 int& dst_b = dst.bottom; 517 int dst_w = abs(dst.right - dst.left); 518 int dst_h = abs(dst.bottom - dst.top); 519 520 const int& sci_l = scissor.left; 521 const int& sci_t = scissor.top; 522 const int& sci_r = scissor.right; 523 const int& sci_b = scissor.bottom; 524 int sci_w = abs(sci_r - sci_l); 525 int sci_h = abs(sci_b - sci_t); 526 527 float leftCutRatio = 0.0f, rightCutRatio = 0.0f, topCutRatio = 0.0f, 528 bottomCutRatio = 0.0f; 529 530 if(dst_l < sci_l) { 531 leftCutRatio = (float)(sci_l - dst_l) / (float)dst_w; 532 dst_l = sci_l; 533 } 534 535 if(dst_r > sci_r) { 536 rightCutRatio = (float)(dst_r - sci_r) / (float)dst_w; 537 dst_r = sci_r; 538 } 539 540 if(dst_t < sci_t) { 541 topCutRatio = (float)(sci_t - dst_t) / (float)dst_h; 542 dst_t = sci_t; 543 } 544 545 if(dst_b > sci_b) { 546 bottomCutRatio = (float)(dst_b - sci_b) / (float)dst_h; 547 dst_b = sci_b; 548 } 549 550 calc_cut(leftCutRatio, topCutRatio, rightCutRatio, bottomCutRatio, orient); 551 crop_l += crop_w * leftCutRatio; 552 crop_t += crop_h * topCutRatio; 553 crop_r -= crop_w * rightCutRatio; 554 crop_b -= crop_h * bottomCutRatio; 555} 556 557void getNonWormholeRegion(hwc_display_contents_1_t* list, 558 hwc_rect_t& nwr) 559{ 560 uint32_t last = list->numHwLayers - 1; 561 hwc_rect_t fbDisplayFrame = list->hwLayers[last].displayFrame; 562 //Initiliaze nwr to first frame 563 nwr.left = list->hwLayers[0].displayFrame.left; 564 nwr.top = list->hwLayers[0].displayFrame.top; 565 nwr.right = list->hwLayers[0].displayFrame.right; 566 nwr.bottom = list->hwLayers[0].displayFrame.bottom; 567 568 for (uint32_t i = 1; i < last; i++) { 569 hwc_rect_t displayFrame = list->hwLayers[i].displayFrame; 570 nwr.left = min(nwr.left, displayFrame.left); 571 nwr.top = min(nwr.top, displayFrame.top); 572 nwr.right = max(nwr.right, displayFrame.right); 573 nwr.bottom = max(nwr.bottom, displayFrame.bottom); 574 } 575 576 //Intersect with the framebuffer 577 nwr.left = max(nwr.left, fbDisplayFrame.left); 578 nwr.top = max(nwr.top, fbDisplayFrame.top); 579 nwr.right = min(nwr.right, fbDisplayFrame.right); 580 nwr.bottom = min(nwr.bottom, fbDisplayFrame.bottom); 581 582} 583 584bool isExternalActive(hwc_context_t* ctx) { 585 return ctx->dpyAttr[HWC_DISPLAY_EXTERNAL].isActive; 586} 587 588void closeAcquireFds(hwc_display_contents_1_t* list) { 589 for(uint32_t i = 0; list && i < list->numHwLayers; i++) { 590 //Close the acquireFenceFds 591 //HWC_FRAMEBUFFER are -1 already by SF, rest we close. 592 if(list->hwLayers[i].acquireFenceFd >= 0) { 593 close(list->hwLayers[i].acquireFenceFd); 594 list->hwLayers[i].acquireFenceFd = -1; 595 } 596 } 597} 598 599int hwc_sync(hwc_context_t *ctx, hwc_display_contents_1_t* list, int dpy, 600 int fd) { 601 int ret = 0; 602 struct mdp_buf_sync data; 603 int acquireFd[MAX_NUM_APP_LAYERS]; 604 int count = 0; 605 int releaseFd = -1; 606 int fbFd = -1; 607 memset(&data, 0, sizeof(data)); 608 bool swapzero = false; 609 data.flags = MDP_BUF_SYNC_FLAG_WAIT; 610 data.acq_fen_fd = acquireFd; 611 data.rel_fen_fd = &releaseFd; 612 char property[PROPERTY_VALUE_MAX]; 613 if(property_get("debug.egl.swapinterval", property, "1") > 0) { 614 if(atoi(property) == 0) 615 swapzero = true; 616 } 617 bool isExtAnimating = false; 618 if(dpy) 619 isExtAnimating = ctx->listStats[dpy].isDisplayAnimating; 620 621 //Accumulate acquireFenceFds 622 for(uint32_t i = 0; i < list->numHwLayers; i++) { 623 if(list->hwLayers[i].compositionType == HWC_OVERLAY && 624 list->hwLayers[i].acquireFenceFd != -1) { 625 if(UNLIKELY(swapzero)) 626 acquireFd[count++] = -1; 627 else 628 acquireFd[count++] = list->hwLayers[i].acquireFenceFd; 629 } 630 if(list->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET) { 631 if(UNLIKELY(swapzero)) 632 acquireFd[count++] = -1; 633 else if(fd != -1) { 634 //set the acquireFD from fd - which is coming from c2d 635 acquireFd[count++] = fd; 636 // Buffer sync IOCTL should be async when using c2d fence is 637 // used 638 data.flags &= ~MDP_BUF_SYNC_FLAG_WAIT; 639 } else if(list->hwLayers[i].acquireFenceFd != -1) 640 acquireFd[count++] = list->hwLayers[i].acquireFenceFd; 641 } 642 } 643 644 data.acq_fen_fd_cnt = count; 645 fbFd = ctx->dpyAttr[dpy].fd; 646 //Waits for acquire fences, returns a release fence 647 if(LIKELY(!swapzero)) { 648 uint64_t start = systemTime(); 649 ret = ioctl(fbFd, MSMFB_BUFFER_SYNC, &data); 650 ALOGD_IF(HWC_UTILS_DEBUG, "%s: time taken for MSMFB_BUFFER_SYNC IOCTL = %d", 651 __FUNCTION__, (size_t) ns2ms(systemTime() - start)); 652 } 653 654 if(ret < 0) { 655 ALOGE("%s: ioctl MSMFB_BUFFER_SYNC failed, err=%s", 656 __FUNCTION__, strerror(errno)); 657 ALOGE("%s: acq_fen_fd_cnt=%d flags=%d fd=%d dpy=%d numHwLayers=%d", 658 __FUNCTION__, data.acq_fen_fd_cnt, data.flags, fbFd, 659 dpy, list->numHwLayers); 660 } 661 662 for(uint32_t i = 0; i < list->numHwLayers; i++) { 663 if(list->hwLayers[i].compositionType == HWC_OVERLAY || 664 list->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET) { 665 //Populate releaseFenceFds. 666 if(UNLIKELY(swapzero)) 667 list->hwLayers[i].releaseFenceFd = -1; 668 else if(isExtAnimating) { 669 // Release all the app layer fds immediately, 670 // if animation is in progress. 671 hwc_layer_1_t const* layer = &list->hwLayers[i]; 672 private_handle_t *hnd = (private_handle_t *)layer->handle; 673 if(isYuvBuffer(hnd)) { 674 list->hwLayers[i].releaseFenceFd = dup(releaseFd); 675 } else 676 list->hwLayers[i].releaseFenceFd = -1; 677 } else 678 list->hwLayers[i].releaseFenceFd = dup(releaseFd); 679 } 680 } 681 682 if(fd >= 0) { 683 close(fd); 684 fd = -1; 685 } 686 687 if (ctx->mCopyBit[dpy]) 688 ctx->mCopyBit[dpy]->setReleaseFd(releaseFd); 689 // if external is animating, close the relaseFd 690 if(isExtAnimating) { 691 close(releaseFd); 692 releaseFd = -1; 693 } 694 if(UNLIKELY(swapzero)){ 695 list->retireFenceFd = -1; 696 close(releaseFd); 697 } else { 698 list->retireFenceFd = releaseFd; 699 } 700 701 return ret; 702} 703 704void trimLayer(hwc_context_t *ctx, const int& dpy, const int& transform, 705 hwc_rect_t& crop, hwc_rect_t& dst) { 706 int hw_w = ctx->dpyAttr[dpy].xres; 707 int hw_h = ctx->dpyAttr[dpy].yres; 708 if(dst.left < 0 || dst.top < 0 || 709 dst.right > hw_w || dst.bottom > hw_h) { 710 hwc_rect_t scissor = {0, 0, hw_w, hw_h }; 711 qhwc::calculate_crop_rects(crop, dst, scissor, transform); 712 } 713} 714 715void setMdpFlags(hwc_layer_1_t *layer, 716 ovutils::eMdpFlags &mdpFlags, 717 int rotDownscale, int transform) { 718 private_handle_t *hnd = (private_handle_t *)layer->handle; 719 MetaData_t *metadata = (MetaData_t *)hnd->base_metadata; 720 721 if(layer->blending == HWC_BLENDING_PREMULT) { 722 ovutils::setMdpFlags(mdpFlags, 723 ovutils::OV_MDP_BLEND_FG_PREMULT); 724 } 725 726 if(isYuvBuffer(hnd)) { 727 if(isSecureBuffer(hnd)) { 728 ovutils::setMdpFlags(mdpFlags, 729 ovutils::OV_MDP_SECURE_OVERLAY_SESSION); 730 } 731 if(metadata && (metadata->operation & PP_PARAM_INTERLACED) && 732 metadata->interlaced) { 733 ovutils::setMdpFlags(mdpFlags, 734 ovutils::OV_MDP_DEINTERLACE); 735 } 736 //Pre-rotation will be used using rotator. 737 if(transform & HWC_TRANSFORM_ROT_90) { 738 ovutils::setMdpFlags(mdpFlags, 739 ovutils::OV_MDP_SOURCE_ROTATED_90); 740 } 741 } 742 743 //No 90 component and no rot-downscale then flips done by MDP 744 //If we use rot then it might as well do flips 745 if(!(transform & HWC_TRANSFORM_ROT_90) && !rotDownscale) { 746 if(transform & HWC_TRANSFORM_FLIP_H) { 747 ovutils::setMdpFlags(mdpFlags, ovutils::OV_MDP_FLIP_H); 748 } 749 750 if(transform & HWC_TRANSFORM_FLIP_V) { 751 ovutils::setMdpFlags(mdpFlags, ovutils::OV_MDP_FLIP_V); 752 } 753 } 754 755 if(metadata && 756 ((metadata->operation & PP_PARAM_HSIC) 757 || (metadata->operation & PP_PARAM_IGC) 758 || (metadata->operation & PP_PARAM_SHARP2))) { 759 ovutils::setMdpFlags(mdpFlags, ovutils::OV_MDP_PP_EN); 760 } 761} 762 763int configRotator(Rotator *rot, const Whf& whf, 764 hwc_rect_t& crop, const eMdpFlags& mdpFlags, 765 const eTransform& orient, const int& downscale) { 766 767 rot->setSource(whf); 768 769 if (qdutils::MDPVersion::getInstance().getMDPVersion() >= 770 qdutils::MDSS_V5) { 771 uint32_t crop_w = (crop.right - crop.left); 772 uint32_t crop_h = (crop.bottom - crop.top); 773 if (ovutils::isYuv(whf.format)) { 774 ovutils::normalizeCrop((uint32_t&)crop.left, crop_w); 775 ovutils::normalizeCrop((uint32_t&)crop.top, crop_h); 776 // For interlaced, crop.h should be 4-aligned 777 if ((mdpFlags & ovutils::OV_MDP_DEINTERLACE) && (crop_h % 4)) 778 crop_h = ovutils::aligndown(crop_h, 4); 779 crop.right = crop.left + crop_w; 780 crop.bottom = crop.top + crop_h; 781 } 782 Dim rotCrop(crop.left, crop.top, crop_w, crop_h); 783 rot->setCrop(rotCrop); 784 } 785 786 rot->setFlags(mdpFlags); 787 rot->setTransform(orient); 788 rot->setDownscale(downscale); 789 if(!rot->commit()) return -1; 790 return 0; 791} 792 793int configMdp(Overlay *ov, const PipeArgs& parg, 794 const eTransform& orient, const hwc_rect_t& crop, 795 const hwc_rect_t& pos, const MetaData_t *metadata, 796 const eDest& dest) { 797 ov->setSource(parg, dest); 798 ov->setTransform(orient, dest); 799 800 int crop_w = crop.right - crop.left; 801 int crop_h = crop.bottom - crop.top; 802 Dim dcrop(crop.left, crop.top, crop_w, crop_h); 803 ov->setCrop(dcrop, dest); 804 805 int posW = pos.right - pos.left; 806 int posH = pos.bottom - pos.top; 807 Dim position(pos.left, pos.top, posW, posH); 808 ov->setPosition(position, dest); 809 810 if (metadata) 811 ov->setVisualParams(*metadata, dest); 812 813 if (!ov->commit(dest)) { 814 return -1; 815 } 816 return 0; 817} 818 819void updateSource(eTransform& orient, Whf& whf, 820 hwc_rect_t& crop) { 821 Dim srcCrop(crop.left, crop.top, 822 crop.right - crop.left, 823 crop.bottom - crop.top); 824 orient = static_cast<eTransform>(ovutils::getMdpOrient(orient)); 825 preRotateSource(orient, whf, srcCrop); 826 if (qdutils::MDPVersion::getInstance().getMDPVersion() >= 827 qdutils::MDSS_V5) { 828 // Source for overlay will be the cropped (and rotated) 829 crop.left = 0; 830 crop.top = 0; 831 crop.right = srcCrop.w; 832 crop.bottom = srcCrop.h; 833 // Set width & height equal to sourceCrop w & h 834 whf.w = srcCrop.w; 835 whf.h = srcCrop.h; 836 } else { 837 crop.left = srcCrop.x; 838 crop.top = srcCrop.y; 839 crop.right = srcCrop.x + srcCrop.w; 840 crop.bottom = srcCrop.y + srcCrop.h; 841 } 842} 843 844int configureLowRes(hwc_context_t *ctx, hwc_layer_1_t *layer, 845 const int& dpy, eMdpFlags& mdpFlags, eZorder& z, 846 eIsFg& isFg, const eDest& dest, Rotator **rot) { 847 848 private_handle_t *hnd = (private_handle_t *)layer->handle; 849 if(!hnd) { 850 ALOGE("%s: layer handle is NULL", __FUNCTION__); 851 return -1; 852 } 853 854 MetaData_t *metadata = (MetaData_t *)hnd->base_metadata; 855 856 hwc_rect_t crop = layer->sourceCrop; 857 hwc_rect_t dst = layer->displayFrame; 858 int transform = layer->transform; 859 eTransform orient = static_cast<eTransform>(transform); 860 int downscale = 0; 861 int rotFlags = ovutils::ROT_FLAGS_NONE; 862 Whf whf(hnd->width, hnd->height, 863 getMdpFormat(hnd->format), hnd->size); 864 865 if(dpy && isYuvBuffer(hnd)) { 866 if(!ctx->listStats[dpy].isDisplayAnimating) { 867 ctx->mPrevCropVideo = crop; 868 ctx->mPrevDestVideo = dst; 869 ctx->mPrevTransformVideo = transform; 870 } else { 871 // Restore the previous crop, dest rect and transform values, during 872 // animation to avoid displaying videos at random coordinates. 873 crop = ctx->mPrevCropVideo; 874 dst = ctx->mPrevDestVideo; 875 transform = ctx->mPrevTransformVideo; 876 orient = static_cast<eTransform>(transform); 877 //In you tube use case when a device rotated from landscape to 878 // portrait, set the isFg flag and zOrder to avoid displaying UI on 879 // hdmi during animation 880 if(ctx->deviceOrientation) { 881 isFg = ovutils::IS_FG_SET; 882 z = ZORDER_1; 883 } 884 } 885 } 886 887 uint32_t x = dst.left, y = dst.right; 888 uint32_t w = dst.right - dst.left; 889 uint32_t h = dst.bottom - dst.top; 890 891 if(dpy && ctx->mExtOrientation) { 892 // Just need to set the position to portrait as the transformation 893 // will already be set to required orientation on TV 894 getAspectRatioPosition(ctx, dpy, ctx->mExtOrientation, x, y, w, h); 895 // Convert position to hwc_rect_t 896 dst.left = x; 897 dst.top = y; 898 dst.right = w + dst.left; 899 dst.bottom = h + dst.top; 900 } 901 902 if(isYuvBuffer(hnd) && ctx->mMDP.version >= qdutils::MDP_V4_2 && 903 ctx->mMDP.version < qdutils::MDSS_V5) { 904 downscale = getDownscaleFactor( 905 crop.right - crop.left, 906 crop.bottom - crop.top, 907 dst.right - dst.left, 908 dst.bottom - dst.top); 909 if(downscale) { 910 rotFlags = ROT_DOWNSCALE_ENABLED; 911 } 912 } 913 914 setMdpFlags(layer, mdpFlags, downscale, transform); 915 trimLayer(ctx, dpy, transform, crop, dst); 916 917 if(isYuvBuffer(hnd) && //if 90 component or downscale, use rot 918 ((transform & HWC_TRANSFORM_ROT_90) || downscale)) { 919 *rot = ctx->mRotMgr->getNext(); 920 if(*rot == NULL) return -1; 921 BwcPM::setBwc(ctx, crop, dst, transform, mdpFlags); 922 //Configure rotator for pre-rotation 923 if(configRotator(*rot, whf, crop, mdpFlags, orient, downscale) < 0) { 924 ALOGE("%s: configRotator failed!", __FUNCTION__); 925 ctx->mOverlay->clear(dpy); 926 return -1; 927 } 928 whf.format = (*rot)->getDstFormat(); 929 updateSource(orient, whf, crop); 930 rotFlags |= ovutils::ROT_PREROTATED; 931 } 932 933 //For the mdp, since either we are pre-rotating or MDP does flips 934 orient = OVERLAY_TRANSFORM_0; 935 transform = 0; 936 PipeArgs parg(mdpFlags, whf, z, isFg, static_cast<eRotFlags>(rotFlags)); 937 if(configMdp(ctx->mOverlay, parg, orient, crop, dst, metadata, dest) < 0) { 938 ALOGE("%s: commit failed for low res panel", __FUNCTION__); 939 return -1; 940 } 941 return 0; 942} 943 944int configureHighRes(hwc_context_t *ctx, hwc_layer_1_t *layer, 945 const int& dpy, eMdpFlags& mdpFlagsL, eZorder& z, 946 eIsFg& isFg, const eDest& lDest, const eDest& rDest, 947 Rotator **rot) { 948 private_handle_t *hnd = (private_handle_t *)layer->handle; 949 if(!hnd) { 950 ALOGE("%s: layer handle is NULL", __FUNCTION__); 951 return -1; 952 } 953 954 MetaData_t *metadata = (MetaData_t *)hnd->base_metadata; 955 956 int hw_w = ctx->dpyAttr[dpy].xres; 957 int hw_h = ctx->dpyAttr[dpy].yres; 958 hwc_rect_t crop = layer->sourceCrop; 959 hwc_rect_t dst = layer->displayFrame; 960 int transform = layer->transform; 961 eTransform orient = static_cast<eTransform>(transform); 962 const int downscale = 0; 963 int rotFlags = ROT_FLAGS_NONE; 964 965 Whf whf(hnd->width, hnd->height, 966 getMdpFormat(hnd->format), hnd->size); 967 968 if(dpy && isYuvBuffer(hnd)) { 969 if(!ctx->listStats[dpy].isDisplayAnimating) { 970 ctx->mPrevCropVideo = crop; 971 ctx->mPrevDestVideo = dst; 972 ctx->mPrevTransformVideo = transform; 973 } else { 974 // Restore the previous crop, dest rect and transform values, during 975 // animation to avoid displaying videos at random coordinates. 976 crop = ctx->mPrevCropVideo; 977 dst = ctx->mPrevDestVideo; 978 transform = ctx->mPrevTransformVideo; 979 orient = static_cast<eTransform>(transform); 980 //In you tube use case when a device rotated from landscape to 981 // portrait, set the isFg flag and zOrder to avoid displaying UI on 982 // hdmi during animation 983 if(ctx->deviceOrientation) { 984 isFg = ovutils::IS_FG_SET; 985 z = ZORDER_1; 986 } 987 } 988 } 989 990 991 setMdpFlags(layer, mdpFlagsL, 0, transform); 992 trimLayer(ctx, dpy, transform, crop, dst); 993 994 if(isYuvBuffer(hnd) && (transform & HWC_TRANSFORM_ROT_90)) { 995 (*rot) = ctx->mRotMgr->getNext(); 996 if((*rot) == NULL) return -1; 997 //Configure rotator for pre-rotation 998 if(configRotator(*rot, whf, crop, mdpFlagsL, orient, downscale) < 0) { 999 ALOGE("%s: configRotator failed!", __FUNCTION__); 1000 ctx->mOverlay->clear(dpy); 1001 return -1; 1002 } 1003 whf.format = (*rot)->getDstFormat(); 1004 updateSource(orient, whf, crop); 1005 rotFlags |= ROT_PREROTATED; 1006 } 1007 1008 eMdpFlags mdpFlagsR = mdpFlagsL; 1009 setMdpFlags(mdpFlagsR, OV_MDSS_MDP_RIGHT_MIXER); 1010 1011 hwc_rect_t tmp_cropL, tmp_dstL; 1012 hwc_rect_t tmp_cropR, tmp_dstR; 1013 1014 if(lDest != OV_INVALID) { 1015 tmp_cropL = crop; 1016 tmp_dstL = dst; 1017 hwc_rect_t scissor = {0, 0, hw_w/2, hw_h }; 1018 qhwc::calculate_crop_rects(tmp_cropL, tmp_dstL, scissor, 0); 1019 } 1020 if(rDest != OV_INVALID) { 1021 tmp_cropR = crop; 1022 tmp_dstR = dst; 1023 hwc_rect_t scissor = {hw_w/2, 0, hw_w, hw_h }; 1024 qhwc::calculate_crop_rects(tmp_cropR, tmp_dstR, scissor, 0); 1025 } 1026 1027 //When buffer is flipped, contents of mixer config also needs to swapped. 1028 //Not needed if the layer is confined to one half of the screen. 1029 //If rotator has been used then it has also done the flips, so ignore them. 1030 if((orient & OVERLAY_TRANSFORM_FLIP_V) && lDest != OV_INVALID 1031 && rDest != OV_INVALID && (*rot) == NULL) { 1032 hwc_rect_t new_cropR; 1033 new_cropR.left = tmp_cropL.left; 1034 new_cropR.right = new_cropR.left + (tmp_cropR.right - tmp_cropR.left); 1035 1036 hwc_rect_t new_cropL; 1037 new_cropL.left = new_cropR.right; 1038 new_cropL.right = tmp_cropR.right; 1039 1040 tmp_cropL.left = new_cropL.left; 1041 tmp_cropL.right = new_cropL.right; 1042 1043 tmp_cropR.left = new_cropR.left; 1044 tmp_cropR.right = new_cropR.right; 1045 1046 } 1047 1048 //For the mdp, since either we are pre-rotating or MDP does flips 1049 orient = OVERLAY_TRANSFORM_0; 1050 transform = 0; 1051 1052 //configure left mixer 1053 if(lDest != OV_INVALID) { 1054 PipeArgs pargL(mdpFlagsL, whf, z, isFg, 1055 static_cast<eRotFlags>(rotFlags)); 1056 if(configMdp(ctx->mOverlay, pargL, orient, 1057 tmp_cropL, tmp_dstL, metadata, lDest) < 0) { 1058 ALOGE("%s: commit failed for left mixer config", __FUNCTION__); 1059 return -1; 1060 } 1061 } 1062 1063 //configure right mixer 1064 if(rDest != OV_INVALID) { 1065 PipeArgs pargR(mdpFlagsR, whf, z, isFg, 1066 static_cast<eRotFlags>(rotFlags)); 1067 tmp_dstR.right = tmp_dstR.right - hw_w/2; 1068 tmp_dstR.left = tmp_dstR.left - hw_w/2; 1069 if(configMdp(ctx->mOverlay, pargR, orient, 1070 tmp_cropR, tmp_dstR, metadata, rDest) < 0) { 1071 ALOGE("%s: commit failed for right mixer config", __FUNCTION__); 1072 return -1; 1073 } 1074 } 1075 1076 return 0; 1077} 1078 1079bool canUseRotator(hwc_context_t *ctx) { 1080 if(qdutils::MDPVersion::getInstance().is8x26() && 1081 ctx->mExtDisplay->isExternalConnected()) { 1082 return false; 1083 } 1084 if(ctx->mMDP.version == qdutils::MDP_V3_0_4) 1085 return false; 1086 return true; 1087} 1088 1089 1090void BwcPM::setBwc(hwc_context_t *ctx, const hwc_rect_t& crop, 1091 const hwc_rect_t& dst, const int& transform, 1092 ovutils::eMdpFlags& mdpFlags) { 1093 //Target doesnt support Bwc 1094 if(!qdutils::MDPVersion::getInstance().supportsBWC()) { 1095 return; 1096 } 1097 //src width > MAX mixer supported dim 1098 if((crop.right - crop.left) > qdutils::MAX_DISPLAY_DIM) { 1099 return; 1100 } 1101 //External connected 1102 if(ctx->mExtDisplay->isExternalConnected()) { 1103 return; 1104 } 1105 //Decimation necessary, cannot use BWC. H/W requirement. 1106 if(qdutils::MDPVersion::getInstance().supportsDecimation()) { 1107 int src_w = crop.right - crop.left; 1108 int src_h = crop.bottom - crop.top; 1109 int dst_w = dst.right - dst.left; 1110 int dst_h = dst.bottom - dst.top; 1111 if(transform & HAL_TRANSFORM_ROT_90) { 1112 swap(src_w, src_h); 1113 } 1114 float horDscale = 0.0f; 1115 float verDscale = 0.0f; 1116 ovutils::getDecimationFactor(src_w, src_h, dst_w, dst_h, horDscale, 1117 verDscale); 1118 if(horDscale || verDscale) return; 1119 } 1120 //Property 1121 char value[PROPERTY_VALUE_MAX]; 1122 property_get("debug.disable.bwc", value, "0"); 1123 if(atoi(value)) return; 1124 1125 ovutils::setMdpFlags(mdpFlags, ovutils::OV_MDSS_MDP_BWC_EN); 1126} 1127 1128};//namespace qhwc 1129