Files
lintunes/tests/test_round87.py
T
trav c1aee48b8b v0.56.0: Connect to AirPlay — stream to AirPlay speakers via pyatv
Every song is decoded by the ffmpeg CLI and streamed over RAOP, so ALAC
and AIFF play too (only FairPlay is refused). pyatv has no pause or seek
for RAOP, so both restart the stream at the heard position. The picker
lists every AirPlay device on the network, greyed with the reason when
LinTunes can't stream to it (video-only TVs, PIN pairing). Casting and
AirPlay are mutually exclusive; the visualizer tile shows the AirPlay glyph
and a click there stops it. Needs: pip install -e . (adds pyatv).
2026-10-15 16:01:08 -07:00

492 lines
18 KiB
Python

"""Round 87: Connect to AirPlay.
The sink is driven against a fake pyatv session on the real AsyncLoop thread;
the ffmpeg source decodes real files. Nothing here touches the network —
pyatv's scan and connect are never called.
"""
import asyncio
import time
from types import SimpleNamespace
from unittest.mock import MagicMock, patch
import pytest
from PyQt6.QtCore import QObject, pyqtSignal
from PyQt6.QtGui import QColor, QImage
from lintunes import player as player_module
from lintunes.airplay import support
from lintunes.airplay.discovery import AirPlayDevice
from lintunes.airplay.loop import AsyncLoop
from lintunes.gui.cast_dialog import AirPlayDialog, ChromecastDialog
from lintunes.models.library import Library
from lintunes.player import Player
def _until(qapp, condition, timeout=3.0):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
qapp.processEvents()
if condition():
return True
time.sleep(0.005)
qapp.processEvents()
return condition()
# ---- pure helpers ----
class TestSupport:
def test_only_receivers_that_take_anyone_are_connectable(self):
assert support.classify(True, "NotNeeded", False) == (True, "")
assert support.classify(True, "Optional", False) == (True, "")
assert support.classify(True, "Mandatory", False) == (False,
"needs pairing")
assert support.classify(True, "NotNeeded", True)[0] is False
assert support.classify(True, "Unsupported", False)[0] is False
# AirPlay without RAOP is a screen to mirror to, not a speaker.
assert support.classify(False, "", False) == (False, "video only")
def test_volume_is_the_same_db_as_the_local_output(self):
assert support.level_to_percent(0.0) == 0.0
assert support.level_to_percent(1.0) == 100.0
# Half amplitude is -6 dB: 24/30 of the way up pyatv's -30..0 scale.
assert support.level_to_percent(0.5) == pytest.approx(79.93, abs=0.01)
# Below pyatv's floor is silence, never a negative percent.
assert support.level_to_percent(0.01) == 0.0
def test_position_is_what_was_heard_not_what_was_sent(self):
rate = 44100
latency = support.latency_ms(rate)
assert latency == pytest.approx(1500, abs=1)
# Nothing read yet: still at the start position.
assert support.heard_ms(5000, 0, None, rate) == 5000
# Inside the receiver's latency nothing has come out yet.
assert support.heard_ms(5000, rate, 1000, rate) == 5000
assert support.heard_ms(0, 10 * rate, 3500, rate) == 2000
# Capped at what was read: pyatv sends trailing silence after the
# song, and the position must not run past it.
assert support.heard_ms(0, 4 * rate, 9000, rate) == 4000
def test_ffmpeg_seeks_only_when_asked_and_sends_big_endian(self):
cmd = support.ffmpeg_command("/m/a.m4a", 0, 44100, 2, 2)
assert "-ss" not in cmd
assert cmd[cmd.index("-f") + 1] == "s16be"
assert cmd[-1] == "pipe:1"
cmd = support.ffmpeg_command("/m/a.m4a", 61_500, 44100, 2, 2)
# Before -i: an input seek, instant however deep into the file.
assert cmd.index("-ss") < cmd.index("-i")
assert cmd[cmd.index("-ss") + 1] == "61.500"
def test_everything_but_fairplay_streams(self):
assert support.can_stream("/m/a.m4a", "Apple Lossless audio file")
assert support.can_stream("/m/a.aiff", "AIFF audio file")
assert not support.can_stream("/m/a.m4p", "")
assert not support.can_stream("/m/a.m4a", "Protected AAC audio file")
assert not support.can_stream("", "")
assert "copy-protected" in support.unstreamable_reason(
"/m/a.m4a", "Protected AAC audio file")
# ---- the ffmpeg source ----
def _drain(request, rate=44100):
from lintunes.airplay.stream import _ffmpeg_source
async def run():
source = await _ffmpeg_source().open(request, rate, 2, 2)
total = b""
while True:
chunk = await source.readframes(352)
if not chunk:
break
total += chunk
await source.close()
return total
return asyncio.run(run())
class TestFfmpegSource:
@pytest.fixture(autouse=True)
def _needs_pyatv(self):
pytest.importorskip("pyatv")
def test_decodes_a_whole_song(self, m4a_file):
from lintunes.airplay.stream import PcmRequest
request = PcmRequest(str(m4a_file), 0, 1000)
data = _drain(request)
assert request.exhausted and not request.decode_error
assert request.frames_read == len(data) // 4
# A 1 s AAC fixture, give or take the encoder's priming frames.
assert request.frames_read == pytest.approx(44100, abs=2048)
assert request.first_read_at is not None
def test_starts_from_an_offset(self, flac_file):
from lintunes.airplay.stream import PcmRequest
request = PcmRequest(str(flac_file), 500, 1000)
_drain(request)
assert request.frames_read == pytest.approx(22050, abs=64)
def test_an_unreadable_file_is_a_decode_error(self, tmp_path):
from lintunes.airplay.stream import PcmRequest
request = PcmRequest(str(tmp_path / "gone.mp3"), 0, 1000)
assert _drain(request) == b""
assert request.decode_error
assert not request.exhausted
def test_shim_routes_only_our_requests(self):
import pyatv.protocols.raop as raop
from lintunes.airplay.stream import install_shim
install_shim()
patched = raop.open_source
install_shim()
assert raop.open_source is patched # idempotent
assert patched._lintunes
# ---- the sink, against a fake pyatv session ----
class _FakeAtv:
def __init__(self):
self.log = []
self.behavior = "finish"
self.closed = 0
outer = self
class Stream:
async def stream_file(self, request, metadata=None):
outer.log.append(("stream", request.start_ms, metadata.title))
behavior = outer.behavior
if behavior == "finish":
request.frames_read = 4410
request.exhausted = True
elif behavior == "hang":
try:
await asyncio.sleep(3600)
except asyncio.CancelledError:
outer.log.append(("cancelled", request.start_ms))
raise
elif behavior == "decode":
request.decode_error = "Invalid data found"
elif behavior == "drop":
request.frames_read = 1000
elif behavior == "unreachable":
raise ConnectionRefusedError("refused")
class Audio:
async def set_volume(self, percent):
outer.log.append(("volume", round(percent, 1)))
self.stream = Stream()
self.audio = Audio()
def close(self):
self.closed += 1
return set()
def kinds(self):
return [entry[0] for entry in self.log]
def _track(location="/m/song.mp3", total_time=4000):
return SimpleNamespace(location=location, kind="MPEG audio file",
name="Song", artist="Artist", album="Album",
total_time=total_time)
@pytest.fixture
def loop():
return AsyncLoop()
@pytest.fixture
def sink_and_atv(qapp, loop):
pytest.importorskip("pyatv")
from lintunes.airplay.sink import AirPlaySink
atv = _FakeAtv()
with patch("lintunes.airplay.sink.tagging.read_embedded_artwork",
return_value=None):
sink = AirPlaySink(atv, loop, "tiat.place")
events = []
sink.ended.connect(lambda: events.append("ended"))
sink.error.connect(lambda m: events.append(("error", m)))
sink.unavailable.connect(lambda m: events.append(("unavailable", m)))
yield sink, atv, events
sink.shutdown()
class TestAirPlaySink:
def test_a_finished_song_ends_once(self, qapp, sink_and_atv):
sink, atv, events = sink_and_atv
sink.load(_track(), autoplay=True, start_ms=0)
assert sink.is_playing()
assert _until(qapp, lambda: events)
assert events == ["ended"]
assert not sink.is_playing()
assert sink.position_ms() == 4000
assert ("stream", 0, "Song") in atv.log
def test_volume_reaches_the_speaker_before_the_stream(
self, qapp, sink_and_atv):
sink, atv, events = sink_and_atv
sink.set_volume(1.0)
sink.load(_track(), autoplay=True, start_ms=0)
assert _until(qapp, lambda: "stream" in atv.kinds())
assert atv.log[0] == ("volume", 100.0)
assert atv.kinds().index("volume") < atv.kinds().index("stream")
def test_loading_paused_streams_nothing(self, qapp, sink_and_atv):
sink, atv, events = sink_and_atv
sink.load(_track(), autoplay=False, start_ms=1200)
_until(qapp, lambda: False, timeout=0.2)
assert "stream" not in atv.kinds()
assert sink.position_ms() == 1200 and not sink.is_playing()
def test_a_seek_replaces_the_stream_and_the_old_one_cannot_end_it(
self, qapp, sink_and_atv):
sink, atv, events = sink_and_atv
atv.behavior = "hang"
sink.load(_track(), autoplay=True, start_ms=0)
assert _until(qapp, lambda: ("stream", 0, "Song") in atv.log)
sink.seek(3000)
assert sink.position_ms() == 3000
assert _until(qapp, lambda: ("stream", 3000, "Song") in atv.log)
assert ("cancelled", 0) in atv.log
# The old stream was cancelled, never finished: no queue advance.
assert events == []
assert sink.is_playing()
def test_pause_stops_the_stream_and_resume_starts_where_it_was(
self, qapp, sink_and_atv):
sink, atv, events = sink_and_atv
atv.behavior = "hang"
sink.load(_track(), autoplay=True, start_ms=2000)
assert _until(qapp, lambda: ("stream", 2000, "Song") in atv.log)
sink.pause()
assert not sink.is_playing()
assert _until(qapp, lambda: ("cancelled", 2000) in atv.log)
paused_at = sink.position_ms()
sink.play()
assert _until(qapp, lambda: atv.kinds().count("stream") == 2)
assert atv.log[-1] == ("stream", paused_at, "Song")
assert events == []
def test_an_undecodable_song_is_skipped_not_a_lost_speaker(
self, qapp, sink_and_atv):
sink, atv, events = sink_and_atv
atv.behavior = "decode"
sink.load(_track(), autoplay=True, start_ms=0)
assert _until(qapp, lambda: events)
assert events[0][0] == "error"
assert "Invalid data" in events[0][1]
@pytest.mark.parametrize("behavior, says", [
("drop", "something else"), # pyatv returned before ffmpeg's end
("unreachable", "Lost"),
])
def test_a_lost_speaker_hands_back_to_this_machine(
self, qapp, sink_and_atv, behavior, says):
sink, atv, events = sink_and_atv
atv.behavior = behavior
sink.load(_track(), autoplay=True, start_ms=0)
assert _until(qapp, lambda: events)
kind, reason = events[0]
assert kind == "unavailable" and says in reason
# Still "playing": Player falls back to the local output carrying on.
assert sink.is_playing()
def test_shutdown_closes_the_session(self, qapp, sink_and_atv):
sink, atv, events = sink_and_atv
sink.shutdown()
sink.shutdown()
assert atv.closed == 1
def test_artwork_is_sent_as_a_small_jpeg(self, qapp):
from lintunes.airplay.sink import ART_MAX_PX, jpeg_artwork
from PyQt6.QtCore import QBuffer, QIODevice
image = QImage(1200, 800, QImage.Format.Format_RGB32)
image.fill(QColor("red"))
buffer = QBuffer()
buffer.open(QIODevice.OpenModeFlag.WriteOnly)
image.save(buffer, "PNG")
out = jpeg_artwork(bytes(buffer.data()))
assert out[:3] == b"\xff\xd8\xff"
decoded = QImage()
decoded.loadFromData(out)
assert max(decoded.width(), decoded.height()) == ART_MAX_PX
assert jpeg_artwork(None) is None
assert jpeg_artwork(b"not an image") is None
# ---- the controller ----
def _player(qapp):
with patch.multiple(player_module, QMediaPlayer=MagicMock(),
QAudioOutput=MagicMock(),
QAudioBufferOutput=MagicMock(),
QMediaDevices=MagicMock()):
return Player(MagicMock(library=Library()))
class TestController:
def test_connect_hands_player_the_sink_and_disconnect_takes_it_back(
self, qapp):
pytest.importorskip("pyatv")
from lintunes.airplay.controller import AirPlayController
player = _player(qapp)
controller = AirPlayController(player)
controller._inhibitor = MagicMock()
seen = []
controller.connected.connect(seen.append)
atv = _FakeAtv()
controller._attempt = 1
controller._on_connect_result({"atv": atv, "name": "tiat.place"}, 1)
assert controller.is_connected()
assert player.active_sink().name == "tiat.place"
assert player.active_sink().listen_src == "airplay"
assert seen == ["tiat.place"]
controller.disconnect()
assert player.is_local
assert not controller.is_connected()
assert atv.closed == 1
def test_a_superseded_connect_is_closed_not_installed(self, qapp):
pytest.importorskip("pyatv")
from lintunes.airplay.controller import AirPlayController
player = _player(qapp)
controller = AirPlayController(player)
atv = _FakeAtv()
controller._attempt = 2
controller._on_connect_result({"atv": atv, "name": "old pick"}, 1)
assert not controller.is_connected()
assert _until(qapp, lambda: atv.closed == 1)
def test_raop_only_turns_the_other_services_off(self):
pytest.importorskip("pyatv")
from pyatv.const import Protocol
from lintunes.airplay.controller import raop_only
services = [SimpleNamespace(protocol=Protocol.AirPlay, enabled=True),
SimpleNamespace(protocol=Protocol.RAOP, enabled=True)]
raop_only(SimpleNamespace(services=services))
assert [s.enabled for s in services] == [False, True]
# ---- discovery and the picker ----
class TestDiscovery:
def test_a_scan_result_becomes_a_device(self):
pytest.importorskip("pyatv")
from pyatv.const import Protocol
from lintunes.airplay.discovery import to_device
def conf(raop, name, model):
return SimpleNamespace(
identifier="42:D9", name=name, address="192.0.2.7",
device_info=SimpleNamespace(raw_model=model),
get_service=lambda p: raop if p == Protocol.RAOP else None)
speaker = to_device(conf(SimpleNamespace(
pairing=SimpleNamespace(name="NotNeeded"), requires_password=False,
properties={"am": "WiiM Mini Receiver"}), "Gallery", None))
assert speaker == AirPlayDevice(
uuid="42:D9", name="Gallery", model="WiiM Mini Receiver",
host="192.0.2.7", connectable=True, note="")
tv = to_device(conf(None, "Lobby TV", "7415X"))
assert not tv.connectable and tv.note == "video only"
assert tv.model == "7415X"
class _FakeDiscovery(QObject):
device_found = pyqtSignal(object)
device_lost = pyqtSignal(object)
failed = pyqtSignal(str)
def __init__(self):
super().__init__()
self.stopped = 0
def devices(self):
return []
def start(self):
pass
def stop(self):
self.stopped += 1
def _ap(uuid, name, connectable=True, note=""):
return AirPlayDevice(uuid=uuid, name=name, model="", host="192.0.2.9",
connectable=connectable, note=note)
class TestPicker:
def test_unusable_devices_are_listed_greyed_with_the_reason(self, qapp):
discovery = _FakeDiscovery()
dialog = AirPlayDialog(discovery)
assert dialog.windowTitle() == "Connect to AirPlay"
assert "AirPlay speaker" in dialog._status.text()
discovery.device_found.emit(_ap("tv", "Lobby TV", False,
"needs pairing"))
assert dialog._list.count() == 1
assert "needs pairing" in dialog._list.item(0).text()
assert not dialog._connect_button.isEnabled()
dialog._on_connect()
assert dialog.selected_device is None
dialog._on_empty_timeout()
assert "can play to" in dialog._status.text()
discovery.device_found.emit(_ap("wiim", "tiat.place"))
assert dialog._connect_button.isEnabled()
dialog._on_connect()
assert dialog.selected_device.name == "tiat.place"
assert discovery.stopped == 1
def test_chromecast_picker_reads_as_before(self, qapp):
dialog = ChromecastDialog(_FakeDiscovery())
assert dialog.windowTitle() == "Connect to Chromecast"
assert dialog._status.text() == "Searching for Chromecasts…"
dialog.reject()
# ---- the transport-bar indicator ----
class TestIndicator:
def test_the_visualizer_shows_airplay_and_a_click_disconnects_it(
self, qapp, tmp_path):
from lintunes.gui.transport import TransportBar
from lintunes.player import PlaybackSink
from lintunes.preferences import Preferences
class Sink(PlaybackSink):
name = "tiat.place"
glyph = "airplay"
def stop(self):
pass
def set_volume(self, level):
pass
def position_ms(self):
return 0
def is_playing(self):
return False
player = _player(qapp)
cast, airplay = MagicMock(), MagicMock()
bar = TransportBar(player, MagicMock(), Preferences(tmp_path),
cast=cast, airplay=airplay)
player.set_sink(Sink())
vis = bar._visualizer
assert vis._glyph == "airplay"
assert vis.toolTip() == "Playing on tiat.place — click to stop"
vis.mousePressEvent(None)
airplay.disconnect.assert_called_once()