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

Commit 63e663ae authored by Pullakavi Srinivas's avatar Pullakavi Srinivas Committed by Linux Build Service Account
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: Ia4c649ef236f5684fb76ff1b4b802a9d01c1da0c
parent cbd4b841

services/surfaceflinger/Layer.cpp

+61 −9
Original line number Diff line number Diff line
@@ -100,7 +100,8 @@ Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client, 
        mLastFrameNumberReceived(0),

        mUpdateTexImageFailed(false),

        mAutoRefresh(false),

        mFreezePositionUpdates(false)

        mFreezePositionUpdates(false),

        mTransformHint(0)

{

#ifdef USE_HWC2

    ALOGV("Creating Layer %s", name.string());
@@ -1011,6 +1012,19 @@ void Layer::drawWithOpenGL(const sp<const DisplayDevice>& hw, 
     * minimal value)? Or, we could make GL behave like HWC -- but this feel

     * like more of a hack.

     */

#ifdef QTI_BSP

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



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

        win = s.crop;

    }



    win = s.active.transform.transform(win);

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

    win = s.active.transform.inverse().transform(win);

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

    win = reduce(win, s.activeTransparentRegion);

#else

    Rect win(computeBounds());



    if (!s.finalCrop.isEmpty()) {
@@ -1023,7 +1037,7 @@ void Layer::drawWithOpenGL(const sp<const DisplayDevice>& hw, 
            win.clear();

        }

    }



#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);
@@ -1181,8 +1195,37 @@ void Layer::computeGeometry(const sp<const DisplayDevice>& hw, Mesh& mesh, 
    if (!s.crop.isEmpty()) {

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

    }

    // subtract the transparent region and snap to the bounds

#ifdef QTI_BSP

    win = s.active.transform.transform(win);

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

    win = s.active.transform.inverse().transform(win);

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

    win = reduce(win, s.activeTransparentRegion);



    const Transform bufferOrientation(mCurrentTransform);

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

    if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) {

        uint32_t invTransform =  DisplayDevice::getPrimaryDisplayOrientationTransform();

         if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) {

              invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V |

                      NATIVE_WINDOW_TRANSFORM_FLIP_H;

         }

          transform = Transform(invTransform) * transform;

    }

    const uint32_t orientation = transform.getOrientation();

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

        if (!useIdentityTransform) {

            win = s.active.transform.transform(win);

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

        }

    }

#else

    win = reduce(win, s.activeTransparentRegion);

#endif







    // subtract the transparent region and snap to the bounds



    vec2 lt = vec2(win.left, win.top);

    vec2 lb = vec2(win.left, win.bottom);
@@ -1190,12 +1233,20 @@ void Layer::computeGeometry(const sp<const DisplayDevice>& hw, Mesh& mesh, 
    vec2 rt = vec2(win.right, win.top);



    if (!useIdentityTransform) {

#ifdef QTI_BSP

        if (orientation | mCurrentTransform | mTransformHint) {

            lt = s.active.transform.transform(lt);

            lb = s.active.transform.transform(lb);

            rb = s.active.transform.transform(rb);

            rt = s.active.transform.transform(rt);

        }



#else

            lt = s.active.transform.transform(lt);

            lb = s.active.transform.transform(lb);

            rb = s.active.transform.transform(rb);

            rt = s.active.transform.transform(rt);

#endif

    }

    if (!s.finalCrop.isEmpty()) {

        boundPoint(&lt, s.finalCrop);

        boundPoint(&lb, s.finalCrop);
@@ -2095,7 +2146,7 @@ uint32_t Layer::getEffectiveUsage(uint32_t usage) const 
    return usage;

}



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

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

    uint32_t orientation = 0;

    if (!mFlinger->mDebugDisableTransformHint) {

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

    }

    mSurfaceFlingerConsumer->setTransformHint(orientation);

    mTransformHint = orientation;

}



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

services/surfaceflinger/Layer.h

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


    // Updates the transform hint in our SurfaceFlingerConsumer to match

    // the current orientation of the display device.

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

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



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

     * Extensions
@@ -616,6 +616,7 @@ private: 


    bool mAutoRefresh;

    bool mFreezePositionUpdates;

    uint32_t mTransformHint;

};



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