Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2010 The Android Open Source Project |
Jeykumar Sankaran | b551ce4 | 2013-01-10 16:26:48 -0800 | [diff] [blame] | 3 | * Copyright (C)2012-2013, 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> |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 26 | #include <hardware/hwcomposer.h> |
Naseer Ahmed | 32ff225 | 2012-09-29 01:41:21 -0400 | [diff] [blame] | 27 | #include <gr.h> |
Naseer Ahmed | 72cf976 | 2012-07-21 12:17:13 -0700 | [diff] [blame] | 28 | #include <gralloc_priv.h> |
Naseer Ahmed | 1d183f5 | 2012-11-26 12:35:16 -0500 | [diff] [blame] | 29 | #include <utils/String8.h> |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 30 | #include "qdMetaData.h" |
| 31 | #include <overlayUtils.h> |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 32 | |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 33 | #define ALIGN_TO(x, align) (((x) + ((align)-1)) & ~((align)-1)) |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 34 | #define LIKELY( exp ) (__builtin_expect( (exp) != 0, true )) |
| 35 | #define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false )) |
Saurabh Shah | 2b03339 | 2013-03-22 11:29:44 -0700 | [diff] [blame] | 36 | #define MAX_NUM_LAYERS 32 //includes fb layer |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 37 | |
Amara Venkata Mastan Manoj Kumar | 11a380d | 2013-01-17 09:30:56 -0800 | [diff] [blame] | 38 | // For support of virtual displays |
| 39 | #define HWC_DISPLAY_VIRTUAL (HWC_DISPLAY_EXTERNAL+1) |
| 40 | #define MAX_DISPLAYS (HWC_NUM_DISPLAY_TYPES+1) |
| 41 | |
Naseer Ahmed | 72cf976 | 2012-07-21 12:17:13 -0700 | [diff] [blame] | 42 | //Fwrd decls |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 43 | struct hwc_context_t; |
Naseer Ahmed | 72cf976 | 2012-07-21 12:17:13 -0700 | [diff] [blame] | 44 | |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 45 | namespace ovutils = overlay::utils; |
| 46 | |
Naseer Ahmed | 72cf976 | 2012-07-21 12:17:13 -0700 | [diff] [blame] | 47 | namespace overlay { |
| 48 | class Overlay; |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 49 | class Rotator; |
| 50 | class RotMgr; |
Naseer Ahmed | 72cf976 | 2012-07-21 12:17:13 -0700 | [diff] [blame] | 51 | } |
| 52 | |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 53 | namespace qhwc { |
Naseer Ahmed | 72cf976 | 2012-07-21 12:17:13 -0700 | [diff] [blame] | 54 | //fwrd decl |
| 55 | class QueuedBufferStore; |
Naseer Ahmed | 96c4c95 | 2012-07-25 18:27:14 -0700 | [diff] [blame] | 56 | class ExternalDisplay; |
Saurabh Shah | cf053c6 | 2012-12-13 12:32:55 -0800 | [diff] [blame] | 57 | class IFBUpdate; |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 58 | class IVideoOverlay; |
Saurabh Shah | cbf7ccc | 2012-12-19 16:45:51 -0800 | [diff] [blame] | 59 | class MDPComp; |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 60 | class CopyBit; |
Ramkumar Radhakrishnan | d224a1a | 2013-04-05 17:46:55 -0700 | [diff] [blame] | 61 | class HwcDebug; |
Naseer Ahmed | 96c4c95 | 2012-07-25 18:27:14 -0700 | [diff] [blame] | 62 | |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 63 | |
Naseer Ahmed | 96c4c95 | 2012-07-25 18:27:14 -0700 | [diff] [blame] | 64 | struct MDPInfo { |
| 65 | int version; |
| 66 | char panel; |
| 67 | bool hasOverlay; |
| 68 | }; |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 69 | |
Saurabh Shah | 3e858eb | 2012-09-17 16:53:21 -0700 | [diff] [blame] | 70 | struct DisplayAttributes { |
| 71 | uint32_t vsync_period; //nanos |
| 72 | uint32_t xres; |
| 73 | uint32_t yres; |
Naseer Ahmed | 54821fe | 2012-11-28 18:44:38 -0500 | [diff] [blame] | 74 | uint32_t stride; |
Naseer Ahmed | 7b80d9c | 2012-09-26 20:14:38 -0400 | [diff] [blame] | 75 | float xdpi; |
| 76 | float ydpi; |
Saurabh Shah | 3e858eb | 2012-09-17 16:53:21 -0700 | [diff] [blame] | 77 | int fd; |
Saurabh Shah | c4d034f | 2012-09-27 15:55:15 -0700 | [diff] [blame] | 78 | bool connected; //Applies only to pluggable disp. |
| 79 | //Connected does not mean it ready to use. |
| 80 | //It should be active also. (UNBLANKED) |
Saurabh Shah | 3e858eb | 2012-09-17 16:53:21 -0700 | [diff] [blame] | 81 | bool isActive; |
Amara Venkata Mastan Manoj Kumar | 11a380d | 2013-01-17 09:30:56 -0800 | [diff] [blame] | 82 | // In pause state, composition is bypassed |
| 83 | // used for WFD displays only |
| 84 | bool isPause; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 85 | }; |
Saurabh Shah | 3e858eb | 2012-09-17 16:53:21 -0700 | [diff] [blame] | 86 | |
| 87 | struct ListStats { |
| 88 | int numAppLayers; //Total - 1, excluding FB layer. |
| 89 | int skipCount; |
| 90 | int fbLayerIndex; //Always last for now. = numAppLayers |
| 91 | //Video specific |
| 92 | int yuvCount; |
Jeykumar Sankaran | cf53700 | 2013-01-21 21:19:15 -0800 | [diff] [blame] | 93 | int yuvIndices[MAX_NUM_LAYERS]; |
Arun Kumar K.R | a297845 | 2013-02-07 01:34:24 -0800 | [diff] [blame] | 94 | int extOnlyLayerIndex; |
Naseer Ahmed | 018e545 | 2012-12-03 14:46:15 -0500 | [diff] [blame] | 95 | bool needsAlphaScale; |
Sravan Kumar D.V.N | b5ed029 | 2013-03-15 08:51:16 +0530 | [diff] [blame] | 96 | bool preMultipliedAlpha; |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 97 | }; |
| 98 | |
Naseer Ahmed | 54821fe | 2012-11-28 18:44:38 -0500 | [diff] [blame] | 99 | struct LayerProp { |
| 100 | uint32_t mFlags; //qcom specific layer flags |
| 101 | LayerProp():mFlags(0) {}; |
| 102 | }; |
| 103 | |
| 104 | // LayerProp::flag values |
Naseer Ahmed | 7c958d4 | 2012-07-31 18:57:03 -0700 | [diff] [blame] | 105 | enum { |
Naseer Ahmed | 54821fe | 2012-11-28 18:44:38 -0500 | [diff] [blame] | 106 | HWC_MDPCOMP = 0x00000001, |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 107 | HWC_COPYBIT = 0x00000002, |
Naseer Ahmed | 7c958d4 | 2012-07-31 18:57:03 -0700 | [diff] [blame] | 108 | }; |
| 109 | |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 110 | // ----------------------------------------------------------------------------- |
| 111 | // Utility functions - implemented in hwc_utils.cpp |
Naseer Ahmed | 5b6708a | 2012-08-02 13:46:08 -0700 | [diff] [blame] | 112 | void dumpLayer(hwc_layer_1_t const* l); |
Saurabh Shah | 3e858eb | 2012-09-17 16:53:21 -0700 | [diff] [blame] | 113 | void setListStats(hwc_context_t *ctx, const hwc_display_contents_1_t *list, |
| 114 | int dpy); |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 115 | void initContext(hwc_context_t *ctx); |
| 116 | void closeContext(hwc_context_t *ctx); |
Naseer Ahmed | f48aef6 | 2012-07-20 09:05:53 -0700 | [diff] [blame] | 117 | //Crops source buffer against destination and FB boundaries |
| 118 | void calculate_crop_rects(hwc_rect_t& crop, hwc_rect_t& dst, |
Jeykumar Sankaran | b551ce4 | 2013-01-10 16:26:48 -0800 | [diff] [blame] | 119 | const hwc_rect_t& scissor, int orient); |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 120 | void getNonWormholeRegion(hwc_display_contents_1_t* list, |
| 121 | hwc_rect_t& nwr); |
Jeykumar Sankaran | 85977e3 | 2013-02-25 17:06:08 -0800 | [diff] [blame] | 122 | bool isSecuring(hwc_context_t* ctx, hwc_layer_1_t const* layer); |
Sushil Chauhan | 2515abf | 2013-01-08 16:40:05 -0800 | [diff] [blame] | 123 | bool isSecureModePolicy(int mdpVersion); |
Saurabh Shah | 3e858eb | 2012-09-17 16:53:21 -0700 | [diff] [blame] | 124 | bool isExternalActive(hwc_context_t* ctx); |
Jeykumar Sankaran | b551ce4 | 2013-01-10 16:26:48 -0800 | [diff] [blame] | 125 | bool needsScaling(hwc_layer_1_t const* layer); |
Sravan Kumar D.V.N | 075ef00 | 2013-03-20 05:22:26 +0530 | [diff] [blame] | 126 | bool isAlphaPresent(hwc_layer_1_t const* layer); |
Naseer Ahmed | 56601cd | 2013-03-05 11:34:14 -0500 | [diff] [blame] | 127 | int hwc_vsync_control(hwc_context_t* ctx, int dpy, int enable); |
Saurabh Shah | fc2acbe | 2012-08-17 19:47:52 -0700 | [diff] [blame] | 128 | |
Naseer Ahmed | 1d183f5 | 2012-11-26 12:35:16 -0500 | [diff] [blame] | 129 | //Helper function to dump logs |
| 130 | void dumpsys_log(android::String8& buf, const char* fmt, ...); |
| 131 | |
Arun Kumar K.R | feb2d8a | 2013-02-01 02:53:13 -0800 | [diff] [blame] | 132 | /* Calculates the destination position based on the action safe rectangle */ |
| 133 | void getActionSafePosition(hwc_context_t *ctx, int dpy, uint32_t& x, |
| 134 | uint32_t& y, uint32_t& w, uint32_t& h); |
| 135 | |
Arun Kumar K.R | ffef748 | 2013-04-10 14:17:22 -0700 | [diff] [blame^] | 136 | |
| 137 | void getAspectRatioPosition(hwc_context_t *ctx, int dpy, int orientation, |
| 138 | uint32_t& x, uint32_t& y, uint32_t& w, uint32_t& h); |
| 139 | |
Saurabh Shah | 747af1e | 2013-02-26 10:25:12 -0800 | [diff] [blame] | 140 | //Close acquireFenceFds of all layers of incoming list |
| 141 | void closeAcquireFds(hwc_display_contents_1_t* list); |
| 142 | |
Kinjal Bhavsar | 2dd04a8 | 2012-09-18 18:27:59 -0700 | [diff] [blame] | 143 | //Sync point impl. |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 144 | 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] | 145 | int fd); |
| 146 | |
| 147 | //Trims a layer's source crop which is outside of screen boundary. |
| 148 | void trimLayer(hwc_context_t *ctx, const int& dpy, const int& transform, |
| 149 | hwc_rect_t& crop, hwc_rect_t& dst); |
| 150 | |
| 151 | //Sets appropriate mdp flags for a layer. |
| 152 | void setMdpFlags(hwc_layer_1_t *layer, |
| 153 | ovutils::eMdpFlags &mdpFlags, |
| 154 | int rotDownscale = 0); |
| 155 | |
Arun Kumar K.R | ffef748 | 2013-04-10 14:17:22 -0700 | [diff] [blame^] | 156 | int configRotator(overlay::Rotator *rot, const ovutils::Whf& whf, |
| 157 | const hwc_rect_t& crop, const ovutils::eMdpFlags& mdpFlags, |
| 158 | const ovutils::eTransform& orient, const int& downscale); |
| 159 | |
| 160 | int configMdp(overlay::Overlay *ov, const ovutils::PipeArgs& parg, |
| 161 | const ovutils::eTransform& orient, const hwc_rect_t& crop, |
| 162 | const hwc_rect_t& pos, const MetaData_t *metadata, |
| 163 | const ovutils::eDest& dest); |
| 164 | |
| 165 | void updateSource(ovutils::eTransform& orient, ovutils::Whf& whf, |
| 166 | hwc_rect_t& crop); |
| 167 | |
| 168 | |
| 169 | |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 170 | //Routine to configure low resolution panels (<= 2048 width) |
| 171 | int configureLowRes(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy, |
| 172 | ovutils::eMdpFlags& mdpFlags, const ovutils::eZorder& z, |
| 173 | const ovutils::eIsFg& isFg, const ovutils::eDest& dest, |
| 174 | overlay::Rotator **rot); |
| 175 | |
| 176 | //Routine to configure high resolution panels (> 2048 width) |
| 177 | int configureHighRes(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy, |
| 178 | ovutils::eMdpFlags& mdpFlags, const ovutils::eZorder& z, |
| 179 | const ovutils::eIsFg& isFg, const ovutils::eDest& lDest, |
| 180 | const ovutils::eDest& rDest, overlay::Rotator **rot); |
Kinjal Bhavsar | 2dd04a8 | 2012-09-18 18:27:59 -0700 | [diff] [blame] | 181 | |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 182 | // Inline utility functions |
Naseer Ahmed | 5b6708a | 2012-08-02 13:46:08 -0700 | [diff] [blame] | 183 | static inline bool isSkipLayer(const hwc_layer_1_t* l) { |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 184 | return (UNLIKELY(l && (l->flags & HWC_SKIP_LAYER))); |
| 185 | } |
| 186 | |
| 187 | // Returns true if the buffer is yuv |
| 188 | static inline bool isYuvBuffer(const private_handle_t* hnd) { |
| 189 | return (hnd && (hnd->bufferType == BUFFER_TYPE_VIDEO)); |
| 190 | } |
| 191 | |
Saurabh Shah | f395d09 | 2012-08-27 12:33:42 -0700 | [diff] [blame] | 192 | // Returns true if the buffer is secure |
| 193 | static inline bool isSecureBuffer(const private_handle_t* hnd) { |
| 194 | return (hnd && (private_handle_t::PRIV_FLAGS_SECURE_BUFFER & hnd->flags)); |
| 195 | } |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 196 | //Return true if buffer is marked locked |
| 197 | static inline bool isBufferLocked(const private_handle_t* hnd) { |
| 198 | return (hnd && (private_handle_t::PRIV_FLAGS_HWC_LOCK & hnd->flags)); |
| 199 | } |
Naseer Ahmed | 31da0b1 | 2012-07-31 18:55:33 -0700 | [diff] [blame] | 200 | |
Naseer Ahmed | 4c588a2 | 2012-07-31 19:12:17 -0700 | [diff] [blame] | 201 | //Return true if buffer is for external display only |
| 202 | static inline bool isExtOnly(const private_handle_t* hnd) { |
| 203 | return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_ONLY)); |
| 204 | } |
| 205 | |
| 206 | //Return true if buffer is for external display only with a BLOCK flag. |
| 207 | static inline bool isExtBlock(const private_handle_t* hnd) { |
| 208 | return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_BLOCK)); |
| 209 | } |
| 210 | |
| 211 | //Return true if buffer is for external display only with a Close Caption flag. |
| 212 | static inline bool isExtCC(const private_handle_t* hnd) { |
| 213 | return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_CC)); |
| 214 | } |
| 215 | |
Naseer Ahmed | 64b8121 | 2013-02-14 10:29:47 -0500 | [diff] [blame] | 216 | template<typename T> inline T max(T a, T b) { return (a > b) ? a : b; } |
| 217 | template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; } |
| 218 | |
Naseer Ahmed | 72cf976 | 2012-07-21 12:17:13 -0700 | [diff] [blame] | 219 | // Initialize uevent thread |
| 220 | void init_uevent_thread(hwc_context_t* ctx); |
Naseer Ahmed | ff4f025 | 2012-10-01 13:03:01 -0400 | [diff] [blame] | 221 | // Initialize vsync thread |
| 222 | void init_vsync_thread(hwc_context_t* ctx); |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 223 | |
Naseer Ahmed | 5b6708a | 2012-08-02 13:46:08 -0700 | [diff] [blame] | 224 | inline void getLayerResolution(const hwc_layer_1_t* layer, |
Naseer Ahmed | ff4f025 | 2012-10-01 13:03:01 -0400 | [diff] [blame] | 225 | int& width, int& height) |
Naseer Ahmed | 7c958d4 | 2012-07-31 18:57:03 -0700 | [diff] [blame] | 226 | { |
| 227 | hwc_rect_t displayFrame = layer->displayFrame; |
| 228 | width = displayFrame.right - displayFrame.left; |
| 229 | height = displayFrame.bottom - displayFrame.top; |
| 230 | } |
Saurabh Shah | 3e858eb | 2012-09-17 16:53:21 -0700 | [diff] [blame] | 231 | |
| 232 | static inline int openFb(int dpy) { |
| 233 | int fd = -1; |
| 234 | const char *devtmpl = "/dev/graphics/fb%u"; |
| 235 | char name[64] = {0}; |
| 236 | snprintf(name, 64, devtmpl, dpy); |
| 237 | fd = open(name, O_RDWR); |
| 238 | return fd; |
| 239 | } |
| 240 | |
Saurabh Shah | 27c1d65 | 2012-08-14 19:30:28 -0700 | [diff] [blame] | 241 | template <class T> |
| 242 | inline void swap(T& a, T& b) { |
| 243 | T tmp = a; |
| 244 | a = b; |
| 245 | b = tmp; |
| 246 | } |
| 247 | |
Naseer Ahmed | f48aef6 | 2012-07-20 09:05:53 -0700 | [diff] [blame] | 248 | }; //qhwc namespace |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 249 | |
Naseer Ahmed | ff4f025 | 2012-10-01 13:03:01 -0400 | [diff] [blame] | 250 | struct vsync_state { |
| 251 | pthread_mutex_t lock; |
| 252 | pthread_cond_t cond; |
| 253 | bool enable; |
Naseer Ahmed | 56601cd | 2013-03-05 11:34:14 -0500 | [diff] [blame] | 254 | bool fakevsync; |
Naseer Ahmed | ff4f025 | 2012-10-01 13:03:01 -0400 | [diff] [blame] | 255 | }; |
| 256 | |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 257 | // ----------------------------------------------------------------------------- |
| 258 | // HWC context |
| 259 | // This structure contains overall state |
| 260 | struct hwc_context_t { |
Naseer Ahmed | 5b6708a | 2012-08-02 13:46:08 -0700 | [diff] [blame] | 261 | hwc_composer_device_1_t device; |
Jesse Hall | 3be78d9 | 2012-08-21 15:12:23 -0700 | [diff] [blame] | 262 | const hwc_procs_t* proc; |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 263 | |
| 264 | //CopyBit objects |
Amara Venkata Mastan Manoj Kumar | 11a380d | 2013-01-17 09:30:56 -0800 | [diff] [blame] | 265 | qhwc::CopyBit *mCopyBit[MAX_DISPLAYS]; |
Arun Kumar K.R | 361da4f | 2012-11-28 10:42:59 -0800 | [diff] [blame] | 266 | |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 267 | //Overlay object - NULL for non overlay devices |
Naseer Ahmed | 758bfc5 | 2012-11-28 17:02:08 -0500 | [diff] [blame] | 268 | overlay::Overlay *mOverlay; |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 269 | //Holds a few rot objects |
| 270 | overlay::RotMgr *mRotMgr; |
Saurabh Shah | cf053c6 | 2012-12-13 12:32:55 -0800 | [diff] [blame] | 271 | |
| 272 | //Primary and external FB updater |
Amara Venkata Mastan Manoj Kumar | 11a380d | 2013-01-17 09:30:56 -0800 | [diff] [blame] | 273 | qhwc::IFBUpdate *mFBUpdate[MAX_DISPLAYS]; |
Naseer Ahmed | 0c8b7b5 | 2012-07-20 09:06:13 -0700 | [diff] [blame] | 274 | // External display related information |
Naseer Ahmed | 72cf976 | 2012-07-21 12:17:13 -0700 | [diff] [blame] | 275 | qhwc::ExternalDisplay *mExtDisplay; |
Naseer Ahmed | 96c4c95 | 2012-07-25 18:27:14 -0700 | [diff] [blame] | 276 | qhwc::MDPInfo mMDP; |
Amara Venkata Mastan Manoj Kumar | 11a380d | 2013-01-17 09:30:56 -0800 | [diff] [blame] | 277 | qhwc::DisplayAttributes dpyAttr[MAX_DISPLAYS]; |
| 278 | qhwc::ListStats listStats[MAX_DISPLAYS]; |
Amara Venkata Mastan Manoj Kumar | 11a380d | 2013-01-17 09:30:56 -0800 | [diff] [blame] | 279 | qhwc::LayerProp *layerProp[MAX_DISPLAYS]; |
Jeykumar Sankaran | 85977e3 | 2013-02-25 17:06:08 -0800 | [diff] [blame] | 280 | qhwc::MDPComp *mMDPComp[MAX_DISPLAYS]; |
Ramkumar Radhakrishnan | d224a1a | 2013-04-05 17:46:55 -0700 | [diff] [blame] | 281 | qhwc::HwcDebug *mHwcDebug[MAX_DISPLAYS]; |
Naseer Ahmed | b1c7632 | 2012-10-17 00:32:50 -0400 | [diff] [blame] | 282 | |
Saurabh Shah | 56f610d | 2012-08-07 15:27:06 -0700 | [diff] [blame] | 283 | //Securing in progress indicator |
| 284 | bool mSecuring; |
Amara Venkata Mastan Manoj Kumar | 75526f5 | 2012-12-27 18:27:01 -0800 | [diff] [blame] | 285 | //External Display configuring progress indicator |
| 286 | bool mExtDispConfiguring; |
Saurabh Shah | 56f610d | 2012-08-07 15:27:06 -0700 | [diff] [blame] | 287 | //Display in secure mode indicator |
| 288 | bool mSecureMode; |
Naseer Ahmed | 32ff225 | 2012-09-29 01:41:21 -0400 | [diff] [blame] | 289 | //Lock to prevent set from being called while blanking |
| 290 | mutable Locker mBlankLock; |
Raj kamal | e3e68ae | 2013-05-02 17:28:23 +0530 | [diff] [blame] | 291 | //Lock to protect prepare & set when detaching external disp |
| 292 | mutable Locker mExtLock; |
Naseer Ahmed | ff4f025 | 2012-10-01 13:03:01 -0400 | [diff] [blame] | 293 | //Vsync |
| 294 | struct vsync_state vstate; |
Saurabh Shah | 0ceeb6a | 2013-04-23 10:46:07 -0700 | [diff] [blame] | 295 | //Drawing round when we use GPU |
| 296 | bool isPaddingRound; |
Arun Kumar K.R | ffef748 | 2013-04-10 14:17:22 -0700 | [diff] [blame^] | 297 | // External Orientation |
| 298 | int mExtOrientation; |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 299 | }; |
| 300 | |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 301 | namespace qhwc { |
Saurabh Shah | cbf7ccc | 2012-12-19 16:45:51 -0800 | [diff] [blame] | 302 | static inline bool isSkipPresent (hwc_context_t *ctx, int dpy) { |
| 303 | return ctx->listStats[dpy].skipCount; |
| 304 | } |
| 305 | |
| 306 | static inline bool isYuvPresent (hwc_context_t *ctx, int dpy) { |
| 307 | return ctx->listStats[dpy].yuvCount; |
| 308 | } |
Saurabh Shah | acf1020 | 2013-02-26 10:15:15 -0800 | [diff] [blame] | 309 | }; |
Saurabh Shah | cbf7ccc | 2012-12-19 16:45:51 -0800 | [diff] [blame] | 310 | |
Naseer Ahmed | 29a2681 | 2012-06-14 00:56:20 -0700 | [diff] [blame] | 311 | #endif //HWC_UTILS_H |