internal void UnPause(float fade)
{
if (isPlaying || advancer == null)
{
return;
}
playbackAction = PlaybackAction.UnPause;
playbackFader.FadeIn(fade);
}
internal void Pause(float fade)
{
if (!isPlaying || advancer == null)
{
return;
}
playbackAction = PlaybackAction.Pause;
playbackFader.FadeOut(fade);
}
private void CheckPlaybackEvents(
int expectedStartedRaised,
int expectedStoppedRaised,
int expectedFinishedRaised,
int expectedRepeatStartedRaised,
PlaybackAction setupPlayback,
PlaybackAction beforeChecks,
PlaybackAction afterChecks)
{
var started = 0;
var stopped = 0;
var finished = 0;
var repeatStarted = 0;
var playbackEvents = new MidiEvent[]
{
new NoteOnEvent(),
new NoteOffEvent
{
DeltaTime = TimeConverter.ConvertFrom(new MetricTimeSpan(0, 0, 1), TempoMap.Default)
}
};
using (var outputDevice = OutputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName))
using (var playback = new Playback(playbackEvents, TempoMap.Default, outputDevice))
{
setupPlayback(null, playback);
playback.Started += (sender, args) => started++;
playback.Stopped += (sender, args) => stopped++;
playback.Finished += (sender, args) => finished++;
playback.RepeatStarted += (sender, args) => repeatStarted++;
playback.Start();
playback.Stop();
playback.Start();
beforeChecks(null, playback);
Assert.IsTrue(
SpinWait.SpinUntil(() => started == expectedStartedRaised && stopped == expectedStoppedRaised && finished == expectedFinishedRaised && repeatStarted == expectedRepeatStartedRaised, TimeSpan.FromSeconds(2)),
"Playback events are raised invalid number of times.");
afterChecks(null, playback);
}
}
private void CheckPlaybackStop(
ICollection <EventToSend> eventsToSend,
ICollection <EventToSend> eventsWillBeSent,
TimeSpan stopAfter,
TimeSpan stopPeriod,
PlaybackAction setupPlayback,
PlaybackAction afterStart,
PlaybackAction afterStop,
PlaybackAction afterResume,
IEnumerable <Tuple <TimeSpan, PlaybackAction> > runningAfterResume = null,
ICollection <TimeSpan> explicitExpectedTimes = null,
double speed = 1.0,
ICollection <ReceivedEvent> expectedReceivedEvents = null,
ICollection <ReceivedEvent> expectedPlayedEvents = null)
{
var playbackContext = new PlaybackContext();
var playedEvents = new List <ReceivedEvent>();
var receivedEvents = playbackContext.ReceivedEvents;
var sentEvents = playbackContext.SentEvents;
var stopwatch = playbackContext.Stopwatch;
var tempoMap = playbackContext.TempoMap;
var eventsForPlayback = GetEventsForPlayback(eventsToSend, tempoMap);
var expectedTimes = playbackContext.ExpectedTimes;
if (explicitExpectedTimes != null || expectedReceivedEvents != null || expectedPlayedEvents != null)
{
expectedTimes.AddRange(explicitExpectedTimes ?? (expectedReceivedEvents?.Select(e => e.Time) ?? expectedPlayedEvents.Select(e => e.Time)));
}
else
{
var currentTime = TimeSpan.Zero;
foreach (var eventWillBeSent in eventsWillBeSent)
{
currentTime += eventWillBeSent.Delay;
var scaledCurrentTime = ScaleTimeSpan(currentTime, 1.0 / speed);
expectedTimes.Add(currentTime > stopAfter ? scaledCurrentTime + stopPeriod : scaledCurrentTime);
}
}
using (var outputDevice = OutputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName))
{
SendReceiveUtilities.WarmUpDevice(outputDevice);
outputDevice.EventSent += (_, e) => sentEvents.Add(new SentEvent(e.Event, stopwatch.Elapsed));
using (var playback = new Playback(eventsForPlayback, tempoMap, outputDevice))
{
playback.Speed = speed;
setupPlayback(playbackContext, playback);
if (expectedPlayedEvents != null)
{
playback.EventPlayed += (_, e) => playedEvents.Add(new ReceivedEvent(e.Event, stopwatch.Elapsed));
}
using (var inputDevice = InputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName))
{
inputDevice.EventReceived += (_, e) =>
{
lock (playbackContext.ReceivedEventsLockObject)
{
receivedEvents.Add(new ReceivedEvent(e.Event, stopwatch.Elapsed));
}
};
inputDevice.StartEventsListening();
stopwatch.Start();
playback.Start();
afterStart(playbackContext, playback);
SpinWait.SpinUntil(() => stopwatch.Elapsed >= stopAfter);
playback.Stop();
afterStop(playbackContext, playback);
Thread.Sleep(stopPeriod);
playback.Start();
afterResume(playbackContext, playback);
if (runningAfterResume != null)
{
foreach (var check in runningAfterResume)
{
Thread.Sleep(check.Item1);
check.Item2(playbackContext, playback);
}
}
var timeout = expectedTimes.Last() + SendReceiveUtilities.MaximumEventSendReceiveDelay;
var areEventsReceived = SpinWait.SpinUntil(() => receivedEvents.Count == expectedTimes.Count, timeout);
Assert.IsTrue(areEventsReceived, $"Events are not received for timeout {timeout}.");
stopwatch.Stop();
var playbackStopped = SpinWait.SpinUntil(() => !playback.IsRunning, SendReceiveUtilities.MaximumEventSendReceiveDelay);
Assert.IsTrue(playbackStopped, "Playback is running after completed.");
}
}
}
CompareSentReceivedEvents(sentEvents, receivedEvents, expectedTimes);
if (expectedReceivedEvents != null)
{
CompareReceivedEvents(receivedEvents, expectedReceivedEvents.ToList());
}
if (expectedPlayedEvents != null)
{
CompareReceivedEvents(playedEvents, expectedPlayedEvents.ToList());
}
}
private void CheckPlayback(
ICollection <EventToSend> eventsToSend,
double speed,
PlaybackAction beforePlaybackStarted,
PlaybackAction startPlayback,
PlaybackAction afterPlaybackStarted,
PlaybackAction waiting,
PlaybackAction finalChecks,
CreateTickGeneratorCallback createTickGeneratorCallback = null)
{
var playbackContext = new PlaybackContext();
var receivedEvents = playbackContext.ReceivedEvents;
var sentEvents = playbackContext.SentEvents;
var stopwatch = playbackContext.Stopwatch;
var tempoMap = playbackContext.TempoMap;
var eventsForPlayback = new List <MidiEvent>();
var expectedTimes = playbackContext.ExpectedTimes;
var currentTime = TimeSpan.Zero;
foreach (var eventToSend in eventsToSend.Where(e => !(e.Event is MetaEvent)))
{
var midiEvent = eventToSend.Event.Clone();
midiEvent.DeltaTime = LengthConverter.ConvertFrom((MetricTimeSpan)eventToSend.Delay, (MetricTimeSpan)currentTime, tempoMap);
currentTime += eventToSend.Delay;
eventsForPlayback.Add(midiEvent);
expectedTimes.Add(TimeSpan.FromTicks(MathUtilities.RoundToLong(currentTime.Ticks / speed)));
}
using (var outputDevice = OutputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName))
{
SendReceiveUtilities.WarmUpDevice(outputDevice);
outputDevice.EventSent += (_, e) => sentEvents.Add(new SentEvent(e.Event, stopwatch.Elapsed));
var clockSettings = createTickGeneratorCallback != null
? new MidiClockSettings {
CreateTickGeneratorCallback = createTickGeneratorCallback
}
: null;
using (var playback = new Playback(eventsForPlayback, tempoMap, outputDevice, clockSettings))
{
playback.Speed = speed;
beforePlaybackStarted(playbackContext, playback);
using (var inputDevice = InputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName))
{
inputDevice.EventReceived += (_, e) =>
{
lock (playbackContext.ReceivedEventsLockObject)
{
receivedEvents.Add(new ReceivedEvent(e.Event, stopwatch.Elapsed));
}
};
inputDevice.StartEventsListening();
stopwatch.Start();
startPlayback(playbackContext, playback);
afterPlaybackStarted(playbackContext, playback);
waiting(playbackContext, playback);
stopwatch.Stop();
finalChecks(playbackContext, playback);
}
}
}
CompareSentReceivedEvents(sentEvents.Take(expectedTimes.Count).ToList(), receivedEvents.Take(expectedTimes.Count).ToList(), expectedTimes);
}
private static string stringify(PlaybackAction action, Sound sound)
{
return action.ToString() + " " + sound.ToString();
}
public PlaybackEvent(object source, PlaybackAction action, Sound sound)
: base(source, PlaybackEvent.stringify(action, sound))
{
this._action = action;
this._sound = sound;
}
