Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2010 The Android Open Source Project |
Arun Kumar K.R | c62935a | 2013-12-03 16:47:47 -0800 | [diff] [blame] | 3 | * Copyright (C)2012-2014, The Linux Foundation. All rights reserved. |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 4 | * |
| 5 | * Not a Contribution, Apache license notifications and license are retained |
| 6 | * for attribution purposes only. |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 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 |
Naseer Ahmed | 72cf976 | 2012-07-21 12:17:13 -0700 | [diff] [blame] | 23 | |
Naseer Ahmed | 5b6708a | 2012-08-02 13:46:08 -0700 | [diff] [blame] | 24 | #define HWC_REMOVE_DEPRECATED_VERSIONS 1 |
Saurabh Shah | 3e858eb | 2012-09-17 16:53:21 -0700 | [diff] [blame] | 25 | #include <fcntl.h> |
Saurabh Shah | 62e1d73 | 2013-09-17 10:44:05 -0700 | [diff] [blame] | 26 | #include <math.h> |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 27 | #include <hardware/hwcomposer.h> |
Naseer Ahmed | 32ff225 | 2012-09-29 01:41:21 -0400 | [diff] [blame] | 28 | #include <gr.h> |
Naseer Ahmed | 72cf976 | 2012-07-21 12:17:13 -0700 | [diff] [blame] | 29 | #include <gralloc_priv.h> |
Naseer Ahmed | 1d183f5 | 2012-11-26 12:35:16 -0500 | [diff] [blame] | 30 | #include <utils/String8.h> |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 31 | #include "qdMetaData.h" |
| 32 | #include <overlayUtils.h> |
Ramkumar Radhakrishnan | 9c9a94b | 2014-03-14 17:28:14 -0700 | [diff] [blame] | 33 | #include <EGL/egl.h> |
| 34 | |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 35 | |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 36 | #define ALIGN_TO(x, align) (((x) + ((align)-1)) & ~((align)-1)) |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 37 | #define LIKELY( exp ) (__builtin_expect( (exp) != 0, true )) |
| 38 | #define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false )) |
Ramkumar Radhakrishnan | e661f96 | 2013-06-05 17:21:38 -0700 | [diff] [blame] | 39 | #define MAX_NUM_APP_LAYERS 32 |
Raj kamal | 9af062e | 2014-04-01 16:52:19 +0530 | [diff] [blame] | 40 | #define HWC_WFDDISPSYNC_LOG 0 |
| 41 | #define STR(f) #f; |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 42 | |
Naseer Ahmed | 72cf976 | 2012-07-21 12:17:13 -0700 | [diff] [blame] | 43 | //Fwrd decls |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 44 | struct hwc_context_t; |
Naseer Ahmed | 72cf976 | 2012-07-21 12:17:13 -0700 | [diff] [blame] | 45 | |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 46 | namespace ovutils = overlay::utils; |
| 47 | |
Naseer Ahmed | 72cf976 | 2012-07-21 12:17:13 -0700 | [diff] [blame] | 48 | namespace overlay { |
| 49 | class Overlay; |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 50 | class Rotator; |
| 51 | class RotMgr; |
Naseer Ahmed | 72cf976 | 2012-07-21 12:17:13 -0700 | [diff] [blame] | 52 | } |
| 53 | |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 54 | namespace qhwc { |
Naseer Ahmed | 72cf976 | 2012-07-21 12:17:13 -0700 | [diff] [blame] | 55 | //fwrd decl |
| 56 | class QueuedBufferStore; |
Naseer Ahmed | 96c4c95 | 2012-07-25 18:27:14 -0700 | [diff] [blame] | 57 | class ExternalDisplay; |
Jeykumar Sankaran | 27dee26 | 2013-08-01 17:09:54 -0700 | [diff] [blame] | 58 | class VirtualDisplay; |
Saurabh Shah | cf053c6 | 2012-12-13 12:32:55 -0800 | [diff] [blame] | 59 | class IFBUpdate; |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 60 | class IVideoOverlay; |
Saurabh Shah | cbf7ccc | 2012-12-19 16:45:51 -0800 | [diff] [blame] | 61 | class MDPComp; |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 62 | class CopyBit; |
Ramkumar Radhakrishnan | d224a1a | 2013-04-05 17:46:55 -0700 | [diff] [blame] | 63 | class HwcDebug; |
Saurabh Shah | a9da08f | 2013-07-03 13:27:53 -0700 | [diff] [blame] | 64 | class AssertiveDisplay; |
Naseer Ahmed | 58780b9 | 2013-07-29 17:41:40 -0400 | [diff] [blame] | 65 | class VPUClient; |
Naseer Ahmed | 96c4c95 | 2012-07-25 18:27:14 -0700 | [diff] [blame] | 66 | |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 67 | |
Naseer Ahmed | 96c4c95 | 2012-07-25 18:27:14 -0700 | [diff] [blame] | 68 | struct MDPInfo { |
| 69 | int version; |
| 70 | char panel; |
| 71 | bool hasOverlay; |
| 72 | }; |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 73 | |
Saurabh Shah | 3e858eb | 2012-09-17 16:53:21 -0700 | [diff] [blame] | 74 | struct DisplayAttributes { |
| 75 | uint32_t vsync_period; //nanos |
| 76 | uint32_t xres; |
| 77 | uint32_t yres; |
Naseer Ahmed | 54821fe | 2012-11-28 18:44:38 -0500 | [diff] [blame] | 78 | uint32_t stride; |
Naseer Ahmed | 7b80d9c | 2012-09-26 20:14:38 -0400 | [diff] [blame] | 79 | float xdpi; |
| 80 | float ydpi; |
Saurabh Shah | 3e858eb | 2012-09-17 16:53:21 -0700 | [diff] [blame] | 81 | int fd; |
Saurabh Shah | c4d034f | 2012-09-27 15:55:15 -0700 | [diff] [blame] | 82 | bool connected; //Applies only to pluggable disp. |
| 83 | //Connected does not mean it ready to use. |
| 84 | //It should be active also. (UNBLANKED) |
Saurabh Shah | 3e858eb | 2012-09-17 16:53:21 -0700 | [diff] [blame] | 85 | bool isActive; |
Amara Venkata Mastan Manoj Kumar | 11a380d | 2013-01-17 09:30:56 -0800 | [diff] [blame] | 86 | // In pause state, composition is bypassed |
| 87 | // used for WFD displays only |
| 88 | bool isPause; |
Jeykumar Sankaran | 27dee26 | 2013-08-01 17:09:54 -0700 | [diff] [blame] | 89 | // To trigger padding round to clean up mdp |
| 90 | // pipes |
| 91 | bool isConfiguring; |
Amara Venkata Mastan Manoj Kumar | 376d8a8 | 2013-03-13 19:18:47 -0700 | [diff] [blame] | 92 | // External Display is in MDP Downscale mode indicator |
| 93 | bool mDownScaleMode; |
Arun Kumar K.R | 8e7a62f | 2013-12-06 18:55:41 -0800 | [diff] [blame] | 94 | // Ext dst Rect |
| 95 | hwc_rect_t mDstRect; |
Ramkumar Radhakrishnan | 4af1ef0 | 2013-12-12 11:53:08 -0800 | [diff] [blame] | 96 | //Action safe attributes |
| 97 | // Flag to indicate the presence of action safe dimensions for external |
| 98 | bool mActionSafePresent; |
| 99 | int mAsWidthRatio; |
| 100 | int mAsHeightRatio; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 101 | }; |
Saurabh Shah | 3e858eb | 2012-09-17 16:53:21 -0700 | [diff] [blame] | 102 | |
| 103 | struct ListStats { |
| 104 | int numAppLayers; //Total - 1, excluding FB layer. |
| 105 | int skipCount; |
| 106 | int fbLayerIndex; //Always last for now. = numAppLayers |
| 107 | //Video specific |
| 108 | int yuvCount; |
Ramkumar Radhakrishnan | e661f96 | 2013-06-05 17:21:38 -0700 | [diff] [blame] | 109 | int yuvIndices[MAX_NUM_APP_LAYERS]; |
Arun Kumar K.R | a297845 | 2013-02-07 01:34:24 -0800 | [diff] [blame] | 110 | int extOnlyLayerIndex; |
Sravan Kumar D.V.N | b5ed029 | 2013-03-15 08:51:16 +0530 | [diff] [blame] | 111 | bool preMultipliedAlpha; |
radhakrishna | c9a6741 | 2013-09-25 17:40:42 +0530 | [diff] [blame] | 112 | int yuv4k2kIndices[MAX_NUM_APP_LAYERS]; |
| 113 | int yuv4k2kCount; |
Ramkumar Radhakrishnan | 59a1107 | 2013-04-15 16:14:49 -0700 | [diff] [blame] | 114 | // Notifies hwcomposer about the start and end of animation |
| 115 | // This will be set to true during animation, otherwise false. |
| 116 | bool isDisplayAnimating; |
Jeykumar Sankaran | 6a9bb9e | 2013-08-01 14:19:26 -0700 | [diff] [blame] | 117 | ovutils::Dim roi; |
Ramkumar Radhakrishnan | ba71338 | 2013-08-30 18:41:07 -0700 | [diff] [blame] | 118 | bool secureUI; // Secure display layer |
Saurabh Shah | 8028e3b | 2013-10-15 12:27:59 -0700 | [diff] [blame] | 119 | bool isSecurePresent; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 120 | }; |
| 121 | |
Naseer Ahmed | 54821fe | 2012-11-28 18:44:38 -0500 | [diff] [blame] | 122 | struct LayerProp { |
| 123 | uint32_t mFlags; //qcom specific layer flags |
Jeykumar Sankaran | 6a9bb9e | 2013-08-01 14:19:26 -0700 | [diff] [blame] | 124 | LayerProp():mFlags(0){}; |
Naseer Ahmed | 54821fe | 2012-11-28 18:44:38 -0500 | [diff] [blame] | 125 | }; |
| 126 | |
Naseer Ahmed | 8bb8f9d | 2013-05-11 07:29:45 -0400 | [diff] [blame] | 127 | struct VsyncState { |
| 128 | bool enable; |
| 129 | bool fakevsync; |
| 130 | }; |
| 131 | |
Saurabh Shah | 1a03d48 | 2013-05-29 13:44:20 -0700 | [diff] [blame] | 132 | struct BwcPM { |
| 133 | static void setBwc(hwc_context_t *ctx, const hwc_rect_t& crop, |
| 134 | const hwc_rect_t& dst, const int& transform, |
| 135 | ovutils::eMdpFlags& mdpFlags); |
| 136 | }; |
| 137 | |
Naseer Ahmed | 54821fe | 2012-11-28 18:44:38 -0500 | [diff] [blame] | 138 | // LayerProp::flag values |
Naseer Ahmed | 7c958d4 | 2012-07-31 18:57:03 -0700 | [diff] [blame] | 139 | enum { |
Naseer Ahmed | 54821fe | 2012-11-28 18:44:38 -0500 | [diff] [blame] | 140 | HWC_MDPCOMP = 0x00000001, |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 141 | HWC_COPYBIT = 0x00000002, |
Naseer Ahmed | 7c958d4 | 2012-07-31 18:57:03 -0700 | [diff] [blame] | 142 | }; |
| 143 | |
Sushil Chauhan | 1f6d68f | 2013-10-11 11:49:35 -0700 | [diff] [blame] | 144 | // HAL specific features |
| 145 | enum { |
Sushil Chauhan | 943797c | 2013-10-21 17:35:55 -0700 | [diff] [blame] | 146 | HWC_COLOR_FILL = 0x00000008, |
Sushil Chauhan | 1f6d68f | 2013-10-11 11:49:35 -0700 | [diff] [blame] | 147 | HWC_FORMAT_RB_SWAP = 0x00000040, |
| 148 | }; |
| 149 | |
Raj kamal | 9af062e | 2014-04-01 16:52:19 +0530 | [diff] [blame] | 150 | /* External Display states */ |
| 151 | enum { |
| 152 | EXTERNAL_OFFLINE = 0, |
| 153 | EXTERNAL_ONLINE, |
| 154 | EXTERNAL_PAUSE, |
| 155 | EXTERNAL_RESUME, |
| 156 | EXTERNAL_MAXSTATES |
| 157 | }; |
| 158 | |
Saurabh Shah | 23a813c | 2013-03-20 16:58:12 -0700 | [diff] [blame] | 159 | class LayerRotMap { |
| 160 | public: |
| 161 | LayerRotMap() { reset(); } |
| 162 | enum { MAX_SESS = 3 }; |
| 163 | void add(hwc_layer_1_t* layer, overlay::Rotator *rot); |
Saurabh Shah | da5b3ce | 2013-11-26 10:48:06 -0800 | [diff] [blame] | 164 | //Resets the mapping of layer to rotator |
Saurabh Shah | 23a813c | 2013-03-20 16:58:12 -0700 | [diff] [blame] | 165 | void reset(); |
Saurabh Shah | da5b3ce | 2013-11-26 10:48:06 -0800 | [diff] [blame] | 166 | //Clears mappings and existing rotator fences |
| 167 | //Intended to be used during errors |
| 168 | void clear(); |
Saurabh Shah | 23a813c | 2013-03-20 16:58:12 -0700 | [diff] [blame] | 169 | uint32_t getCount() const; |
| 170 | hwc_layer_1_t* getLayer(uint32_t index) const; |
| 171 | overlay::Rotator* getRot(uint32_t index) const; |
| 172 | void setReleaseFd(const int& fence); |
| 173 | private: |
| 174 | hwc_layer_1_t* mLayer[MAX_SESS]; |
| 175 | overlay::Rotator* mRot[MAX_SESS]; |
| 176 | uint32_t mCount; |
| 177 | }; |
| 178 | |
| 179 | inline uint32_t LayerRotMap::getCount() const { |
| 180 | return mCount; |
| 181 | } |
| 182 | |
| 183 | inline hwc_layer_1_t* LayerRotMap::getLayer(uint32_t index) const { |
| 184 | if(index >= mCount) return NULL; |
| 185 | return mLayer[index]; |
| 186 | } |
| 187 | |
| 188 | inline overlay::Rotator* LayerRotMap::getRot(uint32_t index) const { |
| 189 | if(index >= mCount) return NULL; |
| 190 | return mRot[index]; |
| 191 | } |
| 192 | |
Saurabh Shah | 62e1d73 | 2013-09-17 10:44:05 -0700 | [diff] [blame] | 193 | inline hwc_rect_t integerizeSourceCrop(const hwc_frect_t& cropF) { |
| 194 | hwc_rect_t cropI = {0}; |
| 195 | cropI.left = int(ceilf(cropF.left)); |
| 196 | cropI.top = int(ceilf(cropF.top)); |
| 197 | cropI.right = int(floorf(cropF.right)); |
| 198 | cropI.bottom = int(floorf(cropF.bottom)); |
| 199 | return cropI; |
| 200 | } |
| 201 | |
Naseer Ahmed | e850a80 | 2013-09-06 13:12:52 -0400 | [diff] [blame] | 202 | inline bool isNonIntegralSourceCrop(const hwc_frect_t& cropF) { |
| 203 | if(cropF.left - roundf(cropF.left) || |
| 204 | cropF.top - roundf(cropF.top) || |
| 205 | cropF.right - roundf(cropF.right) || |
| 206 | cropF.bottom - roundf(cropF.bottom)) |
| 207 | return true; |
| 208 | else |
| 209 | return false; |
| 210 | } |
| 211 | |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 212 | // ----------------------------------------------------------------------------- |
| 213 | // Utility functions - implemented in hwc_utils.cpp |
Naseer Ahmed | 5b6708a | 2012-08-02 13:46:08 -0700 | [diff] [blame] | 214 | void dumpLayer(hwc_layer_1_t const* l); |
Saurabh Shah | d9ff30b | 2013-10-03 16:37:06 -0700 | [diff] [blame] | 215 | void setListStats(hwc_context_t *ctx, hwc_display_contents_1_t *list, |
Saurabh Shah | 3e858eb | 2012-09-17 16:53:21 -0700 | [diff] [blame] | 216 | int dpy); |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 217 | void initContext(hwc_context_t *ctx); |
| 218 | void closeContext(hwc_context_t *ctx); |
Naseer Ahmed | f48aef6 | 2012-07-20 09:05:53 -0700 | [diff] [blame] | 219 | //Crops source buffer against destination and FB boundaries |
| 220 | void calculate_crop_rects(hwc_rect_t& crop, hwc_rect_t& dst, |
Jeykumar Sankaran | b551ce4 | 2013-01-10 16:26:48 -0800 | [diff] [blame] | 221 | const hwc_rect_t& scissor, int orient); |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 222 | void getNonWormholeRegion(hwc_display_contents_1_t* list, |
| 223 | hwc_rect_t& nwr); |
Jeykumar Sankaran | 85977e3 | 2013-02-25 17:06:08 -0800 | [diff] [blame] | 224 | bool isSecuring(hwc_context_t* ctx, hwc_layer_1_t const* layer); |
Sushil Chauhan | 2515abf | 2013-01-08 16:40:05 -0800 | [diff] [blame] | 225 | bool isSecureModePolicy(int mdpVersion); |
Saurabh Shah | 3e858eb | 2012-09-17 16:53:21 -0700 | [diff] [blame] | 226 | bool isExternalActive(hwc_context_t* ctx); |
Prabhanjan Kandula | 21918db | 2013-11-26 15:51:58 +0530 | [diff] [blame] | 227 | bool isAlphaScaled(hwc_layer_1_t const* layer); |
| 228 | bool needsScaling(hwc_layer_1_t const* layer); |
| 229 | bool isDownscaleRequired(hwc_layer_1_t const* layer); |
Sushil Chauhan | 15a2ea6 | 2013-09-04 18:28:36 -0700 | [diff] [blame] | 230 | bool needsScalingWithSplit(hwc_context_t* ctx, hwc_layer_1_t const* layer, |
| 231 | const int& dpy); |
| 232 | void sanitizeSourceCrop(hwc_rect_t& cropL, hwc_rect_t& cropR, |
| 233 | private_handle_t *hnd); |
Sravan Kumar D.V.N | 075ef00 | 2013-03-20 05:22:26 +0530 | [diff] [blame] | 234 | bool isAlphaPresent(hwc_layer_1_t const* layer); |
Naseer Ahmed | 56601cd | 2013-03-05 11:34:14 -0500 | [diff] [blame] | 235 | int hwc_vsync_control(hwc_context_t* ctx, int dpy, int enable); |
Naseer Ahmed | 522ce66 | 2013-03-18 20:14:05 -0400 | [diff] [blame] | 236 | int getBlending(int blending); |
Saurabh Shah | fc2acbe | 2012-08-17 19:47:52 -0700 | [diff] [blame] | 237 | |
Naseer Ahmed | 1d183f5 | 2012-11-26 12:35:16 -0500 | [diff] [blame] | 238 | //Helper function to dump logs |
| 239 | void dumpsys_log(android::String8& buf, const char* fmt, ...); |
| 240 | |
Ramkumar Radhakrishnan | 66f856c | 2013-08-21 16:09:47 -0700 | [diff] [blame] | 241 | int getExtOrientation(hwc_context_t* ctx); |
Jeykumar Sankaran | 6a58579 | 2013-10-03 11:30:55 -0700 | [diff] [blame] | 242 | bool isValidRect(const hwc_rect_t& rect); |
Jeykumar Sankaran | 9394353 | 2013-11-08 18:05:11 -0800 | [diff] [blame] | 243 | hwc_rect_t deductRect(const hwc_rect_t& rect1, const hwc_rect_t& rect2); |
Jeykumar Sankaran | 7889342 | 2014-05-07 16:23:14 -0700 | [diff] [blame] | 244 | hwc_rect_t moveRect(const hwc_rect_t& rect, const int& x_off, const int& y_off); |
Jeykumar Sankaran | 6a58579 | 2013-10-03 11:30:55 -0700 | [diff] [blame] | 245 | hwc_rect_t getIntersection(const hwc_rect_t& rect1, const hwc_rect_t& rect2); |
| 246 | hwc_rect_t getUnion(const hwc_rect_t& rect1, const hwc_rect_t& rect2); |
Prabhanjan Kandula | a5dc8e9 | 2013-09-25 15:20:33 +0530 | [diff] [blame] | 247 | void optimizeLayerRects(hwc_context_t *ctx, |
Prabhanjan Kandula | 9bd5f64 | 2013-09-25 17:00:36 +0530 | [diff] [blame] | 248 | const hwc_display_contents_1_t *list, const int& dpy); |
| 249 | bool areLayersIntersecting(const hwc_layer_1_t* layer1, |
| 250 | const hwc_layer_1_t* layer2); |
Prabhanjan Kandula | a5dc8e9 | 2013-09-25 15:20:33 +0530 | [diff] [blame] | 251 | |
Ramkumar Radhakrishnan | 4af1ef0 | 2013-12-12 11:53:08 -0800 | [diff] [blame] | 252 | // returns true if Action safe dimensions are set and target supports Actionsafe |
| 253 | bool isActionSafePresent(hwc_context_t *ctx, int dpy); |
| 254 | |
Arun Kumar K.R | feb2d8a | 2013-02-01 02:53:13 -0800 | [diff] [blame] | 255 | /* Calculates the destination position based on the action safe rectangle */ |
Arun Kumar K.R | 5898c65 | 2013-07-17 14:20:32 -0700 | [diff] [blame] | 256 | void getActionSafePosition(hwc_context_t *ctx, int dpy, hwc_rect_t& dst); |
Arun Kumar K.R | feb2d8a | 2013-02-01 02:53:13 -0800 | [diff] [blame] | 257 | |
Arun Kumar K.R | 5898c65 | 2013-07-17 14:20:32 -0700 | [diff] [blame] | 258 | void getAspectRatioPosition(hwc_context_t* ctx, int dpy, int extOrientation, |
| 259 | hwc_rect_t& inRect, hwc_rect_t& outRect); |
| 260 | |
| 261 | bool isPrimaryPortrait(hwc_context_t *ctx); |
| 262 | |
Amara Venkata Mastan Manoj Kumar | 376d8a8 | 2013-03-13 19:18:47 -0700 | [diff] [blame] | 263 | bool isOrientationPortrait(hwc_context_t *ctx); |
| 264 | |
Arun Kumar K.R | 5898c65 | 2013-07-17 14:20:32 -0700 | [diff] [blame] | 265 | void calcExtDisplayPosition(hwc_context_t *ctx, |
Ramkumar Radhakrishnan | 66f856c | 2013-08-21 16:09:47 -0700 | [diff] [blame] | 266 | private_handle_t *hnd, |
Amara Venkata Mastan Manoj Kumar | 376d8a8 | 2013-03-13 19:18:47 -0700 | [diff] [blame] | 267 | int dpy, |
| 268 | hwc_rect_t& sourceCrop, |
Ramkumar Radhakrishnan | 66f856c | 2013-08-21 16:09:47 -0700 | [diff] [blame] | 269 | hwc_rect_t& displayFrame, |
| 270 | int& transform, |
| 271 | ovutils::eTransform& orient); |
| 272 | |
Arun Kumar K.R | fb5bfa6 | 2013-07-25 03:10:51 -0700 | [diff] [blame] | 273 | // Returns the orientation that needs to be set on external for |
| 274 | // BufferMirrirMode(Sidesync) |
| 275 | int getMirrorModeOrientation(hwc_context_t *ctx); |
Arun Kumar K.R | ffef748 | 2013-04-10 14:17:22 -0700 | [diff] [blame] | 276 | |
Raj kamal | 9af062e | 2014-04-01 16:52:19 +0530 | [diff] [blame] | 277 | /* Get External State names */ |
| 278 | const char* getExternalDisplayState(uint32_t external_state); |
| 279 | |
Jeykumar Sankaran | 4d76a38 | 2014-02-26 18:26:58 -0800 | [diff] [blame] | 280 | // Aligns updating ROI to panel restrictions |
| 281 | hwc_rect_t sanitizeROI(struct hwc_rect roi, hwc_rect boundary); |
| 282 | |
Arun Kumar K.R | c62935a | 2013-12-03 16:47:47 -0800 | [diff] [blame] | 283 | // Handles wfd Pause and resume events |
| 284 | void handle_pause(hwc_context_t *ctx, int dpy); |
| 285 | void handle_resume(hwc_context_t *ctx, int dpy); |
| 286 | |
Saurabh Shah | 747af1e | 2013-02-26 10:25:12 -0800 | [diff] [blame] | 287 | //Close acquireFenceFds of all layers of incoming list |
| 288 | void closeAcquireFds(hwc_display_contents_1_t* list); |
| 289 | |
Kinjal Bhavsar | 2dd04a8 | 2012-09-18 18:27:59 -0700 | [diff] [blame] | 290 | //Sync point impl. |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 291 | int hwc_sync(hwc_context_t *ctx, hwc_display_contents_1_t* list, int dpy, |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 292 | int fd); |
| 293 | |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 294 | //Sets appropriate mdp flags for a layer. |
| 295 | void setMdpFlags(hwc_layer_1_t *layer, |
| 296 | ovutils::eMdpFlags &mdpFlags, |
Ramkumar Radhakrishnan | 9d52f43 | 2013-05-14 14:46:59 -0700 | [diff] [blame] | 297 | int rotDownscale, int transform); |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 298 | |
Prabhanjan Kandula | a1d8301 | 2013-04-23 13:06:02 +0530 | [diff] [blame] | 299 | int configRotator(overlay::Rotator *rot, ovutils::Whf& whf, |
Sushil Chauhan | 1cac815 | 2013-05-08 15:53:51 -0700 | [diff] [blame] | 300 | hwc_rect_t& crop, const ovutils::eMdpFlags& mdpFlags, |
Arun Kumar K.R | ffef748 | 2013-04-10 14:17:22 -0700 | [diff] [blame] | 301 | const ovutils::eTransform& orient, const int& downscale); |
| 302 | |
| 303 | int configMdp(overlay::Overlay *ov, const ovutils::PipeArgs& parg, |
| 304 | const ovutils::eTransform& orient, const hwc_rect_t& crop, |
| 305 | const hwc_rect_t& pos, const MetaData_t *metadata, |
| 306 | const ovutils::eDest& dest); |
| 307 | |
Sushil Chauhan | 897a9c3 | 2013-07-18 11:09:55 -0700 | [diff] [blame] | 308 | int configColorLayer(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy, |
| 309 | ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z, |
| 310 | ovutils::eIsFg& isFg, const ovutils::eDest& dest); |
| 311 | |
Arun Kumar K.R | ffef748 | 2013-04-10 14:17:22 -0700 | [diff] [blame] | 312 | void updateSource(ovutils::eTransform& orient, ovutils::Whf& whf, |
| 313 | hwc_rect_t& crop); |
| 314 | |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 315 | //Routine to configure low resolution panels (<= 2048 width) |
Saurabh Shah | 88e4d27 | 2013-09-03 13:31:29 -0700 | [diff] [blame] | 316 | int configureNonSplit(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy, |
Ramkumar Radhakrishnan | 59a1107 | 2013-04-15 16:14:49 -0700 | [diff] [blame] | 317 | ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z, |
| 318 | ovutils::eIsFg& isFg, const ovutils::eDest& dest, |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 319 | overlay::Rotator **rot); |
| 320 | |
| 321 | //Routine to configure high resolution panels (> 2048 width) |
Saurabh Shah | 88e4d27 | 2013-09-03 13:31:29 -0700 | [diff] [blame] | 322 | int configureSplit(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy, |
Ramkumar Radhakrishnan | 59a1107 | 2013-04-15 16:14:49 -0700 | [diff] [blame] | 323 | ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z, |
| 324 | ovutils::eIsFg& isFg, const ovutils::eDest& lDest, |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 325 | const ovutils::eDest& rDest, overlay::Rotator **rot); |
Kinjal Bhavsar | 2dd04a8 | 2012-09-18 18:27:59 -0700 | [diff] [blame] | 326 | |
radhakrishna | c9a6741 | 2013-09-25 17:40:42 +0530 | [diff] [blame] | 327 | //Routine to split and configure high resolution YUV layer (> 2048 width) |
| 328 | int configureSourceSplit(hwc_context_t *ctx, hwc_layer_1_t *layer, |
| 329 | const int& dpy, |
| 330 | ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z, |
| 331 | ovutils::eIsFg& isFg, const ovutils::eDest& lDest, |
| 332 | const ovutils::eDest& rDest, overlay::Rotator **rot); |
| 333 | |
Saurabh Shah | e247408 | 2013-05-15 16:32:13 -0700 | [diff] [blame] | 334 | //On certain targets DMA pipes are used for rotation and they won't be available |
| 335 | //for line operations. On a per-target basis we can restrict certain use cases |
| 336 | //from using rotator, since we know before-hand that such scenarios can lead to |
| 337 | //extreme unavailability of pipes. This can also be done via hybrid calculations |
| 338 | //also involving many more variables like number of write-back interfaces etc, |
| 339 | //but the variety of scenarios is too high to warrant that. |
Amara Venkata Mastan Manoj Kumar | 9d373c0 | 2013-08-20 14:30:09 -0700 | [diff] [blame] | 340 | bool canUseRotator(hwc_context_t *ctx, int dpy); |
Saurabh Shah | e247408 | 2013-05-15 16:32:13 -0700 | [diff] [blame] | 341 | |
Saurabh Shah | 07a8ca8 | 2013-08-06 18:45:42 -0700 | [diff] [blame] | 342 | int getLeftSplit(hwc_context_t *ctx, const int& dpy); |
| 343 | |
Saurabh Shah | 88e4d27 | 2013-09-03 13:31:29 -0700 | [diff] [blame] | 344 | bool isDisplaySplit(hwc_context_t* ctx, int dpy); |
| 345 | |
Ramkumar Radhakrishnan | 9c9a94b | 2014-03-14 17:28:14 -0700 | [diff] [blame] | 346 | // Set the GPU hint flag to high for MIXED/GPU composition only for |
| 347 | // first frame after MDP to GPU/MIXED mode transition. |
| 348 | // Set the GPU hint to default if the current composition type is GPU |
| 349 | // due to idle fallback or MDP composition. |
| 350 | void setGPUHint(hwc_context_t* ctx, hwc_display_contents_1_t* list); |
| 351 | |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 352 | // Inline utility functions |
Naseer Ahmed | 5b6708a | 2012-08-02 13:46:08 -0700 | [diff] [blame] | 353 | static inline bool isSkipLayer(const hwc_layer_1_t* l) { |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 354 | return (UNLIKELY(l && (l->flags & HWC_SKIP_LAYER))); |
| 355 | } |
| 356 | |
| 357 | // Returns true if the buffer is yuv |
| 358 | static inline bool isYuvBuffer(const private_handle_t* hnd) { |
| 359 | return (hnd && (hnd->bufferType == BUFFER_TYPE_VIDEO)); |
| 360 | } |
| 361 | |
radhakrishna | c9a6741 | 2013-09-25 17:40:42 +0530 | [diff] [blame] | 362 | // Returns true if the buffer is yuv |
| 363 | static inline bool is4kx2kYuvBuffer(const private_handle_t* hnd) { |
| 364 | return (hnd && (hnd->bufferType == BUFFER_TYPE_VIDEO) && |
| 365 | (hnd->width > 2048)); |
| 366 | } |
| 367 | |
Saurabh Shah | f395d09 | 2012-08-27 12:33:42 -0700 | [diff] [blame] | 368 | // Returns true if the buffer is secure |
| 369 | static inline bool isSecureBuffer(const private_handle_t* hnd) { |
| 370 | return (hnd && (private_handle_t::PRIV_FLAGS_SECURE_BUFFER & hnd->flags)); |
| 371 | } |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 372 | //Return true if buffer is marked locked |
| 373 | static inline bool isBufferLocked(const private_handle_t* hnd) { |
| 374 | return (hnd && (private_handle_t::PRIV_FLAGS_HWC_LOCK & hnd->flags)); |
| 375 | } |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 376 | |
Naseer Ahmed | 4c588a2 | 2012-07-31 19:12:17 -0700 | [diff] [blame] | 377 | //Return true if buffer is for external display only |
| 378 | static inline bool isExtOnly(const private_handle_t* hnd) { |
| 379 | return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_ONLY)); |
| 380 | } |
| 381 | |
Ramkumar Radhakrishnan | ba71338 | 2013-08-30 18:41:07 -0700 | [diff] [blame] | 382 | //Return true if the buffer is intended for Secure Display |
| 383 | static inline bool isSecureDisplayBuffer(const private_handle_t* hnd) { |
| 384 | return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY)); |
| 385 | } |
| 386 | |
Ramkumar Radhakrishnan | 92f3abe | 2013-06-05 13:52:40 -0700 | [diff] [blame] | 387 | static inline int getWidth(const private_handle_t* hnd) { |
| 388 | if(isYuvBuffer(hnd)) { |
| 389 | MetaData_t *metadata = (MetaData_t *)hnd->base_metadata; |
| 390 | if(metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) { |
| 391 | return metadata->bufferDim.sliceWidth; |
| 392 | } |
| 393 | } |
| 394 | return hnd->width; |
| 395 | } |
| 396 | |
| 397 | static inline int getHeight(const private_handle_t* hnd) { |
| 398 | if(isYuvBuffer(hnd)) { |
| 399 | MetaData_t *metadata = (MetaData_t *)hnd->base_metadata; |
| 400 | if(metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) { |
| 401 | return metadata->bufferDim.sliceHeight; |
| 402 | } |
| 403 | } |
| 404 | return hnd->height; |
| 405 | } |
| 406 | |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 407 | template<typename T> inline T max(T a, T b) { return (a > b) ? a : b; } |
| 408 | template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; } |
| 409 | |
Naseer Ahmed | 72cf976 | 2012-07-21 12:17:13 -0700 | [diff] [blame] | 410 | // Initialize uevent thread |
| 411 | void init_uevent_thread(hwc_context_t* ctx); |
Naseer Ahmed | ff4f025 | 2012-10-01 13:03:01 -0400 | [diff] [blame] | 412 | // Initialize vsync thread |
| 413 | void init_vsync_thread(hwc_context_t* ctx); |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 414 | |
Naseer Ahmed | 5b6708a | 2012-08-02 13:46:08 -0700 | [diff] [blame] | 415 | inline void getLayerResolution(const hwc_layer_1_t* layer, |
Naseer Ahmed | 522ce66 | 2013-03-18 20:14:05 -0400 | [diff] [blame] | 416 | int& width, int& height) { |
Naseer Ahmed | 7c958d4 | 2012-07-31 18:57:03 -0700 | [diff] [blame] | 417 | hwc_rect_t displayFrame = layer->displayFrame; |
| 418 | width = displayFrame.right - displayFrame.left; |
| 419 | height = displayFrame.bottom - displayFrame.top; |
| 420 | } |
Saurabh Shah | 3e858eb | 2012-09-17 16:53:21 -0700 | [diff] [blame] | 421 | |
| 422 | static inline int openFb(int dpy) { |
| 423 | int fd = -1; |
| 424 | const char *devtmpl = "/dev/graphics/fb%u"; |
| 425 | char name[64] = {0}; |
| 426 | snprintf(name, 64, devtmpl, dpy); |
| 427 | fd = open(name, O_RDWR); |
| 428 | return fd; |
| 429 | } |
| 430 | |
Saurabh Shah | 27c1d65 | 2012-08-14 19:30:28 -0700 | [diff] [blame] | 431 | template <class T> |
| 432 | inline void swap(T& a, T& b) { |
| 433 | T tmp = a; |
| 434 | a = b; |
| 435 | b = tmp; |
| 436 | } |
| 437 | |
Naseer Ahmed | f48aef6 | 2012-07-20 09:05:53 -0700 | [diff] [blame] | 438 | }; //qhwc namespace |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 439 | |
Ramkumar Radhakrishnan | a70981a | 2013-08-28 11:33:53 -0700 | [diff] [blame] | 440 | enum eAnimationState{ |
| 441 | ANIMATION_STOPPED, |
| 442 | ANIMATION_STARTED, |
| 443 | }; |
| 444 | |
Ramkumar Radhakrishnan | 9c9a94b | 2014-03-14 17:28:14 -0700 | [diff] [blame] | 445 | // Structure holds the information about the GPU hint. |
| 446 | struct gpu_hint_info { |
| 447 | // system level flag to enable gpu_perf_mode |
| 448 | bool mGpuPerfModeEnable; |
| 449 | // Stores the current GPU performance mode DEFAULT/HIGH |
| 450 | bool mCurrGPUPerfMode; |
| 451 | // true if previous composition used GPU |
| 452 | bool mPrevCompositionGLES; |
| 453 | // Stores the EGLContext of current process |
| 454 | EGLContext mEGLContext; |
| 455 | // Stores the EGLDisplay of current process |
| 456 | EGLDisplay mEGLDisplay; |
| 457 | }; |
| 458 | |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 459 | // ----------------------------------------------------------------------------- |
| 460 | // HWC context |
| 461 | // This structure contains overall state |
| 462 | struct hwc_context_t { |
Naseer Ahmed | 5b6708a | 2012-08-02 13:46:08 -0700 | [diff] [blame] | 463 | hwc_composer_device_1_t device; |
Jesse Hall | 3be78d9 | 2012-08-21 15:12:23 -0700 | [diff] [blame] | 464 | const hwc_procs_t* proc; |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 465 | |
| 466 | //CopyBit objects |
Amara Venkata Mastan Manoj Kumar | 7fb1327 | 2013-07-01 13:59:34 -0700 | [diff] [blame] | 467 | qhwc::CopyBit *mCopyBit[HWC_NUM_DISPLAY_TYPES]; |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 468 | |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 469 | //Overlay object - NULL for non overlay devices |
Naseer Ahmed | 758bfc5 | 2012-11-28 17:02:08 -0500 | [diff] [blame] | 470 | overlay::Overlay *mOverlay; |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 471 | //Holds a few rot objects |
| 472 | overlay::RotMgr *mRotMgr; |
Saurabh Shah | cf053c6 | 2012-12-13 12:32:55 -0800 | [diff] [blame] | 473 | |
| 474 | //Primary and external FB updater |
Amara Venkata Mastan Manoj Kumar | 7fb1327 | 2013-07-01 13:59:34 -0700 | [diff] [blame] | 475 | qhwc::IFBUpdate *mFBUpdate[HWC_NUM_DISPLAY_TYPES]; |
Naseer Ahmed | 0c8b7b5 | 2012-07-20 09:06:13 -0700 | [diff] [blame] | 476 | // External display related information |
Naseer Ahmed | 72cf976 | 2012-07-21 12:17:13 -0700 | [diff] [blame] | 477 | qhwc::ExternalDisplay *mExtDisplay; |
Jeykumar Sankaran | 27dee26 | 2013-08-01 17:09:54 -0700 | [diff] [blame] | 478 | qhwc::VirtualDisplay *mVirtualDisplay; |
Naseer Ahmed | 96c4c95 | 2012-07-25 18:27:14 -0700 | [diff] [blame] | 479 | qhwc::MDPInfo mMDP; |
Naseer Ahmed | 8bb8f9d | 2013-05-11 07:29:45 -0400 | [diff] [blame] | 480 | qhwc::VsyncState vstate; |
Amara Venkata Mastan Manoj Kumar | 7fb1327 | 2013-07-01 13:59:34 -0700 | [diff] [blame] | 481 | qhwc::DisplayAttributes dpyAttr[HWC_NUM_DISPLAY_TYPES]; |
| 482 | qhwc::ListStats listStats[HWC_NUM_DISPLAY_TYPES]; |
| 483 | qhwc::LayerProp *layerProp[HWC_NUM_DISPLAY_TYPES]; |
| 484 | qhwc::MDPComp *mMDPComp[HWC_NUM_DISPLAY_TYPES]; |
| 485 | qhwc::HwcDebug *mHwcDebug[HWC_NUM_DISPLAY_TYPES]; |
Ramkumar Radhakrishnan | dd38b82 | 2013-12-04 15:15:42 -0800 | [diff] [blame] | 486 | hwc_rect_t mViewFrame[HWC_NUM_DISPLAY_TYPES]; |
Saurabh Shah | a9da08f | 2013-07-03 13:27:53 -0700 | [diff] [blame] | 487 | qhwc::AssertiveDisplay *mAD; |
Naseer Ahmed | 58780b9 | 2013-07-29 17:41:40 -0400 | [diff] [blame] | 488 | qhwc::VPUClient *mVPUClient; |
Ramkumar Radhakrishnan | a70981a | 2013-08-28 11:33:53 -0700 | [diff] [blame] | 489 | eAnimationState mAnimationState[HWC_NUM_DISPLAY_TYPES]; |
Naseer Ahmed | b1c7632 | 2012-10-17 00:32:50 -0400 | [diff] [blame] | 490 | |
Raj Kamal | fc5b922 | 2014-02-07 16:15:17 +0530 | [diff] [blame] | 491 | // stores the #numHwLayers of the previous frame |
| 492 | // for each display device |
| 493 | int mPrevHwLayerCount[HWC_NUM_DISPLAY_TYPES]; |
| 494 | |
Ramkumar Radhakrishnan | a70981a | 2013-08-28 11:33:53 -0700 | [diff] [blame] | 495 | // stores the primary device orientation |
Ramkumar Radhakrishnan | 59a1107 | 2013-04-15 16:14:49 -0700 | [diff] [blame] | 496 | int deviceOrientation; |
Saurabh Shah | 56f610d | 2012-08-07 15:27:06 -0700 | [diff] [blame] | 497 | //Securing in progress indicator |
| 498 | bool mSecuring; |
Jeykumar Sankaran | 27dee26 | 2013-08-01 17:09:54 -0700 | [diff] [blame] | 499 | //WFD on proprietary stack |
| 500 | bool mVirtualonExtActive; |
Saurabh Shah | 56f610d | 2012-08-07 15:27:06 -0700 | [diff] [blame] | 501 | //Display in secure mode indicator |
| 502 | bool mSecureMode; |
Saurabh Shah | b39f815 | 2013-08-22 10:21:44 -0700 | [diff] [blame] | 503 | //Lock to protect drawing data structures |
| 504 | mutable Locker mDrawLock; |
Saurabh Shah | 0ceeb6a | 2013-04-23 10:46:07 -0700 | [diff] [blame] | 505 | //Drawing round when we use GPU |
| 506 | bool isPaddingRound; |
Arun Kumar K.R | ffef748 | 2013-04-10 14:17:22 -0700 | [diff] [blame] | 507 | // External Orientation |
| 508 | int mExtOrientation; |
Saurabh Shah | d4e6585 | 2013-06-17 11:33:53 -0700 | [diff] [blame] | 509 | //Flags the transition of a video session |
| 510 | bool mVideoTransFlag; |
Arun Kumar K.R | fb5bfa6 | 2013-07-25 03:10:51 -0700 | [diff] [blame] | 511 | //Used for SideSync feature |
| 512 | //which overrides the mExtOrientation |
| 513 | bool mBufferMirrorMode; |
Raj kamal | 9af062e | 2014-04-01 16:52:19 +0530 | [diff] [blame] | 514 | // Used to synchronize between WFD and Display modules |
| 515 | mutable Locker mWfdSyncLock; |
Arun Kumar K.R | fb5bfa6 | 2013-07-25 03:10:51 -0700 | [diff] [blame] | 516 | |
Amara Venkata Mastan Manoj Kumar | 7fb1327 | 2013-07-01 13:59:34 -0700 | [diff] [blame] | 517 | qhwc::LayerRotMap *mLayerRotMap[HWC_NUM_DISPLAY_TYPES]; |
Veera Sankaran | 0dadfb3 | 2013-07-22 16:07:48 -0700 | [diff] [blame] | 518 | // Panel reset flag will be set if BTA check fails |
| 519 | bool mPanelResetStatus; |
Tatenda Chipeperekwa | 093a0b6 | 2014-02-20 19:07:01 -0800 | [diff] [blame] | 520 | |
| 521 | // Downscale feature switch, set via system the property |
| 522 | // sys.hwc.mdp_downscale_enabled |
| 523 | bool mMDPDownscaleEnabled; |
Raj Kamal | 1cbe839 | 2014-01-27 19:35:13 +0530 | [diff] [blame] | 524 | // number of active Displays |
| 525 | int numActiveDisplays; |
Ramkumar Radhakrishnan | 9c9a94b | 2014-03-14 17:28:14 -0700 | [diff] [blame] | 526 | struct gpu_hint_info mGPUHintInfo; |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 527 | }; |
| 528 | |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 529 | namespace qhwc { |
Saurabh Shah | cbf7ccc | 2012-12-19 16:45:51 -0800 | [diff] [blame] | 530 | static inline bool isSkipPresent (hwc_context_t *ctx, int dpy) { |
| 531 | return ctx->listStats[dpy].skipCount; |
| 532 | } |
| 533 | |
| 534 | static inline bool isYuvPresent (hwc_context_t *ctx, int dpy) { |
| 535 | return ctx->listStats[dpy].yuvCount; |
| 536 | } |
Saurabh Shah | e9bc60f | 2013-08-29 12:58:06 -0700 | [diff] [blame] | 537 | |
| 538 | static inline bool has90Transform(hwc_layer_1_t *layer) { |
Sushil Chauhan | 897a9c3 | 2013-07-18 11:09:55 -0700 | [diff] [blame] | 539 | return ((layer->transform & HWC_TRANSFORM_ROT_90) && |
| 540 | !(layer->flags & HWC_COLOR_FILL)); |
Saurabh Shah | e9bc60f | 2013-08-29 12:58:06 -0700 | [diff] [blame] | 541 | } |
| 542 | |
Saurabh Shah | 8028e3b | 2013-10-15 12:27:59 -0700 | [diff] [blame] | 543 | inline bool isSecurePresent(hwc_context_t *ctx, int dpy) { |
| 544 | return ctx->listStats[dpy].isSecurePresent; |
| 545 | } |
| 546 | |
Tatenda Chipeperekwa | 75a4181 | 2014-04-01 12:54:13 -0700 | [diff] [blame] | 547 | static inline bool isSecondaryConnected(hwc_context_t* ctx) { |
| 548 | return (ctx->dpyAttr[HWC_DISPLAY_EXTERNAL].connected || |
| 549 | ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].connected); |
| 550 | } |
| 551 | |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 552 | }; |
Saurabh Shah | cbf7ccc | 2012-12-19 16:45:51 -0800 | [diff] [blame] | 553 | |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 554 | #endif //HWC_UTILS_H |