This commit is contained in:
Kurt Himebauch authored and GitHub committed 2026-10-13 21:27:42 -04:00
1 parent 4163b31b02
commit 83ec5708ed
852 files changed
+4844 -46144

No files matched your search

@@ -4,20 +4,6 @@ import com.droiddeck.launcher.wayland.WaylandCompositor
import org.json.JSONObject
import kotlin.math.sqrt
/**
* Cardboard mode: the compositor draws the session as two lens-distorted eye views side by side
* (waylandcomp/src/cardboard.c), for a phone or handheld dropped into a Google Cardboard-style
* viewer. Units are the menu's own:
*
* - [ipdMm] distance between the eyes, millimetres
* - [screenWidthDm] the virtual screen's width, decimetres (40 = 4 m)
* - [screenDistanceDm] how far away it hangs, decimetres (30 = 3 m)
* - [viewer] a [Viewer] id: the lens it is drawn for
*
* [source] SCREEN shows the frame as a flat virtual screen, world-locked by the rotation sensor
* when [headTracking] is on (3DoF), with real stereo depth from the IPD. SBS takes a frame that is
* already a left/right pair (SteamVR, SBS 3D games and video) and only adds the lens.
*/
data class Cardboard(
val enabled: Boolean = false,
val source: Int = SOURCE_SCREEN,
@@ -29,12 +15,6 @@ data class Cardboard(
) {
val lens: Viewer get() = Viewer.byId(viewer)
/**
* Hands the settings to the compositor. [panelWidthMm] x [panelHeightMm] is the physical size of
* the panel the eyes are drawn on (0 = unknown). The width decides how far each lens centre sits
* from its viewport's centre, so the two pictures line up with the viewer's lenses; the height,
* seen through the lens from its focal distance, is the field of view the distortion works in.
*/
fun push(panelWidthMm: Float, panelHeightMm: Float) {
val l = lens
WaylandCompositor.nativeSetCardboard(enabled, source, ipdMm / 1000f, screenDistanceDm / 10f,
@@ -45,18 +25,10 @@ data class Cardboard(
.put("enabled", enabled).put("source", source).put("viewer", viewer).put("ipdMm", ipdMm)
.put("screenWidthDm", screenWidthDm).put("screenDistanceDm", screenDistanceDm).put("headTracking", headTracking)
/**
* A lens the eyes can be drawn for: its distortion (Cardboard viewer profile coefficients, in
* tangent units at the panel), how far it sits from the panel, and how far apart the two are.
* [fallbackFovDeg] is the eye's field of view when the panel's size is unknown, or with no lens.
*/
enum class Viewer(val id: String, val k1: Float, val k2: Float, val screenToLensMm: Float,
val lensSeparationMm: Float, val chroma: Float, val fallbackFovDeg: Float) {
/** Google Cardboard (2015): the common plastic and cardboard viewers. */
CARDBOARD_V2("cardboard2", 0.34f, 0.55f, 39.3f, 63.9f, 0.006f, 90f),
/** The original 2014 Cardboard: narrower, gentler lenses. */
CARDBOARD_V1("cardboard1", 0.441f, 0.156f, 42f, 60f, 0.004f, 80f),
/** No lens: side-by-side 3D glasses, a 3D TV, or just looking at the stereo pair. */
NONE("none", 0f, 0f, 0f, 0f, 0f, 60f);
companion object {
@@ -80,21 +52,12 @@ data class Cardboard(
headTracking = json.optBoolean("headTracking", true),
)
/**
* One eye's vertical field of view on the panel side of the lens: half the panel's height
* seen from the lens's focal distance. The lens then spreads it wider (the distortion).
*/
fun fovDeg(viewer: Viewer, panelHeightMm: Float): Float {
if (panelHeightMm <= 0f || viewer.screenToLensMm <= 0f) return viewer.fallbackFovDeg
val half = Math.toDegrees(kotlin.math.atan((panelHeightMm / 2f / viewer.screenToLensMm).toDouble())).toFloat()
return (2f * half).coerceIn(30f, 140f)
}
/**
* The lens centre's inset towards the nose, as a fraction of one eye viewport's width. Each
* eye gets half the panel, so its viewport centre is a quarter of the panel from the middle;
* the lens centre is half the lens separation from it. 0 when either is unknown.
*/
fun lensInset(panelWidthMm: Float, lensSeparationMm: Float): Float {
if (panelWidthMm <= 0f || lensSeparationMm <= 0f) return 0f
val inset = (panelWidthMm / 4f - lensSeparationMm / 2f) / (panelWidthMm / 2f)
@@ -103,15 +66,9 @@ data class Cardboard(
}
}
/**
* Head pose maths for Cardboard mode, kept free of Android types so it is unit-tested on the JVM.
* Matrices are row-major 3x3 FloatArrays. "World" is Android's sensor world (x east, y north,
* z up); "screen" axes are x right, y up, z out of the panel towards the viewer's eyes.
*/
object HeadPose {
val IDENTITY = floatArrayOf(1f, 0f, 0f, 0f, 1f, 0f, 0f, 0f, 1f)
/** Unit quaternion (x, y, z, w) -> rotation matrix: what SensorManager.getRotationMatrixFromVector gives. */
fun fromQuaternion(x: Float, y: Float, z: Float, w: Float): FloatArray {
val n = sqrt(x * x + y * y + z * z + w * w).takeIf { it > 1e-6f } ?: 1f
val qx = x / n; val qy = y / n; val qz = z / n; val qw = w / n
@@ -122,57 +79,33 @@ object HeadPose {
)
}
/** The rotation vector sensor's values -> (x, y, z, w), computing w when the sensor leaves it out. */
fun quaternionFromRotationVector(v: FloatArray): FloatArray {
val x = v[0]; val y = v[1]; val z = v[2]
val w = if (v.size >= 4) v[3] else sqrt((1f - x * x - y * y - z * z).coerceAtLeast(0f))
return floatArrayOf(x, y, z, w)
}
/**
* Device -> screen axes for a Display rotation (Surface.ROTATION_* as 0..3): the returned matrix
* maps screen to world, given the device's own device -> world matrix. The same transform as
* input/PadMotion's and SensorManager.remapCoordinateSystem's (ROTATION_90 = AXIS_Y, AXIS_MINUS_X:
* the device's x is the screen's y, its y the screen's -x).
*/
fun toScreen(deviceToWorld: FloatArray, rotation: Int): FloatArray {
// Columns of A: where each screen axis points in device coordinates.
val a = when (rotation and 3) {
1 -> floatArrayOf(0f, 1f, 0f, -1f, 0f, 0f, 0f, 0f, 1f) // screen x = -device y, y = device x
2 -> floatArrayOf(-1f, 0f, 0f, 0f, -1f, 0f, 0f, 0f, 1f) // screen x = -device x, y = -device y
3 -> floatArrayOf(0f, -1f, 0f, 1f, 0f, 0f, 0f, 0f, 1f) // screen x = device y, y = -device x
1 -> floatArrayOf(0f, 1f, 0f, -1f, 0f, 0f, 0f, 0f, 1f)
2 -> floatArrayOf(-1f, 0f, 0f, 0f, -1f, 0f, 0f, 0f, 1f)
3 -> floatArrayOf(0f, -1f, 0f, 1f, 0f, 0f, 0f, 0f, 1f)
else -> IDENTITY
}
return multiply(deviceToWorld, a)
}
/** sin(60 degrees): a view further from level than this is "held flat" for recentring. */
private const val FLAT_SIN = 0.866f
/**
* What a recentre locks to. The pose the compositor gets is basis^T * screenToWorld * tilt:
* - [basis]: a level frame (columns right, up, back in world) facing the recentred heading. Every
* rotation is measured in it, so turning about the real vertical always pans the view;
* - [tilt]: the device's own tilt at the recentre, taken out so that pose starts straight ahead.
* Identity when the device was held upright: the horizon then stays the true one.
*/
class Reference(val basis: FloatArray, val tilt: FloatArray)
/**
* Recentre on the current orientation. Held upright (the screen within 60 degrees of vertical, as
* in a viewer), only the heading resets: forward is where the screen faces. Held flat (lying back,
* or the device on a table or in the hands like a tray), forward is where the top of the screen
* points and the tilt resets too; turning at the hips still pans, tipping the device still tilts.
*/
fun recenter(screenToWorld: FloatArray): Reference {
val fz = -screenToWorld[8]
val flat = kotlin.math.abs(fz) > FLAT_SIN
// Upright: the screen's -z. Flat: the screen's +y (its top edge), which is level then.
var fx = if (flat) screenToWorld[1] else -screenToWorld[2]
var fy = if (flat) screenToWorld[4] else -screenToWorld[5]
val len = sqrt(fx * fx + fy * fy).takeIf { it > 1e-4f } ?: run { fx = 0f; fy = 1f; 1f }
fx /= len; fy /= len
// right = forward x up(0,0,1) = (fy, -fx, 0); up = (0,0,1); back = -forward.
val basis = floatArrayOf(
fy, 0f, -fx,
-fx, 0f, -fy,
@@ -182,7 +115,6 @@ object HeadPose {
return Reference(basis, tilt)
}
/** head -> recentred world: what the compositor takes. */
fun relative(ref: Reference, screenToWorld: FloatArray): FloatArray =
multiply(multiply(transpose(ref.basis), screenToWorld), ref.tilt)
@@ -193,7 +125,6 @@ object HeadPose {
fun transpose(m: FloatArray): FloatArray = floatArrayOf(m[0], m[3], m[6], m[1], m[4], m[7], m[2], m[5], m[8])
/** m * v for a 3-vector. */
fun apply(m: FloatArray, v: FloatArray): FloatArray = floatArrayOf(
m[0] * v[0] + m[1] * v[1] + m[2] * v[2],
m[3] * v[0] + m[4] * v[1] + m[5] * v[2],
@@ -9,25 +9,17 @@ import com.droiddeck.launcher.session.SessionPrefs
import java.io.File
import java.util.Locale
/**
* Everything the device info window shows about the phone's chip: SoC, GPU, CPU, memory, system,
* the phone's own Vulkan driver and the drivers DroidDeck uses. Reads files and asks Vulkan once
* ([VulkanInfo]), so [collect] belongs off the main thread. Values the phone does not give are
* left out rather than guessed.
*/
object DeviceInfo {
class Section(val title: String, val rows: List<Pair<String, String>>)
fun collect(context: Context): List<Section> {
val vk = VulkanInfo.query()
// After Vulkan has been asked, detection can use its name too.
val gpu = GpuInfo.detect()
return listOf(
chip(), gpu(gpu), cpu(), memory(context), system(), vulkan(context, vk), drivers(context, gpu),
).filter { it.rows.isNotEmpty() }
}
/** The whole window as plain text, for a bug report. */
fun text(sections: List<Section>): String = buildString {
append("DroidDeck device info\n")
for (s in sections) {
@@ -78,7 +70,6 @@ object DeviceInfo {
private fun cpu() = Section("CPU", buildList<Pair<String, String>> {
add("Cores", Runtime.getRuntime().availableProcessors().toString())
// Each cpufreq policy is one cluster: the cores it covers and their speed range.
val policies = File("/sys/devices/system/cpu/cpufreq").listFiles { f -> f.name.matches(Regex("policy\\d+")) }
?.sortedBy { it.name.removePrefix("policy").toInt() }.orEmpty()
for (p in policies) {
@@ -94,7 +85,6 @@ object DeviceInfo {
private fun ghz(khz: Long) = String.format(Locale.US, "%.2f GHz", khz / 1e6)
/** The GPU's slowest and fastest step: KGSL's list, else a devfreq GPU node (Mali and others). */
private fun gpuRange(): String? {
fun mhz(hz: Long) = "${hz / 1_000_000} MHz"
val kgsl = read("/sys/class/kgsl/kgsl-3d0/gpu_available_frequencies")
@@ -134,7 +124,6 @@ object DeviceInfo {
add("API version", vk["api"])
add("Loader version", vk["loader"])
add("Driver", listOfNotNull(vk["driver_name"], vk["driver_version"]).joinToString(" "))
// Qualcomm's build string starts with its own label ("Driver Build: 43c70540de, ...").
add("Driver build", vk["driver_info"]?.replace(Regex("(?i)^driver build:\\s*"), ""))
add("Conformance", vk["conformance"])
add("Vendor / device id", listOfNotNull(vk["vendor_id"], vk["device_id"]).joinToString(" / "))
@@ -144,7 +133,6 @@ object DeviceInfo {
val features = listOf("geometry_shader" to "Geometry shaders", "tessellation_shader" to "Tessellation", "texture_bc" to "BC textures")
for ((key, label) in features) add(label, vk[key])
for ((key, value) in vk) if (key.startsWith("ext.")) add(key.removePrefix("ext."), value)
// What Android certifies the phone for.
val pm = context.packageManager
val hw = pm.systemAvailableFeatures.associate { it.name to it.version }
hw[PackageManager.FEATURE_VULKAN_HARDWARE_VERSION]?.let {
@@ -11,37 +11,18 @@ import java.io.File
import java.io.IOException
import java.util.zip.ZipInputStream
/**
* An all-in-one driver package: one zip carrying both halves of a matched pair, the display
* (Android, bionic) driver in one directory and the runtime (Linux, glibc) driver in another,
* indexed by a root `manifest.json` - DroidDeck's own DD-Turnip releases (Droid-Deck/Drivers):
*
* ```
* manifest.json {"package", "version", "drivers": {"android": {"path"}, "linux": {"path"}}}
* android/ meta.json (AdrenoTools) + libvulkan_freedreno.so
* linux/ meta.json + libvulkan_freedreno.so
* ```
*
* Installing one puts each half through its own importer, with that importer's checks, and
* remembers the two as one bundle: picking either half sets both, and deleting either deletes both,
* so a bundle is always used whole. Zips of the older kind, one driver each, never reach this.
*/
object DriverBundle {
private const val TAG = "DriverBundle"
private const val PREFS = "driver_bundles"
private const val MANIFEST = "manifest.json"
/** Refuses a zip that unpacks to more than this: both halves together are about 30 MB. */
private const val MAX_BYTES = 512L shl 20
class Manifest(val name: String, val version: String, val tag: String, val androidPath: String, val linuxPath: String)
/** An installed bundle: [androidId] in TurnipDriver's list, [linuxId] in LinuxVulkanDriverManager's. */
class Bundle(val id: String, val name: String, val version: String, val androidId: String, val linuxId: String) {
/** "DD-Turnip 0.1.0". */
val label: String get() = if (version.isEmpty()) name else "$name $version"
}
/** The manifest of a bundle, or null when [json] is not one (both halves, in two directories). */
fun parseManifest(json: JSONObject): Manifest? {
val drivers = json.optJSONObject("drivers") ?: return null
val android = cleanPath(drivers.optJSONObject("android")?.optString("path").orEmpty()) ?: return null
@@ -58,7 +39,6 @@ object DriverBundle {
return p.takeIf { it.isNotEmpty() && it.split('/').none { part -> part.isEmpty() || part == "." || part == ".." } }
}
/** True when the zip at [uri] is a bundle rather than a single driver. */
fun isBundle(context: Context, uri: Uri): Boolean = try {
context.contentResolver.openInputStream(uri)?.use { input ->
ZipInputStream(input).use { zip ->
@@ -71,11 +51,6 @@ object DriverBundle {
false
}
/**
* Install both halves of the bundle at [uri]. Both or neither: a half that is refused removes
* the one already in. Throws [IllegalArgumentException] with a user-facing reason when the zip
* is not a usable bundle, [IOException] on read failures.
*/
fun install(context: Context, uri: Uri): Bundle {
val work = File(context.cacheDir, "bundle-${System.nanoTime()}")
val td = TurnipDriver(context)
@@ -153,7 +128,6 @@ object DriverBundle {
} ?: throw IOException("cannot open $uri")
}
/** Every installed bundle whose two halves are both still there. */
fun all(context: Context): List<Bundle> {
val td = TurnipDriver(context)
val lm = LinuxVulkanDriverManager(context)
@@ -167,24 +141,20 @@ object DriverBundle {
fun get(context: Context, id: String): Bundle? = all(context).firstOrNull { it.id == id }
/** The bundle [driverId] is a half of, in the runtime list when [linux], else the display list. */
fun containing(context: Context, driverId: String, linux: Boolean): Bundle? =
all(context).firstOrNull { (if (linux) it.linuxId else it.androidId) == driverId }
/** The bundle both drivers are set to right now, if they are one. */
fun active(context: Context): Bundle? {
val android = SessionPrefs.androidDriver(context)
val linux = SessionPrefs.linuxDriver(context)
return all(context).firstOrNull { it.androidId == android && it.linuxId == linux }
}
/** Set both halves as the drivers in use. */
fun select(context: Context, bundle: Bundle) {
SessionPrefs.setAndroidDriver(context, bundle.androidId)
SessionPrefs.setLinuxDriver(context, bundle.linuxId)
}
/** Delete both halves; a driver still set to either goes back to its default. */
fun remove(context: Context, bundle: Bundle) {
TurnipDriver(context).remove(bundle.androidId)
LinuxVulkanDriverManager(context).removeDriver(bundle.linuxId)
@@ -2,20 +2,6 @@ package com.droiddeck.launcher.gpu
import com.droiddeck.launcher.gpu.GpuInfo.Family
/**
* The release drivers as matched pairs: a display build (the app's compositor, bionic) and a Linux
* build (the runtime, glibc) that were made to run together. Mixing a runtime driver carrying a
* patch with a display driver that lacks it is where the hard-to-read bugs come from, so the app
* installs and selects both halves of one pair at once.
*
* - Banners-Turnip publishes each variant as a set in every release (`Turnip-<tag><variant>.zip`
* and `...-Linux.zip`), rebuilt from upstream Mesa as it moves: the pair is one variant of the
* newest release that carries both halves.
* - WinNative ships its display (`v1.x`) and Linux (`linux-v0.x`) builds as two release lines with
* their own numbers: the pair is the newest of each, of one flavour (Balanced or Performance).
* - DroidDeck's DD-Turnip ships both halves in one zip per release (DriverBundle): the pair is the
* newest bundle, and it can never be mixed.
*/
object DriverPairs {
const val BANNER = "banner"
const val BANNER_A8XX = "banner-a8xx"
@@ -24,24 +10,18 @@ object DriverPairs {
const val WN_BALANCED = "wn-b"
const val WN_PERFORMANCE = "wn-p"
const val DD_TURNIP = "dd-turnip"
/** Each DD-Turnip release is its own pair: "dd-turnip:DD-Turnip-v0.1.0". */
fun ddTurnip(tag: String) = "$DD_TURNIP:$tag"
class DriverPair(
val key: String,
/** "Banners-Turnip · Adreno 6xx/7xx", "WinNative · Balanced". */
val name: String,
/** The families the pair is built for; the list only offers it on those unless asked. */
val families: Set<Family>,
val display: TurnipReleases.Asset?,
val linux: TurnipReleases.Asset?,
/** Both halves in one zip, instead of [display] and [linux]. */
val bundle: TurnipReleases.Asset? = null,
) {
val complete: Boolean get() = bundle != null || (display != null && linux != null)
/** The zips to download for the pair: the bundle, or the two halves. */
val assets: List<TurnipReleases.Asset> get() = listOfNotNull(bundle ?: display, if (bundle == null) linux else null)
/** "r4 · 1.19 + 0.1.2": the build of each half. */
val version: String
get() = listOfNotNull(bundle?.tag, display?.tag, linux?.tag).distinct().joinToString(" + ") { it.removePrefix("linux-").removePrefix("DD-Turnip-") }
fun suits(gpu: GpuInfo) = gpu.family in families ||
@@ -65,7 +45,6 @@ object DriverPairs {
else -> key to ALL_ADRENO
}
/** Every pair the last release check found, in the order the list shows them. */
fun from(check: TurnipReleases.Check?): List<DriverPair> {
val assets = check?.assets.orEmpty().filter { it.pair.isNotEmpty() }
val order = listOf(DD_TURNIP, BANNER, BANNER_A8XX, BANNER_ONEUI, BANNER_710, WN_BALANCED, WN_PERFORMANCE)
@@ -75,9 +54,6 @@ object DriverPairs {
val (name, families) = describe(key)
val halves = assets.filter { it.pair == key }
halves.firstOrNull { it.bundle }?.let { return@map DriverPair(key, name, families, null, null, it) }
// The list keeps the newest release of each half; for Banners-Turnip the two halves
// must come from the same release, so a set missing one half in its newest release
// is offered incomplete rather than mixed with an older one.
val display = halves.firstOrNull { !it.linux }
val linux = halves.firstOrNull { it.linux }
val sameRelease = !key.startsWith(BANNER) || display?.tag == linux?.tag
@@ -85,24 +61,15 @@ object DriverPairs {
}
}
/**
* The pair Auto sets for [gpu], among the [pairs] the last release check found: the newest
* official DD-Turnip release on the Adreno 840 (840 and 840v2), WinNative Balanced on the other
* 8xx (Banners' A8xx builds still break on some first boots) and on an 840 while no DD-Turnip
* release is listed, the OneUI build for an 8 Gen 2 under One UI, the patched test builds for
* the 710/720/722, and upstream Banners-Turnip for the rest. Null when nothing fits (not Adreno).
*/
fun recommendedKey(gpu: GpuInfo, pairs: List<DriverPair>): String? = when (gpu.family) {
Family.NOT_ADRENO -> null
Family.A8XX -> if (gpu.model == 840) newestDdTurnip(pairs) ?: WN_BALANCED else WN_BALANCED
Family.A7XX_LOW -> BANNER_710
Family.A7XX -> if (gpu.oneUi8Gen2) BANNER_ONEUI else BANNER
Family.A6XX -> BANNER
// KGSL gave no model: Android 16 arrived with the 8xx, so a device that new is taken as one.
Family.ADRENO_UNKNOWN -> if (android.os.Build.VERSION.SDK_INT >= 36) WN_BALANCED else BANNER
}
/** The complete DD-Turnip pair with the highest version, or null when none is listed. */
fun newestDdTurnip(pairs: List<DriverPair>): String? = pairs
.filter { it.key.startsWith("$DD_TURNIP:") && it.complete }
.maxByOrNull { p ->
@@ -5,7 +5,6 @@ import android.util.Log;
import java.io.File;
import java.io.FileWriter;
/** Setup breadcrumbs survive failures before a session log exists. No account data. */
public final class DriverSetupLog {
private DriverSetupLog() {}
@@ -13,7 +12,7 @@ public final class DriverSetupLog {
Log.i("DriverSetup", stage);
append(context.getFilesDir(), stage);
try { append(context.getExternalFilesDir(null), stage); }
catch (Exception ignored) { /* External storage is optional. */ }
catch (Exception ignored) { }
}
private static void append(File directory, String stage) {
@@ -21,10 +20,9 @@ public final class DriverSetupLog {
try {
directory.mkdirs();
File file = new File(directory, "driver-setup.txt");
// Keep the latest run's breadcrumbs bounded across repeated attempts.
try (FileWriter out = new FileWriter(file, file.length() < 131072)) {
out.write(System.currentTimeMillis() + " " + stage + "\n");
}
} catch (Exception ignored) { /* Diagnostics must never prevent startup. */ }
} catch (Exception ignored) { }
}
}
@@ -5,34 +5,20 @@ import android.util.Log
import com.droiddeck.launcher.R
import com.droiddeck.launcher.wayland.WaylandCompositor
/**
* The frame-generation setting and how it reaches the compositor.
*
* Both engines generate on gamescope's final output inside our compositor, so they work for any
* game with nothing changed in the runtime. Win-FG is our own and needs nothing; LSFG needs the
* shader chain from the user's copy of Lossless Scaling (see [Lossless]). Every compositor
* setter is a value store on the native side, so this can be applied before the compositor is
* up and changed live from the main screen while a session runs.
*/
object FrameGen {
const val ENGINE_OFF = "off"
const val ENGINE_WINFG = "winfg"
const val ENGINE_LSFG = "lsfg"
/** Win-FG's Performance preset, pinned: changing it live rebuilds the whole chain. */
private const val WINFG_PERF_PRESET = 2
/** Bidirectional flow with the occlusion gate - the chain's own default. */
private const val WINFG_MODEL = 4
/** Optical-flow resolution as a fraction of the output; Bannerlator's per-engine defaults. */
private const val FLOW_SCALE_WINFG = 0.60f
private const val FLOW_SCALE_LSFG = 0.80f
/** LSFG's adaptive targets: it generates as many frames as it takes to reach one. */
val ADAPTIVE_TARGETS = listOf(120, 90, 60)
private const val PREFS = "frame_gen"
/** A fixed [multiplier] (2..4), or for LSFG a [target] frame rate (0 = fixed). */
data class Mode(val engine: String, val multiplier: Int = 2, val target: Int = 0) {
companion object {
val OFF = Mode(ENGINE_OFF)
@@ -54,7 +40,6 @@ object FrameGen {
.putString("engine", mode.engine).putInt("multiplier", mode.multiplier).putInt("target", mode.target).apply()
}
/** "Off", "Win-FG 2×", "LSFG 3×", "LSFG Adaptive 90". */
fun label(context: Context): String = label(context, mode(context))
fun label(context: Context, mode: Mode): String = when {
@@ -64,11 +49,6 @@ object FrameGen {
else -> context.getString(R.string.frame_gen_off)
}
/**
* Pushes the saved setting into the compositor. Returns a message for the user when the
* engine cannot run (LSFG without Lossless Scaling), or null. Blocks while a new or updated
* Lossless.dll is prepared.
*/
fun apply(context: Context, refreshHz: Float): String? {
val mode = mode(context)
when (mode.engine) {
@@ -6,38 +6,23 @@ import com.droiddeck.launcher.R
import com.droiddeck.launcher.core.FileUtils
import java.io.File
/**
* What GPU this is, in the terms the driver lists are sorted by. KGSL names the model
* ("Adreno740v2", "Adreno825"); the family decides which Turnip builds run on it at all, and the
* support level is what the app has actually been tested on (Adreno 650, 725 and newer) - an
* Adreno 610 may start, but it is not "supported" just because it is a Qualcomm chip.
*/
data class GpuInfo(
/** "Adreno 740", or the vendor's own name when this is not an Adreno. */
val name: String,
/** The three-digit Adreno model (740, 825), or 0 when KGSL does not say. */
val model: Int,
val family: Family,
/** The SoC as a person would say it ("Snapdragon 8 Gen 2 (QCS8550)"), or "" when the phone does not say. */
val soc: String,
/** Samsung's One UI on an 8 Gen 2: its Turnip needs the OneUI build, or frames tear and flicker. */
val oneUi8Gen2: Boolean,
/** KGSL's own name for the GPU, as the kernel spells it ("Adreno740v2", "Adreno33v2"). */
val kgslName: String = "",
/** Where [model] came from: "kernel", "vulkan" or "platform", "" when unknown. */
val modelSource: String = "",
) {
enum class Family(val label: String) {
A8XX("Adreno 8xx"),
/** Adreno 710/720/722: gen 7 cores cut down enough to need their own patches. */
A7XX_LOW("Adreno 710/720/722"),
A7XX("Adreno 7xx"),
A6XX("Adreno 6xx"),
/** An Adreno whose model KGSL does not give: treated as the newest family it could be. */
ADRENO_UNKNOWN("Adreno"),
NOT_ADRENO("Not an Adreno GPU");
/** [label] in the app's language: the Adreno families are names, the rest is words. */
fun label(context: Context): String = if (this == NOT_ADRENO) context.getString(R.string.gpuinfo_not_adreno) else label
}
@@ -52,7 +37,6 @@ data class GpuInfo(
else -> Support.UNTESTED
}
/** One line for the device card and the system check, in English for the device report. */
val supportText: String
get() = when (support) {
Support.TESTED -> "Supported"
@@ -61,30 +45,23 @@ data class GpuInfo(
Support.UNSUPPORTED -> "Not supported: DroidDeck needs an Adreno (Snapdragon) GPU"
}
/** [supportText] in the app's language. */
fun supportText(context: Context): String = context.getString(when (support) {
Support.TESTED -> R.string.gpuinfo_supported
Support.UNTESTED -> if (family == Family.A7XX_LOW) R.string.gpuinfo_experimental else R.string.gpuinfo_below_tested
Support.UNSUPPORTED -> R.string.gpuinfo_unsupported
})
/** [name] for the screen: the stand-in for a GPU the device does not name is in the app's language. */
fun displayName(context: Context): String = if (name == UNNAMED) context.getString(R.string.gpu_this_gpu) else name
companion object {
/** [name] when the device names no GPU; English, as the device report shows it. */
private const val UNNAMED = "this GPU"
fun detect(): GpuInfo {
val adreno = File("/sys/class/kgsl/kgsl-3d0").exists() || File("/vendor/lib64/hw/vulkan.adreno.so").exists()
val raw = listOf("/sys/class/kgsl/kgsl-3d0/gpu_model", "/sys/class/kgsl/kgsl-3d0/gpu_chipid")
.firstNotNullOfOrNull { FileUtils.readString(File(it))?.trim()?.takeIf(String::isNotEmpty) }
// Where vendors put the chip's model, named when it is known: "Snapdragon 8 Gen 2 (QCS8550)".
val soc = if (adreno) SocNames.label() else ""
val fromKernel = raw?.let { threeDigits(it) } ?: 0
// Some kernels name the GPU without its model (AYANEO's Pocket FIT: "Adreno33v2"). The
// Vulkan driver's own name, when this process has asked it, then the platform's code
// name stand in - the GPU is the same on every phone of a platform.
val fromVulkan = if (fromKernel > 0 || !adreno) 0 else VulkanInfo.cachedOrNull()?.get("device")?.let { threeDigits(it) } ?: 0
val fromPlatform = if (fromKernel > 0 || fromVulkan > 0 || !adreno) 0 else platformModel()
val model = maxOf(fromKernel, fromVulkan, fromPlatform)
@@ -106,7 +83,6 @@ data class GpuInfo(
private fun threeDigits(text: String): Int = Regex("""(\d{3})""").find(text)?.groupValues?.get(1)?.toIntOrNull() ?: 0
/** Qualcomm platform code names whose GPU is known for certain. */
private val PLATFORMS = mapOf(
"msmnile" to 640, "kona" to 650, "lahaina" to 660, "taro" to 730, "cape" to 730,
"kalama" to 740, "pineapple" to 750, "sun" to 830,
@@ -115,7 +91,6 @@ data class GpuInfo(
internal fun platformModel(platform: String = systemProperty("ro.board.platform")): Int =
PLATFORMS[platform.lowercase()] ?: PLATFORMS[systemProperty("ro.vendor.qti.soc_name").lowercase()] ?: 0
/** android.os.SystemProperties.get, which apps may read but not call directly. */
fun systemProperty(name: String): String = try {
Class.forName("android.os.SystemProperties").getMethod("get", String::class.java).invoke(null, name) as? String ?: ""
} catch (_: Exception) {
@@ -10,15 +10,6 @@ import android.os.HandlerThread
import android.util.Log
import com.droiddeck.launcher.wayland.WaylandCompositor
/**
* 3DoF head tracking for Cardboard mode: the rotation sensor -> the compositor's head pose
* ([HeadPose] for the maths). Game rotation vector first (gyro + accelerometer: no compass jumps
* indoors, and only the heading drifts, which a recentre fixes); the plain rotation vector where a
* device has no game one. Events arrive on a thread of their own and go straight to native code,
* so the session's UI thread never sits between the sensor and the screen.
*
* [rotation] is the Display rotation (Surface.ROTATION_*) the session is drawn in.
*/
class HeadTracker(context: Context, private val rotation: () -> Int) : SensorEventListener {
private val sensors = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
private val sensor: Sensor? = sensors.getDefaultSensor(Sensor.TYPE_GAME_ROTATION_VECTOR)
@@ -28,7 +19,6 @@ class HeadTracker(context: Context, private val rotation: () -> Int) : SensorEve
@Volatile private var recenterPending = true
@Volatile private var latest: FloatArray? = null
/** Whether this device has a rotation sensor at all (no sensor = a fixed, head-locked screen). */
val available: Boolean get() = sensor != null
val sensorName: String get() = sensor?.let { "${it.name} (${if (it.type == Sensor.TYPE_GAME_ROTATION_VECTOR) "game rotation vector" else "rotation vector"})" } ?: "none"
@@ -54,7 +44,6 @@ class HeadTracker(context: Context, private val rotation: () -> Int) : SensorEve
WaylandCompositor.nativeSetCardboardPose(HeadPose.IDENTITY, false)
}
/** Make where the viewer looks now straight ahead (see HeadPose.recenter). */
fun recenter() {
recenterPending = true
latest?.let { apply(it) }
@@ -6,28 +6,8 @@ import android.util.Log;
import java.util.ArrayList;
import java.util.List;
/**
* The Vulkan driver a session draws with inside the runtime: in Steam mode the native client's
* own UI (OpenGL through the runtime's Zink), every game it launches (D3D through Proton's
* DXVK/VKD3D) and gamescope's compositing; in desktop mode every program on the desktop. One
* choice per mode covers all of it.
*
* <p>Distinct from the Android driver the app's compositor loads to put the finished frame on the
* screen ({@link TurnipDriver}), which every session ends in - and NOT interchangeable with it:
* these are glibc processes, that one is bionic.
*
* <p>"" (the default) means the driver the runtime was built with, at
* {@code usr/lib/libvulkan_freedreno.so} inside it - nothing is set and nothing is touched.
* Otherwise the value is an imported driver's id ({@link LinuxVulkanDriverManager}), and the
* session is handed that driver's ICD manifest in {@code BL_VK_DRIVER}: the session script points
* the Vulkan loader at it with {@code VK_DRIVER_FILES} after checking both the manifest and the
* library are readable from inside, so the runtime itself is never modified and the choice is
* reversible. Ported from Bannerlator's {@code LinuxVulkanDriver} (GPL-3.0); the choice lives in
* {@code SessionPrefs} per mode here rather than on a shortcut.
*/
public final class LinuxVulkanDriver {
private static final String TAG = "LinuxVulkanDriver";
/** Env var the session reads; its value is an absolute ICD manifest path. */
public static final String ENV = "BL_VK_DRIVER";
public static final String HELP_TEXT =
@@ -38,7 +18,6 @@ public final class LinuxVulkanDriver {
private LinuxVulkanDriver() {}
/** Stored values in editor order: the runtime's own driver, then each imported one. */
public static List<String> optionValues(Context context) {
ArrayList<String> values = new ArrayList<>();
values.add("");
@@ -46,10 +25,6 @@ public final class LinuxVulkanDriver {
return values;
}
/**
* Label for a stored value. An id that is no longer installed says so - the launch path falls
* back to the runtime's own driver for it.
*/
public static String optionLabel(Context context, String value) {
if (value == null || value.isEmpty()) return "Runtime default (built into the runtime)";
LinuxVulkanDriverManager m = new LinuxVulkanDriverManager(context);
@@ -58,10 +33,6 @@ public final class LinuxVulkanDriver {
return m.getDriverName(value) + (ver.isEmpty() ? "" : " " + ver) + " (imported)";
}
/**
* The ICD manifest path to hand the session, or null to leave the runtime's own driver alone.
* An id whose import is gone resolves to null rather than failing the launch.
*/
public static String resolveIcdPath(Context context, String value) {
if (value == null || value.isEmpty()) return null;
LinuxVulkanDriverManager m = new LinuxVulkanDriverManager(context);
@@ -22,30 +22,6 @@ import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
/**
* Imported LINUX Vulkan drivers: glibc Turnip ICDs ({@code Turnip-<tag>[-variant]-Linux.zip} from
* Banners-Turnip) for the runtime - the gamescope session that runs Valve's native ARM64 Steam
* client, and the KDE Plasma desktop beside it. This is the driver that DRAWS there: the client's own UI
* (OpenGL through the runtime's Zink), every game the client launches (D3D through Proton's
* DXVK/VKD3D) and everything on the desktop. Putting the frame on the screen stays the Android
* driver's job, in the app's compositor ({@link TurnipDriver}).
*
* <p>Not interchangeable with that one: the client and its games are glibc processes and cannot
* load a bionic object at all, and this one cannot be loaded by the app. The check that separates
* them is the libc the driver links against - {@code libc.so.6} here, {@code libc.so} there.
*
* <p>Layout (under the app's files dir, which the session sees by its full host path):
* <pre>
* files/linux_vulkan_drivers/&lt;id&gt;/
* libvulkan_freedreno.so the driver
* icd.json generated Vulkan ICD manifest; library_path = the .so's ABSOLUTE path
* meta.json name / driverVersion / minGlibc, our own schema
* </pre>
* The session gets {@code icd.json}'s path in {@code BL_VK_DRIVER} and exports it as
* {@code VK_DRIVER_FILES}, so nothing inside the runtime is modified and the choice is reversible.
*
* <p>Ported from Bannerlator's {@code LinuxVulkanDriverManager} (GPL-3.0), unchanged in behaviour.
*/
public class LinuxVulkanDriverManager {
private static final String TAG = "LinuxVulkanDriver";
public static final String DIR_NAME = "linux_vulkan_drivers";
@@ -66,14 +42,12 @@ public class LinuxVulkanDriverManager {
return new File(rootDir, id);
}
/** Installed = has the .so AND the generated manifest (a half-extracted dir is never offered). */
public boolean isInstalled(String id) {
if (id == null || id.isEmpty() || id.contains("/") || id.contains("..")) return false;
File dir = getDriverDir(id);
return new File(dir, LIB_NAME).isFile() && new File(dir, ICD_NAME).isFile();
}
/** Absolute path of the driver's ICD manifest, or null when the id isn't installed. */
public String getIcdPath(String id) {
return isInstalled(id) ? new File(getDriverDir(id), ICD_NAME).getAbsolutePath() : null;
}
@@ -108,7 +82,6 @@ public class LinuxVulkanDriverManager {
return m != null ? m.optString("driverVersion", "") : "";
}
/** The glibc the driver asks for, as its zip recorded it ("" when the zip did not say). */
public String getMinGlibc(String id) {
JSONObject m = readMeta(id);
return m != null ? m.optString("minGlibc", "") : "";
@@ -118,14 +91,8 @@ public class LinuxVulkanDriverManager {
if (id == null || id.isEmpty() || id.contains("/") || id.contains("..")) return;
Log.d(TAG, "removing imported Linux Vulkan driver " + id);
FileUtils.delete(getDriverDir(id));
// A mode still set to this id falls back to the runtime's own driver at launch (logged there).
}
/**
* Import a {@code -Linux.zip}. Returns the new driver id.
* @throws IllegalArgumentException with a user-facing reason when the zip is not an importable
* Linux driver; {@link IOException} on read/extract failures.
*/
public String installDriver(Uri zipUri, String displayName) throws IOException {
File tmpDir = newStagingDir();
boolean keep = false;
@@ -138,7 +105,6 @@ public class LinuxVulkanDriverManager {
ZipEntry entry;
while ((entry = zis.getNextEntry()) != null) {
if (entry.isDirectory()) continue;
// Flatten: only the base name matters, and it also defeats zip-slip paths.
String base = new File(entry.getName()).getName();
if (base.isEmpty()) continue;
if (base.startsWith("libvulkan_freedreno") && base.endsWith(".so")) {
@@ -154,8 +120,6 @@ public class LinuxVulkanDriverManager {
Log.w(TAG, "meta.json unreadable, ignoring: " + e.getMessage());
}
}
// The zip's own freedreno_icd.aarch64.json is dropped on purpose: its
// library_path is relative to itself, and adopt() writes an absolute one.
}
}
String id = adopt(tmpDir, soName, zipMeta, displayName);
@@ -166,7 +130,6 @@ public class LinuxVulkanDriverManager {
}
}
/** An empty directory beside the installed drivers, for a driver's files before {@link #adopt}. */
File newStagingDir() throws IOException {
File tmpDir = new File(rootDir, ".tmp-" + System.nanoTime());
FileUtils.delete(tmpDir);
@@ -174,11 +137,6 @@ public class LinuxVulkanDriverManager {
return tmpDir;
}
/**
* Check a staged driver ({@link #LIB_NAME} in {@code tmpDir}, copied from {@code soName} in
* the zip), write its manifest and meta.json, and move it in. Returns the id; the caller
* deletes {@code tmpDir} when this throws.
*/
String adopt(File tmpDir, String soName, JSONObject zipMeta, String displayName) throws IOException {
try {
if (soName == null) {
@@ -188,9 +146,6 @@ public class LinuxVulkanDriverManager {
if (!isAarch64Elf(so)) {
throw new IllegalArgumentException(context.getString(R.string.lvd_not_aarch64, soName));
}
// The one check that actually separates this from the bionic builds. Both sonames
// are in the driver's .dynstr, so a byte scan is enough and needs no ELF parsing:
// glibc's is versioned ("libc.so.6"), bionic's is not ("libc.so").
if (!containsAscii(so, "libc.so.6")) {
throw new IllegalArgumentException(context.getString(R.string.lvd_not_glibc, soName));
}
@@ -209,8 +164,6 @@ public class LinuxVulkanDriverManager {
String id = uniqueId(sanitizeId(name));
File dir = getDriverDir(id);
// ICD manifest: absolute library_path, so the loader never depends on cwd and the guest
// reads it at the same path the app wrote (the files dir is bound into the session).
JSONObject icd = new JSONObject();
icd.put("file_format_version", "1.0.0");
JSONObject icdBody = new JSONObject();
@@ -251,7 +204,6 @@ public class LinuxVulkanDriverManager {
return s.isEmpty() ? "linux-driver" : s;
}
/** ELF magic, EI_CLASS = 64-bit, EI_DATA = little-endian, e_machine = 0xB7 (AArch64). */
static boolean isAarch64Elf(File f) {
try (FileInputStream in = new FileInputStream(f)) {
byte[] h = new byte[20];
@@ -292,7 +244,6 @@ public class LinuxVulkanDriverManager {
while (j < nb.length && buf[i + j] == nb[j]) j++;
if (j == nb.length) return true;
}
// Keep the last needle-1 bytes so a match across a buffer boundary is still found.
carry = Math.min(nb.length - 1, len);
System.arraycopy(buf, len - carry, buf, 0, carry);
}
@@ -10,16 +10,6 @@ import java.io.File
import java.security.DigestOutputStream
import java.security.MessageDigest
/**
* LSFG's shader chain, from the user's own Lossless Scaling (Steam app 993090).
*
* The copy the Steam client installs, in any library it installs to, is taken by
* itself and taken again whenever the client updates it. Once the session has seen the account
* own the app, a Lossless.dll can also be imported by hand; it stays until the Steam copy changes
* or another is imported. The DLL is copied in and its shaders are built into a cache named after
* its contents, so a different DLL hands the compositor a different path and its engine reloads.
* Everything here blocks: call it off the main thread.
*/
object Lossless {
enum class Source { NONE, STEAM, IMPORT }
@@ -46,7 +36,6 @@ object Lossless {
return State(owned(context), cacheFile(context)?.isFile == true, source)
}
/** Recorded once: by the session's ownership check (a flag in the guest's home) or a Steam copy. */
fun owned(context: Context): Boolean {
if (prefs(context).getBoolean(KEY_OWNED, false)) return true
if (!ownedFlag(context).exists()) return false
@@ -56,7 +45,6 @@ object Lossless {
fun cacheFile(context: Context): File? = prefs(context).getString(KEY_ID, null)?.let { cacheFor(context, it) }
/** Takes a new or updated Steam copy and rebuilds a missing or outdated cache. A [LsfgNative] status. */
@Synchronized
fun sync(context: Context): Int {
val steam = steamDll(context)
@@ -163,7 +151,6 @@ object Lossless {
?.forEach { it.delete() }
}
/** The newest copy in any library the client installs to: its own, the card's, the Games folders. */
private fun steamDll(context: Context): File? {
val libraries = listOfNotNull(
File(LinuxRuntime.rootDir(context), "root/.local/share/Steam"),
@@ -1,16 +1,10 @@
package com.droiddeck.launcher.gpu;
/**
* The native half of LSFG's shader cache (lsfg_jni.cpp, compiled into the compositor library):
* {@code Lossless.dll} is mapped read-only and parsed as data, never loaded or executed, and its
* DXBC chain translated to SPIR-V. {@link Lossless} decides when; these calls block.
*/
final class LsfgNative {
static { System.loadLibrary("droiddeckwayland"); }
private LsfgNative() {}
// Mirrors lsfg::DllStatus.
static final int STATUS_OK = 0;
static final int STATUS_NOT_INSTALLED = 1;
static final int STATUS_UNREADABLE_FILE = 2;
@@ -19,7 +13,6 @@ final class LsfgNative {
static final int STATUS_TRANSLATION_FAILED = 5;
static final int STATUS_CACHE_UNUSABLE = 6;
// Mirrors lsfg::Variant.
static final int VARIANT_NONE = 0;
static native int nativeValidateDll(String dllPath);
@@ -6,20 +6,6 @@ import com.droiddeck.launcher.wayland.WaylandCompositor
import org.json.JSONObject
import kotlin.math.abs
/**
* The compositor's post chain (waylandcomp/src/effects_chain.c) as the session menu drives it:
* the colour grade, the sharpening, the shader toggles and terminal debanding. Units are the
* menu's own, so a value goes straight from a row into the setter it drives:
*
* - [brightness] / [contrast] -100..100, 0 = neutral
* - [gamma] 0.5..3.0, 1.0 = neutral
* - [saturation] 0..200 percent, 100 = neutral
* - [casLevel] 0..100; the pass runs only while [cas] is on
* - [debandStrength] 0..200, 100 = one LSB
*
* Applies live: the compositor picks the change up on its next frame. While any pass is on, a
* zero-copy game goes through the compositor pass instead, which costs a little GPU time.
*/
data class ScreenEffects(
val brightness: Int = 0,
val contrast: Int = 0,
@@ -35,14 +21,11 @@ data class ScreenEffects(
val crt: Boolean = false,
val ntsc: Boolean = false,
) {
/** The sharpening level the picture gets: 0 while the pass is off, whatever its level is parked at. */
val effectiveCas: Int get() = if (cas) casLevel else 0
/** Whether any pass runs, so the menu can say when the picture is untouched. */
val any: Boolean get() = brightness != 0 || contrast != 0 || abs(gamma - 1f) > 0.005f || saturation != 100 ||
effectiveCas > 0 || hdr || deband || fxaa || toon || crt || ntsc
/** Hands every pass to the compositor, with the Look's name for its log line. */
fun push(upscaler: Int) {
WaylandCompositor.nativeSetCas(cas, casLevel)
WaylandCompositor.nativeSetHdr(hdr)
@@ -77,30 +60,19 @@ data class ScreenEffects(
}
}
/**
* One Look: a named set of values for the rows that already exist on the Display page. Picking
* a Look moves those rows; each stays adjustable afterwards, and the moment one moves the Look
* row reads Custom. [scalingMode] null leaves the scaling mode alone; otherwise it is a
* SessionPrefs.upscalerChoices mode the Look switches to.
*/
data class Look(
/** The Look's id: what the row picks by and the compositor logs. */
val name: String,
val effects: ScreenEffects,
val scalingMode: Int? = null,
/** One line under the row while this Look is picked. */
val desc: String,
/** [name] and [desc] in the app's language, for the menu. */
@StringRes val label: Int,
@StringRes val descRes: Int,
)
object ScreenEffectLooks {
// Scaling modes as the compositor numbers them (WaylandCompositor.nativeSetUpscaler).
private const val SCALING_NEAREST = 2
private const val SCALING_FSR = 4
/** Index 0 is the neutral state a fresh session matches, so the row always names something. */
val LOOKS: List<Look> = listOf(
Look("Off", ScreenEffects.OFF, desc = "Nothing applied.", label = R.string.frame_gen_off, descRes = R.string.look_off_desc),
Look("Game Clarity", ScreenEffects(brightness = 2, contrast = 12, saturation = 108, cas = true, casLevel = 55),
@@ -127,11 +99,6 @@ object ScreenEffectLooks {
desc = "Toon outlines plus sharpening.", label = R.string.look_anime_edge, descRes = R.string.look_anime_edge_desc),
)
/**
* The Look the live values are, or null for Custom. A Look's sharpening is compared as the
* effective level, so a pass switched off matches a Look without one whatever its level is
* parked at; a Look with no scaling mode of its own matches under any.
*/
fun match(e: ScreenEffects, upscaler: Int): Look? = LOOKS.firstOrNull { l ->
val t = l.effects
t.brightness == e.brightness && t.contrast == e.contrast && abs(t.gamma - e.gamma) < 0.005f &&
@@ -2,14 +2,7 @@ package com.droiddeck.launcher.gpu
import android.os.Build
/**
* Which chip this is, as a person would say it. Handhelds often leave Android's SoC model blank
* (the AYANEO Pocket FIT does), so the model is looked for where vendors put it, the same order
* ClusterTune uses; then it is named from a table of models we are sure of, or from the platform
* code name as a family ("Snapdragon 8 Gen 3 family") when the model itself is a vendor variant.
*/
object SocNames {
/** Model codes whose product name is certain. */
private val MODELS = mapOf(
"SM8150" to "Snapdragon 855", "SM8250" to "Snapdragon 865", "SM8250-AC" to "Snapdragon 870",
"SM8350" to "Snapdragon 888", "SM8450" to "Snapdragon 8 Gen 1", "SM8475" to "Snapdragon 8+ Gen 1",
@@ -19,27 +12,22 @@ object SocNames {
"SM6375" to "Snapdragon 695",
)
/** Platform code names: every chip of one platform shares its CPU and GPU design. */
private val PLATFORMS = mapOf(
"msmnile" to "Snapdragon 855/860", "kona" to "Snapdragon 865/870", "lahaina" to "Snapdragon 888",
"taro" to "Snapdragon 8 Gen 1", "cape" to "Snapdragon 8+ Gen 1", "kalama" to "Snapdragon 8 Gen 2",
"pineapple" to "Snapdragon 8 Gen 3", "sun" to "Snapdragon 8 Elite",
)
/** The chip's model code ("QCS8550", "SG8350P"), or "" when the phone does not say. */
fun model(prop: (String) -> String = GpuInfo::systemProperty): String {
val sdk = if (Build.VERSION.SDK_INT >= 31) Build.SOC_MODEL.takeIf { it != Build.UNKNOWN }.orEmpty() else ""
return listOf(prop("ro.soc.model"), prop("ro.vendor.qti.soc_model"), sdk, prop("ro.fota.platform"))
.map { it.trim() }
// ro.fota.platform is often a branch name ("MSM_13.0"), not a chip.
.firstOrNull { it.isNotEmpty() && !Regex("(?i)^msm_\\d").containsMatchIn(it) }.orEmpty()
}
/** "Snapdragon 8 Gen 2", "Snapdragon 8 Gen 3 family", or null when neither the model nor the platform is known. */
fun name(model: String, platform: String = GpuInfo.systemProperty("ro.board.platform")): String? =
MODELS[model.uppercase()] ?: PLATFORMS[platform.lowercase()]?.let { "$it family" }
/** For the GPU card: "Snapdragon 8 Gen 2 (QCS8550)", the bare model, or "". */
fun label(model: String = model(), platform: String = GpuInfo.systemProperty("ro.board.platform")): String {
val name = name(model, platform)
return when {
@@ -4,18 +4,10 @@ import android.content.Context
import com.droiddeck.launcher.agent.AgentGuest
import org.json.JSONObject
/**
* Cardboard mode's SteamVR (docs/cardboard-vr.md): Valve's ARM64 SteamVR in the guest, rendering
* through the DroidDeck driver as a side-by-side pair that the Cardboard pass puts the lens on. Driven
* through the guest agent's fixed "vr" request (droiddeck-steamvr), so it needs no agent commands.
* Every call blocks on the guest: run them off the main thread.
*/
object SteamVr {
enum class Status {
/** No session, no agent, or a runtime without the helper or the driver. */
UNAVAILABLE,
NOT_INSTALLED,
/** Downloading or unpacking (571 MB). */
INSTALLING,
READY,
RUNNING,
@@ -25,24 +17,17 @@ object SteamVr {
parse(AgentGuest.call(context, JSONObject().put("kind", "vr").put("action", "status"), STATUS_TIMEOUT_MS))
}.getOrDefault(Status.UNAVAILABLE)
/** install, start or stop; true when the guest did it. */
fun run(context: Context, action: String): Boolean = runCatching {
require(action in setOf("install", "start", "stop"))
succeeded(action, AgentGuest.call(context, JSONObject().put("kind", "vr").put("action", action), ACTION_TIMEOUT_MS))
}.getOrDefault(false)
/**
* The agent answers ok whenever it ran the request, even when droiddeck-steamvr then failed; the
* helper's own exit code says whether start or stop worked. install runs detached and only reports
* that it started (its progress shows in status).
*/
fun succeeded(action: String, answer: JSONObject): Boolean = when {
!answer.optBoolean("ok", false) -> false
action == "install" -> answer.optBoolean("started", false)
else -> answer.optInt("exitCode", -1) == 0
}
/** The agent's status answer -> what the menu shows. */
fun parse(answer: JSONObject): Status = when {
!answer.optBoolean("ok", false) -> Status.UNAVAILABLE
answer.optInt("exitCode", 0) != 0 -> Status.UNAVAILABLE
@@ -24,43 +24,17 @@ import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
/**
* The Vulkan driver the in-app compositor runs on. It has to be Turnip: the system Adreno driver
* does not implement VK_EXT_image_drm_format_modifier, so importing the dma-bufs gamescope hands
* over fails and the session renders nothing. Two builds ship in the apk, one per Adreno
* generation, and the GPU decides which is unpacked - unless the user has imported an AdrenoTools
* zip of their own and chosen it, which then wins.
*
* <p>The guest's own Turnip is a different copy entirely - a glibc build inside the rootfs, or an
* imported one ({@link LinuxVulkanDriverManager}). This one is the bionic build the app process
* loads through adrenotools, and it is what every session ends in: whatever draws inside the
* runtime, this is the driver that puts the frame on the panel.
*
* <p>Every driver, bundled or imported, lives under {@code files/graphics_driver/<id>/} with a
* {@code meta.json} whose {@code libraryName} names the .so beside it - the AdrenoTools layout.
* The import path is ported from Bannerlator's {@code AdrenotoolsManager} (GPL-3.0), including
* the refusal of zips that belong in the Linux runtime list: a "-Linux" (glibc) Turnip names no
* library on purpose, and installed here it would put the compositor on the system Vulkan - a
* black screen wearing a driver's name.
*/
public final class TurnipDriver {
private static final String TAG = "TurnipDriver";
/** Pinned A6xx/A7xx upstream build; used as the A6xx offline fallback. */
private static final String DRIVER_A6XX = "turnip26.3.0-a6xx";
/** Adreno 7xx (8 Gen 2/3, e.g. the Pocket FIT's A750). */
private static final String DRIVER_A7XX = "turnip25.1.0";
/** Adreno 8xx (8 Elite, e.g. a Fold 8's A830). */
private static final String DRIVER_A8XX = "turnip-sdk36";
/** The two the apk carries; never removable, unpacked on demand. */
public static final List<String> BUNDLED = Collections.unmodifiableList(Arrays.asList(
DRIVER_A7XX, DRIVER_A8XX, com.droiddeck.launcher.session.QuestExperimental.DRIVER,
DRIVER_A6XX, com.droiddeck.launcher.session.QuestExperimental.DRIVER_A6XX));
/** Overrides the pick, for a device we cannot reach: a7xx, a8xx or system. */
private static final String OVERRIDE_FILE = "Download/droiddeck-driver";
/** Bundled drivers the user deleted: hidden from the list, their unpacked copy removed. */
private static final String PREFS = "graphics_driver";
private static final String KEY_HIDDEN = "hiddenBundled";
/** Stored choice meaning "pick by GPU" - the default, and what a removed import falls back to. */
public static final String AUTO = "";
public static final String HELP_TEXT =
@@ -78,7 +52,6 @@ public final class TurnipDriver {
this.contentDir = new File(context.getFilesDir(), "graphics_driver");
}
/** Absolute directory holding the driver, with a trailing slash - adrenotools wants both. */
public String driverPath(String driverId) {
return new File(contentDir, driverId).getAbsolutePath() + "/";
}
@@ -88,7 +61,6 @@ public final class TurnipDriver {
return meta != null ? meta.optString("libraryName", null) : null;
}
/** meta.json's "name", or the id when it has none. */
public String displayName(String driverId) {
JSONObject meta = readMeta(driverId);
String name = meta != null ? meta.optString("name", "") : "";
@@ -113,17 +85,11 @@ public final class TurnipDriver {
}
}
/** An imported driver is installed when its meta.json names a library that is there. */
public boolean isInstalled(String driverId) {
String library = libraryName(driverId);
return library != null && !library.isEmpty() && new File(new File(contentDir, driverId), library).isFile();
}
/**
* The bundled drivers the list shows: {@link #BUNDLED} minus the ones the user deleted. A deleted
* one still lives in the apk and Auto still unpacks it on a GPU that needs it, so deleting can
* never leave a device without a driver; it only leaves the list.
*/
public List<String> visibleBundled() {
java.util.Set<String> hidden = hiddenBundled();
ArrayList<String> out = new ArrayList<>();
@@ -136,7 +102,6 @@ public final class TurnipDriver {
.getStringSet(KEY_HIDDEN, java.util.Collections.<String>emptySet()));
}
/** "Delete" for a bundled driver: remove its unpacked copy and hide it from the list. */
public void hideBundled(String driverId) {
if (!BUNDLED.contains(driverId)) return;
FileUtils.delete(new File(contentDir, driverId));
@@ -150,7 +115,6 @@ public final class TurnipDriver {
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit().remove(KEY_HIDDEN).apply();
}
/** Imported drivers only - the bundled two are listed by {@link #BUNDLED}. */
public List<String> enumerateImported() {
ArrayList<String> ids = new ArrayList<>();
File[] dirs = contentDir.listFiles();
@@ -163,7 +127,6 @@ public final class TurnipDriver {
return ids;
}
/** The bundled build the GPU would pick on its own, for the "Auto" row's label. */
public String autoId() {
String id = chooseByDevice();
return id == null ? "system" : id;
@@ -177,12 +140,6 @@ public final class TurnipDriver {
if (driverId.equals(SessionPrefs.androidDriver(context))) SessionPrefs.setAndroidDriver(context, AUTO);
}
/**
* Import an AdrenoTools zip. Returns the new driver id.
* @throws IllegalArgumentException with a user-facing reason when the zip is not an AdrenoTools
* driver - including when it is a Linux runtime driver, which says which list it belongs in;
* {@link IOException} on read/extract failures.
*/
public String installFromZip(Uri zipUri, String displayName) throws IOException {
File tmpDir = newStagingDir();
boolean keep = false;
@@ -193,8 +150,6 @@ public final class TurnipDriver {
ZipEntry entry;
while ((entry = zis.getNextEntry()) != null) {
if (entry.isDirectory()) continue;
// Flatten: adrenotools reads the .so beside meta.json, and a base name also
// defeats zip-slip paths.
String base = new File(entry.getName()).getName();
if (base.isEmpty()) continue;
Files.copy(zis, new File(tmpDir, base).toPath(), StandardCopyOption.REPLACE_EXISTING);
@@ -208,7 +163,6 @@ public final class TurnipDriver {
}
}
/** An empty directory beside the installed drivers, for a driver's files before {@link #adopt}. */
File newStagingDir() throws IOException {
if (!contentDir.exists()) contentDir.mkdirs();
File tmpDir = new File(contentDir, ".tmp-" + System.nanoTime());
@@ -217,10 +171,6 @@ public final class TurnipDriver {
return tmpDir;
}
/**
* Check a staged driver (meta.json and its library, flat) and move it in as a new driver.
* Returns the id; the caller deletes {@code tmpDir} when this throws.
*/
String adopt(File tmpDir, String displayName) throws IOException {
String rejected = rejectionReason(tmpDir);
if (rejected != null) throw new IllegalArgumentException(context.getString(R.string.turnip_not_adrenotools, rejected));
@@ -246,10 +196,6 @@ public final class TurnipDriver {
}
}
/**
* Why a just-extracted zip is not something adrenotools can be pointed at, or null when it is.
* The kinds refused by name are the other driver lists' zips, which carry a meta.json too.
*/
private String rejectionReason(File dir) {
File metaFile = new File(dir, "meta.json");
if (!metaFile.isFile()) return context.getString(R.string.turnip_reject_no_meta);
@@ -272,7 +218,6 @@ public final class TurnipDriver {
return context.getString(R.string.turnip_reject_library_missing, libraryName);
if (!LinuxVulkanDriverManager.isAarch64Elf(library))
return context.getString(R.string.turnip_reject_not_aarch64, libraryName);
// A glibc build that happens to carry a libraryName would load nothing in this process.
if (LinuxVulkanDriverManager.containsAscii(library, "libc.so.6"))
return context.getString(R.string.turnip_reject_glibc, libraryName);
return null;
@@ -285,11 +230,6 @@ public final class TurnipDriver {
return id;
}
/**
* Unpacks the driver this device needs and returns its id, or null to fall back to the system
* Vulkan loader (which means a black session on Adreno, but is better than refusing to start
* on a GPU neither build covers).
*/
public String install() {
String id = choose();
DriverSetupLog.write(context, "install.begin driver=" + id);
@@ -314,11 +254,6 @@ public final class TurnipDriver {
return id;
}
/**
* The user's choice first - an imported driver, or one of the bundled two pinned by hand -
* then the Downloads override, then the GPU. A chosen import that has since been removed logs
* and falls through, so a stale preference never blocks a session.
*/
private String choose() {
String chosen = SessionPrefs.androidDriver(context);
if (chosen != null && !chosen.isEmpty()) {
@@ -349,7 +284,6 @@ public final class TurnipDriver {
String model = gpuModel();
Log.i(TAG, "gpu model: " + (model == null ? "unknown" : model));
if (model != null) {
// "Adreno750", "adreno_830" - the generation is the first digit of the three.
java.util.regex.Matcher m = java.util.regex.Pattern.compile("(\\d)\\d\\d").matcher(model);
if (m.find()) {
char generation = m.group(1).charAt(0);
@@ -358,11 +292,9 @@ public final class TurnipDriver {
if (generation == '6') return DRIVER_A6XX;
}
}
// Nothing to go on: Android 16 shipped with the 8 Elite, so treat a new device as 8xx.
return android.os.Build.VERSION.SDK_INT >= 36 ? DRIVER_A8XX : DRIVER_A7XX;
}
/** KGSL names the GPU here, and this file is world-readable where /dev/kgsl-3d0 is not. */
private static String gpuModel() {
for (String path : new String[]{
"/sys/class/kgsl/kgsl-3d0/gpu_model",
@@ -12,41 +12,20 @@ import java.io.IOException
import java.net.HttpURLConnection
import java.net.URL
/**
* Driver downloads from the Turnip release repos, offered in both driver menus. Checked only when
* the user taps refresh - the result is remembered, so the menu shows the last check without going
* online. A download goes through the same importer as a zip picked by hand, so it gets the same
* checks and lands as an ordinary imported driver.
*
* Each repo's recent releases are read newest first and every driver variant is offered from the
* newest release that carries it: a repo that stops publishing one variant (Banners-Turnip's A8xx
* Linux build after v26.3.0-20260923) still offers its last one, and a repo with two release lines
* (WinNative's Android `v1.x` and Linux `linux-v0.x`) offers the newest of each.
*/
object TurnipReleases {
private const val PREFS = "turnip_releases"
private const val KEY_RELEASE = "latest"
private const val KEY_DOWNLOADS = "downloads"
/** [label] names the variant for the menu: the GPUs it is for, and a build flavour. */
/** [sha256] is the release asset's digest from GitHub; empty for a list cached before it was kept. */
/**
* [pair] names the matched set an asset belongs to (DriverPairs): a display build and a Linux
* build of the same pair are made to run together. "" for a list cached before pairs were kept.
*/
/** [bundle]: one zip holding both halves of the pair (DriverBundle); [linux] is false for it. */
class Asset(val source: String, val tag: String, val name: String, val url: String, val size: Long, val linux: Boolean, val label: String,
val sha256: String = "", val pair: String = "", val bundle: Boolean = false)
/** [latest] = each source's newest release tag, for the refresh line. */
class Check(val assets: List<Asset>, val latest: List<Pair<String, String>>, val failed: List<String>, val checkedAt: Long)
/** What an asset is: a Linux build or not, the menu label, and the pair it belongs to. */
private class Kind(val linux: Boolean, val label: String, val pair: String, val bundle: Boolean = false)
private class Source(val label: String, val repo: String, val classify: (name: String, tag: String) -> Kind?)
private val SOURCES = listOf(
// Turnip-<tag>[-variant][-Linux|-Wayland].zip; -Wayland is for a path this app does not have.
Source("Banners-Turnip", "The412Banner/Banners-Turnip") { name, tag ->
val prefix = "Turnip-$tag"
if (!name.startsWith(prefix) || !name.endsWith(".zip")) return@Source null
@@ -63,32 +42,23 @@ object TurnipReleases {
}
Kind(linux, label, "banner" + variant.lowercase())
},
// WN-Turnip-<ver>-<b|p>_Axxx.zip (Android) and WN-Linux-Turnip-<ver>-<b|p>_Axxx.zip (Linux):
// b = Balanced, p = Performance, Axxx = every Adreno.
Source("WinNative", "WinNative-Emu/Drivers") { name, _ ->
val m = Regex("""^WN-(Linux-)?Turnip-[^-]+-([a-z]+)_(\w+)\.zip$""").find(name) ?: return@Source null
val flavour = when (m.groupValues[2]) { "b" -> "Balanced"; "p" -> "Performance"; else -> m.groupValues[2] }
val gpus = if (m.groupValues[3] == "Axxx") "all Adreno" else m.groupValues[3]
Kind(m.groupValues[1].isNotEmpty(), "$gpus · $flavour", "wn-" + m.groupValues[2])
},
// DD-Turnip-v<ver>.zip: DroidDeck's own all-in-one build, both halves in one zip, published
// to Drivers-CI (releases only). Every release is offered, not just the newest, each its own pair.
Source("DroidDeck", "Droid-Deck/Drivers-CI") { name, tag ->
if (!Regex("""^DD-Turnip-v\d+\.\d+\.\d+\.zip$""").matches(name)) return@Source null
Kind(false, "Android + Linux · all Adreno", DriverPairs.ddTurnip(tag), bundle = true)
},
)
/** The result of the last check, or null when the user has never checked. */
fun cached(context: Context): Check? {
val raw = prefs(context).getString(KEY_RELEASE, null) ?: return null
return runCatching { parse(JSONObject(raw)) }.getOrNull()
}
/**
* Read every source now and remember the result. A source that fails is named in [Check.failed]
* and the others still count; throws only when every source failed.
*/
fun refresh(context: Context): Check {
val assets = JSONArray()
val latest = JSONArray()
@@ -109,13 +79,10 @@ object TurnipReleases {
val a = list.getJSONObject(j)
val name = a.getString("name")
val kind = src.classify(name, tag) ?: continue
// A bundle is only offered from an official release, never a pre-release.
if (kind.bundle && r.optBoolean("prerelease")) continue
val linux = kind.linux
val label = kind.label
// Only assets GitHub has a sha256 for are offered: the download is checked against it.
val sha = Hashes.githubSha256(a.optString("digest")) ?: continue
// Newest first: the first release carrying a variant is the one offered.
if (!seen.add(if (kind.bundle) kind.pair else "$linux|$label")) continue
assets.put(JSONObject().put("source", src.label).put("tag", tag).put("name", name)
.put("url", a.getString("browser_download_url")).put("size", a.optLong("size"))
@@ -170,11 +137,9 @@ object TurnipReleases {
return Check(out, latest, failed, json.optLong("checkedAt"))
}
/** The id an asset was installed as, when it was downloaded before and is still installed. */
fun installedId(context: Context, asset: Asset, isInstalled: (String) -> Boolean): String? =
downloads(context).optString(asset.name, "").takeIf { it.isNotEmpty() && isInstalled(it) }
/** True when [id] came from a release download rather than a zip picked by hand. */
fun isDownloaded(context: Context, id: String): Boolean {
val d = downloads(context)
return d.keys().asSequence().any { d.optString(it) == id }
@@ -184,7 +149,6 @@ object TurnipReleases {
prefs(context).edit().putString(KEY_DOWNLOADS, downloads(context).put(asset.name, id).toString()).apply()
}
/** Forget a deleted driver, so its release offers the download again. */
fun forget(context: Context, id: String) {
val d = downloads(context)
val keys = d.keys().asSequence().filter { d.optString(it) == id }.toList()
@@ -193,7 +157,6 @@ object TurnipReleases {
prefs(context).edit().putString(KEY_DOWNLOADS, d.toString()).apply()
}
/** Download an asset into the cache; the caller imports it and deletes the file. */
fun download(context: Context, asset: Asset, progress: (Int) -> Unit): File {
if (asset.sha256.isEmpty()) throw IOException(context.getString(R.string.turnip_list_predates_checksums))
val target = File(context.cacheDir, asset.name)
@@ -2,17 +2,11 @@ package com.droiddeck.launcher.gpu
import android.util.Log
/**
* The phone's own Vulkan driver, as it describes itself (native/deviceinfo): device name, API and
* driver versions, a few limits and the extensions DXVK/VKD3D lean on. Asked once per process and
* kept; the first [query] creates a Vulkan instance, so it belongs off the main thread.
*/
object VulkanInfo {
@Volatile private var cached: Map<String, String>? = null
@JvmStatic private external fun nativeQuery(): String
/** Blocking on first use. Empty-ish map with an "error" key when Vulkan cannot be asked. */
@Synchronized
fun query(): Map<String, String> {
cached?.let { return it }
@@ -31,6 +25,5 @@ object VulkanInfo {
return map
}
/** What [query] found, if it has run in this process; never blocks. */
fun cachedOrNull(): Map<String, String>? = cached
}