Files
SpotiFLAC-Mobile/test/media3_engine_deck_test.dart
zarzet da608a6638 fix(usb): never set a rate the DAC's clock does not list, and add a rate limit
A song whose rate the DAC refuses is already converted, but the DAC was
still asked for that rate first, for every song, and a DAC that takes the
request and then plays silence was never converted at all.

- Read the UAC2 clock's RANGE before setting a rate and refuse one it
  does not list, without touching the clock.
- Remember per connected DAC the rate a song rate played at, so the
  refused rate is not requested again on each song.
- Add "Highest sample rate" to the Direct USB settings (Automatic by
  default): rates above it are never requested and such songs are
  converted down.
2026-11-18 21:48:21 +07:00

430 lines
13 KiB
Dart

import 'dart:async';
import 'package:flutter_test/flutter_test.dart';
import 'package:mornye/services/media3_playback_deck.dart';
import 'package:mornye/services/playback_deck.dart';
class _Deck implements PlaybackDeck, QueuedPlaybackDeck {
_Deck(this.name);
final String name;
final calls = <String>[];
final states = StreamController<PlaybackDeckState>.broadcast();
final durations = StreamController<Duration>.broadcast();
final positions = StreamController<Duration>.broadcast();
final completions = StreamController<void>.broadcast();
bool disposed = false;
PlaybackDeck? nextDeck;
@override
bool get canQueueNextSource => name == 'media3';
@override
Future<bool> queueNextSource(
String source, {
required double volume,
required void Function() onStarted,
}) async {
calls.add('queue $source');
return true;
}
@override
Future<void> clearNextSource() async => calls.add('clear next');
@override
PlaybackDeckState state = PlaybackDeckState.stopped;
@override
bool get isDirect => false;
@override
PlaybackTempoSupport tempoSupport = PlaybackTempoSupport.full;
@override
bool get needsSourceReload => false;
@override
Stream<PlaybackDeckState> get onPlayerStateChanged => states.stream;
@override
Stream<Duration> get onDurationChanged => durations.stream;
@override
Stream<Duration> get onPositionChanged => positions.stream;
@override
Stream<void> get onPlayerComplete => completions.stream;
@override
void startPositionUpdates(Duration interval, {bool Function()? wanted}) =>
calls.add('positions ${interval.inMilliseconds}');
@override
Future<void> configureOutput() async => calls.add('configure');
@override
Future<void> setVolume(double volume) async => calls.add('volume $volume');
@override
Future<void> setPlaybackRate(double rate) async => calls.add('rate $rate');
@override
Future<void> setNetworkSource(String url, {bool arriving = false}) async =>
calls.add('url $url');
@override
Future<void> setFileSource(
String path, {
bool preferBitPerfect = false,
bool directUsb = false,
bool allowDop = false,
bool requiresDsd = false,
bool allowFixedVolume = false,
bool dapExclusive = false,
int usbMaxSampleRate = 0,
}) async {
final flags = [
if (preferBitPerfect) 'bit-perfect',
if (directUsb) 'usb',
if (allowDop) 'dop',
if (requiresDsd) 'dsd',
if (allowFixedVolume) 'fixed',
if (dapExclusive) 'aaudio',
];
calls.add(['file $path', ...flags].join(' '));
}
@override
Future<void> cancelPreparation() async {}
@override
Future<void> resume() async {
calls.add('resume');
state = PlaybackDeckState.playing;
}
@override
Future<void> pause() async {
calls.add('pause');
state = PlaybackDeckState.paused;
}
@override
Future<void> seek(Duration position) async =>
calls.add('seek ${position.inSeconds}');
@override
Future<void> stop() async {
calls.add('stop');
state = PlaybackDeckState.stopped;
}
@override
Future<bool> setNextDeck(PlaybackDeck? next) async {
nextDeck = next;
return true;
}
@override
Future<Duration?> getCurrentPosition() async => const Duration(seconds: 30);
@override
Future<Duration?> getDuration() async => const Duration(minutes: 3);
@override
Future<void> dispose() async {
disposed = true;
await states.close();
await durations.close();
await positions.close();
await completions.close();
}
}
Future<void> _settle() => Future<void>.delayed(Duration.zero);
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
late _Deck audioplayers;
late List<_Deck> media3;
late Media3EngineDeck deck;
Media3EngineDeck create(_Deck primary, List<_Deck> created) =>
Media3EngineDeck(
audioplayers: primary,
createMedia3: () {
final deck = _Deck('media3');
created.add(deck);
return deck;
},
);
setUp(() {
audioplayers = _Deck('audioplayers');
media3 = [];
deck = create(audioplayers, media3);
});
tearDown(() async {
await deck.dispose();
playbackMedia3Engine.value = false;
Media3PlaybackDeck.debugResetAvailability();
});
test('while off every source plays through audioplayers', () async {
await deck.configureOutput();
await deck.setFileSource('/song.flac');
await deck.resume();
await deck.setNetworkSource('https://example.com/song.flac');
expect(audioplayers.calls, [
'configure',
'file /song.flac',
'resume',
'url https://example.com/song.flac',
]);
expect(media3, isEmpty);
expect(deck.activeDeck, same(audioplayers));
expect(deck.canQueueNextSource, isFalse);
});
test('reports what the deck playing now does with speed and pitch', () async {
var notices = 0;
void counted() => notices++;
playbackTempoSupportRevision.addListener(counted);
addTearDown(() => playbackTempoSupportRevision.removeListener(counted));
audioplayers.tempoSupport = PlaybackTempoSupport.none;
expect(deck.tempoSupport, PlaybackTempoSupport.none);
playbackMedia3Engine.value = true;
await deck.configureOutput();
await deck.setFileSource('/song.flac');
expect(deck.activeDeck, same(media3.single));
expect(deck.tempoSupport, PlaybackTempoSupport.full);
expect(notices, 1);
await deck.setPlaybackRate(1.05);
expect(media3.single.calls, contains('rate 1.05'));
});
test(
'while on a source plays through media3 with the settings so far',
() async {
await deck.setVolume(0.5);
deck.startPositionUpdates(const Duration(milliseconds: 200));
playbackMedia3Engine.value = true;
await deck.configureOutput();
await deck.setFileSource('/song.flac');
await deck.resume();
expect(media3.single.calls, [
'volume 0.5',
'rate 1.0',
'positions 200',
'configure',
'file /song.flac',
'resume',
]);
expect(audioplayers.calls, [
'volume 0.5',
'positions 200',
'configure',
'stop',
]);
expect(deck.state, PlaybackDeckState.playing);
expect(deck.activeDeck, same(media3.single));
},
);
test('sources for the native outputs stay on audioplayers', () async {
playbackMedia3Engine.value = true;
await deck.setFileSource('/one.flac');
expect(media3, hasLength(1));
await deck.setFileSource(
'/two.flac',
preferBitPerfect: true,
directUsb: true,
allowDop: true,
allowFixedVolume: true,
);
expect(audioplayers.calls.last, 'file /two.flac bit-perfect usb dop fixed');
// Leaving media3 releases its player.
expect(media3.single.disposed, isTrue);
await deck.setFileSource(
'/three.flac',
preferBitPerfect: true,
dapExclusive: true,
);
await deck.setFileSource('/four.dsf', requiresDsd: true);
expect(audioplayers.calls.skip(audioplayers.calls.length - 2), [
'file /three.flac bit-perfect aaudio',
'file /four.dsf dsd',
]);
expect(media3, hasLength(1));
// Without bit-perfect output the native options change nothing.
await deck.setFileSource('/five.flac', dapExclusive: true, allowDop: true);
await deck.setNetworkSource('https://example.com/six.flac');
expect(media3, hasLength(2));
expect(
media3.last.calls,
containsAllInOrder([
'configure',
'file /five.flac dop aaudio',
'url https://example.com/six.flac',
]),
);
});
test('a change mid-song applies from the next song', () async {
final states = <PlaybackDeckState>[];
deck.onPlayerStateChanged.listen(states.add);
await deck.setFileSource('/one.flac');
await deck.resume();
playbackMedia3Engine.value = true;
await _settle();
await _settle();
expect(media3, isEmpty);
expect(audioplayers.calls, ['file /one.flac', 'resume']);
expect(deck.state, PlaybackDeckState.playing);
await deck.configureOutput();
await deck.setFileSource('/two.flac');
await deck.resume();
expect(
media3.single.calls,
containsAllInOrder(['file /two.flac', 'resume']),
);
// The deck left behind no longer reports.
audioplayers.states.add(PlaybackDeckState.stopped);
media3.single.states.add(PlaybackDeckState.playing);
await _settle();
expect(states, [PlaybackDeckState.playing]);
playbackMedia3Engine.value = false;
await _settle();
expect(media3.single.disposed, isFalse);
expect(deck.activeDeck, same(media3.single));
await deck.configureOutput();
await deck.setFileSource('/three.flac');
expect(media3.single.disposed, isTrue);
expect(audioplayers.calls.last, 'file /three.flac');
expect(deck.activeDeck, same(audioplayers));
});
test('gapless queues only on media3 and links audioplayers decks', () async {
playbackMedia3Engine.value = true;
await deck.setFileSource('/one.flac');
expect(deck.canQueueNextSource, isTrue);
var started = 0;
expect(
await deck.queueNextSource(
'/two.flac',
volume: 1,
onStarted: () => started++,
),
isTrue,
);
expect(media3.single.calls.last, 'queue /two.flac');
await deck.clearNextSource();
expect(media3.single.calls.last, 'clear next');
playbackMedia3Engine.value = false;
await deck.setFileSource('/three.flac');
expect(deck.canQueueNextSource, isFalse);
final nextPrimary = _Deck('audioplayers');
final next = create(nextPrimary, []);
addTearDown(next.dispose);
await next.setFileSource('/four.flac');
expect(await deck.setNextDeck(next), isTrue);
expect(audioplayers.nextDeck, same(nextPrimary));
});
test('a build without media3 plays through audioplayers', () async {
var created = 0;
await deck.dispose();
audioplayers = _Deck('audioplayers');
deck = Media3EngineDeck(
audioplayers: audioplayers,
createMedia3: () {
created++;
// No channel handler: the native player is missing.
return Media3PlaybackDeck(playerId: 'missing');
},
);
playbackMedia3Engine.value = true;
await deck.setFileSource('/one.flac');
expect(audioplayers.calls.last, 'file /one.flac');
expect(deck.activeDeck, same(audioplayers));
expect(Media3PlaybackDeck.isAvailable, isFalse);
await deck.setFileSource('/two.flac');
expect(audioplayers.calls.last, 'file /two.flac');
expect(created, 1);
});
test('a newer source during a switch wins', () async {
playbackMedia3Engine.value = true;
final first = deck.setFileSource('/one.flac');
playbackMedia3Engine.value = false;
final second = deck.setFileSource('/two.flac');
await Future.wait([first, second]);
expect(audioplayers.calls.last, 'file /two.flac');
expect([
for (final deck in media3) ...deck.calls,
], isNot(contains('file /one.flac')));
expect(deck.activeDeck, same(audioplayers));
});
group('cleartext streams', () {
setUp(() => playbackMedia3Engine.value = true);
for (final url in [
'http://192.168.1.20:4533/rest/stream?id=1',
'http://nas.example.com/song.flac',
'HTTP://Media.Example.com/song.flac',
// The security config allows these loopback names only.
'http://[::1]:8080/song.flac',
'http://127.0.0.2:8080/song.flac',
]) {
test('a stream from another host stays on audioplayers ($url)', () async {
await deck.setNetworkSource(url);
expect(audioplayers.calls.last, 'url $url');
expect(media3, isEmpty);
expect(deck.activeDeck, same(audioplayers));
});
}
for (final url in [
'http://127.0.0.1:8080/song.flac',
'http://localhost:8080/song.flac',
'https://192.168.1.20/song.flac',
'https://example.com/song.flac',
]) {
test('loopback http and https play through media3 ($url)', () async {
await deck.setNetworkSource(url);
expect(media3.single.calls.last, 'url $url');
expect(deck.activeDeck, same(media3.single));
});
}
test('a LAN stream is not queued on media3', () async {
await deck.setFileSource('/one.flac');
expect(deck.canQueueNextSource, isTrue);
expect(
await deck.queueNextSource(
'http://192.168.1.20/next.flac',
volume: 1,
onStarted: () {},
),
isFalse,
);
expect(media3.single.calls, isNot(contains(startsWith('queue'))));
expect(
await deck.queueNextSource(
'http://127.0.0.1:8080/next.flac',
volume: 1,
onStarted: () {},
),
isTrue,
);
expect(media3.single.calls.last, 'queue http://127.0.0.1:8080/next.flac');
// The ordinary handoff then opens the LAN stream on audioplayers.
await deck.setNetworkSource('http://192.168.1.20/next.flac');
expect(audioplayers.calls.last, 'url http://192.168.1.20/next.flac');
expect(media3.single.disposed, isTrue);
});
});
}