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

Commit 0aa41a85 authored by Vishnu Nair's avatar Vishnu Nair
Browse files

Merge SV transactions to VRI BlastBufferQueue 

Currently SV with blast sync requests a sync transaction from VRI and
merges its transactions with VRI's sync transaction. This can break if
we are not able to set the request in time.

Instead this change will merge SV transaction from the renderthread to
the VRI BlastBufferQueue specifying the framenumber which the
transaction should be merged with. The transaction will be queued until
we submit a VRI buffer with the requested frame number.

Test: open bubbles with sv blast
Test: atest SurfaceViewSyncTest
Bug: 175594838
Change-Id: I87ba346d782f615bab2e8a692adb2b3c49ef4021
parent d2d9390f

core/java/android/view/SurfaceView.java

+37 −74
Original line number Diff line number Diff line
@@ -457,18 +457,8 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall 
                                Log.d(TAG, System.identityHashCode(this)

                                        + " updateSurfaceAlpha RT: set alpha=" + alpha);

                            }

                            if (useBLAST) {

                                synchronized (viewRoot.getBlastTransactionLock()) {

                                    viewRoot.getBLASTSyncTransaction()

                                            .setAlpha(mSurfaceControl, alpha);

                                }

                            } else {

                                Transaction t = new SurfaceControl.Transaction();

                                t.setAlpha(mSurfaceControl, alpha);

                                t.deferTransactionUntil(mSurfaceControl,

                                        viewRoot.getSurfaceControl(), frame);

                                t.apply();

                            }

                            mRtTransaction.setAlpha(mSurfaceControl, alpha);

                            applyRtTransaction(frame);

                        }

                        // It's possible that mSurfaceControl is released in the UI thread before

                        // the transaction completes. If that happens, an exception is thrown, which
@@ -818,17 +808,8 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall 
                        return;

                    }



                    if (useBLAST) {

                        synchronized (viewRoot.getBlastTransactionLock()) {

                            updateRelativeZ(viewRoot.getBLASTSyncTransaction());

                        }

                    } else {

                        final SurfaceControl.Transaction t = new SurfaceControl.Transaction();

                        updateRelativeZ(t);

                        t.deferTransactionUntil(mSurfaceControl,

                                viewRoot.getSurfaceControl(), frame);

                        t.apply();

                    }

                    updateRelativeZ(mRtTransaction);

                    applyRtTransaction(frame);

                }

                // It's possible that mSurfaceControl is released in the UI thread before

                // the transaction completes. If that happens, an exception is thrown, which
@@ -927,7 +908,7 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall 
    }



    private boolean performSurfaceTransaction(ViewRootImpl viewRoot, Translator translator,

        boolean creating, boolean sizeChanged, boolean needBLASTSync) {

            boolean creating, boolean sizeChanged) {

        boolean realSizeChanged = false;



        mSurfaceLock.lock();
@@ -990,8 +971,6 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall 
                    mTmpTransaction.setWindowCrop(mSurfaceControl, mSurfaceWidth,

                            mSurfaceHeight);

                }

            } else if (needBLASTSync) {

                viewRoot.setUseBLASTSyncTransaction();

            }

            mTmpTransaction.setCornerRadius(mSurfaceControl, mCornerRadius);

            if (sizeChanged && !creating) {
@@ -1109,11 +1088,8 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall 
                    return;

                }



                final boolean needBLASTSync =

                    (layoutSizeChanged || positionChanged || visibleChanged) &&

                        useBLASTSync(viewRoot);

                final boolean realSizeChanged = performSurfaceTransaction(viewRoot,

                    translator, creating, sizeChanged, needBLASTSync);

                        translator, creating, sizeChanged);

                final boolean redrawNeeded = sizeChanged || creating ||

                    (mVisible && !mDrawFinished);
