Use estimated vsync period on Android

ui/android/java/src/org/chromium/ui/VSyncMonitor.java

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.ui;
 
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.os.Build;
 import android.os.Handler;
 import android.view.Choreographer;
 import android.view.WindowManager;
 
 import org.chromium.base.TraceEvent;
 
 /**
  * Notifies clients of the default displays's vertical sync pulses.
  * On ICS, VSyncMonitor relies on setVSyncPointForICS() being called to set a reasonable
  * approximation of a vertical sync starting point; see also http://crbug.com/156397.
  */
 @SuppressLint("NewApi")
 public class VSyncMonitor {
     private static final long NANOSECONDS_PER_SECOND = 1000000000;
     private static final long NANOSECONDS_PER_MILLISECOND = 1000000;
     private static final long NANOSECONDS_PER_MICROSECOND = 1000;
 
+    private static final long MAX_VALID_VSYNC_PERIOD_NANOSECONDS = NANOSECONDS_PER_SECOND / 30;

[jdduke (slow), 2014/10/08 03:17:02]

I don't think this is used any longer?

+
     private boolean mInsideVSync = false;
 
+    // Conservative guess about vsync's consecutivity.
+    // If true, next tick is guaranteed to be consecutive.
+    private boolean mConsecutiveVSync = false;
+
     /**
      * VSync listener class
      */
     public interface Listener {
         /**
          * Called very soon after the start of the display's vertical sync period.
          * @param monitor The VSyncMonitor that triggered the signal.
          * @param vsyncTimeMicros Absolute frame time in microseconds.
          */
         public void onVSync(VSyncMonitor monitor, long vsyncTimeMicros);
     }
 
     private Listener mListener;
 
     // Display refresh rate as reported by the system.
-    private final long mRefreshPeriodNano;
+    private long mRefreshPeriodNano;
 
     private boolean mHaveRequestInFlight;
 
     // Choreographer is used to detect vsync on >= JB.
     private final Choreographer mChoreographer;
     private final Choreographer.FrameCallback mVSyncFrameCallback;
 
     // On ICS we just post a task through the handler (http://crbug.com/156397)
     private final Runnable mVSyncRunnableCallback;
     private long mGoodStartingPointNano;
@@ skipping 17 matching lines @@
     /**
      * Constructs a VSyncMonitor
      * @param context The application context.
      * @param listener The listener receiving VSync notifications.
      * @param enableJBVsync Whether to allow Choreographer-based notifications on JB and up.
      */
     public VSyncMonitor(Context context, VSyncMonitor.Listener listener, boolean enableJBVSync) {
         mListener = listener;
         float refreshRate = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE))
                 .getDefaultDisplay().getRefreshRate();
+        final boolean useEstimatedRefreshPeriod = refreshRate < 30;

[jdduke (slow), 2014/10/08 03:17:02]

I see 30 both here and above in the MAX_VALID_VSYNC_PERIOD_NANOSECONDS
calculation. If they're at all coupled, could we pull out the 30 constant to
somewhere above? Or actually, it looks like the constant at the top is unused?

+
         if (refreshRate <= 0) refreshRate = 60;
         mRefreshPeriodNano = (long) (NANOSECONDS_PER_SECOND / refreshRate);
 
         if (enableJBVSync && Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
             // Use Choreographer on JB+ to get notified of vsync.
             mChoreographer = Choreographer.getInstance();
             mVSyncFrameCallback = new Choreographer.FrameCallback() {
                 @Override
                 public void doFrame(long frameTimeNanos) {
                     TraceEvent.begin("VSync");
+                    if (useEstimatedRefreshPeriod && mConsecutiveVSync) {
+                        // Display.getRefreshRate() is unreliable on some platforms.
+                        // Adjust refresh period- initial value is based on Display.getRefreshRate()
+                        // after that it asymptotically approaches the real value.
+                        long lastRefreshDurationNano = frameTimeNanos - mGoodStartingPointNano;
+                        float lastRefreshDurationWeight = 0.1f;
+                        mRefreshPeriodNano += (long) (lastRefreshDurationWeight *

[jdduke (slow), 2014/10/08 03:17:02]

Hmm, I could be wrong, but don't you need to reweight this like:

mRefreshPeriodNano =  (1 - lastRefreshDurationWieght) * mRefreshPeriodNano +
lastRefreshDurationWeight * (lastRefreshDurationNano - mRefreshPeriodNano)?

Otherwise this will just grow without bound? What am I missing?

[Sami, 2014/10/08 10:14:51]

Hmm, I think that reduces to mRefreshPeriodNano = lastRefreshDurationNano / 2
which doesn't look right :) The current code is reducing the error between the
new period and the estimate. The bigger lastRefreshDurationWeight is, the faster
the convergence.

[jdduke (slow), 2014/10/08 13:06:00]

Of course, sigh, I should actually read the variable names =/ I glossed over the
subtraction term and thought it was computing the most recent period, rather
than the difference between the most recent period and the smoothed period.

+                                (lastRefreshDurationNano - mRefreshPeriodNano));
+                    }
                     mGoodStartingPointNano = frameTimeNanos;
                     onVSyncCallback(frameTimeNanos, getCurrentNanoTime());
                     TraceEvent.end("VSync");
                 }
             };
             mVSyncRunnableCallback = null;
         } else {
             // On ICS we just hope that running tasks is relatively predictable.
             mChoreographer = null;
             mVSyncFrameCallback = null;
@@ skipping 77 matching lines @@
         } finally {
             mInsideVSync = false;
         }
     }
 
     private void postCallback() {
         if (mHaveRequestInFlight) return;
         mHaveRequestInFlight = true;
         if (postSyntheticVSync()) return;
         if (isVSyncSignalAvailable()) {
+            mConsecutiveVSync = mInsideVSync;
             mChoreographer.postFrameCallback(mVSyncFrameCallback);
         } else {
             postRunnableCallback();
         }
     }
 
     private boolean postSyntheticVSync() {
         final long currentTime = getCurrentNanoTime();
         // Only trigger a synthetic vsync if we've been idle for long enough and the upcoming real
         // vsync is more than half a frame away.
@@ skipping 18 matching lines @@
 
         if (currentTime + delay <= mLastPostedNano + mRefreshPeriodNano / 2) {
             delay += mRefreshPeriodNano;
         }
 
         mLastPostedNano = currentTime + delay;
         if (delay == 0) mHandler.post(mVSyncRunnableCallback);
         else mHandler.postDelayed(mVSyncRunnableCallback, delay / NANOSECONDS_PER_MILLISECOND);
     }
 }