Split player backends, add VLC strategy

Extract core player logic and mpg123-bound logic into parent-child
classes so that other player backend strategies can be added. Create a
headless VLC strategy that uses VLC if it's available. Update the pydora
player to prefer VLC if it's available on the system because it supports
a much more broad set of codecs and Pandora is now preferring AAC
formatted files.

3 files changed, 269 insertions, 27 deletions

diff --git a/pandora/py2compat.py b/pandora/py2compat.py
index d83f8c5..fe45462 100644
--- a/pandora/py2compat.py
+++ b/pandora/py2compat.py
@@ -26,3 +26,50 @@ except ImportError:
         from mock import Mock, MagicMock, call, patch  # noqa: F401
     except ImportError:
         pass
+
+
+try:
+    from shutil import which
+except ImportError:
+    import os
+    import sys
+
+    # Copypasta from Python 3.6, exists in 3.3+
+    def which(cmd, mode=os.F_OK | os.X_OK, path=None):
+        def _access_check(fn, mode):
+            return (os.path.exists(fn) and os.access(fn, mode)
+                    and not os.path.isdir(fn))
+
+        if os.path.dirname(cmd):
+            if _access_check(cmd, mode):
+                return cmd
+            return None
+
+        if path is None:
+            path = os.environ.get("PATH", os.defpath)
+        if not path:
+            return None
+        path = path.split(os.pathsep)
+
+        if sys.platform == "win32":
+            if os.curdir not in path:
+                path.insert(0, os.curdir)
+
+            pathext = os.environ.get("PATHEXT", "").split(os.pathsep)
+            if any(cmd.lower().endswith(ext.lower()) for ext in pathext):
+                files = [cmd]
+            else:
+                files = [cmd + ext for ext in pathext]
+        else:
+            files = [cmd]
+
+        seen = set()
+        for dir in path:
+            normdir = os.path.normcase(dir)
+            if normdir not in seen:
+                seen.add(normdir)
+                for thefile in files:
+                    name = os.path.join(dir, thefile)
+                    if _access_check(name, mode):
+                        return name
+        return None
diff --git a/pydora/mpg123.py b/pydora/mpg123.py
index 7077f2b..9599771 100644
--- a/pydora/mpg123.py
+++ b/pydora/mpg123.py
@@ -1,39 +1,109 @@
+import os
+import time
+import fcntl
 import select
 
+from pandora.py2compat import which
 from .utils import iterate_forever, SilentPopen
 
 
-class Player(object):
-    """Remote control for an mpg123 process
+class PlayerException(Exception):
+    """Base class for all player exceptions
+    """
+    pass
+
+
+class UnsupportedEncoding(PlayerException):
+    """Song encoding is not supported by player backend
+    """
+    pass
+
 
-    Starts and owns a handle to an mpg123 process then feeds commands to it to
-    play pandora audio
+class PlayerUnusable(PlayerException):
+    """Player can not be used on this system
+    """
+    pass
+
+
+class BasePlayer(object):
+    """Audio Backend Process Manager
+
+    Starts and owns a handle to an audio backend process then feeds commands to
+    it to play pandora audio. This class provides all the base functionality
+    for managing the process and feeding it input but should be subclassed to
+    fill in the rest of the interface that is specific to a backend.
+
+    Consumers should call start before using the class to pre-start the command
+    and decrease response latency when the first play command is sent.
     """
 
     def __init__(self, callbacks, control_channel):
+        """Constructor
+
+        Will attempt to find the player binary on construction and fail if it
+        is not found. Subclasses should append any additional arguments to
+        _cmd.
+        """
         self._control_channel = control_channel
         self._control_fd = control_channel.fileno()
         self._callbacks = callbacks
         self._process = None
-        self._ensure_started()
+        self._cmd = [self._find_path()]
 
-    def __del__(self):
-        self._process.kill()
+    def _find_path(self):
+        """Find the path to the backend binary
 
-    def _ensure_started(self):
-        """Ensure mpg123 is started
+        This method may fail with a PlayerUnusable exception in which case the
+        consumer should opt for another backend.
         """