@@ -1351,13 +1327,7 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall 
    }



    private void applySurfaceTransforms(SurfaceControl surface, SurfaceControl.Transaction t,

            Rect position, long frameNumber) {

        final ViewRootImpl viewRoot = getViewRootImpl();

        if (frameNumber > 0 && viewRoot != null && !useBLASTSync(viewRoot)) {

            t.deferTransactionUntil(surface, viewRoot.getSurfaceControl(),

                    frameNumber);

        }



            Rect position) {

        onSetSurfacePositionAndScaleRT(t, surface,

                position.left /*positionLeft*/,

                position.top /*positionTop*/,
@@ -1378,24 +1348,29 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall 
        return mRTLastReportedPosition;

    }



    private void setParentSpaceRectangle(Transaction t, Rect position, long frameNumber) {

    private void setParentSpaceRectangle(Rect position, long frameNumber) {

        final ViewRootImpl viewRoot = getViewRootImpl();

        applySurfaceTransforms(mSurfaceControl, t, position, frameNumber);

        applyChildSurfaceTransaction_renderWorker(t, viewRoot.mSurface, frameNumber);

        applySurfaceTransforms(mSurfaceControl, mRtTransaction, position);

        applyChildSurfaceTransaction_renderWorker(mRtTransaction, viewRoot.mSurface, frameNumber);

        applyRtTransaction(frameNumber);

    }



    private void setParentSpaceRectangle(Rect position, long frameNumber) {

    private void applyRtTransaction(long frameNumber) {

        final ViewRootImpl viewRoot = getViewRootImpl();

        final boolean useBLAST = useBLASTSync(viewRoot);



        boolean useBLAST = viewRoot != null && useBLASTSync(viewRoot);

        if (useBLAST) {

            synchronized (viewRoot.getBlastTransactionLock()) {

                setParentSpaceRectangle(viewRoot.getBLASTSyncTransaction(), position, frameNumber);

            // If we are using BLAST, merge the transaction with the viewroot buffer transaction.

            viewRoot.mergeWithNextTransaction(mRtTransaction, frameNumber);

            return;

        }

        } else {

            setParentSpaceRectangle(mRtTransaction, position, frameNumber);

            mRtTransaction.apply();



        // Otherwise if the if the ViewRoot is not null, use deferred transaction instead.

        if (frameNumber > 0 && viewRoot != null && viewRoot.mSurface.isValid()

                && mSurfaceControl != null) {

            mRtTransaction.deferTransactionUntil(mSurfaceControl,

                    viewRoot.getSurfaceControl(), frameNumber);

        }

        mRtTransaction.apply();

    }



    private Rect mRTLastReportedPosition = new Rect();
@@ -1444,8 +1419,6 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall 


        @Override

        public void positionLost(long frameNumber) {

            final ViewRootImpl viewRoot = getViewRootImpl();

            boolean useBLAST = viewRoot != null && useBLASTSync(viewRoot);

            if (DEBUG) {

                Log.d(TAG, String.format("%d windowPositionLost, frameNr = %d",

                        System.identityHashCode(this), frameNumber));
@@ -1461,30 +1434,20 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall 
             * need to hold the lock here.

             */

            synchronized (mSurfaceControlLock) {

                if (useBLAST) {

                    synchronized (viewRoot.getBlastTransactionLock()) {

                        viewRoot.getBLASTSyncTransaction().hide(mSurfaceControl);

                        if (mRtReleaseSurfaces) {

                            mRtReleaseSurfaces = false;

                            releaseSurfaces(viewRoot.getBLASTSyncTransaction());

                        }

                    }

                } else {

                    if (frameNumber > 0 && viewRoot != null && viewRoot.mSurface.isValid()) {

                final ViewRootImpl viewRoot = getViewRootImpl();

                boolean deferTransaction = frameNumber > 0 && viewRoot != null

                        && viewRoot.mSurface.isValid() && !useBLASTSync(viewRoot);

                if (deferTransaction) {

                    mRtTransaction.deferTransactionUntil(mSurfaceControl,

                            viewRoot.getSurfaceControl(), frameNumber);

                }



                mRtTransaction.hide(mSurfaceControl);

                if (mRtReleaseSurfaces) {

                    mRtReleaseSurfaces = false;

                    releaseSurfaces(mRtTransaction);

                }

                    // If we aren't using BLAST, we apply the transaction locally, otherwise we let

                    // the ViewRoot apply it for us.

                    // If the ViewRoot is null, we behave as if we aren't using BLAST so we need to

                    // apply the transaction.

                    mRtTransaction.apply();

                }

                applyRtTransaction(frameNumber);

                mRtHandlingPositionUpdates = false;

            }

        }

core/java/android/view/ViewRootImpl.java

+10 −0
Original line number Diff line number Diff line
@@ -10117,4 +10117,14 @@ public final class ViewRootImpl implements ViewParent, 
    int getSurfaceSequenceId() {

        return mSurfaceSequenceId;

    }



    /**

     * Merges the transaction passed in with the next transaction in BLASTBufferQueue. This ensures

     * you can add transactions to the upcoming frame.

     */

    void mergeWithNextTransaction(Transaction t, long frameNumber) {

        if (mBlastBufferQueue != null) {

            mBlastBufferQueue.mergeWithNextTransaction(t, frameNumber);

        }

    }

}

core/jni/android_graphics_BLASTBufferQueue.cpp

+8 −0
Original line number Diff line number Diff line
@@ -114,6 +114,13 @@ static void nativeFlushShadowQueue(JNIEnv* env, jclass clazz, jlong ptr) { 
    queue->flushShadowQueue();

}



static void nativeMergeWithNextTransaction(JNIEnv*, jclass clazz, jlong ptr, jlong transactionPtr,

                                           jlong framenumber) {

    sp<BLASTBufferQueue> queue = reinterpret_cast<BLASTBufferQueue*>(ptr);

    auto transaction = reinterpret_cast<SurfaceComposerClient::Transaction*>(transactionPtr);

    queue->mergeWithNextTransaction(transaction, framenumber);

}



static void nativeSetTransactionCompleteCallback(JNIEnv* env, jclass clazz, jlong ptr,

                                                 jlong frameNumber,

                                                 jobject transactionCompleteCallback) {
@@ -138,6 +145,7 @@ static const JNINativeMethod gMethods[] = { 
        {"nativeSetNextTransaction", "(JJ)V", (void*)nativeSetNextTransaction},

        {"nativeUpdate", "(JJJJ)V", (void*)nativeUpdate},

        {"nativeFlushShadowQueue", "(J)V", (void*)nativeFlushShadowQueue},

        {"nativeMergeWithNextTransaction", "(JJJ)V", (void*)nativeMergeWithNextTransaction},

        {"nativeSetTransactionCompleteCallback",

                "(JJLandroid/graphics/BLASTBufferQueue$TransactionCompleteCallback;)V",

                (void*)nativeSetTransactionCompleteCallback}

graphics/java/android/graphics/BLASTBufferQueue.java

+12 −0
Original line number Diff line number Diff line
@@ -34,6 +34,8 @@ public final class BLASTBufferQueue { 
    private static native void nativeSetNextTransaction(long ptr, long transactionPtr);

    private static native void nativeUpdate(long ptr, long surfaceControl, long width, long height);

    private static native void nativeFlushShadowQueue(long ptr);

    private static native void nativeMergeWithNextTransaction(long ptr, long transactionPtr,

                                                              long frameNumber);

    private static native void nativeSetTransactionCompleteCallback(long ptr, long frameNumber,

            TransactionCompleteCallback callback);
@@ -111,4 +113,14 @@ public final class BLASTBufferQueue { 
    public void flushShadowQueue() {

        nativeFlushShadowQueue(mNativeObject);

    }



    /**

     * Merge the transaction passed in to the next transaction in BlastBufferQueue. The next

     * transaction will be applied or merged when the next frame with specified frame number

     * is available.

     */

    public void mergeWithNextTransaction(SurfaceControl.Transaction t, long frameNumber) {

        nativeMergeWithNextTransaction(mNativeObject, t.mNativeObject, frameNumber);

    }



}