blob: 96d1e5867058aaa8b1db829777ba5bd5422d8628 [file] [log] [blame]
Naseer Ahmed29a26812012-06-14 00:56:20 -07001/*
2 * Copyright (C) 2010 The Android Open Source Project
Arun Kumar K.Rc62935a2013-12-03 16:47:47 -08003 * Copyright (C)2012-2014, The Linux Foundation. All rights reserved.
Arun Kumar K.R361da4f2012-11-28 10:42:59 -08004 *
5 * Not a Contribution, Apache license notifications and license are retained
6 * for attribution purposes only.
Naseer Ahmed29a26812012-06-14 00:56:20 -07007 *
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 Ahmed72cf9762012-07-21 12:17:13 -070023
Ramkumar Radhakrishnana5c72872014-08-28 19:04:18 -070024#define DEBUG_MDPDOWNSCALE 0
Naseer Ahmed5b6708a2012-08-02 13:46:08 -070025#define HWC_REMOVE_DEPRECATED_VERSIONS 1
Ramkumar Radhakrishnana5c72872014-08-28 19:04:18 -070026
Saurabh Shah3e858eb2012-09-17 16:53:21 -070027#include <fcntl.h>
Saurabh Shah62e1d732013-09-17 10:44:05 -070028#include <math.h>
Naseer Ahmed29a26812012-06-14 00:56:20 -070029#include <hardware/hwcomposer.h>
Naseer Ahmed32ff2252012-09-29 01:41:21 -040030#include <gr.h>
Naseer Ahmed72cf9762012-07-21 12:17:13 -070031#include <gralloc_priv.h>
Naseer Ahmed1d183f52012-11-26 12:35:16 -050032#include <utils/String8.h>
Saurabh Shahacf10202013-02-26 10:15:15 -080033#include "qdMetaData.h"
Raj Kamal389d6e32014-08-04 14:43:24 +053034#include "mdp_version.h"
Saurabh Shahacf10202013-02-26 10:15:15 -080035#include <overlayUtils.h>
Raj Kamal389d6e32014-08-04 14:43:24 +053036#include <overlayRotator.h>
Ramkumar Radhakrishnanfb822912014-03-14 17:28:14 -070037#include <EGL/egl.h>
38
Naseer Ahmed29a26812012-06-14 00:56:20 -070039
Naseer Ahmed31da0b12012-07-31 18:55:33 -070040#define ALIGN_TO(x, align) (((x) + ((align)-1)) & ~((align)-1))
Naseer Ahmed29a26812012-06-14 00:56:20 -070041#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true ))
42#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))
Ramkumar Radhakrishnane661f962013-06-05 17:21:38 -070043#define MAX_NUM_APP_LAYERS 32
Jeykumar Sankaranbe93e272014-06-19 18:15:57 -070044#define MAX_NUM_BLEND_STAGES 16
Dileep Kumar Reddibf2678b2014-01-29 15:33:32 +053045#define MIN_DISPLAY_XRES 200
46#define MIN_DISPLAY_YRES 200
Raj kamal59fea562014-04-01 16:52:19 +053047#define HWC_WFDDISPSYNC_LOG 0
48#define STR(f) #f;
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -070049// Max number of PTOR layers handled
50#define MAX_PTOR_LAYERS 2
Naseer Ahmed29a26812012-06-14 00:56:20 -070051
Naseer Ahmed72cf9762012-07-21 12:17:13 -070052//Fwrd decls
Naseer Ahmed29a26812012-06-14 00:56:20 -070053struct hwc_context_t;
Naseer Ahmed72cf9762012-07-21 12:17:13 -070054
Saurabh Shahacf10202013-02-26 10:15:15 -080055namespace ovutils = overlay::utils;
56
Naseer Ahmed72cf9762012-07-21 12:17:13 -070057namespace overlay {
58class Overlay;
Saurabh Shahacf10202013-02-26 10:15:15 -080059class Rotator;
60class RotMgr;
Naseer Ahmed72cf9762012-07-21 12:17:13 -070061}
62
Naseer Ahmed29a26812012-06-14 00:56:20 -070063namespace qhwc {
Naseer Ahmed72cf9762012-07-21 12:17:13 -070064//fwrd decl
65class QueuedBufferStore;
Tatenda Chipeperekwaaf2c0042014-09-17 12:55:01 -070066class HDMIDisplay;
Jeykumar Sankaran27dee262013-08-01 17:09:54 -070067class VirtualDisplay;
Saurabh Shahcf053c62012-12-13 12:32:55 -080068class IFBUpdate;
Saurabh Shahacf10202013-02-26 10:15:15 -080069class IVideoOverlay;
Saurabh Shahcbf7ccc2012-12-19 16:45:51 -080070class MDPComp;
Arun Kumar K.R361da4f2012-11-28 10:42:59 -080071class CopyBit;
Ramkumar Radhakrishnand224a1a2013-04-05 17:46:55 -070072class HwcDebug;
Saurabh Shaha9da08f2013-07-03 13:27:53 -070073class AssertiveDisplay;
Manoj Kumar AVM9591a5e2014-08-21 22:50:21 -070074class HWCVirtualVDS;
Naseer Ahmed96c4c952012-07-25 18:27:14 -070075
Naseer Ahmed64b81212013-02-14 10:29:47 -050076
Naseer Ahmed96c4c952012-07-25 18:27:14 -070077struct MDPInfo {
78 int version;
79 char panel;
80 bool hasOverlay;
81};
Naseer Ahmed29a26812012-06-14 00:56:20 -070082
Saurabh Shah3e858eb2012-09-17 16:53:21 -070083struct DisplayAttributes {
Arun Kumar K.Ra727a882014-08-20 17:14:26 -070084 uint32_t refreshRate;
85 uint32_t dynRefreshRate;
Saurabh Shah3e858eb2012-09-17 16:53:21 -070086 uint32_t vsync_period; //nanos
87 uint32_t xres;
88 uint32_t yres;
Naseer Ahmed54821fe2012-11-28 18:44:38 -050089 uint32_t stride;
Naseer Ahmed7b80d9c2012-09-26 20:14:38 -040090 float xdpi;
91 float ydpi;
Saurabh Shah3e858eb2012-09-17 16:53:21 -070092 int fd;
Saurabh Shahc4d034f2012-09-27 15:55:15 -070093 bool connected; //Applies only to pluggable disp.
94 //Connected does not mean it ready to use.
95 //It should be active also. (UNBLANKED)
Saurabh Shah3e858eb2012-09-17 16:53:21 -070096 bool isActive;
Amara Venkata Mastan Manoj Kumar11a380d2013-01-17 09:30:56 -080097 // In pause state, composition is bypassed
98 // used for WFD displays only
99 bool isPause;
Jeykumar Sankaran27dee262013-08-01 17:09:54 -0700100 // To trigger padding round to clean up mdp
101 // pipes
102 bool isConfiguring;
Tatenda Chipeperekwacb2a2432014-08-06 17:45:58 -0700103 // Indicates whether external/virtual display is in MDP scaling mode
104 bool mMDPScalingMode;
Arun Kumar K.R8e7a62f2013-12-06 18:55:41 -0800105 // Ext dst Rect
106 hwc_rect_t mDstRect;
Ramkumar Radhakrishnan4af1ef02013-12-12 11:53:08 -0800107 //Action safe attributes
108 // Flag to indicate the presence of action safe dimensions for external
109 bool mActionSafePresent;
110 int mAsWidthRatio;
111 int mAsHeightRatio;
Dileep Kumar Reddibf2678b2014-01-29 15:33:32 +0530112
113 //If property fbsize set via adb shell debug.hwc.fbsize = XRESxYRES
114 //following fields are used.
115 bool customFBSize;
Dileep Kumar Reddie351d842014-03-25 10:39:21 +0530116 uint32_t xres_new;
117 uint32_t yres_new;
Dileep Kumar Reddibf2678b2014-01-29 15:33:32 +0530118
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700119};
Saurabh Shah3e858eb2012-09-17 16:53:21 -0700120
121struct ListStats {
122 int numAppLayers; //Total - 1, excluding FB layer.
123 int skipCount;
124 int fbLayerIndex; //Always last for now. = numAppLayers
125 //Video specific
126 int yuvCount;
Ramkumar Radhakrishnane661f962013-06-05 17:21:38 -0700127 int yuvIndices[MAX_NUM_APP_LAYERS];
Sravan Kumar D.V.Nb5ed0292013-03-15 08:51:16 +0530128 bool preMultipliedAlpha;
radhakrishnac9a67412013-09-25 17:40:42 +0530129 int yuv4k2kIndices[MAX_NUM_APP_LAYERS];
130 int yuv4k2kCount;
Ramkumar Radhakrishnan59a11072013-04-15 16:14:49 -0700131 // Notifies hwcomposer about the start and end of animation
132 // This will be set to true during animation, otherwise false.
133 bool isDisplayAnimating;
Ramkumar Radhakrishnanba713382013-08-30 18:41:07 -0700134 bool secureUI; // Secure display layer
Saurabh Shah8028e3b2013-10-15 12:27:59 -0700135 bool isSecurePresent;
Jeykumar Sankaran6c7eeac2013-11-18 11:19:45 -0800136 hwc_rect_t lRoi; //left ROI
137 hwc_rect_t rRoi; //right ROI. Unused in single DSI panels.
Ramakant Singh0def28c2014-03-28 20:43:13 +0530138 //App Buffer Composition index
139 int renderBufIndexforABC;
Ramkumar Radhakrishnan4ec775f2014-07-23 17:43:18 -0700140 // Secure RGB specific
141 int secureRGBCount;
142 int secureRGBIndices[MAX_NUM_APP_LAYERS];
Arun Kumar K.Ra727a882014-08-20 17:14:26 -0700143 //dyn refresh rate-Client requested refreshrate
144 uint32_t refreshRateRequest;
Ramkumar Radhakrishnanb33f4902014-10-03 16:46:35 -0700145 // Flag related to windowboxing feature
146 bool mAIVVideoMode;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700147};
148
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700149//PTOR Comp info
150struct PtorInfo {
151 int count;
152 int layerIndex[MAX_PTOR_LAYERS];
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700153 hwc_rect_t displayFrame[MAX_PTOR_LAYERS];
154 bool isActive() { return (count>0); }
155 int getPTORArrayIndex(int index) {
156 int idx = -1;
157 for(int i = 0; i < count; i++) {
158 if(index == layerIndex[i])
159 idx = i;
160 }
161 return idx;
162 }
163};
164
Naseer Ahmed54821fe2012-11-28 18:44:38 -0500165struct LayerProp {
166 uint32_t mFlags; //qcom specific layer flags
Jeykumar Sankaran6a9bb9e2013-08-01 14:19:26 -0700167 LayerProp():mFlags(0){};
Naseer Ahmed54821fe2012-11-28 18:44:38 -0500168};
169
Naseer Ahmed8bb8f9d2013-05-11 07:29:45 -0400170struct VsyncState {
171 bool enable;
172 bool fakevsync;
Naseer Ahmed35a268c2014-06-24 19:07:13 -0400173 bool debug;
Naseer Ahmed8bb8f9d2013-05-11 07:29:45 -0400174};
175
Saurabh Shah1a03d482013-05-29 13:44:20 -0700176struct BwcPM {
Saurabh Shahc46cf9d2014-07-02 15:22:34 -0700177 static void setBwc(const hwc_rect_t& crop, const hwc_rect_t& dst,
178 const int& transform, const int& downscale,
Saurabh Shah1a03d482013-05-29 13:44:20 -0700179 ovutils::eMdpFlags& mdpFlags);
180};
181
Naseer Ahmed54821fe2012-11-28 18:44:38 -0500182// LayerProp::flag values
Naseer Ahmed7c958d42012-07-31 18:57:03 -0700183enum {
Naseer Ahmed54821fe2012-11-28 18:44:38 -0500184 HWC_MDPCOMP = 0x00000001,
Naseer Ahmed64b81212013-02-14 10:29:47 -0500185 HWC_COPYBIT = 0x00000002,
Naseer Ahmed7c958d42012-07-31 18:57:03 -0700186};
187
Ramkumar Radhakrishnan9d7bc312014-08-13 19:38:13 -0700188// AIV specific flags
189enum {
190 HWC_AIV_VIDEO = 0x80000000,
191 HWC_AIV_CC = 0x40000000,
192};
193
Sushil Chauhan1f6d68f2013-10-11 11:49:35 -0700194// HAL specific features
195enum {
Sushil Chauhan943797c2013-10-21 17:35:55 -0700196 HWC_COLOR_FILL = 0x00000008,
Sushil Chauhan1f6d68f2013-10-11 11:49:35 -0700197 HWC_FORMAT_RB_SWAP = 0x00000040,
198};
199
Raj kamal59fea562014-04-01 16:52:19 +0530200/* External Display states */
201enum {
202 EXTERNAL_OFFLINE = 0,
203 EXTERNAL_ONLINE,
204 EXTERNAL_PAUSE,
205 EXTERNAL_RESUME,
206 EXTERNAL_MAXSTATES
207};
208
Saurabh Shah23a813c2013-03-20 16:58:12 -0700209class LayerRotMap {
210public:
211 LayerRotMap() { reset(); }
Saurabh Shah23a813c2013-03-20 16:58:12 -0700212 void add(hwc_layer_1_t* layer, overlay::Rotator *rot);
Saurabh Shahda5b3ce2013-11-26 10:48:06 -0800213 //Resets the mapping of layer to rotator
Saurabh Shah23a813c2013-03-20 16:58:12 -0700214 void reset();
Saurabh Shahda5b3ce2013-11-26 10:48:06 -0800215 //Clears mappings and existing rotator fences
216 //Intended to be used during errors
217 void clear();
Saurabh Shah23a813c2013-03-20 16:58:12 -0700218 uint32_t getCount() const;
219 hwc_layer_1_t* getLayer(uint32_t index) const;
220 overlay::Rotator* getRot(uint32_t index) const;
Raj Kamalbd3bdc62014-08-05 18:52:49 +0530221 bool isRotCached(uint32_t index) const;
Saurabh Shah23a813c2013-03-20 16:58:12 -0700222 void setReleaseFd(const int& fence);
223private:
Raj Kamal389d6e32014-08-04 14:43:24 +0530224 hwc_layer_1_t* mLayer[overlay::RotMgr::MAX_ROT_SESS];
225 overlay::Rotator* mRot[overlay::RotMgr::MAX_ROT_SESS];
Saurabh Shah23a813c2013-03-20 16:58:12 -0700226 uint32_t mCount;
227};
228
229inline uint32_t LayerRotMap::getCount() const {
230 return mCount;
231}
232
233inline hwc_layer_1_t* LayerRotMap::getLayer(uint32_t index) const {
234 if(index >= mCount) return NULL;
235 return mLayer[index];
236}
237
238inline overlay::Rotator* LayerRotMap::getRot(uint32_t index) const {
239 if(index >= mCount) return NULL;
240 return mRot[index];
241}
242
Saurabh Shah62e1d732013-09-17 10:44:05 -0700243inline hwc_rect_t integerizeSourceCrop(const hwc_frect_t& cropF) {
Praveena Pachipulusud9443c72014-02-17 10:42:28 +0530244 hwc_rect_t cropI = {0,0,0,0};
Saurabh Shah62e1d732013-09-17 10:44:05 -0700245 cropI.left = int(ceilf(cropF.left));
246 cropI.top = int(ceilf(cropF.top));
247 cropI.right = int(floorf(cropF.right));
248 cropI.bottom = int(floorf(cropF.bottom));
249 return cropI;
250}
251
Naseer Ahmede850a802013-09-06 13:12:52 -0400252inline bool isNonIntegralSourceCrop(const hwc_frect_t& cropF) {
253 if(cropF.left - roundf(cropF.left) ||
254 cropF.top - roundf(cropF.top) ||
255 cropF.right - roundf(cropF.right) ||
256 cropF.bottom - roundf(cropF.bottom))
257 return true;
258 else
259 return false;
260}
261
Naseer Ahmed29a26812012-06-14 00:56:20 -0700262// -----------------------------------------------------------------------------
263// Utility functions - implemented in hwc_utils.cpp
Naseer Ahmed5b6708a2012-08-02 13:46:08 -0700264void dumpLayer(hwc_layer_1_t const* l);
Saurabh Shahd9ff30b2013-10-03 16:37:06 -0700265void setListStats(hwc_context_t *ctx, hwc_display_contents_1_t *list,
Saurabh Shah3e858eb2012-09-17 16:53:21 -0700266 int dpy);
Naseer Ahmed29a26812012-06-14 00:56:20 -0700267void initContext(hwc_context_t *ctx);
268void closeContext(hwc_context_t *ctx);
Naseer Ahmedf48aef62012-07-20 09:05:53 -0700269//Crops source buffer against destination and FB boundaries
270void calculate_crop_rects(hwc_rect_t& crop, hwc_rect_t& dst,
Jeykumar Sankaranb551ce42013-01-10 16:26:48 -0800271 const hwc_rect_t& scissor, int orient);
Naseer Ahmed64b81212013-02-14 10:29:47 -0500272void getNonWormholeRegion(hwc_display_contents_1_t* list,
273 hwc_rect_t& nwr);
Jeykumar Sankaran85977e32013-02-25 17:06:08 -0800274bool isSecuring(hwc_context_t* ctx, hwc_layer_1_t const* layer);
Sushil Chauhan2515abf2013-01-08 16:40:05 -0800275bool isSecureModePolicy(int mdpVersion);
Ramkumar Radhakrishnan9d20b392013-11-15 19:32:47 -0800276// Returns true, if the input layer format is supported by rotator
277bool isRotatorSupportedFormat(private_handle_t *hnd);
278//Returns true, if the layer is YUV or the layer has been rendered by CPU
279bool isRotationDoable(hwc_context_t *ctx, private_handle_t *hnd);
Saurabh Shah3e858eb2012-09-17 16:53:21 -0700280bool isExternalActive(hwc_context_t* ctx);
Prabhanjan Kandula21918db2013-11-26 15:51:58 +0530281bool isAlphaScaled(hwc_layer_1_t const* layer);
282bool needsScaling(hwc_layer_1_t const* layer);
283bool isDownscaleRequired(hwc_layer_1_t const* layer);
Sushil Chauhan15a2ea62013-09-04 18:28:36 -0700284bool needsScalingWithSplit(hwc_context_t* ctx, hwc_layer_1_t const* layer,
285 const int& dpy);
286void sanitizeSourceCrop(hwc_rect_t& cropL, hwc_rect_t& cropR,
287 private_handle_t *hnd);
Sravan Kumar D.V.N075ef002013-03-20 05:22:26 +0530288bool isAlphaPresent(hwc_layer_1_t const* layer);
Naseer Ahmed56601cd2013-03-05 11:34:14 -0500289int hwc_vsync_control(hwc_context_t* ctx, int dpy, int enable);
Naseer Ahmed522ce662013-03-18 20:14:05 -0400290int getBlending(int blending);
Ramkumar Radhakrishnan8bb48d32013-12-30 23:11:27 -0800291bool isGLESOnlyComp(hwc_context_t *ctx, const int& dpy);
292void reset_layer_prop(hwc_context_t* ctx, int dpy, int numAppLayers);
Ramakant Singh0def28c2014-03-28 20:43:13 +0530293bool isAbcInUse(hwc_context_t *ctx);
Saurabh Shahfc2acbe2012-08-17 19:47:52 -0700294
Tatenda Chipeperekwa523eac52014-05-29 14:58:39 -0700295void dumpBuffer(private_handle_t *ohnd, char *bufferName);
Tatenda Chipeperekwa03d5df22014-09-16 18:09:18 -0700296void updateDisplayInfo(hwc_context_t* ctx, int dpy);
297void resetDisplayInfo(hwc_context_t* ctx, int dpy);
298void initCompositionResources(hwc_context_t* ctx, int dpy);
299void destroyCompositionResources(hwc_context_t* ctx, int dpy);
Tatenda Chipeperekwad80b6172014-09-23 11:29:37 -0700300void clearPipeResources(hwc_context_t* ctx, int dpy);
Raj Kamal52b4fdb2014-01-27 19:35:13 +0530301
Naseer Ahmed1d183f52012-11-26 12:35:16 -0500302//Helper function to dump logs
303void dumpsys_log(android::String8& buf, const char* fmt, ...);
304
Ramkumar Radhakrishnan66f856c2013-08-21 16:09:47 -0700305int getExtOrientation(hwc_context_t* ctx);
Jeykumar Sankaran6a585792013-10-03 11:30:55 -0700306bool isValidRect(const hwc_rect_t& rect);
Jeykumar Sankaran93943532013-11-08 18:05:11 -0800307hwc_rect_t deductRect(const hwc_rect_t& rect1, const hwc_rect_t& rect2);
Jeykumar Sankaran6c7eeac2013-11-18 11:19:45 -0800308bool isSameRect(const hwc_rect& rect1, const hwc_rect& rect2);
Jeykumar Sankaran71e597c2014-05-07 16:23:14 -0700309hwc_rect_t moveRect(const hwc_rect_t& rect, const int& x_off, const int& y_off);
Jeykumar Sankaran6a585792013-10-03 11:30:55 -0700310hwc_rect_t getIntersection(const hwc_rect_t& rect1, const hwc_rect_t& rect2);
311hwc_rect_t getUnion(const hwc_rect_t& rect1, const hwc_rect_t& rect2);
Arun Kumar K.R2aa44c62014-01-21 23:08:28 -0800312void optimizeLayerRects(const hwc_display_contents_1_t *list);
Prabhanjan Kandula9bd5f642013-09-25 17:00:36 +0530313bool areLayersIntersecting(const hwc_layer_1_t* layer1,
314 const hwc_layer_1_t* layer2);
Ramakant Singh21cec722014-03-07 19:11:45 +0530315bool operator ==(const hwc_rect_t& lhs, const hwc_rect_t& rhs);
Prabhanjan Kandulaa5dc8e92013-09-25 15:20:33 +0530316
Ramkumar Radhakrishnan4af1ef02013-12-12 11:53:08 -0800317// returns true if Action safe dimensions are set and target supports Actionsafe
318bool isActionSafePresent(hwc_context_t *ctx, int dpy);
319
Arun Kumar K.Rfeb2d8a2013-02-01 02:53:13 -0800320/* Calculates the destination position based on the action safe rectangle */
Arun Kumar K.R5898c652013-07-17 14:20:32 -0700321void getActionSafePosition(hwc_context_t *ctx, int dpy, hwc_rect_t& dst);
Arun Kumar K.Rfeb2d8a2013-02-01 02:53:13 -0800322
Arun Kumar K.R5898c652013-07-17 14:20:32 -0700323void getAspectRatioPosition(hwc_context_t* ctx, int dpy, int extOrientation,
324 hwc_rect_t& inRect, hwc_rect_t& outRect);
325
Arun Kumar K.Ra727a882014-08-20 17:14:26 -0700326void setRefreshRate(hwc_context_t *ctx, int dpy, uint32_t refreshRate);
327
Arun Kumar K.R5898c652013-07-17 14:20:32 -0700328bool isPrimaryPortrait(hwc_context_t *ctx);
329
Amara Venkata Mastan Manoj Kumar376d8a82013-03-13 19:18:47 -0700330bool isOrientationPortrait(hwc_context_t *ctx);
331
Arun Kumar K.R5898c652013-07-17 14:20:32 -0700332void calcExtDisplayPosition(hwc_context_t *ctx,
Ramkumar Radhakrishnan66f856c2013-08-21 16:09:47 -0700333 private_handle_t *hnd,
Amara Venkata Mastan Manoj Kumar376d8a82013-03-13 19:18:47 -0700334 int dpy,
335 hwc_rect_t& sourceCrop,
Ramkumar Radhakrishnan66f856c2013-08-21 16:09:47 -0700336 hwc_rect_t& displayFrame,
337 int& transform,
338 ovutils::eTransform& orient);
339
Arun Kumar K.Rfb5bfa62013-07-25 03:10:51 -0700340// Returns the orientation that needs to be set on external for
341// BufferMirrirMode(Sidesync)
342int getMirrorModeOrientation(hwc_context_t *ctx);
Arun Kumar K.Rffef7482013-04-10 14:17:22 -0700343
Raj kamal59fea562014-04-01 16:52:19 +0530344/* Get External State names */
345const char* getExternalDisplayState(uint32_t external_state);
346
Jeykumar Sankaran6c7eeac2013-11-18 11:19:45 -0800347// Resets display ROI to full panel resoluion
348void resetROI(hwc_context_t *ctx, const int dpy);
349
Jeykumar Sankaran7c852382014-02-26 18:26:58 -0800350// Aligns updating ROI to panel restrictions
Jeykumar Sankaran6c7eeac2013-11-18 11:19:45 -0800351hwc_rect_t getSanitizeROI(struct hwc_rect roi, hwc_rect boundary);
Jeykumar Sankaran7c852382014-02-26 18:26:58 -0800352
Arun Kumar K.Rc62935a2013-12-03 16:47:47 -0800353// Handles wfd Pause and resume events
354void handle_pause(hwc_context_t *ctx, int dpy);
355void handle_resume(hwc_context_t *ctx, int dpy);
356
Tatenda Chipeperekwad80b6172014-09-23 11:29:37 -0700357// Handle ONLINE/OFFLINE for HDMI display
358void handle_online(hwc_context_t* ctx, int dpy);
359void handle_offline(hwc_context_t* ctx, int dpy);
360
Saurabh Shah747af1e2013-02-26 10:25:12 -0800361//Close acquireFenceFds of all layers of incoming list
362void closeAcquireFds(hwc_display_contents_1_t* list);
363
Kinjal Bhavsar2dd04a82012-09-18 18:27:59 -0700364//Sync point impl.
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800365int hwc_sync(hwc_context_t *ctx, hwc_display_contents_1_t* list, int dpy,
Saurabh Shahacf10202013-02-26 10:15:15 -0800366 int fd);
367
Saurabh Shahacf10202013-02-26 10:15:15 -0800368//Sets appropriate mdp flags for a layer.
Ramkumar Radhakrishnan9d20b392013-11-15 19:32:47 -0800369void setMdpFlags(hwc_context_t *ctx, hwc_layer_1_t *layer,
Saurabh Shahacf10202013-02-26 10:15:15 -0800370 ovutils::eMdpFlags &mdpFlags,
Ramkumar Radhakrishnan9d52f432013-05-14 14:46:59 -0700371 int rotDownscale, int transform);
Saurabh Shahacf10202013-02-26 10:15:15 -0800372
Prabhanjan Kandulaa1d83012013-04-23 13:06:02 +0530373int configRotator(overlay::Rotator *rot, ovutils::Whf& whf,
Sushil Chauhan1cac8152013-05-08 15:53:51 -0700374 hwc_rect_t& crop, const ovutils::eMdpFlags& mdpFlags,
Arun Kumar K.Rffef7482013-04-10 14:17:22 -0700375 const ovutils::eTransform& orient, const int& downscale);
376
377int configMdp(overlay::Overlay *ov, const ovutils::PipeArgs& parg,
378 const ovutils::eTransform& orient, const hwc_rect_t& crop,
379 const hwc_rect_t& pos, const MetaData_t *metadata,
380 const ovutils::eDest& dest);
381
Sushil Chauhan897a9c32013-07-18 11:09:55 -0700382int configColorLayer(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy,
383 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
Saurabh Shah2c8ad052014-08-15 13:27:46 -0700384 const ovutils::eDest& dest);
Sushil Chauhan897a9c32013-07-18 11:09:55 -0700385
Arun Kumar K.Rffef7482013-04-10 14:17:22 -0700386void updateSource(ovutils::eTransform& orient, ovutils::Whf& whf,
Saurabh Shah8ec9b5e2014-06-30 14:37:17 -0700387 hwc_rect_t& crop, overlay::Rotator *rot);
Arun Kumar K.Rffef7482013-04-10 14:17:22 -0700388
Ramkumar Radhakrishnan9d7bc312014-08-13 19:38:13 -0700389bool isZoomModeEnabled(hwc_rect_t crop);
390void updateCropAIVVideoMode(hwc_context_t *ctx, hwc_rect_t& crop, int dpy);
391void updateDestAIVVideoMode(hwc_context_t *ctx, hwc_rect_t& dst, int dpy);
Ramkumar Radhakrishnanb33f4902014-10-03 16:46:35 -0700392void updateCoordinates(hwc_context_t *ctx, hwc_rect_t& crop,
Ramkumar Radhakrishnan9d7bc312014-08-13 19:38:13 -0700393 hwc_rect_t& dst, int dpy);
394
Saurabh Shahacf10202013-02-26 10:15:15 -0800395//Routine to configure low resolution panels (<= 2048 width)
Saurabh Shah88e4d272013-09-03 13:31:29 -0700396int configureNonSplit(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy,
Ramkumar Radhakrishnan59a11072013-04-15 16:14:49 -0700397 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
Saurabh Shah2c8ad052014-08-15 13:27:46 -0700398 const ovutils::eDest& dest,
Saurabh Shahacf10202013-02-26 10:15:15 -0800399 overlay::Rotator **rot);
400
401//Routine to configure high resolution panels (> 2048 width)
Saurabh Shah88e4d272013-09-03 13:31:29 -0700402int configureSplit(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy,
Ramkumar Radhakrishnan59a11072013-04-15 16:14:49 -0700403 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
Saurabh Shah2c8ad052014-08-15 13:27:46 -0700404 const ovutils::eDest& lDest,
Saurabh Shahacf10202013-02-26 10:15:15 -0800405 const ovutils::eDest& rDest, overlay::Rotator **rot);
Kinjal Bhavsar2dd04a82012-09-18 18:27:59 -0700406
radhakrishnac9a67412013-09-25 17:40:42 +0530407//Routine to split and configure high resolution YUV layer (> 2048 width)
408int configureSourceSplit(hwc_context_t *ctx, hwc_layer_1_t *layer,
409 const int& dpy,
410 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
Saurabh Shah2c8ad052014-08-15 13:27:46 -0700411 const ovutils::eDest& lDest,
radhakrishnac9a67412013-09-25 17:40:42 +0530412 const ovutils::eDest& rDest, overlay::Rotator **rot);
413
Saurabh Shahe2474082013-05-15 16:32:13 -0700414//On certain targets DMA pipes are used for rotation and they won't be available
415//for line operations. On a per-target basis we can restrict certain use cases
416//from using rotator, since we know before-hand that such scenarios can lead to
417//extreme unavailability of pipes. This can also be done via hybrid calculations
418//also involving many more variables like number of write-back interfaces etc,
419//but the variety of scenarios is too high to warrant that.
Amara Venkata Mastan Manoj Kumar9d373c02013-08-20 14:30:09 -0700420bool canUseRotator(hwc_context_t *ctx, int dpy);
Saurabh Shahe2474082013-05-15 16:32:13 -0700421
Saurabh Shah07a8ca82013-08-06 18:45:42 -0700422int getLeftSplit(hwc_context_t *ctx, const int& dpy);
423
Saurabh Shah88e4d272013-09-03 13:31:29 -0700424bool isDisplaySplit(hwc_context_t* ctx, int dpy);
425
Saurabh Shahc46cf9d2014-07-02 15:22:34 -0700426int getRotDownscale(hwc_context_t *ctx, const hwc_layer_1_t *layer);
427
Ramkumar Radhakrishnanfb822912014-03-14 17:28:14 -0700428// Set the GPU hint flag to high for MIXED/GPU composition only for
429// first frame after MDP to GPU/MIXED mode transition.
430// Set the GPU hint to default if the current composition type is GPU
431// due to idle fallback or MDP composition.
432void setGPUHint(hwc_context_t* ctx, hwc_display_contents_1_t* list);
433
Sushil Chauhandefd3522014-05-13 18:17:12 -0700434// Returns true if rect1 is peripheral to rect2, false otherwise.
435bool isPeripheral(const hwc_rect_t& rect1, const hwc_rect_t& rect2);
436
Naseer Ahmed29a26812012-06-14 00:56:20 -0700437// Inline utility functions
Naseer Ahmed5b6708a2012-08-02 13:46:08 -0700438static inline bool isSkipLayer(const hwc_layer_1_t* l) {
Naseer Ahmed29a26812012-06-14 00:56:20 -0700439 return (UNLIKELY(l && (l->flags & HWC_SKIP_LAYER)));
440}
441
Ramkumar Radhakrishnan9d7bc312014-08-13 19:38:13 -0700442static inline bool isAIVVideoLayer(const hwc_layer_1_t* l) {
443 return (UNLIKELY(l && (l->flags & HWC_AIV_VIDEO)));
444}
445
446static inline bool isAIVCCLayer(const hwc_layer_1_t* l) {
447 return (UNLIKELY(l && (l->flags & HWC_AIV_CC)));
448}
449
Naseer Ahmed29a26812012-06-14 00:56:20 -0700450// Returns true if the buffer is yuv
451static inline bool isYuvBuffer(const private_handle_t* hnd) {
452 return (hnd && (hnd->bufferType == BUFFER_TYPE_VIDEO));
453}
454
Raj Kamal389d6e32014-08-04 14:43:24 +0530455// Returns true if the buffer is yuv and exceeds the mixer width
456static inline bool isYUVSplitNeeded(const private_handle_t* hnd) {
457 int maxMixerWidth = qdutils::MDPVersion::getInstance().getMaxMixerWidth();
radhakrishnac9a67412013-09-25 17:40:42 +0530458 return (hnd && (hnd->bufferType == BUFFER_TYPE_VIDEO) &&
Raj Kamal389d6e32014-08-04 14:43:24 +0530459 (hnd->width > maxMixerWidth));
radhakrishnac9a67412013-09-25 17:40:42 +0530460}
461
Saurabh Shahf395d092012-08-27 12:33:42 -0700462// Returns true if the buffer is secure
463static inline bool isSecureBuffer(const private_handle_t* hnd) {
464 return (hnd && (private_handle_t::PRIV_FLAGS_SECURE_BUFFER & hnd->flags));
465}
Manoj Kumar AVM8a220812013-10-10 11:46:06 -0700466
Justin Philipd6166602014-08-12 13:42:21 +0530467// Returns true if the buffer is protected
468static inline bool isProtectedBuffer(const private_handle_t* hnd) {
469 return (hnd && (private_handle_t::PRIV_FLAGS_PROTECTED_BUFFER & hnd->flags));
470}
471
472
Manoj Kumar AVM8a220812013-10-10 11:46:06 -0700473static inline bool isTileRendered(const private_handle_t* hnd) {
474 return (hnd && (private_handle_t::PRIV_FLAGS_TILE_RENDERED & hnd->flags));
475}
476
Naseer Ahmed29a26812012-06-14 00:56:20 -0700477//Return true if buffer is marked locked
478static inline bool isBufferLocked(const private_handle_t* hnd) {
479 return (hnd && (private_handle_t::PRIV_FLAGS_HWC_LOCK & hnd->flags));
480}
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700481
Ramkumar Radhakrishnanba713382013-08-30 18:41:07 -0700482//Return true if the buffer is intended for Secure Display
483static inline bool isSecureDisplayBuffer(const private_handle_t* hnd) {
484 return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY));
485}
486
Ramkumar Radhakrishnan92f3abe2013-06-05 13:52:40 -0700487static inline int getWidth(const private_handle_t* hnd) {
Tatenda Chipeperekwacb2a2432014-08-06 17:45:58 -0700488 MetaData_t *metadata = reinterpret_cast<MetaData_t*>(hnd->base_metadata);
489 if(metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
490 return metadata->bufferDim.sliceWidth;
Ramkumar Radhakrishnan92f3abe2013-06-05 13:52:40 -0700491 }
492 return hnd->width;
493}
494
495static inline int getHeight(const private_handle_t* hnd) {
Tatenda Chipeperekwacb2a2432014-08-06 17:45:58 -0700496 MetaData_t *metadata = reinterpret_cast<MetaData_t*>(hnd->base_metadata);
497 if(metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
498 return metadata->bufferDim.sliceHeight;
Ramkumar Radhakrishnan92f3abe2013-06-05 13:52:40 -0700499 }
500 return hnd->height;
501}
502
Naseer Ahmed64b81212013-02-14 10:29:47 -0500503template<typename T> inline T max(T a, T b) { return (a > b) ? a : b; }
504template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; }
505
Naseer Ahmed72cf9762012-07-21 12:17:13 -0700506// Initialize uevent thread
507void init_uevent_thread(hwc_context_t* ctx);
Naseer Ahmedff4f0252012-10-01 13:03:01 -0400508// Initialize vsync thread
509void init_vsync_thread(hwc_context_t* ctx);
Naseer Ahmed29a26812012-06-14 00:56:20 -0700510
Naseer Ahmed5b6708a2012-08-02 13:46:08 -0700511inline void getLayerResolution(const hwc_layer_1_t* layer,
Naseer Ahmed522ce662013-03-18 20:14:05 -0400512 int& width, int& height) {
Naseer Ahmed7c958d42012-07-31 18:57:03 -0700513 hwc_rect_t displayFrame = layer->displayFrame;
514 width = displayFrame.right - displayFrame.left;
515 height = displayFrame.bottom - displayFrame.top;
516}
Saurabh Shah3e858eb2012-09-17 16:53:21 -0700517
518static inline int openFb(int dpy) {
519 int fd = -1;
520 const char *devtmpl = "/dev/graphics/fb%u";
521 char name[64] = {0};
522 snprintf(name, 64, devtmpl, dpy);
523 fd = open(name, O_RDWR);
524 return fd;
525}
526
Saurabh Shah27c1d652012-08-14 19:30:28 -0700527template <class T>
528inline void swap(T& a, T& b) {
529 T tmp = a;
530 a = b;
531 b = tmp;
532}
533
Naseer Ahmedf48aef62012-07-20 09:05:53 -0700534}; //qhwc namespace
Naseer Ahmed29a26812012-06-14 00:56:20 -0700535
Ramkumar Radhakrishnana70981a2013-08-28 11:33:53 -0700536enum eAnimationState{
537 ANIMATION_STOPPED,
538 ANIMATION_STARTED,
539};
540
Ramkumar Radhakrishnan3efce482014-05-28 15:40:17 -0700541enum eCompositionState {
542 COMPOSITION_STATE_MDP = 0, // Set if composition type is MDP
543 COMPOSITION_STATE_GPU, // Set if composition type is GPU or MIXED
544 COMPOSITION_STATE_IDLE_FALLBACK, // Set if it is idlefallback
545};
546
Ramkumar Radhakrishnanfb822912014-03-14 17:28:14 -0700547// Structure holds the information about the GPU hint.
548struct gpu_hint_info {
549 // system level flag to enable gpu_perf_mode
550 bool mGpuPerfModeEnable;
551 // Stores the current GPU performance mode DEFAULT/HIGH
552 bool mCurrGPUPerfMode;
Ramkumar Radhakrishnan3efce482014-05-28 15:40:17 -0700553 // Stores the compositon state GPU, MDP or IDLE_FALLBACK
554 bool mCompositionState;
Ramkumar Radhakrishnanfb822912014-03-14 17:28:14 -0700555 // Stores the EGLContext of current process
556 EGLContext mEGLContext;
557 // Stores the EGLDisplay of current process
558 EGLDisplay mEGLDisplay;
559};
560
Naseer Ahmed29a26812012-06-14 00:56:20 -0700561// -----------------------------------------------------------------------------
562// HWC context
563// This structure contains overall state
564struct hwc_context_t {
Naseer Ahmed5b6708a2012-08-02 13:46:08 -0700565 hwc_composer_device_1_t device;
Jesse Hall3be78d92012-08-21 15:12:23 -0700566 const hwc_procs_t* proc;
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800567
568 //CopyBit objects
Amara Venkata Mastan Manoj Kumar7fb13272013-07-01 13:59:34 -0700569 qhwc::CopyBit *mCopyBit[HWC_NUM_DISPLAY_TYPES];
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800570
Naseer Ahmed29a26812012-06-14 00:56:20 -0700571 //Overlay object - NULL for non overlay devices
Naseer Ahmed758bfc52012-11-28 17:02:08 -0500572 overlay::Overlay *mOverlay;
Saurabh Shahacf10202013-02-26 10:15:15 -0800573 //Holds a few rot objects
574 overlay::RotMgr *mRotMgr;
Saurabh Shahcf053c62012-12-13 12:32:55 -0800575
576 //Primary and external FB updater
Amara Venkata Mastan Manoj Kumar7fb13272013-07-01 13:59:34 -0700577 qhwc::IFBUpdate *mFBUpdate[HWC_NUM_DISPLAY_TYPES];
Tatenda Chipeperekwaaf2c0042014-09-17 12:55:01 -0700578 // HDMI display related object. Used to configure/teardown
579 // HDMI when it is connected as primary or external.
580 qhwc::HDMIDisplay *mHDMIDisplay;
Naseer Ahmed96c4c952012-07-25 18:27:14 -0700581 qhwc::MDPInfo mMDP;
Naseer Ahmed8bb8f9d2013-05-11 07:29:45 -0400582 qhwc::VsyncState vstate;
Amara Venkata Mastan Manoj Kumar7fb13272013-07-01 13:59:34 -0700583 qhwc::DisplayAttributes dpyAttr[HWC_NUM_DISPLAY_TYPES];
584 qhwc::ListStats listStats[HWC_NUM_DISPLAY_TYPES];
585 qhwc::LayerProp *layerProp[HWC_NUM_DISPLAY_TYPES];
586 qhwc::MDPComp *mMDPComp[HWC_NUM_DISPLAY_TYPES];
587 qhwc::HwcDebug *mHwcDebug[HWC_NUM_DISPLAY_TYPES];
Ramkumar Radhakrishnandd38b822013-12-04 15:15:42 -0800588 hwc_rect_t mViewFrame[HWC_NUM_DISPLAY_TYPES];
Saurabh Shaha9da08f2013-07-03 13:27:53 -0700589 qhwc::AssertiveDisplay *mAD;
Ramkumar Radhakrishnana70981a2013-08-28 11:33:53 -0700590 eAnimationState mAnimationState[HWC_NUM_DISPLAY_TYPES];
Manoj Kumar AVM9591a5e2014-08-21 22:50:21 -0700591 qhwc::HWCVirtualVDS *mHWCVirtual;
Naseer Ahmedb1c76322012-10-17 00:32:50 -0400592
Raj Kamal9ed3d6b2014-02-07 16:15:17 +0530593 // stores the #numHwLayers of the previous frame
594 // for each display device
595 int mPrevHwLayerCount[HWC_NUM_DISPLAY_TYPES];
596
Ramkumar Radhakrishnana70981a2013-08-28 11:33:53 -0700597 // stores the primary device orientation
Ramkumar Radhakrishnan59a11072013-04-15 16:14:49 -0700598 int deviceOrientation;
Saurabh Shah56f610d2012-08-07 15:27:06 -0700599 //Securing in progress indicator
600 bool mSecuring;
Saurabh Shah56f610d2012-08-07 15:27:06 -0700601 //Display in secure mode indicator
602 bool mSecureMode;
Saurabh Shahb39f8152013-08-22 10:21:44 -0700603 //Lock to protect drawing data structures
604 mutable Locker mDrawLock;
Saurabh Shah0ceeb6a2013-04-23 10:46:07 -0700605 //Drawing round when we use GPU
606 bool isPaddingRound;
Tatenda Chipeperekwadc8d7082014-11-04 16:41:50 -0800607 // Used to mark composition cycle when DMA state change is required
608 bool isDMAStateChanging;
Arun Kumar K.Rffef7482013-04-10 14:17:22 -0700609 // External Orientation
610 int mExtOrientation;
Saurabh Shahd4e65852013-06-17 11:33:53 -0700611 //Flags the transition of a video session
612 bool mVideoTransFlag;
Arun Kumar K.Rfb5bfa62013-07-25 03:10:51 -0700613 //Used for SideSync feature
614 //which overrides the mExtOrientation
615 bool mBufferMirrorMode;
Raj kamal59fea562014-04-01 16:52:19 +0530616 // Used to synchronize between WFD and Display modules
617 mutable Locker mWfdSyncLock;
618
Amara Venkata Mastan Manoj Kumar7fb13272013-07-01 13:59:34 -0700619 qhwc::LayerRotMap *mLayerRotMap[HWC_NUM_DISPLAY_TYPES];
Veera Sankaran0dadfb32013-07-22 16:07:48 -0700620 // Panel reset flag will be set if BTA check fails
621 bool mPanelResetStatus;
Raj Kamal52b4fdb2014-01-27 19:35:13 +0530622 // number of active Displays
623 int numActiveDisplays;
Ramkumar Radhakrishnanfb822912014-03-14 17:28:14 -0700624 struct gpu_hint_info mGPUHintInfo;
Ramakant Singh0def28c2014-03-28 20:43:13 +0530625 //App Buffer Composition
626 bool enableABC;
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700627 // PTOR Info
628 qhwc::PtorInfo mPtorInfo;
Dileep Kumar Reddia25a9182014-07-24 20:01:44 +0530629 //Running in Thermal burst mode
630 bool mThermalBurstMode;
Dileep Kumar Reddi4070e932014-09-30 09:00:57 +0530631 //Layers out of ROI
632 bool copybitDrop[MAX_NUM_APP_LAYERS];
Ramkumar Radhakrishnanb33f4902014-10-03 16:46:35 -0700633 // Flag related to windowboxing feature
Ramkumar Radhakrishnan9d7bc312014-08-13 19:38:13 -0700634 bool mWindowboxFeature;
Ramkumar Radhakrishnan812999a2014-09-11 21:42:07 -0700635 // This denotes the tolerance between video layer and external display
636 // aspect ratio
637 float mAspectRatioToleranceLevel;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700638};
639
Saurabh Shahacf10202013-02-26 10:15:15 -0800640namespace qhwc {
Saurabh Shahcbf7ccc2012-12-19 16:45:51 -0800641static inline bool isSkipPresent (hwc_context_t *ctx, int dpy) {
642 return ctx->listStats[dpy].skipCount;
643}
644
645static inline bool isYuvPresent (hwc_context_t *ctx, int dpy) {
646 return ctx->listStats[dpy].yuvCount;
647}
Saurabh Shahe9bc60f2013-08-29 12:58:06 -0700648
Ramkumar Radhakrishnan9d20b392013-11-15 19:32:47 -0800649static inline bool has90Transform(hwc_layer_1_t const* layer) {
Sushil Chauhan897a9c32013-07-18 11:09:55 -0700650 return ((layer->transform & HWC_TRANSFORM_ROT_90) &&
651 !(layer->flags & HWC_COLOR_FILL));
Saurabh Shahe9bc60f2013-08-29 12:58:06 -0700652}
653
Saurabh Shah8028e3b2013-10-15 12:27:59 -0700654inline bool isSecurePresent(hwc_context_t *ctx, int dpy) {
655 return ctx->listStats[dpy].isSecurePresent;
656}
657
Ramkumar Radhakrishnan8bb48d32013-12-30 23:11:27 -0800658static inline bool isSecondaryConfiguring(hwc_context_t* ctx) {
659 return (ctx->dpyAttr[HWC_DISPLAY_EXTERNAL].isConfiguring ||
660 ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].isConfiguring);
661}
662
663static inline bool isSecondaryConnected(hwc_context_t* ctx) {
664 return (ctx->dpyAttr[HWC_DISPLAY_EXTERNAL].connected ||
665 ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].connected);
666}
667
Manoj Kumar AVMfb472b02014-08-21 15:13:37 -0700668/* Return Virtual Display connection status */
669static inline bool isVDConnected(hwc_context_t* ctx) {
670 return ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].connected;
671}
672
Saurabh Shahacf10202013-02-26 10:15:15 -0800673};
Saurabh Shahcbf7ccc2012-12-19 16:45:51 -0800674
Naseer Ahmed29a26812012-06-14 00:56:20 -0700675#endif //HWC_UTILS_H