v0.57.0: repeat button; AirPlay compatibility handshake for third-party speakers

- Transport: a repeat button (off / all / one) between shuffle and the
  visualizer. Repeat-all wraps the walk (a shuffled one is reshuffled per
  lap); repeat-one replays a song that finishes, Next/Previous still move.
  BPM button and the now-playing minimum shrink to make room.
- Clicking the streaming tile to stop casting/AirPlay no longer also opens
  the big visualizer (the release after the stop counted as a click).
- AirPlay: pyatv's AirPlay 2 session is silent on a WiiM, and its AirPlay 1
  pairs then talks plaintext, which the WiiM hangs up on. Non-Apple
  speakers now get cliraop's handshake: auth-setup, no pairing, ALAC
  (uncompressed frames). airplay_protocol "2" keeps pyatv's AirPlay 2.
This commit is contained in:
2026-10-15 18:01:20 -07:00
parent c2a566bf57
commit bdeacd9793
11 changed files with 545 additions and 31 deletions
+21 -5
View File
@@ -169,6 +169,12 @@ persistence) → GUI (Qt widgets that read the manager and connect to its signal
implementation. `set_sink()` carries the current track, position and implementation. `set_sink()` carries the current track, position and
playing-state across a swap and deliberately does *not* re-emit playing-state across a swap and deliberately does *not* re-emit
`track_changed` (that would double-scrobble the same song). `track_changed` (that would double-scrobble the same song).
**Repeat** (Round 88, the transport's button, off → all → one) lives in
`Player`: repeat-all wraps `_step_index` both ways (a shuffled walk is
reshuffled for each lap, never starting with the song that ended the last),
repeat-one replays only a song that *finished* (`_after_finish`) — Next and
Previous still move — and `_load_current`'s unplayable-skip loop gives up
after one lap, since a wrapping walk would otherwise never end.
Player is also deliberately **context-agnostic**: playback *context* Player is also deliberately **context-agnostic**: playback *context*
("library" / "playlist:<pid>") is tracked in `MainWindow`, not the player. ("library" / "playlist:<pid>") is tracked in `MainWindow`, not the player.
@@ -839,11 +845,21 @@ persistence) → GUI (Qt widgets that read the manager and connect to its signal
tile shows the sink's `glyph`. Testing streams against **pyatv's own fake tile shows the sink's `glyph`. Testing streams against **pyatv's own fake
receiver** (`tests/fake_device/raop.py` in its sdist, bound to 127.0.0.1) — receiver** (`tests/fake_device/raop.py` in its sdist, bound to 127.0.0.1) —
never a real speaker unless trav says so. never a real speaker unless trav says so.
pyatv picks AirPlay **2** for any receiver advertising its features (the **pyatv's own handshakes play nothing on a WiiM** (Round 88): its AirPlay 2
WiiM does) and the fake only exercises v1, so `config.json` takes session (picked for any receiver advertising AirPlay 2 features) gets 200
`airplay_protocol` ("auto"/"1"/"2") and `airplay_debug` (pyatv's logger OK for everything, timing included, and stays silent; its AirPlay 1 runs a
at DEBUG); every stream's start, first audio and outcome are logged at transient pairing and then sends the ANNOUNCE unencrypted, and the WiiM
INFO under `lintunes.airplay`, and the chosen protocol in the control log. hangs up. Third-party speakers take what cliraop/owntones send, so
`stream.install_shim` also hooks pyatv for hosts marked by `set_compat`:
auth-setup whatever the model, no pairing, and ALAC — `AppleLossless` in
the SDP, each packet an uncompressed ALAC frame (`support.alac_verbatim`,
byte-identical to ffmpeg's encoder on incompressible input). The handshake
was verified silently (all-zero audio) against tiat.place. `use_compat`:
config.json's `airplay_protocol` "auto" = compat for everything but
Apple's own hardware (a HomePod is AirPlay 2 only), "1" = compat
everywhere, "2" = pyatv's AirPlay 2. `airplay_debug` puts pyatv's logger at
DEBUG; every stream's start, first audio and outcome are logged at INFO
under `lintunes.airplay`, and the chosen protocol in the control log.
## Conventions & gotchas ## Conventions & gotchas
+1 -1
View File
@@ -1,3 +1,3 @@
"""LinTunes — iTunes-style music library manager and player for Linux.""" """LinTunes — iTunes-style music library manager and player for Linux."""
__version__ = "0.56.1" __version__ = "0.57.0"
+12 -5
View File
@@ -12,7 +12,7 @@ from PyQt6.QtCore import QObject, QTimer, pyqtSignal
from lintunes.airplay.discovery import AirPlayDiscovery from lintunes.airplay.discovery import AirPlayDiscovery
from lintunes.airplay.loop import AsyncLoop from lintunes.airplay.loop import AsyncLoop
from lintunes.airplay.support import is_available, protocol_choice from lintunes.airplay.support import is_available, protocol_choice, use_compat
from lintunes.config import load_config from lintunes.config import load_config
from lintunes.eventlog import log_control from lintunes.eventlog import log_control
from lintunes.inhibit import INHIBIT_LOGOUT, INHIBIT_SUSPEND, SleepInhibitor from lintunes.inhibit import INHIBIT_LOGOUT, INHIBIT_SUSPEND, SleepInhibitor
@@ -114,15 +114,22 @@ class AirPlayController(QObject):
logging.getLogger("pyatv").setLevel(logging.DEBUG) logging.getLogger("pyatv").setLevel(logging.DEBUG)
storage = MemoryStorage() storage = MemoryStorage()
settings = await storage.get_settings(conf) settings = await storage.get_settings(conf)
settings.protocols.raop.protocol_version = {
"1": AirPlayVersion.V1, "2": AirPlayVersion.V2,
}.get(choice, AirPlayVersion.Auto)
raop = conf.get_service(Protocol.RAOP) raop = conf.get_service(Protocol.RAOP)
model = raop.properties.get("am", "") if raop is not None else ""
compat = use_compat(choice, model)
from lintunes.airplay.stream import install_shim, set_compat
install_shim()
set_compat(str(conf.address), compat)
settings.protocols.raop.protocol_version = (
AirPlayVersion.V1 if compat
else {"2": AirPlayVersion.V2}.get(choice, AirPlayVersion.Auto))
if raop is not None: if raop is not None:
used = get_protocol_version( used = get_protocol_version(
raop, settings.protocols.raop.protocol_version) raop, settings.protocols.raop.protocol_version)
log_control("airplay", "protocol", log_control("airplay", "protocol",
f"{device.name}: {used.name} (airplay_protocol={choice})") f"{device.name} ({model}): {used.name}"
f"{' compat' if compat else ''} "
f"(airplay_protocol={choice})")
return await asyncio.wait_for( return await asyncio.wait_for(
pyatv.connect(raop_only(conf), loop, storage=storage), pyatv.connect(raop_only(conf), loop, storage=storage),
CONNECT_TIMEOUT_S) CONNECT_TIMEOUT_S)
+91 -1
View File
@@ -10,12 +10,18 @@ pyatv's own code.
A `PcmRequest` is also how the GUI thread watches the stream: the source counts A `PcmRequest` is also how the GUI thread watches the stream: the source counts
frames into it, and the sink turns that count into a position. frames into it, and the sink turns that count into a position.
`install_shim` also hooks pyatv's AirPlay 1 for the *compatibility* handshake
(`support.use_compat`), but only for hosts `set_compat` named: auth-setup
even though the receiver isn't an AirPort, no transient pairing (a WiiM drops
the connection when the ANNOUNCE after it arrives unencrypted), and ALAC
instead of L16 — uncompressed frames, what cliraop sends.
""" """
import asyncio import asyncio
import time import time
from lintunes.airplay.support import ffmpeg_command from lintunes.airplay.support import alac_verbatim, ffmpeg_command
class PcmRequest: class PcmRequest:
@@ -145,6 +151,89 @@ def _ffmpeg_source():
return FfmpegSource return FfmpegSource
_compat_hosts: set[str] = set()
def set_compat(host: str, on: bool):
"""Stream to `host` with the compatibility handshake, or pyatv's own."""
if on:
_compat_hosts.add(host)
else:
_compat_hosts.discard(host)
def _is_compat(connection) -> bool:
return getattr(connection, "remote_ip", None) in _compat_hosts
class _NoPairing:
"""pair_verify's stand-in for a compat host: verifies nothing."""
def __init__(self, credentials, connection):
pass
async def verify_credentials(self) -> bool:
return False
_COMPAT_ANNOUNCE = (
"v=0\r\n"
"o=iTunes {session_id} 0 IN IP4 {local_ip}\r\n"
"s=iTunes\r\n"
"c=IN IP4 {remote_ip}\r\n"
"t=0 0\r\n"
"m=audio 0 RTP/AVP 96\r\n"
"a=rtpmap:96 AppleLossless\r\n"
"a=fmtp:96 {frames} 0 16 40 10 14 2 255 0 0 {sample_rate}\r\n"
)
def _alac_ok(context) -> bool:
return context.bytes_per_channel == 2 and context.channels == 2
def _install_compat():
from pyatv.protocols.raop import stream_client
from pyatv.protocols.raop.protocols import airplayv1
from pyatv.support import rtsp
real_pair = airplayv1.pair_verify
airplayv1.pair_verify = lambda credentials, connection: (
_NoPairing if _is_compat(connection) else real_pair)(
credentials, connection)
real_auth = stream_client.StreamClient._requires_auth_setup
stream_client.StreamClient._requires_auth_setup = property(
lambda self: _is_compat(self.rtsp.connection)
or real_auth.fget(self))
real_announce = rtsp.RtspSession.announce
async def announce(self, bytes_per_channel, channels, sample_rate,
password):
if (not _is_compat(self.connection) or password is not None
or bytes_per_channel != 2 or channels != 2):
return await real_announce(self, bytes_per_channel, channels,
sample_rate, password)
body = _COMPAT_ANNOUNCE.format(
session_id=self.session_id, local_ip=self.connection.local_ip,
remote_ip=self.connection.remote_ip,
frames=rtsp.FRAMES_PER_PACKET, sample_rate=sample_rate)
return await self.exchange("ANNOUNCE", content_type="application/sdp",
body=body)
rtsp.RtspSession.announce = announce
real_send = airplayv1.AirPlayV1.send_audio_packet
async def send_audio_packet(self, transport, rtp_header, audio):
if _is_compat(self.rtsp.connection) and _alac_ok(self.context):
audio = alac_verbatim(audio)
return await real_send(self, transport, rtp_header, audio)
airplayv1.AirPlayV1.send_audio_packet = send_audio_packet
def install_shim(): def install_shim():
"""Route a PcmRequest through `stream_file` to an FfmpegSource. """Route a PcmRequest through `stream_file` to an FfmpegSource.
@@ -164,3 +253,4 @@ def install_shim():
open_source._lintunes = True open_source._lintunes = True
raop.open_source = open_source raop.open_source = open_source
_install_compat()
+45 -3
View File
@@ -111,13 +111,55 @@ def heard_ms(start_ms: int, frames_read: int, elapsed_ms: float | None,
def protocol_choice(value) -> str: def protocol_choice(value) -> str:
"""config.json's `airplay_protocol`: "auto" (pyatv picks from the """config.json's `airplay_protocol`: "auto", "1" or "2". Machine-local on
device's features), "1" or "2". Machine-local on purpose — it's about purpose — it's about which speakers this machine meets — and anything
which speakers this machine meets — and anything unrecognized is auto.""" unrecognized is auto."""
value = str(value or "auto").strip().lower().lstrip("v") value = str(value or "auto").strip().lower().lstrip("v")
return value if value in ("1", "2") else "auto" return value if value in ("1", "2") else "auto"
# RAOP `am` (model) prefixes of Apple's own receivers. A HomePod takes only
# AirPlay 2, so Apple hardware keeps pyatv's own choice.
_APPLE_MODELS = ("AudioAccessory", "AppleTV", "AirPort", "Mac", "iMac")
def use_compat(choice: str, model: str) -> bool:
"""Stream with the AirPlay 1 compatibility handshake (stream.py)?
pyatv picks AirPlay 2 for any receiver advertising its features, and a
WiiM (Linkplay) takes that whole session — RECORD, volume, timing — and
plays nothing; its own AirPlay 1 refuses pyatv's transient pairing. What
third-party speakers accept is the handshake cliraop/owntones send:
auth-setup, no pairing, ALAC. So "auto" means that for everything that
isn't Apple's, "1" means it everywhere, and "2" is pyatv's AirPlay 2.
"""
if choice == "1":
return True
if choice == "2":
return False
return not (model or "").startswith(_APPLE_MODELS)
_ALAC_HEAD = None
def alac_verbatim(pcm: bytes) -> bytes:
"""16-bit stereo big-endian PCM as one uncompressed ALAC frame.
ALAC's escape: a channel-pair element flagged "not compressed" carries
the samples as-is, so there's nothing to encode — a 23-bit header
(0x20 0x00 0x02 less its last bit), the samples, the 3-bit end tag, zero
padding. Byte-identical to ffmpeg's encoder on incompressible input.
"""
import numpy as np
global _ALAC_HEAD
if _ALAC_HEAD is None:
_ALAC_HEAD = np.unpackbits(np.frombuffer(b"\x20\x00\x02", np.uint8))[:23]
bits = np.unpackbits(np.frombuffer(pcm, np.uint8))
return np.packbits(np.concatenate(
[_ALAC_HEAD, bits, np.ones(3, np.uint8)])).tobytes()
_SAMPLE_FORMATS = {2: "s16be", 4: "s32be"} _SAMPLE_FORMATS = {2: "s16be", 4: "s32be"}
+39 -1
View File
@@ -2,7 +2,8 @@
so buttons can flash the theme highlight while pressed.""" so buttons can flash the theme highlight while pressed."""
from PyQt6.QtCore import Qt, QPointF, QRectF from PyQt6.QtCore import Qt, QPointF, QRectF
from PyQt6.QtGui import QIcon, QPixmap, QPainter, QPen, QColor, QPolygonF from PyQt6.QtGui import (QIcon, QPixmap, QPainter, QPainterPath, QPen, QColor,
QPolygonF)
_cache: dict[tuple, QIcon] = {} _cache: dict[tuple, QIcon] = {}
@@ -74,6 +75,41 @@ def _shuffle(p, color):
p.drawPolygon(QPolygonF([QPointF(15, 11), QPointF(19, 14), QPointF(15, 17)])) p.drawPolygon(QPolygonF([QPointF(15, 11), QPointF(19, 14), QPointF(15, 17)]))
def _repeat(p, color):
"""iTunes' repeat: a loop of two strands with rounded far corners, the
top one arrowed to the right, the bottom one back to the left."""
pen = QPen(color, 1.8)
pen.setCapStyle(Qt.PenCapStyle.RoundCap)
p.setPen(pen)
p.setBrush(Qt.BrushStyle.NoBrush)
top = QPainterPath(QPointF(3, 11.5))
top.lineTo(3, 9)
top.quadTo(3, 6, 6, 6)
top.lineTo(14, 6)
bottom = QPainterPath(QPointF(17, 8.5))
bottom.lineTo(17, 11)
bottom.quadTo(17, 14, 14, 14)
bottom.lineTo(6, 14)
p.drawPath(top)
p.drawPath(bottom)
p.setPen(Qt.PenStyle.NoPen)
p.setBrush(color)
p.drawPolygon(QPolygonF([QPointF(13.5, 2.8), QPointF(18, 6), QPointF(13.5, 9.2)]))
p.drawPolygon(QPolygonF([QPointF(6.5, 10.8), QPointF(2, 14), QPointF(6.5, 17.2)]))
def _repeat_one(p, color):
"""Repeat with a "1" inside the loop."""
_repeat(p, color)
pen = QPen(color, 1.9)
pen.setCapStyle(Qt.PenCapStyle.FlatCap)
pen.setJoinStyle(Qt.PenJoinStyle.MiterJoin)
p.setPen(pen)
p.setBrush(Qt.BrushStyle.NoBrush)
p.drawPolyline(QPolygonF([QPointF(8.6, 8.9), QPointF(10.6, 7.4),
QPointF(10.6, 12.6)]))
def _cast(p, color): def _cast(p, color):
"""The standard cast glyph: a screen with signal arcs at its lower left. """The standard cast glyph: a screen with signal arcs at its lower left.
The screen is lit rather than empty — it is only ever drawn while a device The screen is lit rather than empty — it is only ever drawn while a device
@@ -127,6 +163,8 @@ _DRAWERS = {
"next": _next, "next": _next,
"previous": _previous, "previous": _previous,
"shuffle": _shuffle, "shuffle": _shuffle,
"repeat": _repeat,
"repeat_one": _repeat_one,
"cast": _cast, "cast": _cast,
"airplay": _airplay, "airplay": _airplay,
} }
+36 -4
View File
@@ -11,6 +11,7 @@ from lintunes.tap_tempo import TapTempo
from lintunes.gui.icons import transport_icon from lintunes.gui.icons import transport_icon
from lintunes.gui.track_table import format_time from lintunes.gui.track_table import format_time
from lintunes.gui.visualizer import VisualizerWidget from lintunes.gui.visualizer import VisualizerWidget
from lintunes.player import REPEAT_MODES
from lintunes import theme from lintunes import theme
@@ -24,7 +25,7 @@ ROW_GAP = 4
# each pair and after the last, always. The now-playing panel (and the seek # each pair and after the last, always. The now-playing panel (and the seek
# row under it) takes all the width that's left. # row under it) takes all the width that's left.
GAP = 16 GAP = 16
NOW_PLAYING_MIN = 180 NOW_PLAYING_MIN = 150
# Shared height for the boxed side controls (transport, shuffle, bpm) and the # Shared height for the boxed side controls (transport, shuffle, bpm) and the
# visualizer, so they line up. ~midway between their old heights: the stretchy # visualizer, so they line up. ~midway between their old heights: the stretchy
@@ -210,7 +211,7 @@ class BpmButton(QPushButton):
self._manager = manager self._manager = manager
self._tempo = TapTempo() self._tempo = TapTempo()
self._target_track_id: int | None = None self._target_track_id: int | None = None
self.setFixedWidth(74) # + the box's 3 px margins = its old footprint self.setFixedWidth(52) # shuffle and repeat's width: "bpm" or 3 digits
self.setFlat(True) # flat text inside its box, like the transport icons self.setFlat(True) # flat text inside its box, like the transport icons
self.setFocusPolicy(Qt.FocusPolicy.NoFocus) self.setFocusPolicy(Qt.FocusPolicy.NoFocus)
self.setEnabled(False) self.setEnabled(False)
@@ -415,6 +416,19 @@ class TransportBar(QWidget):
layout.addWidget(shuffle_box, alignment=TOP) layout.addWidget(shuffle_box, alignment=TOP)
gap() gap()
# Repeat cycles off → all → one, like iTunes': lit while on, with a
# "1" in the loop for one.
self._repeat_btn = FlashButton("repeat")
self._repeat_btn.setMinimumWidth(50)
self._repeat_btn.setCheckable(True)
self._repeat_btn.clicked.connect(self._cycle_repeat)
repeat_box = _box(self._repeat_btn, bg=box_bg, margins=(3, 3, 3, 3),
height=CONTROL_HEIGHT, split=True)
self._boxes.append(repeat_box)
layout.addWidget(repeat_box, alignment=TOP)
self._show_repeat(player.repeat_mode())
gap()
self._visualizer = VisualizerWidget(player, prefs) self._visualizer = VisualizerWidget(player, prefs)
self._visualizer.setFixedHeight(CONTROL_HEIGHT) self._visualizer.setFixedHeight(CONTROL_HEIGHT)
layout.addWidget(self._visualizer, alignment=TOP) layout.addWidget(self._visualizer, alignment=TOP)
@@ -517,7 +531,8 @@ class TransportBar(QWidget):
hug=True, height=CONTROL_HEIGHT, split=True) hug=True, height=CONTROL_HEIGHT, split=True)
self._boxes.append(bpm_box) self._boxes.append(bpm_box)
layout.addWidget(bpm_box, alignment=TOP) layout.addWidget(bpm_box, alignment=TOP)
self._fixed_controls = (transport_box, shuffle_box, self._visualizer, self._fixed_controls = (transport_box, shuffle_box, repeat_box,
self._visualizer,
self._volume_slider, bpm_box) self._volume_slider, bpm_box)
# Library button · the current view's header · seek row. MainWindow # Library button · the current view's header · seek row. MainWindow
@@ -550,6 +565,23 @@ class TransportBar(QWidget):
lambda: (cast.disconnect(), lambda: (cast.disconnect(),
airplay is not None and airplay.disconnect())) airplay is not None and airplay.disconnect()))
# ---- repeat ----
_REPEAT_TIPS = {"off": "Repeat: off", "all": "Repeat: all",
"one": "Repeat: this song"}
def _cycle_repeat(self):
modes = REPEAT_MODES
mode = modes[(modes.index(self._player.repeat_mode()) + 1) % len(modes)]
self._player.set_repeat(mode)
self._show_repeat(mode)
def _show_repeat(self, mode: str):
# The click already toggled the check; the mode decides it.
self._repeat_btn.setChecked(mode != "off")
self._repeat_btn.set_kind("repeat_one" if mode == "one" else "repeat")
self._repeat_btn.setToolTip(self._REPEAT_TIPS[mode])
# ---- the header row ---- # ---- the header row ----
def set_sidebar_header(self, widget: QWidget): def set_sidebar_header(self, widget: QWidget):
@@ -634,7 +666,7 @@ class TransportBar(QWidget):
color), the tunable grayscale button boxes, and the now-playing panel color), the tunable grayscale button boxes, and the now-playing panel
background + text color.""" background + text color."""
for button in (self._prev_btn, self._play_btn, self._next_btn, for button in (self._prev_btn, self._play_btn, self._next_btn,
self._shuffle_btn): self._shuffle_btn, self._repeat_btn):
button.refresh_icons() button.refresh_icons()
box_bg = theme.gray(theme.gray_value(self._prefs, "color_button")) box_bg = theme.gray(theme.gray_value(self._prefs, "color_button"))
for box in self._boxes: for box in self._boxes:
+9 -1
View File
@@ -92,6 +92,7 @@ class VisualizerWidget(QWidget):
# True while audio is coming out of something other than this machine # True while audio is coming out of something other than this machine
# (a Chromecast), so there is no decoded PCM to draw. # (a Chromecast), so there is no decoded PCM to draw.
self._no_pcm = False self._no_pcm = False
self._swallow_release = False
self._device = "" self._device = ""
self._glyph = "cast" self._glyph = "cast"
@@ -357,12 +358,19 @@ class VisualizerWidget(QWidget):
def mousePressEvent(self, event): def mousePressEvent(self, event):
if self._no_pcm: if self._no_pcm:
# While casting the panel is the cast indicator, not a picture: # While casting the panel is the cast indicator, not a picture:
# a click stops casting instead. # a click stops casting instead. Stopping swaps the sink back
# before the release arrives, so that release belongs to this
# press and must not open the big window.
self._swallow_release = True
self.cast_stop_requested.emit() self.cast_stop_requested.emit()
return return
self._swallow_release = False
event.accept() # acted on at release, like a button event.accept() # acted on at release, like a button
def mouseReleaseEvent(self, event): def mouseReleaseEvent(self, event):
if self._swallow_release:
self._swallow_release = False
return
if self._no_pcm or event.button() != Qt.MouseButton.LeftButton: if self._no_pcm or event.button() != Qt.MouseButton.LeftButton:
return return
if not self.rect().contains(event.position().toPoint()): if not self.rect().contains(event.position().toPoint()):
+45 -5
View File
@@ -16,6 +16,10 @@ from lintunes.storage import listen_history
# Hitting "previous" more than this far into a song restarts it instead # Hitting "previous" more than this far into a song restarts it instead
RESTART_THRESHOLD_MS = 3000 RESTART_THRESHOLD_MS = 3000
# Repeat modes, in the order the transport button cycles them (iTunes').
REPEAT_OFF, REPEAT_ALL, REPEAT_ONE = "off", "all", "one"
REPEAT_MODES = (REPEAT_OFF, REPEAT_ALL, REPEAT_ONE)
# Resuming after a pause at least this long does a seek-in-place first: when # Resuming after a pause at least this long does a seek-in-place first: when
# the machine sits idle, the OS suspends the audio sink and it can come back # the machine sits idle, the OS suspends the audio sink and it can come back
# silently dead — decoding continues (the visualizer moves) but nothing is # silently dead — decoding continues (the visualizer moves) but nothing is
@@ -471,6 +475,7 @@ class Player(QObject):
self._current_track: Track | None = None self._current_track: Track | None = None
self._shuffle = False self._shuffle = False
self._shuffle_order: list[int] = [] self._shuffle_order: list[int] = []
self._repeat = REPEAT_OFF
# Custom stop time (ms) for the loaded track: end it early. Enforced # Custom stop time (ms) for the loaded track: end it early. Enforced
# here rather than in a sink so both playback paths honor it. # here rather than in a sink so both playback paths honor it.
self._stop_at_ms = 0 self._stop_at_ms = 0
@@ -635,13 +640,29 @@ class Player(QObject):
else: else:
self._shuffle_order = [] self._shuffle_order = []
# ---- repeat ----
def repeat_mode(self) -> str:
return self._repeat
def set_repeat(self, mode: str):
"""REPEAT_OFF, REPEAT_ALL (the queue wraps around) or REPEAT_ONE (a
song that *finishes* plays again; Next and Previous still move)."""
self._repeat = mode if mode in REPEAT_MODES else REPEAT_OFF
log_control("player", "repeat", self._repeat)
def _step_index(self, delta: int) -> int | None: def _step_index(self, delta: int) -> int | None:
"""Queue index `delta` steps away in the active walking order.""" """Queue index `delta` steps away in the active walking order. Off
either end is None, unless repeating all: then the walk wraps — and a
shuffled one is reshuffled for its next lap, like iTunes."""
if not self._queue: if not self._queue:
return None return None
wrap = self._repeat == REPEAT_ALL
if not self._shuffle: if not self._shuffle:
candidate = self._index + delta candidate = self._index + delta
return candidate if 0 <= candidate < len(self._queue) else None if 0 <= candidate < len(self._queue):
return candidate
return candidate % len(self._queue) if wrap else None
try: try:
pos = self._shuffle_order.index(self._index) pos = self._shuffle_order.index(self._index)
except ValueError: except ValueError:
@@ -649,7 +670,15 @@ class Player(QObject):
pos += delta pos += delta
if 0 <= pos < len(self._shuffle_order): if 0 <= pos < len(self._shuffle_order):
return self._shuffle_order[pos] return self._shuffle_order[pos]
if not wrap:
return None return None
if pos < 0:
return self._shuffle_order[-1]
# A new lap, never starting with the song that just ended it.
others = [i for i in range(len(self._queue)) if i != self._index]
first = random.choice(others) if others else self._index
self._shuffle_order = make_shuffle_order(len(self._queue), first)
return first
# ---- state ---- # ---- state ----
@@ -844,6 +873,7 @@ class Player(QObject):
sink can't decode (a Chromecast can't play ALAC, AIFF or protected sink can't decode (a Chromecast can't play ALAC, AIFF or protected
AAC). The skip is a loop, not recursion: shuffling into a run of AAC). The skip is a loop, not recursion: shuffling into a run of
unsupported tracks must not walk the stack down.""" unsupported tracks must not walk the stack down."""
skipped = 0
while 0 <= self._index < len(self._queue): while 0 <= self._index < len(self._queue):
key = self._queue[self._index] key = self._queue[self._index]
track = self._resolve(key) track = self._resolve(key)
@@ -871,7 +901,10 @@ class Player(QObject):
self.track_unplayable.emit( self.track_unplayable.emit(
track, self._sink.unplayable_reason(track)) track, self._sink.unplayable_reason(track))
next_index = self._step_index(1) next_index = self._step_index(1)
if next_index is None: skipped += 1
# Repeat-all wraps, so a queue of nothing playable would
# go round forever.
if next_index is None or skipped >= len(self._queue):
self.stop() self.stop()
return return
self._index = next_index self._index = next_index
@@ -913,7 +946,14 @@ class Player(QObject):
def _on_sink_ended(self): def _on_sink_ended(self):
"""The active sink played the track to its natural end.""" """The active sink played the track to its natural end."""
self._note_finished(self._current_track) self._note_finished(self._current_track)
# Playback has already stopped at the end, so force autoplay. self._after_finish()
def _after_finish(self):
"""A song ended by itself: the same one again, or the next. Playback
has already stopped at the end, so autoplay either way."""
if self._repeat == REPEAT_ONE and self._current_track is not None:
self._load_current(autoplay=True)
else:
self._advance(autoplay=True) self._advance(autoplay=True)
def _on_sink_error(self, message: str): def _on_sink_error(self, message: str):
@@ -936,7 +976,7 @@ class Player(QObject):
self._stop_at_ms = 0 # one-shot: don't re-fire while advancing self._stop_at_ms = 0 # one-shot: don't re-fire while advancing
track = self._current_track track = self._current_track
self._note_finished(track) self._note_finished(track)
self._advance(autoplay=True) self._after_finish()
def _note_finished(self, track): def _note_finished(self, track):
"""Record a completed play once, guarding against a double count if """Record a completed play once, guarding against a double count if
+5 -3
View File
@@ -120,7 +120,9 @@ def test_panel_fills_what_the_gaps_leave(qapp, tmp_path):
window.resize(1280, 500) window.resize(1280, 500)
qapp.processEvents() qapp.processEvents()
assert wide - bar._now_playing.width() == 640 assert wide - bar._now_playing.width() == 640
window.resize(800, 500) # Just above the narrowest the row of boxes can be (it grows with each
# control: 784 px before the repeat button, 858 after).
window.resize(bar.minimumSizeHint().width() + 16, 500)
qapp.processEvents() qapp.processEvents()
assert bar._now_playing.width() >= NOW_PLAYING_MIN assert bar._now_playing.width() >= NOW_PLAYING_MIN
bpm = bar._bpm_button.parentWidget() bpm = bar._bpm_button.parentWidget()
@@ -163,13 +165,13 @@ def test_row_is_knolled_with_equal_gaps_and_ends(qapp, tmp_path):
window.resize(width, 500) window.resize(width, 500)
qapp.processEvents() qapp.processEvents()
row = [bar._prev_btn.parentWidget(), bar._shuffle_btn.parentWidget(), row = [bar._prev_btn.parentWidget(), bar._shuffle_btn.parentWidget(),
bar._visualizer, bar._volume_slider, bar._now_playing, bar._repeat_btn.parentWidget(), bar._visualizer, bar._volume_slider, bar._now_playing,
bar._bpm_button.parentWidget()] bar._bpm_button.parentWidget()]
edges = [(w.geometry().left(), w.geometry().right()) for w in row] edges = [(w.geometry().left(), w.geometry().right()) for w in row]
gaps = [b[0] - a[1] - 1 for a, b in zip(edges, edges[1:])] gaps = [b[0] - a[1] - 1 for a, b in zip(edges, edges[1:])]
# The same GAP everywhere, ends included, at every width. # The same GAP everywhere, ends included, at every width.
left_end, right_end = edges[0][0], bar.width() - 1 - edges[-1][1] left_end, right_end = edges[0][0], bar.width() - 1 - edges[-1][1]
assert gaps + [left_end, right_end] == [GAP] * 7 assert gaps + [left_end, right_end] == [GAP] * 8
def test_gap_between_playlists_and_songs_matches_left_inset(qapp, tmp_path): def test_gap_between_playlists_and_songs_matches_left_inset(qapp, tmp_path):
+239
View File
@@ -0,0 +1,239 @@
"""Round 88: a repeat button, the streaming tile's click, and AirPlay's
compatibility handshake for third-party speakers (a WiiM played nothing)."""
import asyncio
import os
import random
from types import SimpleNamespace
from unittest.mock import MagicMock
import pytest
from PyQt6.QtCore import QPointF, Qt
from PyQt6.QtGui import QMouseEvent
from lintunes.airplay import stream
from lintunes.airplay.support import alac_verbatim, use_compat
from lintunes.player import REPEAT_ALL, REPEAT_OFF, REPEAT_ONE
from tests.test_round29 import _FakeSink, _local_track, _player
# ---- repeat ----
def _queue(qapp, tmp_path, n=3, sink=None):
tracks = [_local_track(tmp_path, i) for i in range(1, n + 1)]
player = _player(qapp, tracks)
sink = sink or _FakeSink()
player.set_sink(sink)
player.play_queue([t.track_id for t in tracks], 0)
return player, sink
class TestRepeat:
def test_off_stops_at_the_end(self, qapp, tmp_path):
player, sink = _queue(qapp, tmp_path)
player._index = 2
assert player._step_index(1) is None
assert player._step_index(-3) is None
def test_all_wraps_both_ways(self, qapp, tmp_path):
player, sink = _queue(qapp, tmp_path)
player.set_repeat(REPEAT_ALL)
player._index = 2
assert player._step_index(1) == 0
player._index = 0
assert player._step_index(-1) == 2
def test_all_reshuffles_a_new_lap_without_repeating_the_last_song(
self, qapp, tmp_path):
player, sink = _queue(qapp, tmp_path, n=5)
player.set_shuffle(True)
player.set_repeat(REPEAT_ALL)
for _ in range(20):
player._index = player._shuffle_order[-1]
first = player._step_index(1)
assert first is not None and first != player._index
assert player._shuffle_order[0] == first
assert sorted(player._shuffle_order) == list(range(5))
def test_a_finished_song_plays_again_on_repeat_one(self, qapp, tmp_path):
player, sink = _queue(qapp, tmp_path)
player.set_repeat(REPEAT_ONE)
sink.ended.emit()
assert sink.loads[-1] == (1, True, 0)
assert player.current_track.track_id == 1
player._manager.record_play.assert_called_once_with(1)
def test_next_still_moves_on_repeat_one(self, qapp, tmp_path):
player, sink = _queue(qapp, tmp_path)
player.set_repeat(REPEAT_ONE)
player.next()
assert player.current_track.track_id == 2
def test_nothing_playable_doesnt_loop_forever_on_repeat_all(
self, qapp, tmp_path):
tracks = [_local_track(tmp_path, i) for i in range(1, 4)]
player = _player(qapp, tracks)
player.set_repeat(REPEAT_ALL)
player.set_sink(_FakeSink(playable=False))
player.play_queue([1, 2, 3], 0)
assert player.current_track is None
def test_unknown_mode_is_off(self, qapp, tmp_path):
player, _ = _queue(qapp, tmp_path)
player.set_repeat("sideways")
assert player.repeat_mode() == REPEAT_OFF
class TestRepeatButton:
def test_cycles_off_all_one(self, qapp, tmp_path):
from lintunes.gui.transport import TransportBar
from lintunes.preferences import Preferences
player, _ = _queue(qapp, tmp_path)
bar = TransportBar(player, MagicMock(), Preferences(tmp_path / "p"))
button = bar._repeat_btn
assert not button.isChecked() and button._kind == "repeat"
seen = []
for _ in range(3):
button.click()
seen.append((player.repeat_mode(), button.isChecked(),
button._kind))
assert seen == [(REPEAT_ALL, True, "repeat"),
(REPEAT_ONE, True, "repeat_one"),
(REPEAT_OFF, False, "repeat")]
# ---- the streaming tile ----
class TestStreamingTileClick:
def test_stopping_a_stream_doesnt_open_the_big_window(self, qapp):
from lintunes.gui.visualizer import VisualizerWidget
player = MagicMock()
widget = VisualizerWidget(player, MagicMock(get=lambda k, d=None: d))
widget.resize(140, 60)
widget._no_pcm = True
opened = []
widget.open_big = lambda: opened.append(1)
def stop(): # the swap back happens before the release
widget._no_pcm = False
widget.cast_stop_requested.connect(stop)
at = QPointF(70, 30)
for kind in (QMouseEvent.Type.MouseButtonPress,
QMouseEvent.Type.MouseButtonRelease):
widget.event(QMouseEvent(kind, at, at, Qt.MouseButton.LeftButton,
Qt.MouseButton.LeftButton,
Qt.KeyboardModifier.NoModifier))
assert opened == []
# …and the next click is an ordinary one again.
for kind in (QMouseEvent.Type.MouseButtonPress,
QMouseEvent.Type.MouseButtonRelease):
widget.event(QMouseEvent(kind, at, at, Qt.MouseButton.LeftButton,
Qt.MouseButton.LeftButton,
Qt.KeyboardModifier.NoModifier))
assert opened == [1]
# ---- AirPlay compatibility ----
class TestUseCompat:
def test_auto_is_compat_except_for_apple(self):
assert use_compat("auto", "WiiM Mini Receiver")
assert use_compat("auto", "")
assert not use_compat("auto", "AudioAccessory5,1") # HomePod mini
assert not use_compat("auto", "AppleTV6,2")
def test_explicit_choices_win(self):
assert use_compat("1", "AudioAccessory5,1")
assert not use_compat("2", "WiiM Mini Receiver")
class TestAlacVerbatim:
def test_frame_layout(self):
pcm = bytes(range(256)) * 5 + bytes(128) # 352 stereo frames
frame = alac_verbatim(pcm)
assert len(frame) == 1412 # 23 + 11264 + 3 bits, padded
assert frame[:2] == b"\x20\x00"
bits = int.from_bytes(frame, "big")
total = len(frame) * 8
# the samples sit right after the 23-bit header…
body = (bits >> (total - 23 - len(pcm) * 8)) & ((1 << len(pcm) * 8) - 1)
assert body.to_bytes(len(pcm), "big") == pcm
# …then the end tag 0b111, then zero padding.
tail = bits & ((1 << (total - 23 - len(pcm) * 8)) - 1)
assert tail == 0b111 << 6
def test_header_bits(self):
frame = alac_verbatim(bytes(1408))
# channel pair, tag 0, no size, no shift, not compressed
assert frame[2] >> 1 == 0b0000001
class _Conn:
def __init__(self, ip):
self.remote_ip = ip
self.local_ip = "10.0.0.2"
@pytest.fixture
def shim():
stream.install_shim()
yield
stream._compat_hosts.clear()
class TestCompatHooks:
def test_announce_says_apple_lossless_only_for_compat_hosts(self, shim):
from pyatv.support import rtsp
sent = []
async def exchange(self, method, **kw):
sent.append(kw["body"])
return SimpleNamespace(code=200, headers={})
session = rtsp.RtspSession(_Conn("10.0.0.9"))
session.exchange = exchange.__get__(session)
stream.set_compat("10.0.0.9", True)
asyncio.run(session.announce(2, 2, 44100, None))
stream.set_compat("10.0.0.9", False)
asyncio.run(session.announce(2, 2, 44100, None))
assert "a=rtpmap:96 AppleLossless" in sent[0]
assert "a=fmtp:96 352 0 16 40 10 14 2 255 0 0 44100" in sent[0]
assert "L16/44100/2" in sent[1]
def test_no_pairing_and_auth_setup_for_compat_hosts(self, shim):
from pyatv.protocols.raop import stream_client
from pyatv.protocols.raop.protocols import airplayv1
from pyatv.protocols.raop.parsers import EncryptionType
stream.set_compat("10.0.0.9", True)
assert isinstance(airplayv1.pair_verify(None, _Conn("10.0.0.9")),
stream._NoPairing)
client = SimpleNamespace(rtsp=SimpleNamespace(
connection=_Conn("10.0.0.9")), _properties={"am": "WiiM"},
_encryption_types=EncryptionType.Unencrypted)
assert stream_client.StreamClient._requires_auth_setup.fget(client)
client.rtsp.connection = _Conn("10.0.0.10")
assert not stream_client.StreamClient._requires_auth_setup.fget(client)
def test_audio_is_wrapped_as_alac_for_compat_hosts(self, shim):
from pyatv.protocols.raop.protocols import airplayv1
sent = []
proto = SimpleNamespace(
rtsp=SimpleNamespace(connection=_Conn("10.0.0.9")),
context=SimpleNamespace(bytes_per_channel=2, channels=2, rtpseq=7))
transport = SimpleNamespace(sendto=sent.append)
pcm = os.urandom(1408)
stream.set_compat("10.0.0.9", True)
asyncio.run(airplayv1.AirPlayV1.send_audio_packet(
proto, transport, b"H" * 12, pcm))
stream.set_compat("10.0.0.9", False)
asyncio.run(airplayv1.AirPlayV1.send_audio_packet(
proto, transport, b"H" * 12, pcm))
assert sent[0] == b"H" * 12 + alac_verbatim(pcm)
assert sent[1] == b"H" * 12 + pcm
def test_install_is_idempotent(self, shim):
from pyatv.support import rtsp
announce = rtsp.RtspSession.announce
stream.install_shim()
assert rtsp.RtspSession.announce is announce