hwc_utils.h revision 5320999d7fe1c517ff6629b5c1165bbadf387359
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 198//Close acquireFenceFds of all layers of incoming list 199void closeAcquireFds(hwc_display_contents_1_t* list); 200 201//Sync point impl. 202int hwc_sync(hwc_context_t *ctx, hwc_display_contents_1_t* list, int dpy, 203 int fd); 204 205//Trims a layer's source crop which is outside of screen boundary. 206void trimLayer(hwc_context_t *ctx, const int& dpy, const int& transform, 207 hwc_rect_t& crop, hwc_rect_t& dst); 208 209//Sets appropriate mdp flags for a layer. 210void setMdpFlags(hwc_layer_1_t *layer, 211 ovutils::eMdpFlags &mdpFlags, 212 int rotDownscale, int transform); 213 214int configRotator(overlay::Rotator *rot, ovutils::Whf& whf, 215 hwc_rect_t& crop, const ovutils::eMdpFlags& mdpFlags, 216 const ovutils::eTransform& orient, const int& downscale); 217 218int configMdp(overlay::Overlay *ov, const ovutils::PipeArgs& parg, 219 const ovutils::eTransform& orient, const hwc_rect_t& crop, 220 const hwc_rect_t& pos, const MetaData_t *metadata, 221 const ovutils::eDest& dest); 222 223void updateSource(ovutils::eTransform& orient, ovutils::Whf& whf, 224 hwc_rect_t& crop); 225 226//Routine to configure low resolution panels (<= 2048 width) 227int configureLowRes(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy, 228 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z, 229 ovutils::eIsFg& isFg, const ovutils::eDest& dest, 230 overlay::Rotator **rot); 231 232//Routine to configure high resolution panels (> 2048 width) 233int configureHighRes(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy, 234 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z, 235 ovutils::eIsFg& isFg, const ovutils::eDest& lDest, 236 const ovutils::eDest& rDest, overlay::Rotator **rot); 237 238//On certain targets DMA pipes are used for rotation and they won't be available 239//for line operations. On a per-target basis we can restrict certain use cases 240//from using rotator, since we know before-hand that such scenarios can lead to 241//extreme unavailability of pipes. This can also be done via hybrid calculations 242//also involving many more variables like number of write-back interfaces etc, 243//but the variety of scenarios is too high to warrant that. 244bool canUseRotator(hwc_context_t *ctx, int dpy); 245 246int getLeftSplit(hwc_context_t *ctx, const int& dpy); 247 248// Inline utility functions 249static inline bool isSkipLayer(const hwc_layer_1_t* l) { 250 return (UNLIKELY(l && (l->flags & HWC_SKIP_LAYER))); 251} 252 253// Returns true if the buffer is yuv 254static inline bool isYuvBuffer(const private_handle_t* hnd) { 255 return (hnd && (hnd->bufferType == BUFFER_TYPE_VIDEO)); 256} 257 258// Returns true if the buffer is secure 259static inline bool isSecureBuffer(const private_handle_t* hnd) { 260 return (hnd && (private_handle_t::PRIV_FLAGS_SECURE_BUFFER & hnd->flags)); 261} 262//Return true if buffer is marked locked 263static inline bool isBufferLocked(const private_handle_t* hnd) { 264 return (hnd && (private_handle_t::PRIV_FLAGS_HWC_LOCK & hnd->flags)); 265} 266 267//Return true if buffer is for external display only 268static inline bool isExtOnly(const private_handle_t* hnd) { 269 return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_ONLY)); 270} 271 272//Return true if buffer is for external display only with a BLOCK flag. 273static inline bool isExtBlock(const private_handle_t* hnd) { 274 return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_BLOCK)); 275} 276 277//Return true if buffer is for external display only with a Close Caption flag. 278static inline bool isExtCC(const private_handle_t* hnd) { 279 return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_CC)); 280} 281 282template<typename T> inline T max(T a, T b) { return (a > b) ? a : b; } 283template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; } 284 285// Initialize uevent thread 286void init_uevent_thread(hwc_context_t* ctx); 287// Initialize vsync thread 288void init_vsync_thread(hwc_context_t* ctx); 289 290inline void getLayerResolution(const hwc_layer_1_t* layer, 291 int& width, int& height) { 292 hwc_rect_t displayFrame = layer->displayFrame; 293 width = displayFrame.right - displayFrame.left; 294 height = displayFrame.bottom - displayFrame.top; 295} 296 297static inline int openFb(int dpy) { 298 int fd = -1; 299 const char *devtmpl = "/dev/graphics/fb%u"; 300 char name[64] = {0}; 301 snprintf(name, 64, devtmpl, dpy); 302 fd = open(name, O_RDWR); 303 return fd; 304} 305 306template <class T> 307inline void swap(T& a, T& b) { 308 T tmp = a; 309 a = b; 310 b = tmp; 311} 312 313}; //qhwc namespace 314 315// ----------------------------------------------------------------------------- 316// HWC context 317// This structure contains overall state 318struct hwc_context_t { 319 hwc_composer_device_1_t device; 320 const hwc_procs_t* proc; 321 322 //CopyBit objects 323 qhwc::CopyBit *mCopyBit[HWC_NUM_DISPLAY_TYPES]; 324 325 //Overlay object - NULL for non overlay devices 326 overlay::Overlay *mOverlay; 327 //Holds a few rot objects 328 overlay::RotMgr *mRotMgr; 329 330 //Primary and external FB updater 331 qhwc::IFBUpdate *mFBUpdate[HWC_NUM_DISPLAY_TYPES]; 332 // External display related information 333 qhwc::ExternalDisplay *mExtDisplay; 334 qhwc::VirtualDisplay *mVirtualDisplay; 335 qhwc::MDPInfo mMDP; 336 qhwc::VsyncState vstate; 337 qhwc::DisplayAttributes dpyAttr[HWC_NUM_DISPLAY_TYPES]; 338 qhwc::ListStats listStats[HWC_NUM_DISPLAY_TYPES]; 339 qhwc::LayerProp *layerProp[HWC_NUM_DISPLAY_TYPES]; 340 qhwc::MDPComp *mMDPComp[HWC_NUM_DISPLAY_TYPES]; 341 qhwc::HwcDebug *mHwcDebug[HWC_NUM_DISPLAY_TYPES]; 342 qhwc::AssertiveDisplay *mAD; 343 344 // No animation on External display feature 345 // Notifies hwcomposer about the device orientation before animation. 346 int deviceOrientation; 347 // Stores the crop, dest rect and transform value of video before animation. 348 hwc_rect_t mPrevCropVideo; 349 hwc_rect_t mPrevDestVideo; 350 int mPrevTransformVideo; 351 //Securing in progress indicator 352 bool mSecuring; 353 //WFD on proprietary stack 354 bool mVirtualonExtActive; 355 //Display in secure mode indicator 356 bool mSecureMode; 357 //Lock to protect drawing data structures 358 mutable Locker mDrawLock; 359 //Drawing round when we use GPU 360 bool isPaddingRound; 361 // External Orientation 362 int mExtOrientation; 363 //Flags the transition of a video session 364 bool mVideoTransFlag; 365 qhwc::LayerRotMap *mLayerRotMap[HWC_NUM_DISPLAY_TYPES]; 366}; 367 368namespace qhwc { 369static inline bool isSkipPresent (hwc_context_t *ctx, int dpy) { 370 return ctx->listStats[dpy].skipCount; 371} 372 373static inline bool isYuvPresent (hwc_context_t *ctx, int dpy) { 374 return ctx->listStats[dpy].yuvCount; 375} 376}; 377 378#endif //HWC_UTILS_H 379