hwc_utils.h revision 456d555b1dc25dd1891ab7e38494d057b6bdf82e 
1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 * Copyright (C)2012-2013, 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
34#define ALIGN_TO(x, align)     (((x) + ((align)-1)) & ~((align)-1))
35#define LIKELY( exp )       (__builtin_expect( (exp) != 0, true  ))
36#define UNLIKELY( exp )     (__builtin_expect( (exp) != 0, false ))
37#define MAX_NUM_APP_LAYERS 32
38
39//Fwrd decls
40struct hwc_context_t;
41
42namespace ovutils = overlay::utils;
43
44namespace overlay {
45class Overlay;
46class Rotator;
47class RotMgr;
48}
49
50namespace qhwc {
51//fwrd decl
52class QueuedBufferStore;
53class ExternalDisplay;
54class VirtualDisplay;
55class IFBUpdate;
56class IVideoOverlay;
57class MDPComp;
58class CopyBit;
59class HwcDebug;
60class AssertiveDisplay;
61class VPUClient;
62
63
64struct MDPInfo {
65    int version;
66    char panel;
67    bool hasOverlay;
68};
69
70struct DisplayAttributes {
71    uint32_t vsync_period; //nanos
72    uint32_t xres;
73    uint32_t yres;
74    uint32_t stride;
75    float xdpi;
76    float ydpi;
77    int fd;
78    bool connected; //Applies only to pluggable disp.
79    //Connected does not mean it ready to use.
80    //It should be active also. (UNBLANKED)
81    bool isActive;
82    // In pause state, composition is bypassed
83    // used for WFD displays only
84    bool isPause;
85    // To trigger padding round to clean up mdp
86    // pipes
87    bool isConfiguring;
88    // External Display is in MDP Downscale mode indicator
89    bool mDownScaleMode;
90};
91
92struct ListStats {
93    int numAppLayers; //Total - 1, excluding FB layer.
94    int skipCount;
95    int fbLayerIndex; //Always last for now. = numAppLayers
96    //Video specific
97    int yuvCount;
98    int yuvIndices[MAX_NUM_APP_LAYERS];
99    int extOnlyLayerIndex;
100    bool needsAlphaScale;
101    bool preMultipliedAlpha;
102    int yuv4k2kIndices[MAX_NUM_APP_LAYERS];
103    int yuv4k2kCount;
104    // Notifies hwcomposer about the start and end of animation
105    // This will be set to true during animation, otherwise false.
106    bool isDisplayAnimating;
107    ovutils::Dim roi;
108    bool secureUI; // Secure display layer
109    bool isSecurePresent;
110};
111
112struct LayerProp {
113    uint32_t mFlags; //qcom specific layer flags
114    LayerProp():mFlags(0){};
115};
116
117struct VsyncState {
118    bool enable;
119    bool fakevsync;
120};
121
122struct BwcPM {
123    static void setBwc(hwc_context_t *ctx, const hwc_rect_t& crop,
124            const hwc_rect_t& dst, const int& transform,
125            ovutils::eMdpFlags& mdpFlags);
126};
127
128// LayerProp::flag values
129enum {
130    HWC_MDPCOMP = 0x00000001,
131    HWC_COPYBIT = 0x00000002,
132};
133
134// HAL specific features
135enum {
136    HWC_COLOR_FILL = 0x00000008,
137    HWC_FORMAT_RB_SWAP = 0x00000040,
138};
139
140class LayerRotMap {
141public:
142    LayerRotMap() { reset(); }
143    enum { MAX_SESS = 3 };
144    void add(hwc_layer_1_t* layer, overlay::Rotator *rot);
145    //Resets the mapping of layer to rotator
146    void reset();
147    //Clears mappings and existing rotator fences
148    //Intended to be used during errors
149    void clear();
150    uint32_t getCount() const;
151    hwc_layer_1_t* getLayer(uint32_t index) const;
152    overlay::Rotator* getRot(uint32_t index) const;
153    void setReleaseFd(const int& fence);
154private:
155    hwc_layer_1_t* mLayer[MAX_SESS];
156    overlay::Rotator* mRot[MAX_SESS];
157    uint32_t mCount;
158};
159
160inline uint32_t LayerRotMap::getCount() const {
161    return mCount;
162}
163
164inline hwc_layer_1_t* LayerRotMap::getLayer(uint32_t index) const {
165    if(index >= mCount) return NULL;
166    return mLayer[index];
167}
168
169inline overlay::Rotator* LayerRotMap::getRot(uint32_t index) const {
170    if(index >= mCount) return NULL;
171    return mRot[index];
172}
173
174inline hwc_rect_t integerizeSourceCrop(const hwc_frect_t& cropF) {
175    hwc_rect_t cropI = {0};
176    cropI.left = int(ceilf(cropF.left));
177    cropI.top = int(ceilf(cropF.top));
178    cropI.right = int(floorf(cropF.right));
179    cropI.bottom = int(floorf(cropF.bottom));
180    return cropI;
181}
182
183inline bool isNonIntegralSourceCrop(const hwc_frect_t& cropF) {
184    if(cropF.left - roundf(cropF.left)     ||
185       cropF.top - roundf(cropF.top)       ||
186       cropF.right - roundf(cropF.right)   ||
187       cropF.bottom - roundf(cropF.bottom))
188        return true;
189    else
190        return false;
191}
192
193// -----------------------------------------------------------------------------
194// Utility functions - implemented in hwc_utils.cpp
195void dumpLayer(hwc_layer_1_t const* l);
196void setListStats(hwc_context_t *ctx, hwc_display_contents_1_t *list,
197        int dpy);
198void initContext(hwc_context_t *ctx);
199void closeContext(hwc_context_t *ctx);
200//Crops source buffer against destination and FB boundaries
201void calculate_crop_rects(hwc_rect_t& crop, hwc_rect_t& dst,
202                         const hwc_rect_t& scissor, int orient);
203void getNonWormholeRegion(hwc_display_contents_1_t* list,
204                              hwc_rect_t& nwr);
205bool isSecuring(hwc_context_t* ctx, hwc_layer_1_t const* layer);
206bool isSecureModePolicy(int mdpVersion);
207bool isExternalActive(hwc_context_t* ctx);
208bool needsScaling(hwc_context_t* ctx, hwc_layer_1_t const* layer,
209                  const int& dpy);
210bool needsScalingWithSplit(hwc_context_t* ctx, hwc_layer_1_t const* layer,
211                           const int& dpy);
212void sanitizeSourceCrop(hwc_rect_t& cropL, hwc_rect_t& cropR,
213                        private_handle_t *hnd);
214bool isAlphaPresent(hwc_layer_1_t const* layer);
215int hwc_vsync_control(hwc_context_t* ctx, int dpy, int enable);
216int getBlending(int blending);
217
218//Helper function to dump logs
219void dumpsys_log(android::String8& buf, const char* fmt, ...);
220
221int getExtOrientation(hwc_context_t* ctx);
222bool isValidRect(const hwc_rect_t& rect);
223hwc_rect_t deductRect(const hwc_rect_t& rect1, const hwc_rect_t& rect2);
224hwc_rect_t getIntersection(const hwc_rect_t& rect1, const hwc_rect_t& rect2);
225hwc_rect_t getUnion(const hwc_rect_t& rect1, const hwc_rect_t& rect2);
226void optimizeLayerRects(hwc_context_t *ctx,
227        const hwc_display_contents_1_t *list, const int& dpy);
228bool areLayersIntersecting(const hwc_layer_1_t* layer1,
229        const hwc_layer_1_t* layer2);
230
231/* Calculates the destination position based on the action safe rectangle */
232void getActionSafePosition(hwc_context_t *ctx, int dpy, hwc_rect_t& dst);
233
234void getAspectRatioPosition(int destWidth, int destHeight, int srcWidth,
235                                int srcHeight, hwc_rect_t& rect);
236
237void getAspectRatioPosition(hwc_context_t* ctx, int dpy, int extOrientation,
238                                hwc_rect_t& inRect, hwc_rect_t& outRect);
239
240bool isPrimaryPortrait(hwc_context_t *ctx);
241
242bool isOrientationPortrait(hwc_context_t *ctx);
243
244void calcExtDisplayPosition(hwc_context_t *ctx,
245                               private_handle_t *hnd,
246                               int dpy,
247                               hwc_rect_t& sourceCrop,
248                               hwc_rect_t& displayFrame,
249                               int& transform,
250                               ovutils::eTransform& orient);
251
252// Returns the orientation that needs to be set on external for
253// BufferMirrirMode(Sidesync)
254int getMirrorModeOrientation(hwc_context_t *ctx);
255
256//Close acquireFenceFds of all layers of incoming list
257void closeAcquireFds(hwc_display_contents_1_t* list);
258
259//Sync point impl.
260int hwc_sync(hwc_context_t *ctx, hwc_display_contents_1_t* list, int dpy,
261        int fd);
262
263//Sets appropriate mdp flags for a layer.
264void setMdpFlags(hwc_layer_1_t *layer,
265        ovutils::eMdpFlags &mdpFlags,
266        int rotDownscale, int transform);
267
268int configRotator(overlay::Rotator *rot, ovutils::Whf& whf,
269        hwc_rect_t& crop, const ovutils::eMdpFlags& mdpFlags,
270        const ovutils::eTransform& orient, const int& downscale);
271
272int configMdp(overlay::Overlay *ov, const ovutils::PipeArgs& parg,
273        const ovutils::eTransform& orient, const hwc_rect_t& crop,
274        const hwc_rect_t& pos, const MetaData_t *metadata,
275        const ovutils::eDest& dest);
276
277int configColorLayer(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy,
278        ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
279        ovutils::eIsFg& isFg, const ovutils::eDest& dest);
280
281void updateSource(ovutils::eTransform& orient, ovutils::Whf& whf,
282        hwc_rect_t& crop);
283
284//Routine to configure low resolution panels (<= 2048 width)
285int configureNonSplit(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy,
286        ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
287        ovutils::eIsFg& isFg, const ovutils::eDest& dest,
288        overlay::Rotator **rot);
289
290//Routine to configure high resolution panels (> 2048 width)
291int configureSplit(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy,
292        ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
293        ovutils::eIsFg& isFg, const ovutils::eDest& lDest,
294        const ovutils::eDest& rDest, overlay::Rotator **rot);
295
296//Routine to split and configure high resolution YUV layer (> 2048 width)
297int configureSourceSplit(hwc_context_t *ctx, hwc_layer_1_t *layer,
298        const int& dpy,
299        ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
300        ovutils::eIsFg& isFg, const ovutils::eDest& lDest,
301        const ovutils::eDest& rDest, overlay::Rotator **rot);
302
303//On certain targets DMA pipes are used for rotation and they won't be available
304//for line operations. On a per-target basis we can restrict certain use cases
305//from using rotator, since we know before-hand that such scenarios can lead to
306//extreme unavailability of pipes. This can also be done via hybrid calculations
307//also involving many more variables like number of write-back interfaces etc,
308//but the variety of scenarios is too high to warrant that.
309bool canUseRotator(hwc_context_t *ctx, int dpy);
310
311int getLeftSplit(hwc_context_t *ctx, const int& dpy);
312
313bool isDisplaySplit(hwc_context_t* ctx, int dpy);
314
315// Inline utility functions
316static inline bool isSkipLayer(const hwc_layer_1_t* l) {
317    return (UNLIKELY(l && (l->flags & HWC_SKIP_LAYER)));
318}
319
320// Returns true if the buffer is yuv
321static inline bool isYuvBuffer(const private_handle_t* hnd) {
322    return (hnd && (hnd->bufferType == BUFFER_TYPE_VIDEO));
323}
324
325// Returns true if the buffer is yuv
326static inline bool is4kx2kYuvBuffer(const private_handle_t* hnd) {
327    return (hnd && (hnd->bufferType == BUFFER_TYPE_VIDEO) &&
328            (hnd->width > 2048));
329}
330
331// Returns true if the buffer is secure
332static inline bool isSecureBuffer(const private_handle_t* hnd) {
333    return (hnd && (private_handle_t::PRIV_FLAGS_SECURE_BUFFER & hnd->flags));
334}
335//Return true if buffer is marked locked
336static inline bool isBufferLocked(const private_handle_t* hnd) {
337    return (hnd && (private_handle_t::PRIV_FLAGS_HWC_LOCK & hnd->flags));
338}
339
340//Return true if buffer is for external display only
341static inline bool isExtOnly(const private_handle_t* hnd) {
342    return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_ONLY));
343}
344
345//Return true if buffer is for external display only with a BLOCK flag.
346static inline bool isExtBlock(const private_handle_t* hnd) {
347    return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_BLOCK));
348}
349
350//Return true if buffer is for external display only with a Close Caption flag.
351static inline bool isExtCC(const private_handle_t* hnd) {
352    return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_CC));
353}
354
355//Return true if the buffer is intended for Secure Display
356static inline bool isSecureDisplayBuffer(const private_handle_t* hnd) {
357    return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY));
358}
359
360static inline int getWidth(const private_handle_t* hnd) {
361    if(isYuvBuffer(hnd)) {
362        MetaData_t *metadata = (MetaData_t *)hnd->base_metadata;
363        if(metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
364            return metadata->bufferDim.sliceWidth;
365        }
366    }
367    return hnd->width;
368}
369
370static inline int getHeight(const private_handle_t* hnd) {
371    if(isYuvBuffer(hnd)) {
372        MetaData_t *metadata = (MetaData_t *)hnd->base_metadata;
373        if(metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
374            return metadata->bufferDim.sliceHeight;
375        }
376    }
377    return hnd->height;
378}
379
380template<typename T> inline T max(T a, T b) { return (a > b) ? a : b; }
381template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; }
382
383// Initialize uevent thread
384void init_uevent_thread(hwc_context_t* ctx);
385// Initialize vsync thread
386void init_vsync_thread(hwc_context_t* ctx);
387
388inline void getLayerResolution(const hwc_layer_1_t* layer,
389                               int& width, int& height) {
390    hwc_rect_t displayFrame  = layer->displayFrame;
391    width = displayFrame.right - displayFrame.left;
392    height = displayFrame.bottom - displayFrame.top;
393}
394
395static inline int openFb(int dpy) {
396    int fd = -1;
397    const char *devtmpl = "/dev/graphics/fb%u";
398    char name[64] = {0};
399    snprintf(name, 64, devtmpl, dpy);
400    fd = open(name, O_RDWR);
401    return fd;
402}
403
404template <class T>
405inline void swap(T& a, T& b) {
406    T tmp = a;
407    a = b;
408    b = tmp;
409}
410
411}; //qhwc namespace
412
413// -----------------------------------------------------------------------------
414// HWC context
415// This structure contains overall state
416struct hwc_context_t {
417    hwc_composer_device_1_t device;
418    const hwc_procs_t* proc;
419
420    //CopyBit objects
421    qhwc::CopyBit *mCopyBit[HWC_NUM_DISPLAY_TYPES];
422
423    //Overlay object - NULL for non overlay devices
424    overlay::Overlay *mOverlay;
425    //Holds a few rot objects
426    overlay::RotMgr *mRotMgr;
427
428    //Primary and external FB updater
429    qhwc::IFBUpdate *mFBUpdate[HWC_NUM_DISPLAY_TYPES];
430    // External display related information
431    qhwc::ExternalDisplay *mExtDisplay;
432    qhwc::VirtualDisplay *mVirtualDisplay;
433    qhwc::MDPInfo mMDP;
434    qhwc::VsyncState vstate;
435    qhwc::DisplayAttributes dpyAttr[HWC_NUM_DISPLAY_TYPES];
436    qhwc::ListStats listStats[HWC_NUM_DISPLAY_TYPES];
437    qhwc::LayerProp *layerProp[HWC_NUM_DISPLAY_TYPES];
438    qhwc::MDPComp *mMDPComp[HWC_NUM_DISPLAY_TYPES];
439    qhwc::HwcDebug *mHwcDebug[HWC_NUM_DISPLAY_TYPES];
440    hwc_rect_t mViewFrame[HWC_NUM_DISPLAY_TYPES];
441    qhwc::AssertiveDisplay *mAD;
442    qhwc::VPUClient *mVPUClient;
443
444    // No animation on External display feature
445    // Notifies hwcomposer about the device orientation before animation.
446    int deviceOrientation;
447    // Stores the crop, dest rect and transform value of video before animation.
448    hwc_rect_t mPrevCropVideo;
449    hwc_rect_t mPrevDestVideo;
450    int mPrevTransformVideo;
451    //Securing in progress indicator
452    bool mSecuring;
453    //WFD on proprietary stack
454    bool mVirtualonExtActive;
455    //Display in secure mode indicator
456    bool mSecureMode;
457    //Lock to protect drawing data structures
458    mutable Locker mDrawLock;
459    //Drawing round when we use GPU
460    bool isPaddingRound;
461    // External Orientation
462    int mExtOrientation;
463    //Flags the transition of a video session
464    bool mVideoTransFlag;
465
466    //Used for SideSync feature
467    //which overrides the mExtOrientation
468    bool mBufferMirrorMode;
469
470    qhwc::LayerRotMap *mLayerRotMap[HWC_NUM_DISPLAY_TYPES];
471
472    // Panel reset flag will be set if BTA check fails
473    bool mPanelResetStatus;
474};
475
476namespace qhwc {
477static inline bool isSkipPresent (hwc_context_t *ctx, int dpy) {
478    return  ctx->listStats[dpy].skipCount;
479}
480
481static inline bool isYuvPresent (hwc_context_t *ctx, int dpy) {
482    return  ctx->listStats[dpy].yuvCount;
483}
484
485static inline bool has90Transform(hwc_layer_1_t *layer) {
486    return ((layer->transform & HWC_TRANSFORM_ROT_90) &&
487            !(layer->flags & HWC_COLOR_FILL));
488}
489
490inline bool isSecurePresent(hwc_context_t *ctx, int dpy) {
491    return ctx->listStats[dpy].isSecurePresent;
492}
493
494};
495
496#endif //HWC_UTILS_H
497