1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-16 22:22:54 +08:00
osu-lazer/osu.Game/Overlays/MusicController.cs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

535 lines
20 KiB
C#
Raw Normal View History

// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
2018-04-13 17:19:50 +08:00
2016-10-24 13:00:06 +08:00
using System;
using System.Collections.Generic;
using System.Linq;
2016-11-11 06:40:42 +08:00
using osu.Framework.Allocation;
using osu.Framework.Audio;
using osu.Framework.Audio.Track;
2019-02-21 18:04:31 +08:00
using osu.Framework.Bindables;
2016-10-24 10:50:49 +08:00
using osu.Framework.Graphics;
using osu.Framework.Graphics.Audio;
using osu.Framework.Graphics.Containers;
using osu.Framework.Logging;
using osu.Framework.Threading;
using osu.Game.Audio.Effects;
using osu.Game.Beatmaps;
2021-11-08 16:59:23 +08:00
using osu.Game.Database;
using osu.Game.Rulesets.Mods;
2018-04-13 17:19:50 +08:00
namespace osu.Game.Overlays
{
/// <summary>
/// Handles playback of the global music track.
/// </summary>
public partial class MusicController : CompositeDrawable
{
[Resolved]
2024-07-05 10:55:27 +08:00
private BeatmapManager beatmaps { get; set; } = null!;
2018-04-13 17:19:50 +08:00
2019-10-24 12:10:17 +08:00
/// <summary>
/// Point in time after which the current track will be restarted on triggering a "previous track" action.
/// </summary>
2019-10-11 17:41:54 +08:00
private const double restart_cutoff_point = 5000;
/// <summary>
/// Whether the user has requested the track to be paused. Use <see cref="IsPlaying"/> to determine whether the track is still playing.
/// </summary>
public bool UserPauseRequested { get; private set; }
/// <summary>
/// Whether user control of the global track should be allowed.
/// </summary>
public readonly BindableBool AllowTrackControl = new BindableBool(true);
/// <summary>
/// Fired when the global <see cref="WorkingBeatmap"/> has changed.
/// Includes direction information for display purposes.
/// </summary>
2024-07-05 10:55:27 +08:00
public event Action<WorkingBeatmap, TrackChangeDirection>? TrackChanged;
[Resolved]
2024-07-05 10:55:27 +08:00
private IBindable<WorkingBeatmap> beatmap { get; set; } = null!;
[Resolved]
2024-07-05 10:55:27 +08:00
private IBindable<IReadOnlyList<Mod>> mods { get; set; } = null!;
2020-08-07 18:43:16 +08:00
public DrawableTrack CurrentTrack { get; private set; } = new DrawableTrack(new TrackVirtual(1000));
2021-11-08 16:59:23 +08:00
[Resolved]
2024-07-05 10:55:27 +08:00
private RealmAccess realm { get; set; } = null!;
2021-11-08 16:59:23 +08:00
private readonly BindableDouble audioDuckVolume = new BindableDouble(1);
2024-07-05 11:58:18 +08:00
private AudioFilter audioDuckFilter = null!;
[BackgroundDependencyLoader]
private void load(AudioManager audio)
{
AddInternal(audioDuckFilter = new AudioFilter(audio.TrackMixer));
audio.Tracks.AddAdjustment(AdjustableProperty.Volume, audioDuckVolume);
}
protected override void LoadComplete()
{
base.LoadComplete();
2024-07-05 10:55:27 +08:00
beatmap.BindValueChanged(b =>
{
if (b.NewValue != null)
changeBeatmap(b.NewValue);
}, true);
mods.BindValueChanged(_ => ResetTrackAdjustments(), true);
2016-11-06 00:46:09 +08:00
}
2018-04-13 17:19:50 +08:00
/// <summary>
/// Forcefully reload the current <see cref="WorkingBeatmap"/>'s track from disk.
/// </summary>
public void ReloadCurrentTrack()
{
2024-07-05 10:55:27 +08:00
if (current == null)
return;
changeTrack();
TrackChanged?.Invoke(current, TrackChangeDirection.None);
}
2019-08-13 13:38:49 +08:00
/// <summary>
/// Returns whether the beatmap track is playing.
2019-08-13 13:38:49 +08:00
/// </summary>
2020-08-07 19:51:56 +08:00
public bool IsPlaying => CurrentTrack.IsRunning;
/// <summary>
/// Returns whether the beatmap track is loaded.
/// </summary>
2020-08-11 11:37:00 +08:00
public bool TrackLoaded => CurrentTrack.TrackLoaded;
2019-08-13 13:38:49 +08:00
2024-07-05 10:55:27 +08:00
private ScheduledDelegate? seekDelegate;
2018-04-13 17:19:50 +08:00
public void SeekTo(double position)
{
seekDelegate?.Cancel();
seekDelegate = Schedule(() =>
2018-11-03 07:04:30 +08:00
{
if (beatmap.Disabled || !AllowTrackControl.Value)
return;
CurrentTrack.Seek(position);
});
2016-10-24 17:23:30 +08:00
}
2018-04-13 17:19:50 +08:00
/// <summary>
/// Ensures music is playing, no matter what, unless the user has explicitly paused.
/// This means that if the current beatmap has a virtual track (see <see cref="TrackVirtual"/>) a new beatmap will be selected.
/// </summary>
public void EnsurePlayingSomething()
2016-11-11 10:35:58 +08:00
{
if (UserPauseRequested) return;
2018-04-13 17:19:50 +08:00
if (CurrentTrack.IsDummyDevice || beatmap.Value.BeatmapSetInfo.DeletePending)
2017-05-01 12:41:22 +08:00
{
if (beatmap.Disabled || !AllowTrackControl.Value)
return;
2019-08-13 13:38:49 +08:00
2022-06-27 19:40:02 +08:00
Logger.Log($"{nameof(MusicController)} skipping next track to {nameof(EnsurePlayingSomething)}");
NextTrack();
2017-05-01 12:41:22 +08:00
}
else if (!IsPlaying)
{
Logger.Log($"{nameof(MusicController)} starting playback to {nameof(EnsurePlayingSomething)}");
Play();
}
}
/// <summary>
/// Start playing the current track (if not already playing).
/// </summary>
/// <param name="restart">Whether to restart the track from the beginning.</param>
/// <param name="requestedByUser">
/// Whether the request to play was issued by the user rather than internally.
/// Specifying <c>true</c> will ensure that other methods like <see cref="EnsurePlayingSomething"/>
/// will resume music playback going forward.
/// </param>
/// <returns>Whether the operation was successful.</returns>
public bool Play(bool restart = false, bool requestedByUser = false)
{
if (requestedByUser && !AllowTrackControl.Value)
return false;
if (requestedByUser)
UserPauseRequested = false;
if (restart)
CurrentTrack.RestartAsync();
else if (!IsPlaying)
CurrentTrack.StartAsync();
return true;
}
/// <summary>
/// Stop playing the current track and pause at the current position.
/// </summary>
/// <param name="requestedByUser">
/// Whether the request to stop was issued by the user rather than internally.
/// Specifying <c>true</c> will ensure that other methods like <see cref="EnsurePlayingSomething"/>
/// will not resume music playback until the next explicit call to <see cref="Play"/>.
/// </param>
public void Stop(bool requestedByUser = false)
{
if (requestedByUser && !AllowTrackControl.Value)
return;
UserPauseRequested |= requestedByUser;
2020-08-07 19:51:56 +08:00
if (CurrentTrack.IsRunning)
CurrentTrack.StopAsync();
}
/// <summary>
/// Toggle pause / play.
/// </summary>
/// <returns>Whether the operation was successful.</returns>
public bool TogglePause()
{
if (!AllowTrackControl.Value)
return false;
2020-08-07 19:51:56 +08:00
if (CurrentTrack.IsRunning)
Stop(true);
2017-05-01 12:41:22 +08:00
else
Play(requestedByUser: true);
2019-08-13 13:38:49 +08:00
return true;
2016-10-28 20:44:59 +08:00
}
2018-04-13 17:19:50 +08:00
/// <summary>
/// Play the previous track or restart the current track if it's current time below <see cref="restart_cutoff_point"/>.
/// </summary>
2020-09-08 17:26:13 +08:00
/// <param name="onSuccess">Invoked when the operation has been performed successfully.</param>
2024-07-05 10:55:27 +08:00
public void PreviousTrack(Action<PreviousTrackResult>? onSuccess = null) => Schedule(() =>
{
PreviousTrackResult res = prev();
if (res != PreviousTrackResult.None)
onSuccess?.Invoke(res);
});
/// <summary>
/// Play the previous track or restart the current track if it's current time below <see cref="restart_cutoff_point"/>.
/// </summary>
/// <returns>The <see cref="PreviousTrackResult"/> that indicate the decided action.</returns>
private PreviousTrackResult prev()
2016-10-28 20:08:27 +08:00
{
if (beatmap.Disabled || !AllowTrackControl.Value)
return PreviousTrackResult.None;
double currentTrackPosition = CurrentTrack.CurrentTime;
2019-10-11 01:12:36 +08:00
2019-10-11 17:41:54 +08:00
if (currentTrackPosition >= restart_cutoff_point)
2019-10-11 01:12:36 +08:00
{
SeekTo(0);
2019-10-24 12:10:17 +08:00
return PreviousTrackResult.Restart;
2019-10-11 01:12:36 +08:00
}
queuedDirection = TrackChangeDirection.Prev;
2024-07-05 10:55:27 +08:00
var playableSet = getBeatmapSets().AsEnumerable().TakeWhile(i => !i.Equals(current?.BeatmapSetInfo)).LastOrDefault()
?? getBeatmapSets().LastOrDefault();
2019-04-01 11:16:05 +08:00
if (playableSet != null)
2018-05-14 16:45:11 +08:00
{
changeBeatmap(beatmaps.GetWorkingBeatmap(playableSet.Beatmaps.First()));
restartTrack();
2019-10-24 12:10:17 +08:00
return PreviousTrackResult.Previous;
2018-05-14 16:45:11 +08:00
}
2019-08-13 13:38:49 +08:00
2019-10-24 12:10:17 +08:00
return PreviousTrackResult.None;
2016-10-24 15:34:44 +08:00
}
2018-04-13 17:19:50 +08:00
/// <summary>
/// Play the next random or playlist track.
/// </summary>
2020-09-08 17:26:13 +08:00
/// <param name="onSuccess">Invoked when the operation has been performed successfully.</param>
/// <returns>A <see cref="ScheduledDelegate"/> of the operation.</returns>
2024-07-05 10:55:27 +08:00
public void NextTrack(Action? onSuccess = null) => Schedule(() =>
{
bool res = next();
if (res)
onSuccess?.Invoke();
});
private readonly List<DuckParameters> duckOperations = new List<DuckParameters>();
/// <summary>
/// Applies ducking, attenuating the volume and/or low-pass cutoff of the currently playing track to make headroom for effects (or just to apply an effect).
/// </summary>
/// <returns>A <see cref="IDisposable"/> which will restore the duck operation when disposed.</returns>
public IDisposable Duck(DuckParameters? parameters = null)
{
parameters ??= new DuckParameters();
duckOperations.Add(parameters);
DuckParameters volumeOperation = duckOperations.MinBy(p => p.DuckVolumeTo)!;
DuckParameters lowPassOperation = duckOperations.MinBy(p => p.DuckCutoffTo)!;
audioDuckFilter.CutoffTo(lowPassOperation.DuckCutoffTo, lowPassOperation.DuckDuration, lowPassOperation.DuckEasing);
this.TransformBindableTo(audioDuckVolume, volumeOperation.DuckVolumeTo, volumeOperation.DuckDuration, volumeOperation.DuckEasing);
return new InvokeOnDisposal(restoreDucking);
void restoreDucking() => Schedule(() =>
{
if (!duckOperations.Remove(parameters))
return;
DuckParameters? restoreVolumeOperation = duckOperations.MinBy(p => p.DuckVolumeTo);
DuckParameters? restoreLowPassOperation = duckOperations.MinBy(p => p.DuckCutoffTo);
// If another duck operation is in the list, restore ducking to its level, else reset back to defaults.
audioDuckFilter.CutoffTo(restoreLowPassOperation?.DuckCutoffTo ?? AudioFilter.MAX_LOWPASS_CUTOFF, parameters.RestoreDuration, parameters.RestoreEasing);
this.TransformBindableTo(audioDuckVolume, restoreVolumeOperation?.DuckVolumeTo ?? 1, parameters.RestoreDuration, parameters.RestoreEasing);
});
}
/// <summary>
/// A convenience method that ducks the currently playing track, then after a delay, restores automatically.
/// </summary>
/// <param name="delayUntilRestore">A delay in milliseconds which defines how long to delay restoration after ducking completes.</param>
/// <param name="parameters">Parameters defining the ducking operation.</param>
public void DuckMomentarily(double delayUntilRestore, DuckParameters? parameters = null)
{
parameters ??= new DuckParameters();
IDisposable duckOperation = Duck(parameters);
Scheduler.AddDelayed(() => duckOperation.Dispose(), delayUntilRestore);
}
private bool next()
2016-10-24 15:34:44 +08:00
{
if (beatmap.Disabled || !AllowTrackControl.Value)
return false;
queuedDirection = TrackChangeDirection.Next;
2024-07-05 10:55:27 +08:00
var playableSet = getBeatmapSets().AsEnumerable().SkipWhile(i => !i.Equals(current?.BeatmapSetInfo)).ElementAtOrDefault(1)
?? getBeatmapSets().FirstOrDefault();
var playableBeatmap = playableSet?.Beatmaps.FirstOrDefault();
2019-04-01 11:16:05 +08:00
if (playableBeatmap != null)
2018-05-14 16:45:11 +08:00
{
changeBeatmap(beatmaps.GetWorkingBeatmap(playableBeatmap));
restartTrack();
2019-08-13 13:38:49 +08:00
return true;
2018-05-14 16:45:11 +08:00
}
2019-08-13 13:38:49 +08:00
return false;
2016-10-24 15:34:44 +08:00
}
2018-04-13 17:19:50 +08:00
private void restartTrack()
{
// if not scheduled, the previously track will be stopped one frame later (see ScheduleAfterChildren logic in GameBase).
// we probably want to move this to a central method for switching to a new working beatmap in the future.
Schedule(() => CurrentTrack.RestartAsync());
}
2024-07-05 10:55:27 +08:00
private WorkingBeatmap? current;
private TrackChangeDirection? queuedDirection;
2018-04-13 17:19:50 +08:00
private IQueryable<BeatmapSetInfo> getBeatmapSets() => realm.Realm.All<BeatmapSetInfo>().Where(s => !s.DeletePending);
private void changeBeatmap(WorkingBeatmap newWorking)
2017-05-01 12:41:22 +08:00
{
// This method can potentially be triggered multiple times as it is eagerly fired in next() / prev() to ensure correct execution order
// (changeBeatmap must be called before consumers receive the bindable changed event, which is not the case when the local beatmap bindable is updated directly).
if (newWorking == current)
return;
var lastWorking = current;
TrackChangeDirection direction = TrackChangeDirection.None;
2018-04-13 17:19:50 +08:00
2024-07-05 10:55:27 +08:00
bool audioEquals = newWorking.BeatmapInfo?.AudioEquals(current?.BeatmapInfo) == true;
2020-08-18 12:01:35 +08:00
if (current != null)
{
if (audioEquals)
direction = TrackChangeDirection.None;
else if (queuedDirection.HasValue)
{
direction = queuedDirection.Value;
queuedDirection = null;
}
else
{
2020-05-05 09:31:11 +08:00
// figure out the best direction based on order in playlist.
int last = getBeatmapSets().AsEnumerable().TakeWhile(b => !b.Equals(current.BeatmapSetInfo)).Count();
2024-07-05 10:55:27 +08:00
int next = getBeatmapSets().AsEnumerable().TakeWhile(b => !b.Equals(newWorking.BeatmapSetInfo)).Count();
2018-04-13 17:19:50 +08:00
direction = last > next ? TrackChangeDirection.Prev : TrackChangeDirection.Next;
}
}
2018-04-13 17:19:50 +08:00
current = newWorking;
if (lastWorking == null || !lastWorking.TryTransferTrack(current))
changeTrack();
TrackChanged?.Invoke(current, direction);
ResetTrackAdjustments();
queuedDirection = null;
// this will be a noop if coming from the beatmapChanged event.
// the exception is local operations like next/prev, where we want to complete loading the track before sending out a change.
if (beatmap.Value != current && beatmap is Bindable<WorkingBeatmap> working)
working.Value = current;
}
private void changeTrack()
{
var queuedTrack = getQueuedTrack();
var lastTrack = CurrentTrack;
lastTrack.Completed -= onTrackCompleted;
CurrentTrack = queuedTrack;
// At this point we may potentially be in an async context from tests. This is extremely dangerous but we have to make do for now.
// CurrentTrack is immediately updated above for situations where a immediate knowledge about the new track is required,
// but the mutation of the hierarchy is scheduled to avoid exceptions.
Schedule(() =>
{
lastTrack.VolumeTo(0, 500, Easing.Out).Expire();
if (queuedTrack == CurrentTrack)
{
AddInternal(queuedTrack);
queuedTrack.VolumeTo(0).Then().VolumeTo(1, 300, Easing.Out);
}
else
{
// If the track has changed since the call to changeTrack, it is safe to dispose the
// queued track rather than consume it.
queuedTrack.Dispose();
}
});
2017-05-01 12:41:22 +08:00
}
2018-04-13 17:19:50 +08:00
private DrawableTrack getQueuedTrack()
{
// Important to keep this in its own method to avoid inadvertently capturing unnecessary variables in the callback.
// Can lead to leaks.
2024-07-05 10:55:27 +08:00
var queuedTrack = new DrawableTrack(current!.LoadTrack());
queuedTrack.Completed += onTrackCompleted;
return queuedTrack;
}
private void onTrackCompleted()
2020-08-05 20:21:08 +08:00
{
if (!CurrentTrack.Looping && !beatmap.Disabled && AllowTrackControl.Value)
2020-08-05 20:21:08 +08:00
NextTrack();
}
private bool applyModTrackAdjustments;
/// <summary>
/// Whether mod track adjustments are allowed to be applied.
/// </summary>
public bool ApplyModTrackAdjustments
{
get => applyModTrackAdjustments;
set
{
if (applyModTrackAdjustments == value)
return;
applyModTrackAdjustments = value;
ResetTrackAdjustments();
}
}
2024-07-05 10:55:27 +08:00
private AudioAdjustments? modTrackAdjustments;
/// <summary>
/// Resets the adjustments currently applied on <see cref="CurrentTrack"/> and applies the mod adjustments if <see cref="ApplyModTrackAdjustments"/> is <c>true</c>.
/// </summary>
/// <remarks>
/// Does not reset any adjustments applied directly to the beatmap track.
/// </remarks>
public void ResetTrackAdjustments()
{
// todo: we probably want a helper method rather than this.
CurrentTrack.RemoveAllAdjustments(AdjustableProperty.Balance);
CurrentTrack.RemoveAllAdjustments(AdjustableProperty.Frequency);
CurrentTrack.RemoveAllAdjustments(AdjustableProperty.Tempo);
CurrentTrack.RemoveAllAdjustments(AdjustableProperty.Volume);
if (applyModTrackAdjustments)
{
CurrentTrack.BindAdjustments(modTrackAdjustments = new AudioAdjustments());
foreach (var mod in mods.Value.OfType<IApplicableToTrack>())
mod.ApplyToTrack(modTrackAdjustments);
}
}
}
public class DuckParameters
{
/// <summary>
/// The duration of the ducking transition in milliseconds.
/// Defaults to 100 ms.
/// </summary>
public double DuckDuration = 100;
/// <summary>
/// The final volume which should be reached during ducking, when 0 is silent and 1 is original volume.
/// Defaults to 25%.
/// </summary>
2024-07-08 12:47:04 +08:00
public double DuckVolumeTo = 0.25;
/// <summary>
/// The low-pass cutoff frequency which should be reached during ducking. If not required, set to <see cref="AudioFilter.MAX_LOWPASS_CUTOFF"/>.
/// Defaults to 300 Hz.
/// </summary>
public int DuckCutoffTo = 300;
/// <summary>
/// The easing curve to be applied during ducking.
/// Defaults to <see cref="Easing.Out"/>.
/// </summary>
public Easing DuckEasing = Easing.Out;
/// <summary>
/// The duration of the restoration transition in milliseconds.
/// Defaults to 500 ms.
/// </summary>
public double RestoreDuration = 500;
/// <summary>
/// The easing curve to be applied during restoration.
/// Defaults to <see cref="Easing.In"/>.
/// </summary>
public Easing RestoreEasing = Easing.In;
}
public enum TrackChangeDirection
{
None,
Next,
Prev
}
2019-10-11 17:41:54 +08:00
2019-10-24 12:10:17 +08:00
public enum PreviousTrackResult
2019-10-11 17:41:54 +08:00
{
None,
Restart,
Previous
}
}