-        if self._process and self._process.poll() is None:
-            return
+        raise NotImplementedError
 
-        self._process = SilentPopen(
-            ["mpg123", "-q", "-R", "--ignore-mime", "."])
+    def _load_track(self, song):
+        """Load a track into the audio backend by song model
+        """
+        raise NotImplementedError
 
-        # Only output play status in the player stdout
-        self._send_cmd("silence")
+    def _player_stopped(self, value):
+        """Determine if player has stopped
+        """
+        raise NotImplementedError
+
+    def raise_volume(self):
+        """Raise the volume of the audio output
+
+        The player backend may not support this functionality in which case it
+        should not override this method.
+        """
+        raise NotImplementedError
+
+    def lower_volume(self):
+        """Lower the volume of the audio output
+
+        The player backend may not support this functionality in which case it
+        should not override this method.
+        """
+        raise NotImplementedError
+
+    def _post_start(self):
+        """Optionally, do something after the audio backend is started
+        """
+        return
+
+    def _loop_hook(self):
+        """Optionally, do something each main loop iteration
+        """
+        return
+
+    def _read_from_process(self, handle):
+        """Read a line from the process and clean it
+
+        Different audio backends return text in different formats so provides a
+        hook for each subclass to customize reader behaviour.
+        """
+        return handle.readline().strip()
 
     def _send_cmd(self, cmd):
-        """Write command to remote mpg123 process
+        """Write command to remote process
         """
         self._process.stdin.write("{}\n".format(cmd).encode("utf-8"))
         self._process.stdin.flush()
@@ -48,34 +118,54 @@ class Player(object):
         """
         self._send_cmd("pause")
 
-    def _player_stopped(self, value):
-        """Determine if player has stopped
+    def __del__(self):
+        if self._process:
+            self._process.kill()
+
+    def start(self):
+        """Start the audio backend process for the player
+
+        This is just a friendlier API for consumers
         """
-        return value.startswith(b"@P") and value.decode("utf-8")[3] == "0"
+        self._ensure_started()
+
+    def _ensure_started(self):
+        """Ensure player backing process is started
+        """
+        if self._process and self._process.poll() is None:
+            return
+
+        if not getattr(self, "_cmd"):
+            raise RuntimeError("Player command is not configured")
+
+        self._process = SilentPopen(self._cmd)
+        self._post_start()
 
     def play(self, song):
         """Play a new song from a Pandora model
 
