/// <summary>
/// Get image data from all sources for either fileanme or MetaData
/// </summary>
/// <param name="filename">Name of the File (ie a CUE file)</param>
/// <param name="metaData">Populated MetaData</param>
/// <returns></returns>
public AudioMetaDataImage GetPictureForMetaData(string filename, AudioMetaData metaData)
{
SimpleContract.Requires <ArgumentException>(!string.IsNullOrEmpty(filename), "Invalid Filename");
SimpleContract.Requires <ArgumentException>(metaData != null, "Invalid MetaData");
return(this.ImageForFilename(filename));
}
public void GetMetaData(AudioMetaData audioMD)
{
using (IMarshaler marsh = audioMD.GetMarshaler(true))
{
SafeNativeMethods.xnGetAudioMetaData(this.InternalObject, marsh.Native);
}
}
public static string DetermineMissingRequiredMetaData(AudioMetaData metaData)
{
var result = new List <string>();
if (string.IsNullOrEmpty(metaData.Artist))
{
result.Add("Artist Name (TPE1)");
}
if (string.IsNullOrEmpty(metaData.Release))
{
result.Add("Release Title (TALB)");
}
if (string.IsNullOrEmpty(metaData.Title))
{
result.Add("Track Title (TIT2)");
}
if ((metaData.Year ?? 0) < 1)
{
result.Add("Release Year (TYER | TDRC | TORY | TDOR)");
}
if ((metaData.TrackNumber ?? 0) < 1)
{
result.Add("TrackNumber (TRCK)");
}
return(string.Join(", ", result));
}
public TextToSpeechDecal()
{
MetaData = new AudioMetaData();
CanResize = false;
Stretch = System.Windows.Media.Stretch.None;
Center = new System.Windows.Point(0.5,1);
PinPoint = new System.Windows.Point(0.5,1);
CanMove = false;
#if !SILVERLIGHT
Play = new DelegateCommand(() =>
{
if (!string.IsNullOrEmpty(MetaData.Source) && !_isSpeaking)
{
synthesizer = new SpeechSynthesizer();
synthesizer.Rate = -1;
synthesizer.SpeakAsync(MetaData.Source);
_isSpeaking = true;
// always dispose resources!
synthesizer.SpeakCompleted += new EventHandler<System.Speech.Synthesis.SpeakCompletedEventArgs>(task_SpeakCompleted);
}
}, () =>
{
return !string.IsNullOrEmpty(MetaData.Source);
});
#endif
}
public TextToSpeechDecal()
{
MetaData = new AudioMetaData();
CanResize = false;
Stretch = System.Windows.Media.Stretch.None;
Center = new System.Windows.Point(0.5, 1);
PinPoint = new System.Windows.Point(0.5, 1);
CanMove = false;
#if !SILVERLIGHT
Play = new DelegateCommand(() =>
{
if (!string.IsNullOrEmpty(MetaData.Source) && !_isSpeaking)
{
synthesizer = new SpeechSynthesizer();
synthesizer.Rate = -1;
synthesizer.SpeakAsync(MetaData.Source);
_isSpeaking = true;
// always dispose resources!
synthesizer.SpeakCompleted += new EventHandler <System.Speech.Synthesis.SpeakCompletedEventArgs>(task_SpeakCompleted);
}
}, () =>
{
return(!string.IsNullOrEmpty(MetaData.Source));
});
#endif
}
public void GetMetaData(AudioMetaData audioMD)
{
using (IMarshaler marsh = audioMD.GetMarshaler(true))
{
OpenNIImporter.xnGetAudioMetaData(this.InternalObject, marsh.Native);
}
}
/// <summary>
/// Returns the Full path (FQDN) for given Track details
/// </summary>
/// <param name="metaData">Populated Track MetaData</param>
/// <param name="destinationFolder">Optional Root folder defaults to Library Folder from Settings</param>
/// <param name="artistFolder">Optional ArtistFolder default is to get from MetaData artist</param>
public static string TrackFullPath(IRoadieSettings configuration, AudioMetaData metaData, string destinationFolder = null, string artistFolder = null, string releaseFolder = null)
{
return(FolderPathHelper.TrackFullPath(configuration, metaData.Artist, metaData.Release, SafeParser.ToDateTime(metaData.Year).Value,
metaData.Title, metaData.TrackNumber ?? 0, destinationFolder, metaData.Disc ?? 0,
metaData.TotalTrackNumbers ?? 0,
artistFolder: artistFolder,
releaseFolder: releaseFolder));
}
private extern static IntPtr readaudio(String filename,
Int32 sr,
[In, Out, MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.R4)]
float[] buf,
ref UInt32 buflen,
float nbsecs,
ref AudioMetaData mdata,
ref Int32 error);
public TrackDownloadService(TrackModel track, AudioProcessor audioProcessor, IDownloadPathConfigurator downloadPathConfigurator)
{
Track = track;
AudioProcessor = audioProcessor;
DownloadPathConfigurator = downloadPathConfigurator;
AudioMetaData = new AudioMetaData();
Mp3MetaData = new Mp3MetaData();
Cleanup = true;
OutputDirectory = "download";
}
/// <summary>
/// Returns the Directory for a Track (just directory not Track FileName)
/// </summary>
/// <param name="metaData">Populated Track MetaData</param>
/// <param name="destinationFolder">Optional Root folder defaults to Library Folder from Settings</param>
/// <param name="artistFolder">Optional ArtistFolder default is to get from MetaData artist</param>
/// ///
public static string TrackPath(IRoadieSettings configuration, AudioMetaData metaData, string destinationFolder = null, string artistFolder = null)
{
var fileInfo = new FileInfo(TrackFullPath(configuration, metaData, destinationFolder, artistFolder));
var tf = fileInfo.Directory.Parent.FullName.Replace(new DirectoryInfo(configuration.LibraryFolder).FullName, "");
if (tf.StartsWith(Path.DirectorySeparatorChar))
{
tf = tf.RemoveFirst(Path.DirectorySeparatorChar.ToString());
}
return(Path.Combine(tf, fileInfo.Directory.Name));
}
private OperationResult <AudioMetaData> MetaDataForFileFromATL(string fileName)
{
var sw = new Stopwatch();
sw.Start();
var result = new AudioMetaData();
var isSuccess = false;
try
{
result.Filename = fileName;
var theTrack = new Track(fileName);
result.Release = theTrack.Album;
result.Artist = theTrack.AlbumArtist ?? theTrack.Artist;
result.ArtistRaw = theTrack.AlbumArtist ?? theTrack.Artist;
result.Genres = SplitGenre(theTrack.Genre);
result.TrackArtist = theTrack.OriginalArtist ?? theTrack.Artist ?? theTrack.AlbumArtist;
result.TrackArtistRaw = theTrack.OriginalArtist ?? theTrack.Artist ?? theTrack.AlbumArtist;
result.AudioBitrate = theTrack.Bitrate;
result.AudioSampleRate = theTrack.Bitrate;
result.Disc = theTrack.DiscNumber;
if (theTrack.AdditionalFields.ContainsKey("TSST"))
{
result.DiscSubTitle = theTrack.AdditionalFields["TSST"];
}
result.Images = theTrack.EmbeddedPictures?.Select(x => new AudioMetaDataImage
{
Data = x.PictureData,
Description = x.Description,
MimeType = "image/jpg",
Type = x.PicType == PictureInfo.PIC_TYPE.Front || x.PicType == PictureInfo.PIC_TYPE.Generic
? AudioMetaDataImageType.FrontCover
: AudioMetaDataImageType.Other
}).ToArray();
result.Time = theTrack.DurationMs > 0 ? ((decimal?)theTrack.DurationMs).ToTimeSpan() : null;
result.Title = theTrack.Title.ToTitleCase(false);
result.TrackNumber = (short)theTrack.TrackNumber;
result.Year = theTrack.Year;
isSuccess = result.IsValid;
}
catch (Exception ex)
{
Logger.LogError(ex,
"MetaDataForFileFromTagLib Filename [" + fileName + "] Error [" + ex.Serialize() + "]");
}
sw.Stop();
return(new OperationResult <AudioMetaData>
{
IsSuccess = isSuccess,
OperationTime = sw.ElapsedMilliseconds,
Data = result
});
}
public static int DetermineDiscNumber(AudioMetaData metaData)
{
for (var i = MaximumDiscNumber; i > 0; i--)
{
if (Regex.IsMatch(metaData.Filename, @"(cd\s*(0*" + i + "))", RegexOptions.IgnoreCase))
{
return(i);
}
}
return(1);
}
private void LoadFile(AudioMetaData file)
{
if (HasValidExtension(file))
{
InGameDebug.Log("\t\tLoading '" + file.Path + "'.");
StartCoroutine(StreamFile(file));
}
else
{
InGameDebug.Log("\t\tAudioLoader: '" + file + "' has invalid extension.");
}
}
public override OperationResult <AudioMetaData> Process(AudioMetaData metaData)
{
var result = new OperationResult <AudioMetaData>();
var metaDatasForFilesInFolder = GetAudioMetaDatasForDirectory(metaData.FileInfo.Directory);
metaData.TrackNumber = (metaData.TrackNumber ?? 0) > 0 ? metaData.TrackNumber : ID3TagsHelper.DetermineTrackNumber(metaData.FileInfo.Name);
metaData.TotalTrackNumbers = ID3TagsHelper.DetermineTotalTrackNumbers(metaData.Filename) ?? metaDatasForFilesInFolder.Count();
metaData.Disc = ID3TagsHelper.DetermineDiscNumber(metaData);
metaData.TotalDiscCount = ID3TagsHelper.DetermineTotalDiscNumbers(metaDatasForFilesInFolder);
result.Data = metaData;
result.IsSuccess = true;
return(result);
}
public override OperationResult <AudioMetaData> Process(AudioMetaData metaData)
{
var result = new OperationResult <AudioMetaData>();
if (this.Configuration.Processing.DoAudioCleanup)
{
metaData.Artist = CleanArtist(metaData.ArtistRaw);
metaData.TrackArtist = CleanArtist(metaData.TrackArtistRaw, metaData.ArtistRaw);
}
result.Data = metaData;
result.IsSuccess = true;
return(result);
}
public static int DetermineDiscNumber(AudioMetaData metaData)
{
var maxDiscNumber = 500; // Damnit Karajan
for (var i = maxDiscNumber; i > 0; i--)
{
if (Regex.IsMatch(metaData.Filename, @"(cd\s*(0*" + i + "))", RegexOptions.IgnoreCase))
{
return(i);
}
}
return(1);
}
/// <summary>
/// Read in an audio file and return a buffer of samples at given samplerate, sr
/// </summary>
/// <param name="strign">name of file</param>
/// <param name="Int32">sr samplerate of samples, e.g. 6000 samples per sec</param>
/// <param name="float*">buf pre-allocated buffer of floats in which to put the signal, can be null,
/// in which case a buffer is allocated by the function.</param>
/// <param name="UInt32">buflen, reference to unsigned int to return the length of the buffer.</param>
/// <param name="float">nbsecs, number of seconds to read from the file, 0 for complete file.</param>
/// <param name="AudioMetaData">mdata, reference to struct AudioMetaData to return metadata in file.</param>
/// <param name="int">error, ref to int to indicate error code in case of error.</param>
/// <returns>float[] array of samples </returns>
public static float[] readaudio(string filename,
Int32 sr,
float nbsecs,
ref AudioMetaData mdata,
ref Int32 error)
{
UInt32 buflen = 0;
IntPtr buf = readaudio(filename, sr, null, ref buflen, nbsecs, ref mdata, ref error);
float[] buffer = new float[(Int32)buflen];
Marshal.Copy(buf, buffer, 0, (Int32)buflen);
audiodata_free(buf);
return buffer;
}
/// <summary>
/// Read in an audio file and return a buffer of samples at given samplerate, sr
/// </summary>
/// <param name="strign">name of file</param>
/// <param name="Int32">sr samplerate of samples, e.g. 6000 samples per sec</param>
/// <param name="float*">buf pre-allocated buffer of floats in which to put the signal, can be null,
/// in which case a buffer is allocated by the function.</param>
/// <param name="UInt32">buflen, reference to unsigned int to return the length of the buffer.</param>
/// <param name="float">nbsecs, number of seconds to read from the file, 0 for complete file.</param>
/// <param name="AudioMetaData">mdata, reference to struct AudioMetaData to return metadata in file.</param>
/// <param name="int">error, ref to int to indicate error code in case of error.</param>
/// <returns>float[] array of samples </returns>
public static float[] readaudio(string filename,
Int32 sr,
float nbsecs,
ref AudioMetaData mdata,
ref Int32 error)
{
UInt32 buflen = 0;
IntPtr buf = readaudio(filename, sr, null, ref buflen, nbsecs, ref mdata, ref error);
float[] buffer = new float[(Int32)buflen];
Marshal.Copy(buf, buffer, 0, (Int32)buflen);
audiodata_free(buf);
return(buffer);
}
public override OperationResult <AudioMetaData> Process(AudioMetaData metaData)
{
var result = new OperationResult <AudioMetaData>();
if (this.Configuration.Processing.DoAudioCleanup)
{
if (this.Configuration.Processing.DoClearComments)
{
metaData.Comments = null;
}
}
result.Data = metaData;
result.IsSuccess = true;
return(result);
}
private IMediaMetaData GetMetaData(string mediaType)
{
IMediaMetaData result = default(IMediaMetaData);
switch (mediaType)
{
case "Video":
result = new VideoMetaData() as IMediaMetaData;
break;
case "Audio":
result = new AudioMetaData() as IMediaMetaData;
break;
}
return(result);
}
public override OperationResult <AudioMetaData> Process(AudioMetaData metaData)
{
var result = new OperationResult <AudioMetaData>();
if (this.Configuration.Processing.DoAudioCleanup)
{
if (metaData.FileInfo.IsReadOnly)
{
metaData.FileInfo.Attributes = RemoveAttribute(metaData.FileInfo.Attributes, FileAttributes.ReadOnly);
Console.WriteLine($"â•Ÿ Removed read only attribute on file file [{ metaData.FileInfo.Name}");
}
}
result.Data = metaData;
result.IsSuccess = true;
return(result);
}
public override OperationResult <AudioMetaData> Process(AudioMetaData metaData)
{
var result = new OperationResult <AudioMetaData>();
if (this.Configuration.Processing.DoAudioCleanup)
{
var originalRelease = metaData.Release;
metaData.Release = metaData.Release?.CleanString(this.Configuration, this.Configuration.Processing.ReleaseRemoveStringsRegex).ToTitleCase(doPutTheAtEnd: false);
if (string.IsNullOrEmpty(metaData.Release))
{
metaData.Release = originalRelease;
}
}
result.Data = metaData;
result.IsSuccess = true;
return(result);
}
private async Task <string> DetermineArtistFolder(string destinationRoot, AudioMetaData metaData, bool doJustInfo)
{
var artist = await this.ArtistLookupEngine.GetByName(metaData, !doJustInfo);
if (!artist.IsSuccess)
{
return(null);
}
try
{
return(artist.Data.ArtistFileFolder(this.Configuration, destinationRoot));
}
catch (Exception ex)
{
this.Logger.LogError(ex, ex.Serialize());
}
return(null);
}
public static string ReleaseInspectorToken(AudioMetaData metaData)
{
var hashids = new Hashids(Inspector.Salt);
var releaseId = 0;
var bytes = System.Text.Encoding.ASCII.GetBytes(metaData.Artist + metaData.Release);
var looper = bytes.Length / 4;
for (var i = 0; i < looper; i++)
{
releaseId += BitConverter.ToInt32(bytes, i * 4);
}
if (releaseId < 0)
{
releaseId = releaseId * -1;
}
var token = hashids.Encode(releaseId);
return(token);
}
public override OperationResult <AudioMetaData> Process(AudioMetaData metaData)
{
var result = new OperationResult <AudioMetaData>();
if (Configuration.Processing.DoAudioCleanup)
{
var originalTitle = metaData.Title;
metaData.Title = metaData.Title
?.CleanString(Configuration, Configuration.Processing.TrackRemoveStringsRegex).ToTitleCase(false);
if (string.IsNullOrEmpty(metaData.Title))
{
metaData.Title = originalTitle;
}
}
result.Data = metaData;
result.IsSuccess = true;
return(result);
}
private async Task <string> DetermineArtistFolder(AudioMetaData metaData,
bool doJustInfo)
{
var artist = await ArtistLookupEngine.GetByName(metaData, !doJustInfo).ConfigureAwait(false);
if (!artist.IsSuccess)
{
return(null);
}
try
{
return(artist.Data.ArtistFileFolder(Configuration));
}
catch (Exception ex)
{
Logger.LogError(ex, ex.Serialize());
}
return(null);
}
private async Task <string> DetermineReleaseFolder(string artistFolder, AudioMetaData metaData, bool doJustInfo, int?submissionId)
{
var artist = await this.ArtistLookupEngine.GetByName(metaData, !doJustInfo);
if (!artist.IsSuccess)
{
return(null);
}
this._artistId = artist.Data.RoadieId;
var release = await this.ReleaseLookupEngine.GetByName(artist.Data, metaData, !doJustInfo, submissionId : submissionId);
if (!release.IsSuccess)
{
return(null);
}
this._releaseId = release.Data.RoadieId;
release.Data.ReleaseDate = SafeParser.ToDateTime(release.Data.ReleaseYear ?? metaData.Year);
if (release.Data.ReleaseYear.HasValue && release.Data.ReleaseYear != metaData.Year)
{
this.Logger.LogWarning($"Found Release `{ release.Data }` has different Release Year than MetaData Year `{ metaData }`");
}
return(release.Data.ReleaseFileFolder(artistFolder));
}
private IEnumerator <UnityWebRequestAsyncOperation> StreamFile(AudioMetaData file)
{
var path = file.Path.Replace('\\', '/');
using (var www = UnityWebRequestMultimedia.GetAudioClip("file://" + path, GetAudioType(path)))
{
yield return(www.SendWebRequest());
if (www.isNetworkError)
{
InGameDebug.Log(www.error);
}
else
{
var clip = DownloadHandlerAudioClip.GetContent(www);
InGameDebug.Log("\t\t<color=green>AudioLoader: '" + path + "' loaded.</color>");
Clips.Add(file, clip);
if (Clips.Count == _count)
{
OnLoadingDone?.Invoke();
}
}
}
}
public async Task <OperationResult <Data.Release> > GetByName(Data.Artist artist, AudioMetaData metaData, bool doFindIfNotInDatabase = false, bool doAddTracksInDatabase = false, int?submissionId = null)
{
SimpleContract.Requires <ArgumentNullException>(artist != null, "Invalid Artist");
SimpleContract.Requires <ArgumentOutOfRangeException>(artist.Id > 0, "Invalid Artist Id");
try
{
var sw = new Stopwatch();
sw.Start();
var cacheRegion = (new Data.Release {
Artist = artist, Title = metaData.Release
}).CacheRegion;
var cacheKey = string.Format("urn:release_by_artist_id_and_name:{0}:{1}", artist.Id, metaData.Release);
var resultInCache = this.CacheManager.Get <Data.Release>(cacheKey, cacheRegion);
if (resultInCache != null)
{
sw.Stop();
return(new OperationResult <Data.Release>
{
IsSuccess = true,
OperationTime = sw.ElapsedMilliseconds,
Data = resultInCache
});
}
var searchName = metaData.Release.NormalizeName().ToLower();
var specialSearchName = metaData.Release.ToAlphanumericName();
var altStart = $"{ searchName }|";
var altIn = $"|{ searchName }|";
var altEnds = $"|{ searchName }";
var altStartSpecial = $"{ specialSearchName }|";
var altInSpecial = $"|{ specialSearchName }|";
var altEndsSpecial = $"|{ specialSearchName }";
var release = (from r in this.DbContext.Releases
where (r.ArtistId == artist.Id)
where (r.Title.ToLower() == searchName ||
r.AlternateNames.ToLower() == searchName ||
r.AlternateNames.ToLower() == specialSearchName ||
r.AlternateNames.ToLower().Contains(altStart) ||
r.AlternateNames.ToLower().Contains(altIn) ||
r.AlternateNames.ToLower().Contains(altEnds) ||
r.AlternateNames.ToLower().Contains(altStartSpecial) ||
r.AlternateNames.ToLower().Contains(altInSpecial) ||
r.AlternateNames.ToLower().Contains(altEndsSpecial))
select r
).FirstOrDefault();
sw.Stop();
if (release == null || !release.IsValid)
{
this.Logger.LogInformation("ReleaseFactory: Release Not Found For Artist `{0}` MetaData [{1}]", artist.ToString(), metaData.ToString());
if (doFindIfNotInDatabase)
{
OperationResult <Data.Release> releaseSearch = new OperationResult <Data.Release>();
try
{
releaseSearch = await this.PerformMetaDataProvidersReleaseSearch(metaData, artist.ArtistFileFolder(this.Configuration, this.Configuration.LibraryFolder), submissionId);
}
catch (Exception ex)
{
sw.Stop();
this.Logger.LogError(ex);
return(new OperationResult <Data.Release>
{
OperationTime = sw.ElapsedMilliseconds,
Errors = new Exception[1] {
ex
}
});
}
if (releaseSearch.IsSuccess)
{
release = releaseSearch.Data;
release.ArtistId = artist.Id;
var addResult = await this.Add(release, doAddTracksInDatabase);
if (!addResult.IsSuccess)
{
sw.Stop();
return(new OperationResult <Data.Release>
{
OperationTime = sw.ElapsedMilliseconds,
Errors = addResult.Errors
});
}
}
}
}
if (release != null)
{
this.CacheManager.Add(cacheKey, release);
}
return(new OperationResult <Data.Release>
{
IsSuccess = release != null,
OperationTime = sw.ElapsedMilliseconds,
Data = release
});
}
catch (Exception ex)
{
this.Logger.LogError(ex);
}
return(new OperationResult <Data.Release>());
}
public async Task <OperationResult <Data.Release> > PerformMetaDataProvidersReleaseSearch(AudioMetaData metaData, string artistFolder = null, int?submissionId = null)
{
SimpleContract.Requires <ArgumentNullException>(metaData != null, "Invalid MetaData");
var sw = new Stopwatch();
sw.Start();
var result = new Data.Release
{
Title = metaData.Release.ToTitleCase(false),
TrackCount = (short)(metaData.TotalTrackNumbers ?? 0),
ReleaseDate = SafeParser.ToDateTime(metaData.Year),
SubmissionId = submissionId
};
var resultsExceptions = new List <Exception>();
var releaseGenres = new List <string>();
// Add any Genre found in the given MetaData
if (metaData.Genres != null)
{
releaseGenres.AddRange(metaData.Genres);
}
var releaseLabels = new List <ReleaseLabelSearchResult>();
var releaseMedias = new List <ReleaseMediaSearchResult>();
var releaseImageUrls = new List <string>();
var dontDoMetaDataProvidersSearchArtists = this.Configuration.DontDoMetaDataProvidersSearchArtists;
if (!dontDoMetaDataProvidersSearchArtists.Any(x => x.Equals(metaData.Artist, StringComparison.OrdinalIgnoreCase)))
{
try
{
#region ITunes
if (this.ITunesReleaseSearchEngine.IsEnabled)
{
this.Logger.LogTrace("ITunesReleaseSearchEngine Release Search for ArtistName [{0}], ReleaseTitle [{1}]", metaData.Artist, result.Title);
var iTunesResult = await this.ITunesReleaseSearchEngine.PerformReleaseSearch(metaData.Artist, result.Title, 1);
if (iTunesResult.IsSuccess)
{
var i = iTunesResult.Data.First();
if (i.AlternateNames != null)
{
result.AlternateNames = result.AlternateNames.AddToDelimitedList(i.AlternateNames);
}
if (i.Tags != null)
{
result.Tags = result.Tags.AddToDelimitedList(i.Tags);
}
if (i.Urls != null)
{
result.URLs = result.URLs.AddToDelimitedList(i.Urls);
}
if (i.ImageUrls != null)
{
releaseImageUrls.AddRange(i.ImageUrls);
}
if (i.ReleaseGenres != null)
{
releaseGenres.AddRange(i.ReleaseGenres);
}
result.CopyTo(new Data.Release
{
ReleaseDate = result.ReleaseDate ?? i.ReleaseDate,
AmgId = i.AmgId,
Profile = i.Profile,
ITunesId = i.iTunesId,
Title = result.Title ?? i.ReleaseTitle,
Thumbnail = i.ReleaseThumbnailUrl != null ? WebHelper.BytesForImageUrl(i.ReleaseThumbnailUrl) : null,
ReleaseType = result.ReleaseType == ReleaseType.Unknown ? SafeParser.ToEnum <ReleaseType>(i.ReleaseType) : result.ReleaseType
});
if (i.ReleaseLabel != null)
{
releaseLabels.AddRange(i.ReleaseLabel);
}
if (i.ReleaseMedia != null)
{
releaseMedias.AddRange(i.ReleaseMedia);
}
}
if (iTunesResult.Errors != null)
{
resultsExceptions.AddRange(iTunesResult.Errors);
}
}
#endregion ITunes
#region MusicBrainz
if (this.MusicBrainzReleaseSearchEngine.IsEnabled)
{
this.Logger.LogTrace("MusicBrainzReleaseSearchEngine Release Search for ArtistName [{0}], ReleaseTitle [{1}]", metaData.Artist, result.Title);
var mbResult = await this.MusicBrainzReleaseSearchEngine.PerformReleaseSearch(metaData.Artist, result.Title, 1);
if (mbResult.IsSuccess)
{
var mb = mbResult.Data.First();
if (mb.AlternateNames != null)
{
result.AlternateNames = result.AlternateNames.AddToDelimitedList(mb.AlternateNames);
}
if (mb.Tags != null)
{
result.Tags = result.Tags.AddToDelimitedList(mb.Tags);
}
if (mb.Urls != null)
{
result.URLs = result.URLs.AddToDelimitedList(mb.Urls);
}
if (mb.ImageUrls != null)
{
releaseImageUrls.AddRange(mb.ImageUrls);
}
if (mb.ReleaseGenres != null)
{
releaseGenres.AddRange(mb.ReleaseGenres);
}
if (!string.IsNullOrEmpty(mb.ReleaseTitle) && !mb.ReleaseTitle.Equals(result.Title, StringComparison.OrdinalIgnoreCase))
{
result.AlternateNames.AddToDelimitedList(new string[] { mb.ReleaseTitle });
}
result.CopyTo(new Data.Release
{
ReleaseDate = result.ReleaseDate ?? mb.ReleaseDate,
AmgId = mb.AmgId,
Profile = mb.Profile,
TrackCount = mb.ReleaseMedia != null ? (short)mb.ReleaseMedia.Sum(x => x.TrackCount) : (short)0,
MusicBrainzId = mb.MusicBrainzId,
ITunesId = mb.iTunesId,
Title = result.Title ?? mb.ReleaseTitle,
Thumbnail = mb.ReleaseThumbnailUrl != null ? WebHelper.BytesForImageUrl(mb.ReleaseThumbnailUrl) : null,
ReleaseType = result.ReleaseType == ReleaseType.Unknown ? SafeParser.ToEnum <ReleaseType>(mb.ReleaseType) : result.ReleaseType
});
if (mb.ReleaseLabel != null)
{
releaseLabels.AddRange(mb.ReleaseLabel);
}
if (mb.ReleaseMedia != null)
{
releaseMedias.AddRange(mb.ReleaseMedia);
}
}
if (mbResult.Errors != null)
{
resultsExceptions.AddRange(mbResult.Errors);
}
}
#endregion MusicBrainz
#region LastFm
if (this.LastFmReleaseSearchEngine.IsEnabled)
{
this.Logger.LogTrace("LastFmReleaseSearchEngine Release Search for ArtistName [{0}], ReleaseTitle [{1}]", metaData.Artist, result.Title);
var lastFmResult = await this.LastFmReleaseSearchEngine.PerformReleaseSearch(metaData.Artist, result.Title, 1);
if (lastFmResult.IsSuccess)
{
var l = lastFmResult.Data.First();
if (l.AlternateNames != null)
{
result.AlternateNames = result.AlternateNames.AddToDelimitedList(l.AlternateNames);
}
if (l.Tags != null)
{
result.Tags = result.Tags.AddToDelimitedList(l.Tags);
}
if (l.Urls != null)
{
result.URLs = result.URLs.AddToDelimitedList(l.Urls);
}
if (l.ImageUrls != null)
{
releaseImageUrls.AddRange(l.ImageUrls);
}
if (l.ReleaseGenres != null)
{
releaseGenres.AddRange(l.ReleaseGenres);
}
if (!string.IsNullOrEmpty(l.ReleaseTitle) && !l.ReleaseTitle.Equals(result.Title, StringComparison.OrdinalIgnoreCase))
{
result.AlternateNames.AddToDelimitedList(new string[] { l.ReleaseTitle });
}
result.CopyTo(new Data.Release
{
ReleaseDate = result.ReleaseDate ?? l.ReleaseDate,
AmgId = l.AmgId,
Profile = l.Profile,
LastFMId = l.LastFMId,
LastFMSummary = l.LastFMSummary,
MusicBrainzId = l.MusicBrainzId,
ITunesId = l.iTunesId,
Title = result.Title ?? l.ReleaseTitle,
Thumbnail = l.ReleaseThumbnailUrl != null ? WebHelper.BytesForImageUrl(l.ReleaseThumbnailUrl) : null,
ReleaseType = result.ReleaseType == ReleaseType.Unknown ? SafeParser.ToEnum <ReleaseType>(l.ReleaseType) : result.ReleaseType
});
if (l.ReleaseLabel != null)
{
releaseLabels.AddRange(l.ReleaseLabel);
}
if (l.ReleaseMedia != null)
{
releaseMedias.AddRange(l.ReleaseMedia);
}
}
if (lastFmResult.Errors != null)
{
resultsExceptions.AddRange(lastFmResult.Errors);
}
}
#endregion LastFm
#region Spotify
if (this.SpotifyReleaseSearchEngine.IsEnabled)
{
this.Logger.LogTrace("SpotifyReleaseSearchEngine Release Search for ArtistName [{0}], ReleaseTitle [{1}]", metaData.Artist, result.Title);
var spotifyResult = await this.SpotifyReleaseSearchEngine.PerformReleaseSearch(metaData.Artist, result.Title, 1);
if (spotifyResult.IsSuccess)
{
var s = spotifyResult.Data.First();
if (s.Tags != null)
{
result.Tags = result.Tags.AddToDelimitedList(s.Tags);
}
if (s.Urls != null)
{
result.URLs = result.URLs.AddToDelimitedList(s.Urls);
}
if (s.ImageUrls != null)
{
releaseImageUrls.AddRange(s.ImageUrls);
}
if (s.ReleaseGenres != null)
{
releaseGenres.AddRange(s.ReleaseGenres);
}
if (!string.IsNullOrEmpty(s.ReleaseTitle) && !s.ReleaseTitle.Equals(result.Title, StringComparison.OrdinalIgnoreCase))
{
result.AlternateNames.AddToDelimitedList(new string[] { s.ReleaseTitle });
}
result.CopyTo(new Data.Release
{
ReleaseDate = result.ReleaseDate ?? s.ReleaseDate,
AmgId = s.AmgId,
Profile = this.HttpEncoder.HtmlEncode(s.Profile),
SpotifyId = s.SpotifyId,
MusicBrainzId = s.MusicBrainzId,
ITunesId = s.iTunesId,
Title = result.Title ?? s.ReleaseTitle,
Thumbnail = s.ReleaseThumbnailUrl != null ? WebHelper.BytesForImageUrl(s.ReleaseThumbnailUrl) : null,
ReleaseType = result.ReleaseType == ReleaseType.Unknown ? SafeParser.ToEnum <ReleaseType>(s.ReleaseType) : result.ReleaseType
});
if (s.ReleaseLabel != null)
{
releaseLabels.AddRange(s.ReleaseLabel);
}
if (s.ReleaseMedia != null)
{
releaseMedias.AddRange(s.ReleaseMedia);
}
}
if (spotifyResult.Errors != null)
{
resultsExceptions.AddRange(spotifyResult.Errors);
}
}
#endregion Spotify
#region Discogs
if (this.DiscogsReleaseSearchEngine.IsEnabled)
{
this.Logger.LogTrace("DiscogsReleaseSearchEngine Release Search for ArtistName [{0}], ReleaseTitle [{1}]", metaData.Artist, result.Title);
var discogsResult = await this.DiscogsReleaseSearchEngine.PerformReleaseSearch(metaData.Artist, result.Title, 1);
if (discogsResult.IsSuccess)
{
var d = discogsResult.Data.First();
if (d.Urls != null)
{
result.URLs = result.URLs.AddToDelimitedList(d.Urls);
}
if (d.ImageUrls != null)
{
releaseImageUrls.AddRange(d.ImageUrls);
}
if (d.AlternateNames != null)
{
result.AlternateNames = result.AlternateNames.AddToDelimitedList(d.AlternateNames);
}
if (!string.IsNullOrEmpty(d.ReleaseTitle) && !d.ReleaseTitle.Equals(result.Title, StringComparison.OrdinalIgnoreCase))
{
result.AlternateNames.AddToDelimitedList(new string[] { d.ReleaseTitle });
}
result.CopyTo(new Data.Release
{
Profile = this.HttpEncoder.HtmlEncode(d.Profile),
DiscogsId = d.DiscogsId,
Title = result.Title ?? d.ReleaseTitle,
Thumbnail = d.ReleaseThumbnailUrl != null ? WebHelper.BytesForImageUrl(d.ReleaseThumbnailUrl) : null,
ReleaseType = result.ReleaseType == ReleaseType.Unknown ? SafeParser.ToEnum <ReleaseType>(d.ReleaseType) : result.ReleaseType
});
if (d.ReleaseLabel != null)
{
releaseLabels.AddRange(d.ReleaseLabel);
}
if (d.ReleaseMedia != null)
{
releaseMedias.AddRange(d.ReleaseMedia);
}
}
if (discogsResult.Errors != null)
{
resultsExceptions.AddRange(discogsResult.Errors);
}
}
#endregion Discogs
}
catch (Exception ex)
{
this.Logger.LogError(ex);
}
this.Logger.LogTrace("Metadata Providers Search Complete. [{0}]", sw.ElapsedMilliseconds);
}
else
{
this.Logger.LogTrace("Skipped Metadata Providers Search, DontDoMetaDataProvidersSearchArtists set for Artist [{0}].", metaData.Artist);
}
if (result.AlternateNames != null)
{
result.AlternateNames = string.Join("|", result.AlternateNames.ToListFromDelimited().Distinct().OrderBy(x => x));
}
if (result.URLs != null)
{
result.URLs = string.Join("|", result.URLs.ToListFromDelimited().Distinct().OrderBy(x => x));
}
if (result.Tags != null)
{
result.Tags = string.Join("|", result.Tags.ToListFromDelimited().Distinct().OrderBy(x => x));
}
if (releaseGenres.Any())
{
result.Genres = new List <ReleaseGenre>();
foreach (var releaseGenre in releaseGenres.Where(x => !string.IsNullOrEmpty(x)).GroupBy(x => x).Select(x => x.First()))
{
var rg = releaseGenre.Trim();
if (!string.IsNullOrEmpty(rg))
{
result.Genres.Add(new Data.ReleaseGenre
{
Genre = (this.DbContext.Genres.Where(x => x.Name.ToLower() == rg.ToLower()).FirstOrDefault() ?? new Data.Genre {
Name = rg
})
});
}
}
;
}
if (releaseImageUrls.Any())
{
var imageBag = new ConcurrentBag <Data.Image>();
var i = releaseImageUrls.Select(async url =>
{
imageBag.Add(await WebHelper.GetImageFromUrlAsync(url));
});
await Task.WhenAll(i);
// If the release has images merge any fetched images
var existingImages = result.Images != null?result.Images.ToList() : new List <Data.Image>();
existingImages.AddRange(imageBag.ToList());
// Now set release images to be unique image based on image hash
result.Images = existingImages.Where(x => x != null && x.Bytes != null).GroupBy(x => x.Signature).Select(x => x.First()).Take(this.Configuration.Processing.MaximumReleaseImagesToAdd).ToList();
if (result.Thumbnail == null && result.Images != null)
{
result.Thumbnail = result.Images.First().Bytes;
}
}
if (releaseLabels.Any())
{
result.Labels = releaseLabels.GroupBy(x => x.CatalogNumber).Select(x => x.First()).Select(x => new Data.ReleaseLabel
{
CatalogNumber = x.CatalogNumber,
BeginDate = x.BeginDate,
EndDate = x.EndDate,
Status = Statuses.New,
Label = new Data.Label
{
Name = x.Label.LabelName,
SortName = x.Label.LabelSortName,
MusicBrainzId = x.Label.MusicBrainzId,
BeginDate = x.Label.StartDate,
EndDate = x.Label.EndDate,
ImageUrl = x.Label.LabelImageUrl,
AlternateNames = x.Label.AlternateNames.ToDelimitedList(),
URLs = x.Label.Urls.ToDelimitedList(),
Status = Statuses.New
}
}).ToList();
}
if (releaseMedias.Any())
{
var resultReleaseMedias = new List <Data.ReleaseMedia>();
foreach (var releaseMedia in releaseMedias.GroupBy(x => x.ReleaseMediaNumber).Select(x => x.First()))
{
var rm = new Data.ReleaseMedia
{
MediaNumber = releaseMedia.ReleaseMediaNumber ?? 0,
SubTitle = releaseMedia.ReleaseMediaSubTitle,
TrackCount = releaseMedia.TrackCount ?? 0,
Status = Statuses.New
};
var rmTracks = new List <Data.Track>();
foreach (var releaseTrack in releaseMedias.Where(x => x.ReleaseMediaNumber == releaseMedia.ReleaseMediaNumber)
.SelectMany(x => x.Tracks)
.Where(x => x.TrackNumber.HasValue)
.OrderBy(x => x.TrackNumber))
{
var foundTrack = true;
var rmTrack = rmTracks.FirstOrDefault(x => x.TrackNumber == releaseTrack.TrackNumber.Value);
if (rmTrack == null)
{
Data.Artist trackArtist = null;
if (releaseTrack.Artist != null)
{
trackArtist = new Data.Artist
{
Name = releaseTrack.Artist.ArtistName,
SpotifyId = releaseTrack.Artist.SpotifyId,
ArtistType = releaseTrack.Artist.ArtistType
};
}
rmTrack = new Data.Track
{
TrackArtist = trackArtist,
TrackArtists = releaseTrack.Artists,
TrackNumber = releaseTrack.TrackNumber.Value,
MusicBrainzId = releaseTrack.MusicBrainzId,
SpotifyId = releaseTrack.SpotifyId,
AmgId = releaseTrack.AmgId,
Title = releaseTrack.Title,
AlternateNames = releaseTrack.AlternateNames.ToDelimitedList(),
Duration = releaseTrack.Duration,
Tags = releaseTrack.Tags.ToDelimitedList(),
ISRC = releaseTrack.ISRC,
LastFMId = releaseTrack.LastFMId,
Status = Statuses.New
};
foundTrack = false;
}
rmTrack.Duration = rmTrack.Duration ?? releaseTrack.Duration;
rmTrack.MusicBrainzId = rmTrack.MusicBrainzId ?? releaseTrack.MusicBrainzId;
rmTrack.SpotifyId = rmTrack.SpotifyId ?? releaseTrack.SpotifyId;
rmTrack.AmgId = rmTrack.AmgId ?? releaseTrack.AmgId;
rmTrack.Title = rmTrack.Title ?? releaseTrack.Title;
rmTrack.Duration = releaseTrack.Duration;
rmTrack.Tags = rmTrack.Tags == null?releaseTrack.Tags.ToDelimitedList() : rmTrack.Tags.AddToDelimitedList(releaseTrack.Tags);
rmTrack.AlternateNames = rmTrack.AlternateNames == null?releaseTrack.AlternateNames.ToDelimitedList() : rmTrack.AlternateNames.AddToDelimitedList(releaseTrack.AlternateNames);
rmTrack.ISRC = rmTrack.ISRC ?? releaseTrack.ISRC;
rmTrack.LastFMId = rmTrack.LastFMId ?? releaseTrack.LastFMId;
if (!foundTrack)
{
rmTracks.Add(rmTrack);
}
}
rm.Tracks = rmTracks;
rm.TrackCount = (short)rmTracks.Count();
resultReleaseMedias.Add(rm);
}
result.Medias = resultReleaseMedias;
result.TrackCount = (short)releaseMedias.SelectMany(x => x.Tracks).Count();
}
if (metaData.Images != null && metaData.Images.Any())
{
var image = metaData.Images.FirstOrDefault(x => x.Type == AudioMetaDataImageType.FrontCover);
if (image == null)
{
image = metaData.Images.FirstOrDefault();
}
// If there is an image on the metadata file itself then that over-rides metadata providers.
if (image != null)
{
result.Thumbnail = image.Data;
}
}
if (!string.IsNullOrEmpty(artistFolder))
{
// If any file exist for cover that over-rides whatever if found in metadata providers.
var releaseFolder = new DirectoryInfo(result.ReleaseFileFolder(artistFolder));
if (releaseFolder.Exists)
{
var cover = ImageHelper.FindImageTypeInDirectory(releaseFolder, ImageType.Release);
if (cover.Any())
{
// Read image and convert to jpeg
var coverFileName = cover.First().FullName;
result.Thumbnail = File.ReadAllBytes(coverFileName);
this.Logger.LogDebug("Using Release Cover File [{0}]", coverFileName);
}
}
}
if (result.Thumbnail != null)
{
result.Thumbnail = ImageHelper.ResizeImage(result.Thumbnail, this.Configuration.ThumbnailImageSize.Width, this.Configuration.ThumbnailImageSize.Height);
result.Thumbnail = ImageHelper.ConvertToJpegFormat(result.Thumbnail);
}
sw.Stop();
return(new OperationResult <Data.Release>
{
Data = result,
IsSuccess = result != null,
Errors = resultsExceptions,
OperationTime = sw.ElapsedMilliseconds
});
}
public AudioMetaData GetMetaData()
{
AudioMetaData audioMD = new AudioMetaData();
GetMetaData(audioMD);
return audioMD;
}
public abstract OperationResult <AudioMetaData> Process(AudioMetaData metaData);
private bool HasValidExtension(AudioMetaData file)
{
var extension = Path.GetExtension(file.Path);
return(extension == ".ogg" || extension == ".wav");
}
public static string ArtistInspectorToken(AudioMetaData metaData) => ToToken(metaData.Artist);
public void SetData(AudioMetaData audioMD)
{
SetData(audioMD, audioMD.FrameID, audioMD.Timestamp);
}
public extern static void free_mdata(ref AudioMetaData mdata);
private extern static IntPtr readaudio(String filename,
Int32 sr,
[ In, Out, MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.R4)]
float[] buf,
ref UInt32 buflen,
float nbsecs,
ref AudioMetaData mdata,
ref Int32 error);
public static string ReleaseInspectorToken(AudioMetaData metaData) => ToToken(metaData.Artist + metaData.Release);
public void SetData(AudioMetaData audioMD, UInt32 frameID, UInt64 timestamp)
{
SetData(frameID, timestamp, audioMD.DataSize, audioMD.AudioBufferPtr);
}
