ADHOC/replicant-frameworks_native
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

SF: Add support to draw S3D framebuffer target

Browse Source 
Add support to draw S3D framebuffer target in case HWC driver
can not handle due to resource or capability issue.

Change-Id: I536fa4a03e246d51891045b692d5dc5be88f2adf
CRs-fixed: 999055
This commit is contained in:
feifanz 2016-04-27 12:23:28 +08:00 committed by Steve Kondik
parent 8cafa373aa
commit 537364c722
9 changed files with 263 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
services/surfaceflinger/Android.mk
View File

@ -120,6 +120,7 @@ ifeq ($(TARGET_USES_QCOM_BSP), true)
LOCAL_C_INCLUDES += $(call project-path-for,qcom-display)/libgralloc
LOCAL_C_INCLUDES += $(call project-path-for,qcom-display)/libqdutils
LOCAL_SHARED_LIBRARIES += libqdutils
LOCAL_SHARED_LIBRARIES += libqdMetaData
LOCAL_CFLAGS += -DQTI_BSP
LOCAL_SRC_FILES += \
ExSurfaceFlinger/ExLayer.cpp \

1
services/surfaceflinger/DisplayHardware/HWComposer.h
View File

@ -306,6 +306,7 @@ public:
};
friend class VSyncThread;
friend class ExHWComposer;
// for debugging ----------------------------------------------------------
void dump(String8& out) const;

23
services/surfaceflinger/ExSurfaceFlinger/ExHWComposer.cpp
View File

@ -31,6 +31,8 @@
#include "ExHWComposer.h"
#ifdef QTI_BSP
#include <hardware/display_defs.h>
#include <gralloc_priv.h>
#include <qdMetaData.h>
#endif
namespace android {
@ -74,4 +76,25 @@ bool ExHWComposer::isCompositionTypeBlit(const int32_t compType) const {
return false;
}
#ifdef QTI_BSP
uint32_t ExHWComposer::getS3DFlag(int disp) const {
const DisplayData& disp_data(mDisplayData[disp]);
for (size_t i=0 ; i<disp_data.list->numHwLayers-1; i++) {
const hwc_layer_1_t &l = disp_data.list->hwLayers[i];
private_handle_t *pvt_handle = static_cast<private_handle_t *>
(const_cast<native_handle_t*>(l.handle));
if (pvt_handle != NULL) {
struct S3DSFRender_t s3dRender;
getMetaData(pvt_handle, GET_S3D_RENDER, &s3dRender);
if (s3dRender.DisplayId == static_cast<uint32_t>(disp) && s3dRender.GpuRender) {
return s3dRender.GpuS3dFormat;
}
}
}
return 0;
}
#endif
}; // namespace android

4
services/surfaceflinger/ExSurfaceFlinger/ExHWComposer.h
View File

@ -43,6 +43,10 @@ public:
virtual ~ExHWComposer();
#ifdef QTI_BSP
uint32_t getS3DFlag(int disp) const;
#endif
protected:
bool mVDSEnabled;
inline bool isVDSEnabled() const { return mVDSEnabled; };

184
services/surfaceflinger/ExSurfaceFlinger/ExLayer.cpp
View File

