chore: Release v5.2.0-dev.4 [skip ci]

# [5.2.0-dev.4](https://github.com/ReVanced/revanced-patches/compare/v5.2.0-dev.3...v5.2.0-dev.4) (2024-11-26)

### Bug Fixes

* **YouTube - Playback speed:** Allow long press 2x speed when using custom playback speeds ([#3990](https://github.com/ReVanced/revanced-patches/issues/3990)) ([fafed09](fafed099c5))

CHANGELOG.md

@@ -1,3 +1,17 @@
+# [5.2.0-dev.4](https://github.com/ReVanced/revanced-patches/compare/v5.2.0-dev.3...v5.2.0-dev.4) (2024-11-26)
+
+
+### Bug Fixes
+
+* **YouTube - Playback speed:** Allow long press 2x speed when using custom playback speeds ([#3990](https://github.com/ReVanced/revanced-patches/issues/3990)) ([79a543a](https://github.com/ReVanced/revanced-patches/commit/79a543a57470638f983862c61270e046f3ac5cb7))
+
+# [5.2.0-dev.3](https://github.com/ReVanced/revanced-patches/compare/v5.2.0-dev.2...v5.2.0-dev.3) (2024-11-26)
+
+
+### Features
+
+* **VSCO:** Remove non functional `Unlock pro` patch ([4fddb19](https://github.com/ReVanced/revanced-patches/commit/4fddb1930bc7adeee3b60ae9cd346b143e88bd42))
+
 # [5.2.0-dev.2](https://github.com/ReVanced/revanced-patches/compare/v5.2.0-dev.1...v5.2.0-dev.2) (2024-11-26)
 
 

extensions/shared/src/main/java/app/revanced/extension/youtube/patches/VideoInformation.java

@@ -1,14 +1,14 @@
 package app.revanced.extension.youtube.patches;
 
 import androidx.annotation.NonNull;
-import app.revanced.extension.youtube.patches.playback.speed.RememberPlaybackSpeedPatch;
-import app.revanced.extension.youtube.shared.VideoState;
-import app.revanced.extension.shared.Logger;
-import app.revanced.extension.shared.Utils;
 
 import java.lang.ref.WeakReference;
 import java.util.Objects;
 
+import app.revanced.extension.shared.Logger;
+import app.revanced.extension.shared.Utils;
+import app.revanced.extension.youtube.shared.VideoState;
+
 /**
  * Hooking class for the current playing video.
  * @noinspection unused
@@ -120,6 +120,16 @@ public final class VideoInformation {
         }
     }
 
+    /**
+     * Injection point.
+     */
+    public static void videoSpeedChanged(float currentVideoSpeed) {
+        if (playbackSpeed != currentVideoSpeed) {
+            Logger.printDebug(() -> "Video speed changed: " + currentVideoSpeed);
+            playbackSpeed = currentVideoSpeed;
+        }
+    }
+
     /**
      * Injection point.
      * Called when user selects a playback speed.
@@ -131,18 +141,6 @@ public final class VideoInformation {
         playbackSpeed = userSelectedPlaybackSpeed;
     }
 
-    /**
-     * Overrides the current playback speed.
-     * <p>
-     * <b> Used exclusively by {@link RememberPlaybackSpeedPatch} </b>
-     */
-    public static void overridePlaybackSpeed(float speedOverride) {
-        if (playbackSpeed != speedOverride) {
-            Logger.printDebug(() -> "Overriding playback speed to: " + speedOverride);
-            playbackSpeed = speedOverride;
-        }
-    }
-
     /**
      * Injection point.
      *

extensions/shared/src/main/java/app/revanced/extension/youtube/patches/playback/speed/RememberPlaybackSpeedPatch.java

@@ -12,6 +12,8 @@ public final class RememberPlaybackSpeedPatch {
 
     private static final long TOAST_DELAY_MILLISECONDS = 750;
 
+    private static volatile boolean newVideoStarted;
+
     private static long lastTimeSpeedChanged;
 
     /**
@@ -19,7 +21,7 @@ public final class RememberPlaybackSpeedPatch {
      */
     public static void newVideoStarted(VideoInformation.PlaybackController ignoredPlayerController) {
         Logger.printDebug(() -> "newVideoStarted");
-        VideoInformation.overridePlaybackSpeed(Settings.PLAYBACK_SPEED_DEFAULT.get());
+        newVideoStarted = true;
     }
 
     /**
@@ -29,42 +31,56 @@ public final class RememberPlaybackSpeedPatch {
      * @param playbackSpeed The playback speed the user selected
      */
     public static void userSelectedPlaybackSpeed(float playbackSpeed) {
-        if (Settings.REMEMBER_PLAYBACK_SPEED_LAST_SELECTED.get()) {
+        try {
-            // With the 0.05x menu, if the speed is set by integrations to higher than 2.0x
+            if (Settings.REMEMBER_PLAYBACK_SPEED_LAST_SELECTED.get()) {
-            // then the menu will allow increasing without bounds but the max speed is
+                // With the 0.05x menu, if the speed is set by integrations to higher than 2.0x
-            // still capped to under 8.0x.
+                // then the menu will allow increasing without bounds but the max speed is
-            playbackSpeed = Math.min(playbackSpeed, CustomPlaybackSpeedPatch.PLAYBACK_SPEED_MAXIMUM - 0.05f);
+                // still capped to under 8.0x.
+                playbackSpeed = Math.min(playbackSpeed, CustomPlaybackSpeedPatch.PLAYBACK_SPEED_MAXIMUM - 0.05f);
 
-            // Prevent toast spamming if using the 0.05x adjustments.
+                // Prevent toast spamming if using the 0.05x adjustments.
-            // Show exactly one toast after the user stops interacting with the speed menu.
+                // Show exactly one toast after the user stops interacting with the speed menu.
-            final long now = System.currentTimeMillis();
+                final long now = System.currentTimeMillis();
-            lastTimeSpeedChanged = now;
+                lastTimeSpeedChanged = now;
 
-            final float finalPlaybackSpeed = playbackSpeed;
+                final float finalPlaybackSpeed = playbackSpeed;
-            Utils.runOnMainThreadDelayed(() -> {
+                Utils.runOnMainThreadDelayed(() -> {
-                if (lastTimeSpeedChanged != now) {
+                    if (lastTimeSpeedChanged != now) {
-                    // The user made additional speed adjustments and this call is outdated.
+                        // The user made additional speed adjustments and this call is outdated.
-                    return;
+                        return;
-                }
+                    }
 
-                if (Settings.PLAYBACK_SPEED_DEFAULT.get() == finalPlaybackSpeed) {
+                    if (Settings.PLAYBACK_SPEED_DEFAULT.get() == finalPlaybackSpeed) {
-                    // User changed to a different speed and immediately changed back.
+                        // User changed to a different speed and immediately changed back.
-                    // Or the user is going past 8.0x in the glitched out 0.05x menu.
+                        // Or the user is going past 8.0x in the glitched out 0.05x menu.
-                    return;
+                        return;
-                }
+                    }
-                Settings.PLAYBACK_SPEED_DEFAULT.save(finalPlaybackSpeed);
+                    Settings.PLAYBACK_SPEED_DEFAULT.save(finalPlaybackSpeed);
 
-                Utils.showToastLong(str("revanced_remember_playback_speed_toast", (finalPlaybackSpeed + "x")));
+                    Utils.showToastLong(str("revanced_remember_playback_speed_toast", (finalPlaybackSpeed + "x")));
-            }, TOAST_DELAY_MILLISECONDS);
+                }, TOAST_DELAY_MILLISECONDS);
+            }
+        } catch (Exception ex) {
+            Logger.printException(() -> "userSelectedPlaybackSpeed failure", ex);
         }
     }
 
     /**
      * Injection point.
-     * Overrides the video speed.  Called after video loads, and immediately after user selects a different playback speed
+     * Overrides the video speed.  Called after video loads,
+     * and immediately after the user selects a different playback speed.
      */
     public static float getPlaybackSpeedOverride() {
-        return VideoInformation.getPlaybackSpeed();
+        if (newVideoStarted) {
+            newVideoStarted = false;
+
+            final float defaultSpeed = Settings.PLAYBACK_SPEED_DEFAULT.get();
+            if (defaultSpeed > 0) {
+                return defaultSpeed;
+            }
+        }
+
+        return -2.0f;
     }
 
-}
+}

gradle.properties

@@ -3,4 +3,4 @@ org.gradle.jvmargs = -Xms512M -Xmx2048M
 org.gradle.parallel = true
 android.useAndroidX = true
 kotlin.code.style = official
-version = 5.2.0-dev.2
+version = 5.2.0-dev.4

patches/api/patches.api

@@ -1370,11 +1370,9 @@ public final class app/revanced/patches/youtube/shared/FingerprintsKt {
 }
 
 public final class app/revanced/patches/youtube/video/information/VideoInformationPatchKt {
-	public static final fun getSetPlaybackSpeedClassFieldReference ()Ljava/lang/String;
-	public static final fun getSetPlaybackSpeedContainerClassFieldReference ()Ljava/lang/String;
-	public static final fun getSetPlaybackSpeedMethodReference ()Ljava/lang/String;
 	public static final fun getVideoInformationPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
 	public static final fun userSelectedPlaybackSpeedHook (Ljava/lang/String;Ljava/lang/String;)V
+	public static final fun videoSpeedChangedHook (Ljava/lang/String;Ljava/lang/String;)V
 	public static final fun videoTimeHook (Ljava/lang/String;Ljava/lang/String;)V
 }
 

patches/src/main/kotlin/app/revanced/patches/vsco/misc/pro/UnlockProPatch.kt

@@ -3,9 +3,9 @@ package app.revanced.patches.vsco.misc.pro
 import app.revanced.patcher.extensions.InstructionExtensions.addInstruction
 import app.revanced.patcher.patch.bytecodePatch
 
+@Deprecated("This patch is deprecated because it does not work anymore and will be removed in the future.")
 @Suppress("unused")
 val unlockProPatch = bytecodePatch(
-    name = "Unlock pro",
     description = "Unlocks pro features.",
 ) {
     compatibleWith("com.vsco.cam"("345"))

patches/src/main/kotlin/app/revanced/patches/youtube/video/information/VideoInformationPatch.kt

@@ -20,13 +20,13 @@ import app.revanced.util.getReference
 import app.revanced.util.indexOfFirstInstructionOrThrow
 import com.android.tools.smali.dexlib2.AccessFlags
 import com.android.tools.smali.dexlib2.Opcode
-import com.android.tools.smali.dexlib2.builder.BuilderInstruction
 import com.android.tools.smali.dexlib2.builder.MutableMethodImplementation
 import com.android.tools.smali.dexlib2.iface.Method
 import com.android.tools.smali.dexlib2.iface.instruction.FiveRegisterInstruction
 import com.android.tools.smali.dexlib2.iface.instruction.OneRegisterInstruction
 import com.android.tools.smali.dexlib2.iface.instruction.ReferenceInstruction
 import com.android.tools.smali.dexlib2.iface.instruction.TwoRegisterInstruction
+import com.android.tools.smali.dexlib2.iface.reference.FieldReference
 import com.android.tools.smali.dexlib2.iface.reference.MethodReference
 import com.android.tools.smali.dexlib2.immutable.ImmutableMethod
 import com.android.tools.smali.dexlib2.immutable.ImmutableMethodParameter
@@ -57,12 +57,16 @@ private lateinit var speedSelectionInsertMethod: MutableMethod
 private var speedSelectionInsertIndex = -1
 private var speedSelectionValueRegister = -1
 
+// Change playback speed method.
+private lateinit var setPlaybackSpeedMethod: MutableMethod
+private var setPlaybackSpeedMethodIndex = -1
+
 // Used by other patches.
-lateinit var setPlaybackSpeedContainerClassFieldReference: String
+internal lateinit var setPlaybackSpeedContainerClassFieldReference: FieldReference
     private set
-lateinit var setPlaybackSpeedClassFieldReference: String
+internal lateinit var setPlaybackSpeedClassFieldReference: FieldReference
     private set
-lateinit var setPlaybackSpeedMethodReference: String
+internal lateinit var setPlaybackSpeedMethodReference: MethodReference
     private set
 
 val videoInformationPatch = bytecodePatch(
@@ -164,24 +168,27 @@ val videoInformationPatch = bytecodePatch(
         videoTimeHook(EXTENSION_CLASS_DESCRIPTOR, "setVideoTime")
 
         /*
-         * Hook the user playback speed selection
+         * Hook the user playback speed selection.
          */
         onPlaybackSpeedItemClickFingerprint.method.apply {
-            val speedSelectionMethodInstructions = implementation!!.instructions
+            val speedSelectionValueInstructionIndex = indexOfFirstInstructionOrThrow(Opcode.IGET)
-            val speedSelectionValueInstructionIndex = speedSelectionMethodInstructions.indexOfFirst {
+
-                it.opcode == Opcode.IGET
-            }
             legacySpeedSelectionInsertMethod = this
             legacySpeedSelectionInsertIndex = speedSelectionValueInstructionIndex + 1
             legacySpeedSelectionValueRegister =
                 getInstruction<TwoRegisterInstruction>(speedSelectionValueInstructionIndex).registerA
 
-            setPlaybackSpeedClassFieldReference =
-                getInstruction<ReferenceInstruction>(speedSelectionValueInstructionIndex + 1).reference.toString()
             setPlaybackSpeedMethodReference =
-                getInstruction<ReferenceInstruction>(speedSelectionValueInstructionIndex + 2).reference.toString()
+                getInstruction<ReferenceInstruction>(speedSelectionValueInstructionIndex + 2).reference as MethodReference
+            setPlaybackSpeedClassFieldReference =
+                getInstruction<ReferenceInstruction>(speedSelectionValueInstructionIndex + 1).reference as FieldReference
             setPlaybackSpeedContainerClassFieldReference =
-                getReference(speedSelectionMethodInstructions, -1, Opcode.IF_EQZ)
+                getInstruction<ReferenceInstruction>(indexOfFirstInstructionOrThrow(Opcode.IF_EQZ) - 1).reference as FieldReference
+
+            setPlaybackSpeedMethod =
+                proxy(classes.first { it.type == setPlaybackSpeedMethodReference.definingClass })
+                    .mutableClass.methods.first { it.name == setPlaybackSpeedMethodReference.name }
+            setPlaybackSpeedMethodIndex = 0
         }
 
         // Handle new playback speed menu.
@@ -195,6 +202,7 @@ val videoInformationPatch = bytecodePatch(
             speedSelectionValueRegister = getInstruction<TwoRegisterInstruction>(index).registerA
         }
 
+        videoSpeedChangedHook(EXTENSION_CLASS_DESCRIPTOR, "videoSpeedChanged")
         userSelectedPlaybackSpeedHook(EXTENSION_CLASS_DESCRIPTOR, "userSelectedPlaybackSpeed")
     }
 }
@@ -295,9 +303,14 @@ fun videoTimeHook(targetMethodClass: String, targetMethodName: String) =
         "$targetMethodClass->$targetMethodName(J)V",
     )
 
-private fun getReference(instructions: List<BuilderInstruction>, offset: Int, opcode: Opcode) =
+/**
-    (instructions[instructions.indexOfFirst { it.opcode == opcode } + offset] as ReferenceInstruction)
+ * Hook when the video speed is changed for any reason _except when the user manually selects a new speed_.
-        .reference.toString()
+ */
+fun videoSpeedChangedHook(targetMethodClass: String, targetMethodName: String) =
+    setPlaybackSpeedMethod.addInstruction(
+        setPlaybackSpeedMethodIndex++,
+        "invoke-static { p1 }, $targetMethodClass->$targetMethodName(F)V"
+    )
 
 /**
  * Hook the video speed selected by the user.
@@ -312,4 +325,4 @@ fun userSelectedPlaybackSpeedHook(targetMethodClass: String, targetMethodName: S
         speedSelectionInsertIndex++,
         "invoke-static { v$speedSelectionValueRegister }, $targetMethodClass->$targetMethodName(F)V",
     )
-}
+}