hwc_utils.h revision 60712080d834941754dca8d34adac6bd355318ea 
1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 * Copyright (C)2012-2014, The Linux Foundation. All rights reserved.
4 *
5 * Not a Contribution, Apache license notifications and license are retained
6 * for attribution purposes only.
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 *      http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 */
20
21#ifndef HWC_UTILS_H
22#define HWC_UTILS_H
23
24#define HWC_REMOVE_DEPRECATED_VERSIONS 1
25#include <fcntl.h>
26#include <math.h>
27#include <hardware/hwcomposer.h>
28#include <gr.h>
29#include <gralloc_priv.h>
30#include <utils/String8.h>
31#include "qdMetaData.h"
32#include <overlayUtils.h>
33#include <EGL/egl.h>
34
35
36#define ALIGN_TO(x, align)     (((x) + ((align)-1)) & ~((align)-1))
37#define LIKELY( exp )       (__builtin_expect( (exp) != 0, true  ))
38#define UNLIKELY( exp )     (__builtin_expect( (exp) != 0, false ))
39#define MAX_NUM_APP_LAYERS 32
40#define MIN_DISPLAY_XRES 200
41#define MIN_DISPLAY_YRES 200
42#define HWC_WFDDISPSYNC_LOG 0
43#define STR(f) #f;
44// Max number of PTOR layers handled
45#define MAX_PTOR_LAYERS 2
46
47//Fwrd decls
48struct hwc_context_t;
49
50namespace ovutils = overlay::utils;
51
52namespace overlay {
53class Overlay;
54class Rotator;
55class RotMgr;
56}
57
58namespace qhwc {
59//fwrd decl
60class QueuedBufferStore;
61class ExternalDisplay;
62class VirtualDisplay;
63class IFBUpdate;
64class IVideoOverlay;
65class MDPComp;
66class CopyBit;
67class HwcDebug;
68class AssertiveDisplay;
69class HWCVirtualBase;
70
71
72struct MDPInfo {
73    int version;
74    char panel;
75    bool hasOverlay;
76};
77
78struct DisplayAttributes {
79    uint32_t vsync_period; //nanos
80    uint32_t xres;
81    uint32_t yres;
82    uint32_t stride;
83    float xdpi;
84    float ydpi;
85    int fd;
86    bool connected; //Applies only to pluggable disp.
87    //Connected does not mean it ready to use.
88    //It should be active also. (UNBLANKED)
89    bool isActive;
90    // In pause state, composition is bypassed
91    // used for WFD displays only
92    bool isPause;
93    // To trigger padding round to clean up mdp
94    // pipes
95    bool isConfiguring;
96    // External Display is in MDP Downscale mode indicator
97    bool mDownScaleMode;
98    // Ext dst Rect
99    hwc_rect_t mDstRect;
100    //Action safe attributes
101    // Flag to indicate the presence of action safe dimensions for external
102    bool mActionSafePresent;
103    int mAsWidthRatio;
104    int mAsHeightRatio;
105
106    //If property fbsize set via adb shell debug.hwc.fbsize = XRESxYRES
107    //following fields are used.
108    bool customFBSize;
109    uint32_t xres_new;
110    uint32_t yres_new;
111
112};
113
114struct ListStats {
115    int numAppLayers; //Total - 1, excluding FB layer.
116    int skipCount;
117    int fbLayerIndex; //Always last for now. = numAppLayers
118    //Video specific
119    int yuvCount;
120    int yuvIndices[MAX_NUM_APP_LAYERS];
121    int extOnlyLayerIndex;
122    bool preMultipliedAlpha;
123    int yuv4k2kIndices[MAX_NUM_APP_LAYERS];
124    int yuv4k2kCount;
125    // Notifies hwcomposer about the start and end of animation
126    // This will be set to true during animation, otherwise false.
127    bool isDisplayAnimating;
128    bool secureUI; // Secure display layer
129    bool isSecurePresent;
130    hwc_rect_t lRoi;  //left ROI
131    hwc_rect_t rRoi;  //right ROI. Unused in single DSI panels.
132    //App Buffer Composition index
133    int  renderBufIndexforABC;
134};
135
136//PTOR Comp info
137struct PtorInfo {
138    int count;
139    int layerIndex[MAX_PTOR_LAYERS];
140    int mRenderBuffOffset[MAX_PTOR_LAYERS];
141    hwc_rect_t displayFrame[MAX_PTOR_LAYERS];
142    bool isActive() { return (count>0); }
143    int getPTORArrayIndex(int index) {
144        int idx = -1;
145        for(int i = 0; i < count; i++) {
146            if(index == layerIndex[i])
147                idx = i;
148        }
149        return idx;
150    }
151};
152
153struct LayerProp {
154    uint32_t mFlags; //qcom specific layer flags
155    LayerProp():mFlags(0){};
156};
157
158struct VsyncState {
159    bool enable;
160    bool fakevsync;
161    bool debug;
162};
163
164struct BwcPM {
165    static void setBwc(const hwc_rect_t& crop,
166            const hwc_rect_t& dst, const int& transform,
167            ovutils::eMdpFlags& mdpFlags);
168};
169
170// LayerProp::flag values
171enum {
172    HWC_MDPCOMP = 0x00000001,
173    HWC_COPYBIT = 0x00000002,
174};
175
176// HAL specific features
177enum {
178    HWC_COLOR_FILL = 0x00000008,
179    HWC_FORMAT_RB_SWAP = 0x00000040,
180};
181
182/* External Display states */
183enum {
184    EXTERNAL_OFFLINE = 0,
185    EXTERNAL_ONLINE,
186    EXTERNAL_PAUSE,
187    EXTERNAL_RESUME,
188    EXTERNAL_MAXSTATES
189};
190
191class LayerRotMap {
192public:
193    LayerRotMap() { reset(); }
194    enum { MAX_SESS = 3 };
195    void add(hwc_layer_1_t* layer, overlay::Rotator *rot);
196    //Resets the mapping of layer to rotator
197    void reset();
198    //Clears mappings and existing rotator fences
199    //Intended to be used during errors
200    void clear();
201    uint32_t getCount() const;
202    hwc_layer_1_t* getLayer(uint32_t index) const;
203    overlay::Rotator* getRot(uint32_t index) const;
204    void setReleaseFd(const int& fence);
205private:
206    hwc_layer_1_t* mLayer[MAX_SESS];
207    overlay::Rotator* mRot[MAX_SESS];
208    uint32_t mCount;
209};
210
211inline uint32_t LayerRotMap::getCount() const {
212    return mCount;
213}
214
215inline hwc_layer_1_t* LayerRotMap::getLayer(uint32_t index) const {
216    if(index >= mCount) return NULL;
217    return mLayer[index];
218}
219
220inline overlay::Rotator* LayerRotMap::getRot(uint32_t index) const {
221    if(index >= mCount) return NULL;
222    return mRot[index];
223}
224
225inline hwc_rect_t integerizeSourceCrop(const hwc_frect_t& cropF) {
226    hwc_rect_t cropI = {0,0,0,0};
227    cropI.left = int(ceilf(cropF.left));
228    cropI.top = int(ceilf(cropF.top));
229    cropI.right = int(floorf(cropF.right));
230    cropI.bottom = int(floorf(cropF.bottom));
231    return cropI;
232}
233
234inline bool isNonIntegralSourceCrop(const hwc_frect_t& cropF) {
235    if(cropF.left - roundf(cropF.left)     ||
236       cropF.top - roundf(cropF.top)       ||
237       cropF.right - roundf(cropF.right)   ||
238       cropF.bottom - roundf(cropF.bottom))
239        return true;
240    else
241        return false;
242}
243
244// -----------------------------------------------------------------------------
245// Utility functions - implemented in hwc_utils.cpp
246void dumpLayer(hwc_layer_1_t const* l);
247void setListStats(hwc_context_t *ctx, hwc_display_contents_1_t *list,
248        int dpy);
249void initContext(hwc_context_t *ctx);
250void closeContext(hwc_context_t *ctx);
251//Crops source buffer against destination and FB boundaries
252void calculate_crop_rects(hwc_rect_t& crop, hwc_rect_t& dst,
253                         const hwc_rect_t& scissor, int orient);
254void getNonWormholeRegion(hwc_display_contents_1_t* list,
255                              hwc_rect_t& nwr);
256bool isSecuring(hwc_context_t* ctx, hwc_layer_1_t const* layer);
257bool isSecureModePolicy(int mdpVersion);
258// Returns true, if the input layer format is supported by rotator
259bool isRotatorSupportedFormat(private_handle_t *hnd);
260//Returns true, if the layer is YUV or the layer has been rendered by CPU
261bool isRotationDoable(hwc_context_t *ctx, private_handle_t *hnd);
262bool isExternalActive(hwc_context_t* ctx);
263bool isAlphaScaled(hwc_layer_1_t const* layer);
264bool needsScaling(hwc_layer_1_t const* layer);
265bool isDownscaleRequired(hwc_layer_1_t const* layer);
266bool needsScalingWithSplit(hwc_context_t* ctx, hwc_layer_1_t const* layer,
267                           const int& dpy);
268void sanitizeSourceCrop(hwc_rect_t& cropL, hwc_rect_t& cropR,
269                        private_handle_t *hnd);
270bool isAlphaPresent(hwc_layer_1_t const* layer);
271int hwc_vsync_control(hwc_context_t* ctx, int dpy, int enable);
272int getBlending(int blending);
273bool isGLESOnlyComp(hwc_context_t *ctx, const int& dpy);
274void reset_layer_prop(hwc_context_t* ctx, int dpy, int numAppLayers);
275bool isAbcInUse(hwc_context_t *ctx);
276
277void dumpBuffer(private_handle_t *ohnd, char *bufferName);
278
279//Helper function to dump logs
280void dumpsys_log(android::String8& buf, const char* fmt, ...);
281
282int getExtOrientation(hwc_context_t* ctx);
283bool isValidRect(const hwc_rect_t& rect);
284hwc_rect_t deductRect(const hwc_rect_t& rect1, const hwc_rect_t& rect2);
285bool isSameRect(const hwc_rect& rect1, const hwc_rect& rect2);
286hwc_rect_t moveRect(const hwc_rect_t& rect, const int& x_off, const int& y_off);
287hwc_rect_t getIntersection(const hwc_rect_t& rect1, const hwc_rect_t& rect2);
288hwc_rect_t getUnion(const hwc_rect_t& rect1, const hwc_rect_t& rect2);
289void optimizeLayerRects(const hwc_display_contents_1_t *list);
290bool areLayersIntersecting(const hwc_layer_1_t* layer1,
291        const hwc_layer_1_t* layer2);
292bool operator ==(const hwc_rect_t& lhs, const hwc_rect_t& rhs);
293
294// returns true if Action safe dimensions are set and target supports Actionsafe
295bool isActionSafePresent(hwc_context_t *ctx, int dpy);
296
297/* Calculates the destination position based on the action safe rectangle */
298void getActionSafePosition(hwc_context_t *ctx, int dpy, hwc_rect_t& dst);
299
300void getAspectRatioPosition(hwc_context_t* ctx, int dpy, int extOrientation,
301                                hwc_rect_t& inRect, hwc_rect_t& outRect);
302
303bool isPrimaryPortrait(hwc_context_t *ctx);
304
305bool isOrientationPortrait(hwc_context_t *ctx);
306
307void calcExtDisplayPosition(hwc_context_t *ctx,
308                               private_handle_t *hnd,
309                               int dpy,
310                               hwc_rect_t& sourceCrop,
311                               hwc_rect_t& displayFrame,
312                               int& transform,
313                               ovutils::eTransform& orient);
314
315// Returns the orientation that needs to be set on external for
316// BufferMirrirMode(Sidesync)
317int getMirrorModeOrientation(hwc_context_t *ctx);
318
319/* Get External State names */
320const char* getExternalDisplayState(uint32_t external_state);
321
322// Resets display ROI to full panel resoluion
323void resetROI(hwc_context_t *ctx, const int dpy);
324
325// Aligns updating ROI to panel restrictions
326hwc_rect_t getSanitizeROI(struct hwc_rect roi, hwc_rect boundary);
327
328// Handles wfd Pause and resume events
329void handle_pause(hwc_context_t *ctx, int dpy);
330void handle_resume(hwc_context_t *ctx, int dpy);
331
332//Close acquireFenceFds of all layers of incoming list
333void closeAcquireFds(hwc_display_contents_1_t* list);
334
335//Sync point impl.
336int hwc_sync(hwc_context_t *ctx, hwc_display_contents_1_t* list, int dpy,
337        int fd);
338
339//Sets appropriate mdp flags for a layer.
340void setMdpFlags(hwc_context_t *ctx, hwc_layer_1_t *layer,
341        ovutils::eMdpFlags &mdpFlags,
342        int rotDownscale, int transform);
343
344int configRotator(overlay::Rotator *rot, ovutils::Whf& whf,
345        hwc_rect_t& crop, const ovutils::eMdpFlags& mdpFlags,
346        const ovutils::eTransform& orient, const int& downscale);
347
348int configMdp(overlay::Overlay *ov, const ovutils::PipeArgs& parg,
349        const ovutils::eTransform& orient, const hwc_rect_t& crop,
350        const hwc_rect_t& pos, const MetaData_t *metadata,
351        const ovutils::eDest& dest);
352
353int configColorLayer(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy,
354        ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
355        ovutils::eIsFg& isFg, const ovutils::eDest& dest);
356
357void updateSource(ovutils::eTransform& orient, ovutils::Whf& whf,
358        hwc_rect_t& crop, overlay::Rotator *rot);
359
360//Routine to configure low resolution panels (<= 2048 width)
361int configureNonSplit(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy,
362        ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
363        ovutils::eIsFg& isFg, const ovutils::eDest& dest,
364        overlay::Rotator **rot);
365
366//Routine to configure high resolution panels (> 2048 width)
367int configureSplit(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy,
368        ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
369        ovutils::eIsFg& isFg, const ovutils::eDest& lDest,
370        const ovutils::eDest& rDest, overlay::Rotator **rot);
371
372//Routine to split and configure high resolution YUV layer (> 2048 width)
373int configureSourceSplit(hwc_context_t *ctx, hwc_layer_1_t *layer,
374        const int& dpy,
375        ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
376        ovutils::eIsFg& isFg, const ovutils::eDest& lDest,
377        const ovutils::eDest& rDest, overlay::Rotator **rot);
378
379//On certain targets DMA pipes are used for rotation and they won't be available
380//for line operations. On a per-target basis we can restrict certain use cases
381//from using rotator, since we know before-hand that such scenarios can lead to
382//extreme unavailability of pipes. This can also be done via hybrid calculations
383//also involving many more variables like number of write-back interfaces etc,
384//but the variety of scenarios is too high to warrant that.
385bool canUseRotator(hwc_context_t *ctx, int dpy);
386
387int getLeftSplit(hwc_context_t *ctx, const int& dpy);
388
389bool isDisplaySplit(hwc_context_t* ctx, int dpy);
390
391// Set the GPU hint flag to high for MIXED/GPU composition only for
392// first frame after MDP to GPU/MIXED mode transition.
393// Set the GPU hint to default if the current composition type is GPU
394// due to idle fallback or MDP composition.
395void setGPUHint(hwc_context_t* ctx, hwc_display_contents_1_t* list);
396
397// Returns true if rect1 is peripheral to rect2, false otherwise.
398bool isPeripheral(const hwc_rect_t& rect1, const hwc_rect_t& rect2);
399
400// Inline utility functions
401static inline bool isSkipLayer(const hwc_layer_1_t* l) {
402    return (UNLIKELY(l && (l->flags & HWC_SKIP_LAYER)));
403}
404
405// Returns true if the buffer is yuv
406static inline bool isYuvBuffer(const private_handle_t* hnd) {
407    return (hnd && (hnd->bufferType == BUFFER_TYPE_VIDEO));
408}
409
410// Returns true if the buffer is yuv
411static inline bool is4kx2kYuvBuffer(const private_handle_t* hnd) {
412    return (hnd && (hnd->bufferType == BUFFER_TYPE_VIDEO) &&
413            (hnd->width > 2048));
414}
415
416// Returns true if the buffer is secure
417static inline bool isSecureBuffer(const private_handle_t* hnd) {
418    return (hnd && (private_handle_t::PRIV_FLAGS_SECURE_BUFFER & hnd->flags));
419}
420
421static inline bool isTileRendered(const private_handle_t* hnd) {
422    return (hnd && (private_handle_t::PRIV_FLAGS_TILE_RENDERED & hnd->flags));
423}
424
425static inline bool isCPURendered(const private_handle_t* hnd) {
426    return (hnd && (private_handle_t::PRIV_FLAGS_CPU_RENDERED & hnd->flags));
427}
428
429//Return true if buffer is marked locked
430static inline bool isBufferLocked(const private_handle_t* hnd) {
431    return (hnd && (private_handle_t::PRIV_FLAGS_HWC_LOCK & hnd->flags));
432}
433
434//Return true if buffer is for external display only
435static inline bool isExtOnly(const private_handle_t* hnd) {
436    return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_ONLY));
437}
438
439//Return true if the buffer is intended for Secure Display
440static inline bool isSecureDisplayBuffer(const private_handle_t* hnd) {
441    return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY));
442}
443
444static inline int getWidth(const private_handle_t* hnd) {
445    if(isYuvBuffer(hnd)) {
446        MetaData_t *metadata = reinterpret_cast<MetaData_t*>(hnd->base_metadata);
447        if(metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
448            return metadata->bufferDim.sliceWidth;
449        }
450    }
451    return hnd->width;
452}
453
454static inline int getHeight(const private_handle_t* hnd) {
455    if(isYuvBuffer(hnd)) {
456        MetaData_t *metadata = reinterpret_cast<MetaData_t*>(hnd->base_metadata);
457        if(metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
458            return metadata->bufferDim.sliceHeight;
459        }
460    }
461    return hnd->height;
462}
463
464template<typename T> inline T max(T a, T b) { return (a > b) ? a : b; }
465template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; }
466
467// Initialize uevent thread
468void init_uevent_thread(hwc_context_t* ctx);
469// Initialize vsync thread
470void init_vsync_thread(hwc_context_t* ctx);
471
472inline void getLayerResolution(const hwc_layer_1_t* layer,
473                               int& width, int& height) {
474    hwc_rect_t displayFrame  = layer->displayFrame;
475    width = displayFrame.right - displayFrame.left;
476    height = displayFrame.bottom - displayFrame.top;
477}
478
479static inline int openFb(int dpy) {
480    int fd = -1;
481    const char *devtmpl = "/dev/graphics/fb%u";
482    char name[64] = {0};
483    snprintf(name, 64, devtmpl, dpy);
484    fd = open(name, O_RDWR);
485    return fd;
486}
487
488template <class T>
489inline void swap(T& a, T& b) {
490    T tmp = a;
491    a = b;
492    b = tmp;
493}
494
495}; //qhwc namespace
496
497enum eAnimationState{
498    ANIMATION_STOPPED,
499    ANIMATION_STARTED,
500};
501
502enum eCompositionState {
503    COMPOSITION_STATE_MDP = 0,        // Set if composition type is MDP
504    COMPOSITION_STATE_GPU,            // Set if composition type is GPU or MIXED
505    COMPOSITION_STATE_IDLE_FALLBACK,  // Set if it is idlefallback
506};
507
508// Structure holds the information about the GPU hint.
509struct gpu_hint_info {
510    // system level flag to enable gpu_perf_mode
511    bool mGpuPerfModeEnable;
512    // Stores the current GPU performance mode DEFAULT/HIGH
513    bool mCurrGPUPerfMode;
514    // Stores the compositon state GPU, MDP or IDLE_FALLBACK
515    bool mCompositionState;
516    // Stores the EGLContext of current process
517    EGLContext mEGLContext;
518    // Stores the EGLDisplay of current process
519    EGLDisplay mEGLDisplay;
520};
521
522// -----------------------------------------------------------------------------
523// HWC context
524// This structure contains overall state
525struct hwc_context_t {
526    hwc_composer_device_1_t device;
527    const hwc_procs_t* proc;
528
529    //CopyBit objects
530    qhwc::CopyBit *mCopyBit[HWC_NUM_DISPLAY_TYPES];
531
532    //Overlay object - NULL for non overlay devices
533    overlay::Overlay *mOverlay;
534    //Holds a few rot objects
535    overlay::RotMgr *mRotMgr;
536
537    //Primary and external FB updater
538    qhwc::IFBUpdate *mFBUpdate[HWC_NUM_DISPLAY_TYPES];
539    // External display related information
540    qhwc::ExternalDisplay *mExtDisplay;
541    qhwc::VirtualDisplay *mVirtualDisplay;
542    qhwc::MDPInfo mMDP;
543    qhwc::VsyncState vstate;
544    qhwc::DisplayAttributes dpyAttr[HWC_NUM_DISPLAY_TYPES];
545    qhwc::ListStats listStats[HWC_NUM_DISPLAY_TYPES];
546    qhwc::LayerProp *layerProp[HWC_NUM_DISPLAY_TYPES];
547    qhwc::MDPComp *mMDPComp[HWC_NUM_DISPLAY_TYPES];
548    qhwc::HwcDebug *mHwcDebug[HWC_NUM_DISPLAY_TYPES];
549    hwc_rect_t mViewFrame[HWC_NUM_DISPLAY_TYPES];
550    qhwc::AssertiveDisplay *mAD;
551    eAnimationState mAnimationState[HWC_NUM_DISPLAY_TYPES];
552    qhwc::HWCVirtualBase *mHWCVirtual;
553
554    // stores the #numHwLayers of the previous frame
555    // for each display device
556    int mPrevHwLayerCount[HWC_NUM_DISPLAY_TYPES];
557
558    // stores the primary device orientation
559    int deviceOrientation;
560    //Securing in progress indicator
561    bool mSecuring;
562    //WFD on proprietary stack
563    bool mVirtualonExtActive;
564    //Display in secure mode indicator
565    bool mSecureMode;
566    //Lock to protect drawing data structures
567    mutable Locker mDrawLock;
568    //Drawing round when we use GPU
569    bool isPaddingRound;
570    // External Orientation
571    int mExtOrientation;
572    //Flags the transition of a video session
573    bool mVideoTransFlag;
574    //Used for SideSync feature
575    //which overrides the mExtOrientation
576    bool mBufferMirrorMode;
577    // Used to synchronize between WFD and Display modules
578    mutable Locker mWfdSyncLock;
579
580    qhwc::LayerRotMap *mLayerRotMap[HWC_NUM_DISPLAY_TYPES];
581    // Panel reset flag will be set if BTA check fails
582    bool mPanelResetStatus;
583    // number of active Displays
584    int numActiveDisplays;
585    // Downscale feature switch, set via system property
586    // sys.hwc.mdp_downscale_enabled
587    bool mMDPDownscaleEnabled;
588    // Is WFD enabled through VDS solution ?
589    // This can be set via system property
590    // persist.hwc.enable_vds
591    bool mVDSEnabled;
592    struct gpu_hint_info mGPUHintInfo;
593    //App Buffer Composition
594    bool enableABC;
595    // PTOR Info
596    qhwc::PtorInfo mPtorInfo;
597};
598
599namespace qhwc {
600static inline bool isSkipPresent (hwc_context_t *ctx, int dpy) {
601    return  ctx->listStats[dpy].skipCount;
602}
603
604static inline bool isYuvPresent (hwc_context_t *ctx, int dpy) {
605    return  ctx->listStats[dpy].yuvCount;
606}
607
608static inline bool has90Transform(hwc_layer_1_t const* layer) {
609    return ((layer->transform & HWC_TRANSFORM_ROT_90) &&
610            !(layer->flags & HWC_COLOR_FILL));
611}
612
613inline bool isSecurePresent(hwc_context_t *ctx, int dpy) {
614    return ctx->listStats[dpy].isSecurePresent;
615}
616
617static inline bool isSecondaryConfiguring(hwc_context_t* ctx) {
618    return (ctx->dpyAttr[HWC_DISPLAY_EXTERNAL].isConfiguring ||
619            ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].isConfiguring);
620}
621
622static inline bool isSecondaryConnected(hwc_context_t* ctx) {
623    return (ctx->dpyAttr[HWC_DISPLAY_EXTERNAL].connected ||
624            ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].connected);
625}
626
627};
628
629#endif //HWC_UTILS_H
630