Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit bea57f31 authored by Ramakant Singh's avatar Ramakant Singh Committed by Steve Kondik
Browse files

sf : Fix vertices & texture coordinates computation. 

Compute crop and display frame for GPU composition also
in the same way it's done for HWC and compute vertices
and texture coordinates for GPU composition. This avoids
pixel shifts in output of GPU composition & overlays.

Change-Id: I0d31b1e4a81049fff72109d1a210e7cbd945cfe9
parent 7cacf26a

services/surfaceflinger/Layer.cpp

+53 −7
Original line number Original line Diff line number Diff line
@@ -84,7 +84,8 @@ Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client, 
        mQueueItemCondition(),

        mQueueItemCondition(),

        mQueueItems(),

        mQueueItems(),

        mLastFrameNumberReceived(0),

        mLastFrameNumberReceived(0),

        mUpdateTexImageFailed(false)

        mUpdateTexImageFailed(false),

        mTransformHint(0)

{

{

    mCurrentCrop.makeInvalid();

    mCurrentCrop.makeInvalid();

    mFlinger->getRenderEngine().genTextures(1, &mTextureName);

    mFlinger->getRenderEngine().genTextures(1, &mTextureName);
@@ -753,8 +754,19 @@ void Layer::drawWithOpenGL(const sp<const DisplayDevice>& hw, 
     * minimal value)? Or, we could make GL behave like HWC -- but this feel

     * minimal value)? Or, we could make GL behave like HWC -- but this feel

     * like more of a hack.

     * like more of a hack.

     */

     */

    const Rect win(computeBounds());

    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 left   = float(win.left)   / float(s.active.w);

    float top    = float(win.top)    / float(s.active.h);

    float top    = float(win.top)    / float(s.active.h);

    float right  = float(win.right)  / float(s.active.w);

    float right  = float(win.right)  / float(s.active.w);
@@ -821,16 +833,49 @@ void Layer::computeGeometry(const sp<const DisplayDevice>& hw, Mesh& mesh, 
        bool useIdentityTransform) const

        bool useIdentityTransform) const

{

{

    const Layer::State& s(getDrawingState());

    const Layer::State& s(getDrawingState());

    const Transform tr(useIdentityTransform ?

    Transform tr(useIdentityTransform ?

            hw->getTransform() : hw->getTransform() * s.transform);

            hw->getTransform() : hw->getTransform() * s.transform);

    const uint32_t hw_h = hw->getHeight();

    const uint32_t hw_h = hw->getHeight();

    Rect win(s.active.w, s.active.h);

    Rect win(s.active.w, s.active.h);

    if (!s.active.crop.isEmpty()) {

    if (!s.active.crop.isEmpty()) {

        win.intersect(s.active.crop, &win);

        win.intersect(s.active.crop, &win);

    }

    }

    // subtract the transparent region and snap to the bounds

#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);

    win = reduce(win, s.activeTransparentRegion);



    const Transform bufferOrientation(mCurrentTransform);

    Transform transform(tr * s.transform * bufferOrientation);

    if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) {

        uint32_t invTransform = hw->getOrientationTransform();

        uint32_t t_orientation = transform.getOrientation();

        if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) {

            invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V |

                    NATIVE_WINDOW_TRANSFORM_FLIP_H;

            bool is_h_flipped = (t_orientation &

                                 NATIVE_WINDOW_TRANSFORM_FLIP_H) != 0;

            bool is_v_flipped = (t_orientation &

                                 NATIVE_WINDOW_TRANSFORM_FLIP_V) != 0;

            if (is_h_flipped != is_v_flipped) {

                t_orientation ^= NATIVE_WINDOW_TRANSFORM_FLIP_V |

                        NATIVE_WINDOW_TRANSFORM_FLIP_H;

            }

            transform = Transform(t_orientation) * Transform(invTransform);

        }

    }

    const uint32_t orientation = transform.getOrientation();

    if (!(mTransformHint | mCurrentTransform | orientation)) {

        tr = hw->getTransform();

        if (!useIdentityTransform) {

            win = s.transform.transform(win);

            win.intersect(hw->getViewport(), &win);

        }

    }

#else

    win = reduce(win, s.activeTransparentRegion);

#endif

    Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());

    Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());

    position[0] = tr.transform(win.left,  win.top);

    position[0] = tr.transform(win.left,  win.top);

    position[1] = tr.transform(win.left,  win.bottom);

    position[1] = tr.transform(win.left,  win.bottom);
@@ -1451,7 +1496,7 @@ uint32_t Layer::getEffectiveUsage(uint32_t usage) const 
    return usage;

    return usage;

}

}





void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const {

void Layer::updateTransformHint(const sp<const DisplayDevice>& hw)  {

    uint32_t orientation = 0;

    uint32_t orientation = 0;

    if (!mFlinger->mDebugDisableTransformHint) {

    if (!mFlinger->mDebugDisableTransformHint) {

        // The transform hint is used to improve performance, but we can

        // The transform hint is used to improve performance, but we can
@@ -1464,6 +1509,7 @@ void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const { 
        }

        }

    }

    }

    mSurfaceFlingerConsumer->setTransformHint(orientation);

    mSurfaceFlingerConsumer->setTransformHint(orientation);

    mTransformHint = orientation;

}

}





// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

services/surfaceflinger/Layer.h

+2 −1
Original line number Original line Diff line number Diff line
@@ -299,7 +299,7 @@ public: 




    // Updates the transform hint in our SurfaceFlingerConsumer to match

    // Updates the transform hint in our SurfaceFlingerConsumer to match

    // the current orientation of the display device.

    // the current orientation of the display device.

    void updateTransformHint(const sp<const DisplayDevice>& hw) const;

    void updateTransformHint(const sp<const DisplayDevice>& hw) ;





    /* ------------------------------------------------------------------------

    /* ------------------------------------------------------------------------

     * Extensions

     * Extensions
@@ -451,6 +451,7 @@ private: 
    Vector<BufferItem> mQueueItems;

    Vector<BufferItem> mQueueItems;

    uint64_t mLastFrameNumberReceived;

    uint64_t mLastFrameNumberReceived;

    bool mUpdateTexImageFailed; // This is only modified from the main thread

    bool mUpdateTexImageFailed; // This is only modified from the main thread

    uint32_t mTransformHint;

};

};





// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------