Release line when device is inactive or after being idle for a while (#150)

Author: devgianlu

core/src/main/java/xyz/gianlu/librespot/FileConfiguration.java

@@ -285,6 +285,11 @@ public int crossfadeDuration() {
         return config.get("player.crossfadeDuration");
     }
 
+    @Override
+    public int releaseLineDelay() {
+        return config.get("player.releaseLineDelay");
+    }
+
     @Override
     public @Nullable String deviceName() {
         return config.get("deviceName");

core/src/main/java/xyz/gianlu/librespot/player/Player.java

@@ -7,6 +7,7 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import spotify.player.proto.transfer.TransferStateOuterClass;
+import xyz.gianlu.librespot.common.NameThreadFactory;
 import xyz.gianlu.librespot.common.Utils;
 import xyz.gianlu.librespot.connectstate.DeviceStateHandler;
 import xyz.gianlu.librespot.connectstate.DeviceStateHandler.PlayCommandHelper;
@@ -26,6 +27,10 @@
 import java.io.IOException;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
 
 import static spotify.player.proto.ContextTrackOuterClass.ContextTrack;
 
@@ -34,13 +39,15 @@
  */
 public class Player implements Closeable, DeviceStateHandler.Listener, PlayerRunner.Listener {
     private static final Logger LOGGER = Logger.getLogger(Player.class);
+    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(new NameThreadFactory((r) -> "release-line-scheduler-" + r.hashCode()));
     private final Session session;
     private final Configuration conf;
     private final PlayerRunner runner;
     private StateWrapper state;
     private TrackHandler trackHandler;
     private TrackHandler crossfadeHandler;
     private TrackHandler preloadTrackHandler;
+    private ScheduledFuture releaseLineFuture = null;
 
     public Player(@NotNull Player.Configuration conf, @NotNull Session session) {
         this.conf = conf;
@@ -206,7 +213,7 @@ public void volumeChanged() {
 
     @Override
     public void notActive() {
-        runner.stopMixer();
+        if (runner.stopAndRelease()) LOGGER.debug("Released line due to inactivity.");
     }
 
     @Override
@@ -428,6 +435,11 @@ private void loadTrack(boolean play, @NotNull PushToMixerReason reason) {
                 runner.playMixer();
             }
         }
+
+        if (releaseLineFuture != null) {
+            releaseLineFuture.cancel(true);
+            releaseLineFuture = null;
+        }
     }
 
     private void handleResume() {
@@ -442,6 +454,11 @@ private void handleResume() {
             }
 
             state.updated();
+
+            if (releaseLineFuture != null) {
+                releaseLineFuture.cancel(true);
+                releaseLineFuture = null;
+            }
         }
     }
 
@@ -456,6 +473,13 @@ private void handlePause() {
             }
 
             state.updated();
+
+            if (releaseLineFuture != null) releaseLineFuture.cancel(true);
+            releaseLineFuture = scheduler.schedule(() -> {
+                if (!state.isPaused()) return;
+
+                if (runner.pauseAndRelease()) LOGGER.debug("Released line after a period of inactivity.");
+            }, conf.releaseLineDelay(), TimeUnit.SECONDS);
         }
     }
 
@@ -631,5 +655,7 @@ public interface Configuration {
         boolean autoplayEnabled();
 
         int crossfadeDuration();
+
+        int releaseLineDelay();
     }
 }

core/src/main/java/xyz/gianlu/librespot/player/PlayerRunner.java

@@ -3,7 +3,6 @@
 import com.spotify.metadata.proto.Metadata;
 import javazoom.jl.decoder.BitstreamException;
 import org.apache.log4j.Logger;
