blob: f290dc80f4338effb994985f3c333136600119b1 [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>
Naseer Ahmed7a7b66d2014-07-23 17:56:26 -040038#include <QService.h>
Ramkumar Radhakrishnanfb822912014-03-14 17:28:14 -070039
Naseer Ahmed29a26812012-06-14 00:56:20 -070040
Naseer Ahmed31da0b12012-07-31 18:55:33 -070041#define ALIGN_TO(x, align) (((x) + ((align)-1)) & ~((align)-1))
Naseer Ahmed29a26812012-06-14 00:56:20 -070042#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true ))
43#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))
Ramkumar Radhakrishnane661f962013-06-05 17:21:38 -070044#define MAX_NUM_APP_LAYERS 32
Jeykumar Sankaranbe93e272014-06-19 18:15:57 -070045#define MAX_NUM_BLEND_STAGES 16
Dileep Kumar Reddibf2678b2014-01-29 15:33:32 +053046#define MIN_DISPLAY_XRES 200
47#define MIN_DISPLAY_YRES 200
Raj kamal59fea562014-04-01 16:52:19 +053048#define HWC_WFDDISPSYNC_LOG 0
49#define STR(f) #f;
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -070050// Max number of PTOR layers handled
51#define MAX_PTOR_LAYERS 2
Naseer Ahmed29a26812012-06-14 00:56:20 -070052
Naseer Ahmed72cf9762012-07-21 12:17:13 -070053//Fwrd decls
Naseer Ahmed29a26812012-06-14 00:56:20 -070054struct hwc_context_t;
Naseer Ahmed72cf9762012-07-21 12:17:13 -070055
Saurabh Shahacf10202013-02-26 10:15:15 -080056namespace ovutils = overlay::utils;
57
Naseer Ahmed72cf9762012-07-21 12:17:13 -070058namespace overlay {
59class Overlay;
Saurabh Shahacf10202013-02-26 10:15:15 -080060class Rotator;
61class RotMgr;
Naseer Ahmed72cf9762012-07-21 12:17:13 -070062}
63
Naseer Ahmed29a26812012-06-14 00:56:20 -070064namespace qhwc {
Naseer Ahmed72cf9762012-07-21 12:17:13 -070065//fwrd decl
66class QueuedBufferStore;
Tatenda Chipeperekwaaf2c0042014-09-17 12:55:01 -070067class HDMIDisplay;
Jeykumar Sankaran27dee262013-08-01 17:09:54 -070068class VirtualDisplay;
Saurabh Shahcf053c62012-12-13 12:32:55 -080069class IFBUpdate;
Saurabh Shahacf10202013-02-26 10:15:15 -080070class IVideoOverlay;
Saurabh Shahcbf7ccc2012-12-19 16:45:51 -080071class MDPComp;
Arun Kumar K.R361da4f2012-11-28 10:42:59 -080072class CopyBit;
Ramkumar Radhakrishnand224a1a2013-04-05 17:46:55 -070073class HwcDebug;
Saurabh Shaha9da08f2013-07-03 13:27:53 -070074class AssertiveDisplay;
Manoj Kumar AVM9591a5e2014-08-21 22:50:21 -070075class HWCVirtualVDS;
Naseer Ahmed96c4c952012-07-25 18:27:14 -070076
Naseer Ahmed64b81212013-02-14 10:29:47 -050077
Naseer Ahmed96c4c952012-07-25 18:27:14 -070078struct MDPInfo {
79 int version;
80 char panel;
81 bool hasOverlay;
82};
Naseer Ahmed29a26812012-06-14 00:56:20 -070083
Saurabh Shah3e858eb2012-09-17 16:53:21 -070084struct DisplayAttributes {
Arun Kumar K.Ra727a882014-08-20 17:14:26 -070085 uint32_t refreshRate;
86 uint32_t dynRefreshRate;
Saurabh Shah3e858eb2012-09-17 16:53:21 -070087 uint32_t vsync_period; //nanos
88 uint32_t xres;
89 uint32_t yres;
Naseer Ahmed54821fe2012-11-28 18:44:38 -050090 uint32_t stride;
Naseer Ahmed7b80d9c2012-09-26 20:14:38 -040091 float xdpi;
92 float ydpi;
Arun Kumar K.R074c9cf2014-08-21 18:43:53 -070093 bool secure;
radhakrishnac3198ff2015-03-10 17:10:02 +053094 uint32_t fbformat;
Saurabh Shah3e858eb2012-09-17 16:53:21 -070095 int fd;
Saurabh Shahc4d034f2012-09-27 15:55:15 -070096 bool connected; //Applies only to pluggable disp.
97 //Connected does not mean it ready to use.
98 //It should be active also. (UNBLANKED)
Saurabh Shah3e858eb2012-09-17 16:53:21 -070099 bool isActive;
Amara Venkata Mastan Manoj Kumar11a380d2013-01-17 09:30:56 -0800100 // In pause state, composition is bypassed
Naseer Ahmed78951b22014-12-10 18:19:21 -0500101 // used for WFD displays and in QDCM calibration mode
Amara Venkata Mastan Manoj Kumar11a380d2013-01-17 09:30:56 -0800102 bool isPause;
Jeykumar Sankaran27dee262013-08-01 17:09:54 -0700103 // To trigger padding round to clean up mdp
104 // pipes
105 bool isConfiguring;
Tatenda Chipeperekwacb2a2432014-08-06 17:45:58 -0700106 // Indicates whether external/virtual display is in MDP scaling mode
107 bool mMDPScalingMode;
Arun Kumar K.R8e7a62f2013-12-06 18:55:41 -0800108 // Ext dst Rect
109 hwc_rect_t mDstRect;
Ramkumar Radhakrishnan4af1ef02013-12-12 11:53:08 -0800110 //Action safe attributes
111 // Flag to indicate the presence of action safe dimensions for external
112 bool mActionSafePresent;
113 int mAsWidthRatio;
114 int mAsHeightRatio;
Dileep Kumar Reddibf2678b2014-01-29 15:33:32 +0530115
Naseer Ahmed6bbd0a12015-01-23 11:57:10 -0500116 // This is the 3D mode to which the TV is set
117 // The mode may be set via the appearance of a layer with 3D format
118 // or by forcing the mode via binder.
119 // If the mode is set via binder, the s3dModeForced flag is set, so that the
120 // mode is not changed back when the 3D video layer drops out.
121 // If the forced mode is different from the one in 3D video, the results
122 // are unpredictable. The assumption is made here that the caller forcing
123 // the mode via binder knows the right formats to use.
124 // The s3dModeForced flag is also used to force 2D if the s3dMode is
125 // HDMI_S3D_NONE
126 int s3dMode;
127 bool s3dModeForced;
Saurabh Shah90c55cf2015-02-10 15:37:39 -0800128 //If property fbsize set via adb shell debug.hwc.fbsize = XRESxYRES
129 //following fields are used.
130 //Also used when the actual panel's dimensions change and FB remains
131 //constant
132 bool fbScaling;
133 uint32_t xresFB; //FB's width, by default from VSCREEN overridden by prop
134 uint32_t yresFB; //FB's height, by default from VSCREEN overridden by prop
135 float fbWidthScaleRatio; // Panel Width / FB Width
136 float fbHeightScaleRatio; // Panel Height / FB Height
137 //If configuration changed dynamically without subsequent GEOMETRY changes
138 //we may still need to adjust destination params
139 bool configSwitched;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700140};
Saurabh Shah3e858eb2012-09-17 16:53:21 -0700141
142struct ListStats {
143 int numAppLayers; //Total - 1, excluding FB layer.
144 int skipCount;
145 int fbLayerIndex; //Always last for now. = numAppLayers
146 //Video specific
147 int yuvCount;
Ramkumar Radhakrishnane661f962013-06-05 17:21:38 -0700148 int yuvIndices[MAX_NUM_APP_LAYERS];
Sravan Kumar D.V.Nb5ed0292013-03-15 08:51:16 +0530149 bool preMultipliedAlpha;
radhakrishnac9a67412013-09-25 17:40:42 +0530150 int yuv4k2kIndices[MAX_NUM_APP_LAYERS];
151 int yuv4k2kCount;
Ramkumar Radhakrishnan59a11072013-04-15 16:14:49 -0700152 // Notifies hwcomposer about the start and end of animation
153 // This will be set to true during animation, otherwise false.
154 bool isDisplayAnimating;
Ramkumar Radhakrishnanba713382013-08-30 18:41:07 -0700155 bool secureUI; // Secure display layer
Saurabh Shah8028e3b2013-10-15 12:27:59 -0700156 bool isSecurePresent;
Jeykumar Sankaran6c7eeac2013-11-18 11:19:45 -0800157 hwc_rect_t lRoi; //left ROI
158 hwc_rect_t rRoi; //right ROI. Unused in single DSI panels.
Ramakant Singh0def28c2014-03-28 20:43:13 +0530159 //App Buffer Composition index
160 int renderBufIndexforABC;
Ramkumar Radhakrishnan4ec775f2014-07-23 17:43:18 -0700161 // Secure RGB specific
162 int secureRGBCount;
163 int secureRGBIndices[MAX_NUM_APP_LAYERS];
Arun Kumar K.Ra727a882014-08-20 17:14:26 -0700164 //dyn refresh rate-Client requested refreshrate
165 uint32_t refreshRateRequest;
Ramkumar Radhakrishnanb33f4902014-10-03 16:46:35 -0700166 // Flag related to windowboxing feature
167 bool mAIVVideoMode;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700168};
169
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700170//PTOR Comp info
171struct PtorInfo {
172 int count;
173 int layerIndex[MAX_PTOR_LAYERS];
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700174 hwc_rect_t displayFrame[MAX_PTOR_LAYERS];
175 bool isActive() { return (count>0); }
176 int getPTORArrayIndex(int index) {
177 int idx = -1;
178 for(int i = 0; i < count; i++) {
179 if(index == layerIndex[i])
180 idx = i;
181 }
182 return idx;
183 }
184};
185
Naseer Ahmed54821fe2012-11-28 18:44:38 -0500186struct LayerProp {
187 uint32_t mFlags; //qcom specific layer flags
Jeykumar Sankaran6a9bb9e2013-08-01 14:19:26 -0700188 LayerProp():mFlags(0){};
Naseer Ahmed54821fe2012-11-28 18:44:38 -0500189};
190
Naseer Ahmed8bb8f9d2013-05-11 07:29:45 -0400191struct VsyncState {
192 bool enable;
193 bool fakevsync;
Naseer Ahmed35a268c2014-06-24 19:07:13 -0400194 bool debug;
Naseer Ahmed8bb8f9d2013-05-11 07:29:45 -0400195};
196
Saurabh Shah1a03d482013-05-29 13:44:20 -0700197struct BwcPM {
Saurabh Shahcd018352014-11-11 13:54:19 -0800198 static void setBwc(const hwc_context_t *ctx, const int& dpy,
199 const private_handle_t *hnd,
200 const hwc_rect_t& crop, const hwc_rect_t& dst,
Saurabh Shahc46cf9d2014-07-02 15:22:34 -0700201 const int& transform, const int& downscale,
Saurabh Shah1a03d482013-05-29 13:44:20 -0700202 ovutils::eMdpFlags& mdpFlags);
203};
204
Naseer Ahmed54821fe2012-11-28 18:44:38 -0500205// LayerProp::flag values
Naseer Ahmed7c958d42012-07-31 18:57:03 -0700206enum {
Naseer Ahmed54821fe2012-11-28 18:44:38 -0500207 HWC_MDPCOMP = 0x00000001,
Naseer Ahmed64b81212013-02-14 10:29:47 -0500208 HWC_COPYBIT = 0x00000002,
Naseer Ahmed7c958d42012-07-31 18:57:03 -0700209};
210
Ramkumar Radhakrishnan9d7bc312014-08-13 19:38:13 -0700211// AIV specific flags
212enum {
213 HWC_AIV_VIDEO = 0x80000000,
214 HWC_AIV_CC = 0x40000000,
215};
216
Sushil Chauhan1f6d68f2013-10-11 11:49:35 -0700217// HAL specific features
218enum {
Sushil Chauhan943797c2013-10-21 17:35:55 -0700219 HWC_COLOR_FILL = 0x00000008,
Sushil Chauhan1f6d68f2013-10-11 11:49:35 -0700220 HWC_FORMAT_RB_SWAP = 0x00000040,
221};
222
Raj kamal59fea562014-04-01 16:52:19 +0530223/* External Display states */
224enum {
225 EXTERNAL_OFFLINE = 0,
226 EXTERNAL_ONLINE,
227 EXTERNAL_PAUSE,
228 EXTERNAL_RESUME,
229 EXTERNAL_MAXSTATES
230};
231
Saurabh Shah23a813c2013-03-20 16:58:12 -0700232class LayerRotMap {
233public:
234 LayerRotMap() { reset(); }
Saurabh Shah23a813c2013-03-20 16:58:12 -0700235 void add(hwc_layer_1_t* layer, overlay::Rotator *rot);
Saurabh Shahda5b3ce2013-11-26 10:48:06 -0800236 //Resets the mapping of layer to rotator
Saurabh Shah23a813c2013-03-20 16:58:12 -0700237 void reset();
Saurabh Shahda5b3ce2013-11-26 10:48:06 -0800238 //Clears mappings and existing rotator fences
239 //Intended to be used during errors
240 void clear();
Saurabh Shah23a813c2013-03-20 16:58:12 -0700241 uint32_t getCount() const;
242 hwc_layer_1_t* getLayer(uint32_t index) const;
243 overlay::Rotator* getRot(uint32_t index) const;
Raj Kamalbd3bdc62014-08-05 18:52:49 +0530244 bool isRotCached(uint32_t index) const;
Saurabh Shah23a813c2013-03-20 16:58:12 -0700245 void setReleaseFd(const int& fence);
246private:
Raj Kamal389d6e32014-08-04 14:43:24 +0530247 hwc_layer_1_t* mLayer[overlay::RotMgr::MAX_ROT_SESS];
248 overlay::Rotator* mRot[overlay::RotMgr::MAX_ROT_SESS];
Saurabh Shah23a813c2013-03-20 16:58:12 -0700249 uint32_t mCount;
250};
251
252inline uint32_t LayerRotMap::getCount() const {
253 return mCount;
254}
255
256inline hwc_layer_1_t* LayerRotMap::getLayer(uint32_t index) const {
257 if(index >= mCount) return NULL;
258 return mLayer[index];
259}
260
261inline overlay::Rotator* LayerRotMap::getRot(uint32_t index) const {
262 if(index >= mCount) return NULL;
263 return mRot[index];
264}
265
Saurabh Shah62e1d732013-09-17 10:44:05 -0700266inline hwc_rect_t integerizeSourceCrop(const hwc_frect_t& cropF) {
Praveena Pachipulusud9443c72014-02-17 10:42:28 +0530267 hwc_rect_t cropI = {0,0,0,0};
Saurabh Shahb45cc7f2015-02-17 09:57:47 -0800268 cropI.left = int(floorf(cropF.left));
269 cropI.top = int(floorf(cropF.top));
270 cropI.right = int(ceilf(cropF.right));
271 cropI.bottom = int(ceilf(cropF.bottom));
Saurabh Shah62e1d732013-09-17 10:44:05 -0700272 return cropI;
273}
274
Naseer Ahmede850a802013-09-06 13:12:52 -0400275inline bool isNonIntegralSourceCrop(const hwc_frect_t& cropF) {
276 if(cropF.left - roundf(cropF.left) ||
277 cropF.top - roundf(cropF.top) ||
278 cropF.right - roundf(cropF.right) ||
279 cropF.bottom - roundf(cropF.bottom))
280 return true;
281 else
282 return false;
283}
284
Naseer Ahmed29a26812012-06-14 00:56:20 -0700285// -----------------------------------------------------------------------------
286// Utility functions - implemented in hwc_utils.cpp
Naseer Ahmed5b6708a2012-08-02 13:46:08 -0700287void dumpLayer(hwc_layer_1_t const* l);
Saurabh Shahd9ff30b2013-10-03 16:37:06 -0700288void setListStats(hwc_context_t *ctx, hwc_display_contents_1_t *list,
Saurabh Shah3e858eb2012-09-17 16:53:21 -0700289 int dpy);
Arun Kumar K.R205df772015-02-20 18:45:58 -0800290int initContext(hwc_context_t *ctx);
Naseer Ahmed29a26812012-06-14 00:56:20 -0700291void closeContext(hwc_context_t *ctx);
Naseer Ahmedf48aef62012-07-20 09:05:53 -0700292//Crops source buffer against destination and FB boundaries
293void calculate_crop_rects(hwc_rect_t& crop, hwc_rect_t& dst,
Jeykumar Sankaranb551ce42013-01-10 16:26:48 -0800294 const hwc_rect_t& scissor, int orient);
Naseer Ahmed64b81212013-02-14 10:29:47 -0500295void getNonWormholeRegion(hwc_display_contents_1_t* list,
296 hwc_rect_t& nwr);
Jeykumar Sankaran85977e32013-02-25 17:06:08 -0800297bool isSecuring(hwc_context_t* ctx, hwc_layer_1_t const* layer);
Sushil Chauhan2515abf2013-01-08 16:40:05 -0800298bool isSecureModePolicy(int mdpVersion);
Ramkumar Radhakrishnan9d20b392013-11-15 19:32:47 -0800299// Returns true, if the input layer format is supported by rotator
300bool isRotatorSupportedFormat(private_handle_t *hnd);
301//Returns true, if the layer is YUV or the layer has been rendered by CPU
302bool isRotationDoable(hwc_context_t *ctx, private_handle_t *hnd);
Prabhanjan Kandula21918db2013-11-26 15:51:58 +0530303bool isAlphaScaled(hwc_layer_1_t const* layer);
304bool needsScaling(hwc_layer_1_t const* layer);
305bool isDownscaleRequired(hwc_layer_1_t const* layer);
Sushil Chauhan15a2ea62013-09-04 18:28:36 -0700306bool needsScalingWithSplit(hwc_context_t* ctx, hwc_layer_1_t const* layer,
307 const int& dpy);
308void sanitizeSourceCrop(hwc_rect_t& cropL, hwc_rect_t& cropR,
309 private_handle_t *hnd);
Sravan Kumar D.V.N075ef002013-03-20 05:22:26 +0530310bool isAlphaPresent(hwc_layer_1_t const* layer);
radhakrishnac3198ff2015-03-10 17:10:02 +0530311bool isAlphaPresentinFB(hwc_context_t* ctx, int dpy);
Naseer Ahmed56601cd2013-03-05 11:34:14 -0500312int hwc_vsync_control(hwc_context_t* ctx, int dpy, int enable);
Naseer Ahmed522ce662013-03-18 20:14:05 -0400313int getBlending(int blending);
Ramkumar Radhakrishnan8bb48d32013-12-30 23:11:27 -0800314bool isGLESOnlyComp(hwc_context_t *ctx, const int& dpy);
315void reset_layer_prop(hwc_context_t* ctx, int dpy, int numAppLayers);
Ramakant Singh0def28c2014-03-28 20:43:13 +0530316bool isAbcInUse(hwc_context_t *ctx);
Saurabh Shahfc2acbe2012-08-17 19:47:52 -0700317
Tatenda Chipeperekwa523eac52014-05-29 14:58:39 -0700318void dumpBuffer(private_handle_t *ohnd, char *bufferName);
Tatenda Chipeperekwa03d5df22014-09-16 18:09:18 -0700319void updateDisplayInfo(hwc_context_t* ctx, int dpy);
320void resetDisplayInfo(hwc_context_t* ctx, int dpy);
321void initCompositionResources(hwc_context_t* ctx, int dpy);
322void destroyCompositionResources(hwc_context_t* ctx, int dpy);
Tatenda Chipeperekwad80b6172014-09-23 11:29:37 -0700323void clearPipeResources(hwc_context_t* ctx, int dpy);
Raj Kamal52b4fdb2014-01-27 19:35:13 +0530324
Naseer Ahmed1d183f52012-11-26 12:35:16 -0500325//Helper function to dump logs
326void dumpsys_log(android::String8& buf, const char* fmt, ...);
327
Ramkumar Radhakrishnan66f856c2013-08-21 16:09:47 -0700328int getExtOrientation(hwc_context_t* ctx);
Jeykumar Sankaran6a585792013-10-03 11:30:55 -0700329bool isValidRect(const hwc_rect_t& rect);
Jeykumar Sankaran93943532013-11-08 18:05:11 -0800330hwc_rect_t deductRect(const hwc_rect_t& rect1, const hwc_rect_t& rect2);
Jeykumar Sankaran6c7eeac2013-11-18 11:19:45 -0800331bool isSameRect(const hwc_rect& rect1, const hwc_rect& rect2);
Jeykumar Sankaran71e597c2014-05-07 16:23:14 -0700332hwc_rect_t moveRect(const hwc_rect_t& rect, const int& x_off, const int& y_off);
Jeykumar Sankaran6a585792013-10-03 11:30:55 -0700333hwc_rect_t getIntersection(const hwc_rect_t& rect1, const hwc_rect_t& rect2);
334hwc_rect_t getUnion(const hwc_rect_t& rect1, const hwc_rect_t& rect2);
Arun Kumar K.R2aa44c62014-01-21 23:08:28 -0800335void optimizeLayerRects(const hwc_display_contents_1_t *list);
Prabhanjan Kandula9bd5f642013-09-25 17:00:36 +0530336bool areLayersIntersecting(const hwc_layer_1_t* layer1,
337 const hwc_layer_1_t* layer2);
Ramakant Singh21cec722014-03-07 19:11:45 +0530338bool operator ==(const hwc_rect_t& lhs, const hwc_rect_t& rhs);
Prabhanjan Kandulaa5dc8e92013-09-25 15:20:33 +0530339
Ramkumar Radhakrishnan4af1ef02013-12-12 11:53:08 -0800340// returns true if Action safe dimensions are set and target supports Actionsafe
341bool isActionSafePresent(hwc_context_t *ctx, int dpy);
342
Arun Kumar K.Rfeb2d8a2013-02-01 02:53:13 -0800343/* Calculates the destination position based on the action safe rectangle */
Arun Kumar K.R5898c652013-07-17 14:20:32 -0700344void getActionSafePosition(hwc_context_t *ctx, int dpy, hwc_rect_t& dst);
Arun Kumar K.Rfeb2d8a2013-02-01 02:53:13 -0800345
Arun Kumar K.R5898c652013-07-17 14:20:32 -0700346void getAspectRatioPosition(hwc_context_t* ctx, int dpy, int extOrientation,
347 hwc_rect_t& inRect, hwc_rect_t& outRect);
348
Raj Kamal0d53fc62014-11-25 17:36:36 +0530349uint32_t roundOff(uint32_t refreshRate);
350
Arun Kumar K.Ra727a882014-08-20 17:14:26 -0700351void setRefreshRate(hwc_context_t *ctx, int dpy, uint32_t refreshRate);
352
Arun Kumar K.R5898c652013-07-17 14:20:32 -0700353bool isPrimaryPortrait(hwc_context_t *ctx);
354
Amara Venkata Mastan Manoj Kumar376d8a82013-03-13 19:18:47 -0700355bool isOrientationPortrait(hwc_context_t *ctx);
356
Arun Kumar K.R5898c652013-07-17 14:20:32 -0700357void calcExtDisplayPosition(hwc_context_t *ctx,
Ramkumar Radhakrishnan66f856c2013-08-21 16:09:47 -0700358 private_handle_t *hnd,
Amara Venkata Mastan Manoj Kumar376d8a82013-03-13 19:18:47 -0700359 int dpy,
360 hwc_rect_t& sourceCrop,
Ramkumar Radhakrishnan66f856c2013-08-21 16:09:47 -0700361 hwc_rect_t& displayFrame,
362 int& transform,
363 ovutils::eTransform& orient);
364
Arun Kumar K.Rfb5bfa62013-07-25 03:10:51 -0700365// Returns the orientation that needs to be set on external for
366// BufferMirrirMode(Sidesync)
367int getMirrorModeOrientation(hwc_context_t *ctx);
Arun Kumar K.Rffef7482013-04-10 14:17:22 -0700368
Raj kamal59fea562014-04-01 16:52:19 +0530369/* Get External State names */
370const char* getExternalDisplayState(uint32_t external_state);
371
Jeykumar Sankaran6c7eeac2013-11-18 11:19:45 -0800372// Resets display ROI to full panel resoluion
373void resetROI(hwc_context_t *ctx, const int dpy);
374
Jeykumar Sankaranaedd1432015-01-15 11:25:03 -0800375// Modifies ROI even from middle of the screen
376hwc_rect expandROIFromMidPoint(hwc_rect roi, hwc_rect fullFrame);
377
Jeykumar Sankaran7c852382014-02-26 18:26:58 -0800378// Aligns updating ROI to panel restrictions
Jeykumar Sankaran6c7eeac2013-11-18 11:19:45 -0800379hwc_rect_t getSanitizeROI(struct hwc_rect roi, hwc_rect boundary);
Jeykumar Sankaran7c852382014-02-26 18:26:58 -0800380
Arun Kumar K.Rc62935a2013-12-03 16:47:47 -0800381// Handles wfd Pause and resume events
382void handle_pause(hwc_context_t *ctx, int dpy);
383void handle_resume(hwc_context_t *ctx, int dpy);
384
Tatenda Chipeperekwad80b6172014-09-23 11:29:37 -0700385// Handle ONLINE/OFFLINE for HDMI display
386void handle_online(hwc_context_t* ctx, int dpy);
387void handle_offline(hwc_context_t* ctx, int dpy);
388
Saurabh Shah747af1e2013-02-26 10:25:12 -0800389//Close acquireFenceFds of all layers of incoming list
390void closeAcquireFds(hwc_display_contents_1_t* list);
391
Kinjal Bhavsar2dd04a82012-09-18 18:27:59 -0700392//Sync point impl.
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800393int hwc_sync(hwc_context_t *ctx, hwc_display_contents_1_t* list, int dpy,
Saurabh Shahacf10202013-02-26 10:15:15 -0800394 int fd);
395
Saurabh Shahacf10202013-02-26 10:15:15 -0800396//Sets appropriate mdp flags for a layer.
Ramkumar Radhakrishnan9d20b392013-11-15 19:32:47 -0800397void setMdpFlags(hwc_context_t *ctx, hwc_layer_1_t *layer,
Saurabh Shahacf10202013-02-26 10:15:15 -0800398 ovutils::eMdpFlags &mdpFlags,
Ramkumar Radhakrishnan9d52f432013-05-14 14:46:59 -0700399 int rotDownscale, int transform);
Saurabh Shahacf10202013-02-26 10:15:15 -0800400
Prabhanjan Kandulaa1d83012013-04-23 13:06:02 +0530401int configRotator(overlay::Rotator *rot, ovutils::Whf& whf,
Sushil Chauhan1cac8152013-05-08 15:53:51 -0700402 hwc_rect_t& crop, const ovutils::eMdpFlags& mdpFlags,
Arun Kumar K.Rffef7482013-04-10 14:17:22 -0700403 const ovutils::eTransform& orient, const int& downscale);
404
405int configMdp(overlay::Overlay *ov, const ovutils::PipeArgs& parg,
406 const ovutils::eTransform& orient, const hwc_rect_t& crop,
407 const hwc_rect_t& pos, const MetaData_t *metadata,
408 const ovutils::eDest& dest);
409
Sushil Chauhan897a9c32013-07-18 11:09:55 -0700410int configColorLayer(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy,
411 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
Saurabh Shah2c8ad052014-08-15 13:27:46 -0700412 const ovutils::eDest& dest);
Sushil Chauhan897a9c32013-07-18 11:09:55 -0700413
Arun Kumar K.Rffef7482013-04-10 14:17:22 -0700414void updateSource(ovutils::eTransform& orient, ovutils::Whf& whf,
Saurabh Shah8ec9b5e2014-06-30 14:37:17 -0700415 hwc_rect_t& crop, overlay::Rotator *rot);
Arun Kumar K.Rffef7482013-04-10 14:17:22 -0700416
Ramkumar Radhakrishnan9d7bc312014-08-13 19:38:13 -0700417bool isZoomModeEnabled(hwc_rect_t crop);
418void updateCropAIVVideoMode(hwc_context_t *ctx, hwc_rect_t& crop, int dpy);
419void updateDestAIVVideoMode(hwc_context_t *ctx, hwc_rect_t& dst, int dpy);
Ramkumar Radhakrishnanb33f4902014-10-03 16:46:35 -0700420void updateCoordinates(hwc_context_t *ctx, hwc_rect_t& crop,
Ramkumar Radhakrishnan9d7bc312014-08-13 19:38:13 -0700421 hwc_rect_t& dst, int dpy);
422
Saurabh Shahacf10202013-02-26 10:15:15 -0800423//Routine to configure low resolution panels (<= 2048 width)
Saurabh Shah88e4d272013-09-03 13:31:29 -0700424int configureNonSplit(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy,
Ramkumar Radhakrishnan59a11072013-04-15 16:14:49 -0700425 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
Saurabh Shah2c8ad052014-08-15 13:27:46 -0700426 const ovutils::eDest& dest,
Saurabh Shahacf10202013-02-26 10:15:15 -0800427 overlay::Rotator **rot);
428
429//Routine to configure high resolution panels (> 2048 width)
Saurabh Shah88e4d272013-09-03 13:31:29 -0700430int configureSplit(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy,
Ramkumar Radhakrishnan59a11072013-04-15 16:14:49 -0700431 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
Saurabh Shah2c8ad052014-08-15 13:27:46 -0700432 const ovutils::eDest& lDest,
Saurabh Shahacf10202013-02-26 10:15:15 -0800433 const ovutils::eDest& rDest, overlay::Rotator **rot);
Kinjal Bhavsar2dd04a82012-09-18 18:27:59 -0700434
Naseer Ahmed6bbd0a12015-01-23 11:57:10 -0500435//Check if the current round needs 3D composition
436bool needs3DComposition(hwc_context_t* ctx, int dpy);
437
438//Routine to configure 3D video
439int configure3DVideo(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy,
440 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
441 const ovutils::eDest& lDest,
442 const ovutils::eDest& rDest, overlay::Rotator **rot);
443
radhakrishnac9a67412013-09-25 17:40:42 +0530444//Routine to split and configure high resolution YUV layer (> 2048 width)
445int configureSourceSplit(hwc_context_t *ctx, hwc_layer_1_t *layer,
446 const int& dpy,
447 ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
Saurabh Shah2c8ad052014-08-15 13:27:46 -0700448 const ovutils::eDest& lDest,
radhakrishnac9a67412013-09-25 17:40:42 +0530449 const ovutils::eDest& rDest, overlay::Rotator **rot);
450
Saurabh Shahe2474082013-05-15 16:32:13 -0700451//On certain targets DMA pipes are used for rotation and they won't be available
452//for line operations. On a per-target basis we can restrict certain use cases
453//from using rotator, since we know before-hand that such scenarios can lead to
454//extreme unavailability of pipes. This can also be done via hybrid calculations
455//also involving many more variables like number of write-back interfaces etc,
456//but the variety of scenarios is too high to warrant that.
Amara Venkata Mastan Manoj Kumar9d373c02013-08-20 14:30:09 -0700457bool canUseRotator(hwc_context_t *ctx, int dpy);
Saurabh Shahe2474082013-05-15 16:32:13 -0700458
Saurabh Shah07a8ca82013-08-06 18:45:42 -0700459int getLeftSplit(hwc_context_t *ctx, const int& dpy);
460
Saurabh Shah88e4d272013-09-03 13:31:29 -0700461bool isDisplaySplit(hwc_context_t* ctx, int dpy);
462
Saurabh Shahc46cf9d2014-07-02 15:22:34 -0700463int getRotDownscale(hwc_context_t *ctx, const hwc_layer_1_t *layer);
464
Ramkumar Radhakrishnanfb822912014-03-14 17:28:14 -0700465// Set the GPU hint flag to high for MIXED/GPU composition only for
466// first frame after MDP to GPU/MIXED mode transition.
467// Set the GPU hint to default if the current composition type is GPU
468// due to idle fallback or MDP composition.
469void setGPUHint(hwc_context_t* ctx, hwc_display_contents_1_t* list);
470
Sushil Chauhandefd3522014-05-13 18:17:12 -0700471// Returns true if rect1 is peripheral to rect2, false otherwise.
472bool isPeripheral(const hwc_rect_t& rect1, const hwc_rect_t& rect2);
473
Krishna Chaitanya Parimidb992fd2014-10-22 20:50:50 +0530474// Checks if boot animation has completed and applies default mode
475void processBootAnimCompleted(hwc_context_t *ctx);
476
Naseer Ahmed6bbd0a12015-01-23 11:57:10 -0500477//The gralloc API and driver have different formats
478//The format needs to be converted before passing to libhdmi
479int convertS3DFormatToMode(int s3DFormat);
480
481//Configure resources for 3D mode
482void setup3DMode(hwc_context_t* ctx, int dpy, int s3dMode);
483
484//Checks if this display supports 3D
485bool displaySupports3D(hwc_context_t* ctx, int dpy);
486
Naseer Ahmed29a26812012-06-14 00:56:20 -0700487// Inline utility functions
Naseer Ahmed5b6708a2012-08-02 13:46:08 -0700488static inline bool isSkipLayer(const hwc_layer_1_t* l) {
Naseer Ahmed29a26812012-06-14 00:56:20 -0700489 return (UNLIKELY(l && (l->flags & HWC_SKIP_LAYER)));
490}
491
Ramkumar Radhakrishnan9d7bc312014-08-13 19:38:13 -0700492static inline bool isAIVVideoLayer(const hwc_layer_1_t* l) {
493 return (UNLIKELY(l && (l->flags & HWC_AIV_VIDEO)));
494}
495
496static inline bool isAIVCCLayer(const hwc_layer_1_t* l) {
497 return (UNLIKELY(l && (l->flags & HWC_AIV_CC)));
498}
499
Naseer Ahmed29a26812012-06-14 00:56:20 -0700500// Returns true if the buffer is yuv
501static inline bool isYuvBuffer(const private_handle_t* hnd) {
502 return (hnd && (hnd->bufferType == BUFFER_TYPE_VIDEO));
503}
504
Raj Kamal389d6e32014-08-04 14:43:24 +0530505// Returns true if the buffer is yuv and exceeds the mixer width
506static inline bool isYUVSplitNeeded(const private_handle_t* hnd) {
Jeykumar Sankaran39305802014-12-12 17:55:57 -0800507 int maxPipeWidth = qdutils::MDPVersion::getInstance().getMaxPipeWidth();
radhakrishnac9a67412013-09-25 17:40:42 +0530508 return (hnd && (hnd->bufferType == BUFFER_TYPE_VIDEO) &&
Jeykumar Sankaran39305802014-12-12 17:55:57 -0800509 (hnd->width > maxPipeWidth));
radhakrishnac9a67412013-09-25 17:40:42 +0530510}
511
Saurabh Shahf395d092012-08-27 12:33:42 -0700512// Returns true if the buffer is secure
513static inline bool isSecureBuffer(const private_handle_t* hnd) {
514 return (hnd && (private_handle_t::PRIV_FLAGS_SECURE_BUFFER & hnd->flags));
515}
Manoj Kumar AVM8a220812013-10-10 11:46:06 -0700516
Justin Philipd6166602014-08-12 13:42:21 +0530517// Returns true if the buffer is protected
518static inline bool isProtectedBuffer(const private_handle_t* hnd) {
519 return (hnd && (private_handle_t::PRIV_FLAGS_PROTECTED_BUFFER & hnd->flags));
520}
521
522
Manoj Kumar AVM8a220812013-10-10 11:46:06 -0700523static inline bool isTileRendered(const private_handle_t* hnd) {
524 return (hnd && (private_handle_t::PRIV_FLAGS_TILE_RENDERED & hnd->flags));
525}
526
Ramkumar Radhakrishnanba713382013-08-30 18:41:07 -0700527//Return true if the buffer is intended for Secure Display
528static inline bool isSecureDisplayBuffer(const private_handle_t* hnd) {
529 return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY));
530}
531
Naseer Ahmed6bbd0a12015-01-23 11:57:10 -0500532static inline uint32_t get3DFormat(const private_handle_t* hnd) {
533 MetaData_t *metadata = reinterpret_cast<MetaData_t*>(hnd->base_metadata);
534 if(isYuvBuffer(hnd) && metadata && metadata->operation & S3D_FORMAT) {
535 return metadata->s3dFormat;
536 }
537 return HAL_NO_3D;
538}
539
Ramkumar Radhakrishnan92f3abe2013-06-05 13:52:40 -0700540static inline int getWidth(const private_handle_t* hnd) {
Tatenda Chipeperekwacb2a2432014-08-06 17:45:58 -0700541 MetaData_t *metadata = reinterpret_cast<MetaData_t*>(hnd->base_metadata);
542 if(metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
543 return metadata->bufferDim.sliceWidth;
Ramkumar Radhakrishnan92f3abe2013-06-05 13:52:40 -0700544 }
545 return hnd->width;
546}
547
548static inline int getHeight(const private_handle_t* hnd) {
Tatenda Chipeperekwacb2a2432014-08-06 17:45:58 -0700549 MetaData_t *metadata = reinterpret_cast<MetaData_t*>(hnd->base_metadata);
550 if(metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
551 return metadata->bufferDim.sliceHeight;
Ramkumar Radhakrishnan92f3abe2013-06-05 13:52:40 -0700552 }
553 return hnd->height;
554}
555
Naseer Ahmed64b81212013-02-14 10:29:47 -0500556template<typename T> inline T max(T a, T b) { return (a > b) ? a : b; }
557template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; }
558
Naseer Ahmed72cf9762012-07-21 12:17:13 -0700559// Initialize uevent thread
560void init_uevent_thread(hwc_context_t* ctx);
Naseer Ahmedff4f0252012-10-01 13:03:01 -0400561// Initialize vsync thread
562void init_vsync_thread(hwc_context_t* ctx);
Naseer Ahmed29a26812012-06-14 00:56:20 -0700563
Naseer Ahmed5b6708a2012-08-02 13:46:08 -0700564inline void getLayerResolution(const hwc_layer_1_t* layer,
Naseer Ahmed522ce662013-03-18 20:14:05 -0400565 int& width, int& height) {
Naseer Ahmed7c958d42012-07-31 18:57:03 -0700566 hwc_rect_t displayFrame = layer->displayFrame;
567 width = displayFrame.right - displayFrame.left;
568 height = displayFrame.bottom - displayFrame.top;
569}
Saurabh Shah3e858eb2012-09-17 16:53:21 -0700570
571static inline int openFb(int dpy) {
572 int fd = -1;
573 const char *devtmpl = "/dev/graphics/fb%u";
574 char name[64] = {0};
575 snprintf(name, 64, devtmpl, dpy);
576 fd = open(name, O_RDWR);
577 return fd;
578}
579
Saurabh Shah27c1d652012-08-14 19:30:28 -0700580template <class T>
581inline void swap(T& a, T& b) {
582 T tmp = a;
583 a = b;
584 b = tmp;
585}
586
Naseer Ahmedf48aef62012-07-20 09:05:53 -0700587}; //qhwc namespace
Naseer Ahmed29a26812012-06-14 00:56:20 -0700588
Ramkumar Radhakrishnana70981a2013-08-28 11:33:53 -0700589enum eAnimationState{
590 ANIMATION_STOPPED,
591 ANIMATION_STARTED,
592};
593
Ramkumar Radhakrishnan3efce482014-05-28 15:40:17 -0700594enum eCompositionState {
595 COMPOSITION_STATE_MDP = 0, // Set if composition type is MDP
596 COMPOSITION_STATE_GPU, // Set if composition type is GPU or MIXED
597 COMPOSITION_STATE_IDLE_FALLBACK, // Set if it is idlefallback
598};
599
Ramkumar Radhakrishnanfb822912014-03-14 17:28:14 -0700600// Structure holds the information about the GPU hint.
601struct gpu_hint_info {
602 // system level flag to enable gpu_perf_mode
603 bool mGpuPerfModeEnable;
604 // Stores the current GPU performance mode DEFAULT/HIGH
605 bool mCurrGPUPerfMode;
Ramkumar Radhakrishnan3efce482014-05-28 15:40:17 -0700606 // Stores the compositon state GPU, MDP or IDLE_FALLBACK
607 bool mCompositionState;
Ramkumar Radhakrishnanfb822912014-03-14 17:28:14 -0700608 // Stores the EGLContext of current process
609 EGLContext mEGLContext;
610 // Stores the EGLDisplay of current process
611 EGLDisplay mEGLDisplay;
612};
613
Naseer Ahmed29a26812012-06-14 00:56:20 -0700614// -----------------------------------------------------------------------------
615// HWC context
616// This structure contains overall state
617struct hwc_context_t {
Naseer Ahmed5b6708a2012-08-02 13:46:08 -0700618 hwc_composer_device_1_t device;
Jesse Hall3be78d92012-08-21 15:12:23 -0700619 const hwc_procs_t* proc;
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800620
621 //CopyBit objects
Amara Venkata Mastan Manoj Kumar7fb13272013-07-01 13:59:34 -0700622 qhwc::CopyBit *mCopyBit[HWC_NUM_DISPLAY_TYPES];
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800623
Naseer Ahmed29a26812012-06-14 00:56:20 -0700624 //Overlay object - NULL for non overlay devices
Naseer Ahmed758bfc52012-11-28 17:02:08 -0500625 overlay::Overlay *mOverlay;
Saurabh Shahacf10202013-02-26 10:15:15 -0800626 //Holds a few rot objects
627 overlay::RotMgr *mRotMgr;
Saurabh Shahcf053c62012-12-13 12:32:55 -0800628
629 //Primary and external FB updater
Amara Venkata Mastan Manoj Kumar7fb13272013-07-01 13:59:34 -0700630 qhwc::IFBUpdate *mFBUpdate[HWC_NUM_DISPLAY_TYPES];
Tatenda Chipeperekwaaf2c0042014-09-17 12:55:01 -0700631 // HDMI display related object. Used to configure/teardown
632 // HDMI when it is connected as primary or external.
633 qhwc::HDMIDisplay *mHDMIDisplay;
Naseer Ahmed96c4c952012-07-25 18:27:14 -0700634 qhwc::MDPInfo mMDP;
Naseer Ahmed8bb8f9d2013-05-11 07:29:45 -0400635 qhwc::VsyncState vstate;
Amara Venkata Mastan Manoj Kumar7fb13272013-07-01 13:59:34 -0700636 qhwc::DisplayAttributes dpyAttr[HWC_NUM_DISPLAY_TYPES];
637 qhwc::ListStats listStats[HWC_NUM_DISPLAY_TYPES];
638 qhwc::LayerProp *layerProp[HWC_NUM_DISPLAY_TYPES];
639 qhwc::MDPComp *mMDPComp[HWC_NUM_DISPLAY_TYPES];
640 qhwc::HwcDebug *mHwcDebug[HWC_NUM_DISPLAY_TYPES];
Ramkumar Radhakrishnandd38b822013-12-04 15:15:42 -0800641 hwc_rect_t mViewFrame[HWC_NUM_DISPLAY_TYPES];
Saurabh Shaha9da08f2013-07-03 13:27:53 -0700642 qhwc::AssertiveDisplay *mAD;
Ramkumar Radhakrishnana70981a2013-08-28 11:33:53 -0700643 eAnimationState mAnimationState[HWC_NUM_DISPLAY_TYPES];
Manoj Kumar AVM9591a5e2014-08-21 22:50:21 -0700644 qhwc::HWCVirtualVDS *mHWCVirtual;
Naseer Ahmedb1c76322012-10-17 00:32:50 -0400645
Raj Kamal9ed3d6b2014-02-07 16:15:17 +0530646 // stores the #numHwLayers of the previous frame
647 // for each display device
648 int mPrevHwLayerCount[HWC_NUM_DISPLAY_TYPES];
649
Ramkumar Radhakrishnana70981a2013-08-28 11:33:53 -0700650 // stores the primary device orientation
Ramkumar Radhakrishnan59a11072013-04-15 16:14:49 -0700651 int deviceOrientation;
Saurabh Shah56f610d2012-08-07 15:27:06 -0700652 //Securing in progress indicator
653 bool mSecuring;
Saurabh Shah56f610d2012-08-07 15:27:06 -0700654 //Display in secure mode indicator
655 bool mSecureMode;
Saurabh Shahb39f8152013-08-22 10:21:44 -0700656 //Lock to protect drawing data structures
657 mutable Locker mDrawLock;
Saurabh Shah0ceeb6a2013-04-23 10:46:07 -0700658 //Drawing round when we use GPU
659 bool isPaddingRound;
Tatenda Chipeperekwadc8d7082014-11-04 16:41:50 -0800660 // Used to mark composition cycle when DMA state change is required
661 bool isDMAStateChanging;
Arun Kumar K.Rffef7482013-04-10 14:17:22 -0700662 // External Orientation
663 int mExtOrientation;
Saurabh Shahd4e65852013-06-17 11:33:53 -0700664 //Flags the transition of a video session
665 bool mVideoTransFlag;
Arun Kumar K.Rfb5bfa62013-07-25 03:10:51 -0700666 //Used for SideSync feature
667 //which overrides the mExtOrientation
668 bool mBufferMirrorMode;
Raj kamal59fea562014-04-01 16:52:19 +0530669 // Used to synchronize between WFD and Display modules
670 mutable Locker mWfdSyncLock;
671
Amara Venkata Mastan Manoj Kumar7fb13272013-07-01 13:59:34 -0700672 qhwc::LayerRotMap *mLayerRotMap[HWC_NUM_DISPLAY_TYPES];
Veera Sankaran0dadfb32013-07-22 16:07:48 -0700673 // Panel reset flag will be set if BTA check fails
674 bool mPanelResetStatus;
Raj Kamal52b4fdb2014-01-27 19:35:13 +0530675 // number of active Displays
676 int numActiveDisplays;
Ramkumar Radhakrishnanfb822912014-03-14 17:28:14 -0700677 struct gpu_hint_info mGPUHintInfo;
Ramakant Singh0def28c2014-03-28 20:43:13 +0530678 //App Buffer Composition
679 bool enableABC;
Arun Kumar K.Rb2a03b12014-06-03 11:54:10 -0700680 // PTOR Info
681 qhwc::PtorInfo mPtorInfo;
Dileep Kumar Reddia25a9182014-07-24 20:01:44 +0530682 //Running in Thermal burst mode
683 bool mThermalBurstMode;
Dileep Kumar Reddi4070e932014-09-30 09:00:57 +0530684 //Layers out of ROI
685 bool copybitDrop[MAX_NUM_APP_LAYERS];
Ramkumar Radhakrishnanb33f4902014-10-03 16:46:35 -0700686 // Flag related to windowboxing feature
Ramkumar Radhakrishnan9d7bc312014-08-13 19:38:13 -0700687 bool mWindowboxFeature;
Ramkumar Radhakrishnan812999a2014-09-11 21:42:07 -0700688 // This denotes the tolerance between video layer and external display
689 // aspect ratio
690 float mAspectRatioToleranceLevel;
Saurabh Shahcd018352014-11-11 13:54:19 -0800691 // Runtime switch for BWC for targets that support it
692 bool mBWCEnabled;
Raj Kamal0d53fc62014-11-25 17:36:36 +0530693 // Provides a way for OEM's to disable setting dynfps via metadata.
694 bool mUseMetaDataRefreshRate;
Naseer Ahmed6bbd0a12015-01-23 11:57:10 -0500695 // Stores the hpd enabled status- avoids re-enabling HDP on suspend resume.
Arun Kumar K.R2225eaa2014-12-02 15:52:41 -0800696 bool mHPDEnabled;
Krishna Chaitanya Parimidb992fd2014-10-22 20:50:50 +0530697 //Used to notify that boot has completed
698 bool mBootAnimCompleted;
Naseer Ahmed7a7b66d2014-07-23 17:56:26 -0400699 // Display binder service
700 qService::QService* mQService;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700701};
702
Saurabh Shahacf10202013-02-26 10:15:15 -0800703namespace qhwc {
Saurabh Shahcbf7ccc2012-12-19 16:45:51 -0800704static inline bool isSkipPresent (hwc_context_t *ctx, int dpy) {
705 return ctx->listStats[dpy].skipCount;
706}
707
708static inline bool isYuvPresent (hwc_context_t *ctx, int dpy) {
709 return ctx->listStats[dpy].yuvCount;
710}
Saurabh Shahe9bc60f2013-08-29 12:58:06 -0700711
Ramkumar Radhakrishnan9d20b392013-11-15 19:32:47 -0800712static inline bool has90Transform(hwc_layer_1_t const* layer) {
Sushil Chauhan897a9c32013-07-18 11:09:55 -0700713 return ((layer->transform & HWC_TRANSFORM_ROT_90) &&
714 !(layer->flags & HWC_COLOR_FILL));
Saurabh Shahe9bc60f2013-08-29 12:58:06 -0700715}
716
Saurabh Shah8028e3b2013-10-15 12:27:59 -0700717inline bool isSecurePresent(hwc_context_t *ctx, int dpy) {
718 return ctx->listStats[dpy].isSecurePresent;
719}
720
Ramkumar Radhakrishnan8bb48d32013-12-30 23:11:27 -0800721static inline bool isSecondaryConfiguring(hwc_context_t* ctx) {
722 return (ctx->dpyAttr[HWC_DISPLAY_EXTERNAL].isConfiguring ||
723 ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].isConfiguring);
724}
725
726static inline bool isSecondaryConnected(hwc_context_t* ctx) {
727 return (ctx->dpyAttr[HWC_DISPLAY_EXTERNAL].connected ||
728 ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].connected);
729}
730
Manoj Kumar AVMfb472b02014-08-21 15:13:37 -0700731/* Return Virtual Display connection status */
732static inline bool isVDConnected(hwc_context_t* ctx) {
733 return ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].connected;
734}
735
Saurabh Shah514759d2014-11-11 18:02:24 -0800736inline uint32_t getLayerClock(const uint32_t& dstW, const uint32_t& dstH,
737 const uint32_t& srcH) {
738 return max(dstW, (srcH * dstW) / dstH);
739}
740
Saurabh Shahacf10202013-02-26 10:15:15 -0800741};
Saurabh Shahcbf7ccc2012-12-19 16:45:51 -0800742
Naseer Ahmed29a26812012-06-14 00:56:20 -0700743#endif //HWC_UTILS_H