Version 10.8.2

This can happen if a stylus hover event is received while touching an OSC element

app/build.gradle

@@ -9,8 +9,8 @@ android {
         minSdk 16
         targetSdk 33
 
-        versionName "10.8.1"
-        versionCode = 288
+        versionName "10.8.3"
+        versionCode = 292
 
         // Generate native debug symbols to allow Google Play to symbolicate our native crashes
         ndk.debugSymbolLevel = 'FULL'

app/src/main/java/com/limelight/Game.java

@@ -232,12 +232,18 @@ public class Game extends Activity implements SurfaceHolder.Callback,
             }
         }
 
-        // Listen for events on the game surface
+        // Listen for non-touch events on the game surface
         streamView = findViewById(R.id.surfaceView);
         streamView.setOnGenericMotionListener(this);
-        streamView.setOnTouchListener(this);
         streamView.setInputCallbacks(this);
 
+        // Listen for touch events on the background touch view to enable trackpad mode
+        // to work on areas outside of the StreamView itself. We use a separate View
+        // for this rather than just handling it at the Activity level, because that
+        // allows proper touch splitting, which the OSC relies upon.
+        View backgroundTouchView = findViewById(R.id.backgroundTouchView);
+        backgroundTouchView.setOnTouchListener(this);
+
         boolean needsInputBatching = false;
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
             // Request unbuffered input event dispatching for all input classes we handle here.
@@ -1574,15 +1580,22 @@ public class Game extends Activity implements SurfaceHolder.Callback,
                     return true;
                 }
 
-                if (view == null && !prefConfig.touchscreenTrackpad) {
-                    // Absolute touch events should be dropped outside our view.
-                    return true;
+                // If this is the parent view, we'll offset our coordinates to appear as if they
+                // are relative to the StreamView like our StreamView touch events are.
+                float xOffset, yOffset;
+                if (view != streamView && !prefConfig.touchscreenTrackpad) {
+                    xOffset = -streamView.getX();
+                    yOffset = -streamView.getY();
+                }
+                else {
+                    xOffset = 0.f;
+                    yOffset = 0.f;
                 }
 
                 int actionIndex = event.getActionIndex();
 
-                int eventX = (int)event.getX(actionIndex);
-                int eventY = (int)event.getY(actionIndex);
+                int eventX = (int)(event.getX(actionIndex) + xOffset);
+                int eventY = (int)(event.getY(actionIndex) + yOffset);
 
                 // Special handling for 3 finger gesture
                 if (event.getActionMasked() == MotionEvent.ACTION_POINTER_DOWN &&
@@ -1637,7 +1650,10 @@ public class Game extends Activity implements SurfaceHolder.Callback,
                     }
                     if (actionIndex == 0 && event.getPointerCount() > 1 && !context.isCancelled()) {
                         // The original secondary touch now becomes primary
-                        context.touchDownEvent((int)event.getX(1), (int)event.getY(1), event.getEventTime(), false);
+                        context.touchDownEvent(
+                                (int)(event.getX(1) + xOffset),
+                                (int)(event.getY(1) + yOffset),
+                                event.getEventTime(), false);
                     }
                     break;
                 case MotionEvent.ACTION_MOVE:
@@ -1650,8 +1666,8 @@ public class Game extends Activity implements SurfaceHolder.Callback,
                             if (aTouchContextMap.getActionIndex() < event.getPointerCount())
                             {
                                 aTouchContextMap.touchMoveEvent(
-                                        (int)event.getHistoricalX(aTouchContextMap.getActionIndex(), i),
-                                        (int)event.getHistoricalY(aTouchContextMap.getActionIndex(), i),
+                                        (int)(event.getHistoricalX(aTouchContextMap.getActionIndex(), i) + xOffset),
+                                        (int)(event.getHistoricalY(aTouchContextMap.getActionIndex(), i) + yOffset),
                                         event.getHistoricalEventTime(i));
                             }
                         }
@@ -1662,8 +1678,8 @@ public class Game extends Activity implements SurfaceHolder.Callback,
                         if (aTouchContextMap.getActionIndex() < event.getPointerCount())
                         {
                             aTouchContextMap.touchMoveEvent(
-                                    (int)event.getX(aTouchContextMap.getActionIndex()),
-                                    (int)event.getY(aTouchContextMap.getActionIndex()),
+                                    (int)(event.getX(aTouchContextMap.getActionIndex()) + xOffset),
+                                    (int)(event.getY(aTouchContextMap.getActionIndex()) + yOffset),
                                     event.getEventTime());
                         }
                     }
@@ -1687,22 +1703,27 @@ public class Game extends Activity implements SurfaceHolder.Callback,
         return false;
     }
 
-    @Override
-    public boolean onTouchEvent(MotionEvent event) {
-        return handleMotionEvent(null, event) || super.onTouchEvent(event);
-
-    }
-
     @Override
     public boolean onGenericMotionEvent(MotionEvent event) {
         return handleMotionEvent(null, event) || super.onGenericMotionEvent(event);
 
     }
 
-    private void updateMousePosition(View view, MotionEvent event) {
+    private void updateMousePosition(View touchedView, MotionEvent event) {
         // X and Y are already relative to the provided view object
-        float eventX = event.getX(0);
-        float eventY = event.getY(0);
+        float eventX, eventY;
+
+        // For our StreamView itself, we can use the coordinates unmodified.
+        if (touchedView == streamView) {
+            eventX = event.getX(0);
+            eventY = event.getY(0);
+        }
+        else {
+            // For the containing background view, we must subtract the origin
+            // of the StreamView to get video-relative coordinates.
+            eventX = event.getX(0) - streamView.getX();
+            eventY = event.getY(0) - streamView.getY();
+        }
 
         if (event.getPointerCount() == 1 && event.getActionIndex() == 0 &&
                 (event.getToolType(0) == MotionEvent.TOOL_TYPE_ERASER ||
@@ -1735,10 +1756,10 @@ public class Game extends Activity implements SurfaceHolder.Callback,
         // Normalize these to the view size. We can't just drop them because we won't always get an event
         // right at the boundary of the view, so dropping them would result in our cursor never really
         // reaching the sides of the screen.
-        eventX = Math.min(Math.max(eventX, 0), view.getWidth());
-        eventY = Math.min(Math.max(eventY, 0), view.getHeight());
+        eventX = Math.min(Math.max(eventX, 0), streamView.getWidth());
+        eventY = Math.min(Math.max(eventY, 0), streamView.getHeight());
 
-        conn.sendMousePosition((short)eventX, (short)eventY, (short)view.getWidth(), (short)view.getHeight());
+        conn.sendMousePosition((short)eventX, (short)eventY, (short)streamView.getWidth(), (short)streamView.getHeight());
     }
 
     @Override
@@ -1757,6 +1778,7 @@ public class Game extends Activity implements SurfaceHolder.Callback,
                 view.requestUnbufferedDispatch(event);
             }
         }
+
         return handleMotionEvent(view, event);
     }
 

app/src/main/java/com/limelight/binding/input/ControllerHandler.java

@@ -9,6 +9,8 @@ import android.hardware.usb.UsbManager;
 import android.media.AudioAttributes;
 import android.os.Build;
 import android.os.CombinedVibration;
+import android.os.Handler;
+import android.os.Looper;
 import android.os.VibrationAttributes;
 import android.os.VibrationEffect;
 import android.os.Vibrator;
@@ -34,8 +36,6 @@ import com.limelight.utils.Vector2d;
 import org.cgutman.shieldcontrollerextensions.SceManager;
 
 import java.lang.reflect.InvocationTargetException;
-import java.util.Timer;
-import java.util.TimerTask;
 
 public class ControllerHandler implements InputManager.InputDeviceListener, UsbDriverListener {
 
@@ -60,6 +60,7 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
     private final GameGestures gestures;
     private final Vibrator deviceVibrator;
     private final SceManager sceManager;
+    private final Handler handler;
     private boolean hasGameController;
 
     private final PreferenceConfiguration prefConfig;
@@ -71,6 +72,7 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
         this.gestures = gestures;
         this.prefConfig = prefConfig;
         this.deviceVibrator = (Vibrator) activityContext.getSystemService(Context.VIBRATOR_SERVICE);
+        this.handler = new Handler(Looper.getMainLooper());
 
         this.sceManager = new SceManager(activityContext);
         this.sceManager.start();
@@ -1292,28 +1294,6 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
         }
     }
 
