Version 8.5

app/build.gradle

@@ -7,8 +7,8 @@ android {
         minSdkVersion 16
         targetSdkVersion 29
 
-        versionName "8.4.1"
-        versionCode = 203
+        versionName "8.5"
+        versionCode = 204
     }
 
     flavorDimensions "root"

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

@@ -397,27 +397,36 @@ public class Game extends Activity implements SurfaceHolder.Callback,
         // Hopefully, we can get rid of this once someone comes up with a better way
         // to track the state of the pipeline and time frames.
         int roundedRefreshRate = Math.round(displayRefreshRate);
-        if ((!prefConfig.disableFrameDrop || prefConfig.unlockFps) && prefConfig.fps >= roundedRefreshRate) {
+        if (!prefConfig.disableFrameDrop || prefConfig.unlockFps) {
+            if (Build.DEVICE.equals("coral") || Build.DEVICE.equals("flame")) {
+                // HACK: Pixel 4 (XL) ignores the preferred display mode and lowers refresh rate,
+                // causing frame pacing issues. See https://issuetracker.google.com/issues/143401475
+                // To work around this, use frame drop mode if we want to stream at >= 60 FPS.
+                if (prefConfig.fps >= 60) {
+                    LimeLog.info("Using Pixel 4 rendering hack");
+                    decoderRenderer.enableLegacyFrameDropRendering();
+                }
+            }
+            else if (prefConfig.fps >= roundedRefreshRate) {
                 if (prefConfig.unlockFps) {
                     // Use frame drops when rendering above the screen frame rate
                     decoderRenderer.enableLegacyFrameDropRendering();
                     LimeLog.info("Using drop mode for FPS > Hz");
-            }
-            else if (roundedRefreshRate <= 49) {
+                } else if (roundedRefreshRate <= 49) {
                     // Let's avoid clearly bogus refresh rates and fall back to legacy rendering
                     decoderRenderer.enableLegacyFrameDropRendering();
                     LimeLog.info("Bogus refresh rate: " + roundedRefreshRate);
                 }
                 // HACK: Avoid crashing on some MTK devices
-            else if (roundedRefreshRate == 50 && decoderRenderer.is49FpsBlacklisted()) {
+                else if (decoderRenderer.isBlacklistedForFrameRate(roundedRefreshRate - 1)) {
                     // Use the old rendering strategy on these broken devices
                     decoderRenderer.enableLegacyFrameDropRendering();
-            }
-            else {
+                } else {
                     prefConfig.fps = roundedRefreshRate - 1;
                     LimeLog.info("Adjusting FPS target for screen to " + prefConfig.fps);
                 }
             }
+        }
 
         StreamConfiguration config = new StreamConfiguration.Builder()
                 .setResolution(prefConfig.width, prefConfig.height)

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

@@ -215,9 +215,10 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
         if (PreferenceConfiguration.readPreferences(context).usbDriver) {
             UsbManager usbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
             for (UsbDevice dev : usbManager.getDeviceList().values()) {
-                // We explicitly ask not to claim devices that appear as InputDevices
+                // We explicitly check not to claim devices that appear as InputDevices
                 // otherwise we will double count them.
-                if (UsbDriverService.shouldClaimDevice(dev, false)) {
+                if (UsbDriverService.shouldClaimDevice(dev, false) &&
+                        !UsbDriverService.isRecognizedInputDevice(dev)) {
                     LimeLog.info("Counting UsbDevice: "+dev.getDeviceName());
                     mask |= 1 << count++;
                 }

app/src/main/java/com/limelight/binding/input/driver/UsbDriverService.java

@@ -166,7 +166,7 @@ public class UsbDriverService extends Service implements UsbDriverListener {
         }
     }
 
-    private static boolean isRecognizedInputDevice(UsbDevice device) {
+    public static boolean isRecognizedInputDevice(UsbDevice device) {
         // On KitKat and later, we can determine if this VID and PID combo
         // matches an existing input device and defer to the built-in controller
         // support in that case. Prior to KitKat, we'll always return true to be safe.

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

@@ -190,8 +190,8 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
         return avcDecoder != null;
     }
 
-    public boolean is49FpsBlacklisted() {
-        return avcDecoder != null && MediaCodecHelper.decoderBlacklistedFor49Fps(avcDecoder.getName());
+    public boolean isBlacklistedForFrameRate(int frameRate) {
+        return avcDecoder != null && MediaCodecHelper.decoderBlacklistedForFrameRate(avcDecoder.getName(), frameRate);
     }
 
     public void enableLegacyFrameDropRendering() {

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

@@ -37,6 +37,7 @@ public class MediaCodecHelper {
     private static final List<String> refFrameInvalidationAvcPrefixes;
     private static final List<String> refFrameInvalidationHevcPrefixes;
     private static final List<String> blacklisted49FpsDecoderPrefixes;
+    private static final List<String> blacklisted59FpsDecoderPrefixes;
 
     private static boolean isLowEndSnapdragon = false;
     private static boolean initialized = false;
@@ -47,6 +48,7 @@ public class MediaCodecHelper {
         // These decoders have low enough input buffer latency that they
         // can be directly invoked from the receive thread
         directSubmitPrefixes.add("omx.qcom");
+        directSubmitPrefixes.add("c2.qti");
         directSubmitPrefixes.add("omx.sec");
         directSubmitPrefixes.add("omx.exynos");
         directSubmitPrefixes.add("omx.intel");
@@ -147,7 +149,7 @@ public class MediaCodecHelper {
         //whitelistedHevcDecoders.add("omx.amlogic");
         //whitelistedHevcDecoders.add("omx.rk");
 
-		// Based on GPU attributes queried at runtime, the omx.qcom prefix will be added
+        // Based on GPU attributes queried at runtime, the omx.qcom/c2.qti prefix will be added
         // during initialization to avoid SoCs with broken HEVC decoders.
     }
 
@@ -161,12 +163,19 @@ public class MediaCodecHelper {
 
     static {
         blacklisted49FpsDecoderPrefixes = new LinkedList<>();
+        blacklisted59FpsDecoderPrefixes = new LinkedList<>();
 
         // We see a bunch of crashes on MediaTek Android TVs running
         // at 49 FPS (PAL 50 Hz - 1). Blacklist this frame rate for
         // these devices and hope they fix it in Pie.
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) {
             blacklisted49FpsDecoderPrefixes.add("omx.mtk");
+
+            // 59 FPS also seems to crash on the Sony Bravia TV ATV3 model.
+            // Blacklist that frame rate on these devices too.
+            if (Build.DEVICE.startsWith("BRAVIA_ATV3")) {
+                blacklisted59FpsDecoderPrefixes.add("omx.mtk");
+            }
         }
     }
 
@@ -237,8 +246,9 @@ public class MediaCodecHelper {
                 LimeLog.info("Added omx.nvidia to AVC reference frame invalidation support list");
                 refFrameInvalidationAvcPrefixes.add("omx.nvidia");
 
-				LimeLog.info("Added omx.qcom to AVC reference frame invalidation support list");
+                LimeLog.info("Added omx.qcom/c2.qti to AVC reference frame invalidation support list");
                 refFrameInvalidationAvcPrefixes.add("omx.qcom");
+                refFrameInvalidationAvcPrefixes.add("c2.qti");
 
                 // Prior to M, we were tricking the decoder into using baseline profile, which
                 // won't support RFI properly.
@@ -261,11 +271,13 @@ public class MediaCodecHelper {
                 // older Qualcomm chips) vs. enabling HEVC by default. The user can override using the settings
                 // to force HEVC on. If HDR or mobile data will be used, we'll override this and use
                 // HEVC anyway.
-				LimeLog.info("Added omx.qcom to deprioritized HEVC decoders based on GLES 3.1+ support");
+                LimeLog.info("Added omx.qcom/c2.qti to deprioritized HEVC decoders based on GLES 3.1+ support");
                 deprioritizedHevcDecoders.add("omx.qcom");
+                deprioritizedHevcDecoders.add("c2.qti");
             }
             else {
                 blacklistedDecoderPrefixes.add("OMX.qcom.video.decoder.hevc");
+                blacklistedDecoderPrefixes.add("c2.qti.hevc.decoder");
             }
 
             // Older MediaTek SoCs have issues with HEVC rendering but the newer chips with
@@ -345,9 +357,17 @@ public class MediaCodecHelper {
         return isDecoderInList(baselineProfileHackPrefixes, decoderName);
     }
 
-	public static boolean decoderBlacklistedFor49Fps(String decoderName) {
+    public static boolean decoderBlacklistedForFrameRate(String decoderName, int fps) {
+        if (fps == 49) {
             return isDecoderInList(blacklisted49FpsDecoderPrefixes, decoderName);
         }
+        else if (fps == 59) {
+            return isDecoderInList(blacklisted59FpsDecoderPrefixes, decoderName);
+        }
+        else {
+            return false;
+        }
+    }
 
     public static boolean decoderSupportsRefFrameInvalidationAvc(String decoderName, int videoHeight) {
         // Reference frame invalidation is broken on low-end Snapdragon SoCs at 1080p.
@@ -468,6 +488,13 @@ public class MediaCodecHelper {
                     continue;
                 }
 
+                // Skip compatibility aliases on Q+
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                    if (codecInfo.isAlias()) {
+                        continue;
+                    }
+                }
+                
                 // Check for preferred decoders
                 if (preferredDecoder.equalsIgnoreCase(codecInfo.getName())) {
                     LimeLog.info("Preferred decoder choice is "+codecInfo.getName());
@@ -504,6 +531,13 @@ public class MediaCodecHelper {
                 continue;
             }
 
+            // Skip compatibility aliases on Q+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                if (codecInfo.isAlias()) {
+                    continue;
+                }
+            }
+            
             // Find a decoder that supports the specified video format
             for (String mime : codecInfo.getSupportedTypes()) {
                 if (mime.equalsIgnoreCase(mimeType)) {
@@ -551,6 +585,13 @@ public class MediaCodecHelper {
                 continue;
             }
 
+            // Skip compatibility aliases on Q+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                if (codecInfo.isAlias()) {
+                    continue;
+                }
+            }
+            
             // Find a decoder that supports the requested video format
             for (String mime : codecInfo.getSupportedTypes()) {
                 if (mime.equalsIgnoreCase(mimeType)) {

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

@@ -0,0 +1,4 @@
+- Optimized for new devices launching with Android 10
+- Added a workaround to avoid video lag on the Pixel 4
+- Fixed duplicate gamepads being created when using a USB Xbox One gamepad
+- Fixed crashes on Sony Bravia Android TV devices