hwc_utils.cpp revision ffc656e881bc4dba3fb2418bb32fe4194b1d55e3
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 "hwc_video.h" 33#include "mdp_version.h" 34#include "hwc_copybit.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 56 if (ioctl(fb_fd, FBIOGET_VSCREENINFO, &info) == -1) 57 return -errno; 58 59 if (int(info.width) <= 0 || int(info.height) <= 0) { 60 // the driver doesn't return that information 61 // default to 160 dpi 62 info.width = ((info.xres * 25.4f)/160.0f + 0.5f); 63 info.height = ((info.yres * 25.4f)/160.0f + 0.5f); 64 } 65 66 float xdpi = (info.xres * 25.4f) / info.width; 67 float ydpi = (info.yres * 25.4f) / info.height; 68 69#ifdef MSMFB_METADATA_GET 70 struct msmfb_metadata metadata; 71 memset(&metadata, 0 , sizeof(metadata)); 72 metadata.op = metadata_op_frame_rate; 73 74 if (ioctl(fb_fd, MSMFB_METADATA_GET, &metadata) == -1) { 75 ALOGE("Error retrieving panel frame rate"); 76 return -errno; 77 } 78 79 float fps = metadata.data.panel_frame_rate; 80#else 81 //XXX: Remove reserved field usage on all baselines 82 //The reserved[3] field is used to store FPS by the driver. 83 float fps = info.reserved[3] & 0xFF; 84#endif 85 86 if (ioctl(fb_fd, FBIOGET_FSCREENINFO, &finfo) == -1) 87 return -errno; 88 89 if (finfo.smem_len <= 0) 90 return -errno; 91 92 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].fd = fb_fd; 93 //xres, yres may not be 32 aligned 94 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].stride = finfo.line_length /(info.xres/8); 95 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xres = info.xres; 96 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].yres = info.yres; 97 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xdpi = xdpi; 98 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].ydpi = ydpi; 99 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].vsync_period = 1000000000l / fps; 100 101 return 0; 102} 103 104void initContext(hwc_context_t *ctx) 105{ 106 openFramebufferDevice(ctx); 107 ctx->mMDP.version = qdutils::MDPVersion::getInstance().getMDPVersion(); 108 ctx->mMDP.hasOverlay = qdutils::MDPVersion::getInstance().hasOverlay(); 109 ctx->mMDP.panel = qdutils::MDPVersion::getInstance().getPanelType(); 110 overlay::Overlay::initOverlay(); 111 ctx->mOverlay = overlay::Overlay::getInstance(); 112 ctx->mRotMgr = new RotMgr(); 113 114 //Is created and destroyed only once for primary 115 //For external it could get created and destroyed multiple times depending 116 //on what external we connect to. 117 ctx->mFBUpdate[HWC_DISPLAY_PRIMARY] = 118 IFBUpdate::getObject(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xres, 119 HWC_DISPLAY_PRIMARY); 120 121 ctx->mVidOv[HWC_DISPLAY_PRIMARY] = 122 IVideoOverlay::getObject(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xres, 123 HWC_DISPLAY_PRIMARY); 124 125 char value[PROPERTY_VALUE_MAX]; 126 // Check if the target supports copybit compostion (dyn/mdp/c2d) to 127 // decide if we need to open the copybit module. 128 int compositionType = 129 qdutils::QCCompositionType::getInstance().getCompositionType(); 130 131 if (compositionType & (qdutils::COMPOSITION_TYPE_DYN | 132 qdutils::COMPOSITION_TYPE_MDP | 133 qdutils::COMPOSITION_TYPE_C2D)) { 134 ctx->mCopyBit[HWC_DISPLAY_PRIMARY] = new CopyBit(); 135 } 136 137 ctx->mExtDisplay = new ExternalDisplay(ctx); 138 for (uint32_t i = 0; i < MAX_DISPLAYS; i++) 139 ctx->mLayerCache[i] = new LayerCache(); 140 ctx->mMDPComp = MDPComp::getObject(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xres); 141 MDPComp::init(ctx); 142 143 pthread_mutex_init(&(ctx->vstate.lock), NULL); 144 pthread_cond_init(&(ctx->vstate.cond), NULL); 145 ctx->vstate.enable = false; 146 ctx->vstate.fakevsync = false; 147 ctx->mExtDispConfiguring = false; 148 149 //Right now hwc starts the service but anybody could do it, or it could be 150 //independent process as well. 151 QService::init(); 152 sp<IQClient> client = new QClient(ctx); 153 interface_cast<IQService>( 154 defaultServiceManager()->getService( 155 String16("display.qservice")))->connect(client); 156 157 ALOGI("Initializing Qualcomm Hardware Composer"); 158 ALOGI("MDP version: %d", ctx->mMDP.version); 159} 160 161void closeContext(hwc_context_t *ctx) 162{ 163 if(ctx->mOverlay) { 164 delete ctx->mOverlay; 165 ctx->mOverlay = NULL; 166 } 167 168 if(ctx->mRotMgr) { 169 delete ctx->mRotMgr; 170 ctx->mRotMgr = NULL; 171 } 172 173 for(int i = 0; i < MAX_DISPLAYS; i++) { 174 if(ctx->mCopyBit[i]) { 175 delete ctx->mCopyBit[i]; 176 ctx->mCopyBit[i] = NULL; 177 } 178 } 179 180 if(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].fd) { 181 close(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].fd); 182 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].fd = -1; 183 } 184 185 if(ctx->mExtDisplay) { 186 delete ctx->mExtDisplay; 187 ctx->mExtDisplay = NULL; 188 } 189 190 for(int i = 0; i < MAX_DISPLAYS; i++) { 191 if(ctx->mFBUpdate[i]) { 192 delete ctx->mFBUpdate[i]; 193 ctx->mFBUpdate[i] = NULL; 194 } 195 if(ctx->mVidOv[i]) { 196 delete ctx->mVidOv[i]; 197 ctx->mVidOv[i] = NULL; 198 } 199 } 200 201 if(ctx->mMDPComp) { 202 delete ctx->mMDPComp; 203 ctx->mMDPComp = NULL; 204 } 205 206 pthread_mutex_destroy(&(ctx->vstate.lock)); 207 pthread_cond_destroy(&(ctx->vstate.cond)); 208} 209 210 211void dumpsys_log(android::String8& buf, const char* fmt, ...) 212{ 213 va_list varargs; 214 va_start(varargs, fmt); 215 buf.appendFormatV(fmt, varargs); 216 va_end(varargs); 217} 218 219/* Calculates the destination position based on the action safe rectangle */ 220void getActionSafePosition(hwc_context_t *ctx, int dpy, uint32_t& x, 221 uint32_t& y, uint32_t& w, uint32_t& h) { 222 223 // if external supports underscan, do nothing 224 // it will be taken care in the driver 225 if(ctx->mExtDisplay->isCEUnderscanSupported()) 226 return; 227 228 float wRatio = 1.0; 229 float hRatio = 1.0; 230 float xRatio = 1.0; 231 float yRatio = 1.0; 232 233 float fbWidth = ctx->dpyAttr[dpy].xres; 234 float fbHeight = ctx->dpyAttr[dpy].yres; 235 236 float asX = 0; 237 float asY = 0; 238 float asW = fbWidth; 239 float asH= fbHeight; 240 char value[PROPERTY_VALUE_MAX]; 241 242 // Apply action safe parameters 243 property_get("hw.actionsafe.width", value, "0"); 244 int asWidthRatio = atoi(value); 245 property_get("hw.actionsafe.height", value, "0"); 246 int asHeightRatio = atoi(value); 247 // based on the action safe ratio, get the Action safe rectangle 248 asW = fbWidth * (1.0f - asWidthRatio / 100.0f); 249 asH = fbHeight * (1.0f - asHeightRatio / 100.0f); 250 asX = (fbWidth - asW) / 2; 251 asY = (fbHeight - asH) / 2; 252 253 // calculate the position ratio 254 xRatio = (float)x/fbWidth; 255 yRatio = (float)y/fbHeight; 256 wRatio = (float)w/fbWidth; 257 hRatio = (float)h/fbHeight; 258 259 //Calculate the position... 260 x = (xRatio * asW) + asX; 261 y = (yRatio * asH) + asY; 262 w = (wRatio * asW); 263 h = (hRatio * asH); 264 265 return; 266} 267 268bool needsScaling(hwc_layer_1_t const* layer) { 269 int dst_w, dst_h, src_w, src_h; 270 271 hwc_rect_t displayFrame = layer->displayFrame; 272 hwc_rect_t sourceCrop = layer->sourceCrop; 273 274 dst_w = displayFrame.right - displayFrame.left; 275 dst_h = displayFrame.bottom - displayFrame.top; 276 277 src_w = sourceCrop.right - sourceCrop.left; 278 src_h = sourceCrop.bottom - sourceCrop.top; 279 280 if(((src_w != dst_w) || (src_h != dst_h))) 281 return true; 282 283 return false; 284} 285 286bool isAlphaScaled(hwc_layer_1_t const* layer) { 287 if(needsScaling(layer)) { 288 if(layer->blending != HWC_BLENDING_NONE) 289 return true; 290 } 291 return false; 292} 293 294void setListStats(hwc_context_t *ctx, 295 const hwc_display_contents_1_t *list, int dpy) { 296 297 ctx->listStats[dpy].numAppLayers = list->numHwLayers - 1; 298 ctx->listStats[dpy].fbLayerIndex = list->numHwLayers - 1; 299 ctx->listStats[dpy].skipCount = 0; 300 ctx->listStats[dpy].needsAlphaScale = false; 301 ctx->listStats[dpy].yuvCount = 0; 302 ctx->mDMAInUse = false; 303 304 for (size_t i = 0; i < list->numHwLayers; i++) { 305 hwc_layer_1_t const* layer = &list->hwLayers[i]; 306 private_handle_t *hnd = (private_handle_t *)layer->handle; 307 308 //reset stored yuv index 309 ctx->listStats[dpy].yuvIndices[i] = -1; 310 311 if(list->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET) { 312 continue; 313 //We disregard FB being skip for now! so the else if 314 } else if (isSkipLayer(&list->hwLayers[i])) { 315 ctx->listStats[dpy].skipCount++; 316 } else if (UNLIKELY(isYuvBuffer(hnd))) { 317 int& yuvCount = ctx->listStats[dpy].yuvCount; 318 ctx->listStats[dpy].yuvIndices[yuvCount] = i; 319 yuvCount++; 320 321 if((layer->transform & HWC_TRANSFORM_ROT_90) && !ctx->mDMAInUse) 322 ctx->mDMAInUse = true; 323 } 324 325 if(!ctx->listStats[dpy].needsAlphaScale) 326 ctx->listStats[dpy].needsAlphaScale = isAlphaScaled(layer); 327 } 328} 329 330 331static inline void calc_cut(float& leftCutRatio, float& topCutRatio, 332 float& rightCutRatio, float& bottomCutRatio, int orient) { 333 if(orient & HAL_TRANSFORM_FLIP_H) { 334 swap(leftCutRatio, rightCutRatio); 335 } 336 if(orient & HAL_TRANSFORM_FLIP_V) { 337 swap(topCutRatio, bottomCutRatio); 338 } 339 if(orient & HAL_TRANSFORM_ROT_90) { 340 //Anti clock swapping 341 float tmpCutRatio = leftCutRatio; 342 leftCutRatio = topCutRatio; 343 topCutRatio = rightCutRatio; 344 rightCutRatio = bottomCutRatio; 345 bottomCutRatio = tmpCutRatio; 346 } 347} 348 349bool isSecuring(hwc_context_t* ctx) { 350 if((ctx->mMDP.version < qdutils::MDSS_V5) && 351 (ctx->mMDP.version > qdutils::MDP_V3_0) && 352 ctx->mSecuring) { 353 return true; 354 } 355 return false; 356} 357 358bool isSecureModePolicy(int mdpVersion) { 359 if (mdpVersion < qdutils::MDSS_V5) 360 return true; 361 else 362 return false; 363} 364 365//Crops source buffer against destination and FB boundaries 366void calculate_crop_rects(hwc_rect_t& crop, hwc_rect_t& dst, 367 const hwc_rect_t& scissor, int orient) { 368 369 int& crop_l = crop.left; 370 int& crop_t = crop.top; 371 int& crop_r = crop.right; 372 int& crop_b = crop.bottom; 373 int crop_w = crop.right - crop.left; 374 int crop_h = crop.bottom - crop.top; 375 376 int& dst_l = dst.left; 377 int& dst_t = dst.top; 378 int& dst_r = dst.right; 379 int& dst_b = dst.bottom; 380 int dst_w = abs(dst.right - dst.left); 381 int dst_h = abs(dst.bottom - dst.top); 382 383 const int& sci_l = scissor.left; 384 const int& sci_t = scissor.top; 385 const int& sci_r = scissor.right; 386 const int& sci_b = scissor.bottom; 387 int sci_w = abs(sci_r - sci_l); 388 int sci_h = abs(sci_b - sci_t); 389 390 float leftCutRatio = 0.0f, rightCutRatio = 0.0f, topCutRatio = 0.0f, 391 bottomCutRatio = 0.0f; 392 393 if(dst_l < sci_l) { 394 leftCutRatio = (float)(sci_l - dst_l) / (float)dst_w; 395 dst_l = sci_l; 396 } 397 398 if(dst_r > sci_r) { 399 rightCutRatio = (float)(dst_r - sci_r) / (float)dst_w; 400 dst_r = sci_r; 401 } 402 403 if(dst_t < sci_t) { 404 topCutRatio = (float)(sci_t - dst_t) / (float)dst_h; 405 dst_t = sci_t; 406 } 407 408 if(dst_b > sci_b) { 409 bottomCutRatio = (float)(dst_b - sci_b) / (float)dst_h; 410 dst_b = sci_b; 411 } 412 413 calc_cut(leftCutRatio, topCutRatio, rightCutRatio, bottomCutRatio, orient); 414 crop_l += crop_w * leftCutRatio; 415 crop_t += crop_h * topCutRatio; 416 crop_r -= crop_w * rightCutRatio; 417 crop_b -= crop_h * bottomCutRatio; 418} 419 420void getNonWormholeRegion(hwc_display_contents_1_t* list, 421 hwc_rect_t& nwr) 422{ 423 uint32_t last = list->numHwLayers - 1; 424 hwc_rect_t fbDisplayFrame = list->hwLayers[last].displayFrame; 425 //Initiliaze nwr to first frame 426 nwr.left = list->hwLayers[0].displayFrame.left; 427 nwr.top = list->hwLayers[0].displayFrame.top; 428 nwr.right = list->hwLayers[0].displayFrame.right; 429 nwr.bottom = list->hwLayers[0].displayFrame.bottom; 430 431 for (uint32_t i = 1; i < last; i++) { 432 hwc_rect_t displayFrame = list->hwLayers[i].displayFrame; 433 nwr.left = min(nwr.left, displayFrame.left); 434 nwr.top = min(nwr.top, displayFrame.top); 435 nwr.right = max(nwr.right, displayFrame.right); 436 nwr.bottom = max(nwr.bottom, displayFrame.bottom); 437 } 438 439 //Intersect with the framebuffer 440 nwr.left = max(nwr.left, fbDisplayFrame.left); 441 nwr.top = max(nwr.top, fbDisplayFrame.top); 442 nwr.right = min(nwr.right, fbDisplayFrame.right); 443 nwr.bottom = min(nwr.bottom, fbDisplayFrame.bottom); 444 445} 446 447bool isExternalActive(hwc_context_t* ctx) { 448 return ctx->dpyAttr[HWC_DISPLAY_EXTERNAL].isActive; 449} 450 451void closeAcquireFds(hwc_display_contents_1_t* list) { 452 for(uint32_t i = 0; list && i < list->numHwLayers; i++) { 453 //Close the acquireFenceFds 454 //HWC_FRAMEBUFFER are -1 already by SF, rest we close. 455 if(list->hwLayers[i].acquireFenceFd >= 0) { 456 close(list->hwLayers[i].acquireFenceFd); 457 list->hwLayers[i].acquireFenceFd = -1; 458 } 459 } 460} 461 462int hwc_sync(hwc_context_t *ctx, hwc_display_contents_1_t* list, int dpy, 463 int fd) { 464 int ret = 0; 465 struct mdp_buf_sync data; 466 int acquireFd[MAX_NUM_LAYERS]; 467 int count = 0; 468 int releaseFd = -1; 469 int fbFd = -1; 470 memset(&data, 0, sizeof(data)); 471 bool swapzero = false; 472 data.flags = MDP_BUF_SYNC_FLAG_WAIT; 473 data.acq_fen_fd = acquireFd; 474 data.rel_fen_fd = &releaseFd; 475 char property[PROPERTY_VALUE_MAX]; 476 if(property_get("debug.egl.swapinterval", property, "1") > 0) { 477 if(atoi(property) == 0) 478 swapzero = true; 479 } 480 481 //Accumulate acquireFenceFds 482 for(uint32_t i = 0; i < list->numHwLayers; i++) { 483 if(list->hwLayers[i].compositionType == HWC_OVERLAY && 484 list->hwLayers[i].acquireFenceFd != -1) { 485 if(UNLIKELY(swapzero)) 486 acquireFd[count++] = -1; 487 else 488 acquireFd[count++] = list->hwLayers[i].acquireFenceFd; 489 } 490 if(list->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET) { 491 if(UNLIKELY(swapzero)) 492 acquireFd[count++] = -1; 493 else if(fd != -1) { 494 //set the acquireFD from fd - which is coming from c2d 495 acquireFd[count++] = fd; 496 // Buffer sync IOCTL should be async when using c2d fence is 497 // used 498 data.flags &= ~MDP_BUF_SYNC_FLAG_WAIT; 499 } else if(list->hwLayers[i].acquireFenceFd != -1) 500 acquireFd[count++] = list->hwLayers[i].acquireFenceFd; 501 } 502 } 503 504 data.acq_fen_fd_cnt = count; 505 fbFd = ctx->dpyAttr[dpy].fd; 506 //Waits for acquire fences, returns a release fence 507 if(LIKELY(!swapzero)) { 508 uint64_t start = systemTime(); 509 ret = ioctl(fbFd, MSMFB_BUFFER_SYNC, &data); 510 ALOGD_IF(HWC_UTILS_DEBUG, "%s: time taken for MSMFB_BUFFER_SYNC IOCTL = %d", 511 __FUNCTION__, (size_t) ns2ms(systemTime() - start)); 512 } 513 514 if(ret < 0) { 515 ALOGE("ioctl MSMFB_BUFFER_SYNC failed, err=%s", 516 strerror(errno)); 517 } 518 519 for(uint32_t i = 0; i < list->numHwLayers; i++) { 520 if(list->hwLayers[i].compositionType == HWC_OVERLAY || 521 list->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET) { 522 //Populate releaseFenceFds. 523 if(UNLIKELY(swapzero)) 524 list->hwLayers[i].releaseFenceFd = -1; 525 else 526 list->hwLayers[i].releaseFenceFd = dup(releaseFd); 527 } 528 } 529 530 if(fd >= 0) { 531 close(fd); 532 fd = -1; 533 } 534 535 if (ctx->mCopyBit[dpy]) 536 ctx->mCopyBit[dpy]->setReleaseFd(releaseFd); 537 if(UNLIKELY(swapzero)){ 538 list->retireFenceFd = -1; 539 close(releaseFd); 540 } else { 541 list->retireFenceFd = releaseFd; 542 } 543 544 return ret; 545} 546 547void trimLayer(hwc_context_t *ctx, const int& dpy, const int& transform, 548 hwc_rect_t& crop, hwc_rect_t& dst) { 549 int hw_w = ctx->dpyAttr[dpy].xres; 550 int hw_h = ctx->dpyAttr[dpy].yres; 551 if(dst.left < 0 || dst.top < 0 || 552 dst.right > hw_w || dst.bottom > hw_h) { 553 hwc_rect_t scissor = {0, 0, hw_w, hw_h }; 554 qhwc::calculate_crop_rects(crop, dst, scissor, transform); 555 } 556} 557 558void setMdpFlags(hwc_layer_1_t *layer, 559 ovutils::eMdpFlags &mdpFlags, 560 int rotDownscale) { 561 private_handle_t *hnd = (private_handle_t *)layer->handle; 562 MetaData_t *metadata = (MetaData_t *)hnd->base_metadata; 563 const int& transform = layer->transform; 564 565 if(layer->blending == HWC_BLENDING_PREMULT) { 566 ovutils::setMdpFlags(mdpFlags, 567 ovutils::OV_MDP_BLEND_FG_PREMULT); 568 } 569 570 if(isYuvBuffer(hnd)) { 571 if(isSecureBuffer(hnd)) { 572 ovutils::setMdpFlags(mdpFlags, 573 ovutils::OV_MDP_SECURE_OVERLAY_SESSION); 574 } 575 if(metadata && (metadata->operation & PP_PARAM_INTERLACED) && 576 metadata->interlaced) { 577 ovutils::setMdpFlags(mdpFlags, 578 ovutils::OV_MDP_DEINTERLACE); 579 } 580 //Pre-rotation will be used using rotator. 581 if(transform & HWC_TRANSFORM_ROT_90) { 582 ovutils::setMdpFlags(mdpFlags, 583 ovutils::OV_MDP_SOURCE_ROTATED_90); 584 } 585 } 586 587 //No 90 component and no rot-downscale then flips done by MDP 588 //If we use rot then it might as well do flips 589 if(!(layer->transform & HWC_TRANSFORM_ROT_90) && !rotDownscale) { 590 if(layer->transform & HWC_TRANSFORM_FLIP_H) { 591 ovutils::setMdpFlags(mdpFlags, ovutils::OV_MDP_FLIP_H); 592 } 593 594 if(layer->transform & HWC_TRANSFORM_FLIP_V) { 595 ovutils::setMdpFlags(mdpFlags, ovutils::OV_MDP_FLIP_V); 596 } 597 } 598} 599 600static inline int configRotator(Rotator *rot, const Whf& whf, 601 const eMdpFlags& mdpFlags, const eTransform& orient, 602 const int& downscale) { 603 rot->setSource(whf); 604 rot->setFlags(mdpFlags); 605 rot->setTransform(orient); 606 rot->setDownscale(downscale); 607 if(!rot->commit()) return -1; 608 return 0; 609} 610 611static inline int configMdp(Overlay *ov, const PipeArgs& parg, 612 const eTransform& orient, const hwc_rect_t& crop, 613 const hwc_rect_t& pos, const eDest& dest) { 614 ov->setSource(parg, dest); 615 ov->setTransform(orient, dest); 616 617 int crop_w = crop.right - crop.left; 618 int crop_h = crop.bottom - crop.top; 619 Dim dcrop(crop.left, crop.top, crop_w, crop_h); 620 ov->setCrop(dcrop, dest); 621 622 int posW = pos.right - pos.left; 623 int posH = pos.bottom - pos.top; 624 Dim position(pos.left, pos.top, posW, posH); 625 ov->setPosition(position, dest); 626 627 if (!ov->commit(dest)) { 628 return -1; 629 } 630 return 0; 631} 632 633static inline void updateSource(eTransform& orient, Whf& whf, 634 hwc_rect_t& crop) { 635 Dim srcCrop(crop.left, crop.top, 636 crop.right - crop.left, 637 crop.bottom - crop.top); 638 //getMdpOrient will switch the flips if the source is 90 rotated. 639 //Clients in Android dont factor in 90 rotation while deciding the flip. 640 orient = static_cast<eTransform>(ovutils::getMdpOrient(orient)); 641 preRotateSource(orient, whf, srcCrop); 642 crop.left = srcCrop.x; 643 crop.top = srcCrop.y; 644 crop.right = srcCrop.x + srcCrop.w; 645 crop.bottom = srcCrop.y + srcCrop.h; 646} 647 648int configureLowRes(hwc_context_t *ctx, hwc_layer_1_t *layer, 649 const int& dpy, eMdpFlags& mdpFlags, const eZorder& z, 650 const eIsFg& isFg, const eDest& dest, Rotator **rot) { 651 652 private_handle_t *hnd = (private_handle_t *)layer->handle; 653 if(!hnd) { 654 ALOGE("%s: layer handle is NULL", __FUNCTION__); 655 return -1; 656 } 657 658 hwc_rect_t crop = layer->sourceCrop; 659 hwc_rect_t dst = layer->displayFrame; 660 int transform = layer->transform; 661 eTransform orient = static_cast<eTransform>(transform); 662 int downscale = 0; 663 int rotFlags = ovutils::ROT_FLAGS_NONE; 664 Whf whf(hnd->width, hnd->height, 665 getMdpFormat(hnd->format), hnd->size); 666 667 if(isYuvBuffer(hnd) && ctx->mMDP.version >= qdutils::MDP_V4_2 && 668 ctx->mMDP.version < qdutils::MDSS_V5) { 669 downscale = getDownscaleFactor( 670 crop.right - crop.left, 671 crop.bottom - crop.top, 672 dst.right - dst.left, 673 dst.bottom - dst.top); 674 if(downscale) { 675 rotFlags = ROT_DOWNSCALE_ENABLED; 676 } 677 } 678 679 setMdpFlags(layer, mdpFlags, downscale); 680 trimLayer(ctx, dpy, transform, crop, dst); 681 682 if(isYuvBuffer(hnd) && //if 90 component or downscale, use rot 683 ((transform & HWC_TRANSFORM_ROT_90) || downscale)) { 684 *rot = ctx->mRotMgr->getNext(); 685 if(*rot == NULL) return -1; 686 //Configure rotator for pre-rotation 687 if(configRotator(*rot, whf, mdpFlags, orient, downscale) < 0) 688 return -1; 689 whf.format = (*rot)->getDstFormat(); 690 updateSource(orient, whf, crop); 691 rotFlags |= ovutils::ROT_PREROTATED; 692 } 693 694 //For the mdp, since either we are pre-rotating or MDP does flips 695 orient = OVERLAY_TRANSFORM_0; 696 transform = 0; 697 698 PipeArgs parg(mdpFlags, whf, z, isFg, static_cast<eRotFlags>(rotFlags)); 699 if(configMdp(ctx->mOverlay, parg, orient, crop, dst, dest) < 0) { 700 ALOGE("%s: commit failed for low res panel", __FUNCTION__); 701 return -1; 702 } 703 return 0; 704} 705 706int configureHighRes(hwc_context_t *ctx, hwc_layer_1_t *layer, 707 const int& dpy, eMdpFlags& mdpFlagsL, const eZorder& z, 708 const eIsFg& isFg, const eDest& lDest, const eDest& rDest, 709 Rotator **rot) { 710 private_handle_t *hnd = (private_handle_t *)layer->handle; 711 if(!hnd) { 712 ALOGE("%s: layer handle is NULL", __FUNCTION__); 713 return -1; 714 } 715 716 int hw_w = ctx->dpyAttr[dpy].xres; 717 int hw_h = ctx->dpyAttr[dpy].yres; 718 hwc_rect_t crop = layer->sourceCrop; 719 hwc_rect_t dst = layer->displayFrame; 720 int transform = layer->transform; 721 eTransform orient = static_cast<eTransform>(transform); 722 const int downscale = 0; 723 int rotFlags = ROT_FLAGS_NONE; 724 725 Whf whf(hnd->width, hnd->height, 726 getMdpFormat(hnd->format), hnd->size); 727 728 setMdpFlags(layer, mdpFlagsL); 729 trimLayer(ctx, dpy, transform, crop, dst); 730 731 if(isYuvBuffer(hnd) && (transform & HWC_TRANSFORM_ROT_90)) { 732 (*rot) = ctx->mRotMgr->getNext(); 733 if((*rot) == NULL) return -1; 734 //Configure rotator for pre-rotation 735 if(configRotator(*rot, whf, mdpFlagsL, orient, downscale) < 0) 736 return -1; 737 whf.format = (*rot)->getDstFormat(); 738 updateSource(orient, whf, crop); 739 rotFlags |= ROT_PREROTATED; 740 } 741 742 eMdpFlags mdpFlagsR = mdpFlagsL; 743 setMdpFlags(mdpFlagsR, OV_MDSS_MDP_RIGHT_MIXER); 744 745 hwc_rect_t tmp_cropL, tmp_dstL; 746 hwc_rect_t tmp_cropR, tmp_dstR; 747 748 if(lDest != OV_INVALID) { 749 tmp_cropL = crop; 750 tmp_dstL = dst; 751 hwc_rect_t scissor = {0, 0, hw_w/2, hw_h }; 752 qhwc::calculate_crop_rects(tmp_cropL, tmp_dstL, scissor, 0); 753 } 754 if(rDest != OV_INVALID) { 755 tmp_cropR = crop; 756 tmp_dstR = dst; 757 hwc_rect_t scissor = {hw_w/2, 0, hw_w, hw_h }; 758 qhwc::calculate_crop_rects(tmp_cropR, tmp_dstR, scissor, 0); 759 } 760 761 //When buffer is flipped, contents of mixer config also needs to swapped. 762 //Not needed if the layer is confined to one half of the screen. 763 //If rotator has been used then it has also done the flips, so ignore them. 764 if((orient & OVERLAY_TRANSFORM_FLIP_V) && lDest != OV_INVALID 765 && rDest != OV_INVALID && rot == NULL) { 766 hwc_rect_t new_cropR; 767 new_cropR.left = tmp_cropL.left; 768 new_cropR.right = new_cropR.left + (tmp_cropR.right - tmp_cropR.left); 769 770 hwc_rect_t new_cropL; 771 new_cropL.left = new_cropR.right; 772 new_cropL.right = tmp_cropR.right; 773 774 tmp_cropL.left = new_cropL.left; 775 tmp_cropL.right = new_cropL.right; 776 777 tmp_cropR.left = new_cropR.left; 778 tmp_cropR.right = new_cropR.right; 779 780 } 781 782 //For the mdp, since either we are pre-rotating or MDP does flips 783 orient = OVERLAY_TRANSFORM_0; 784 transform = 0; 785 786 //configure left mixer 787 if(lDest != OV_INVALID) { 788 PipeArgs pargL(mdpFlagsL, whf, z, isFg, 789 static_cast<eRotFlags>(rotFlags)); 790 if(configMdp(ctx->mOverlay, pargL, orient, 791 tmp_cropL, tmp_dstL, lDest) < 0) { 792 ALOGE("%s: commit failed for left mixer config", __FUNCTION__); 793 return -1; 794 } 795 } 796 797 //configure right mixer 798 if(rDest != OV_INVALID) { 799 PipeArgs pargR(mdpFlagsR, whf, z, isFg, 800 static_cast<eRotFlags>(rotFlags)); 801 if(configMdp(ctx->mOverlay, pargR, orient, 802 tmp_cropR, tmp_dstR, rDest) < 0) { 803 ALOGE("%s: commit failed for right mixer config", __FUNCTION__); 804 return -1; 805 } 806 } 807 808 return 0; 809} 810 811void LayerCache::resetLayerCache(int num) { 812 for(uint32_t i = 0; i < MAX_NUM_LAYERS; i++) { 813 hnd[i] = NULL; 814 } 815 numHwLayers = num; 816} 817 818void LayerCache::updateLayerCache(hwc_display_contents_1_t* list) { 819 820 int numFbLayers = 0; 821 int numCacheableLayers = 0; 822 823 canUseLayerCache = false; 824 //Bail if geometry changed or num of layers changed 825 if(list->flags & HWC_GEOMETRY_CHANGED || 826 list->numHwLayers != numHwLayers ) { 827 resetLayerCache(list->numHwLayers); 828 return; 829 } 830 831 for(uint32_t i = 0; i < list->numHwLayers; i++) { 832 //Bail on skip layers 833 if(list->hwLayers[i].flags & HWC_SKIP_LAYER) { 834 resetLayerCache(list->numHwLayers); 835 return; 836 } 837 838 if(list->hwLayers[i].compositionType == HWC_FRAMEBUFFER) { 839 numFbLayers++; 840 if(hnd[i] == NULL) { 841 hnd[i] = list->hwLayers[i].handle; 842 } else if (hnd[i] == 843 list->hwLayers[i].handle) { 844 numCacheableLayers++; 845 } else { 846 hnd[i] = NULL; 847 return; 848 } 849 } else { 850 hnd[i] = NULL; 851 } 852 } 853 if(numFbLayers == numCacheableLayers) 854 canUseLayerCache = true; 855 856 //XXX: The marking part is separate, if MDP comp wants 857 // to use it in the future. Right now getting MDP comp 858 // to use this is more trouble than it is worth. 859 markCachedLayersAsOverlay(list); 860} 861 862void LayerCache::markCachedLayersAsOverlay(hwc_display_contents_1_t* list) { 863 //This optimization only works if ALL the layer handles 864 //that were on the framebuffer didn't change. 865 if(canUseLayerCache){ 866 for(uint32_t i = 0; i < list->numHwLayers; i++) { 867 if (list->hwLayers[i].handle && 868 list->hwLayers[i].handle == hnd[i] && 869 list->hwLayers[i].compositionType != HWC_FRAMEBUFFER_TARGET) 870 { 871 list->hwLayers[i].compositionType = HWC_OVERLAY; 872 } 873 } 874 } 875} 876 877};//namespace qhwc 878