quoije/useless-umd-player
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Stop previous stream when a new one starts; ease animations

Browse Source 
Starting a movie now closes the current decode engine and bumps a playback
generation so the stale video/audio threads stop themselves (they were
overlapping the movie's canvas and audio). PlaybackEngine.close is idempotent.
Animation records now honor their accelMode (linear/accel/decel easing).
This commit is contained in:
quoije
2026-09-16 12:20:47 -04:00
parent 0531671d26
commit ba21426b77
9 changed files with 103 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+24 -5
View File
@@ -8,21 +8,40 @@ a standalone player for PSP UMD Video ISO images: open a disc, render its real
menu, and play the movie (H.264 video + ATRAC3+ audio) with mouse and
keyboard/media-key controls.
> **Status:** early development. Currently implemented: ISO 9660/UMD reading,
> `param.sfo` metadata parsing, and file listing.
> **Status:** playable. Opens a UMD Video ISO, plays the real RCO menu (rendered
> from the disc), and plays the movie (H.264 video + ATRAC3+ audio).
## Build
Requires JDK 21 (Gradle auto-provisions it via the Foojay toolchain resolver).
Requires JDK 21 (Gradle auto-provisions it).
```sh
./gradlew build
```
## Run
## Run the player
```sh
./gradlew cli:run --args="dump /path/to/disc.iso"
./gradlew ui:run --args="/path/to/disc.iso"
```
Controls:
- **↑ ↓ ← →** — navigate the menu
- **Enter** — select
- **M** — back to the menu
- **S** — skip the current intro/track
- **Space / P** — pause
- **F11** — fullscreen
## CLI
The `cli` module has inspection/debug commands:
```sh
./gradlew cli:run --args="dump /path/to/disc.iso" # metadata + playlist
./gradlew cli:run --args="rco <iso> UMD_VIDEO/RESOURCE/EN100000.RCO" # menu data
./gradlew cli:run --args="play <iso> <streamName>" # headless A/V sync test
```
## License
core/src/main/java/dev/quoije/umd/player/PlaybackEngine.java
+5
View File
@@ -66,6 +66,7 @@ public final class PlaybackEngine implements AutoCloseable {
private volatile boolean eof = false;
private volatile IOException failure = null;
private volatile boolean closed = false;
private final Thread decodeThread;
private PlaybackEngine(UmdIsoReader iso, String streamName, int audioSubstream) throws IOException {
@@ -254,6 +255,10 @@ public final class PlaybackEngine implements AutoCloseable {
@Override
public void close() {
if (closed) {
return;
}
closed = true;
decodeThread.interrupt();
try {
decodeThread.join(1000);
core/src/main/java/dev/quoije/umd/rco/anim/FadeAnim.java
+1 -1
View File
@@ -26,7 +26,7 @@ public class FadeAnim extends BaseAnim {
return;
}
float sa = target.alphaScale.getFloatValue();
Animator.getInstance().add(new Tween(millis, p -> {
Animator.getInstance().add(new Tween(millis, accelMode.getIntValue(), p -> {
target.alphaScale.setFloatValue(sa + (ta - sa) * p);
target.onDisplayUpdated();
}));
core/src/main/java/dev/quoije/umd/rco/anim/MoveToAnim.java
+1 -1
View File
@@ -34,7 +34,7 @@ public class MoveToAnim extends BaseAnim {
float sx = target.animX;
float sy = target.animY;
float sz = target.animZ;
Animator.getInstance().add(new Tween(millis, p -> {
Animator.getInstance().add(new Tween(millis, accelMode.getIntValue(), p -> {
target.animX = sx + (tx - sx) * p;
target.animY = sy + (ty - sy) * p;
target.animZ = sz + (tz - sz) * p;
core/src/main/java/dev/quoije/umd/rco/anim/RecolourAnim.java
+1 -1
View File
@@ -38,7 +38,7 @@ public class RecolourAnim extends BaseAnim {
float sg = target.greenScale.getFloatValue();
float sb = target.blueScale.getFloatValue();
float sa = target.alphaScale.getFloatValue();
Animator.getInstance().add(new Tween(millis, p -> {
Animator.getInstance().add(new Tween(millis, accelMode.getIntValue(), p -> {
target.redScale.setFloatValue(sr + (tr - sr) * p);
target.greenScale.setFloatValue(sg + (tg - sg) * p);
target.blueScale.setFloatValue(sb + (tb - sb) * p);
core/src/main/java/dev/quoije/umd/rco/anim/ResizeAnim.java
+1 -1
View File
@@ -34,7 +34,7 @@ public class ResizeAnim extends BaseAnim {
float sw = target.scaleWidth.getFloatValue();
float sh = target.scaleHeight.getFloatValue();
float sd = target.scaleDepth.getFloatValue();
Animator.getInstance().add(new Tween(millis, p -> {
Animator.getInstance().add(new Tween(millis, accelMode.getIntValue(), p -> {
target.scaleWidth.setFloatValue(sw + (tw - sw) * p);
target.scaleHeight.setFloatValue(sh + (th - sh) * p);
target.scaleDepth.setFloatValue(sd + (td - sd) * p);
core/src/main/java/dev/quoije/umd/rco/anim/RotateAnim.java
+1 -1
View File
@@ -34,7 +34,7 @@ public class RotateAnim extends BaseAnim {
float sx = target.rotX;
float sy = target.rotY;
float sz = target.rotZ;
Animator.getInstance().add(new Tween(millis, p -> {
Animator.getInstance().add(new Tween(millis, accelMode.getIntValue(), p -> {
target.rotX = sx + (tx - sx) * p;
target.rotY = sy + (ty - sy) * p;
target.rotZ = sz + (tz - sz) * p;
core/src/main/java/dev/quoije/umd/rco/anim/Tween.java
+23 -2
View File
@@ -3,10 +3,17 @@ package dev.quoije.umd.rco.anim;
/**
* A single interpolation from 0..1 over a duration in milliseconds. The
* callback receives linear progress each frame until completion.
* callback receives eased progress each frame until completion.
*/
public final class Tween {
/** Linear progress (no easing). */
public static final int EASE_LINEAR = 0;
/** Accelerate: slow start, fast finish. */
public static final int EASE_IN = 1;
/** Decelerate: fast start, slow finish. */
public static final int EASE_OUT = 2;
/** Receives progress 0..1 on every animation tick. */
@FunctionalInterface
public interface ProgressCallback {
@@ -15,12 +22,18 @@ public final class Tween {
private final long startNanos;
private final long durationNanos;
private final int accelMode;
private final ProgressCallback callback;
private boolean finished;
public Tween(long durationMillis, ProgressCallback callback) {
this(durationMillis, EASE_LINEAR, callback);
}
public Tween(long durationMillis, int accelMode, ProgressCallback callback) {
this.startNanos = System.nanoTime();
this.durationNanos = Math.max(1L, durationMillis) * 1_000_000L;
this.accelMode = accelMode;
this.callback = callback;
}
@@ -31,7 +44,15 @@ public final class Tween {
progress = 1f;
finished = true;
}
callback.apply(progress);
callback.apply(ease(progress, accelMode));
return finished;
}
private static float ease(float p, int accelMode) {
return switch (accelMode) {
case EASE_IN -> p * p;
case EASE_OUT -> 1f - (1f - p) * (1f - p);
default -> p;
};
}
}
ui/src/main/java/dev/quoije/umd/ui/PlayerApp.java
+46 -8
View File
@@ -72,6 +72,11 @@ public final class PlayerApp extends Application {
private volatile VsmxNativeObject controllerObject;
private long lastMenuKeyNanos = 0;
/** The active decode engine, closed when a new stream starts. */
private volatile PlaybackEngine currentEngine;
/** Bumped each time playback starts so stale streams stop themselves. */
private volatile long playbackGeneration = 0;
@Override
public void start(Stage stage) {
// Gradle's --args splits on whitespace; rejoin so paths with spaces work.
@@ -200,6 +205,12 @@ public final class PlayerApp extends Application {
@Override
public void stopMovie() {
PlaybackEngine engine = currentEngine;
if (engine != null) {
playbackGeneration++;
engine.close();
currentEngine = null;
}
}
@Override
@@ -230,17 +241,29 @@ public final class PlayerApp extends Application {
private void startPlayback(String isoPath, Playlist.Stream stream, int playListNumber) {
String streamName = stream.name();
long generation = ++playbackGeneration;
// Stop the previous stream so its video and audio threads don't keep
// playing underneath the new one.
PlaybackEngine previous = currentEngine;
if (previous != null) {
previous.close();
}
currentEngine = null;
Thread player = new Thread(() -> {
try (UmdIsoReader iso = new UmdIsoReader(Path.of(isoPath));
PlaybackEngine engine = PlaybackEngine.open(iso, streamName, 0)) {
currentEngine = engine;
// Each stream has its own PTS timeline, so re-anchor the master
// clock to this stream's first audio chunk.
clockStartPts = -1;
clockStartNanos = -1;
clockOffsetNanos = 0;
Thread audio = startAudio(engine);
Thread audio = startAudio(engine, generation);
awaitClock();
long basePts = clockStartPts;
long baseNanos = clockStartNanos;
@@ -248,6 +271,9 @@ public final class PlayerApp extends Application {
PlaybackEngine.VideoFrame frame;
int lastChapter = -2;
while ((frame = engine.nextVideoFrame()) != null) {
if (playbackGeneration != generation) {
break;
}
if (skipRequested) {
skipRequested = false;
break;
@@ -279,13 +305,17 @@ public final class PlayerApp extends Application {
sleepUntil(targetNanos);
}
// Wait for the audio thread to finish draining before the
// engine (and its decoders) is closed by this try block.
// Wait for the audio thread to finish before the engine (and
// its decoders) is closed by this try block.
audio.join(2000);
MoviePlayer mp = moviePlayer;
if (mp != null) {
mp.onPlayListEnd(playListNumber);
// Only report end-of-stream if we're still the active playback;
// otherwise a stale stream would re-trigger the menu loop.
if (playbackGeneration == generation) {
MoviePlayer mp = moviePlayer;
if (mp != null) {
mp.onPlayListEnd(playListNumber);
}
}
} catch (Exception e) {
e.printStackTrace();
@@ -296,13 +326,16 @@ public final class PlayerApp extends Application {
}
/** Plays decoded PCM through the system audio line, acting as the master A/V clock. */
private Thread startAudio(PlaybackEngine engine) {
private Thread startAudio(PlaybackEngine engine, long generation) {
Thread audio = new Thread(() -> {
SourceDataLine line = null;
try {
line = openLine();
PlaybackEngine.AudioChunk chunk;
while ((chunk = engine.nextAudioChunk()) != null) {
if (playbackGeneration != generation) {
break;
}
if (clockStartPts < 0) {
clockStartPts = chunk.pts();
clockStartNanos = System.nanoTime();
@@ -313,7 +346,12 @@ public final class PlayerApp extends Application {
sleepUntil(targetNanos);
line.write(chunk.pcm(), 0, chunk.pcm().length);
}
line.drain();
if (playbackGeneration != generation) {
// Superseded: cut off any buffered audio immediately.
line.flush();
} else {
line.drain();
}
} catch (Exception e) {
e.printStackTrace();
} finally {