-        Returns once the stream starts but does not shut down the remote mpg123
-        process. Calls the input callback when the user has input.
+        Returns once the stream starts but does not shut down the remote audio
+        output backend process. Calls the input callback when the user has
+        input.
         """
         self._callbacks.play(song)
-        self._send_cmd("load {}".format(song.audio_url))
+        self._load_track(song)
+        time.sleep(2)  # Give the backend time to load the track
 
         while True:
             try:
                 self._callbacks.pre_poll()
                 self._ensure_started()
+                self._loop_hook()
 
                 readers, _, _ = select.select(
                     [self._control_channel, self._process.stdout], [], [], 1)
 
                 for handle in readers:
-                    value = handle.readline().strip()
-
                     if handle.fileno() == self._control_fd:
-                        self._callbacks.input(value, song)
+                        self._callbacks.input(handle.readline().strip(), song)
                     else:
+                        value = self._read_from_process(handle)
                         if self._player_stopped(value):
                             return
             finally:
@@ -98,3 +188,87 @@ class Player(object):
             except StopIteration:
                 self.stop()
                 return
+
+
+class MPG123Player(BasePlayer):
+    """Player Backend Using mpg123
+    """
+
+    def __init__(self, callbacks, control_channel):
+        super(MPG123Player, self).__init__(callbacks, control_channel)
+        self._cmd.extend(["-q", "-R", "--ignore-mime", "."])
+
+    def _find_path(self):
+        loc = which("mpg123")
+        if not loc:
+            raise PlayerUnusable("Unable to find mpg123")
+
+        return loc
+
+    def _load_track(self, song):
+        if song.encoding != "mp3":
+            raise UnsupportedEncoding("mpg123 only supports mp3 files")
+
+        self._send_cmd("load {}".format(song.audio_url))
+
+    def _post_start(self):
+        # Only output play status in the player stdout
+        self._send_cmd("silence")
+
+    def _player_stopped(self, value):
+        return value.startswith(b"@P") and value.decode("utf-8")[3] == "0"
+
+
+class VLCPlayer(BasePlayer):
+
+    POLL_INTERVAL = 3
+    CHUNK_SIZE = 1024
+    VOL_STEPS = 5
+
+    def __init__(self, callbacks, control_channel):
+        super(VLCPlayer, self).__init__(callbacks, control_channel)
+        self._cmd.extend(["-I", "rc", "--advanced", "--rc-fake-tty", "-q"])
+        self._last_poll = 0
+
+    def _find_path(self):
+        loc = which("vlc")
+        if not loc:  # Mac OS X
+            loc = which("VLC", path="/Applications/VLC.app/Contents/MacOS")
+
+        if not loc:
+            raise PlayerUnusable("Unable to find VLC")
+
+        return loc
+
+    def raise_volume(self):
+        self._send_cmd("volup {}".format(self.VOL_STEPS))
+
+    def lower_volume(self):
+        self._send_cmd("voldown {}".format(self.VOL_STEPS))
+
+    def _post_start(self):
+        """Set stdout to non-blocking
+
+        VLC does not always return a newline when reading status so in order to
+        be lazy and still use the read API without caring about how much output
+        there is we switch stdout to nonblocking mode and just read a large
+        chunk of datin order to be lazy and still use the read API without
+        caring about how much output there is we switch stdout to nonblocking
+        mode and just read a large chunk of data.
+        """
+        flags = fcntl.fcntl(self._process.stdout, fcntl.F_GETFL)
+        fcntl.fcntl(self._process.stdout, fcntl.F_SETFL, flags | os.O_NONBLOCK)
+
+    def _read_from_process(self, handle):
+        return handle.read(self.CHUNK_SIZE).strip()
+
+    def _load_track(self, song):
+        self._send_cmd("add {}".format(song.audio_url))
+
+    def _player_stopped(self, value):
+        return "state stopped" in value.decode("utf-8")
+
+    def _loop_hook(self):
+        if (time.time() - self._last_poll) >= self.POLL_INTERVAL:
+            self._send_cmd("status")
+            self._last_poll = time.time()
diff --git a/pydora/player.py b/pydora/player.py
index a6b926d..c56fe21 100755
--- a/pydora/player.py
+++ b/pydora/player.py
@@ -12,8 +12,9 @@ import os
 import sys
 from pandora import clientbuilder
 
-from .mpg123 import Player
 from .utils import Colors, Screen
+from .mpg123 import MPG123Player, VLCPlayer
+from .mpg123 import UnsupportedEncoding, PlayerUnusable
 
 
 class PlayerCallbacks(object):
@@ -61,7 +62,24 @@ class PlayerApp(object):
 
     def __init__(self):
         self.client = None
-        self.player = Player(self, sys.stdin)
+
+    def get_player(self):
+        try:
+            player = VLCPlayer(self, sys.stdin)
+            Screen.print_success("Using VLC")
+            return player
+        except PlayerUnusable:
+            pass
+
+        try:
+            player = MPG123Player(self, sys.stdin)
+            Screen.print_success("Using mpg123")
+            return player
+        except PlayerUnusable:
+            pass
+
+        Screen.print_error("Unable to find a player")
+        sys.exit(1)
 
     def get_client(self):
         cfg_file = os.environ.get("PYDORA_CFG", "")
@@ -184,6 +202,9 @@ class PlayerApp(object):
         Screen.set_echo(True)
 
     def run(self):
+        self.player = self.get_player()
+        self.player.start()
+
         self.client = self.get_client()
         self.stations = self.client.get_station_list()