android/surfacecomposition/CustomSurfaceView.java

/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * 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.
 */
package android.surfacecomposition;

import java.util.Random;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

/**
 * This provides functionality to measure Surface update frame rate. The idea is to
 * constantly invalidates Surface in a separate thread. Lowest possible way is to
 * use SurfaceView which works with Surface. This gives a very small overhead
 * and very close to Android internals. Note, that lockCanvas is blocking
 * methods and it returns once SurfaceFlinger consumes previous buffer. This
 * gives the change to measure real performance of Surface compositor.
 */
public class CustomSurfaceView extends SurfaceView implements SurfaceHolder.Callback {
    private final static long DURATION_TO_WARMUP_MS = 50;
    private final static long DURATION_TO_MEASURE_ROUGH_MS = 500;
    private final static long DURATION_TO_MEASURE_PRECISE_MS = 3000;
    private final static Random mRandom = new Random();

    private final Object mSurfaceLock = new Object();
    private Surface mSurface;
    private boolean mDrawNameOnReady = true;
    private boolean mSurfaceWasChanged = false;
    private String mName;
    private Canvas mCanvas;

    class ValidateThread extends Thread {
        private double mFPS = 0.0f;
        // Used to support early exit and prevent long computation.
        private double mBadFPS;
        private double mPerfectFPS;

        ValidateThread(double badFPS, double perfectFPS) {
            mBadFPS = badFPS;
            mPerfectFPS = perfectFPS;
        }

        public void run() {
            long startTime = System.currentTimeMillis();
            while (System.currentTimeMillis() - startTime < DURATION_TO_WARMUP_MS) {
                invalidateSurface(false);
            }

            startTime = System.currentTimeMillis();
            long endTime;
            int frameCnt = 0;
            while (true) {
                invalidateSurface(false);
                endTime = System.currentTimeMillis();
                ++frameCnt;
                mFPS = (double)frameCnt * 1000.0 / (endTime - startTime);
                if ((endTime - startTime) >= DURATION_TO_MEASURE_ROUGH_MS) {
                    // Test if result looks too bad or perfect and stop early.
                    if (mFPS <= mBadFPS || mFPS >= mPerfectFPS) {
                        break;
                    }
                }
                if ((endTime - startTime) >= DURATION_TO_MEASURE_PRECISE_MS) {
                    break;
                }
            }
        }

        public double getFPS() {
            return mFPS;
        }
    }

    public CustomSurfaceView(Context context, String name) {
        super(context);
        mName = name;
        getHolder().addCallback(this);
    }

    public void setMode(int pixelFormat, boolean drawNameOnReady) {
        mDrawNameOnReady = drawNameOnReady;
        getHolder().setFormat(pixelFormat);
    }

    public void acquireCanvas() {
        synchronized (mSurfaceLock) {
            if (mCanvas != null) {
                throw new RuntimeException("Surface canvas was already acquired.");
            }
            if (mSurface != null) {
                mCanvas = mSurface.lockCanvas(null);
            }
        }
    }

    public void releaseCanvas() {
        synchronized (mSurfaceLock) {
            if (mCanvas != null) {
                if (mSurface == null) {
                    throw new RuntimeException(
                            "Surface was destroyed but canvas was not released.");
                }
                mSurface.unlockCanvasAndPost(mCanvas);
                mCanvas = null;
            }
        }
    }

    /**
     * Invalidate surface.
     */
    private void invalidateSurface(boolean drawSurfaceId) {
        synchronized (mSurfaceLock) {
            if (mSurface != null) {
                Canvas canvas = mSurface.lockCanvas(null);
                // Draw surface name for debug purpose only. This does not affect the test
                // because it is drawn only during allocation.
                if (drawSurfaceId) {
                    int textSize = canvas.getHeight() / 24;
                    Paint paint = new Paint();
                    paint.setTextSize(textSize);
                    int textWidth = (int)(paint.measureText(mName) + 0.5f);
                    int x = mRandom.nextInt(canvas.getWidth() - textWidth);
                    int y = textSize + mRandom.nextInt(canvas.getHeight() - textSize);
                    // Create effect of fog to visually control correctness of composition.
                    paint.setColor(0xFFFF8040);
                    canvas.drawARGB(32, 255, 255, 255);
                    canvas.drawText(mName, x, y, paint);
                }
                mSurface.unlockCanvasAndPost(canvas);
            }
        }
    }

    /**
     * Wait until surface is created and ready to use or return immediately if surface
     * already exists.
     */
    public void waitForSurfaceReady() {
        synchronized (mSurfaceLock) {
            if (mSurface == null) {
                try {
                    mSurfaceLock.wait(5000);
                } catch(InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if (mSurface == null)
                throw new RuntimeException("Surface is not ready.");
            mSurfaceWasChanged = false;
        }
    }

    /**
     * Wait until surface is destroyed or return immediately if surface does not exist.
     */
    public void waitForSurfaceDestroyed() {
        synchronized (mSurfaceLock) {
            if (mSurface != null) {
                try {
                    mSurfaceLock.wait(5000);
                } catch(InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if (mSurface != null)
                throw new RuntimeException("Surface still exists.");
            mSurfaceWasChanged = false;
        }
    }

    /**
     * Validate that surface has not been changed since waitForSurfaceReady or
     * waitForSurfaceDestroyed.
     */
    public void validateSurfaceNotChanged() {
        synchronized (mSurfaceLock) {
            if (mSurfaceWasChanged) {
                throw new RuntimeException("Surface was changed during the test execution.");
            }
        }
    }

    public double measureFPS(double badFPS, double perfectFPS) {
        try {
            ValidateThread validateThread = new ValidateThread(badFPS, perfectFPS);
            validateThread.start();
            validateThread.join();
            return validateThread.getFPS();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        synchronized (mSurfaceLock) {
            mSurfaceWasChanged = true;
        }
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        // This method is always called at least once, after surfaceCreated.
        synchronized (mSurfaceLock) {
            mSurface = holder.getSurface();
            // We only need to invalidate the surface for the compositor performance test so that
            // it gets included in the composition process. For allocation performance we
            // don't need to invalidate surface and this allows us to remove non-necessary
            // surface invalidation from the test.
            if (mDrawNameOnReady) {
                invalidateSurface(true);
            }
            mSurfaceWasChanged = true;
            mSurfaceLock.notify();
        }
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        synchronized (mSurfaceLock) {
            mSurface = null;
            mSurfaceWasChanged = true;
            mSurfaceLock.notify();
        }
    }
}