public TrackInformationWindow(PlayableBase track)
{
this.CurrentTrack = track;
InitializeComponent();
if (!CurrentTrack.IsOpened)
{
CurrentTrack.Load();
if (CurrentTrack.Image == null)
{
CurrentTrack.ImageLoadedComplete +=
(s, e) => { if (CurrentTrack.Image != null)
{
Dispatcher.Invoke(() => image = CurrentTrack.Image.Clone());
}
};
return;
}
}
if (CurrentTrack.Image != null)
{
image = CurrentTrack.Image.Clone();
}
}
protected void ShowNotification(PlayableBase track, NotificationType type)
{
ConfigSettings config = HurricaneSettings.Instance.Config;
if (config.Notification == NotificationType.None)
{
return;
}
if (_lastwindow != null && _lastwindow.Visibility == Visibility.Visible)
{
_lastwindow.Close();
}
TimeSpan timetostayopen = TimeSpan.FromMilliseconds(config.NotificationShowTime);
Window messagewindow;
switch (type)
{
case NotificationType.Top:
messagewindow = new NotificationTopWindow(track, timetostayopen);
break;
case NotificationType.RightBottom:
messagewindow = new NotificationRightBottomWindow(track, timetostayopen);
break;
default:
return;
}
messagewindow.Show();
_lastwindow = messagewindow;
}
public PlayableBase GetRandomTrack(PlayableBase currentTrack)
{
if (Tracks.Count == 0)
{
return(null);
}
if (ShuffleList.Count == 0)
{
CreateShuffleList();
}
bool hasrefreshed = false;
while (true)
{
int i = _random.Next(0, ShuffleList.Count);
var track = ShuffleList[i];
if (track != currentTrack && track.TrackExists)
{
RemoveFromShuffleList(track);
return(track);
}
RemoveFromShuffleList(track);
if (ShuffleList.Count == 0)
{
if (hasrefreshed)
{
return(null);
}
CreateShuffleList();
hasrefreshed = true;
}
}
}
public void AddTrack(PlayableBase track, IPlaylist playlist)
{
Add(new TrackRepresenter(track));
TrackPlaylists.Add(new TrackPlaylistPair(track, playlist));
track.QueueId = (IndexOf(GetTrackRepresenter(track)) + 1).ToString();
RefreshDuration();
}
public TrackInformationWindow(PlayableBase track)
{
CurrentTrack = track;
if (CurrentTrack.StartTime == 0 && CurrentTrack.EndTime == 0)
{
StartTime = 0;
EndTime = Math.Round(CurrentTrack.DurationTimespan.TotalMilliseconds, 0);
}
else
{
StartTime = CurrentTrack.StartTime;
EndTime = CurrentTrack.EndTime;
}
MaximumTime = Math.Round(CurrentTrack.DurationTimespan.TotalMilliseconds, 0);
InitializeComponent();
if (!CurrentTrack.IsOpened)
{
CurrentTrack.Load();
if (CurrentTrack.Image == null)
{
CurrentTrack.ImageLoadedComplete +=
(s, e) => { if (CurrentTrack.Image != null) Dispatcher.Invoke(() => _image = CurrentTrack.Image.Clone()); };
return;
}
}
if (CurrentTrack.Image != null) _image = CurrentTrack.Image.Clone();
}
private async Task <Result> SetSoundSource(PlayableBase track)
{
if (_cts != null)
{
_cts.Cancel();
}
_cts = new CancellationTokenSource();
var token = _cts.Token;
IWaveSource result;
try
{
result = await track.GetSoundSource();
if (token.IsCancellationRequested)
{
result.Dispose();
return(new Result(State.False));
}
}
catch (Exception ex)
{
if (token.IsCancellationRequested)
{
return(new Result(State.False));
}
return(new Result(State.Exception, ex));
}
SoundSource = result;
return(new Result(State.True));
}
public async Task <IPlayable> SearchTrack(string artist, string title)
{
PlayableBase result = null;
var sw = Stopwatch.StartNew();
foreach (var track in Tracks.Tracks)
{
if (track.Title.IndexOf(title.Trim(), StringComparison.OrdinalIgnoreCase) > -1 && !string.IsNullOrEmpty(track.Artist?.Name) &&
LevenshteinDistance.Compute(artist.ToLower(), track.Artist.Name.ToLower()) <=
Math.Abs(artist.Length - track.Artist.Name.Length))
{
result = track;
break;
}
}
Debug.Print($"Search track in local collection: {sw.ElapsedMilliseconds} ms");
if (result != null)
{
return(result);
}
return
(await
MusicStreamingPluginManager.DefaultMusicStreaming.GetTrack(
$"{artist} - {title}"));
}
public async override void RemoveTrack(PlayableBase track)
{
base.RemoveTrack(track);
ShuffleList.Remove(track);
track.IsRemoving = true;
await Task.Delay(500);
if (!track.TrackExists)
{
for (var i = 0; i < Tracks.Count; i++)
{
if (Tracks[i].AuthenticationCode != track.AuthenticationCode)
{
continue;
}
Tracks.RemoveAt(i);
break;
}
}
else
{
Tracks.Remove(track);
}
track.IsRemoving = false; //The track could be also in another playlist
}
public async Task <IPlayable> SearchTrack(Artist artist, string title)
{
PlayableBase result = null;
var sw = Stopwatch.StartNew();
foreach (var track in Tracks.Tracks.Where(x => x.Artist == artist))
{
if (track.Title.IndexOf(title, StringComparison.OrdinalIgnoreCase) > -1)
{
result = track;
break;
}
}
Debug.Print($"Search track in local collection: {sw.ElapsedMilliseconds} ms");
if (result != null)
{
return(result);
}
return
(await
MusicStreamingPluginManager.DefaultMusicStreaming.GetTrack(
$"{artist} - {title}"));
}
protected string TrackToString(PlayableBase track)
{
return(JsonConvert.SerializeObject(new ShortTrack()
{
Title = track.Title, Artist = track.Artist, Album = track.Album, Duration = track.Duration, kbps = track.kbps.ToString(), kHz = track.kHz.ToString()
}));
}
public Task AddTrack(PlayableBase track)
{
track.Guid = Guid.NewGuid();
Collection.Add(track.Guid, track);
Tracks.Add(track);
_imageProvider.AddImage(track.Cover);
using (
var command =
new SQLiteCommand(
"INSERT INTO `Tracks` (Title, ArtistGuid, AlbumGuid, Guid, LastTimePlayed, MusicBrainzId, Duration, Cover, XmlData) VALUES (@title, @artistGuid, @albumGuid, @guid, @lastTimePlayed, @musicBrainzId, @duration, @cover, @xmlData)",
_connection))
{
command.Parameters.AddWithValue("@title", track.Title);
command.Parameters.AddGuid("@artistGuid", track.Artist.Guid);
command.Parameters.AddGuid("@albumGuid", track.Album?.Guid);
command.Parameters.AddGuid("@guid", track.Guid);
command.Parameters.AddWithValue("@lastTimePlayed", track.LastTimePlayed.ToString("yyyy-MM-dd HH:mm:ss"));
command.Parameters.AddWithValue("@musicBrainzId", track.MusicBrainzId);
command.Parameters.AddWithValue("@duration", XmlConvert.ToString(track.Duration));
command.Parameters.AddGuid("@cover", track.Cover?.Guid);
using (var stringWriter = new StringWriter())
{
_serializer.Serialize(stringWriter, track);
command.Parameters.AddWithValue("@xmlData", stringWriter.ToString());
}
return(command.ExecuteNonQueryAsync());
}
}
private async Task <SoundCloudWebTrackResult> GetSoundCloudTrack(string url)
{
using (var web = new WebClient {
Proxy = null
})
{
try
{
var result = JsonConvert.DeserializeObject <ApiResult>(await web.DownloadStringTaskAsync(string.Format("http://api.soundcloud.com/resolve.json?url={0}&client_id={1}", url, SensitiveInformation.SoundCloudKey)));
return(new SoundCloudWebTrackResult
{
Duration = TimeSpan.FromMilliseconds(result.duration),
Year = result.release_year != null?uint.Parse(result.release_year.ToString()) : (uint)DateTime.Parse(result.created_at).Year,
Title = result.title,
Uploader = result.user.username,
Result = result,
Views = (uint)result.playback_count,
ImageUrl = result.artwork_url,
Url = result.permalink_url,
Genres = new List <Genre>
{
PlayableBase.StringToGenre(result.genre)
},
Description = result.description
});
}
catch (Exception)
{
return(null);
}
}
}
protected void RemoveFromShuffleList(PlayableBase track)
{
ShuffleList.Remove(track);
if (_addedFavoriteTracksTwoTimes)
{
ShuffleList.Remove(track);
}
}
void TrackChanged(PlayableBase newtrack)
{
ConfigSettings config = HurricaneSettings.Instance.Config;
if (config.DisableNotificationInGame && WindowHelper.WindowIsFullscreen(UnsafeNativeMethods.GetForegroundWindow())) return;
ShowNotification(newtrack, config.Notification);
_lasttrack = newtrack;
}
public static async Task<BitmapImage> LoadCoverFromWeb(PlayableBase track, DirectoryInfo di, bool useArtist = true)
{
var config = HurricaneSettings.Instance.Config;
if (config.SaveCoverLocal)
{
if (!di.Exists) di.Create();
}
return await LastfmApi.GetImage(config.DownloadAlbumCoverQuality, config.SaveCoverLocal, di, track, config.TrimTrackname, useArtist);
}
public Task RemoveTrack(PlayableBase track)
{
Collection.Remove(track.Guid);
Tracks.Remove(track);
using (var command = new SQLiteCommand("DELETE FROM `Tracks` WHERE Guid=@guid", _connection))
{
command.Parameters.AddGuid("@guid", track.Guid);
return(command.ExecuteNonQueryAsync());
}
}
public Task UpdateLastTimePlayed(PlayableBase track, DateTime newLastTimePlayed)
{
track.LastTimePlayed = newLastTimePlayed;
using (var command = new SQLiteCommand("UPDATE `Tracks` SET LastTimePlayed=@newLastTimePlayed WHERE Guid=@guid", _connection))
{
command.Parameters.AddWithValue("@newLastTimePlayed", newLastTimePlayed.ToString("yyyy-MM-dd HH:mm:ss"));
command.Parameters.AddGuid("@guid", track.Guid);
return(command.ExecuteNonQueryAsync());
}
}
void TrackChanged(PlayableBase newtrack)
{
ConfigSettings config = HurricaneSettings.Instance.Config;
if (config.DisableNotificationInGame && WindowHelper.WindowIsFullscreen(UnsafeNativeMethods.GetForegroundWindow()))
{
return;
}
ShowNotification(newtrack, config.Notification);
_lasttrack = newtrack;
}
public void RemoveMissingTracks()
{
for (int i = Tracks.Count - 1; i > -1; i--)
{
PlayableBase t = Tracks[i];
if (!t.TrackExists)
{
RemoveTrack(t);
}
}
OnTrackListChanged();
}
public async void LoadFromSettings()
{
HurricaneSettings settings = HurricaneSettings.Instance;
Playlists = settings.Playlists.Playlists;
var currentState = settings.CurrentState;
CSCoreEngine.EqualizerSettings = currentState.EqualizerSettings;
CSCoreEngine.EqualizerSettings.Loaded();
CSCoreEngine.Volume = currentState.Volume;
DownloadManager = settings.Config.Downloader;
favoritePlaylist = new FavoriteList();
favoritePlaylist.Initalize(this.Playlists);
if (currentState.LastPlaylistIndex > -10)
{
CurrentPlaylist = IndexToPlaylist(currentState.LastPlaylistIndex);
}
SelectedPlaylist = IndexToPlaylist(currentState.SelectedPlaylist);
if (currentState.SelectedTrack > -1 && currentState.SelectedTrack < SelectedPlaylist.Tracks.Count)
{
SelectedTrack = SelectedPlaylist.Tracks[currentState.SelectedTrack];
}
IsLoopEnabled = currentState.IsLoopEnabled;
IsShuffleEnabled = currentState.IsShuffleEnabled;
foreach (NormalPlaylist lst in Playlists)
{
lst.LoadList();
}
favoritePlaylist.LoadList();
if (currentState.Queue != null)
{
Queue = currentState.Queue; Queue.Initialize(Playlists);
}
if (currentState.LastTrackIndex > -1 && currentState.LastTrackIndex < SelectedPlaylist.Tracks.Count)
{
PlayableBase t = CurrentPlaylist.Tracks[currentState.LastTrackIndex];
if (t.TrackExists && currentState.TrackPosition >= 0)
{
await CSCoreEngine.OpenTrack(t);
CSCoreEngine.Position = currentState.TrackPosition;
CSCoreEngine.OnPropertyChanged("Position");
}
}
AsyncTrackLoader.Instance.RunAsync(Playlists.ToList());
}
public Tuple <PlayableBase, IPlaylist> PlayNextTrack()
{
if (!HasTracks)
{
return(null);
}
PlayableBase nexttrack = this.First().Track;
var result = Tuple.Create(nexttrack, TrackPlaylists.First(x => x.Track == nexttrack).Playlist);
RemoveTrack(nexttrack);
return(result);
}
public static async Task <BitmapImage> LoadCoverFromWeb(PlayableBase track, DirectoryInfo di, bool useArtist = true)
{
var config = AnyListenSettings.Instance.Config;
if (config.SaveCoverLocal)
{
if (!di.Exists)
{
di.Create();
}
}
return(null);
}
private async void Playlist_TrackAdded(object sender, PlayableBase e)
{
using (
var command =
new SQLiteCommand(
"INSERT INTO `PlaylistTracks` (PlaylistId, TrackId) VALUES (@playlistId, @trackId)", _connection)
)
{
command.Parameters.AddGuid("@playlistId", ((UserPlaylist)sender).Id);
command.Parameters.AddGuid("@trackId", e.Guid);
await command.ExecuteNonQueryAsync();
}
}
public static async Task <BitmapImage> LoadCoverFromWeb(PlayableBase track, DirectoryInfo di, bool useArtist = true)
{
var config = HurricaneSettings.Instance.Config;
if (config.SaveCoverLocal)
{
if (!di.Exists)
{
di.Create();
}
}
return(await LastfmAPI.GetImage(config.DownloadAlbumCoverQuality, config.SaveCoverLocal, di, track, config.TrimTrackname, useArtist));
}
private async void Playlist_TrackRemoved(object sender, PlayableBase e)
{
using (
var command =
new SQLiteCommand(
"DELETE FROM `PlaylistTracks` WHERE PlaylistId=@playlistId AND TrackId=@trackId", _connection)
)
{
command.Parameters.AddGuid("@playlistId", ((UserPlaylist)sender).Id);
command.Parameters.AddGuid("@trackId", e.Guid);
await command.ExecuteNonQueryAsync();
}
}
public void Test(NotificationType type)
{
PlayableBase trackToUse = _lasttrack ?? new LocalTrack
{
Artist = "Alkaline",
Title = "Sample Track",
Duration = "03:26",
kHz = 44,
Path = Assembly.GetExecutingAssembly().Location,
Extension = "MP3"
};
ShowNotification(trackToUse, type);
}
public void RemoveTrack(PlayableBase track)
{
var trackrepresentertoremove = GetTrackRepresenter(track);
if (trackrepresentertoremove == null)
{
return;
}
Remove(trackrepresentertoremove);
TrackPlaylists.Remove(TrackPlaylists.First(x => x.Track == track));
track.QueueId = null;
RefreshQueuePositionIds();
RefreshDuration();
}
public async void PlayTrack(PlayableBase track, IPlaylist playlist)
{
CSCoreEngine.StopPlayback();
if (Queue.HasTracks && Queue.FirstOrDefault(t => t.TrackID == track.AuthenticationCode) != null)
{
Queue.RemoveTrack(track);
}
if (await CSCoreEngine.OpenTrack(track))
{
CSCoreEngine.TogglePlayPause();
CurrentPlaylist = playlist;
}
}
public NotificationTopWindow(PlayableBase track, TimeSpan timestayopened)
{
CurrentTrack = track;
InitializeComponent();
Width = SystemParameters.WorkArea.Width;
MouseMove += NotificationTopWindow_MouseMove;
Closing += NotificationTopWindow_Closing;
Top = SystemParameters.WorkArea.Top;
Thread t = new Thread(() =>
{
Thread.Sleep(timestayopened);
if (!_isClosing) Application.Current.Dispatcher.Invoke(MoveOut);
}) { IsBackground = true };
t.Start();
}
public static BitmapImage GetTrackImage(PlayableBase track, DirectoryInfo di)
{
if (di.Exists)
{
// ReSharper disable once LoopCanBeConvertedToQuery
foreach (var item in di.GetFiles("*.png"))
{
if (track.AuthenticationCode.ToString() == Path.GetFileNameWithoutExtension(item.FullName).ToLower())
{
return(new BitmapImage(new Uri(item.FullName)));
}
}
}
return(null);
}
public static BitmapImage GetTrackImage(PlayableBase track, DirectoryInfo di)
{
if (di.Exists)
{
// ReSharper disable once LoopCanBeConvertedToQuery
foreach (var item in di.GetFiles("*.png"))
{
if (track.AuthenticationCode.ToString() == Path.GetFileNameWithoutExtension(item.FullName).ToLower())
{
return new BitmapImage(new Uri(item.FullName));
}
}
}
return null;
}
public override void AddTrack(PlayableBase track)
{
base.AddTrack(track);
Tracks.Add(track);
if (ShuffleList != null)
ShuffleList.Add(track);
track.IsAdded = true;
var tmr = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(500) };
tmr.Tick += (s, e) =>
{
track.IsAdded = false;
tmr.Stop();
};
tmr.Start();
}
public static BitmapImage GetAlbumImage(PlayableBase track, DirectoryInfo di)
{
if (string.IsNullOrEmpty(track.Album)) return null;
if (di.Exists)
{
// ReSharper disable once LoopCanBeConvertedToQuery
foreach (var item in di.GetFiles("*.png"))
{
if (track.Album.ToEscapedFilename().ToLower() == Path.GetFileNameWithoutExtension(item.FullName).ToLower())
{
return new BitmapImage(new Uri(item.FullName));
}
}
}
return null;
}
public override void AddTrack(PlayableBase track)
{
base.AddTrack(track);
Tracks.Add(track);
ShuffleList?.Add(track);
track.IsAdded = true;
var tmr = new DispatcherTimer {
Interval = TimeSpan.FromMilliseconds(500)
};
tmr.Tick += (s, e) =>
{
track.IsAdded = false;
tmr.Stop();
};
tmr.Start();
}
public static BitmapImage GetAlbumImage(PlayableBase track, DirectoryInfo di)
{
if (string.IsNullOrEmpty(track.Album))
{
return(null);
}
if (di.Exists)
{
// ReSharper disable once LoopCanBeConvertedToQuery
foreach (var item in di.GetFiles("*.png"))
{
if (track.Album.ToEscapedFilename().ToLower() == Path.GetFileNameWithoutExtension(item.FullName).ToLower())
{
return(new BitmapImage(new Uri(item.FullName)));
}
}
}
return(null);
}
public static BitmapImage GetTrackImage(PlayableBase track, DirectoryInfo di)
{
if (di.Exists)
{
var fileName = track.WebTrack == null
? track.AuthenticationCode.ToString()
: (track.WebTrack.Type + "_" + (string.IsNullOrEmpty(track.WebTrack.AlbumId) ? track.WebTrack.SongId : track.WebTrack.AlbumId));
// ReSharper disable once LoopCanBeConvertedToQuery
foreach (var item in di.GetFiles("*.png"))
{
if (fileName.ToLower() == Path.GetFileNameWithoutExtension(item.FullName).ToLower())
{
return(new BitmapImage(new Uri(item.FullName)));
}
}
}
return(null);
}
protected void ShowNotification(PlayableBase track, NotificationType type)
{
ConfigSettings config = HurricaneSettings.Instance.Config;
if (config.Notification == NotificationType.None) return;
if (_lastwindow != null && _lastwindow.Visibility == Visibility.Visible) _lastwindow.Close();
TimeSpan timetostayopen = TimeSpan.FromMilliseconds(config.NotificationShowTime);
Window messagewindow;
switch (type)
{
case NotificationType.Top:
messagewindow = new NotificationTopWindow(track, timetostayopen);
break;
case NotificationType.RightBottom:
messagewindow = new NotificationRightBottomWindow(track, timetostayopen);
break;
default:
return;
}
messagewindow.Show();
_lastwindow = messagewindow;
}
public NotificationTopWindow(PlayableBase track, TimeSpan timestayopened)
{
CurrentTrack = track;
InitializeComponent();
Width = SystemParameters.WorkArea.Width;
MouseMove += NotificationTopWindow_MouseMove;
Closing += NotificationTopWindow_Closing;
Top = SystemParameters.WorkArea.Top;
Thread t = new Thread(() =>
{
Thread.Sleep(timestayopened);
if (!_isClosing)
{
Application.Current.Dispatcher.Invoke(MoveOut);
}
})
{
IsBackground = true
};
t.Start();
}
protected void RemoveFromShuffleList(PlayableBase track)
{
ShuffleList.Remove(track);
if (_addedFavoriteTracksTwoTimes) ShuffleList.Remove(track);
}
public PlayableBase GetRandomTrack(PlayableBase currentTrack)
{
if (Tracks.Count == 0) return null;
if (ShuffleList.Count == 0) CreateShuffleList();
bool hasrefreshed = false;
while (true)
{
int i = _random.Next(0, ShuffleList.Count);
var track = ShuffleList[i];
if (track != currentTrack && track.TrackExists)
{
RemoveFromShuffleList(track);
return track;
}
RemoveFromShuffleList(track);
if (ShuffleList.Count == 0)
{
if (hasrefreshed)
return null;
CreateShuffleList();
hasrefreshed = true;
}
}
}
public virtual void RemoveTrack(PlayableBase track)
{
OnTrackListChanged();
}
public override bool Equals(PlayableBase other)
{
if (other == null) return false;
if (GetType() != other.GetType()) return false;
return StreamUrl == ((VkontakteTrack)other).StreamUrl;
}
public async override void RemoveTrack(PlayableBase track)
{
base.RemoveTrack(track);
ShuffleList.Remove(track);
track.IsRemoving = true;
await Task.Delay(500);
if (!track.TrackExists)
{
for (int i = 0; i < Tracks.Count; i++)
{
if (Tracks[i].AuthenticationCode == track.AuthenticationCode)
{
Tracks.RemoveAt(i);
break;
}
}
}
else { Tracks.Remove(track); }
track.IsRemoving = false; //The track could be also in another playlist
}
public TrackChangedEventArgs(PlayableBase newtrack)
{
NewTrack = newtrack;
}
protected string TrackToString(PlayableBase track)
{
return JsonConvert.SerializeObject(new ShortTrack() { Title = track.Title, Artist = track.Artist, Album = track.Album, Duration = track.Duration, kbps = track.kbps.ToString(), kHz = track.kHz.ToString() });
}
public async static Task<BitmapImage> GetImage(ImageQuality imagequality, bool saveimage, DirectoryInfo directory, PlayableBase track, bool trimtrackname, bool useArtist = true)
{
string apikey = SensitiveInformation.LastfmKey;
string title = track.Title;
string artist = useArtist ? track.Artist : string.Empty;
if (trimtrackname) title = TrimTrackTitle(track.Title);
string url = Uri.EscapeUriString(string.Format("http://ws.audioscrobbler.com/2.0/?method=track.search&track={0}{1}&api_key={2}", title.ToEscapedUrl(), !string.IsNullOrEmpty(artist) ? "&artist=" + artist.ToEscapedUrl() : string.Empty, apikey));
using (WebClient web = new WebClient() { Proxy = null })
{
string result = await web.DownloadStringTaskAsync(new Uri(url));
using (StringReader sr = new StringReader(result))
{
XmlSerializer xmls = new XmlSerializer(typeof(lfm));
var item = (lfm)xmls.Deserialize(sr);
if (item.results.trackmatches.Length > 0)
{
var foundtrack = item.results.trackmatches[0];
url = Uri.EscapeUriString(string.Format("http://ws.audioscrobbler.com/2.0/?method=track.getInfo&api_key={2}&track={0}&artist={1}", foundtrack.name, foundtrack.artist, apikey));
result = await web.DownloadStringTaskAsync(url);
using (StringReader srtrackinformation = new StringReader(result))
{
var trackinfo = (lfm)xmls.Deserialize(srtrackinformation);
if (trackinfo.track.album != null && trackinfo.track.album.image != null && trackinfo.track.album.image.Length > 0)
{
string imageurl = GetImageLink(trackinfo.track.album.image, imagequality);
if (imageurl != null && !imageurl.EndsWith("default_album_medium.png") && !imageurl.EndsWith("[unknown].png")) //We don't want the default album art
{
BitmapImage img = await ImageHelper.DownloadImage(web, imageurl);
string album;
if (string.IsNullOrEmpty(trackinfo.track.album.title))
{
album = string.IsNullOrEmpty(track.Album) ? title : track.Album;
}
else { album = trackinfo.track.album.title; }
if (saveimage) await ImageHelper.SaveImage(img, album, directory.FullName);
return img;
}
}
if (directory.Exists)
{
foreach (var file in directory.GetFiles("*.png"))
{
if (artist.ToEscapedFilename().ToLower() == Path.GetFileNameWithoutExtension(file.FullName).ToLower())
{
var img = new BitmapImage(new Uri(file.FullName));
img.Freeze();
return img;
}
}
}
if (trackinfo.track.artist != null && !string.IsNullOrEmpty(trackinfo.track.artist.mbid))
{
url = string.Format("http://ws.audioscrobbler.com/2.0/?method=artist.getinfo&mbid={0}&api_key={1}", trackinfo.track.artist.mbid, apikey);
}
else if (trackinfo.track.artist != null && !string.IsNullOrEmpty(trackinfo.track.artist.name))
{
url = string.Format("http://ws.audioscrobbler.com/2.0/?method=artist.getinfo&artist={0}&api_key={1}", trackinfo.track.artist.name, apikey);
}
else if (!string.IsNullOrEmpty(artist))
{
url = string.Format("http://ws.audioscrobbler.com/2.0/?method=artist.getinfo&artist={0}&autocorrect=1&api_key={1}", artist, apikey);
}
if (string.IsNullOrEmpty(url)) return null;
result = await web.DownloadStringTaskAsync(Uri.EscapeUriString(url));
using (StringReader srartist = new StringReader(result))
{
lfm artistinfo = (lfm)xmls.Deserialize(srartist);
if (artistinfo.artist != null && artistinfo.artist.image != null && artistinfo.artist.image.Length > 0)
{
string imageurl = GetImageLink(artistinfo.artist.image, imagequality);
if (imageurl == null) return null;
if (!imageurl.EndsWith("default_album_medium.png") && !imageurl.EndsWith("[unknown].png")) //We don't want the default album art
{
BitmapImage img = await ImageHelper.DownloadImage(web, imageurl);
string artistname;
if (string.IsNullOrEmpty(artistinfo.artist.name))
{
artistname = string.IsNullOrEmpty(artist) ? track.Title : artist;
}
else { artistname = artistinfo.artist.name; }
if (saveimage) await ImageHelper.SaveImage(img, artistname, directory.FullName);
return img;
}
}
}
}
}
}
}
return null;
}
public override bool Equals(PlayableBase other)
{
return other == this;
}
public override bool Equals(PlayableBase other)
{
if (other == null) return false;
if (GetType() != other.GetType()) return false;
return Link == ((YouTubeTrack)other).Link;
}
public TrackPlaylistPair(PlayableBase track, IPlaylist playlist)
{
Track = track;
Playlist = playlist;
}
public override bool Equals(PlayableBase other)
{
if (other == null) return false;
if (GetType() != other.GetType()) return false;
return SoundCloudID == ((SoundCloudTrack)other).SoundCloudID;
}
private async Task<Result> SetSoundSource(PlayableBase track)
{
if (_cts != null)
_cts.Cancel();
_cts = new CancellationTokenSource();
var token = _cts.Token;
IWaveSource result;
try
{
result = await track.GetSoundSource();
if (token.IsCancellationRequested)
{
result.Dispose();
return new Result(State.False);
}
}
catch (Exception ex)
{
if (token.IsCancellationRequested)
{
return new Result(State.False);
}
return new Result(State.Exception, ex);
}
SoundSource = result;
return new Result(State.True);
}
public override bool Equals(PlayableBase other)
{
if (other == null) return false;
if (GetType() != other.GetType()) return false;
return TinySongUrl == ((GroovesharkTrack)other).TinySongUrl;
}
public override bool Equals(PlayableBase other)
{
if (other == null) return false;
if (!other.TrackExists || !TrackExists) return false;
if (GetType() != other.GetType()) return false;
var otherAsLocalTrack = (LocalTrack)other;
if (UniqueId == otherAsLocalTrack.UniqueId) return true;
return false;
}
public async Task<bool> OpenTrack(PlayableBase track)
{
if (!IsEnabled)
{
OnSoundOutErrorOccurred(Application.Current.Resources["NoSoundOutDeviceFound"].ToString());
return false;
}
_playAfterLoading = false;
IsLoading = true;
StopPlayback();
if (CurrentTrack != null) { CurrentTrack.IsOpened = false; CurrentTrack.Unload(); }
if (SoundSource != null && !_crossfade.IsCrossfading) { SoundSource.Dispose(); }
track.IsOpened = true;
CurrentTrack = track;
var t = Task.Run(() => track.Load());
Equalizer equalizer;
var result = await SetSoundSource(track);
switch (result.State)
{
case State.False:
track.IsOpened = false;
return false;
case State.Exception:
track.IsOpened = false;
IsLoading = false;
CurrentTrack = null;
if (ExceptionOccurred != null) ExceptionOccurred(this, (Exception)result.CustomState);
StopPlayback();
return false;
}
if (Settings.SampleRate == -1 && SoundSource.WaveFormat.SampleRate < 44100)
{
SoundSource = SoundSource.ChangeSampleRate(44100);
}
else if (Settings.SampleRate > -1) { SoundSource = SoundSource.ChangeSampleRate(Settings.SampleRate); }
SoundSource = SoundSource
.AppendSource(Equalizer.Create10BandEqualizer, out equalizer)
.AppendSource(x => new SingleBlockNotificationStream(x), out _singleBlockNotificationStream)
.AppendSource(x => new SimpleNotificationSource(x) { Interval = 100 }, out _simpleNotificationSource)
.ToWaveSource(Settings.WaveSourceBits);
MusicEqualizer = equalizer;
SetAllEqualizerSettings();
_simpleNotificationSource.BlockRead += notifysource_BlockRead;
_singleBlockNotificationStream.SingleBlockRead += notificationSource_SingleBlockRead;
_analyser = new SampleAnalyser(FFTSize);
_analyser.Initialize(SoundSource.WaveFormat);
try
{
_soundOut.Initialize(SoundSource);
}
catch (Exception ex)
{
track.IsOpened = false;
IsLoading = false;
OnSoundOutErrorOccurred(ex.Message);
return false;
}
OnPropertyChanged("TrackLength");
OnPropertyChanged("CurrentTrackLength");
CurrentStateChanged();
_soundOut.Volume = Volume;
if (StartVisualization != null) StartVisualization(this, EventArgs.Empty);
track.LastTimePlayed = DateTime.Now;
if (_crossfade.IsCrossfading)
_fader.CrossfadeIn(_soundOut, Volume);
IsLoading = false;
if (_playAfterLoading) TogglePlayPause();
await t;
return true;
}
