Merge motor-sound into main: v0.6.0 release

Author: eried

.gitignore

@@ -26,6 +26,8 @@ release/
 *.btsnoop
 *.cfa
 *.log
+deletelater.html
+delete.html
 
 # Stray build-output paths that have leaked into the repo before
 **/eucplanet_*.png

app/build.gradle.kts

@@ -27,8 +27,8 @@ android {
         applicationId = "com.eried.eucplanet"
         minSdk = 29
         targetSdk = 35
-        versionCode = 37
-        versionName = "0.4.5"
+        versionCode = 39
+        versionName = "0.6.0"
 
         val buildStamp = SimpleDateFormat("yyMMdd.HHmm")
             .apply { timeZone = TimeZone.getTimeZone("UTC") }
@@ -133,6 +133,10 @@ dependencies {
     // Drag-to-reorder for settings lists
     implementation(libs.reorderable)
 
+    // ExoPlayer — gapless looping for the multi-section engine sound composition
+    implementation(libs.media3.exoplayer)
+    implementation(libs.media3.common)
+
     // Wear OS Data Layer (talks to the wear/ companion module on paired watches)
     implementation(libs.play.services.wearable)
 }

app/src/main/java/com/eried/eucplanet/audio/CompositionEnginePlayer.kt

@@ -0,0 +1,250 @@
+package com.eried.eucplanet.audio
+
+import android.content.Context
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import androidx.annotation.OptIn
+import androidx.media3.common.AudioAttributes
+import androidx.media3.common.C
+import androidx.media3.common.MediaItem
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.datasource.DataSource
+import androidx.media3.datasource.RawResourceDataSource
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.exoplayer.source.ClippingMediaSource
+import androidx.media3.exoplayer.source.ProgressiveMediaSource
+import kotlin.math.abs
+
+/**
+ * Multi-section playback for sampled engines. Procedural [EngineSynth] plays a
+ * single buffer it owns; this player composes the engine sound from named
+ * sections inside one or more raw resources (picked in deletelater.html).
+ *
+ * Section types:
+ *  - "idle_loop" — sustained low-RPM loop (required)
+ *  - "rev_loop"  — sustained high-RPM loop (optional — without it, idle pitch-shifts up)
+ *  - "startup"   — one-shot transient played on engine start (optional)
+ *  - "decel"     — one-shot transient played when throttle closes sharply (optional)
+ *  - "shutdown"  — one-shot transient played on engine stop (optional)
+ *
+ * Looping sections use [ExoPlayer] with [ClippingMediaSource] + REPEAT_MODE_ONE so
+ * the decoder seamlessly stitches the startMs..endMs window back to its start —
+ * no audible click at the seam. The two loops (idle, rev) play simultaneously and
+ * are crossfaded by RPM. One-shots are spawned on demand for startup/decel/shutdown.
+ */
+@OptIn(UnstableApi::class)
+class CompositionEnginePlayer(private val context: Context) {
+
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    @Volatile private var profile: EngineProfile? = null
+    @Volatile private var idle: SectionPlayer? = null
+    @Volatile private var rev: SectionPlayer? = null
+    private val oneShots = mutableListOf<SectionPlayer>()
+
+    @Volatile private var lastVolume: Float = 0f
+    @Volatile private var lastRpmNorm: Float = 0f
+    @Volatile private var lastIdleVol: Float = -1f
+    @Volatile private var lastRevVol: Float = -1f
+    @Volatile private var lastSpeed: Float = -1f
+    // Smoothed actual volumes — drives engine-start fade-in plus the idle ↔ rev
+    // crossfade. Alpha 0.15 ≈ ~85 ms time constant at ~100 Hz telemetry.
+    @Volatile private var smoothedIdleVol: Float = 0f
+    @Volatile private var smoothedRevVol: Float = 0f
+    private val volSmoothingAlpha = 0.15f
+
+    fun isPlaying(): Boolean = idle != null
+
+    fun start(profile: EngineProfile) {
+        if (this.profile?.key == profile.key && idle != null) return
+        stop()
+        val sections = profile.sampleSections ?: return
+        this.profile = profile
+
+        sections["idle_loop"]?.let { sec ->
+            idle = SectionPlayer(context, sec, looping = true).also {
+                if (!it.prepare()) { it.release(); idle = null; Log.w(TAG, "idle_loop failed") }
+                else { it.setVolume(0f); it.play() }
+            }
+        }
+        sections["rev_loop"]?.let { sec ->
+            rev = SectionPlayer(context, sec, looping = true).also {
+                if (!it.prepare()) { it.release(); rev = null; Log.w(TAG, "rev_loop failed") }
+                else { it.setVolume(0f); it.play() }
+            }
+        }
+        sections["startup"]?.let { fireOneShot(it, gain = 1f) }
+    }
+
+    fun stop() {
+        val shutdown = profile?.sampleSections?.get("shutdown")
+        val fadeDurMs = shutdown?.durationMs?.coerceIn(200, 2500) ?: 300
+        shutdown?.let { fireOneShot(it, gain = lastVolume) }
+
+        val idleSnap = idle
+        val revSnap = rev
+        val startIdle = smoothedIdleVol
+        val startRev = smoothedRevVol
+        idle = null
+        rev = null
+        profile = null
+        val steps = 24
+        val stepMs = (fadeDurMs / steps).coerceAtLeast(8)
+        for (i in 1..steps) {
+            val gain = 1f - (i.toFloat() / steps)
+            mainHandler.postDelayed({
+                idleSnap?.setVolume(startIdle * gain)
+                revSnap?.setVolume(startRev * gain)
+            }, (i * stepMs).toLong())
+        }
+        mainHandler.postDelayed({
+            idleSnap?.release()
+            revSnap?.release()
+            synchronized(oneShots) {
+                oneShots.forEach { it.release() }
+                oneShots.clear()
+            }
+        }, (fadeDurMs + 100).toLong())
+
+        lastIdleVol = -1f
+        lastRevVol = -1f
+        lastSpeed = -1f
+        smoothedIdleVol = 0f
+        smoothedRevVol = 0f
+    }
+
+    fun update(rpmNorm: Float, volume: Float) {
+        lastRpmNorm = rpmNorm.coerceIn(0f, 1f)
+        lastVolume = volume.coerceIn(0f, 1f)
+
+        // Equal-power crossfade between idle and rev. At rpm=0.5 each contributes
+        // sqrt(0.5)≈0.71, summing close to 1 in perceived loudness.
+        val targetIdle = if (rev == null) lastVolume else kotlin.math.sqrt(1f - lastRpmNorm) * lastVolume
+        val targetRev  = if (rev == null) 0f else kotlin.math.sqrt(lastRpmNorm) * lastVolume
+
+        smoothedIdleVol += (targetIdle - smoothedIdleVol) * volSmoothingAlpha
+        smoothedRevVol  += (targetRev  - smoothedRevVol)  * volSmoothingAlpha
+
+        if (abs(smoothedIdleVol - lastIdleVol) > 0.005f) {
+            idle?.setVolume(smoothedIdleVol); lastIdleVol = smoothedIdleVol
+        }
+        if (abs(smoothedRevVol - lastRevVol) > 0.005f) {
+            rev?.setVolume(smoothedRevVol); lastRevVol = smoothedRevVol
+        }
+
+        // Playback speed stays at 1.0× — ExoPlayer's Sonic time-stretch was painting
+        // audible artifacts over every loop iteration. The natural idle ↔ rev crossfade
+        // (above) handles the perceived "going faster" without touching pitch.
+        // Variable speed left for a future profile-level opt-in only if a clip really
+        // demands it.
+    }
+
+    fun fireDecel() {
+        profile?.sampleSections?.get("decel")?.let { fireOneShot(it, gain = lastVolume) }
+    }
+
+    private fun fireOneShot(section: SampleSection, gain: Float) {
+        val sp = SectionPlayer(context, section, looping = false)
+        if (!sp.prepare()) { sp.release(); return }
+        sp.setVolume(gain.coerceIn(0f, 1f))
+        sp.play()
+        synchronized(oneShots) { oneShots.add(sp) }
+        mainHandler.postDelayed({
+            synchronized(oneShots) { oneShots.remove(sp) }
+            sp.release()
+        }, section.durationMs + 200L)   // grace beyond the natural duration
+    }
+
+    companion object {
+        private const val TAG = "CompositionEnginePlayer"
+    }
+}
+
+/**
+ * Plays a [SampleSection] from a res/raw resource via [ExoPlayer]. When
+ * [looping] is true, ExoPlayer's [ClippingMediaSource] reports a duration
+ * matching the section window and REPEAT_MODE_ONE handles a gapless restart —
+ * no perceptible seam.
+ */
+@OptIn(UnstableApi::class)
+private class SectionPlayer(
+    private val context: Context,
+    private val section: SampleSection,
+    private val looping: Boolean,
+) {
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private val player: ExoPlayer = ExoPlayer.Builder(context)
+        // Bind to the main looper so callers from any thread can talk to us safely
+        // through [postToMain] — all actual mutations happen there.
+        .setLooper(Looper.getMainLooper())
+        .setAudioAttributes(
+            AudioAttributes.Builder()
+                .setUsage(C.USAGE_MEDIA)
+                .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC)
+                .build(),
+            /* handleAudioFocus = */ false
+        )
+        .build()
+    @Volatile private var released = false
+
+    private inline fun postToMain(crossinline block: () -> Unit) {
+        if (Looper.myLooper() == Looper.getMainLooper()) block()
+        else mainHandler.post { block() }
+    }
+
+    fun prepare(): Boolean {
+        val resId = context.resources.getIdentifier(section.rawAsset, "raw", context.packageName)
+        if (resId == 0) {
+            Log.w("SectionPlayer", "raw/${section.rawAsset} not found")
+            return false
+        }
+        return try {
+            postToMain {
+                if (released) return@postToMain
+                val uri = RawResourceDataSource.buildRawResourceUri(resId)
+                val dataSourceFactory = DataSource.Factory { RawResourceDataSource(context) }
+                val mediaItem = MediaItem.fromUri(uri)
+                val source = ProgressiveMediaSource.Factory(dataSourceFactory)
+                    .createMediaSource(mediaItem)
+                // ClippingMediaSource takes microseconds, and REPEAT_MODE_ONE then
+                // gaplessly stitches the [startMs..endMs] window into a continuous loop.
+                val clipped = ClippingMediaSource(
+                    source,
+                    section.startMs * 1000L,
+                    section.endMs * 1000L
+                )
+                player.setMediaSource(clipped)
+                player.repeatMode = if (looping) Player.REPEAT_MODE_ONE else Player.REPEAT_MODE_OFF
+                player.volume = 0f
+                player.prepare()
+            }
+            true
+        } catch (e: Throwable) {
+            Log.e("SectionPlayer", "prepare failed for ${section.rawAsset}", e)
+            false
+        }
+    }
+
+    fun play() = postToMain { if (!released) player.play() }
+
+    fun setVolume(v: Float) = postToMain {
+        if (released) return@postToMain
+        try { player.volume = v.coerceIn(0f, 1f) } catch (_: Throwable) {}
+    }
+
+    fun setSpeed(s: Float) = postToMain {
+        if (released) return@postToMain
+        try { player.setPlaybackSpeed(s.coerceIn(0.5f, 2.0f)) } catch (_: Throwable) {}
+    }
+
+    fun release() {
+        released = true
+        postToMain {
+            try { player.stop() } catch (_: Throwable) {}
+            try { player.release() } catch (_: Throwable) {}
+        }
+    }
+}

