1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * Copyright (C)2012-2014, 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 21 #ifndef HWC_UTILS_H 22 #define HWC_UTILS_H 23 24 #define DEBUG_MDPDOWNSCALE 0 25 #define HWC_REMOVE_DEPRECATED_VERSIONS 1 26 27 #include <fcntl.h> 28 #include <math.h> 29 #include <hardware/hwcomposer.h> 30 #include <gr.h> 31 #include <gralloc_priv.h> 32 #include <utils/String8.h> 33 #include "qdMetaData.h" 34 #include "mdp_version.h" 35 #include <overlayUtils.h> 36 #include <overlayRotator.h> 37 #include <EGL/egl.h> 38 39 40 #define ALIGN_TO(x, align) (((x) + ((align)-1)) & ~((align)-1)) 41 #define LIKELY( exp ) (__builtin_expect( (exp) != 0, true )) 42 #define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false )) 43 #define MAX_NUM_APP_LAYERS 32 44 #define MAX_NUM_BLEND_STAGES 16 45 #define MIN_DISPLAY_XRES 200 46 #define MIN_DISPLAY_YRES 200 47 #define HWC_WFDDISPSYNC_LOG 0 48 #define STR(f) #f; 49 // Max number of PTOR layers handled 50 #define MAX_PTOR_LAYERS 2 51 #define MAX_NUM_COLOR_MODES 32 52 53 //Fwrd decls 54 struct hwc_context_t; 55 56 namespace ovutils = overlay::utils; 57 58 namespace overlay { 59 class Overlay; 60 class Rotator; 61 class RotMgr; 62 } 63 64 namespace qhwc { 65 //fwrd decl 66 class QueuedBufferStore; 67 class HDMIDisplay; 68 class VirtualDisplay; 69 class IFBUpdate; 70 class IVideoOverlay; 71 class MDPComp; 72 class CopyBit; 73 class HwcDebug; 74 class AssertiveDisplay; 75 class HWCVirtualVDS; 76 77 78 struct MDPInfo { 79 int version; 80 char panel; 81 bool hasOverlay; 82 }; 83 84 struct DisplayAttributes { 85 uint32_t refreshRate; 86 uint32_t dynRefreshRate; 87 uint32_t vsync_period; //nanos 88 uint32_t xres; 89 uint32_t yres; 90 uint32_t stride; 91 float xdpi; 92 float ydpi; 93 bool secure; 94 int fd; 95 bool connected; //Applies only to pluggable disp. 96 //Connected does not mean it ready to use. 97 //It should be active also. (UNBLANKED) 98 bool isActive; 99 // In pause state, composition is bypassed 100 // used for WFD displays and in QDCM calibration mode 101 bool isPause; 102 // To trigger padding round to clean up mdp 103 // pipes 104 bool isConfiguring; 105 // Indicates whether external/virtual display is in MDP scaling mode 106 bool mMDPScalingMode; 107 // Ext dst Rect 108 hwc_rect_t mDstRect; 109 //Action safe attributes 110 // Flag to indicate the presence of action safe dimensions for external 111 bool mActionSafePresent; 112 int mAsWidthRatio; 113 int mAsHeightRatio; 114 115 //If property fbsize set via adb shell debug.hwc.fbsize = XRESxYRES 116 //following fields are used. 117 bool customFBSize; 118 uint32_t xres_new; 119 uint32_t yres_new; 120 121 }; 122 123 struct ListStats { 124 int numAppLayers; //Total - 1, excluding FB layer. 125 int skipCount; 126 int fbLayerIndex; //Always last for now. = numAppLayers 127 //Video specific 128 int yuvCount; 129 int yuvIndices[MAX_NUM_APP_LAYERS]; 130 bool preMultipliedAlpha; 131 int yuv4k2kIndices[MAX_NUM_APP_LAYERS]; 132 int yuv4k2kCount; 133 // Notifies hwcomposer about the start and end of animation 134 // This will be set to true during animation, otherwise false. 135 bool isDisplayAnimating; 136 bool secureUI; // Secure display layer 137 bool isSecurePresent; 138 hwc_rect_t lRoi; //left ROI 139 hwc_rect_t rRoi; //right ROI. Unused in single DSI panels. 140 //App Buffer Composition index 141 int renderBufIndexforABC; 142 // Secure RGB specific 143 int secureRGBCount; 144 int secureRGBIndices[MAX_NUM_APP_LAYERS]; 145 //dyn refresh rate-Client requested refreshrate 146 uint32_t refreshRateRequest; 147 // Flag related to windowboxing feature 148 bool mAIVVideoMode; 149 }; 150 151 //PTOR Comp info 152 struct PtorInfo { 153 int count; 154 int layerIndex[MAX_PTOR_LAYERS]; 155 hwc_rect_t displayFrame[MAX_PTOR_LAYERS]; isActivePtorInfo156 bool isActive() { return (count>0); } getPTORArrayIndexPtorInfo157 int getPTORArrayIndex(int index) { 158 int idx = -1; 159 for(int i = 0; i < count; i++) { 160 if(index == layerIndex[i]) 161 idx = i; 162 } 163 return idx; 164 } 165 }; 166 167 struct LayerProp { 168 uint32_t mFlags; //qcom specific layer flags LayerPropLayerProp169 LayerProp():mFlags(0){}; 170 }; 171 172 struct VsyncState { 173 bool enable; 174 bool fakevsync; 175 bool debug; 176 }; 177 178 struct BwcPM { 179 static void setBwc(const hwc_context_t *ctx, const int& dpy, 180 const private_handle_t *hnd, 181 const hwc_rect_t& crop, const hwc_rect_t& dst, 182 const int& transform, const int& downscale, 183 ovutils::eMdpFlags& mdpFlags); 184 }; 185 186 // LayerProp::flag values 187 enum { 188 HWC_MDPCOMP = 0x00000001, 189 HWC_COPYBIT = 0x00000002, 190 }; 191 192 // AIV specific flags 193 enum { 194 HWC_AIV_VIDEO = 0x80000000, 195 HWC_AIV_CC = 0x40000000, 196 }; 197 198 // HAL specific features 199 enum { 200 HWC_COLOR_FILL = 0x00000008, 201 HWC_FORMAT_RB_SWAP = 0x00000040, 202 }; 203 204 /* External Display states */ 205 enum { 206 EXTERNAL_OFFLINE = 0, 207 EXTERNAL_ONLINE, 208 EXTERNAL_PAUSE, 209 EXTERNAL_RESUME, 210 EXTERNAL_MAXSTATES 211 }; 212 213 class LayerRotMap { 214 public: LayerRotMap()215 LayerRotMap() { reset(); } 216 void add(hwc_layer_1_t* layer, overlay::Rotator *rot); 217 //Resets the mapping of layer to rotator 218 void reset(); 219 //Clears mappings and existing rotator fences 220 //Intended to be used during errors 221 void clear(); 222 uint32_t getCount() const; 223 hwc_layer_1_t* getLayer(uint32_t index) const; 224 overlay::Rotator* getRot(uint32_t index) const; 225 bool isRotCached(uint32_t index) const; 226 void setReleaseFd(const int& fence); 227 private: 228 hwc_layer_1_t* mLayer[overlay::RotMgr::MAX_ROT_SESS]; 229 overlay::Rotator* mRot[overlay::RotMgr::MAX_ROT_SESS]; 230 uint32_t mCount; 231 }; 232 233 //ColorModes for primary displays 234 class ColorMode { 235 public: 236 void init(); 237 void destroy(); getNumModes()238 int32_t getNumModes() { return mNumModes; } getModeList()239 const int32_t* getModeList() { return mModeList; } 240 int32_t getModeForIndex(int32_t index); 241 int32_t getIndexForMode(int32_t mode); 242 int applyDefaultMode(); 243 int applyModeByID(int modeID); 244 int applyModeByIndex(int index); 245 int setDefaultMode(int modeID); getActiveModeIndex()246 int getActiveModeIndex() { return mCurModeIndex; } 247 private: 248 int32_t (*fnGetNumModes)(int /*dispID*/); 249 int32_t (*fnGetModeList)(int32_t* /*mModeList*/, int32_t* /*current default*/, 250 int32_t /*dispID*/); 251 int (*fnApplyDefaultMode)(int /*dispID*/); 252 int (*fnApplyModeById)(int /*modeID*/, int /*dispID*/); 253 int (*fnSetDefaultMode)(int /*modeID*/, int /*dispID*/); 254 255 void* mModeHandle = NULL; 256 int32_t mModeList[MAX_NUM_COLOR_MODES]; 257 int32_t mNumModes = 0; 258 int32_t mCurModeIndex = 0; 259 int32_t mCurMode = 0; 260 261 }; 262 getCount()263 inline uint32_t LayerRotMap::getCount() const { 264 return mCount; 265 } 266 getLayer(uint32_t index)267 inline hwc_layer_1_t* LayerRotMap::getLayer(uint32_t index) const { 268 if(index >= mCount) return NULL; 269 return mLayer[index]; 270 } 271 getRot(uint32_t index)272 inline overlay::Rotator* LayerRotMap::getRot(uint32_t index) const { 273 if(index >= mCount) return NULL; 274 return mRot[index]; 275 } 276 integerizeSourceCrop(const hwc_frect_t & cropF)277 inline hwc_rect_t integerizeSourceCrop(const hwc_frect_t& cropF) { 278 hwc_rect_t cropI = {0,0,0,0}; 279 cropI.left = int(ceilf(cropF.left)); 280 cropI.top = int(ceilf(cropF.top)); 281 cropI.right = int(floorf(cropF.right)); 282 cropI.bottom = int(floorf(cropF.bottom)); 283 return cropI; 284 } 285 isNonIntegralSourceCrop(const hwc_frect_t & cropF)286 inline bool isNonIntegralSourceCrop(const hwc_frect_t& cropF) { 287 if(cropF.left - roundf(cropF.left) || 288 cropF.top - roundf(cropF.top) || 289 cropF.right - roundf(cropF.right) || 290 cropF.bottom - roundf(cropF.bottom)) 291 return true; 292 else 293 return false; 294 } 295 296 // ----------------------------------------------------------------------------- 297 // Utility functions - implemented in hwc_utils.cpp 298 void dumpLayer(hwc_layer_1_t const* l); 299 void setListStats(hwc_context_t *ctx, hwc_display_contents_1_t *list, 300 int dpy); 301 void initContext(hwc_context_t *ctx); 302 void closeContext(hwc_context_t *ctx); 303 //Crops source buffer against destination and FB boundaries 304 void calculate_crop_rects(hwc_rect_t& crop, hwc_rect_t& dst, 305 const hwc_rect_t& scissor, int orient); 306 void getNonWormholeRegion(hwc_display_contents_1_t* list, 307 hwc_rect_t& nwr); 308 bool isSecuring(hwc_context_t* ctx, hwc_layer_1_t const* layer); 309 bool isSecureModePolicy(int mdpVersion); 310 // Returns true, if the input layer format is supported by rotator 311 bool isRotatorSupportedFormat(private_handle_t *hnd); 312 //Returns true, if the layer is YUV or the layer has been rendered by CPU 313 bool isRotationDoable(hwc_context_t *ctx, private_handle_t *hnd); 314 bool isExternalActive(hwc_context_t* ctx); 315 bool isAlphaScaled(hwc_layer_1_t const* layer); 316 bool needsScaling(hwc_layer_1_t const* layer); 317 bool isDownscaleRequired(hwc_layer_1_t const* layer); 318 bool needsScalingWithSplit(hwc_context_t* ctx, hwc_layer_1_t const* layer, 319 const int& dpy); 320 void sanitizeSourceCrop(hwc_rect_t& cropL, hwc_rect_t& cropR, 321 private_handle_t *hnd); 322 bool isAlphaPresent(hwc_layer_1_t const* layer); 323 int hwc_vsync_control(hwc_context_t* ctx, int dpy, int enable); 324 int getBlending(int blending); 325 bool isGLESOnlyComp(hwc_context_t *ctx, const int& dpy); 326 void reset_layer_prop(hwc_context_t* ctx, int dpy, int numAppLayers); 327 bool isAbcInUse(hwc_context_t *ctx); 328 329 void dumpBuffer(private_handle_t *ohnd, char *bufferName); 330 void updateDisplayInfo(hwc_context_t* ctx, int dpy); 331 void resetDisplayInfo(hwc_context_t* ctx, int dpy); 332 void initCompositionResources(hwc_context_t* ctx, int dpy); 333 void destroyCompositionResources(hwc_context_t* ctx, int dpy); 334 void clearPipeResources(hwc_context_t* ctx, int dpy); 335 336 //Helper function to dump logs 337 void dumpsys_log(android::String8& buf, const char* fmt, ...); 338 339 int getExtOrientation(hwc_context_t* ctx); 340 bool isValidRect(const hwc_rect_t& rect); 341 hwc_rect_t deductRect(const hwc_rect_t& rect1, const hwc_rect_t& rect2); 342 bool isSameRect(const hwc_rect& rect1, const hwc_rect& rect2); 343 hwc_rect_t moveRect(const hwc_rect_t& rect, const int& x_off, const int& y_off); 344 hwc_rect_t getIntersection(const hwc_rect_t& rect1, const hwc_rect_t& rect2); 345 hwc_rect_t getUnion(const hwc_rect_t& rect1, const hwc_rect_t& rect2); 346 void optimizeLayerRects(const hwc_display_contents_1_t *list); 347 bool areLayersIntersecting(const hwc_layer_1_t* layer1, 348 const hwc_layer_1_t* layer2); 349 bool operator ==(const hwc_rect_t& lhs, const hwc_rect_t& rhs); 350 bool layerUpdating(const hwc_layer_1_t* layer); 351 352 // returns true if Action safe dimensions are set and target supports Actionsafe 353 bool isActionSafePresent(hwc_context_t *ctx, int dpy); 354 355 /* Calculates the destination position based on the action safe rectangle */ 356 void getActionSafePosition(hwc_context_t *ctx, int dpy, hwc_rect_t& dst); 357 358 void getAspectRatioPosition(hwc_context_t* ctx, int dpy, int extOrientation, 359 hwc_rect_t& inRect, hwc_rect_t& outRect); 360 361 uint32_t roundOff(uint32_t refreshRate); 362 363 void setRefreshRate(hwc_context_t *ctx, int dpy, uint32_t refreshRate); 364 365 bool isPrimaryPortrait(hwc_context_t *ctx); 366 367 bool isOrientationPortrait(hwc_context_t *ctx); 368 369 void calcExtDisplayPosition(hwc_context_t *ctx, 370 private_handle_t *hnd, 371 int dpy, 372 hwc_rect_t& sourceCrop, 373 hwc_rect_t& displayFrame, 374 int& transform, 375 ovutils::eTransform& orient); 376 377 // Returns the orientation that needs to be set on external for 378 // BufferMirrirMode(Sidesync) 379 int getMirrorModeOrientation(hwc_context_t *ctx); 380 381 /* Get External State names */ 382 const char* getExternalDisplayState(uint32_t external_state); 383 384 // Resets display ROI to full panel resoluion 385 void resetROI(hwc_context_t *ctx, const int dpy); 386 387 // Modifies ROI even from middle of the screen 388 hwc_rect expandROIFromMidPoint(hwc_rect roi, hwc_rect fullFrame); 389 390 // Aligns updating ROI to panel restrictions 391 hwc_rect_t getSanitizeROI(struct hwc_rect roi, hwc_rect boundary); 392 393 // Handles wfd Pause and resume events 394 void handle_pause(hwc_context_t *ctx, int dpy); 395 void handle_resume(hwc_context_t *ctx, int dpy); 396 397 // Handle ONLINE/OFFLINE for HDMI display 398 void handle_online(hwc_context_t* ctx, int dpy); 399 void handle_offline(hwc_context_t* ctx, int dpy); 400 401 //Close acquireFenceFds of all layers of incoming list 402 void closeAcquireFds(hwc_display_contents_1_t* list); 403 404 //Sync point impl. 405 int hwc_sync(hwc_context_t *ctx, hwc_display_contents_1_t* list, int dpy, 406 int fd); 407 408 //Sets appropriate mdp flags for a layer. 409 void setMdpFlags(hwc_context_t *ctx, hwc_layer_1_t *layer, 410 ovutils::eMdpFlags &mdpFlags, 411 int rotDownscale, int transform); 412 413 int configRotator(overlay::Rotator *rot, ovutils::Whf& whf, 414 hwc_rect_t& crop, const ovutils::eMdpFlags& mdpFlags, 415 const ovutils::eTransform& orient, const int& downscale); 416 417 int configMdp(overlay::Overlay *ov, const ovutils::PipeArgs& parg, 418 const ovutils::eTransform& orient, const hwc_rect_t& crop, 419 const hwc_rect_t& pos, const MetaData_t *metadata, 420 const ovutils::eDest& dest); 421 422 int configColorLayer(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy, 423 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z, 424 const ovutils::eDest& dest); 425 426 void updateSource(ovutils::eTransform& orient, ovutils::Whf& whf, 427 hwc_rect_t& crop, overlay::Rotator *rot); 428 429 bool isZoomModeEnabled(hwc_rect_t crop); 430 void updateCropAIVVideoMode(hwc_context_t *ctx, hwc_rect_t& crop, int dpy); 431 void updateDestAIVVideoMode(hwc_context_t *ctx, hwc_rect_t& dst, int dpy); 432 void updateCoordinates(hwc_context_t *ctx, hwc_rect_t& crop, 433 hwc_rect_t& dst, int dpy); 434 435 //Routine to configure low resolution panels (<= 2048 width) 436 int configureNonSplit(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy, 437 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z, 438 const ovutils::eDest& dest, 439 overlay::Rotator **rot); 440 441 //Routine to configure high resolution panels (> 2048 width) 442 int configureSplit(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy, 443 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z, 444 const ovutils::eDest& lDest, 445 const ovutils::eDest& rDest, overlay::Rotator **rot); 446 447 //Routine to split and configure high resolution YUV layer (> 2048 width) 448 int configureSourceSplit(hwc_context_t *ctx, hwc_layer_1_t *layer, 449 const int& dpy, 450 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z, 451 const ovutils::eDest& lDest, 452 const ovutils::eDest& rDest, overlay::Rotator **rot); 453 454 //On certain targets DMA pipes are used for rotation and they won't be available 455 //for line operations. On a per-target basis we can restrict certain use cases 456 //from using rotator, since we know before-hand that such scenarios can lead to 457 //extreme unavailability of pipes. This can also be done via hybrid calculations 458 //also involving many more variables like number of write-back interfaces etc, 459 //but the variety of scenarios is too high to warrant that. 460 bool canUseRotator(hwc_context_t *ctx, int dpy); 461 462 int getLeftSplit(hwc_context_t *ctx, const int& dpy); 463 464 bool isDisplaySplit(hwc_context_t* ctx, int dpy); 465 466 int getRotDownscale(hwc_context_t *ctx, const hwc_layer_1_t *layer); 467 468 // Set the GPU hint flag to high for MIXED/GPU composition only for 469 // first frame after MDP to GPU/MIXED mode transition. 470 // Set the GPU hint to default if the current composition type is GPU 471 // due to idle fallback or MDP composition. 472 void setGPUHint(hwc_context_t* ctx, hwc_display_contents_1_t* list); 473 474 // Returns true if rect1 is peripheral to rect2, false otherwise. 475 bool isPeripheral(const hwc_rect_t& rect1, const hwc_rect_t& rect2); 476 477 // Applies default mode at boot 478 void applyDefaultMode(hwc_context_t *ctx); 479 480 // Inline utility functions isSkipLayer(const hwc_layer_1_t * l)481 static inline bool isSkipLayer(const hwc_layer_1_t* l) { 482 return (UNLIKELY(l && (l->flags & HWC_SKIP_LAYER))); 483 } 484 isAIVVideoLayer(const hwc_layer_1_t * l)485 static inline bool isAIVVideoLayer(const hwc_layer_1_t* l) { 486 return (UNLIKELY(l && (l->flags & HWC_AIV_VIDEO))); 487 } 488 isAIVCCLayer(const hwc_layer_1_t * l)489 static inline bool isAIVCCLayer(const hwc_layer_1_t* l) { 490 return (UNLIKELY(l && (l->flags & HWC_AIV_CC))); 491 } 492 493 // Returns true if the buffer is yuv isYuvBuffer(const private_handle_t * hnd)494 static inline bool isYuvBuffer(const private_handle_t* hnd) { 495 return (hnd && (hnd->bufferType == BUFFER_TYPE_VIDEO)); 496 } 497 498 // Returns true if the buffer is yuv and exceeds the mixer width isYUVSplitNeeded(const private_handle_t * hnd)499 static inline bool isYUVSplitNeeded(const private_handle_t* hnd) { 500 int maxPipeWidth = qdutils::MDPVersion::getInstance().getMaxPipeWidth(); 501 return (hnd && (hnd->bufferType == BUFFER_TYPE_VIDEO) && 502 (hnd->width > maxPipeWidth)); 503 } 504 505 // Returns true if the buffer is secure isSecureBuffer(const private_handle_t * hnd)506 static inline bool isSecureBuffer(const private_handle_t* hnd) { 507 return (hnd && (private_handle_t::PRIV_FLAGS_SECURE_BUFFER & hnd->flags)); 508 } 509 510 // Returns true if the buffer is protected isProtectedBuffer(const private_handle_t * hnd)511 static inline bool isProtectedBuffer(const private_handle_t* hnd) { 512 return (hnd && (private_handle_t::PRIV_FLAGS_PROTECTED_BUFFER & hnd->flags)); 513 } 514 515 isTileRendered(const private_handle_t * hnd)516 static inline bool isTileRendered(const private_handle_t* hnd) { 517 return (hnd && (private_handle_t::PRIV_FLAGS_TILE_RENDERED & hnd->flags)); 518 } 519 520 //Return true if the buffer is intended for Secure Display isSecureDisplayBuffer(const private_handle_t * hnd)521 static inline bool isSecureDisplayBuffer(const private_handle_t* hnd) { 522 return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY)); 523 } 524 getWidth(const private_handle_t * hnd)525 static inline int getWidth(const private_handle_t* hnd) { 526 MetaData_t *metadata = reinterpret_cast<MetaData_t*>(hnd->base_metadata); 527 if(metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) { 528 return metadata->bufferDim.sliceWidth; 529 } 530 return hnd->width; 531 } 532 getHeight(const private_handle_t * hnd)533 static inline int getHeight(const private_handle_t* hnd) { 534 MetaData_t *metadata = reinterpret_cast<MetaData_t*>(hnd->base_metadata); 535 if(metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) { 536 return metadata->bufferDim.sliceHeight; 537 } 538 return hnd->height; 539 } 540 max(T a,T b)541 template<typename T> inline T max(T a, T b) { return (a > b) ? a : b; } min(T a,T b)542 template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; } 543 544 // Initialize uevent thread 545 void init_uevent_thread(hwc_context_t* ctx); 546 // Initialize vsync thread 547 void init_vsync_thread(hwc_context_t* ctx); 548 getLayerResolution(const hwc_layer_1_t * layer,int & width,int & height)549 inline void getLayerResolution(const hwc_layer_1_t* layer, 550 int& width, int& height) { 551 hwc_rect_t displayFrame = layer->displayFrame; 552 width = displayFrame.right - displayFrame.left; 553 height = displayFrame.bottom - displayFrame.top; 554 } 555 openFb(int dpy)556 static inline int openFb(int dpy) { 557 int fd = -1; 558 const char *devtmpl = "/dev/graphics/fb%u"; 559 char name[64] = {0}; 560 snprintf(name, 64, devtmpl, dpy); 561 fd = open(name, O_RDWR); 562 return fd; 563 } 564 565 template <class T> swap(T & a,T & b)566 inline void swap(T& a, T& b) { 567 T tmp = a; 568 a = b; 569 b = tmp; 570 } 571 572 }; //qhwc namespace 573 574 enum eAnimationState{ 575 ANIMATION_STOPPED, 576 ANIMATION_STARTED, 577 }; 578 579 enum eCompositionState { 580 COMPOSITION_STATE_MDP = 0, // Set if composition type is MDP 581 COMPOSITION_STATE_GPU, // Set if composition type is GPU or MIXED 582 COMPOSITION_STATE_IDLE_FALLBACK, // Set if it is idlefallback 583 }; 584 585 // Structure holds the information about the GPU hint. 586 struct gpu_hint_info { 587 // system level flag to enable gpu_perf_mode 588 bool mGpuPerfModeEnable; 589 // Stores the current GPU performance mode DEFAULT/HIGH 590 bool mCurrGPUPerfMode; 591 // Stores the compositon state GPU, MDP or IDLE_FALLBACK 592 bool mCompositionState; 593 // Stores the EGLContext of current process 594 EGLContext mEGLContext; 595 // Stores the EGLDisplay of current process 596 EGLDisplay mEGLDisplay; 597 }; 598 599 // ----------------------------------------------------------------------------- 600 // HWC context 601 // This structure contains overall state 602 struct hwc_context_t { 603 hwc_composer_device_1_t device; 604 const hwc_procs_t* proc; 605 606 //CopyBit objects 607 qhwc::CopyBit *mCopyBit[HWC_NUM_DISPLAY_TYPES]; 608 609 //Overlay object - NULL for non overlay devices 610 overlay::Overlay *mOverlay; 611 //Holds a few rot objects 612 overlay::RotMgr *mRotMgr; 613 614 //Primary and external FB updater 615 qhwc::IFBUpdate *mFBUpdate[HWC_NUM_DISPLAY_TYPES]; 616 // HDMI display related object. Used to configure/teardown 617 // HDMI when it is connected as primary or external. 618 qhwc::HDMIDisplay *mHDMIDisplay; 619 qhwc::MDPInfo mMDP; 620 qhwc::VsyncState vstate; 621 qhwc::DisplayAttributes dpyAttr[HWC_NUM_DISPLAY_TYPES]; 622 qhwc::ListStats listStats[HWC_NUM_DISPLAY_TYPES]; 623 qhwc::LayerProp *layerProp[HWC_NUM_DISPLAY_TYPES]; 624 qhwc::MDPComp *mMDPComp[HWC_NUM_DISPLAY_TYPES]; 625 qhwc::HwcDebug *mHwcDebug[HWC_NUM_DISPLAY_TYPES]; 626 hwc_rect_t mViewFrame[HWC_NUM_DISPLAY_TYPES]; 627 qhwc::AssertiveDisplay *mAD; 628 eAnimationState mAnimationState[HWC_NUM_DISPLAY_TYPES]; 629 qhwc::HWCVirtualVDS *mHWCVirtual; 630 631 // stores the #numHwLayers of the previous frame 632 // for each display device 633 int mPrevHwLayerCount[HWC_NUM_DISPLAY_TYPES]; 634 635 // stores the primary device orientation 636 int deviceOrientation; 637 //Securing in progress indicator 638 bool mSecuring; 639 //Display in secure mode indicator 640 bool mSecureMode; 641 //Lock to protect drawing data structures 642 mutable Locker mDrawLock; 643 //Drawing round when we use GPU 644 bool isPaddingRound; 645 // Used to mark composition cycle when DMA state change is required 646 bool isDMAStateChanging; 647 // External Orientation 648 int mExtOrientation; 649 //Flags the transition of a video session 650 bool mVideoTransFlag; 651 //Used for SideSync feature 652 //which overrides the mExtOrientation 653 bool mBufferMirrorMode; 654 // Used to synchronize between WFD and Display modules 655 mutable Locker mWfdSyncLock; 656 657 qhwc::LayerRotMap *mLayerRotMap[HWC_NUM_DISPLAY_TYPES]; 658 // Panel reset flag will be set if BTA check fails 659 bool mPanelResetStatus; 660 // number of active Displays 661 int numActiveDisplays; 662 struct gpu_hint_info mGPUHintInfo; 663 //App Buffer Composition 664 bool enableABC; 665 // PTOR Info 666 qhwc::PtorInfo mPtorInfo; 667 //Running in Thermal burst mode 668 bool mThermalBurstMode; 669 //Layers out of ROI 670 bool copybitDrop[MAX_NUM_APP_LAYERS]; 671 // Flag related to windowboxing feature 672 bool mWindowboxFeature; 673 // This denotes the tolerance between video layer and external display 674 // aspect ratio 675 float mAspectRatioToleranceLevel; 676 // Runtime switch for BWC for targets that support it 677 bool mBWCEnabled; 678 // Provides a way for OEM's to disable setting dynfps via metadata. 679 bool mUseMetaDataRefreshRate; 680 // Stores the hpd enabled status- avoids re-enabling HDP on suspend resume. 681 bool mHPDEnabled; 682 //Used to notify that default mode has been applied 683 bool mDefaultModeApplied; 684 //Manages color modes 685 qhwc::ColorMode *mColorMode; 686 }; 687 688 namespace qhwc { isSkipPresent(hwc_context_t * ctx,int dpy)689 static inline bool isSkipPresent (hwc_context_t *ctx, int dpy) { 690 return ctx->listStats[dpy].skipCount; 691 } 692 isYuvPresent(hwc_context_t * ctx,int dpy)693 static inline bool isYuvPresent (hwc_context_t *ctx, int dpy) { 694 return ctx->listStats[dpy].yuvCount; 695 } 696 has90Transform(hwc_layer_1_t const * layer)697 static inline bool has90Transform(hwc_layer_1_t const* layer) { 698 return ((layer->transform & HWC_TRANSFORM_ROT_90) && 699 !(layer->flags & HWC_COLOR_FILL)); 700 } 701 isSecurePresent(hwc_context_t * ctx,int dpy)702 inline bool isSecurePresent(hwc_context_t *ctx, int dpy) { 703 return ctx->listStats[dpy].isSecurePresent; 704 } 705 isSecondaryConfiguring(hwc_context_t * ctx)706 static inline bool isSecondaryConfiguring(hwc_context_t* ctx) { 707 return (ctx->dpyAttr[HWC_DISPLAY_EXTERNAL].isConfiguring || 708 ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].isConfiguring); 709 } 710 isSecondaryConnected(hwc_context_t * ctx)711 static inline bool isSecondaryConnected(hwc_context_t* ctx) { 712 return (ctx->dpyAttr[HWC_DISPLAY_EXTERNAL].connected || 713 ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].connected); 714 } 715 716 /* Return Virtual Display connection status */ isVDConnected(hwc_context_t * ctx)717 static inline bool isVDConnected(hwc_context_t* ctx) { 718 return ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].connected; 719 } 720 getLayerClock(const uint32_t & dstW,const uint32_t & dstH,const uint32_t & srcH)721 inline uint32_t getLayerClock(const uint32_t& dstW, const uint32_t& dstH, 722 const uint32_t& srcH) { 723 return max(dstW, (srcH * dstW) / dstH); 724 } 725 726 }; 727 728 #endif //HWC_UTILS_H 729