@ -36,10 +36,12 @@
#include <ui/GraphicBuffer.h>
#ifdef QTI_BSP
#include <gralloc_priv.h>
#include <qdMetaData.h>
#include <hardware/display_defs.h>
#endif
#include "ExLayer.h"
#include "RenderEngine/RenderEngine.h"
namespace android {
@ -70,12 +72,18 @@ static Rect getAspectRatio(const sp<const DisplayDevice>& hw,
ExLayer::ExLayer(SurfaceFlinger* flinger, const sp<Client>& client,
const String8& name, uint32_t w, uint32_t h, uint32_t flags)
#ifdef QTI_BSP
: Layer(flinger, client, name, w, h, flags),
mMeshLeftTop(Mesh::TRIANGLE_FAN, 4, 2, 2),
mMeshRightBottom(Mesh::TRIANGLE_FAN, 4, 2, 2) {
#else
: Layer(flinger, client, name, w, h, flags) {
#endif
char property[PROPERTY_VALUE_MAX] = {0};
mDebugLogs = false;
mIsGPUAllowedForProtected = false;
mIsHDMIPrimary = false;
if((property_get("persist.debug.qdframework.logs", property, NULL) > 0) &&
(!strncmp(property, "1", PROPERTY_VALUE_MAX ) ||
(!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) {
@ -88,6 +96,12 @@ ExLayer::ExLayer(SurfaceFlinger* flinger, const sp<Client>& client,
(atoi(property) == 1)) {
mIsGPUAllowedForProtected = true;
}
if ((property_get("persist.sys.is_hdmi_primary", property, NULL) > 0) &&
(atoi(property) == 1)) {
mIsHDMIPrimary = true;
}
}
ExLayer::~ExLayer() {
@ -204,4 +218,172 @@ bool ExLayer::canAllowGPUForProtected() const {
}
}
void ExLayer::drawWithOpenGL(const sp<const DisplayDevice>& hw,
const Region& /* clip */, bool useIdentityTransform) const {
const State& s(getDrawingState());
#ifdef QTI_BSP
uint32_t s3d_fmt = 0;
private_handle_t *pvt_handle = static_cast<private_handle_t *>
(const_cast<native_handle_t*>(mActiveBuffer->handle));
if (pvt_handle != NULL) {
struct S3DSFRender_t s3dRender;
getMetaData(pvt_handle, GET_S3D_RENDER, &s3dRender);
if ((s3dRender.DisplayId == static_cast<uint32_t>(hw->getHwcDisplayId()) ||
mIsHDMIPrimary) && s3dRender.GpuRender) {
clearMetaData(pvt_handle, SET_S3D_RENDER);
s3d_fmt = s3dRender.GpuS3dFormat;
}
}
#endif
computeGeometry(hw, mMesh, useIdentityTransform);
/*
* NOTE: the way we compute the texture coordinates here produces
* different results than when we take the HWC path -- in the later case
* the "source crop" is rounded to texel boundaries.
* This can produce significantly different results when the texture
* is scaled by a large amount.
*
* The GL code below is more logical (imho), and the difference with
* HWC is due to a limitation of the HWC API to integers -- a question
* is suspend is whether we should ignore this problem or revert to
* GL composition when a buffer scaling is applied (maybe with some
* minimal value)? Or, we could make GL behave like HWC -- but this feel
* like more of a hack.
*/
Rect win(s.active.w, s.active.h);
if(!s.active.crop.isEmpty()) {
win = s.active.crop;
}
#ifdef QTI_BSP
win = s.transform.transform(win);
win.intersect(hw->getViewport(), &win);
win = s.transform.inverse().transform(win);
win.intersect(Rect(s.active.w, s.active.h), &win);
win = reduce(win, s.activeTransparentRegion);
#else
win = reduce(win, s.activeTransparentRegion);
#endif
float left = float(win.left) / float(s.active.w);
float top = float(win.top) / float(s.active.h);
float right = float(win.right) / float(s.active.w);
float bottom = float(win.bottom) / float(s.active.h);
// TODO: we probably want to generate the texture coords with the mesh
// here we assume that we only have 4 vertices
Mesh::VertexArray<vec2> texCoords(mMesh.getTexCoordArray<vec2>());
texCoords[0] = vec2(left, 1.0f - top);
texCoords[1] = vec2(left, 1.0f - bottom);
texCoords[2] = vec2(right, 1.0f - bottom);
texCoords[3] = vec2(right, 1.0f - top);
#ifdef QTI_BSP
computeGeometryS3D(hw, mMesh, mMeshLeftTop, mMeshRightBottom, s3d_fmt);
#endif
RenderEngine& engine(mFlinger->getRenderEngine());
engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(s), s.alpha);
#ifdef QTI_BSP
if (s3d_fmt != HWC_S3DMODE_NONE) {
engine.setScissor(0, 0, hw->getWidth(), hw->getHeight());
engine.drawMesh(mMeshLeftTop);
engine.drawMesh(mMeshRightBottom);
} else {
#endif
engine.drawMesh(mMesh);
#ifdef QTI_BSP
}
#endif
engine.disableBlending();
}
#ifdef QTI_BSP
void ExLayer::computeGeometryS3D(const sp<const DisplayDevice>& hw, Mesh& mesh,
Mesh& meshLeftTop, Mesh &meshRightBottom, uint32_t s3d_fmt) const
{
Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());
Mesh::VertexArray<vec2> positionLeftTop(meshLeftTop.getPositionArray<vec2>());
Mesh::VertexArray<vec2> positionRightBottom(meshRightBottom.getPositionArray<vec2>());
Mesh::VertexArray<vec2> texCoords(mesh.getTexCoordArray<vec2>());
Mesh::VertexArray<vec2> texCoordsLeftTop(meshLeftTop.getTexCoordArray<vec2>());
Mesh::VertexArray<vec2> texCoordsRightBottom(meshRightBottom.getTexCoordArray<vec2>());
Rect scissor = hw->getBounds();
if(s3d_fmt == HWC_S3DMODE_NONE) {
return;
}
uint32_t count = mesh.getVertexCount();
while(count--) {
positionLeftTop[count] = positionRightBottom[count] = position[count];
texCoordsLeftTop[count] = texCoordsRightBottom[count] = texCoords[count];
}
switch (s3d_fmt) {
case HWC_S3DMODE_LR:
case HWC_S3DMODE_RL:
{
positionLeftTop[0].x = (position[0].x - scissor.left) / 2.0f + scissor.left;
positionLeftTop[1].x = (position[1].x - scissor.left) / 2.0f + scissor.left;
positionLeftTop[2].x = (position[2].x - scissor.left) / 2.0f + scissor.left;
positionLeftTop[3].x = (position[3].x - scissor.left) / 2.0f + scissor.left;
positionRightBottom[0].x = positionLeftTop[0].x + scissor.getWidth()/2;
positionRightBottom[1].x = positionLeftTop[1].x + scissor.getWidth()/2;
positionRightBottom[2].x = positionLeftTop[2].x + scissor.getWidth()/2;
positionRightBottom[3].x = positionLeftTop[3].x + scissor.getWidth()/2;
if(isYuvLayer()) {
texCoordsLeftTop[0].x = texCoords[0].x / 2.0f;
texCoordsLeftTop[1].x = texCoords[1].x / 2.0f;
texCoordsLeftTop[2].x = texCoords[2].x / 2.0f;
texCoordsLeftTop[3].x = texCoords[3].x / 2.0f;
texCoordsRightBottom[0].x = texCoordsLeftTop[0].x + 0.5f;
texCoordsRightBottom[1].x = texCoordsLeftTop[1].x + 0.5f;
texCoordsRightBottom[2].x = texCoordsLeftTop[2].x + 0.5f;
texCoordsRightBottom[3].x = texCoordsLeftTop[3].x + 0.5f;
}
break;
}
case HWC_S3DMODE_TB:
{
positionRightBottom[0].y = (position[0].y - scissor.top) / 2.0f + scissor.top;
positionRightBottom[1].y = (position[1].y - scissor.top) / 2.0f + scissor.top;
positionRightBottom[2].y = (position[2].y - scissor.top) / 2.0f + scissor.top;
positionRightBottom[3].y = (position[3].y - scissor.top) / 2.0f + scissor.top;
positionLeftTop[0].y = positionRightBottom[0].y + scissor.getHeight() / 2.0f;
positionLeftTop[1].y = positionRightBottom[1].y + scissor.getHeight() / 2.0f;
positionLeftTop[2].y = positionRightBottom[2].y + scissor.getHeight() / 2.0f;
positionLeftTop[3].y = positionRightBottom[3].y + scissor.getHeight() / 2.0f;
positionLeftTop[0].x = positionRightBottom[0].x = position[0].x;
positionLeftTop[1].x = positionRightBottom[1].x = position[1].x;
positionLeftTop[2].x = positionRightBottom[2].x = position[2].x;
positionLeftTop[3].x = positionRightBottom[3].x = position[3].x;
if(isYuvLayer()) {
texCoordsRightBottom[0].y = texCoords[0].y / 2.0f;
texCoordsRightBottom[1].y = texCoords[1].y / 2.0f;
texCoordsRightBottom[2].y = texCoords[2].y / 2.0f;
texCoordsRightBottom[3].y = texCoords[3].y / 2.0f;
texCoordsLeftTop[0].y = texCoordsRightBottom[0].y + 0.5f;
texCoordsLeftTop[1].y = texCoordsRightBottom[1].y + 0.5f;
texCoordsLeftTop[2].y = texCoordsRightBottom[2].y + 0.5f;
texCoordsLeftTop[3].y = texCoordsRightBottom[3].y + 0.5f;
}
break;
}
default:
break;
}
}
#endif
}; // namespace android

32
services/surfaceflinger/ExSurfaceFlinger/ExLayer.h
View File

@ -43,6 +43,22 @@ class ExSurfaceFlinger;
class ExLayer : public Layer
{
public:
#ifdef QTI_BSP
enum {
/*
* HWC S3D_MODE is set by HWC driver to indicate that HWC driver can not support
* S3D standalone, need surfaceflinger help to draw layers twice to construct
* S3D framebuffer target.
*/
HWC_S3DMODE_NONE = 0x00000000,
HWC_S3DMODE_LR = 0x00000001,
HWC_S3DMODE_RL = 0x00000002,
HWC_S3DMODE_TB = 0x00000003,
HWC_S3DMODE_FP = 0x00000004,
HWC_S3DMODE_MAX = 0x00000005,
};
#endif
ExLayer(SurfaceFlinger* flinger, const sp<Client>& client,
const String8& name, uint32_t w, uint32_t h, uint32_t flags);
virtual ~ExLayer();
@ -57,11 +73,27 @@ public:
HWComposer::HWCLayerInterface& layer);
virtual bool canAllowGPUForProtected() const;
#ifdef QTI_BSP
virtual void computeGeometryS3D(const sp<const DisplayDevice>& hw, Mesh& mesh,
Mesh& meshLeftTop, Mesh &meshRightBottom, uint32_t s3d_fmt) const;
#endif
protected:
bool mDebugLogs;
bool isDebug() { return mDebugLogs; }
bool mIsGPUAllowedForProtected;
bool mIsHDMIPrimary;
private:
#ifdef QTI_BSP
// The mesh used to draw the layer in GLES composition mode for s3d left/top
mutable Mesh mMeshLeftTop;
// The mesh used to draw the layer in GLES composition mode for s3d right/bottom
mutable Mesh mMeshRightBottom;
virtual void drawWithOpenGL(const sp<const DisplayDevice>& hw, const Region& clip,
bool useIdentityTransform) const;
};
#endif
}; // namespace android

10
services/surfaceflinger/Layer.h
View File

@ -162,8 +162,13 @@ public:
uint32_t getTransactionFlags(uint32_t flags);
uint32_t setTransactionFlags(uint32_t flags);
#ifdef QTI_BSP
virtual void computeGeometry(const sp<const DisplayDevice>& hw, Mesh& mesh,
bool useIdentityTransform) const;
#else
void computeGeometry(const sp<const DisplayDevice>& hw, Mesh& mesh,
bool useIdentityTransform) const;
#endif
Rect computeBounds(const Region& activeTransparentRegion) const;
Rect computeBounds() const;
@ -392,9 +397,14 @@ private:
// drawing
void clearWithOpenGL(const sp<const DisplayDevice>& hw, const Region& clip,
float r, float g, float b, float alpha) const;
#ifdef QTI_BSP
virtual void drawWithOpenGL(const sp<const DisplayDevice>& hw, const Region& clip,
bool useIdentityTransform) const;
#else
void drawWithOpenGL(const sp<const DisplayDevice>& hw, const Region& clip,
bool useIdentityTransform) const;
#endif
// Temporary - Used only for LEGACY camera mode.
uint32_t getProducerStickyTransform() const;

6
services/surfaceflinger/SurfaceFlinger.cpp
View File

@ -74,6 +74,7 @@
#include "DisplayHardware/FramebufferSurface.h"
#include "DisplayHardware/HWComposer.h"
#include "ExSurfaceFlinger/ExHWComposer.h"
#include "DisplayHardware/VirtualDisplaySurface.h"
#include "Effects/Daltonizer.h"
@ -2003,7 +2004,12 @@ bool SurfaceFlinger::doComposeSurfaces(const sp<const DisplayDevice>& hw, const
}
// Never touch the framebuffer if we don't have any framebuffer layers
#ifdef QTI_BSP
const bool hasHwcComposition = hwc.hasHwcComposition(id) |
(reinterpret_cast<ExHWComposer*>(&hwc))->getS3DFlag(id);
#else
const bool hasHwcComposition = hwc.hasHwcComposition(id);
#endif
if (hasHwcComposition) {
// when using overlays, we assume a fully transparent framebuffer
// NOTE: we could reduce how much we need to clear, for instance

3
services/surfaceflinger/SurfaceFlinger.h
View File

@ -146,6 +146,9 @@ private:
friend class DisplayEventConnection;
friend class Layer;
friend class LayerDim;
#ifdef QTI_BSP
friend class ExLayer;
#endif
friend class MonitoredProducer;
friend class LayerBlur;