hwc_utils.h revision effbd25d502916fcdebadd1d2b83988559434e79
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 21#ifndef HWC_UTILS_H 22#define HWC_UTILS_H 23 24#define HWC_REMOVE_DEPRECATED_VERSIONS 1 25#include <fcntl.h> 26#include <hardware/hwcomposer.h> 27#include <gr.h> 28#include <gralloc_priv.h> 29#include <utils/String8.h> 30#include "qdMetaData.h" 31#include <overlayUtils.h> 32 33#define ALIGN_TO(x, align) (((x) + ((align)-1)) & ~((align)-1)) 34#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true )) 35#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false )) 36#define MAX_NUM_APP_LAYERS 32 37 38//Fwrd decls 39struct hwc_context_t; 40 41namespace ovutils = overlay::utils; 42 43namespace overlay { 44class Overlay; 45class Rotator; 46class RotMgr; 47} 48 49namespace qhwc { 50//fwrd decl 51class QueuedBufferStore; 52class ExternalDisplay; 53class VirtualDisplay; 54class IFBUpdate; 55class IVideoOverlay; 56class MDPComp; 57class CopyBit; 58class HwcDebug; 59class AssertiveDisplay; 60 61 62struct MDPInfo { 63 int version; 64 char panel; 65 bool hasOverlay; 66}; 67 68struct DisplayAttributes { 69 uint32_t vsync_period; //nanos 70 uint32_t xres; 71 uint32_t yres; 72 uint32_t stride; 73 float xdpi; 74 float ydpi; 75 int fd; 76 bool connected; //Applies only to pluggable disp. 77 //Connected does not mean it ready to use. 78 //It should be active also. (UNBLANKED) 79 bool isActive; 80 // In pause state, composition is bypassed 81 // used for WFD displays only 82 bool isPause; 83 // To trigger padding round to clean up mdp 84 // pipes 85 bool isConfiguring; 86 // External Display is in MDP Downscale mode indicator 87 bool mDownScaleMode; 88}; 89 90struct ListStats { 91 int numAppLayers; //Total - 1, excluding FB layer. 92 int skipCount; 93 int fbLayerIndex; //Always last for now. = numAppLayers 94 //Video specific 95 int yuvCount; 96 int yuvIndices[MAX_NUM_APP_LAYERS]; 97 int extOnlyLayerIndex; 98 bool needsAlphaScale; 99 bool preMultipliedAlpha; 100 // Notifies hwcomposer about the start and end of animation 101 // This will be set to true during animation, otherwise false. 102 bool isDisplayAnimating; 103}; 104 105struct LayerProp { 106 uint32_t mFlags; //qcom specific layer flags 107 LayerProp():mFlags(0) {}; 108}; 109 110struct VsyncState { 111 bool enable; 112 bool fakevsync; 113}; 114 115struct BwcPM { 116 static void setBwc(hwc_context_t *ctx, const hwc_rect_t& crop, 117 const hwc_rect_t& dst, const int& transform, 118 ovutils::eMdpFlags& mdpFlags); 119}; 120 121// LayerProp::flag values 122enum { 123 HWC_MDPCOMP = 0x00000001, 124 HWC_COPYBIT = 0x00000002, 125}; 126 127class LayerRotMap { 128public: 129 LayerRotMap() { reset(); } 130 enum { MAX_SESS = 3 }; 131 void add(hwc_layer_1_t* layer, overlay::Rotator *rot); 132 void reset(); 133 uint32_t getCount() const; 134 hwc_layer_1_t* getLayer(uint32_t index) const; 135 overlay::Rotator* getRot(uint32_t index) const; 136 void setReleaseFd(const int& fence); 137private: 138 hwc_layer_1_t* mLayer[MAX_SESS]; 139 overlay::Rotator* mRot[MAX_SESS]; 140 uint32_t mCount; 141}; 142 143inline uint32_t LayerRotMap::getCount() const { 144 return mCount; 145} 146 147inline hwc_layer_1_t* LayerRotMap::getLayer(uint32_t index) const { 148 if(index >= mCount) return NULL; 149 return mLayer[index]; 150} 151 152inline overlay::Rotator* LayerRotMap::getRot(uint32_t index) const { 153 if(index >= mCount) return NULL; 154 return mRot[index]; 155} 156 157// ----------------------------------------------------------------------------- 158// Utility functions - implemented in hwc_utils.cpp 159void dumpLayer(hwc_layer_1_t const* l); 160void setListStats(hwc_context_t *ctx, const hwc_display_contents_1_t *list, 161 int dpy); 162void initContext(hwc_context_t *ctx); 163void closeContext(hwc_context_t *ctx); 164//Crops source buffer against destination and FB boundaries 165void calculate_crop_rects(hwc_rect_t& crop, hwc_rect_t& dst, 166 const hwc_rect_t& scissor, int orient); 167void getNonWormholeRegion(hwc_display_contents_1_t* list, 168 hwc_rect_t& nwr); 169bool isSecuring(hwc_context_t* ctx, hwc_layer_1_t const* layer); 170bool isSecureModePolicy(int mdpVersion); 171bool isExternalActive(hwc_context_t* ctx); 172bool needsScaling(hwc_context_t* ctx, hwc_layer_1_t const* layer, const int& dpy); 173bool isAlphaPresent(hwc_layer_1_t const* layer); 174int hwc_vsync_control(hwc_context_t* ctx, int dpy, int enable); 175 176//Helper function to dump logs 177void dumpsys_log(android::String8& buf, const char* fmt, ...); 178 179/* Calculates the destination position based on the action safe rectangle */ 180void getActionSafePosition(hwc_context_t *ctx, int dpy, hwc_rect_t& dst); 181 182void getAspectRatioPosition(int destWidth, int destHeight, int srcWidth, 183 int srcHeight, hwc_rect_t& rect); 184 185void getAspectRatioPosition(hwc_context_t* ctx, int dpy, int extOrientation, 186 hwc_rect_t& inRect, hwc_rect_t& outRect); 187 188bool isPrimaryPortrait(hwc_context_t *ctx); 189 190bool isOrientationPortrait(hwc_context_t *ctx); 191 192void calcExtDisplayPosition(hwc_context_t *ctx, 193 int dpy, 194 hwc_rect_t& sourceCrop, 195 hwc_rect_t& displayFrame); 196// Returns the orientation that needs to be set on external for 197// BufferMirrirMode(Sidesync) 198int getMirrorModeOrientation(hwc_context_t *ctx); 199 200//Close acquireFenceFds of all layers of incoming list 201void closeAcquireFds(hwc_display_contents_1_t* list); 202 203//Sync point impl. 204int hwc_sync(hwc_context_t *ctx, hwc_display_contents_1_t* list, int dpy, 205 int fd); 206 207//Trims a layer's source crop which is outside of screen boundary. 208void trimLayer(hwc_context_t *ctx, const int& dpy, const int& transform, 209 hwc_rect_t& crop, hwc_rect_t& dst); 210 211//Sets appropriate mdp flags for a layer. 212void setMdpFlags(hwc_layer_1_t *layer, 213 ovutils::eMdpFlags &mdpFlags, 214 int rotDownscale, int transform); 215 216int configRotator(overlay::Rotator *rot, const ovutils::Whf& whf, 217 hwc_rect_t& crop, const ovutils::eMdpFlags& mdpFlags, 218 const ovutils::eTransform& orient, const int& downscale); 219 220int configMdp(overlay::Overlay *ov, const ovutils::PipeArgs& parg, 221 const ovutils::eTransform& orient, const hwc_rect_t& crop, 222 const hwc_rect_t& pos, const MetaData_t *metadata, 223 const ovutils::eDest& dest); 224 225void updateSource(ovutils::eTransform& orient, ovutils::Whf& whf, 226 hwc_rect_t& crop); 227 228//Routine to configure low resolution panels (<= 2048 width) 229int configureLowRes(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy, 230 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z, 231 ovutils::eIsFg& isFg, const ovutils::eDest& dest, 232 overlay::Rotator **rot); 233 234//Routine to configure high resolution panels (> 2048 width) 235int configureHighRes(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy, 236 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z, 237 ovutils::eIsFg& isFg, const ovutils::eDest& lDest, 238 const ovutils::eDest& rDest, overlay::Rotator **rot); 239 240//On certain targets DMA pipes are used for rotation and they won't be available 241//for line operations. On a per-target basis we can restrict certain use cases 242//from using rotator, since we know before-hand that such scenarios can lead to 243//extreme unavailability of pipes. This can also be done via hybrid calculations 244//also involving many more variables like number of write-back interfaces etc, 245//but the variety of scenarios is too high to warrant that. 246bool canUseRotator(hwc_context_t *ctx); 247 248int getLeftSplit(hwc_context_t *ctx, const int& dpy); 249 250// Inline utility functions 251static inline bool isSkipLayer(const hwc_layer_1_t* l) { 252 return (UNLIKELY(l && (l->flags & HWC_SKIP_LAYER))); 253} 254 255// Returns true if the buffer is yuv 256static inline bool isYuvBuffer(const private_handle_t* hnd) { 257 return (hnd && (hnd->bufferType == BUFFER_TYPE_VIDEO)); 258} 259 260// Returns true if the buffer is secure 261static inline bool isSecureBuffer(const private_handle_t* hnd) { 262 return (hnd && (private_handle_t::PRIV_FLAGS_SECURE_BUFFER & hnd->flags)); 263} 264//Return true if buffer is marked locked 265static inline bool isBufferLocked(const private_handle_t* hnd) { 266 return (hnd && (private_handle_t::PRIV_FLAGS_HWC_LOCK & hnd->flags)); 267} 268 269//Return true if buffer is for external display only 270static inline bool isExtOnly(const private_handle_t* hnd) { 271 return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_ONLY)); 272} 273 274//Return true if buffer is for external display only with a BLOCK flag. 275static inline bool isExtBlock(const private_handle_t* hnd) { 276 return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_BLOCK)); 277} 278 279//Return true if buffer is for external display only with a Close Caption flag. 280static inline bool isExtCC(const private_handle_t* hnd) { 281 return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_CC)); 282} 283 284template<typename T> inline T max(T a, T b) { return (a > b) ? a : b; } 285template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; } 286 287// Initialize uevent thread 288void init_uevent_thread(hwc_context_t* ctx); 289// Initialize vsync thread 290void init_vsync_thread(hwc_context_t* ctx); 291 292inline void getLayerResolution(const hwc_layer_1_t* layer, 293 int& width, int& height) 294{ 295 hwc_rect_t displayFrame = layer->displayFrame; 296 width = displayFrame.right - displayFrame.left; 297 height = displayFrame.bottom - displayFrame.top; 298} 299 300static inline int openFb(int dpy) { 301 int fd = -1; 302 const char *devtmpl = "/dev/graphics/fb%u"; 303 char name[64] = {0}; 304 snprintf(name, 64, devtmpl, dpy); 305 fd = open(name, O_RDWR); 306 return fd; 307} 308 309template <class T> 310inline void swap(T& a, T& b) { 311 T tmp = a; 312 a = b; 313 b = tmp; 314} 315 316}; //qhwc namespace 317 318// ----------------------------------------------------------------------------- 319// HWC context 320// This structure contains overall state 321struct hwc_context_t { 322 hwc_composer_device_1_t device; 323 const hwc_procs_t* proc; 324 325 //CopyBit objects 326 qhwc::CopyBit *mCopyBit[HWC_NUM_DISPLAY_TYPES]; 327 328 //Overlay object - NULL for non overlay devices 329 overlay::Overlay *mOverlay; 330 //Holds a few rot objects 331 overlay::RotMgr *mRotMgr; 332 333 //Primary and external FB updater 334 qhwc::IFBUpdate *mFBUpdate[HWC_NUM_DISPLAY_TYPES]; 335 // External display related information 336 qhwc::ExternalDisplay *mExtDisplay; 337 qhwc::VirtualDisplay *mVirtualDisplay; 338 qhwc::MDPInfo mMDP; 339 qhwc::VsyncState vstate; 340 qhwc::DisplayAttributes dpyAttr[HWC_NUM_DISPLAY_TYPES]; 341 qhwc::ListStats listStats[HWC_NUM_DISPLAY_TYPES]; 342 qhwc::LayerProp *layerProp[HWC_NUM_DISPLAY_TYPES]; 343 qhwc::MDPComp *mMDPComp[HWC_NUM_DISPLAY_TYPES]; 344 qhwc::HwcDebug *mHwcDebug[HWC_NUM_DISPLAY_TYPES]; 345 qhwc::AssertiveDisplay *mAD; 346 347 // No animation on External display feature 348 // Notifies hwcomposer about the device orientation before animation. 349 int deviceOrientation; 350 // Stores the crop, dest rect and transform value of video before animation. 351 hwc_rect_t mPrevCropVideo; 352 hwc_rect_t mPrevDestVideo; 353 int mPrevTransformVideo; 354 //Securing in progress indicator 355 bool mSecuring; 356 //WFD on proprietary stack 357 bool mVirtualonExtActive; 358 //Display in secure mode indicator 359 bool mSecureMode; 360 //Lock to prevent set from being called while blanking 361 mutable Locker mBlankLock; 362 //Lock to protect prepare & set when detaching external disp 363 mutable Locker mExtLock; 364 /*Lock to set both mSecureMode and mSecuring as part 365 of binder thread without context switch to composition 366 thread. This lock is needed only for A-family targets 367 since the state of mSecureMode and mSecuring variables 368 are not checked in B-family targets. 369 */ 370 mutable Locker mSecureLock; 371 //Drawing round when we use GPU 372 bool isPaddingRound; 373 // External Orientation 374 int mExtOrientation; 375 //Flags the transition of a video session 376 bool mVideoTransFlag; 377 378 //Used for SideSync feature 379 //which overrides the mExtOrientation 380 bool mBufferMirrorMode; 381 382 qhwc::LayerRotMap *mLayerRotMap[HWC_NUM_DISPLAY_TYPES]; 383}; 384 385namespace qhwc { 386static inline bool isSkipPresent (hwc_context_t *ctx, int dpy) { 387 return ctx->listStats[dpy].skipCount; 388} 389 390static inline bool isYuvPresent (hwc_context_t *ctx, int dpy) { 391 return ctx->listStats[dpy].yuvCount; 392} 393}; 394 395#endif //HWC_UTILS_H 396