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