-    private void toggleMouseEmulation(final GenericControllerContext context) {
-        if (context.mouseEmulationTimer != null) {
-            context.mouseEmulationTimer.cancel();
-            context.mouseEmulationTimer = null;
-        }
-
-        context.mouseEmulationActive = !context.mouseEmulationActive;
-        Toast.makeText(activityContext, "Mouse emulation is: " + (context.mouseEmulationActive ? "ON" : "OFF"), Toast.LENGTH_SHORT).show();
-
-        if (context.mouseEmulationActive) {
-            context.mouseEmulationTimer = new Timer();
-            context.mouseEmulationTimer.schedule(new TimerTask() {
-                @Override
-                public void run() {
-                    // Send mouse movement events from analog sticks
-                    sendEmulatedMouseEvent(context.leftStickX, context.leftStickY);
-                    sendEmulatedMouseEvent(context.rightStickX, context.rightStickY);
-                }
-            }, 50, 50);
-        }
-    }
-
     @TargetApi(31)
     private boolean hasDualAmplitudeControlledRumbleVibrators(VibratorManager vm) {
         int[] vibratorIds = vm.getVibratorIds();
@@ -1531,7 +1511,7 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
             if ((context.inputMap & ControllerPacket.PLAY_FLAG) != 0 &&
                     event.getEventTime() - context.startDownTime > ControllerHandler.START_DOWN_TIME_MOUSE_MODE_MS &&
                     prefConfig.mouseEmulation) {
-                toggleMouseEmulation(context);
+                context.toggleMouseEmulation();
             }
             context.inputMap &= ~ControllerPacket.PLAY_FLAG;
             break;
@@ -1878,7 +1858,7 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
         usbDeviceContexts.put(controller.getControllerId(), context);
     }
 
