943797c361
1. Color layer has a destination rectangle, RGBA color and plane alpha. There is no gralloc buffer. Layer flag HWC_COLOR_FILL denotes color layer. MDP BLIT happens via MDP_SOLID_FILL mode. 2. There is no color member in HWC layer, so RGBA color value is passed via "tranform" member from framework to HAL. 3. Update HWC query to enable framework to query for Color layer support in HAL, at run-time. Change-Id: I2c698007c1689779fe86d549093bb5285432dc5f
476 lines
15 KiB
C++
476 lines
15 KiB
C++
/*
|
|
* Copyright (C) 2010 The Android Open Source Project
|
|
* Copyright (C)2012-2013, The Linux Foundation. All rights reserved.
|
|
*
|
|
* Not a Contribution, Apache license notifications and license are retained
|
|
* for attribution purposes only.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef HWC_UTILS_H
|
|
#define HWC_UTILS_H
|
|
|
|
#define HWC_REMOVE_DEPRECATED_VERSIONS 1
|
|
#include <fcntl.h>
|
|
#include <math.h>
|
|
#include <hardware/hwcomposer.h>
|
|
#include <gr.h>
|
|
#include <gralloc_priv.h>
|
|
#include <utils/String8.h>
|
|
#include "qdMetaData.h"
|
|
#include <overlayUtils.h>
|
|
|
|
#define ALIGN_TO(x, align) (((x) + ((align)-1)) & ~((align)-1))
|
|
#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true ))
|
|
#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))
|
|
#define MAX_NUM_APP_LAYERS 32
|
|
|
|
//Fwrd decls
|
|
struct hwc_context_t;
|
|
|
|
namespace ovutils = overlay::utils;
|
|
|
|
namespace overlay {
|
|
class Overlay;
|
|
class Rotator;
|
|
class RotMgr;
|
|
}
|
|
|
|
namespace qhwc {
|
|
//fwrd decl
|
|
class QueuedBufferStore;
|
|
class ExternalDisplay;
|
|
class VirtualDisplay;
|
|
class IFBUpdate;
|
|
class IVideoOverlay;
|
|
class MDPComp;
|
|
class CopyBit;
|
|
class HwcDebug;
|
|
class AssertiveDisplay;
|
|
class VPUClient;
|
|
|
|
|
|
struct MDPInfo {
|
|
int version;
|
|
char panel;
|
|
bool hasOverlay;
|
|
};
|
|
|
|
struct DisplayAttributes {
|
|
uint32_t vsync_period; //nanos
|
|
uint32_t xres;
|
|
uint32_t yres;
|
|
uint32_t stride;
|
|
float xdpi;
|
|
float ydpi;
|
|
int fd;
|
|
bool connected; //Applies only to pluggable disp.
|
|
//Connected does not mean it ready to use.
|
|
//It should be active also. (UNBLANKED)
|
|
bool isActive;
|
|
// In pause state, composition is bypassed
|
|
// used for WFD displays only
|
|
bool isPause;
|
|
// To trigger padding round to clean up mdp
|
|
// pipes
|
|
bool isConfiguring;
|
|
// External Display is in MDP Downscale mode indicator
|
|
bool mDownScaleMode;
|
|
};
|
|
|
|
struct ListStats {
|
|
int numAppLayers; //Total - 1, excluding FB layer.
|
|
int skipCount;
|
|
int fbLayerIndex; //Always last for now. = numAppLayers
|
|
//Video specific
|
|
int yuvCount;
|
|
int yuvIndices[MAX_NUM_APP_LAYERS];
|
|
int extOnlyLayerIndex;
|
|
bool needsAlphaScale;
|
|
bool preMultipliedAlpha;
|
|
// Notifies hwcomposer about the start and end of animation
|
|
// This will be set to true during animation, otherwise false.
|
|
bool isDisplayAnimating;
|
|
ovutils::Dim roi;
|
|
bool secureUI; // Secure display layer
|
|
bool isSecurePresent;
|
|
};
|
|
|
|
struct LayerProp {
|
|
uint32_t mFlags; //qcom specific layer flags
|
|
LayerProp():mFlags(0){};
|
|
};
|
|
|
|
struct VsyncState {
|
|
bool enable;
|
|
bool fakevsync;
|
|
};
|
|
|
|
struct BwcPM {
|
|
static void setBwc(hwc_context_t *ctx, const hwc_rect_t& crop,
|
|
const hwc_rect_t& dst, const int& transform,
|
|
ovutils::eMdpFlags& mdpFlags);
|
|
};
|
|
|
|
// LayerProp::flag values
|
|
enum {
|
|
HWC_MDPCOMP = 0x00000001,
|
|
HWC_COPYBIT = 0x00000002,
|
|
};
|
|
|
|
// HAL specific features
|
|
enum {
|
|
HWC_COLOR_FILL = 0x00000008,
|
|
HWC_FORMAT_RB_SWAP = 0x00000040,
|
|
};
|
|
|
|
class LayerRotMap {
|
|
public:
|
|
LayerRotMap() { reset(); }
|
|
enum { MAX_SESS = 3 };
|
|
void add(hwc_layer_1_t* layer, overlay::Rotator *rot);
|
|
void reset();
|
|
uint32_t getCount() const;
|
|
hwc_layer_1_t* getLayer(uint32_t index) const;
|
|
overlay::Rotator* getRot(uint32_t index) const;
|
|
void setReleaseFd(const int& fence);
|
|
private:
|
|
hwc_layer_1_t* mLayer[MAX_SESS];
|
|
overlay::Rotator* mRot[MAX_SESS];
|
|
uint32_t mCount;
|
|
};
|
|
|
|
inline uint32_t LayerRotMap::getCount() const {
|
|
return mCount;
|
|
}
|
|
|
|
inline hwc_layer_1_t* LayerRotMap::getLayer(uint32_t index) const {
|
|
if(index >= mCount) return NULL;
|
|
return mLayer[index];
|
|
}
|
|
|
|
inline overlay::Rotator* LayerRotMap::getRot(uint32_t index) const {
|
|
if(index >= mCount) return NULL;
|
|
return mRot[index];
|
|
}
|
|
|
|
inline hwc_rect_t integerizeSourceCrop(const hwc_frect_t& cropF) {
|
|
hwc_rect_t cropI = {0};
|
|
cropI.left = int(ceilf(cropF.left));
|
|
cropI.top = int(ceilf(cropF.top));
|
|
cropI.right = int(floorf(cropF.right));
|
|
cropI.bottom = int(floorf(cropF.bottom));
|
|
return cropI;
|
|
}
|
|
|
|
inline bool isNonIntegralSourceCrop(const hwc_frect_t& cropF) {
|
|
if(cropF.left - roundf(cropF.left) ||
|
|
cropF.top - roundf(cropF.top) ||
|
|
cropF.right - roundf(cropF.right) ||
|
|
cropF.bottom - roundf(cropF.bottom))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Utility functions - implemented in hwc_utils.cpp
|
|
void dumpLayer(hwc_layer_1_t const* l);
|
|
void setListStats(hwc_context_t *ctx, const hwc_display_contents_1_t *list,
|
|
int dpy);
|
|
void initContext(hwc_context_t *ctx);
|
|
void closeContext(hwc_context_t *ctx);
|
|
//Crops source buffer against destination and FB boundaries
|
|
void calculate_crop_rects(hwc_rect_t& crop, hwc_rect_t& dst,
|
|
const hwc_rect_t& scissor, int orient);
|
|
void getNonWormholeRegion(hwc_display_contents_1_t* list,
|
|
hwc_rect_t& nwr);
|
|
bool isSecuring(hwc_context_t* ctx, hwc_layer_1_t const* layer);
|
|
bool isSecureModePolicy(int mdpVersion);
|
|
bool isExternalActive(hwc_context_t* ctx);
|
|
bool needsScaling(hwc_context_t* ctx, hwc_layer_1_t const* layer,
|
|
const int& dpy);
|
|
bool needsScalingWithSplit(hwc_context_t* ctx, hwc_layer_1_t const* layer,
|
|
const int& dpy);
|
|
void sanitizeSourceCrop(hwc_rect_t& cropL, hwc_rect_t& cropR,
|
|
private_handle_t *hnd);
|
|
bool isAlphaPresent(hwc_layer_1_t const* layer);
|
|
int hwc_vsync_control(hwc_context_t* ctx, int dpy, int enable);
|
|
int getBlending(int blending);
|
|
|
|
//Helper function to dump logs
|
|
void dumpsys_log(android::String8& buf, const char* fmt, ...);
|
|
|
|
int getExtOrientation(hwc_context_t* ctx);
|
|
bool isValidRect(const hwc_rect_t& rect);
|
|
void deductRect(const hwc_layer_1_t* layer, hwc_rect_t& irect);
|
|
hwc_rect_t getIntersection(const hwc_rect_t& rect1, const hwc_rect_t& rect2);
|
|
hwc_rect_t getUnion(const hwc_rect_t& rect1, const hwc_rect_t& rect2);
|
|
void optimizeLayerRects(hwc_context_t *ctx,
|
|
const hwc_display_contents_1_t *list, const int& dpy);
|
|
bool areLayersIntersecting(const hwc_layer_1_t* layer1,
|
|
const hwc_layer_1_t* layer2);
|
|
|
|
/* Calculates the destination position based on the action safe rectangle */
|
|
void getActionSafePosition(hwc_context_t *ctx, int dpy, hwc_rect_t& dst);
|
|
|
|
void getAspectRatioPosition(int destWidth, int destHeight, int srcWidth,
|
|
int srcHeight, hwc_rect_t& rect);
|
|
|
|
void getAspectRatioPosition(hwc_context_t* ctx, int dpy, int extOrientation,
|
|
hwc_rect_t& inRect, hwc_rect_t& outRect);
|
|
|
|
bool isPrimaryPortrait(hwc_context_t *ctx);
|
|
|
|
bool isOrientationPortrait(hwc_context_t *ctx);
|
|
|
|
void calcExtDisplayPosition(hwc_context_t *ctx,
|
|
private_handle_t *hnd,
|
|
int dpy,
|
|
hwc_rect_t& sourceCrop,
|
|
hwc_rect_t& displayFrame,
|
|
int& transform,
|
|
ovutils::eTransform& orient);
|
|
|
|
// Returns the orientation that needs to be set on external for
|
|
// BufferMirrirMode(Sidesync)
|
|
int getMirrorModeOrientation(hwc_context_t *ctx);
|
|
|
|
//Close acquireFenceFds of all layers of incoming list
|
|
void closeAcquireFds(hwc_display_contents_1_t* list);
|
|
|
|
//Sync point impl.
|
|
int hwc_sync(hwc_context_t *ctx, hwc_display_contents_1_t* list, int dpy,
|
|
int fd);
|
|
|
|
//Trims a layer's source crop which is outside of screen boundary.
|
|
void trimLayer(hwc_context_t *ctx, const int& dpy, const int& transform,
|
|
hwc_rect_t& crop, hwc_rect_t& dst);
|
|
|
|
//Sets appropriate mdp flags for a layer.
|
|
void setMdpFlags(hwc_layer_1_t *layer,
|
|
ovutils::eMdpFlags &mdpFlags,
|
|
int rotDownscale, int transform);
|
|
|
|
int configRotator(overlay::Rotator *rot, ovutils::Whf& whf,
|
|
hwc_rect_t& crop, const ovutils::eMdpFlags& mdpFlags,
|
|
const ovutils::eTransform& orient, const int& downscale);
|
|
|
|
int configMdp(overlay::Overlay *ov, const ovutils::PipeArgs& parg,
|
|
const ovutils::eTransform& orient, const hwc_rect_t& crop,
|
|
const hwc_rect_t& pos, const MetaData_t *metadata,
|
|
const ovutils::eDest& dest);
|
|
|
|
void updateSource(ovutils::eTransform& orient, ovutils::Whf& whf,
|
|
hwc_rect_t& crop);
|
|
|
|
//Routine to configure low resolution panels (<= 2048 width)
|
|
int configureNonSplit(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy,
|
|
ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
|
|
ovutils::eIsFg& isFg, const ovutils::eDest& dest,
|
|
overlay::Rotator **rot);
|
|
|
|
//Routine to configure high resolution panels (> 2048 width)
|
|
int configureSplit(hwc_context_t *ctx, hwc_layer_1_t *layer, const int& dpy,
|
|
ovutils::eMdpFlags& mdpFlags, ovutils::eZorder& z,
|
|
ovutils::eIsFg& isFg, const ovutils::eDest& lDest,
|
|
const ovutils::eDest& rDest, overlay::Rotator **rot);
|
|
|
|
//On certain targets DMA pipes are used for rotation and they won't be available
|
|
//for line operations. On a per-target basis we can restrict certain use cases
|
|
//from using rotator, since we know before-hand that such scenarios can lead to
|
|
//extreme unavailability of pipes. This can also be done via hybrid calculations
|
|
//also involving many more variables like number of write-back interfaces etc,
|
|
//but the variety of scenarios is too high to warrant that.
|
|
bool canUseRotator(hwc_context_t *ctx, int dpy);
|
|
|
|
int getLeftSplit(hwc_context_t *ctx, const int& dpy);
|
|
|
|
bool isDisplaySplit(hwc_context_t* ctx, int dpy);
|
|
|
|
// Inline utility functions
|
|
static inline bool isSkipLayer(const hwc_layer_1_t* l) {
|
|
return (UNLIKELY(l && (l->flags & HWC_SKIP_LAYER)));
|
|
}
|
|
|
|
// Returns true if the buffer is yuv
|
|
static inline bool isYuvBuffer(const private_handle_t* hnd) {
|
|
return (hnd && (hnd->bufferType == BUFFER_TYPE_VIDEO));
|
|
}
|
|
|
|
// Returns true if the buffer is secure
|
|
static inline bool isSecureBuffer(const private_handle_t* hnd) {
|
|
return (hnd && (private_handle_t::PRIV_FLAGS_SECURE_BUFFER & hnd->flags));
|
|
}
|
|
//Return true if buffer is marked locked
|
|
static inline bool isBufferLocked(const private_handle_t* hnd) {
|
|
return (hnd && (private_handle_t::PRIV_FLAGS_HWC_LOCK & hnd->flags));
|
|
}
|
|
|
|
//Return true if buffer is for external display only
|
|
static inline bool isExtOnly(const private_handle_t* hnd) {
|
|
return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_ONLY));
|
|
}
|
|
|
|
//Return true if buffer is for external display only with a BLOCK flag.
|
|
static inline bool isExtBlock(const private_handle_t* hnd) {
|
|
return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_BLOCK));
|
|
}
|
|
|
|
//Return true if buffer is for external display only with a Close Caption flag.
|
|
static inline bool isExtCC(const private_handle_t* hnd) {
|
|
return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_CC));
|
|
}
|
|
|
|
//Return true if the buffer is intended for Secure Display
|
|
static inline bool isSecureDisplayBuffer(const private_handle_t* hnd) {
|
|
return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY));
|
|
}
|
|
|
|
static inline int getWidth(const private_handle_t* hnd) {
|
|
if(isYuvBuffer(hnd)) {
|
|
MetaData_t *metadata = (MetaData_t *)hnd->base_metadata;
|
|
if(metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
|
|
return metadata->bufferDim.sliceWidth;
|
|
}
|
|
}
|
|
return hnd->width;
|
|
}
|
|
|
|
static inline int getHeight(const private_handle_t* hnd) {
|
|
if(isYuvBuffer(hnd)) {
|
|
MetaData_t *metadata = (MetaData_t *)hnd->base_metadata;
|
|
if(metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
|
|
return metadata->bufferDim.sliceHeight;
|
|
}
|
|
}
|
|
return hnd->height;
|
|
}
|
|
|
|
template<typename T> inline T max(T a, T b) { return (a > b) ? a : b; }
|
|
template<typename T> inline T min(T a, T b) { return (a < b) ? a : b; }
|
|
|
|
// Initialize uevent thread
|
|
void init_uevent_thread(hwc_context_t* ctx);
|
|
// Initialize vsync thread
|
|
void init_vsync_thread(hwc_context_t* ctx);
|
|
|
|
inline void getLayerResolution(const hwc_layer_1_t* layer,
|
|
int& width, int& height) {
|
|
hwc_rect_t displayFrame = layer->displayFrame;
|
|
width = displayFrame.right - displayFrame.left;
|
|
height = displayFrame.bottom - displayFrame.top;
|
|
}
|
|
|
|
static inline int openFb(int dpy) {
|
|
int fd = -1;
|
|
const char *devtmpl = "/dev/graphics/fb%u";
|
|
char name[64] = {0};
|
|
snprintf(name, 64, devtmpl, dpy);
|
|
fd = open(name, O_RDWR);
|
|
return fd;
|
|
}
|
|
|
|
template <class T>
|
|
inline void swap(T& a, T& b) {
|
|
T tmp = a;
|
|
a = b;
|
|
b = tmp;
|
|
}
|
|
|
|
}; //qhwc namespace
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// HWC context
|
|
// This structure contains overall state
|
|
struct hwc_context_t {
|
|
hwc_composer_device_1_t device;
|
|
const hwc_procs_t* proc;
|
|
|
|
//CopyBit objects
|
|
qhwc::CopyBit *mCopyBit[HWC_NUM_DISPLAY_TYPES];
|
|
|
|
//Overlay object - NULL for non overlay devices
|
|
overlay::Overlay *mOverlay;
|
|
//Holds a few rot objects
|
|
overlay::RotMgr *mRotMgr;
|
|
|
|
//Primary and external FB updater
|
|
qhwc::IFBUpdate *mFBUpdate[HWC_NUM_DISPLAY_TYPES];
|
|
// External display related information
|
|
qhwc::ExternalDisplay *mExtDisplay;
|
|
qhwc::VirtualDisplay *mVirtualDisplay;
|
|
qhwc::MDPInfo mMDP;
|
|
qhwc::VsyncState vstate;
|
|
qhwc::DisplayAttributes dpyAttr[HWC_NUM_DISPLAY_TYPES];
|
|
qhwc::ListStats listStats[HWC_NUM_DISPLAY_TYPES];
|
|
qhwc::LayerProp *layerProp[HWC_NUM_DISPLAY_TYPES];
|
|
qhwc::MDPComp *mMDPComp[HWC_NUM_DISPLAY_TYPES];
|
|
qhwc::HwcDebug *mHwcDebug[HWC_NUM_DISPLAY_TYPES];
|
|
qhwc::AssertiveDisplay *mAD;
|
|
qhwc::VPUClient *mVPUClient;
|
|
|
|
// No animation on External display feature
|
|
// Notifies hwcomposer about the device orientation before animation.
|
|
int deviceOrientation;
|
|
// Stores the crop, dest rect and transform value of video before animation.
|
|
hwc_rect_t mPrevCropVideo;
|
|
hwc_rect_t mPrevDestVideo;
|
|
int mPrevTransformVideo;
|
|
//Securing in progress indicator
|
|
bool mSecuring;
|
|
//WFD on proprietary stack
|
|
bool mVirtualonExtActive;
|
|
//Display in secure mode indicator
|
|
bool mSecureMode;
|
|
//Lock to protect drawing data structures
|
|
mutable Locker mDrawLock;
|
|
//Drawing round when we use GPU
|
|
bool isPaddingRound;
|
|
// External Orientation
|
|
int mExtOrientation;
|
|
//Flags the transition of a video session
|
|
bool mVideoTransFlag;
|
|
|
|
//Used for SideSync feature
|
|
//which overrides the mExtOrientation
|
|
bool mBufferMirrorMode;
|
|
|
|
qhwc::LayerRotMap *mLayerRotMap[HWC_NUM_DISPLAY_TYPES];
|
|
|
|
// Panel reset flag will be set if BTA check fails
|
|
bool mPanelResetStatus;
|
|
};
|
|
|
|
namespace qhwc {
|
|
static inline bool isSkipPresent (hwc_context_t *ctx, int dpy) {
|
|
return ctx->listStats[dpy].skipCount;
|
|
}
|
|
|
|
static inline bool isYuvPresent (hwc_context_t *ctx, int dpy) {
|
|
return ctx->listStats[dpy].yuvCount;
|
|
}
|
|
|
|
static inline bool has90Transform(hwc_layer_1_t *layer) {
|
|
return (layer->transform & HWC_TRANSFORM_ROT_90);
|
|
}
|
|
|
|
inline bool isSecurePresent(hwc_context_t *ctx, int dpy) {
|
|
return ctx->listStats[dpy].isSecurePresent;
|
|
}
|
|
|
|
};
|
|
|
|
#endif //HWC_UTILS_H
|