Support album artwork ('albumart' command) and binary responses

mopidy_mpd/__init__.py

@@ -25,6 +25,7 @@ def get_config_schema(self):
         schema["zeroconf"] = config.String(optional=True)
         schema["command_blacklist"] = config.List(optional=True)
         schema["default_playlist_scheme"] = config.String()
+        schema["albumart_chunk_size"] = config.Integer(minimum=1)
         return schema
 
     def setup(self, registry):

mopidy_mpd/dispatcher.py

@@ -155,7 +155,11 @@ def _add_ok_filter(self, request, response, filter_chain):
         return response
 
     def _has_error(self, response):
-        return response and response[-1].startswith("ACK")
+        return (
+            response
+            and type(response[-1]) is str
+            and response[-1].startswith("ACK")
+        )
 
     # Filter: call handler
 

mopidy_mpd/ext.conf

@@ -8,3 +8,4 @@ connection_timeout = 60
 zeroconf = Mopidy MPD server on $hostname
 command_blacklist = listall,listallinfo
 default_playlist_scheme = m3u
+albumart_chunk_size = 8192

mopidy_mpd/network.py

@@ -509,9 +509,8 @@ def decode(self, line):
 
     def join_lines(self, lines):
         if not lines:
-            return ""
-        line_terminator = self.decode(self.terminator)
-        return line_terminator.join(lines) + line_terminator
+            return b""
+        return self.terminator.join(lines) + self.terminator
 
     def send_lines(self, lines):
         """
@@ -524,7 +523,12 @@ def send_lines(self, lines):
             return
 
         # Remove all control characters (first 32 ASCII characters)
-        lines = [line.translate(CONTROL_CHARS) for line in lines]
+        lines = [
+            self.encode(line.translate(CONTROL_CHARS))
+            if type(line) is str
+            else line
+            for line in lines
+        ]
 
         data = self.join_lines(lines)
-        self.connection.queue_send(self.encode(data))
+        self.connection.queue_send(data)

mopidy_mpd/protocol/__init__.py

@@ -30,6 +30,7 @@ def load_protocol_modules():
     :attr:`commands`.
     """
     from . import (  # noqa
+        album_art,
         audio_output,
         channels,
         command_list,

mopidy_mpd/protocol/album_art.py

@@ -0,0 +1,110 @@
+from mopidy_mpd import protocol
+from urllib.request import urlopen
+from mopidy_mpd.exceptions import MpdNoExistError, MpdArgError
+
+
+def _get_art_url(self, uri):
+    images = self.core.library.get_images([uri]).get()
+    if images[uri]:
+        largest_image = sorted(
+            images[uri], key=lambda i: i.width or 0, reverse=True
+        )[0]
+        return largest_image.uri
+
+
+cover_cache = {}
+
+
+@protocol.commands.add("albumart", offset=protocol.UINT)
+def albumart(context, uri, offset):
+    """
+    *musicpd.org, the music database section:*
+
+        ``albumart {URI} {OFFSET}``
+
+        Locate album art for the given song and return a chunk
+        of an album art image file at offset OFFSET.
+
+        This is currently implemented by searching the directory
+        the file resides in for a file called cover.png, cover.jpg,
+        cover.tiff or cover.bmp.
+
+        Returns the file size and actual number of bytes read at
+        the requested offset, followed by the chunk requested as
+        raw bytes (see Binary Responses), then a newline and the completion code.
+
+        Example::
+
+            albumart foo/bar.ogg 0
+            size: 1024768
+            binary: 8192
+            <8192 bytes>
+            OK
+
+    .. versionadded:: 0.21
+        New in MPD protocol version 0.21
+    """
+    global cover_cache
+
+    if uri not in cover_cache:
+        art_url = _get_art_url(context, uri)
+
+        if art_url is None:
+            raise MpdNoExistError("No art file exists")
+
+        cover_cache[uri] = urlopen(art_url).read()
+
+    data = cover_cache[uri]
+
+    total_size = len(data)
+    chunk_size = context.dispatcher.config["mpd"]["albumart_chunk_size"]
+
+    if offset > total_size:
+        return MpdArgError("Bad file offset")
+
+    size = min(chunk_size, total_size - offset)
+
+    if offset + size >= total_size:
+        cover_cache.pop(uri)
+
+    return b"size: %d\nbinary: %d\n%b" % (
+        total_size,
+        size,
+        data[offset : offset + size],
+    )
+
+
+# @protocol.commands.add("readpicture", offset=protocol.UINT) # not yet implemented
+def readpicture(context, uri, offset):
+    """
+    *musicpd.org, the music database section:*
+
+        ``readpicture {URI} {OFFSET}``
+
+        Locate a picture for the given song and return a chunk
+        of the image file at offset OFFSET. This is usually
+        implemented by reading embedded pictures from
+        binary tags (e.g. ID3v2's APIC tag).
+
+        Returns the following values:
+
+        * size: the total file size
+        * type: the file's MIME type (optional)
+        * binary: see Binary Responses
+
+        If the song file was recognized, but there is no picture,
+        the response is successful, but is otherwise empty.
+
+        Example::
+
+            readpicture foo/bar.ogg 0
+            size: 1024768
+            type: image/jpeg
+            binary: 8192
+            <8192 bytes>
+            OK
+
+    .. versionadded:: 0.21
+        New in MPD protocol version 0.21
+    """
+    # raise exceptions.MpdNotImplemented  # TODO

mopidy_mpd/session.py

@@ -45,7 +45,11 @@ def on_line_received(self, line):
         logger.debug(
             "Response to %s: %s",
             self.connection,
-            formatting.indent(self.decode(self.terminator).join(response)),
+            formatting.indent(
+                self.decode(self.terminator).join(
+                    [str(line) for line in response]
+                )
+            ),
         )
 
         self.send_lines(response)

tests/network/test_lineprotocol.py

@@ -211,32 +211,36 @@ def test_send_lines_calls_join_lines(self):
         self.mock.connection = Mock(spec=network.Connection)
         self.mock.join_lines.return_value = "lines"
 
-        network.LineProtocol.send_lines(self.mock, ["line 1", "line 2"])
-        self.mock.join_lines.assert_called_once_with(["line 1", "line 2"])
+        network.LineProtocol.send_lines(
+            self.mock, ["line 1".encode(), "line 2".encode()]
+        )
+        self.mock.join_lines.assert_called_once_with(
+            ["line 1".encode(), "line 2".encode()]
+        )
 
     def test_send_line_encodes_joined_lines_with_final_terminator(self):
         self.mock.connection = Mock(spec=network.Connection)
-        self.mock.join_lines.return_value = "lines\n"
 
-        network.LineProtocol.send_lines(self.mock, ["line 1", "line 2"])
-        self.mock.encode.assert_called_once_with("lines\n")
+        network.LineProtocol.send_lines(self.mock, ["line 1"])
+        self.mock.encode.assert_called_once_with("line 1")
 
     def test_send_lines_sends_encoded_string(self):
         self.mock.connection = Mock(spec=network.Connection)
-        self.mock.join_lines.return_value = "lines"
+        self.mock.join_lines.return_value = sentinel.data
         self.mock.encode.return_value = sentinel.data
 
         network.LineProtocol.send_lines(self.mock, ["line 1", "line 2"])
         self.mock.connection.queue_send.assert_called_once_with(sentinel.data)
 
     def test_join_lines_returns_empty_string_for_no_lines(self):
-        assert "" == network.LineProtocol.join_lines(self.mock, [])
+        assert b"" == network.LineProtocol.join_lines(self.mock, [])
 
     def test_join_lines_returns_joined_lines(self):
         self.mock.decode.return_value = "\n"
-        assert "1\n2\n" == network.LineProtocol.join_lines(
-            self.mock, ["1", "2"]
+        result = network.LineProtocol.join_lines(
+            self.mock, ["1".encode(), "2".encode()]
         )
+        assert "1\n2\n".encode() == result
 
     def test_decode_calls_decode_on_string(self):
         string = Mock()

tests/protocol/__init__.py

@@ -28,7 +28,11 @@ class BaseTestCase(unittest.TestCase):
     def get_config(self):
         return {
             "core": {"max_tracklist_length": 10000},
-            "mpd": {"password": None, "default_playlist_scheme": "dummy"},
+            "mpd": {
+                "password": None,
+                "default_playlist_scheme": "dummy",
+                "albumart_chunk_size": 8192,
+            },
         }
 
     def setUp(self):  # noqa: N802

tests/protocol/test_albumart.py

@@ -0,0 +1,53 @@
+from io import BytesIO
+from mopidy_mpd.protocol import album_art
+from unittest import mock
+from mopidy.models import Album, Track, Image
+
+from tests import protocol
+
+
+def mock_get_images(self, uris):
+    result = {}
+    for uri in uris:
+        result[uri] = [Image(uri="dummy:/albumart.jpg", width=128, height=128)]
+    return result
+
+
+class AlbumArtTest(protocol.BaseTestCase):
+    def test_albumart_for_track_without_art(self):
+        track = Track(
+            uri="dummy:/à",
+            name="a nàme",
+            album=Album(uri="something:àlbum:12345"),
+        )
+        self.backend.library.dummy_library = [track]
+        self.core.tracklist.add(uris=[track.uri]).get()
+
+        self.core.playback.play().get()
+
+        self.send_request("albumart file:///home/test/music.flac 0")
+        self.assertInResponse("ACK [50@0] {albumart} No art file exists")
+
+    @mock.patch.object(
+        protocol.core.library.LibraryController, "get_images", mock_get_images
+    )
+    def test_albumart(self):
+        track = Track(
+            uri="dummy:/à",
+            name="a nàme",
+            album=Album(uri="something:àlbum:12345"),
+        )
+        self.backend.library.dummy_library = [track]
+        self.core.tracklist.add(uris=[track.uri]).get()
+
+        self.core.playback.play().get()
+
+        ##
+        expected = b"result"
+
+        with mock.patch.object(
+            album_art, "urlopen", return_value=BytesIO(expected)
+        ):
+            self.send_request("albumart file:///home/test/music.flac 0")
+
+        self.assertInResponse("binary: " + str(len(expected)))

tests/test_extension.py

@@ -23,3 +23,4 @@ def test_get_config_schema():
     assert "zeroconf" in schema
     assert "command_blacklist" in schema
     assert "default_playlist_scheme" in schema
+    assert "albumart_chunk_size" in schema