-import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import xyz.gianlu.librespot.common.NameThreadFactory;
@@ -65,10 +64,7 @@ public class PlayerRunner implements Runnable, Closeable {
         switch (conf.output()) {
             case MIXER:
                 try {
-                    SourceDataLine line = LineHelper.getLineFor(conf, Output.OUTPUT_FORMAT);
-                    line.open(Output.OUTPUT_FORMAT);
-
-                    output = new Output(mixing, line, null, null);
+                    output = new Output(Output.Type.MIXER, mixing, conf, null, null);
                 } catch (LineUnavailableException ex) {
                     throw new IllegalStateException("Failed opening line!", ex);
                 }
@@ -78,10 +74,18 @@ public class PlayerRunner implements Runnable, Closeable {
                 if (pipe == null || !pipe.exists() || !pipe.canWrite())
                     throw new IllegalArgumentException("Invalid pipe file: " + pipe);
 
-                output = new Output(mixing, null, pipe, null);
+                try {
+                    output = new Output(Output.Type.PIPE, mixing, conf, pipe, null);
+                } catch (LineUnavailableException ignored) {
+                    throw new IllegalStateException(); // Cannot be thrown
+                }
                 break;
             case STDOUT:
-                output = new Output(mixing, null, null, System.out);
+                try {
+                    output = new Output(Output.Type.STREAM, mixing, conf, null, System.out);
+                } catch (LineUnavailableException ignored) {
+                    throw new IllegalStateException(); // Cannot be thrown
+                }
                 break;
             default:
                 throw new IllegalArgumentException("Unknown output: " + conf.output());
@@ -93,6 +97,40 @@ public class PlayerRunner implements Runnable, Closeable {
         new Thread(looper = new Looper(), "player-runner-looper-" + looper.hashCode()).start();
     }
 
+    /**
+     * Pauses the mixer and then releases the {@link javax.sound.sampled.Line} if acquired.
+     *
+     * @return Whether the line was released.
+     */
+    public boolean pauseAndRelease() {
+        pauseMixer();
+        while (!paused) {
+            synchronized (pauseLock) {
+                try {
+                    pauseLock.wait(100);
+                } catch (InterruptedException ignored) {
+                }
+            }
+        }
+
+        return output.releaseLine();
+    }
+
+    /**
+     * Stops the mixer and then releases the {@link javax.sound.sampled.Line} if acquired.
+     */
+    public boolean stopAndRelease() {
+        stopMixer();
+        synchronized (pauseLock) {
+            try {
+                pauseLock.wait();
+            } catch (InterruptedException ignored) {
+            }
+        }
+
+        return output.releaseLine();
+    }
+
     private void sendCommand(@NotNull Command command, int id, Object... args) {
         commands.add(new CommandBundle(command, id, args));
     }
@@ -128,7 +166,7 @@ public void run() {
                     int r = count % mixing.getFrameSize();
                     if (r != 0) count += mixing.read(buffer, count, mixing.getFrameSize() - r);
                     output.write(buffer, 0, count);
-                } catch (IOException ex) {
+                } catch (IOException | LineUnavailableException ex) {
                     if (closed) break;
 
                     paused = true;
@@ -222,25 +260,46 @@ public interface Listener {
 
     private static class Output implements Closeable {
         private static final AudioFormat OUTPUT_FORMAT = new AudioFormat(44100, 16, 2, true, false);
-        private final SourceDataLine line;
         private final File pipe;
         private final MixingLine mixing;
+        private final Player.Configuration conf;
+        private final Type type;
+        private SourceDataLine line;
         private OutputStream out;
 
-        @Contract("_, null, null, null -> fail")
-        Output(@NotNull MixingLine mixing, @Nullable SourceDataLine line, @Nullable File pipe, @Nullable OutputStream out) {
-            if (line == null && pipe == null && out == null) throw new IllegalArgumentException();
-
+        Output(@NotNull Type type, @NotNull MixingLine mixing, @NotNull Player.Configuration conf, @Nullable File pipe, @Nullable OutputStream out) throws LineUnavailableException {
+            this.conf = conf;
             this.mixing = mixing;
-            this.line = line;
+            this.type = type;
             this.pipe = pipe;
             this.out = out;
+
+            switch (type) {
+                case MIXER:
+                    acquireLine();
+                    break;
+                case PIPE:
+                    if (pipe == null) throw new IllegalArgumentException();
+                    break;
+                case STREAM:
+                    if (out == null) throw new IllegalArgumentException();
+                    break;
+                default:
+                    throw new IllegalArgumentException(String.valueOf(type));
+            }
         }
 
         private static float calcLogarithmic(int val) {
             return (float) (Math.log10((double) val / VOLUME_MAX) * 20f);
         }
 
+        private void acquireLine() throws LineUnavailableException {
+            if (line != null) return;
+
+            line = LineHelper.getLineFor(conf, Output.OUTPUT_FORMAT);
+            line.open(Output.OUTPUT_FORMAT);
+        }
+
         void stop() {
             if (line != null) line.stop();
         }
@@ -249,13 +308,12 @@ void start() {
             if (line != null) line.start();
         }
 
-        void write(byte[] buffer, int off, int len) throws IOException {
-            if (line != null) {
+        void write(byte[] buffer, int off, int len) throws IOException, LineUnavailableException {
+            if (type == Type.MIXER) {
+                acquireLine();
                 line.write(buffer, off, len);
-            } else {
+            } else if (type == Type.PIPE) {
                 if (out == null) {
-                    if (pipe == null) throw new IllegalStateException();
-
                     if (!pipe.exists()) {
                         try {
                             Process p = new ProcessBuilder().command("mkfifo " + pipe.getAbsolutePath())
@@ -274,6 +332,10 @@ void write(byte[] buffer, int off, int len) throws IOException {
                 }
 
                 out.write(buffer, off, len);
+            } else if (type == Type.STREAM) {
+                out.write(buffer, off, len);
+            } else {
+                throw new IllegalStateException();
             }
         }
 
@@ -306,6 +368,18 @@ void setVolume(int volume) {
             // Cannot set volume through line
             mixing.setGlobalGain(((float) volume) / VOLUME_MAX);
         }
+
+        boolean releaseLine() {
+            if (line == null) return false;
+
+            line.close();
+            line = null;
+            return true;
+        }
+
+        enum Type {
+            MIXER, PIPE, STREAM
+        }
     }
 
     private static class CommandBundle {
@@ -404,6 +478,10 @@ public void run() {
                             firstHandler = null;
                             secondHandler = null;
                             loadedTracks.clear();
+
+                            synchronized (pauseLock) {
+                                pauseLock.notifyAll();
+                            }
                             break;
                         case TerminateMixer:
                             return;

core/src/main/resources/default.toml

@@ -35,4 +35,5 @@ logAvailableMixers = true # Log available mixers
 mixerSearchKeywords = "" # Mixer/backend search keywords (semicolon separated)
 crossfadeDuration = 0 # Crossfade overlap time (in milliseconds)
 output = "MIXER" # Audio output device (MIXER, PIPE, STDOUT)
+releaseLineDelay = 20 # Release mixer line after set delay (in seconds)
 pipe = "" # Output raw (signed) PCM to this file (`player.output` must be PIPE)