private byte[] GetExternalArtwork(string filename, int size)
{
byte[] artwork = null;
artwork = IndexerUtils.GetExternalArtwork(filename, size, size);
return(artwork);
}
private async Task ImportFiles()
{
var tracks = new List <TrackInfo>();
await Task.Run(() =>
{
lock (this.lockObject)
{
// Sort the files alphabetically
this.files.Sort();
// Convert the files to tracks
foreach (string path in this.files)
{
if (FileFormats.IsSupportedAudioFile(path))
{
// The file is a supported audio format: add it directly.
tracks.Add(IndexerUtils.Path2TrackInfo(path, "file-" + this.instanceGuid));
}
else if (FileFormats.IsSupportedPlaylistFile(path))
{
// The file is a supported playlist format: process the contents of the playlist file.
List <string> audioFilePaths = this.ProcessPlaylistFile(path);
foreach (string audioFilePath in audioFilePaths)
{
tracks.Add(IndexerUtils.Path2TrackInfo(audioFilePath, "file-" + this.instanceGuid));
}
}
else if (Directory.Exists(path))
{
// The file is a directory: get the audio files in that directory.
List <string> audioFilePaths = this.ProcessDirectory(path);
foreach (string audioFilePath in audioFilePaths)
{
tracks.Add(IndexerUtils.Path2TrackInfo(audioFilePath, "file-" + this.instanceGuid));
}
}
else
{
// The file is unknown: do not process it.
}
}
// When done importing files, clear the list.
this.files.Clear();
}
});
LogClient.Instance.Logger.Info("Number of tracks to play = {0}", tracks.Count);
if (tracks.Count > 0)
{
LogClient.Instance.Logger.Info("Enqueuing {0} tracks.", tracks.Count);
await this.playbackService.Enqueue(tracks);
}
}
private async Task <AlbumMetadataChangeStatus> UpdateDatabaseAlbumMetadataAsync(FileMetadata fileMetadata, bool updateAlbumArtwork)
{
var albumMetadataChangeStatus = new AlbumMetadataChangeStatus();
Track dbTrack = await this.trackRepository.GetTrackAsync(fileMetadata.FileName);
if (fileMetadata.Album.IsValueChanged | fileMetadata.AlbumArtists.IsValueChanged | fileMetadata.Year.IsValueChanged)
{
albumMetadataChangeStatus.IsAlbumTitleChanged = fileMetadata.Album.IsValueChanged;
albumMetadataChangeStatus.IsAlbumArtistChanged = fileMetadata.AlbumArtists.IsValueChanged;
albumMetadataChangeStatus.IsAlbumYearChanged = fileMetadata.Year.IsValueChanged;
Album dbAlbum = null;
string newAlbumTitle = !string.IsNullOrWhiteSpace(fileMetadata.Album.Value) ? fileMetadata.Album.Value : Defaults.UnknownAlbumString;
string newAlbumArtist = fileMetadata.AlbumArtists.Values != null && !string.IsNullOrEmpty(fileMetadata.AlbumArtists.Values.FirstOrDefault()) ? fileMetadata.AlbumArtists.Values.FirstOrDefault() : Defaults.UnknownAlbumArtistString;
dbAlbum = await this.albumRepository.GetAlbumAsync(newAlbumTitle, newAlbumArtist);
if (dbAlbum == null)
{
dbAlbum = new Album {
AlbumTitle = newAlbumTitle, AlbumArtist = newAlbumArtist
};
await Task.Run(() => IndexerUtils.CacheArtwork(dbAlbum, dbTrack.Path)); // Artwork
dbAlbum = await this.albumRepository.AddAlbumAsync(dbAlbum);
}
dbTrack.AlbumID = dbAlbum.AlbumID;
await this.trackRepository.UpdateTrackAsync(dbTrack);
await Task.Run(() => IndexerUtils.UpdateAlbumYear(dbAlbum, fileMetadata.Year.Value.SafeConvertToLong())); // Update the album's year
await this.albumRepository.UpdateAlbumAsync(dbAlbum);
}
if (updateAlbumArtwork)
{
albumMetadataChangeStatus.IsAlbumArtworkChanged = true;
string artworkID = String.Empty;
if (fileMetadata.ArtworkData.DataValue != null)
{
await Task.Run(() => artworkID = IndexerUtils.CacheArtworkData(fileMetadata.ArtworkData.DataValue));
}
await this.albumRepository.UpdateAlbumArtworkAsync(!string.IsNullOrWhiteSpace(fileMetadata.Album.Value)?fileMetadata.Album.Value : Defaults.UnknownAlbumString,
fileMetadata.AlbumArtists.Values == null && !string.IsNullOrEmpty(fileMetadata.AlbumArtists.Values.FirstOrDefault())?fileMetadata.AlbumArtists.Values.FirstOrDefault() : Defaults.UnknownAlbumArtistString,
artworkID);
}
return(albumMetadataChangeStatus);
}
private byte[] GetExternalArtwork(string filename, int size)
{
byte[] artwork = null;
artwork = IndexerUtils.GetExternalArtwork(filename, size, size);
if (artwork != null)
{
this.cachedArtwork = new Tuple <string, byte[]>(filename, artwork);
}
return(artwork);
}
public async Task UpdateAlbumAsync(Album album, MetadataArtworkValue artwork, bool updateFileArtwork)
{
string artworkID = String.Empty;
// Cache new artwork
if (artwork != null)
{
await Task.Run(() =>
{
try
{
artworkID = IndexerUtils.CacheArtworkData(artwork.DataValue);
}
catch (Exception ex)
{
LogClient.Instance.Logger.Error("An error occured while caching artwork data for album with title='{0}' and album artist='{1}'. Exception: {2}", album.AlbumTitle, album.AlbumArtist, ex.Message);
}
});
}
// Update artwork in database
await this.albumRepository.UpdateAlbumArtworkAsync(album.AlbumTitle, album.AlbumArtist, artworkID);
if (updateFileArtwork)
{
List <TrackInfo> albumTracks = await this.trackRepository.GetTracksAsync(album.ToList());
List <FileMetadata> fileMetadatas = (from t in albumTracks select new FileMetadata(t.Path)
{
ArtworkData = artwork
}).ToList();
// Queue update of the file metadata
await this.QueueFileMetadata(fileMetadatas);
}
// Raise event
var metadataChangedEventArgs = new MetadataChangedEventArgs();
metadataChangedEventArgs.IsAlbumArtworkMetadataChanged = true;
this.MetadataChanged(metadataChangedEventArgs);
}
private async Task UpdateDatabaseMetadataAsync(IFileMetadata fileMetadata, bool updateAlbumArtwork)
{
Track track = await this.trackRepository.GetTrackAsync(fileMetadata.SafePath);
if (track == null)
{
return;
}
// Track
if (fileMetadata.Title.IsValueChanged)
{
track.TrackTitle = fileMetadata.Title.Value;
}
if (fileMetadata.Year.IsValueChanged)
{
track.Year = fileMetadata.Year.Value.SafeConvertToLong();
}
if (fileMetadata.TrackNumber.IsValueChanged)
{
track.TrackNumber = fileMetadata.TrackNumber.Value.SafeConvertToLong();
}
if (fileMetadata.TrackCount.IsValueChanged)
{
track.TrackCount = fileMetadata.TrackCount.Value.SafeConvertToLong();
}
if (fileMetadata.DiscNumber.IsValueChanged)
{
track.DiscNumber = fileMetadata.DiscNumber.Value.SafeConvertToLong();
}
if (fileMetadata.DiscCount.IsValueChanged)
{
track.DiscCount = fileMetadata.DiscCount.Value.SafeConvertToLong();
}
if (fileMetadata.Lyrics.IsValueChanged)
{
track.HasLyrics = string.IsNullOrWhiteSpace(fileMetadata.Lyrics.Value) ? 0 : 1;
}
// Artist
if (fileMetadata.Artists.IsValueChanged)
{
string newArtistName = fileMetadata.Artists.Values != null && !string.IsNullOrEmpty(fileMetadata.Artists.Values.FirstOrDefault()) ? fileMetadata.Artists.Values.FirstOrDefault() : Defaults.UnknownArtistText;
Artist artist = await this.artistRepository.GetArtistAsync(newArtistName);
if (artist == null)
{
artist = await this.artistRepository.AddArtistAsync(new Artist { ArtistName = newArtistName });
}
if (artist != null)
{
track.ArtistID = artist.ArtistID;
}
}
// Genre
if (fileMetadata.Genres.IsValueChanged)
{
string newGenreName = fileMetadata.Genres.Values != null && !string.IsNullOrEmpty(fileMetadata.Genres.Values.FirstOrDefault()) ? fileMetadata.Genres.Values.FirstOrDefault() : Defaults.UnknownGenreText;
Genre genre = await this.genreRepository.GetGenreAsync(newGenreName);
if (genre == null)
{
genre = await this.genreRepository.AddGenreAsync(new Genre { GenreName = newGenreName });
}
if (genre != null)
{
track.GenreID = genre.GenreID;
}
}
// Album
if (fileMetadata.Album.IsValueChanged || fileMetadata.AlbumArtists.IsValueChanged || fileMetadata.Year.IsValueChanged)
{
string newAlbumTitle = !string.IsNullOrWhiteSpace(fileMetadata.Album.Value) ? fileMetadata.Album.Value : Defaults.UnknownAlbumText;
string newAlbumArtist = fileMetadata.AlbumArtists.Values != null && !string.IsNullOrEmpty(fileMetadata.AlbumArtists.Values.FirstOrDefault()) ? fileMetadata.AlbumArtists.Values.FirstOrDefault() : Defaults.UnknownArtistText;
Album album = await this.albumRepository.GetAlbumAsync(newAlbumTitle, newAlbumArtist);
if (album == null)
{
album = new Album {
AlbumTitle = newAlbumTitle, AlbumArtist = newAlbumArtist, DateLastSynced = DateTime.Now.Ticks
};
album.ArtworkID = await this.cacheService.CacheArtworkAsync(IndexerUtils.GetArtwork(album, this.metadataFactory.Create(track.Path)));
album = await this.albumRepository.AddAlbumAsync(album);
}
if (album != null)
{
track.AlbumID = album.AlbumID;
}
await Task.Run(() => MetadataUtils.UpdateAlbumYear(album, fileMetadata.Year.Value.SafeConvertToLong())); // Update Album year
await this.albumRepository.UpdateAlbumAsync(album);
}
await this.trackRepository.UpdateTrackAsync(track); // Update Track in the database
if (updateAlbumArtwork)
{
// Get album artist
string albumArtist = fileMetadata.AlbumArtists.Values != null && !string.IsNullOrEmpty(fileMetadata.AlbumArtists.Values.FirstOrDefault()) ? fileMetadata.AlbumArtists.Values.FirstOrDefault() : string.Empty;
// If no album artist is found, use the artist name. The album was probably saved using the artist name.
if (string.IsNullOrEmpty(albumArtist))
{
albumArtist = fileMetadata.Artists.Values != null && !string.IsNullOrEmpty(fileMetadata.Artists.Values.FirstOrDefault()) ? fileMetadata.Artists.Values.FirstOrDefault() : Defaults.UnknownArtistText;
}
// Get the album title
string albumTitle = !string.IsNullOrWhiteSpace(fileMetadata.Album.Value) ? fileMetadata.Album.Value : Defaults.UnknownAlbumText;
// Cache the new artwork
string artworkID = await this.cacheService.CacheArtworkAsync(fileMetadata.ArtworkData.Value);
// Update the album artwork in the database
await this.albumRepository.UpdateAlbumArtworkAsync(albumTitle, albumArtist, artworkID);
}
}
public async Task <byte[]> GetArtworkAsync(string path)
{
byte[] artwork = null;
await Task.Run(async() =>
{
lock (this.cachedArtworkLock)
{
// First, check if artwork for this path has been asked recently.
if (this.cachedArtwork != null && this.cachedArtwork.Item1.ToSafePath() == path.ToSafePath())
{
if (this.cachedArtwork.Item2 != null)
{
artwork = this.cachedArtwork.Item2;
}
}
if (artwork == null)
{
// If no cached artwork was found, try to load embedded artwork.
IFileMetadata fmd = this.GetFileMetadata(path);
if (fmd.ArtworkData.Value != null)
{
artwork = fmd.ArtworkData.Value;
this.cachedArtwork = new Tuple <string, byte[]>(path, artwork);
}
}
if (artwork == null)
{
// If no embedded artwork was found, try to find external artwork.
artwork = IndexerUtils.GetExternalArtwork(path);
if (artwork != null)
{
this.cachedArtwork = new Tuple <string, byte[]>(path, artwork);
}
}
if (artwork == null)
{
// If no embedded artwork was found, try to find album artwork.
Track track = this.trackRepository.GetTrack(path);
Album album = track != null ? this.albumRepository.GetAlbum(track.AlbumID) : null;
if (album != null)
{
string artworkPath = this.cacheService.GetCachedArtworkPath((string)album.ArtworkID);
if (!string.IsNullOrEmpty(artworkPath))
{
artwork = ImageUtils.Image2ByteArray(artworkPath);
}
if (artwork != null)
{
this.cachedArtwork = new Tuple <string, byte[]>(path, artwork);
}
}
}
}
});
return(artwork);
}
