hwc_utils.h revision 5208cf1acefb3cb74ea3ba904b6bee9f800133da
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); 175int getBlending(int blending); 176 177//Helper function to dump logs 178void dumpsys_log(android::String8& buf, const char* fmt, ...); 179 180/* Calculates the destination position based on the action safe rectangle */ 181void getActionSafePosition(hwc_context_t *ctx, int dpy, hwc_rect_t& dst); 182 183void getAspectRatioPosition(int destWidth, int destHeight, int srcWidth, 184 int srcHeight, hwc_rect_t& rect); 185 186void getAspectRatioPosition(hwc_context_t* ctx, int dpy, int extOrientation, 187 hwc_rect_t& inRect, hwc_rect_t& outRect); 188 189bool isPrimaryPortrait(hwc_context_t *ctx); 190 191bool isOrientationPortrait(hwc_context_t *ctx); 192 193void calcExtDisplayPosition(hwc_context_t *ctx, 194 int dpy, 195 hwc_rect_t& sourceCrop, 196 hwc_rect_t& displayFrame); 197// Returns the orientation that needs to be set on external for 198// BufferMirrirMode(Sidesync) 199int getMirrorModeOrientation(hwc_context_t *ctx); 200 201//Close acquireFenceFds of all layers of incoming list 202void closeAcquireFds(hwc_display_contents_1_t* list); 203 204//Sync point impl. 205int hwc_sync(hwc_context_t *ctx, hwc_display_contents_1_t* list, int dpy, 206 int fd); 207 208//Trims a layer's source crop which is outside of screen boundary. 209void trimLayer(hwc_context_t *ctx, const int& dpy, const int& transform, 210 hwc_rect_t& crop, hwc_rect_t& dst); 211 212//Sets appropriate mdp flags for a layer. 213void setMdpFlags(hwc_layer_1_t *layer, 214 ovutils::eMdpFlags &mdpFlags, 215 int rotDownscale, int transform); 216 217int configRotator(overlay::Rotator *rot, ovutils::Whf& whf, 218 hwc_rect_t& crop, const ovutils::eMdpFlags& mdpFlags, 219 const ovutils::eTransform& orient, const int& downscale); 220 221int configMdp(overlay::Overlay *ov, const ovutils::PipeArgs& parg, 222 const ovutils::eTransform& orient, const hwc_rect_t& crop, 223 const hwc_rect_t& pos, const MetaData_t *metadata, 224 const ovutils::eDest& dest); 225 226void updateSource(ovutils::eTransform& orient, ovutils::Whf& whf, 227 hwc_rect_t& crop); 228 229//Routine to configure low resolution panels (<= 2048 width) 230int configureLowRes(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy, 231 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z, 232 ovutils::eIsFg& isFg, const ovutils::eDest& dest, 233 overlay::Rotator **rot); 234 235//Routine to configure high resolution panels (> 2048 width) 236int configureHighRes(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy, 237 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z, 238 ovutils::eIsFg& isFg, const ovutils::eDest& lDest, 239 const ovutils::eDest& rDest, overlay::Rotator **rot); 240 241//On certain targets DMA pipes are used for rotation and they won't be available 242//for line operations. On a per-target basis we can restrict certain use cases 243//from using rotator, since we know before-hand that such scenarios can lead to 244//extreme unavailability of pipes. This can also be done via hybrid calculations 245//also involving many more variables like number of write-back interfaces etc, 246//but the variety of scenarios is too high to warrant that. 247bool canUseRotator(hwc_context_t *ctx, int dpy); 248 249int getLeftSplit(hwc_context_t *ctx, const int& dpy); 250 251// Inline utility functions 252static inline bool isSkipLayer(const hwc_layer_1_t* l) { 253 return (UNLIKELY(l && (l->flags & HWC_SKIP_LAYER))); 254} 255 256// Returns true if the buffer is yuv 257static inline bool isYuvBuffer(const private_handle_t* hnd) { 258 return (hnd && (hnd->bufferType == BUFFER_TYPE_VIDEO)); 259} 260 261// Returns true if the buffer is secure 262static inline bool isSecureBuffer(const private_handle_t* hnd) { 263 return (hnd && (private_handle_t::PRIV_FLAGS_SECURE_BUFFER & hnd->flags)); 264} 265//Return true if buffer is marked locked 266static inline bool isBufferLocked(const private_handle_t* hnd) { 267 return (hnd && (private_handle_t::PRIV_FLAGS_HWC_LOCK & hnd->flags)); 268} 269 270//Return true if buffer is for external display only 271static inline bool isExtOnly(const private_handle_t* hnd) { 272 return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_ONLY)); 273} 274 275//Return true if buffer is for external display only with a BLOCK flag. 276static inline bool isExtBlock(const private_handle_t* hnd) { 277 return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_BLOCK)); 278} 279 280//Return true if buffer is for external display only with a Close Caption flag. 281static inline bool isExtCC(const private_handle_t* hnd) { 282 return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_CC)); 283} 284 285template<typename T> inline T max(T a, T b) { return (a > b) ? a : b; } 286template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; } 287 288// Initialize uevent thread 289void init_uevent_thread(hwc_context_t* ctx); 290// Initialize vsync thread 291void init_vsync_thread(hwc_context_t* ctx); 292 293inline void getLayerResolution(const hwc_layer_1_t* layer, 294 int& width, int& height) { 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 protect drawing data structures 361 mutable Locker mDrawLock; 362 //Drawing round when we use GPU 363 bool isPaddingRound; 364 // External Orientation 365 int mExtOrientation; 366 //Flags the transition of a video session 367 bool mVideoTransFlag; 368 369 //Used for SideSync feature 370 //which overrides the mExtOrientation 371 bool mBufferMirrorMode; 372 373 qhwc::LayerRotMap *mLayerRotMap[HWC_NUM_DISPLAY_TYPES]; 374}; 375 376namespace qhwc { 377static inline bool isSkipPresent (hwc_context_t *ctx, int dpy) { 378 return ctx->listStats[dpy].skipCount; 379} 380 381static inline bool isYuvPresent (hwc_context_t *ctx, int dpy) { 382 return ctx->listStats[dpy].yuvCount; 383} 384}; 385 386#endif //HWC_UTILS_H 387