public PlaybackStatus Create(Guid id)
{
PlaybackStatus mine = new PlaybackStatus();
mine.Id = id;
return(mine);
}
public void Update(Track track, PlaybackStatus status)
{
string activity = string.Empty;
string state = string.Empty;
switch (status)
{
case PlaybackStatus.Playing:
activity = "play";
state = $"by {track.Artist}";
break;
case PlaybackStatus.Paused:
activity = "pause";
state = "Paused";
break;
case PlaybackStatus.Stopped:
activity = "idle";
state = "Idle";
break;
}
client?.SetPresence(new RichPresence
{
Details = TruncateBytes(track.Title, 120),
State = TruncateBytes(state, 120),
Assets = new Assets
{
LargeImageKey = "icon",
SmallImageKey = activity
},
Timestamps = Timestamps.Now
});
}
private void OnStatusUpdateReceived(PlaybackStatus status)
{
if (StatusUpdateReceived != null)
{
StatusUpdateReceived(status);
}
}
public async void Update(IMetadataProvider track, PlaybackStatus status)
{
smtc.PlaybackStatus = (MediaPlaybackStatus)status;
var updater = smtc.DisplayUpdater;
updater.Type = MediaPlaybackType.Music;
updater.MusicProperties.Artist = string.Join(", ", track.Artists);
updater.MusicProperties.AlbumTitle = track.Album;
updater.MusicProperties.TrackNumber = (uint)track.TrackNumber;
updater.MusicProperties.AlbumTrackCount = (uint)track.TrackTotal;
if (track.CoverArt != null)
{
var decoder = await BitmapDecoder.CreateAsync(new MemoryStream(track.CoverArt).AsRandomAccessStream());
var transcodedImage = new InMemoryRandomAccessStream();
BitmapEncoder encoder = await BitmapEncoder.CreateForTranscodingAsync(transcodedImage, decoder);
await encoder.FlushAsync();
transcodedImage.Seek(0);
updater.Thumbnail = RandomAccessStreamReference.CreateFromStream(transcodedImage);
}
else
{
updater.Thumbnail = null;
}
updater.MusicProperties.Title = track.Title;
updater.Update();
}
//function for the thread that interrupts a playback sequence.
private void abortWrapper()
{
//block until the macro is hit, then set flags to stop the interpreter.
raController.interruptInterpreterSequence(macroVKs);
//clean up
isPlayingBack = false;
status = PlaybackStatus.Nothing;
}
private void Pause()
{
if (playbackStatus == PlaybackStatus.Playing)
{
wavePlayer.Pause();
playbackStatus = PlaybackStatus.Paused;
}
}
public void PlayPrepare(string fileName)
{
try
{
var filePath = _Storage.GetPath(fileName);
var url = NSUrl.FromFilename(filePath);
if (_Player == null)
{
_Player = new AVPlayer();
}
if (_PlayerItem != null)
{
_Player.RemoveTimeObserver(_TimeChanged); // for skipping 1-2 extra triggering for new item creation code below
CleanPlayerItem();
}
PlayerReady = false;
_Asset = AVAsset.FromUrl(url);
_PlayerItem = new AVPlayerItem(_Asset);
_PlayerItem.AddObserver(this, _status, NSKeyValueObservingOptions.Initial | NSKeyValueObservingOptions.New, _Player.Handle);
_PlayerItem.AddObserver(this, _error, NSKeyValueObservingOptions.Initial | NSKeyValueObservingOptions.New, _Player.Handle);
_Player.ReplaceCurrentItemWithPlayerItem(_PlayerItem);
_Player.Rate = 1;
_Player.Pause(); // HACK: stop autoplaying after recording
_TimeChanged = _Player.AddPeriodicTimeObserver(new CMTime(1, 1), DispatchQueue.MainQueue, time => {
// skip restart event
if (_isRestart)
{
_isRestart = false;
return;
}
if (_PlayerItem != null && _PlayerItem.Duration != CMTime.Indefinite)
{
var stopped = time == _PlayerItem.Duration;
PlaybackStatus?.Invoke(this, new PlaybackEventArgs {
CurrentTime = time.Seconds,
Duration = _PlayerItem.Duration.Seconds,
Stopped = stopped
});
if (stopped)
{
_isRestart = true;
_Player.Seek(CMTime.Zero);
}
}
});
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(string.Format("*** AudioService.PlayPrepare - Exception: {0}", ex));
}
}
protected override void WndProc(ref Message m)
{
if (m.Msg == WinmmHook.WM_USER + 1)
{
PlaybackStatus status = (PlaybackStatus)(int)m.WParam;
playbackUpdate(status);
}
base.WndProc(ref m);
}
private void PlaybackMediaEnded(MediaPlayer sender, object args)
{
_playbackTimer.Stop();
PlaybackStatus?.Invoke(this, new PlaybackEventArgs {
Stopped = true,
CurrentTime = sender.PlaybackSession.NaturalDuration.TotalSeconds,
Duration = sender.PlaybackSession.NaturalDuration.TotalSeconds
});
}
public PlaybackForm(RAController rac)
{
raController = rac;
InitializeComponent();
speed = 1;
loops = 1;
status = PlaybackStatus.Nothing;
this.Show();
this.Hide();
}
public void TestWatchedIsFiredCorrectly()
{
var stat = new PlaybackStatus();
stat.WasPlayedChanged += new EventHandler <EventArgs>(stat_OnWatchedChanged);
played = stat.WasPlayed;
stat.PlayCount = 1;
Assert.IsTrue(played);
stat.PlayCount = 0;
Assert.IsFalse(played);
}
private void UpdateCans()
{
PlaybackStatus playbackStatus = this._statusSubject.Value;
this._canLoadSubject.OnNext(PlaybackStatusHelper.LoadablePlaybackStatuses.Contains(playbackStatus));
this._canPlaySubject.OnNext(PlaybackStatusHelper.PlayablePlaybackStatuses.Contains(playbackStatus));
this._canPauseSubject.OnNext(PlaybackStatusHelper.PausablePlaybackStatuses.Contains(playbackStatus));
this._canResumeSubject.OnNext(PlaybackStatusHelper.ResumablePlaybackStatuses.Contains(playbackStatus));
this._canStopSubject.OnNext(PlaybackStatusHelper.StoppablePlaybackStatuses.Contains(playbackStatus));
this._canSeekSubject.OnNext(PlaybackStatusHelper.SeekablePlaybackStatuses.Contains(playbackStatus));
}
/// <summary>
/// Called when [media state changed].
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="oldValue">The old value.</param>
/// <param name="newValue">The new value.</param>
public void OnMediaStateChanged(MediaEngine sender, PlaybackStatus oldValue, PlaybackStatus newValue)
{
if (Parent == null)
{
return;
}
Parent?.PostMediaStateChangedEvent(
(System.Windows.Controls.MediaState)oldValue,
(System.Windows.Controls.MediaState)newValue);
}
public void SetIntegrations(PlaybackStatus status)
{
if (Environment.OSVersion.Version.Major >= 10 && App.Config.IntegrateSMTC)
{
smtcIntegration?.Update(CurrentTrack, status);
}
if (App.Config.IntegrateDiscordRPC)
{
discordIntegration?.Update(CurrentTrack, status);
}
}
private void PlaybackMediaOpened(MediaPlayer sender, object args)
{
PlayerReady = true;
PlaybackStatus?.Invoke(this, new PlaybackEventArgs {
Stopped = true,
CurrentTime = 0,
Duration = sender.PlaybackSession.NaturalDuration.TotalSeconds,
IsNew = true
});
PlayerStatus?.Invoke(this, new EventArgs());
}
private void UpdateCans()
{
PlaybackStatus playbackStatus = this._statusSubject.Value;
this._canLoadSubject.OnNext(PlaybackStatusHelper.CanLoadPlaybackStatuses.Contains(playbackStatus));
this._canPlaySubject.OnNext(PlaybackStatusHelper.CanPlayPlaybackStatuses.Contains(playbackStatus));
this._canPauseSubject.OnNext(PlaybackStatusHelper.CanPausePlaybackStatuses.Contains(playbackStatus));
this._canResumeSubject.OnNext(PlaybackStatusHelper.CanResumePlaybackStatuses.Contains(playbackStatus));
this._canStopSubject.OnNext(PlaybackStatusHelper.CanStopPlaybackStatuses.Contains(playbackStatus));
this._canSeekSubject.OnNext(PlaybackStatusHelper.CanSeekPlaybackStatuses.Contains(playbackStatus));
}
public void Init(string path)
{
sinfo = new StreamInfo(path);
_mixer = new WaveMixerStream32();
_mixer.AddInputStream(sinfo.Stream);
_wavePlayer = new WaveOut();
_wavePlayer.Init(_mixer);
_mixer.AutoStop = false;
_skipSeconds = 3;
Status = PlaybackStatus.Stopped;
}
private void PlaybackMediaFailed(MediaPlayer sender, MediaPlayerFailedEventArgs args)
{
_playbackTimer.Stop();
PlayerReady = false;
PlaybackStatus?.Invoke(this, new PlaybackEventArgs {
Stopped = true,
Duration = 0,
CurrentTime = 0,
HasError = true
});
}
public void Update(Track track, PlaybackStatus status)
{
smtc.PlaybackStatus = (MediaPlaybackStatus)status;
var updater = smtc.DisplayUpdater;
updater.Type = MediaPlaybackType.Music;
updater.MusicProperties.Artist = track.Artist;
updater.MusicProperties.AlbumArtist = track.AlbumArtist;
updater.MusicProperties.Title = track.Title;
updater.Update();
}
public void Stop()
{
if (Status != PlaybackStatus.Stopped)
{
if (_wavePlayer != null)
{
_wavePlayer.Stop();
_mixer.CurrentTime = TimeSpan.Zero;
Status = PlaybackStatus.Stopped;
}
}
}
private void PlaybackStateChanged(MediaPlayer sender, object args)
{
if (!PlayerReady)
{
return;
}
PlaybackStatus.Invoke(this, new PlaybackEventArgs {
Stopped = sender.PlaybackSession.PlaybackState != MediaPlaybackState.Playing && sender.PlaybackSession.PlaybackState != MediaPlaybackState.Paused,
CurrentTime = sender.PlaybackSession.Position.TotalSeconds,
Duration = sender.PlaybackSession.NaturalDuration.TotalSeconds
});
}
private void Stop()
{
if (playbackStatus != PlaybackStatus.Stopped)
{
if (wavePlayer != null)
{
wavePlayer.Stop();
playbackStatus = PlaybackStatus.Stopped;
timer1.Stop();
}
Rewind();
}
}
/// <summary>
/// Called when [media state changed].
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="oldValue">The old value.</param>
/// <param name="newValue">The new value.</param>
public void OnMediaStateChanged(MediaEngine sender, PlaybackStatus oldValue, PlaybackStatus newValue)
{
if (Parent == null)
{
return;
}
// Force a reportable position when the media state changes
Parent.ReportablePosition = sender.State.Position;
Parent?.PostMediaStateChangedEvent(
(System.Windows.Controls.MediaState)oldValue,
(System.Windows.Controls.MediaState)newValue);
}
/// <summary>
/// Called when [media state changed].
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="oldValue">The old value.</param>
/// <param name="newValue">The new value.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public Task OnMediaStateChanged(MediaEngine sender, PlaybackStatus oldValue, PlaybackStatus newValue)
{
if (Parent == null)
{
return(Task.CompletedTask);
}
// Force a reportable position when the media state changes
Parent.ReportablePosition = sender.State.Position;
return(Parent.RaiseMediaStateChangedEvent(
(System.Windows.Controls.MediaState)oldValue,
(System.Windows.Controls.MediaState)newValue));
}
public void Play(PlaybackStatus playstate, bool resume)
{
this.PlayState = playstate;
this.Prepare(resume);
if (this is PlayableCollection && (this.PlayableItems == null || this.PlayableItems.Count() < 1))
{
Microsoft.MediaCenter.MediaCenterEnvironment ev = Microsoft.MediaCenter.Hosting.AddInHost.Current.MediaCenterEnvironment;
ev.Dialog(Application.CurrentInstance.StringData("NoContentDial"), Application.CurrentInstance.StringData("Playstr"), Microsoft.MediaCenter.DialogButtons.Ok, 500, true);
}
else
{
PlayInternal(resume);
}
}
internal void OnPlayStateSaved(BaseItem media, PlaybackStatus playstate)
{
// Fire off event in async so we don't tie anything up
if (_PlayStateSaved != null)
{
Async.Queue("OnPlayStateSaved", () =>
{
_PlayStateSaved(this, new PlayStateSaveEventArgs()
{
PlaybackStatus = playstate, Item = media
});
});
}
}
internal void EnsurePlayStateChangesBoundToUI()
{
if (playstate == null)
{
Media media = baseItem as Media;
if (media != null)
{
playstate = media.PlaybackStatus;
// if we want any chance to reclaim memory we are going to have to use
// weak event handlers
playstate.WasPlayedChanged += new EventHandler <EventArgs>(PlaybackStatusPlayedChanged);
PlaybackStatusPlayedChanged(this, null);
}
}
}
private void Play()
{
if (playbackStatus != PlaybackStatus.Playing)
{
if (playbackStatus != PlaybackStatus.Paused)
{
Rewind();
}
if (wavePlayer == null)
{
wavePlayer = new WaveOut();
wavePlayer.Init(mixer);
}
wavePlayer.Play();
playbackStatus = PlaybackStatus.Playing;
timer1.Start();
}
}
protected override void InternalStatusChange(PlaybackStatus oldStatus, PlaybackStatus newStatus)
{
switch (newStatus)
{
case PlaybackStatus.NotPlaying:
_playWait.Reset();
break;
case PlaybackStatus.Paused when oldStatus == PlaybackStatus.Playing:
_playWait.Reset();
_layerContext.Stop();
break;
case PlaybackStatus.Playing:
_playWait.Set();
break;
}
}
public void Forward()
{
if (_mixer == null)
{
return;
}
if (Status == PlaybackStatus.Playing)
{
_mixer.CurrentTime += TimeSpan.FromSeconds(_skipSeconds);
}
if (_mixer.CurrentTime < _mixer.TotalTime)
{
return;
}
_wavePlayer.Stop();
_mixer.CurrentTime = TimeSpan.Zero;
Status = PlaybackStatus.Stopped;
}
public void ChangePlaybackStatus(PlaybackStatus playing)
{
_trackHandler.ChangePlaybackStatus(playing);
}
private void Pause()
{
if (playbackStatus == PlaybackStatus.Playing)
{
wavePlayer.Pause();
playbackStatus = PlaybackStatus.Paused;
}
}
public PlaybackStatusEventArgs(PlaybackStatus status)
{
this.status = status;
}
private void Play()
{
if (playbackStatus != PlaybackStatus.Playing)
{
if (playbackStatus != PlaybackStatus.Paused)
{
Rewind();
}
if (wavePlayer == null)
{
wavePlayer = new WaveOut();
wavePlayer.Init(mixer);
}
wavePlayer.Play();
playbackStatus = PlaybackStatus.Playing;
timer1.Start();
}
}
/*
================== UI Update Helpers ====================
*/
public void playbackUpdate(PlaybackStatus update)
{
System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Mixer));
switch (update) {
case PlaybackStatus.Playing:
btnPlay.Enabled = true;
btnPlay.Image = Comp3931_Project_JoePelz.Properties.Resources.btnPause;
btnStop.Enabled = true;
btnStop.Image = Comp3931_Project_JoePelz.Properties.Resources.btnStop;
btnRecord.Enabled = false;
btnRecord.Image = Comp3931_Project_JoePelz.Properties.Resources.btnRecordDisabled;
btnNew.Enabled = false;
btnNew.Image = Comp3931_Project_JoePelz.Properties.Resources.btnNewDisabled;
btnOpen.Enabled = false;
btnOpen.Image = Comp3931_Project_JoePelz.Properties.Resources.btnOpenDisabled;
btnSave.Enabled = false;
btnSave.Image = Comp3931_Project_JoePelz.Properties.Resources.btnSaveDisabled;
break;
case PlaybackStatus.Paused:
btnPlay.Image = Comp3931_Project_JoePelz.Properties.Resources.btnPlay;
break;
case PlaybackStatus.Recording:
btnPlay.Enabled = false;
btnPlay.Image = Comp3931_Project_JoePelz.Properties.Resources.btnPlayDisabled;
btnStop.Enabled = false;
btnStop.Image = Comp3931_Project_JoePelz.Properties.Resources.btnStopDisabled;
btnRecord.Enabled = true;
btnRecord.Image = Comp3931_Project_JoePelz.Properties.Resources.btnRecord;
btnNew.Enabled = false;
btnNew.Image = Comp3931_Project_JoePelz.Properties.Resources.btnNewDisabled;
btnOpen.Enabled = false;
btnOpen.Image = Comp3931_Project_JoePelz.Properties.Resources.btnOpenDisabled;
btnSave.Enabled = false;
btnSave.Image = Comp3931_Project_JoePelz.Properties.Resources.btnSaveDisabled;
break;
case PlaybackStatus.Stopped:
btnPlay.Enabled = true;
btnPlay.Image = Comp3931_Project_JoePelz.Properties.Resources.btnPlay;
btnStop.Enabled = true;
btnStop.Image = Comp3931_Project_JoePelz.Properties.Resources.btnStop;
btnRecord.Enabled = true;
btnRecord.Image = Comp3931_Project_JoePelz.Properties.Resources.btnRecord;
btnNew.Enabled = true;
btnNew.Image = Comp3931_Project_JoePelz.Properties.Resources.btnNew;
btnOpen.Enabled = true;
btnOpen.Image = Comp3931_Project_JoePelz.Properties.Resources.btnOpen;
btnSave.Enabled = true;
btnSave.Image = Comp3931_Project_JoePelz.Properties.Resources.btnSave;
break;
case PlaybackStatus.Disabled:
btnPlay.Enabled = false;
btnPlay.Image = Comp3931_Project_JoePelz.Properties.Resources.btnPlayDisabled;
btnStop.Enabled = true;
btnStop.Image = Comp3931_Project_JoePelz.Properties.Resources.btnStop;
btnRecord.Enabled = true;
btnRecord.Image = Comp3931_Project_JoePelz.Properties.Resources.btnRecord;
btnNew.Enabled = true;
btnNew.Image = Comp3931_Project_JoePelz.Properties.Resources.btnNew;
btnOpen.Enabled = true;
btnOpen.Image = Comp3931_Project_JoePelz.Properties.Resources.btnOpen;
btnSave.Enabled = true;
btnSave.Image = Comp3931_Project_JoePelz.Properties.Resources.btnSave;
break;
}
}
private void Stop()
{
if (playbackStatus != PlaybackStatus.Stopped)
{
if (wavePlayer != null)
{
wavePlayer.Stop();
playbackStatus = PlaybackStatus.Stopped;
timer1.Stop();
}
Rewind();
}
}
public void SetPlaybackStatus(PlaybackStatus playbackStatus)
{
switch (playbackStatus)
{
case PlaybackStatus.Playing:
_spotifyWrapper.Play(true);
break;
case PlaybackStatus.Paused:
_spotifyWrapper.Play(false);
break;
}
}