app/src/main/java/com/eried/eucplanet/audio/EngineParams.kt

@@ -0,0 +1,40 @@
+package com.eried.eucplanet.audio
+
+/**
+ * Snapshot of live engine state, produced by [EngineSoundEngine] and consumed by
+ * the audio thread on every buffer fill. All fields are smoothed/derived — the
+ * raw (speed, pwm) inputs never reach the synth directly so jittery telemetry
+ * doesn't make the engine warble.
+ *
+ * Immutable / value-type by intent; copy a new one on each update.
+ */
+data class EngineParams(
+    /** Smoothed engine RPM (post low-pass). */
+    val rpm: Float = 0f,
+    /** Smoothed load 0..1 (PWM normalized, with floor for engine compression sound at idle). */
+    val load: Float = 0f,
+    /** Decel intensity 0..1 — rises when PWM falls sharply; drives backfire pops. */
+    val decelAmount: Float = 0f,
+    /** Idle envelope 0..1 — fades the whole signal out after parked timeout. */
+    val idleAmount: Float = 1f,
+    /** Master output gain 0..1 (master volume × duck factor). */
+    val masterGain: Float = 1f,
+    /** Number of decel pop events queued for this buffer (0+ — typically 0 or 1). */
+    val pendingPops: Int = 0,
+    /** Transient RPM bump from rev-up detection — added on top of [rpm] in the synth. */
+    val revBump: Float = 0f,
+    /**
+     * Engine brake intensity 0..1 — rises during sustained regen/decel, decays
+     * back to 0 under accel/cruise. Drives the high-frequency overrun whine.
+     */
+    val engineBrakeAmount: Float = 0f,
+    /** Active profile. */
+    val profile: EngineProfile = EngineProfile.byKey("FOUR_STROKE_SINGLE"),
+    /** Muffler cutoff scale 0..1 (1 = open pipes, 0 = closed muffler). */
+    val mufflerOpenness: Float = 0.6f
+) {
+    companion object {
+        /** Silent / off state. */
+        val SILENT = EngineParams(rpm = 0f, masterGain = 0f, idleAmount = 0f)
+    }
+}