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); }