public static bool SaveTrack(Track track)
{
var tags = new ID3v2Tag(track.Filename)
{
Genre = track.Genre.Replace(NoValue, ""),
Album = track.Album.Replace(NoValue, ""),
TrackNumber = track.TrackNumber.ToString(),
LengthMilliseconds = Convert.ToInt32(track.FullLength*1000M),
BPM = track.Bpm.ToString("0.00"),
InitialKey = track.Key
};
if (track.Artist == track.AlbumArtist)
{
tags.Artist = track.Artist.Replace(NoValue, "");
tags.Title = track.Title.Replace(NoValue, "");
}
else
{
tags.Artist = track.AlbumArtist.Replace(NoValue, "");
tags.Title = track.Artist.Replace(NoValue, "") + " / " + track.Title.Replace(NoValue, "");
}
try
{
tags.Save(track.Filename);
}
catch
{
return false;
}
track.OriginalDescription = track.Description;
return true;
}
/// <summary>
/// Displays the current track details.
/// </summary>
public void DisplayTrackDetails(Track track)
{
if (track != null && track.Filename == _currentFilename) return;
if (track != null)
{
lblCurrentTrackDescription.Text = track.Description.Replace("&", "&&");
var details = track.Album + " - " + track.Genre + " ";
details += " - " + track.LengthFormatted;
if (track.Bpm != 0) details += " - " + track.Bpm.ToString("0.00") + " BPM";
if (track.Key != "") details += " - " + KeyHelper.GetDisplayKey(track.Key);
lblCurrentTrackDetails.Text = details;
picCover.Image = Library.GetAlbumCover(track.Album);
_currentFilename = track.Filename;
}
else
{
lblCurrentTrackDescription.Text = "";
lblCurrentTrackDetails.Text = "";
picCover.Image = null;
_currentFilename = "";
}
}
/// <summary>
/// Loads and caches an album cover.
/// </summary>
/// <param name="track">The track.</param>
public static void LoadAlbumCover(Track track)
{
try
{
var path = Path.GetDirectoryName(track.Filename);
if (path == null) return;
var albumArtImagePath = Path.Combine(path, "AlbumArtSmall.jpg");
var folderImagePath = Path.Combine(path, "folder.jpg");
var albumArtImageDate = DateTime.MinValue;
if (File.Exists(albumArtImagePath)) albumArtImageDate = File.GetLastWriteTime(albumArtImagePath);
var folderImageDate = DateTime.MinValue;
if (File.Exists(folderImagePath)) folderImageDate = File.GetLastWriteTime(folderImagePath);
if (!File.Exists(folderImagePath))
{
if (ID3v2Tag.DoesTagExist(track.Filename))
{
var tags = new ID3v2Tag(track.Filename);
if (tags.PictureList.Count > 0)
{
using (Image folderImage = new Bitmap(tags.PictureList[0].Picture))
{
ImageHelper.SaveJpg(folderImagePath, folderImage);
}
}
}
}
if (!File.Exists(albumArtImagePath) || albumArtImageDate < folderImageDate)
{
if (File.Exists(folderImagePath))
{
using (Image image = new Bitmap(folderImagePath))
{
using (var smallImage = ImageHelper.Resize(image, new Size(150, 150)))
{
ImageHelper.SaveJpg(albumArtImagePath, smallImage);
File.SetAttributes(albumArtImagePath, FileAttributes.Hidden);
}
}
}
}
if (File.Exists(albumArtImagePath))
{
Image image = new Bitmap(albumArtImagePath);
AlbumCovers.Add(track.Album, image);
}
}
catch (Exception e)
{
DebugHelper.WriteLine(e.ToString());
}
}
public void UpdateSampleFromTrack(Sample sample, Track track)
{
sample.TrackArtist = track.Artist;
sample.TrackTitle = track.Title;
sample.TrackLength = track.FullLength;
sample.Key = track.Key;
var genre = track.Genre.ToLower();
if (!sample.Tags.Contains(genre)) sample.Tags.Add(genre);
}
public void DisplayMixableTracks(Track parentTrack)
{
_parentTrack = parentTrack;
// BindData();
if (InvokeRequired)
{
BeginInvoke(new MethodInvoker(BindData));
}
else BindData();
}
/// <summary>
/// Gets the file name from track details.
/// </summary>
/// <param name="track">The track.</param>
/// <returns>The generated filename</returns>
private static string GetFileNameFromTrackDetails(Track track)
{
var filename = "";
if (track.TrackNumber > 0) filename += track.TrackNumber.ToString("D2") + " - ";
filename += track.AlbumArtist + " - ";
if (track.Artist == track.AlbumArtist) filename += track.Title;
else filename += track.Artist + " / " + track.Title;
filename += ".mp3";
filename = FileSystemHelper.StripInvalidFileNameChars(filename);
return filename;
}
private List<Track> GetMixableToTracks(Track track, List<int> mixLevels)
{
var mixableTracks = _mixLibrary
.GetMixableToTracks(track, mixLevels)
.Select(x => x.Description)
.ToList();
return _libraryControl
.GetDisplayedTracks()
.Where(x => mixableTracks.Contains(x.Description))
.ToList();
}
public static bool RenameTrack(Track track)
{
var filename = GetFileNameFromTrackDetails(track);
if (filename == Path.GetFileName(track.Filename)) return false;
try
{
var directoryName = Path.GetDirectoryName(track.Filename);
if (directoryName != null)
{
filename = Path.Combine(directoryName, filename);
File.Move(track.Filename, filename);
track.Filename = filename;
}
}
catch
{
return false;
}
return true;
}
public List<Sample> GetMixSectionsAsSamples(Track track)
{
var bassTrack = BassPlayer.LoadTrackAndAudio(track.Filename);
var samples = new List<Sample>();
var fadeIn = new Sample
{
Description = "FadeIn",
Start = bassTrack.SamplesToSeconds(bassTrack.FadeInStart),
Length = bassTrack.FadeOutLengthSeconds
};
UpdateSampleFromTrack(fadeIn, track);
samples.Add(fadeIn);
var fadeOut = new Sample
{
Description = "FadeOut",
Start = bassTrack.SamplesToSeconds(bassTrack.FadeOutStart),
Length = bassTrack.FadeOutLengthSeconds
};
UpdateSampleFromTrack(fadeOut, track);
samples.Add(fadeOut);
if (bassTrack.UsePreFadeIn)
{
var preFadeIn = new Sample
{
Description = "preFadeIn",
Start = bassTrack.SamplesToSeconds(bassTrack.PreFadeInStart),
Length = bassTrack.SamplesToSeconds(bassTrack.FadeInStart - bassTrack.PreFadeInStart),
LoopMode = LoopMode.PartialLoopAnchorEnd
};
UpdateSampleFromTrack(preFadeIn, track);
samples.Add(preFadeIn);
}
BassPlayer.UnloadTrackAudioData(bassTrack);
return samples;
}
public void SaveSampleFiles(Track track)
{
var samples = GetSamples(track);
if (samples.Count == 0) return;
if (!File.Exists(track.Filename)) return;
var folder = GetSampleFolder(samples[0]);
if (!Directory.Exists(folder))
CreateSampleFolder(samples[0]);
FileSystemHelper.DeleteFiles(folder);
var bassTrack = BassPlayer.LoadTrackAndAudio(track.Filename);
foreach (var sample in samples)
{
SaveSampleFile(bassTrack, sample);
}
BassPlayer.UnloadTrackAudioData(bassTrack);
}
public List<Sample> GetSamples(Track track)
{
var samples = Samples
.Where(
x =>
x.TrackTitle == track.Title && x.TrackArtist == track.Artist &&
x.TrackLength == track.FullLength)
.OrderBy(x => x.Description)
.ToList();
return samples;
}
/// <summary>
/// Updates the track title
/// </summary>
/// <param name="track">The track.</param>
/// <param name="artist">The artist.</param>
/// <param name="title">The title.</param>
/// <param name="album">The album.</param>
/// <param name="albumArtist">The album artist.</param>
/// <param name="genre">The genre.</param>
/// <param name="trackNumber">The title.</param>
/// <param name="updateAxillaryFiles">If set to true, will update axillary files.</param>
/// <returns></returns>
public bool UpdateTrackDetails(Track track, string artist, string title, string album, string albumArtist,
string genre, int trackNumber, bool updateAxillaryFiles)
{
var oldTitle = track.Title;
var oldAlbum = track.Album;
var oldAlbumArtist = track.AlbumArtist;
var oldArtist = track.Artist;
var oldGenre = track.Genre;
var oldTrackNumber = track.TrackNumber;
track.Title = title;
track.Album = album;
track.AlbumArtist = albumArtist;
track.Artist = artist;
track.Genre = genre;
track.TrackNumber = trackNumber;
var result = SaveTrack(track, updateAxillaryFiles);
if (result)
{
SaveToDatabase();
}
else
{
track.Title = oldTitle;
track.Album = oldAlbum;
track.AlbumArtist = oldAlbumArtist;
track.Artist = oldArtist;
track.Genre = oldGenre;
track.TrackNumber = oldTrackNumber;
}
return result;
}
public void CopyAudioFromAnotherTrack(Track destinationTrack, Track sourceTrack)
{
File.Move(destinationTrack.Filename, destinationTrack.Filename + ".old");
try
{
File.Copy(sourceTrack.Filename, destinationTrack.Filename);
}
catch (Exception)
{
try
{
File.Move(destinationTrack.Filename + ".old", destinationTrack.Filename);
}
catch
{
// ignored
}
throw;
}
var title = destinationTrack.Title;
var album = destinationTrack.Album;
var albumArtist = destinationTrack.AlbumArtist;
var artist = destinationTrack.Artist;
var genre = destinationTrack.Genre;
var trackNumber = destinationTrack.TrackNumber;
UpdateTrackDetails(destinationTrack, artist, title, album, albumArtist, genre, trackNumber, false);
var albumCover = AlbumCoverHelper.GetAlbumCover(destinationTrack.Album);
if (albumCover != null) AlbumCoverHelper.SetTrackAlbumCover(destinationTrack, albumCover);
File.Delete(destinationTrack.Filename + ".old");
LoadTrack(destinationTrack.Filename);
}
public bool SaveNonLibraryTrack(Track track)
{
return TrackHelper.SaveTrack(track);
}
public void UpdateTrackSamples(Track track, List<Sample> trackSamples)
{
Samples.RemoveAll(
x => x.TrackTitle == track.Title && x.TrackArtist == track.Artist && x.TrackLength == track.FullLength);
trackSamples.ForEach(x => UpdateSampleFromTrack(x, track));
Samples.AddRange(trackSamples);
}
/// <summary>
/// Removes a track from all play-lists.
/// </summary>
/// <param name="track">The track.</param>
public static void RemoveTrackFromAllPlaylists(Track track)
{
foreach (var playlist in Playlists.Where(playlist => playlist.Tracks.Contains(track)))
{
playlist.Tracks.Remove(track);
SavePlaylist(playlist);
}
}
public static void UpdateRank(Track track)
{
var bassTrack = BassPlayer.LoadTrack(track.Filename);
bassTrack.Rank = track.Rank;
ExtenedAttributesHelper.SaveExtendedAttributes(bassTrack);
}
/// <summary>
/// Updates the track number.
/// </summary>
/// <param name="track">The track.</param>
/// <param name="trackNumber">The track number.</param>
public void UpdateTrackNumber(Track track, int trackNumber)
{
track.TrackNumber = trackNumber;
SaveTrack(track);
SaveToDatabase();
}
public void SaveRank(Track track)
{
TrackHelper.UpdateRank(track);
}
public void SetTrackAlbumCover(Track track, Image image)
{
AlbumCoverHelper.SetTrackAlbumCover(track, image);
}
/// <summary>
/// Saves a track.
/// </summary>
/// <param name="track">The track.</param>
/// <param name="updateAxillaryFiles">If set to true, update axillary files.</param>
/// <returns></returns>
public bool SaveTrack(Track track, bool updateAxillaryFiles = true)
{
if (!TrackHelper.SaveTrack(track)) return false;
if (!TrackHelper.RenameTrack(track)) return false;
if (!updateAxillaryFiles) return true;
try
{
if (track.IsShufflerTrack) ShufflerHelper.RenameShufferFiles(track);
// if filename changed, save any associated play-list files
var playlists = PlaylistHelper.GetAllPlaylists().Where(playlist => playlist.Tracks.Contains(track));
foreach (var playlist in playlists)
{
PlaylistHelper.SavePlaylist(playlist);
}
}
catch
{
// ignored
}
return true;
}
private List<Sample> GetTrackSamples(Track track)
{
return Samples.Where(x => x.TrackArtist == track.Artist && x.TrackTitle == track.Title).ToList();
}
private static void UpdateKey(Track track)
{
var attributes = ShufflerHelper.LoadShufflerDetails(track);
var attributeKey = (attributes == null) ? "" : attributes.ContainsKey("Key") ? attributes["Key"] : "";
if (track.Key != "" && attributeKey == "" && track.IsShufflerTrack)
{
ShufflerHelper.SetAttribute("Key", track.Key, attributes);
ShufflerHelper.SaveShufflerAttributes(track, attributes);
}
else if (track.Key == "" && attributeKey != "")
{
SaveTrack(track);
}
track.Key = string.IsNullOrEmpty(attributeKey) ? track.Key : attributeKey;
}
/// <summary>
/// Loads the artist and album artist for a track
/// </summary>
/// <param name="track">The track.</param>
private static void LoadArtistAndAlbumArtist(Track track)
{
if (!track.Title.Contains("/")) return;
var data = track.Title.Split('/').ToList();
track.Artist = data[0].Trim();
track.Title = data[1].Trim();
}
/// <summary>
/// Removes the shuffler details for a track
/// </summary>
/// <param name="track">The track.</param>
public void RemoveShufflerDetails(Track track)
{
if (!track.IsShufflerTrack) return;
File.Delete(track.ShufflerAttribuesFile);
LoadTrack(track.Filename);
}
public List<Playlist> GetPlaylistsForTrack(Track track)
{
return PlaylistHelper.GetPlaylistsForTrack(track);
}
/// <summary>
/// Gets all the play-lists that contain a specific track.
/// </summary>
/// <param name="track">The track.</param>
/// <returns>A list of play-lists that contain the track</returns>
public static List<Playlist> GetPlaylistsForTrack(Track track)
{
return GetAllPlaylists().Where(p => p.Tracks.Contains(track)).Distinct().ToList();
}
/// <summary>
/// Updates the track title
/// </summary>
/// <param name="track">The track.</param>
/// <param name="title">The title.</param>
/// <param name="updateAxillaryFiles">If set to true, will update axillary files.</param>
public void UpdateTitle(Track track, string title, bool updateAxillaryFiles)
{
track.Title = title;
SaveTrack(track, updateAxillaryFiles);
SaveToDatabase();
}
private static Module.AudioFile GetNewAudioFile(Track track)
{
return new Module.AudioFile
{
Samples = new List<Module.Sample>(),
Path = track.Filename,
Key = StringHelper.GetAlphaNumericCharactersOnly(track.Title)
};
}
public void RemoveTrackFromAllPlaylists(Track track)
{
PlaylistHelper.RemoveTrackFromAllPlaylists(track);
}
