/// <summary>
/// 트랙 2개 재생 시작 (하나는 메인, 하나는 사이드)
/// </summary>
public void StartWithTwoTrack(Data.Track mainTrack, int startStep, Data.Track sideTrack, int sideStep, Data.TransitionScenario transcen)
{
m_cmdQueue.Enqueue(new Command()
{
type = Command.Type.StartWithTwoTrack, param1 = mainTrack, param2 = startStep, param3 = sideTrack, param4 = sideStep, param5 = transcen
});
}
void _StartWithTwoTrack(Data.Track mainTrack, int startStep, Data.Track sideTrack, int sideStep, Data.TransitionScenario transcen)
{
var newreq = new NewStartTwoTrackRequest(this);
newreq.Setup(mainTrack, startStep, sideTrack, sideStep, transcen);
m_reqQueue.Enqueue(newreq);
}
void _StartWithOneTrack(Data.Track track, int startStep, bool reverse = false)
{
var newreq = new NewStartOneTrackRequest(this);
newreq.Setup(track, reverse);
m_reqQueue.Enqueue(newreq);
}
/// <summary>
/// 트랜지션 단계 진행. 새 트랙을 준비한다.
/// </summary>
/// <param name="newTrack"></param>
/// <param name="transcen"></param>
/// <param name="reverse"></param>
public void StepMove(int step, Data.Track newTrack, Data.TransitionScenario transcen, int newstep = -1, bool reverse = false)
{
m_cmdQueue.Enqueue(new Command()
{
type = Command.Type.StepMove, param1 = step, param2 = newTrack, param3 = transcen, param4 = newstep, param5 = reverse
});
}
/// <summary>
///
/// </summary>
/// <param name="step"></param>
/// <param name="newTrack"></param>
/// <param name="transcen"></param>
/// <param name="reverse"></param>
/// <returns>cmd 를 소모해야하는지 여부. true일 경우 큐에서 날린다. false일 경우 날리지 않고 다음 프레임에 계속 체크해본다</returns>
bool _StepMove(int step, Data.Track newTrack, Data.TransitionScenario transcen, int newstep = -1, bool reverse = false)
{
//Debug.Log(string.Format("m_curTrackStep : {0}, step : {1}", m_curTrackStep, step));
if (m_curTrackStep == step) // 동일한 step으로 진행하는 요청이 들어온 경우엔 무시한다.
{
Debug.Log("[LibSequentia] same step");
return(true);
}
// 현재 진행중인 요청이 stepmove고, 한번 더 진행이 가능한 경우에는 따로 요청을 늘리지 않는다. (자연 -> 강제 전환으로 바꾸는 것임)
var stepMoveReq = m_reqQueue.Count > 0 ? m_reqQueue.Peek() as StepMoveRequest : null;
if (stepMoveReq != null && stepMoveReq.MoveOnceMore(reverse))
{
return(true);
}
if (stepMoveReq == null) // 현재 진행중인 요청이 stepmove가 아닌 경우에만 새 명령을 추가한다.
{
var newreq = new StepMoveRequest(this);
//var newstep = m_newTrackIsOn? m_newTrackStep : m_curTrackStep;
//newstep += reverse? -1 : 1;
newreq.Setup(step, newstep, reverse, newTrack, transcen);
m_reqQueue.Enqueue(newreq);
return(true);
}
else
{ // stepmove가 맞긴 맞는데 위 moveoncemore 를 실패한 경우라면, 이 명령은 소모해서는 안됨
return(false);
}
}
public void Setup(Data.Track curtrack, int curstep, Data.Track newtrack, int newstep, Data.TransitionScenario tscen)
{
m_curtrack = curtrack;
m_curstep = curstep;
m_newtrack = newtrack;
m_newstep = newstep;
m_tscen = tscen;
}
/// <summary>
/// For a given Track database record determine the path using the given destination folder
/// </summary>
/// <param name="track">Populate track database record</param>
/// <param name="destinationFolder">Optional Root folder defaults to Library Folder from Settings</param>
public static string PathForTrack(IRoadieSettings configuration, Data.Track track, string destinationFolder = null)
{
destinationFolder = destinationFolder ?? configuration.LibraryFolder;
if (string.IsNullOrEmpty(track.FilePath) || string.IsNullOrEmpty(track.FileName))
{
return(null);
}
var directoryInfo = new DirectoryInfo(Path.Combine(destinationFolder, track.FilePath, track.FileName));
return(directoryInfo.FullName);
}
public static Track Map(this Data.Track t)
{
Track track = new Track()
{
ID = t.ID,
EventID = t.Event_ID,
Name = t.Name,
Description = t.Description
};
return(track);
}
/// <summary>
/// 두 트랙 모두 설정 (초기화 목적)
/// </summary>
/// <param name="mainTrack"></param>
/// <param name="sideTrack"></param>
/// <param name="trans"></param>
public IMessageHandle[] SetBothTracks(Data.Track mainTrack, Data.Track sideTrack, Data.TransitionScenario trans)
{
return(new IMessageHandle[]
{
EnqueAndMakeHandle(new Message()
{
type = Message.Type.BothTrack, parameter = mainTrack, parameter2 = sideTrack
}),
EnqueAndMakeHandle(new Message()
{
type = Message.Type.NewTransitionScenario, parameter = trans
}),
});
}
/// <summary>
/// 새 트랙 올리기. 재생은 하지 않음. 다음번 진행 타이밍에 맞춰서 시작
/// </summary>
/// <param name="track"></param>
public IMessageHandle[] SetNewTrack(Data.Track track, Data.TransitionScenario trans)
{
return(new IMessageHandle[]
{
EnqueAndMakeHandle(new Message()
{
type = Message.Type.NewTrack, parameter = track
}),
EnqueAndMakeHandle(new Message()
{
type = Message.Type.NewTransitionScenario, parameter = trans
}),
});
}
public void CreateTrack(Track track)
{
using (OCCDB db = new OCCDB())
{
Data.Track t = new Data.Track()
{
Event_ID = track.EventID,
Name = track.Name,
Description = track.Description
};
db.Tracks.Add(t);
db.SaveChanges();
}
}
public void DeleteTrack(int id)
{
using (OCCDB db = new OCCDB())
{
Data.Track track = (from t in db.Tracks.Include("Sessions") where t.ID == id select t).FirstOrDefault();
if (track.Sessions.Count > 0)
{
throw new Exception("Can't delete a track that contains sessions!");
}
db.Tracks.Remove(track);
db.SaveChanges();
}
}
public void AddTrack(Track track)
{
using (OCCDB db = new OCCDB())
{
Data.Track t = new Data.Track()
{
EventID = track.EventID,
Name = track.Name,
Description = track.Description
};
db.Tracks.Add(t);
db.SaveChanges();
}
}
public void Setup(int targetStep, int newStep, bool reverse, Data.Track newtrack = null, Data.TransitionScenario trans = null)
{
// 새 트랙이 진행중이면서 진행방향이 일치하는 경우 newStep을 사용한다. (새 트랙에 타겟팅중이므로)
bool usingNewStep = ctrl.m_newTrackIsOn && reverse == ctrl.m_newTrackWasReversed;
//Debug.Log(usingNewStep? "using newStep" : "using targetStep");
m_targetStep = usingNewStep? newStep : targetStep;
m_reverse = reverse;
m_newTrack = ctrl.m_newTrackIsOn? null : newtrack; // 새 트랙이 올라와있다면 newtrack은 무시한다.
m_trans = trans;
m_wasNaturalTransition = (targetStep % 2 == 1);
//Debug.Log(string.Format("[stepmove setup] targetStep : {0} reverse : {1} ... ctrl.m_newTrackIsOn : {2}", targetStep, reverse, ctrl.m_newTrackIsOn));
}
public static Track AsTrackWithSessions(this Data.Track t)
{
Track track = new Track()
{
ID = t.ID,
EventID = t.Event_ID,
Name = t.Name,
Description = t.Description
};
foreach (var sesion in t.Sessions)
{
track.Sessions.Add(sesion.Map());
}
return(track);
}
/// <summary>
/// 트랙 1개 재생 시작
/// </summary>
/// <param name="track"></param>
public void StartWithOneTrack(Data.Track track, int startStep, bool reverse = false)
{
// NOTE : StartWithOneTrack 은 맨 앞쪽 섹션만 시작 가능하므로 이렇게 처리되지 않는 경우는 StartWithTwoTrack 으로 처리한다
if (!reverse && startStep <= 1 || reverse && startStep >= (track.sectionCount + 1) * 2 - 1)
{
m_cmdQueue.Enqueue(new Command()
{
type = Command.Type.StartWithOneTrack, param1 = track, param2 = startStep, param3 = reverse
});
}
else
{
m_cmdQueue.Enqueue(new Command()
{
type = Command.Type.StartWithTwoTrack, param1 = track, param2 = startStep, param3 = null, param4 = -1, param5 = null
});
}
}
internal static MappingSearch.Data.Track CreateLocationFromNewLocationModel(NewTrackModel newLocation)
{
Data.Track track = new Data.Track();
track.City = FormInputHelper.StripInput(newLocation.City);
track.Details = FormInputHelper.StripInput(newLocation.Details);
track.State = FormInputHelper.StripInput(newLocation.State);
track.ZipCode = FormInputHelper.StripInput(newLocation.Zip);
track.StreetAddress = FormInputHelper.StripInput(newLocation.StreetAddress);
GoogleGeoCodeResponse latLong = GetLatLongOfZip(newLocation.Zip);
track.Name = FormInputHelper.StripInput(newLocation.TrackName);
track.Lat = Convert.ToDouble(latLong.results[0].geometry.location.lat);
track.Long = Convert.ToDouble(latLong.results[0].geometry.location.lng);
track.TrackLength = newLocation.TrackLength;
track.Approved = false;
track.TrackWebsite = CorrectSiteUrl(newLocation.TrackWebSite);
track.SubmittedBy = System.Web.HttpContext.Current.User.Identity.Name;
return track;
}
public static TrackList FromDataTrack(string trackPlayUrl,
Data.Track track,
int releaseMediaNumber,
Release release,
Data.Artist artist,
Data.Artist trackArtist,
string baseUrl,
Image trackThumbnail,
Image releaseThumbnail,
Image artistThumbnail,
Image trackArtistThumbnail)
{
return(new TrackList
{
DatabaseId = track.Id,
Id = track.RoadieId,
Track = new DataToken
{
Text = track.Title,
Value = track.RoadieId.ToString()
},
Release = ReleaseList.FromDataRelease(release, artist, baseUrl, artistThumbnail, releaseThumbnail),
LastPlayed = track.LastPlayed,
Artist = ArtistList.FromDataArtist(artist, artistThumbnail),
TrackArtist = trackArtist == null ? null : ArtistList.FromDataArtist(trackArtist, trackArtistThumbnail),
TrackNumber = track.TrackNumber,
MediaNumber = releaseMediaNumber,
CreatedDate = track.CreatedDate,
LastUpdated = track.LastUpdated,
Duration = track.Duration,
FileSize = track.FileSize,
ReleaseDate = release.ReleaseDate,
PlayedCount = track.PlayedCount,
Rating = track.Rating,
Status = track.Status,
Title = track.Title,
TrackPlayUrl = trackPlayUrl,
Thumbnail = trackThumbnail
});
}
protected override bool OnStart()
{
if (player.isPlaying) // 재생중이면 계속 보류
{
return(false);
}
ctrl.m_curTrackStep = 0; // 초기화
ctrl.m_newTrackStep = 0;
ctrl.m_newTrackIsOn = false;
ctrl.m_lastMoveWasReversed = false;
var reverse = false; // NOTE : 무조건 정방향 진행으로 설정한다.
// NOTE : curstep/newstep 의 자연/강제 트랜지션 여부가 따로 놀면 안될텐데... 제한하는 코드가 필요한가?
var curstep_next = m_curstep + (m_curstep % 2);
var newstep_next = m_newstep + (m_newstep % 2);
bool directNewTrack = m_newstep == 3; // 바로 newtrack을 재생해야 하는 경우인지
if (directNewTrack)
{
m_curtrack = m_newtrack;
m_curstep = m_newstep;
m_newtrack = null;
}
if (m_newtrack == null) // 트랙 한개만 초기화
{
player.SetNewTrack(m_curtrack, m_tscen);
var handle = player.ProgressStepTo(m_curstep, reverse);
handle.consumedDelegate = () =>
{
ctrl.m_curTrackStep = curstep_next;
ctrl.m_lastMoveWasReversed = reverse;
ctrl.m_newTrackWasReversed = reverse;
ctrl.m_newTrackIsOn = false;
Debug.Log("m_curTrackStep <- nextstep (NewStartOneTrackRequest) : " + ctrl.m_curTrackStep);
};
handle.transitionDelegate = () =>
{
Debug.Log("transition over - curstep_next : " + curstep_next);
isComplete = true;
};
}
else
{ // 두 트랙 초기화
player.SetBothTracks(m_curtrack, m_newtrack, m_tscen);
var handle = player.ProgressStepTo(m_curstep, reverse);
handle.consumedDelegate = () =>
{
ctrl.m_curTrackStep = curstep_next;
ctrl.m_newTrackStep = newstep_next;
ctrl.m_lastMoveWasReversed = reverse;
ctrl.m_newTrackWasReversed = reverse;
ctrl.m_newTrackIsOn = true;
};
handle.transitionDelegate = () =>
{
isComplete = true;
};
}
return(true);
}
public void CreateTrack(Track track)
{
using (var db = new CC.Data.CCDB())
{
Data.Track t = new Data.Track()
{
Event_ID = track.EventID,
Name = track.Name,
Description = track.Description
};
db.Tracks.Add(t);
db.SaveChanges();
}
}
/// <summary>
/// Returns the Directory for a Track (just directory not Track FileName)
/// </summary>
/// <param name="artist">Artist For release</param>
/// <param name="release">Release</param>
/// <param name="track">Track</param>
/// <param name="destinationFolder">Optional Root folder defaults to Library Folder from Settings</param>
public static string TrackPath(IRoadieSettings configuration, Data.Artist artist, Data.Release release, Data.Track track, string destinationFolder = null)
{
var fileInfo = new FileInfo(FolderPathHelper.TrackFullPath(configuration, artist.SortNameValue, release.Title, release.ReleaseDate.Value, track.Title, track.TrackNumber, destinationFolder));
return(fileInfo.Directory.Name);
}
public void Setup(Data.Track track, bool reverse)
{
m_newTrack = track;
m_reverse = reverse;
}
public void Setup(int targetStep, int newStep, bool reverse, Data.Track newtrack = null, Data.TransitionScenario trans = null)
{
// 새 트랙이 진행중이면서 진행방향이 일치하는 경우 newStep을 사용한다. (새 트랙에 타겟팅중이므로)
bool usingNewStep = ctrl.m_newTrackIsOn && reverse == ctrl.m_newTrackWasReversed;
//Debug.Log(usingNewStep? "using newStep" : "using targetStep");
m_targetStep = usingNewStep? newStep : targetStep;
m_reverse = reverse;
m_newTrack = ctrl.m_newTrackIsOn? null : newtrack; // 새 트랙이 올라와있다면 newtrack은 무시한다.
m_trans = trans;
m_wasNaturalTransition = (targetStep % 2 == 1);
//Debug.Log(string.Format("[stepmove setup] targetStep : {0} reverse : {1} ... ctrl.m_newTrackIsOn : {2}", targetStep, reverse, ctrl.m_newTrackIsOn));
}
protected override bool OnStart()
{
if (player.isPlaying) // 재생중이면 계속 보류
return false;
ctrl.m_curTrackStep = 0; // 초기화
ctrl.m_newTrackStep = 0;
ctrl.m_newTrackIsOn = false;
ctrl.m_lastMoveWasReversed = false;
var reverse = false; // NOTE : 무조건 정방향 진행으로 설정한다.
// NOTE : curstep/newstep 의 자연/강제 트랜지션 여부가 따로 놀면 안될텐데... 제한하는 코드가 필요한가?
var curstep_next = m_curstep + (m_curstep % 2);
var newstep_next = m_newstep + (m_newstep % 2);
bool directNewTrack = m_newstep == 3; // 바로 newtrack을 재생해야 하는 경우인지
if (directNewTrack)
{
m_curtrack = m_newtrack;
m_curstep = m_newstep;
m_newtrack = null;
}
if (m_newtrack == null) // 트랙 한개만 초기화
{
player.SetNewTrack(m_curtrack, m_tscen);
var handle = player.ProgressStepTo(m_curstep, reverse);
handle.consumedDelegate = () =>
{
ctrl.m_curTrackStep = curstep_next;
ctrl.m_lastMoveWasReversed = reverse;
ctrl.m_newTrackWasReversed = reverse;
ctrl.m_newTrackIsOn = false;
Debug.Log("m_curTrackStep <- nextstep (NewStartOneTrackRequest) : " + ctrl.m_curTrackStep);
};
handle.transitionDelegate = () =>
{
Debug.Log("transition over - curstep_next : " + curstep_next);
isComplete = true;
};
}
else
{ // 두 트랙 초기화
player.SetBothTracks(m_curtrack, m_newtrack, m_tscen);
var handle = player.ProgressStepTo(m_curstep, reverse);
handle.consumedDelegate = () =>
{
ctrl.m_curTrackStep = curstep_next;
ctrl.m_newTrackStep = newstep_next;
ctrl.m_lastMoveWasReversed = reverse;
ctrl.m_newTrackWasReversed = reverse;
ctrl.m_newTrackIsOn = true;
};
handle.transitionDelegate = () =>
{
isComplete = true;
};
}
return true;
}
public void Setup(Data.Track curtrack, int curstep, Data.Track newtrack, int newstep, Data.TransitionScenario tscen)
{
m_curtrack = curtrack;
m_curstep = curstep;
m_newtrack = newtrack;
m_newstep = newstep;
m_tscen = tscen;
}
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 void Setup(Data.Track track, bool reverse)
{
m_newTrack = track;
m_reverse = reverse;
}