-    static class GenericControllerContext {
+    class GenericControllerContext {
         public int id;
         public boolean external;
 
@@ -1902,14 +1882,38 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
         public short leftStickY = 0x0000;
 
         public boolean mouseEmulationActive;
-        public Timer mouseEmulationTimer;
         public short mouseEmulationLastInputMap;
+        public final int mouseEmulationReportPeriod = 50;
+
+        public final Runnable mouseEmulationRunnable = new Runnable() {
+            @Override
+            public void run() {
+                if (!mouseEmulationActive) {
+                    return;
+                }
+
+                // Send mouse movement events from analog sticks
+                sendEmulatedMouseEvent(leftStickX, leftStickY);
+                sendEmulatedMouseEvent(rightStickX, rightStickY);
+
+                // Requeue the callback
+                handler.postDelayed(this, mouseEmulationReportPeriod);
+            }
+        };
+
+        public void toggleMouseEmulation() {
+            handler.removeCallbacks(mouseEmulationRunnable);
+            mouseEmulationActive = !mouseEmulationActive;
+            Toast.makeText(activityContext, "Mouse emulation is: " + (mouseEmulationActive ? "ON" : "OFF"), Toast.LENGTH_SHORT).show();
+
+            if (mouseEmulationActive) {
+                handler.postDelayed(mouseEmulationRunnable, mouseEmulationReportPeriod);
+            }
+        }
 
         public void destroy() {
-            if (mouseEmulationTimer != null) {
-                mouseEmulationTimer.cancel();
-                mouseEmulationTimer = null;
-            }
+            mouseEmulationActive = false;
+            handler.removeCallbacks(mouseEmulationRunnable);
         }
     }
 

app/src/main/java/com/limelight/binding/input/touch/AbsoluteTouchContext.java

@@ -7,9 +7,6 @@ import android.view.View;
 import com.limelight.nvstream.NvConnection;
 import com.limelight.nvstream.input.MouseButtonPacket;
 
-import java.util.Timer;
-import java.util.TimerTask;
-
 public class AbsoluteTouchContext implements TouchContext {
     private int lastTouchDownX = 0;
     private int lastTouchDownY = 0;
@@ -22,8 +19,29 @@ public class AbsoluteTouchContext implements TouchContext {
     private boolean cancelled;
     private boolean confirmedLongPress;
     private boolean confirmedTap;
-    private Timer longPressTimer;
-    private Timer tapDownTimer;
+
+    private final Runnable longPressRunnable = new Runnable() {
+        @Override
+        public void run() {
+            // This timer should have already expired, but cancel it just in case
+            cancelTapDownTimer();
+
+            // Switch from a left click to a right click after a long press
+            confirmedLongPress = true;
+            if (confirmedTap) {
+                conn.sendMouseButtonUp(MouseButtonPacket.BUTTON_LEFT);
+            }
+            conn.sendMouseButtonDown(MouseButtonPacket.BUTTON_RIGHT);
+        }
+    };
+
+    private final Runnable tapDownRunnable = new Runnable() {
+        @Override
+        public void run() {
+            // Start our tap
+            tapConfirmed();
+        }
+    };
 
     private final NvConnection conn;
     private final int actionIndex;
@@ -136,67 +154,22 @@ public class AbsoluteTouchContext implements TouchContext {
         lastTouchUpTime = eventTime;
     }
 
-    private synchronized void startLongPressTimer() {
-        longPressTimer = new Timer(true);
-        longPressTimer.schedule(new TimerTask() {
-            @Override
-            public void run() {
-                synchronized (AbsoluteTouchContext.this) {
-                    // Check if someone cancelled us
-                    if (longPressTimer == null) {
-                        return;
-                    }
-
-                    // Uncancellable now
-                    longPressTimer = null;
-
-                    // This timer should have already expired, but cancel it just in case
-                    cancelTapDownTimer();
-
-                    // Switch from a left click to a right click after a long press
-                    confirmedLongPress = true;
-                    if (confirmedTap) {
-                        conn.sendMouseButtonUp(MouseButtonPacket.BUTTON_LEFT);
-                    }
-                    conn.sendMouseButtonDown(MouseButtonPacket.BUTTON_RIGHT);
-                }
-            }
-        }, LONG_PRESS_TIME_THRESHOLD);
+    private void startLongPressTimer() {
+        cancelLongPressTimer();
+        handler.postDelayed(longPressRunnable, LONG_PRESS_TIME_THRESHOLD);
     }
 
-    private synchronized void cancelLongPressTimer() {
-        if (longPressTimer != null) {
-            longPressTimer.cancel();
-            longPressTimer = null;
-        }
+    private void cancelLongPressTimer() {
+        handler.removeCallbacks(longPressRunnable);
     }
 
-    private synchronized void startTapDownTimer() {
-        tapDownTimer = new Timer(true);
-        tapDownTimer.schedule(new TimerTask() {
-            @Override
-            public void run() {
-                synchronized (AbsoluteTouchContext.this) {
-                    // Check if someone cancelled us
-                    if (tapDownTimer == null) {
-                        return;
-                    }
-
-                    // Uncancellable now
-                    tapDownTimer = null;
-
-                    // Start our tap
-                    tapConfirmed();
-                }
-            }
-        }, TOUCH_DOWN_DEAD_ZONE_TIME_THRESHOLD);
+    private void startTapDownTimer() {
+        cancelTapDownTimer();
+        handler.postDelayed(tapDownRunnable, TOUCH_DOWN_DEAD_ZONE_TIME_THRESHOLD);
     }
 
-    private synchronized void cancelTapDownTimer() {
-        if (tapDownTimer != null) {
-            tapDownTimer.cancel();
-            tapDownTimer = null;
-        }
+    private void cancelTapDownTimer() {
+        handler.removeCallbacks(tapDownRunnable);
     }
 
     private void tapConfirmed() {

app/src/main/java/com/limelight/binding/input/touch/RelativeTouchContext.java

@@ -8,9 +8,6 @@ import com.limelight.nvstream.NvConnection;
 import com.limelight.nvstream.input.MouseButtonPacket;
 import com.limelight.preferences.PreferenceConfiguration;
 
-import java.util.Timer;
-import java.util.TimerTask;
-
 public class RelativeTouchContext implements TouchContext {
     private int lastTouchX = 0;
     private int lastTouchY = 0;
@@ -21,7 +18,6 @@ public class RelativeTouchContext implements TouchContext {
     private boolean confirmedMove;
     private boolean confirmedDrag;
     private boolean confirmedScroll;
-    private Timer dragTimer;
     private double distanceMoved;
     private double xFactor, yFactor;
     private int pointerCount;
@@ -35,6 +31,25 @@ public class RelativeTouchContext implements TouchContext {
     private final PreferenceConfiguration prefConfig;
     private final Handler handler;
 
+    private final Runnable dragTimerRunnable = new Runnable() {
+        @Override
+        public void run() {
+            // Check if someone already set move
+            if (confirmedMove) {
+                return;
+            }
+
+            // The drag should only be processed for the primary finger
+            if (actionIndex != maxPointerCountInGesture - 1) {
+                return;
+            }
+
+            // We haven't been cancelled before the timer expired so begin dragging
+            confirmedDrag = true;
+            conn.sendMouseButtonDown(getMouseButtonIndex());
+        }
+    };
+
     // Indexed by MouseButtonPacket.BUTTON_XXX - 1
     private final Runnable[] buttonUpRunnables = new Runnable[] {
             new Runnable() {
@@ -184,49 +199,16 @@ public class RelativeTouchContext implements TouchContext {
         }
     }
 
-    private synchronized void startDragTimer() {
-        // Cancel any existing drag timers
+    private void startDragTimer() {
         cancelDragTimer();
-
-        dragTimer = new Timer(true);
-        dragTimer.schedule(new TimerTask() {
-            @Override
-            public void run() {
-                synchronized (RelativeTouchContext.this) {
-                    // Check if someone already set move
-                    if (confirmedMove) {
-                        return;
-                    }
-
-                    // The drag should only be processed for the primary finger
-                    if (actionIndex != maxPointerCountInGesture - 1) {
-                        return;
-                    }
-
-                    // Check if someone cancelled us
-                    if (dragTimer == null) {
-                        return;
-                    }
-
-                    // Uncancellable now
-                    dragTimer = null;
-
-                    // We haven't been cancelled before the timer expired so begin dragging
-                    confirmedDrag = true;
-                    conn.sendMouseButtonDown(getMouseButtonIndex());
-                }
-            }
-        }, DRAG_TIME_THRESHOLD);
+        handler.postDelayed(dragTimerRunnable, DRAG_TIME_THRESHOLD);
     }
 
-    private synchronized void cancelDragTimer() {
-        if (dragTimer != null) {
-            dragTimer.cancel();
-            dragTimer = null;
-        }
+    private void cancelDragTimer() {
+        handler.removeCallbacks(dragTimerRunnable);
     }
 
-    private synchronized void checkForConfirmedMove(int eventX, int eventY) {
+    private void checkForConfirmedMove(int eventX, int eventY) {
         // If we've already confirmed something, get out now
         if (confirmedMove || confirmedDrag) {
             return;

app/src/main/java/com/limelight/binding/input/virtual_controller/AnalogStick.java

@@ -305,8 +305,7 @@ public class AnalogStick extends VirtualControllerElement {
         // handle event depending on action
         switch (event.getActionMasked()) {
             // down event (touch event)
-            case MotionEvent.ACTION_DOWN:
-            case MotionEvent.ACTION_POINTER_DOWN: {
+            case MotionEvent.ACTION_DOWN: {
                 // set to dead zoned, will be corrected in update position if necessary
                 stick_state = STICK_STATE.MOVED_IN_DEAD_ZONE;
                 // check for double click
@@ -325,8 +324,8 @@ public class AnalogStick extends VirtualControllerElement {
                 break;
             }
             // up event (revoke touch)
-            case MotionEvent.ACTION_UP:
-            case MotionEvent.ACTION_POINTER_UP: {
+            case MotionEvent.ACTION_CANCEL:
+            case MotionEvent.ACTION_UP: {
                 setPressed(false);
                 break;
             }

app/src/main/java/com/limelight/binding/input/virtual_controller/DigitalButton.java

@@ -14,8 +14,6 @@ import android.view.MotionEvent;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Timer;
-import java.util.TimerTask;
 
 /**
  * This is a digital button on screen element. It is used to get click and double click user input.
@@ -43,22 +41,16 @@ public class DigitalButton extends VirtualControllerElement {
         void onRelease();
     }
 
-    /**
-     *
-     */
-    private class TimerLongClickTimerTask extends TimerTask {
-        @Override
-        public void run() {
-            onLongClickCallback();
-        }
-    }
-
     private List<DigitalButtonListener> listeners = new ArrayList<>();
     private String text = "";
     private int icon = -1;
     private long timerLongClickTimeout = 3000;
-    private Timer timerLongClick = null;
-    private TimerLongClickTimerTask longClickTimerTask = null;
+    private final Runnable longClickRunnable = new Runnable() {
+        @Override
+        public void run() {
+            onLongClickCallback();
+        }
+    };
 
     private final Paint paint = new Paint();
     private final RectF rect = new RectF();
@@ -177,18 +169,8 @@ public class DigitalButton extends VirtualControllerElement {
             listener.onClick();
         }
 
-        if (timerLongClick != null) {
-            timerLongClick.cancel();
-            timerLongClick = null;
-        }
-        if (longClickTimerTask != null) {
-            longClickTimerTask.cancel();
-            longClickTimerTask = null;
-        }
-
-        timerLongClick = new Timer();
-        longClickTimerTask = new TimerLongClickTimerTask();
-        timerLongClick.schedule(longClickTimerTask, timerLongClickTimeout);
+        virtualController.getHandler().removeCallbacks(longClickRunnable);
+        virtualController.getHandler().postDelayed(longClickRunnable, timerLongClickTimeout);
     }
 
     private void onLongClickCallback() {
@@ -207,14 +189,7 @@ public class DigitalButton extends VirtualControllerElement {
         }
 
         // We may be called for a release without a prior click
-        if (timerLongClick != null) {
-            timerLongClick.cancel();
-            timerLongClick = null;
-        }
-        if (longClickTimerTask != null) {
-            longClickTimerTask.cancel();
-            longClickTimerTask = null;
-        }
+        virtualController.getHandler().removeCallbacks(longClickRunnable);
     }
 
     @Override
@@ -225,8 +200,7 @@ public class DigitalButton extends VirtualControllerElement {
         int action = event.getActionMasked();
 
         switch (action) {
-            case MotionEvent.ACTION_DOWN:
-            case MotionEvent.ACTION_POINTER_DOWN: {
+            case MotionEvent.ACTION_DOWN: {
                 movingButton = null;
                 setPressed(true);
                 onClickCallback();
@@ -241,8 +215,7 @@ public class DigitalButton extends VirtualControllerElement {
                 return true;
             }
             case MotionEvent.ACTION_CANCEL:
-            case MotionEvent.ACTION_UP:
-            case MotionEvent.ACTION_POINTER_UP: {
+            case MotionEvent.ACTION_UP: {
                 setPressed(false);
                 onReleaseCallback();
 

app/src/main/java/com/limelight/binding/input/virtual_controller/DigitalPad.java

@@ -162,7 +162,6 @@ public class DigitalPad extends VirtualControllerElement {
         // get masked (not specific to a pointer) action
         switch (event.getActionMasked()) {
             case MotionEvent.ACTION_DOWN:
-            case MotionEvent.ACTION_POINTER_DOWN:
             case MotionEvent.ACTION_MOVE: {
                 direction = 0;
 
@@ -184,8 +183,7 @@ public class DigitalPad extends VirtualControllerElement {
                 return true;
             }
             case MotionEvent.ACTION_CANCEL:
-            case MotionEvent.ACTION_UP:
-            case MotionEvent.ACTION_POINTER_UP: {
+            case MotionEvent.ACTION_UP: {
                 direction = 0;
                 newDirectionCallback(direction);
                 invalidate();

app/src/main/java/com/limelight/binding/input/virtual_controller/VirtualController.java

@@ -5,6 +5,8 @@
 package com.limelight.binding.input.virtual_controller;
 
 import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
 import android.util.DisplayMetrics;
 import android.view.View;
 import android.widget.Button;
@@ -17,8 +19,6 @@ import com.limelight.binding.input.ControllerHandler;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Timer;
-import java.util.TimerTask;
 
 public class VirtualController {
     public static class ControllerInputContext {
@@ -41,11 +41,17 @@ public class VirtualController {
 
     private final ControllerHandler controllerHandler;
     private final Context context;
+    private final Handler handler;
+
+    private final Runnable delayedRetransmitRunnable = new Runnable() {
+        @Override
+        public void run() {
+            sendControllerInputContextInternal();
+        }
+    };
 
     private FrameLayout frame_layout = null;
 
-    private Timer retransmitTimer;
-
     ControllerMode currentMode = ControllerMode.Active;
     ControllerInputContext inputContext = new ControllerInputContext();
 
@@ -57,6 +63,7 @@ public class VirtualController {
         this.controllerHandler = controllerHandler;
         this.frame_layout = layout;
         this.context = context;
+        this.handler = new Handler(Looper.getMainLooper());
 
         buttonConfigure = new Button(context);
         buttonConfigure.setAlpha(0.25f);
@@ -91,9 +98,11 @@ public class VirtualController {
 
     }
 
-    public void hide() {
-        retransmitTimer.cancel();
+    Handler getHandler() {
+        return handler;
+    }
 
+    public void hide() {
         for (VirtualControllerElement element : elements) {
             element.setVisibility(View.INVISIBLE);
         }
@@ -107,18 +116,6 @@ public class VirtualController {
         }
 
         buttonConfigure.setVisibility(View.VISIBLE);
-
-        // HACK: GFE sometimes discards gamepad packets when they are received
-        // very shortly after another. This can be critical if an axis zeroing packet
-        // is lost and causes an analog stick to get stuck. To avoid this, we send
-        // a gamepad input packet every 100 ms to ensure any loss can be recovered.
-        retransmitTimer = new Timer("OSC timer", true);
-        retransmitTimer.schedule(new TimerTask() {
-            @Override
-            public void run() {
-                sendControllerInputContext();
-            }
-        }, 100, 100);
     }
 
     public void removeElements() {
@@ -181,7 +178,7 @@ public class VirtualController {
         return inputContext;
     }
 
-    void sendControllerInputContext() {
+    private void sendControllerInputContextInternal() {
         _DBG("INPUT_MAP + " + inputContext.inputMap);
         _DBG("LEFT_TRIGGER " + inputContext.leftTrigger);
         _DBG("RIGHT_TRIGGER " + inputContext.rightTrigger);
@@ -200,4 +197,19 @@ public class VirtualController {
             );
         }
     }
+
+    void sendControllerInputContext() {
+        // Cancel retransmissions of prior gamepad inputs
+        handler.removeCallbacks(delayedRetransmitRunnable);
+
+        sendControllerInputContextInternal();
+
+        // HACK: GFE sometimes discards gamepad packets when they are received
+        // very shortly after another. This can be critical if an axis zeroing packet
+        // is lost and causes an analog stick to get stuck. To avoid this, we retransmit
+        // the gamepad state a few times unless another input event happens before then.
+        handler.postDelayed(delayedRetransmitRunnable, 25);
+        handler.postDelayed(delayedRetransmitRunnable, 50);
+        handler.postDelayed(delayedRetransmitRunnable, 75);
+    }
 }

app/src/main/java/com/limelight/binding/input/virtual_controller/VirtualControllerConfigurationLoader.java

@@ -40,27 +40,31 @@ public class VirtualControllerConfigurationLoader {
                 VirtualController.ControllerInputContext inputContext =
                         controller.getControllerInputContext();
 
-                if (direction == DigitalPad.DIGITAL_PAD_DIRECTION_NO_DIRECTION) {
-                    inputContext.inputMap &= ~ControllerPacket.LEFT_FLAG;
-                    inputContext.inputMap &= ~ControllerPacket.RIGHT_FLAG;
-                    inputContext.inputMap &= ~ControllerPacket.UP_FLAG;
-                    inputContext.inputMap &= ~ControllerPacket.DOWN_FLAG;
-
-                    controller.sendControllerInputContext();
-                    return;
-                }
-                if ((direction & DigitalPad.DIGITAL_PAD_DIRECTION_LEFT) > 0) {
+                if ((direction & DigitalPad.DIGITAL_PAD_DIRECTION_LEFT) != 0) {
                     inputContext.inputMap |= ControllerPacket.LEFT_FLAG;
                 }
-                if ((direction & DigitalPad.DIGITAL_PAD_DIRECTION_RIGHT) > 0) {
+                else {
+                    inputContext.inputMap &= ~ControllerPacket.LEFT_FLAG;
+                }
+                if ((direction & DigitalPad.DIGITAL_PAD_DIRECTION_RIGHT) != 0) {
                     inputContext.inputMap |= ControllerPacket.RIGHT_FLAG;
                 }
-                if ((direction & DigitalPad.DIGITAL_PAD_DIRECTION_UP) > 0) {
+                else {
+                    inputContext.inputMap &= ~ControllerPacket.RIGHT_FLAG;
+                }
+                if ((direction & DigitalPad.DIGITAL_PAD_DIRECTION_UP) != 0) {
                     inputContext.inputMap |= ControllerPacket.UP_FLAG;
                 }
-                if ((direction & DigitalPad.DIGITAL_PAD_DIRECTION_DOWN) > 0) {
+                else {
+                    inputContext.inputMap &= ~ControllerPacket.UP_FLAG;
+                }
+                if ((direction & DigitalPad.DIGITAL_PAD_DIRECTION_DOWN) != 0) {
                     inputContext.inputMap |= ControllerPacket.DOWN_FLAG;
                 }
+                else {
+                    inputContext.inputMap &= ~ControllerPacket.DOWN_FLAG;
+                }
+
                 controller.sendControllerInputContext();
             }
         });

app/src/main/java/com/limelight/binding/input/virtual_controller/VirtualControllerElement.java

@@ -223,13 +223,21 @@ public abstract class VirtualControllerElement extends View {
 
     @Override
     public boolean onTouchEvent(MotionEvent event) {
+        // Ignore secondary touches on controls
+        //
+        // NB: We can get an additional pointer down if the user touches a non-StreamView area
+        // while also touching an OSC control, even if that pointer down doesn't correspond to
+        // an area of the OSC control.
+        if (event.getActionIndex() != 0) {
+            return true;
+        }
+
         if (virtualController.getControllerMode() == VirtualController.ControllerMode.Active) {
             return onElementTouchEvent(event);
         }
 
         switch (event.getActionMasked()) {
-            case MotionEvent.ACTION_DOWN:
-            case MotionEvent.ACTION_POINTER_DOWN: {
+            case MotionEvent.ACTION_DOWN: {
                 position_pressed_x = event.getX();
                 position_pressed_y = event.getY();
                 startSize_x = getWidth();
@@ -267,8 +275,7 @@ public abstract class VirtualControllerElement extends View {
                 return true;
             }
             case MotionEvent.ACTION_CANCEL:
-            case MotionEvent.ACTION_UP:
-            case MotionEvent.ACTION_POINTER_UP: {
+            case MotionEvent.ACTION_UP: {
                 actionCancel();
                 return true;
             }

app/src/main/java/com/limelight/binding/video/MediaCodecDecoderRenderer.java

@@ -1,9 +1,10 @@
 package com.limelight.binding.video;
 
+import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.List;
-import java.util.Locale;
 import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import org.jcodec.codecs.h264.H264Utils;
 import org.jcodec.codecs.h264.io.model.SeqParameterSet;
@@ -71,6 +72,23 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
     private boolean foreground = true;
     private PerfOverlayListener perfListener;
 
+    private static final int CR_TIMEOUT_MS = 5000;
+    private static final int CR_MAX_TRIES = 10;
+    private static final int CR_RECOVERY_TYPE_NONE = 0;
+    private static final int CR_RECOVERY_TYPE_RESTART = 1;
+    private static final int CR_RECOVERY_TYPE_RESET = 2;
+    private AtomicInteger codecRecoveryType = new AtomicInteger(CR_RECOVERY_TYPE_NONE);
+    private final Object codecRecoveryMonitor = new Object();
+
+    // Each thread that touches the MediaCodec object or any associated buffers must have a flag
+    // here and must call doCodecRecoveryIfRequired() on a regular basis.
+    private static final int CR_FLAG_INPUT_THREAD = 0x1;
+    private static final int CR_FLAG_RENDER_THREAD = 0x2;
+    private static final int CR_FLAG_CHOREOGRAPHER = 0x4;
+    private static final int CR_FLAG_ALL = CR_FLAG_INPUT_THREAD | CR_FLAG_RENDER_THREAD | CR_FLAG_CHOREOGRAPHER;
+    private int codecRecoveryThreadQuiescedFlags = 0;
+    private int codecRecoveryAttempts = 0;
+
     private MediaFormat inputFormat;
     private MediaFormat outputFormat;
     private MediaFormat configuredFormat;
@@ -337,68 +355,68 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
         return videoFormat;
     }
 
-    private boolean tryConfigureDecoder(MediaCodecInfo selectedDecoderInfo, MediaFormat format) {
-        try {
-            videoDecoder = MediaCodec.createByCodecName(selectedDecoderInfo.getName());
-            LimeLog.info("Configuring with format: "+format);
+    private void configureAndStartDecoder(MediaFormat format) {
+        LimeLog.info("Configuring with format: "+format);
 
-            videoDecoder.configure(format, renderTarget.getSurface(), null, 0);
+        videoDecoder.configure(format, renderTarget.getSurface(), null, 0);
 
-            configuredFormat = format;
+        configuredFormat = format;
 
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-                // This will contain the actual accepted input format attributes
-                inputFormat = videoDecoder.getInputFormat();
-                LimeLog.info("Input format: "+inputFormat);
-            }
+        // After reconfiguration, we must resubmit CSD buffers
+        submittedCsd = false;
+        submitCsdNextCall = false;
+        vpsBuffer = null;
+        spsBuffer = null;
+        ppsBuffer = null;
 
-            videoDecoder.setVideoScalingMode(MediaCodec.VIDEO_SCALING_MODE_SCALE_TO_FIT);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            // This will contain the actual accepted input format attributes
+            inputFormat = videoDecoder.getInputFormat();
+            LimeLog.info("Input format: "+inputFormat);
+        }
 
-            if (USE_FRAME_RENDER_TIME && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-                videoDecoder.setOnFrameRenderedListener(new MediaCodec.OnFrameRenderedListener() {
-                    @Override
-                    public void onFrameRendered(MediaCodec mediaCodec, long presentationTimeUs, long renderTimeNanos) {
-                        long delta = (renderTimeNanos / 1000000L) - (presentationTimeUs / 1000);
-                        if (delta >= 0 && delta < 1000) {
-                            if (USE_FRAME_RENDER_TIME) {
-                                activeWindowVideoStats.totalTimeMs += delta;
-                            }
-                        }
-                    }
-                }, null);
-            }
+        videoDecoder.setVideoScalingMode(MediaCodec.VIDEO_SCALING_MODE_SCALE_TO_FIT);
 
-            LimeLog.info("Using codec "+selectedDecoderInfo.getName()+" for hardware decoding "+format.getString(MediaFormat.KEY_MIME));
+        // Start the decoder
+        videoDecoder.start();
 
-            // Start the decoder
-            videoDecoder.start();
-
-            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
-                legacyInputBuffers = videoDecoder.getInputBuffers();
-            }
-
-            fetchNextInputBuffer();
-
-            return true;
-        } catch (Exception e) {
-            e.printStackTrace();
-
-            if (videoDecoder != null) {
-                videoDecoder.release();
-                videoDecoder = null;
-            }
-
-            return false;
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+            legacyInputBuffers = videoDecoder.getInputBuffers();
         }
     }
 
-    @Override
-    public int setup(int format, int width, int height, int redrawRate) {
-        this.initialWidth = width;
-        this.initialHeight = height;
-        this.videoFormat = format;
-        this.refreshRate = redrawRate;
+    private boolean tryConfigureDecoder(MediaCodecInfo selectedDecoderInfo, MediaFormat format, boolean throwOnCodecError) {
+        boolean configured = false;
+        try {
+            videoDecoder = MediaCodec.createByCodecName(selectedDecoderInfo.getName());
+            configureAndStartDecoder(format);
+            LimeLog.info("Using codec " + selectedDecoderInfo.getName() + " for hardware decoding " + format.getString(MediaFormat.KEY_MIME));
+            configured = true;
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+            if (throwOnCodecError) {
+                throw e;
+            }
+        } catch (IllegalStateException e) {
+            e.printStackTrace();
+            if (throwOnCodecError) {
+                throw e;
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+            if (throwOnCodecError) {
+                throw new RuntimeException(e);
+            }
+        } finally {
+            if (!configured && videoDecoder != null) {
+                videoDecoder.release();
+                videoDecoder = null;
+            }
+        }
+        return configured;
+    }
 
+    public int initializeDecoder(boolean throwOnCodecError) {
         String mimeType;
         MediaCodecInfo selectedDecoderInfo;
 
@@ -411,7 +429,7 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
                 return -1;
             }
 
-            if (width > 4096 || height > 4096) {
+            if (initialWidth > 4096 || initialHeight > 4096) {
                 LimeLog.severe("> 4K streaming only supported on HEVC");
                 return -1;
             }
@@ -464,7 +482,8 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
             // This will try low latency options until we find one that works (or we give up).
             boolean newFormat = MediaCodecHelper.setDecoderLowLatencyOptions(mediaFormat, selectedDecoderInfo, tryNumber);
 
-            if (tryConfigureDecoder(selectedDecoderInfo, mediaFormat)) {
+            // Throw the underlying codec exception on the last attempt if the caller requested it
+            if (tryConfigureDecoder(selectedDecoderInfo, mediaFormat, !newFormat && throwOnCodecError)) {
                 // Success!
                 break;
             }
@@ -475,26 +494,233 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
             }
         }
 
+        if (USE_FRAME_RENDER_TIME && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            videoDecoder.setOnFrameRenderedListener(new MediaCodec.OnFrameRenderedListener() {
+                @Override
+                public void onFrameRendered(MediaCodec mediaCodec, long presentationTimeUs, long renderTimeNanos) {
+                    long delta = (renderTimeNanos / 1000000L) - (presentationTimeUs / 1000);
+                    if (delta >= 0 && delta < 1000) {
+                        if (USE_FRAME_RENDER_TIME) {
+                            activeWindowVideoStats.totalTimeMs += delta;
+                        }
+                    }
+                }
+            }, null);
+        }
+
         return 0;
     }
 
-    private void handleDecoderException(Exception e, ByteBuffer buf, int codecFlags, boolean throwOnTransient) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-            if (e instanceof CodecException) {
-                CodecException codecExc = (CodecException) e;
+    @Override
+    public int setup(int format, int width, int height, int redrawRate) {
+        this.initialWidth = width;
+        this.initialHeight = height;
+        this.videoFormat = format;
+        this.refreshRate = redrawRate;
 
-                if (codecExc.isTransient() && !throwOnTransient) {
-                    // We'll let transient exceptions go
-                    LimeLog.warning(codecExc.getDiagnosticInfo());
-                    return;
+        return initializeDecoder(false);
+    }
+
+    // All threads that interact with the MediaCodec instance must call this function regularly!
+    private boolean doCodecRecoveryIfRequired(int quiescenceFlag) {
+        // NB: We cannot check 'stopping' here because we could end up bailing in a partially
+        // quiesced state that will cause the quiesced threads to never wake up.
+        if (codecRecoveryType.get() == CR_RECOVERY_TYPE_NONE) {
+            // Common case
+            return false;
+        }
+
+        // We need some sort of recovery, so quiesce all threads before starting that
+        synchronized (codecRecoveryMonitor) {
+            if (choreographerHandlerThread == null) {
+                // If we have no choreographer thread, we can just mark that as quiesced right now.
+                codecRecoveryThreadQuiescedFlags |= CR_FLAG_CHOREOGRAPHER;
+            }
+
+            codecRecoveryThreadQuiescedFlags |= quiescenceFlag;
+
+            if (codecRecoveryThreadQuiescedFlags == CR_FLAG_ALL) {
+                // This is the final thread to quiesce, so let's perform the codec recovery now.
+                codecRecoveryAttempts++;
+                LimeLog.info("Codec recovery attempt: "+codecRecoveryAttempts);
+
+                // Input and output buffers are invalidated by stop() and reset().
+                nextInputBuffer = null;
+                nextInputBufferIndex = -1;
+                outputBufferQueue.clear();
+
+                // For "recoverable" exceptions, we can just stop, reconfigure, and restart.
+                if (codecRecoveryType.get() == CR_RECOVERY_TYPE_RESTART) {
+                    LimeLog.warning("Trying to restart decoder after CodecException");
+                    try {
+                        videoDecoder.stop();
+                        configureAndStartDecoder(configuredFormat);
+                        codecRecoveryType.set(CR_RECOVERY_TYPE_NONE);
+                    } catch (IllegalArgumentException e) {
+                        e.printStackTrace();
+
+                        // Our Surface is probably invalid, so just stop
+                        stopping = true;
+                        codecRecoveryType.set(CR_RECOVERY_TYPE_NONE);
+                    } catch (IllegalStateException e) {
+                        e.printStackTrace();
+
+                        // Something went wrong during the restart, let's use a bigger hammer
+                        // and try a reset instead.
+                        codecRecoveryType.set(CR_RECOVERY_TYPE_RESET);
+                    }
                 }
 
-                LimeLog.severe(codecExc.getDiagnosticInfo());
+                // For "non-recoverable" exceptions on L+, we can call reset() to recover
+                // without having to recreate the entire decoder again.
+                if (codecRecoveryType.get() == CR_RECOVERY_TYPE_RESET && Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+                    LimeLog.warning("Trying to reset decoder after CodecException");
+                    try {
+                        videoDecoder.reset();
+                        configureAndStartDecoder(configuredFormat);
+                        codecRecoveryType.set(CR_RECOVERY_TYPE_NONE);
+                    } catch (IllegalArgumentException e) {
+                        e.printStackTrace();
+
+                        // Our Surface is probably invalid, so just stop
+                        stopping = true;
+                        codecRecoveryType.set(CR_RECOVERY_TYPE_NONE);
+                    } catch (IllegalStateException e) {
+                        e.printStackTrace();
+
+                        // Something went wrong during the reset, we'll have to resort to
+                        // releasing and recreating the decoder now.
+                    }
+                }
+
+                // If we _still_ haven't managed to recover, go for the nuclear option and just
+                // throw away the old decoder and reinitialize a new one from scratch.
+                if (codecRecoveryType.get() == CR_RECOVERY_TYPE_RESET) {
+                    LimeLog.warning("Trying to recreate decoder after CodecException");
+                    videoDecoder.release();
+
+                    try {
+                        int err = initializeDecoder(true);
+                        if (err != 0) {
+                            throw new IllegalStateException("Decoder reset failed: " + err);
+                        }
+                        codecRecoveryType.set(CR_RECOVERY_TYPE_NONE);
+                    } catch (IllegalArgumentException e) {
+                        e.printStackTrace();
+
+                        // Our Surface is probably invalid, so just stop
+                        stopping = true;
+                        codecRecoveryType.set(CR_RECOVERY_TYPE_NONE);
+                    } catch (IllegalStateException e) {
+                        // If we failed to recover after all of these attempts, just crash
+                        if (!reportedCrash) {
+                            reportedCrash = true;
+                            crashListener.notifyCrash(e);
+                        }
+                        throw new RendererException(this, e);
+                    }
+                }
+
+                // Wake all quiesced threads and allow them to begin work again
+                codecRecoveryThreadQuiescedFlags = 0;
+                codecRecoveryMonitor.notifyAll();
+            }
+            else {
+                // If we haven't quiesced all threads yet, wait to be signalled after recovery.
+                // The final thread to be quiesced will handle the codec recovery.
+                LimeLog.info("Waiting to quiesce decoder threads: "+codecRecoveryThreadQuiescedFlags);
+                long startTime = SystemClock.uptimeMillis();
+                while (codecRecoveryType.get() != CR_RECOVERY_TYPE_NONE) {
+                    try {
+                        if (SystemClock.uptimeMillis() - startTime >= CR_TIMEOUT_MS) {
+                            throw new IllegalStateException("Decoder failed to recover within timeout");
+                        }
+                        codecRecoveryMonitor.wait(CR_TIMEOUT_MS);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+
+                        // InterruptedException clears the thread's interrupt status. Since we can't
+                        // handle that here, we will re-interrupt the thread to set the interrupt
+                        // status back to true.
+                        Thread.currentThread().interrupt();
+
+                        break;
+                    }
+                }
             }
         }
 
-        // Only throw if we're not stopping
-        if (!stopping) {
+        return true;
+    }
+
+    // Returns true if the exception is transient
+    private boolean handleDecoderException(IllegalStateException e) {
+        // Eat decoder exceptions if we're in the process of stopping
+        if (stopping) {
+            return false;
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && e instanceof CodecException) {
+            CodecException codecExc = (CodecException) e;
+
+            if (codecExc.isTransient()) {
+                // We'll let transient exceptions go
+                LimeLog.warning(codecExc.getDiagnosticInfo());
+                return true;
+            }
+
+            LimeLog.severe(codecExc.getDiagnosticInfo());
+
+            // We can attempt a recovery or reset at this stage to try to start decoding again
+            if (codecRecoveryAttempts < CR_MAX_TRIES) {
+                // If the exception is non-recoverable or we already require a reset, perform a reset.
+                // If we have no prior unrecoverable failure, we will try a restart instead.
+                if (codecExc.isRecoverable() && codecRecoveryType.compareAndSet(CR_RECOVERY_TYPE_NONE, CR_RECOVERY_TYPE_RESTART)) {
+                    LimeLog.info("Decoder requires restart for recoverable CodecException");
+                    e.printStackTrace();
+                }
+                else if (!codecExc.isRecoverable()) {
+                    if (codecRecoveryType.compareAndSet(CR_RECOVERY_TYPE_NONE, CR_RECOVERY_TYPE_RESET)) {
+                        LimeLog.info("Decoder requires reset for non-recoverable CodecException");
+                        e.printStackTrace();
+                    }
+                    else if (codecRecoveryType.compareAndSet(CR_RECOVERY_TYPE_RESTART, CR_RECOVERY_TYPE_RESET)) {
+                        LimeLog.info("Decoder restart promoted to reset for non-recoverable CodecException");
+                        e.printStackTrace();
+                    }
+                    else if (codecRecoveryType.get() != CR_RECOVERY_TYPE_RESET) {
+                        throw new IllegalStateException("Unexpected codec recovery type" + codecRecoveryType.get());
+                    }
+                }
+
+                // The recovery will take place when all threads reach doCodecRecoveryIfRequired().
+                return false;
+            }
+        }
+        else {
+            // IllegalStateException was primarily used prior to the introduction of CodecException.
+            // Recovery from this requires a full decoder reset.
+            //
+            // NB: CodecException is an IllegalStateException, so we must check for it first.
+            if (codecRecoveryAttempts < CR_MAX_TRIES) {
+                if (codecRecoveryType.compareAndSet(CR_RECOVERY_TYPE_NONE, CR_RECOVERY_TYPE_RESET)) {
+                    LimeLog.info("Decoder requires reset for IllegalStateException");
+                    e.printStackTrace();
+                }
+                else if (codecRecoveryType.compareAndSet(CR_RECOVERY_TYPE_RESTART, CR_RECOVERY_TYPE_RESET)) {
+                    LimeLog.info("Decoder restart promoted to reset for IllegalStateException");
+                    e.printStackTrace();
+                }
+                else if (codecRecoveryType.get() != CR_RECOVERY_TYPE_RESET) {
+                    throw new IllegalStateException("Unexpected codec recovery type: " + codecRecoveryType.get());
+                }
+
+                return false;
+            }
+        }
+
+        // Only throw if we're not in the middle of codec recovery
+        if (codecRecoveryType.get() == CR_RECOVERY_TYPE_NONE) {
             //
             // There seems to be a race condition with decoder/surface teardown causing some
             // decoders to to throw IllegalStateExceptions even before 'stopping' is set.
@@ -515,15 +741,13 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
             }
             else {
                 // This is the first exception we've hit
-                if (buf != null || codecFlags != 0) {
-                    initialException = new RendererException(this, e, buf, codecFlags);
-                }
-                else {
-                    initialException = new RendererException(this, e);
-                }
+                initialException = new RendererException(this, e);
                 initialExceptionTimestamp = SystemClock.uptimeMillis();
             }
         }
+
+        // Not transient
+        return false;
     }
 
     @Override
@@ -555,13 +779,23 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
 
                     lastRenderedFrameTimeNanos = frameTimeNanos;
                     activeWindowVideoStats.totalFramesRendered++;
-                } catch (Exception e) {
-                    // This will leak nextOutputBuffer, but there's really nothing else we can do
-                    handleDecoderException(e, null, 0, false);
+                } catch (IllegalStateException ignored) {
+                    try {
+                        // Try to avoid leaking the output buffer by releasing it without rendering
+                        videoDecoder.releaseOutputBuffer(nextOutputBuffer, false);
+                    } catch (IllegalStateException e) {
+                        // This will leak nextOutputBuffer, but there's really nothing else we can do
+                        e.printStackTrace();
+                        handleDecoderException(e);
+                    }
                 }
             }
         }
 
+        // Attempt codec recovery even if we have nothing to render right now. Recovery can still
+        // be required even if the codec died before giving any output.
+        doCodecRecoveryIfRequired(CR_FLAG_CHOREOGRAPHER);
+
         // Request another callback for next frame
         Choreographer.getInstance().postFrameCallback(this);
     }
@@ -648,7 +882,13 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
                                 // run for a while (if there is a huge mismatch between stream FPS and display
                                 // refresh rate).
                                 if (outputBufferQueue.size() == OUTPUT_BUFFER_QUEUE_LIMIT) {
-                                    videoDecoder.releaseOutputBuffer(outputBufferQueue.take(), false);
+                                    try {
+                                        videoDecoder.releaseOutputBuffer(outputBufferQueue.take(), false);
+                                    } catch (InterruptedException e) {
+                                        // We're shutting down, so we can just drop this buffer on the floor
+                                        // and it will be reclaimed when the codec is released.
+                                        return;
+                                    }
                                 }
 
                                 // Add this buffer
@@ -676,8 +916,10 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
                                     break;
                             }
                         }
-                    } catch (Exception e) {
-                        handleDecoderException(e, null, 0, false);
+                    } catch (IllegalStateException e) {
+                        handleDecoderException(e);
+                    } finally {
+                        doCodecRecoveryIfRequired(CR_FLAG_RENDER_THREAD);
                     }
                 }
             }
@@ -689,8 +931,9 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
 
     private boolean fetchNextInputBuffer() {
         long startTime;
+        boolean codecRecovered;
 
-        if (nextInputBufferIndex >= 0) {
+        if (nextInputBuffer != null) {
             // We already have an input buffer
             return true;
         }
@@ -698,15 +941,23 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
         startTime = SystemClock.uptimeMillis();
 
         try {
+            // If we don't have an input buffer index yet, fetch one now
             while (nextInputBufferIndex < 0 && !stopping) {
                 nextInputBufferIndex = videoDecoder.dequeueInputBuffer(10000);
             }
 
+            // Get the backing ByteBuffer for the input buffer index
             if (nextInputBufferIndex >= 0) {
                 // Using the new getInputBuffer() API on Lollipop allows
                 // the framework to do some performance optimizations for us
                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                     nextInputBuffer = videoDecoder.getInputBuffer(nextInputBufferIndex);
+                    if (nextInputBuffer == null) {
+                        // According to the Android docs, getInputBuffer() can return null "if the
+                        // index is not a dequeued input buffer". I don't think this ever should
+                        // happen but if it does, let's try to get a new input buffer next time.
+                        nextInputBufferIndex = -1;
+                    }
                 }
                 else {
                     nextInputBuffer = legacyInputBuffers[nextInputBufferIndex];
@@ -715,8 +966,16 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
                     nextInputBuffer.clear();
                 }
             }
-        } catch (Exception e) {
-            handleDecoderException(e, null, 0, true);
+        } catch (IllegalStateException e) {
+            handleDecoderException(e);
+            return false;
+        } finally {
+            codecRecovered = doCodecRecoveryIfRequired(CR_FLAG_INPUT_THREAD);
+        }
+
+        // If codec recovery is required, always return false to ensure the caller will request
+        // an IDR frame to complete the codec recovery.
+        if (codecRecovered) {
             return false;
         }
 
@@ -726,7 +985,7 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
             LimeLog.warning("Dequeue input buffer ran long: " + deltaMs + " ms");
         }
 
-        if (nextInputBufferIndex < 0) {
+        if (nextInputBuffer == null) {
             // We've been hung for 5 seconds and no other exception was reported,
             // so generate a decoder hung exception
             if (deltaMs >= 5000 && initialException == null) {
@@ -760,6 +1019,12 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
             rendererThread.interrupt();
         }
 
+        // Stop any active codec recovery operations
+        synchronized (codecRecoveryMonitor) {
+            codecRecoveryType.set(CR_RECOVERY_TYPE_NONE);
+            codecRecoveryMonitor.notifyAll();
+        }
+
         // Post a quit message to the Choreographer looper (if we have one)
         if (choreographerHandler != null) {
             choreographerHandler.post(new Runnable() {
@@ -818,23 +1083,47 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
     }
 
     private boolean queueNextInputBuffer(long timestampUs, int codecFlags) {
+        boolean codecRecovered;
+
         try {
             videoDecoder.queueInputBuffer(nextInputBufferIndex,
                     0, nextInputBuffer.position(),
                     timestampUs, codecFlags);
-        } catch (Exception e) {
-            handleDecoderException(e, null, codecFlags, true);
-            return false;
-        } finally {
+
+            // We need a new buffer now
             nextInputBufferIndex = -1;
             nextInputBuffer = null;
+        } catch (IllegalStateException e) {
+            if (handleDecoderException(e)) {
+                // We encountered a transient error. In this case, just hold onto the buffer
+                // (to avoid leaking it), clear it, and keep it for the next frame. We'll return
+                // false to trigger an IDR frame to recover.
+                nextInputBuffer.clear();
+            }
+            else {
+                // We encountered a non-transient error. In this case, we will simply leak the
+                // buffer because we cannot be sure we will ever succeed in queuing it.
+                nextInputBufferIndex = -1;
+                nextInputBuffer = null;
+            }
+            return false;
+        } finally {
+            codecRecovered = doCodecRecoveryIfRequired(CR_FLAG_INPUT_THREAD);
+        }
+
+        // If codec recovery is required, always return false to ensure the caller will request
+        // an IDR frame to complete the codec recovery.
+        if (codecRecovered) {
+            return false;
         }
 
         // Fetch a new input buffer now while we have some time between frames
         // to have it ready immediately when the next frame arrives.
-        fetchNextInputBuffer();
-
-        return true;
+        //
+        // We must propagate the return value here in order to properly handle
+        // codec recovery happening in fetchNextInputBuffer(). If we don't, we'll
+        // never get an IDR frame to complete the recovery process.
+        return fetchNextInputBuffer();
     }
 
     private void doProfileSpecificSpsPatching(SeqParameterSet sps) {
@@ -971,7 +1260,7 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
 
             // GFE 2.5.11 changed the SPS to add additional extensions
             // Some devices don't like these so we remove them here on old devices.
-            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O && sps.vuiParams != null) {
                 sps.vuiParams.videoSignalTypePresentFlag = false;
                 sps.vuiParams.colourDescriptionPresentFlag = false;
                 sps.vuiParams.chromaLocInfoPresentFlag = false;
@@ -983,6 +1272,12 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
                 // The SPS that comes in the current H264 bytestream doesn't set bitstream_restriction_flag
                 // or max_dec_frame_buffering which increases decoding latency on Tegra.
 
+                // If the encoder didn't include VUI parameters in the SPS, add them now
+                if (sps.vuiParams == null) {
+                    LimeLog.info("Adding VUI parameters");
+                    sps.vuiParams = new VUIParameters();
+                }
+
                 // GFE 2.5.11 started sending bitstream restrictions
                 if (sps.vuiParams.bitstreamRestriction == null) {
                     LimeLog.info("Adding bitstream restrictions");
@@ -1007,7 +1302,7 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
                 // log2_max_mv_length_horizontal and log2_max_mv_length_vertical are set to more
                 // conservative values by GFE 2.5.11. We'll let those values stand.
             }
-            else {
+            else if (sps.vuiParams != null) {
                 // Devices that didn't/couldn't get bitstream restrictions before GFE 2.5.11
                 // will continue to not receive them now
                 sps.vuiParams.bitstreamRestriction = null;
@@ -1251,18 +1546,14 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
         private String text;
 
         RendererException(MediaCodecDecoderRenderer renderer, Exception e) {
-            this.text = generateText(renderer, e, null, 0);
-        }
-
-        RendererException(MediaCodecDecoderRenderer renderer, Exception e, ByteBuffer currentBuffer, int currentCodecFlags) {
-            this.text = generateText(renderer, e, currentBuffer, currentCodecFlags);
+            this.text = generateText(renderer, e);
         }
 
         public String toString() {
             return text;
         }
 
-        private String generateText(MediaCodecDecoderRenderer renderer, Exception originalException, ByteBuffer currentBuffer, int currentCodecFlags) {
+        private String generateText(MediaCodecDecoderRenderer renderer, Exception originalException) {
             String str;
 
             if (renderer.numVpsIn == 0 && renderer.numSpsIn == 0 && renderer.numPpsIn == 0) {
@@ -1287,7 +1578,6 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
                 str = "ErrorWhileStreaming";
             }
 
-            str += ": 1\n";
             str += "Format: "+String.format("%x", renderer.videoFormat)+"\n";
             str += "AVC Decoder: "+((renderer.avcDecoder != null) ? renderer.avcDecoder.getName():"(none)")+"\n";
             str += "HEVC Decoder: "+((renderer.hevcDecoder != null) ? renderer.hevcDecoder.getName():"(none)")+"\n";
@@ -1320,11 +1610,11 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
             str += "Output format: "+renderer.outputFormat+"\n";
             str += "Adaptive playback: "+renderer.adaptivePlayback+"\n";
             str += "GL Renderer: "+renderer.glRenderer+"\n";
-            str += "Build fingerprint: "+Build.FINGERPRINT+"\n";
+            //str += "Build fingerprint: "+Build.FINGERPRINT+"\n";
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
                 str += "SOC: "+Build.SOC_MANUFACTURER+" - "+Build.SOC_MODEL+"\n";
                 str += "Performance class: "+Build.VERSION.MEDIA_PERFORMANCE_CLASS+"\n";
-                str += "Vendor params: ";
+                /*str += "Vendor params: ";
                 List<String> params = renderer.videoDecoder.getSupportedVendorParameters();
                 if (params.isEmpty()) {
                     str += "NONE";
@@ -1334,7 +1624,7 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
                         str += param + " ";
                     }
                 }
-                str += "\n";
+                str += "\n";*/
             }
             str += "Foreground: "+renderer.foreground+"\n";
             str += "Consecutive crashes: "+renderer.consecutiveCrashCount+"\n";
@@ -1353,18 +1643,6 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
             str += "Average hardware decoder latency: "+renderer.getAverageDecoderLatency()+"ms\n";
             str += "Frame pacing mode: "+renderer.prefs.framePacing+"\n";
 
-            if (currentBuffer != null) {
-                str += "Current buffer: ";
-                currentBuffer.flip();
-                while (currentBuffer.hasRemaining() && currentBuffer.position() < 10) {
-                    str += String.format((Locale)null, "%02x ", currentBuffer.get());
-                }
-                str += "\n";
-                str += "Buffer codec flags: "+currentCodecFlags+"\n";
-            }
-
-            str += "Is Exynos 4: "+renderer.isExynos4+"\n";
-
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                 if (originalException instanceof CodecException) {
                     CodecException ce = (CodecException) originalException;
@@ -1379,20 +1657,6 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer implements C
                 }
             }
 
-            str += "/proc/cpuinfo:\n";
-            try {
-                str += MediaCodecHelper.readCpuinfo();
-            } catch (Exception e) {
-                str += e.getMessage();
-            }
-
-            str += "Full decoder dump:\n";
-            try {
-                str += MediaCodecHelper.dumpDecoders();
-            } catch (Exception e) {
-                str += e.getMessage();
-            }
-
             str += originalException.toString();
 
             return str;

app/src/main/java/com/limelight/binding/video/MediaCodecHelper.java

@@ -44,7 +44,8 @@ public class MediaCodecHelper {
     private static final List<String> exynosDecoderPrefixes;
     private static final List<String> amlogicDecoderPrefixes;
 
-    public static final boolean IS_EMULATOR = Build.HARDWARE.equals("ranchu") || Build.HARDWARE.equals("cheets");
+    public static final boolean SHOULD_BYPASS_SOFTWARE_BLOCK =
+            Build.HARDWARE.equals("ranchu") || Build.HARDWARE.equals("cheets") || Build.BRAND.equals("Android-x86");
 
     private static boolean isLowEndSnapdragon = false;
     private static boolean isAdreno620 = false;
@@ -82,18 +83,18 @@ public class MediaCodecHelper {
     static {
         blacklistedDecoderPrefixes = new LinkedList<>();
 
-        // Blacklist software decoders that don't support H264 high profile,
-        // but exclude the official AOSP and CrOS emulator from this restriction.
-        if (!IS_EMULATOR) {
+        // Blacklist software decoders that don't support H264 high profile except on systems
+        // that are expected to only have software decoders (like emulators).
+        if (!SHOULD_BYPASS_SOFTWARE_BLOCK) {
             blacklistedDecoderPrefixes.add("omx.google");
             blacklistedDecoderPrefixes.add("AVCDecoder");
-        }
 
-        // We want to avoid ffmpeg decoders since they're software decoders,
-        // but on Android-x86 they might be all we have (and also relatively
-        // performant on a modern x86 processor).
-        if (!Build.BRAND.equals("Android-x86")) {
-            blacklistedDecoderPrefixes.add("OMX.ffmpeg");
+            // We want to avoid ffmpeg decoders since they're usually software decoders,
+            // but we'll defer to the Android 10 isSoftwareOnly() API on newer devices
+            // to determine if we should use these or not.
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+                blacklistedDecoderPrefixes.add("OMX.ffmpeg");
+            }
         }
 
         // Force these decoders disabled because:
@@ -721,7 +722,7 @@ public class MediaCodecHelper {
     private static boolean isCodecBlacklisted(MediaCodecInfo codecInfo) {
         // Use the new isSoftwareOnly() function on Android Q
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            if (!IS_EMULATOR && codecInfo.isSoftwareOnly()) {
+            if (!SHOULD_BYPASS_SOFTWARE_BLOCK && codecInfo.isSoftwareOnly()) {
                 LimeLog.info("Skipping software-only decoder: "+codecInfo.getName());
                 return true;
             }

app/src/main/res/layout/activity_game.xml

@@ -4,6 +4,12 @@
     android:layout_height="match_parent"
     tools:context=".Game" >
 
+    <View
+        android:id="@+id/backgroundTouchView"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:layout_gravity="center" />
+
     <com.limelight.ui.StreamView
         android:id="@+id/surfaceView"
         android:layout_width="match_parent"

app/src/main/res/values-fr/strings.xml

@@ -253,4 +253,10 @@
     <string name="title_checkbox_absolute_mouse_mode">Mode souris pour bureau à distance</string>
     <string name="summary_seekbar_deadzone">Remarque : Certains jeux peuvent imposer une zone morte plus grande que celle que Moonlight est configuré pour utiliser.</string>
     <string name="summary_checkbox_absolute_mouse_mode">Cela peut rendre l\'accélération de la souris plus naturelle pour l\'utilisation du bureau à distance, mais elle est incompatible avec de nombreux jeux.</string>
+    <string name="resolution_prefix_native_landscape">(Paysage)</string>
+    <string name="resolution_prefix_native_portrait">(Portrait)</string>
+    <string name="title_checkbox_reduce_refresh_rate">Autoriser la réduction du taux de rafraîchissement</string>
+    <string name="summary_checkbox_reduce_refresh_rate">Des taux de rafraîchissement d\'affichage plus bas peuvent économiser de l\'énergie au détriment d\'une latence vidéo plus importante</string>
+    <string name="summary_checkbox_enable_audiofx">Permet aux effets audio de fonctionner lors du streaming, mais peut augmenter la latence</string>
+    <string name="title_checkbox_enable_audiofx">Activer le support de l\'égalisateur système</string>
 </resources>

app/src/main/res/values-zh-rCN/strings.xml

@@ -217,7 +217,7 @@
     <string name="nettest_text_blocked">您设备当前的网络连接拦截了Moonlight。连接到该网络时可能无法通过互联网串流。</string>
     <string name="perf_overlay_netlatency">平均网络延迟： %1$d ms (抖动： %2$d ms)</string>
     <string name="perf_overlay_streamdetails">视频流： %1$s %2$.2f FPS</string>
-    <string name="resolution_prefix_native_fullscreen">本地全屏</string>
+    <string name="resolution_prefix_native_fullscreen">原生全屏</string>
     <!-- Array strings -->
     <string name="audioconf_stereo">立体声</string>
     <string name="audioconf_51surround">5.1环绕声</string>
@@ -251,4 +251,10 @@
     <string name="summary_seekbar_deadzone">注意：有些游戏可以执行一个比Moonlight摇杆配置的更大的盲区。</string>
     <string name="title_checkbox_absolute_mouse_mode">适合远程桌面的鼠标模式</string>
     <string name="summary_checkbox_absolute_mouse_mode">这可以使得鼠标加速在远程桌面使用中表现得更自然，但它与许多游戏不兼容。</string>
+    <string name="resolution_prefix_native_landscape">（横向）</string>
+    <string name="resolution_prefix_native_portrait">（纵向）</string>
+    <string name="title_checkbox_enable_audiofx">启用对系统均衡器的支持</string>
+    <string name="summary_checkbox_enable_audiofx">串流时允许音效工作，可能会导致音频延迟增加</string>
+    <string name="title_checkbox_reduce_refresh_rate">允许降低刷新率</string>
+    <string name="summary_checkbox_reduce_refresh_rate">较低的屏幕刷新率可以在增加一些视频延迟的情况下省电</string>
 </resources>

app/src/main/res/values-zh-rTW/strings.xml

@@ -254,4 +254,8 @@
     <string name="summary_checkbox_absolute_mouse_mode">這可以讓滑鼠在遠端桌面使用中的加速表現更加自然，但與很多遊戲不相容。</string>
     <string name="title_checkbox_enable_audiofx">啟用系統等化器支援</string>
     <string name="summary_checkbox_enable_audiofx">允許音訊效果在串流中發揮作用，但可能會增加音訊延遲</string>
+    <string name="resolution_prefix_native_landscape">(橫向)</string>
+    <string name="resolution_prefix_native_portrait">(直向)</string>
+    <string name="title_checkbox_reduce_refresh_rate">允許減小重新整理率</string>
+    <string name="summary_checkbox_reduce_refresh_rate">更低的顯示器重新整理速率可在犧牲一些額外視訊延遲的狀況下節省電力</string>
 </resources>

build.gradle

@@ -5,7 +5,7 @@ buildscript {
         google()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:7.2.2'
+        classpath 'com.android.tools.build:gradle:7.3.0'
     }
 }
 

fastlane/metadata/android/en-US/changelogs/292.txt

@@ -0,0 +1,3 @@
+- Fixed several input bugs with the on-screen gamepad
+- Implemented recovery logic for video decoder errors
+- Updated community contributed translations from Weblate