/// <summary>
/// Tag the the Selected files from Internet
/// </summary>
private void IdentifyFilesThread(object sender, DoWorkEventArgs e)
{
log.Trace(">>>");
//Make calls to Tracksgrid Threadsafe
if (tracksGrid.InvokeRequired)
{
ThreadSafeGridDelegate1 d = IdentifyFilesThread;
tracksGrid.Invoke(d, new[] { sender, e });
return;
}
int count = 0;
int trackCount = tracksGrid.SelectedRows.Count;
SetProgressBar(trackCount);
MusicBrainzAlbum musicBrainzAlbum = new MusicBrainzAlbum();
foreach (DataGridViewRow row in tracksGrid.Rows)
{
ClearStatusColumn(row.Index);
if (!row.Selected)
{
continue;
}
count++;
try
{
Application.DoEvents();
_main.progressBar1.Value += 1;
if (_progressCancelled)
{
ResetProgressBar();
return;
}
TrackData track = Options.Songlist[row.Index];
using (MusicBrainzTrackInfo trackinfo = new MusicBrainzTrackInfo())
{
Util.SendProgress(string.Format("Identifying file {0}", track.FileName));
log.Debug("Identify: Processing file: {0}", track.FullFileName);
List<MusicBrainzTrack> musicBrainzTracks = trackinfo.GetMusicBrainzTrack(track.FullFileName);
if (musicBrainzTracks == null)
{
log.Debug("Identify: Couldn't identify file");
continue;
}
if (musicBrainzTracks.Count > 0)
{
MusicBrainzTrack musicBrainzTrack = null;
if (musicBrainzTracks.Count == 1)
musicBrainzTrack = musicBrainzTracks[0];
else
{
// Skip the Album selection, if the album been selected already for a previous track
bool albumFound = false;
foreach (MusicBrainzTrack mbtrack in musicBrainzTracks)
{
if (mbtrack.AlbumID == musicBrainzAlbum.Id)
{
albumFound = true;
musicBrainzTrack = mbtrack;
break;
}
}
if (!albumFound)
{
MusicBrainzAlbumResults dlgAlbumResults = new MusicBrainzAlbumResults(musicBrainzTracks);
dlgAlbumResults.Owner = _main;
if (_main.ShowModalDialog(dlgAlbumResults) == DialogResult.OK)
{
if (dlgAlbumResults.SelectedListItem > -1)
musicBrainzTrack = musicBrainzTracks[dlgAlbumResults.SelectedListItem];
else
musicBrainzTrack = musicBrainzTracks[0];
}
dlgAlbumResults.Dispose();
}
}
// We didn't get a track
if (musicBrainzTrack == null)
{
log.Debug("Identify: No information returned from Musicbrainz");
continue;
}
// Are we still at the same album?
// if not, get the album, so that we have the release date
if (musicBrainzAlbum.Id != musicBrainzTrack.AlbumID)
{
using (MusicBrainzAlbumInfo albumInfo = new MusicBrainzAlbumInfo())
{
Application.DoEvents();
if (_progressCancelled)
{
ResetProgressBar();
return;
}
musicBrainzAlbum = albumInfo.GetMusicBrainzAlbumById(musicBrainzTrack.AlbumID.ToString());
}
}
track.Title = musicBrainzTrack.Title;
track.Artist = musicBrainzTrack.Artist;
track.Album = musicBrainzTrack.Album;
track.Track = musicBrainzTrack.Number.ToString();
if (musicBrainzAlbum.Year != null && musicBrainzAlbum.Year.Length >= 4)
track.Year = Convert.ToInt32(musicBrainzAlbum.Year.Substring(0, 4));
// Do we have a valid Amazon Album?
if (musicBrainzAlbum.Amazon != null)
{
// Only write a picture if we don't have a picture OR Overwrite Pictures is set
if (track.Pictures.Count == 0 || Options.MainSettings.OverwriteExistingCovers)
{
ByteVector vector = musicBrainzAlbum.Amazon.AlbumImage;
if (vector != null)
{
MPTagThat.Core.Common.Picture pic = new MPTagThat.Core.Common.Picture();
pic.MimeType = "image/jpg";
pic.Description = "";
pic.Type = PictureType.FrontCover;
pic.Data = vector.Data;
track.Pictures.Add(pic);
}
}
}
SetBackgroundColorChanged(row.Index);
track.Changed = true;
Options.Songlist[row.Index] = track;
_itemsChanged = true;
}
}
}
catch (Exception ex)
{
Options.Songlist[row.Index].Status = 2;
AddErrorMessage(row, ex.Message);
}
}
Util.SendProgress("");
tracksGrid.Refresh();
tracksGrid.Parent.Refresh();
_main.TagEditForm.FillForm();
ResetProgressBar();
log.Trace("<<<");
}
public MusicBrainzAlbum GetMusicBrainzAlbumById(string albumID)
{
MusicBrainzAlbum album = new MusicBrainzAlbum();
string requestString = musicBrainzUrl + string.Format(requestByID, albumID);
string responseXml = Util.GetWebPage(requestString);
if (responseXml == null)
return null;
XmlDocument xml = new XmlDocument();
xml.LoadXml(responseXml);
XmlNamespaceManager nsMgr = new XmlNamespaceManager(xml.NameTable);
nsMgr.AddNamespace("m", "http://musicbrainz.org/ns/mmd-1.0#");
XmlNodeList nodes = xml.SelectNodes("/m:metadata/m:release", nsMgr);
if (nodes.Count > 0)
{
album.Id = new Guid(nodes[0].Attributes["id"].InnerXml);
foreach (XmlNode childNode in nodes[0])
{
if (childNode.Name == "title")
album.Title = childNode.InnerText;
if (childNode.Name == "asin")
album.Asin = childNode.InnerText;
if (childNode.Name == "artist")
{
foreach (XmlNode artistNode in childNode)
{
if (artistNode.Name == "name")
{
album.Artist = artistNode.InnerText;
break;
}
}
}
if (childNode.Name == "release-event-list")
{
foreach (XmlNode releaseNode in childNode)
{
if (releaseNode.Name == "event")
album.Year = releaseNode.Attributes["date"].InnerXml;
}
}
if (childNode.Name == "track-list")
{
foreach (XmlNode trackNode in childNode.ChildNodes)
{
MusicBrainzTrack track = new MusicBrainzTrack();
track.Id = new Guid(trackNode.Attributes["id"].InnerXml);
track.AlbumID = album.Id;
track.Album = album.Title;
track.Artist = album.Artist;
foreach (XmlNode trackDetail in trackNode.ChildNodes)
{
if (trackDetail.Name == "title")
track.Title = trackDetail.InnerText;
if (trackDetail.Name == "duration")
track.Duration = Convert.ToInt32(trackDetail.InnerText);
}
album.Tracks.Add(track);
}
}
}
if (album.Asin != null)
{
// Now do a lookup on Amazon for the Image Url
using (AmazonAlbumInfo amazonInfo = new AmazonAlbumInfo())
{
AmazonAlbum amazonAlbum = amazonInfo.AmazonAlbumLookup(album.Asin);
album.Amazon = amazonAlbum;
}
}
}
return album;
}
/// <summary>
/// Lookup the file in Music Brainz with the Fingerprint
/// </summary>
/// <param name="track"></param>
/// <param name="rowIndex"></param>
/// <returns></returns>
public override bool Execute(ref TrackData track, int rowIndex)
{
using (MusicBrainzTrackInfo trackinfo = new MusicBrainzTrackInfo())
{
Util.SendProgress(string.Format("Identifying file {0}", track.FileName));
Log.Debug("Identify: Processing file: {0}", track.FullFileName);
List<MusicBrainzTrack> musicBrainzTracks = trackinfo.GetMusicBrainzTrack(track.FullFileName);
if (musicBrainzTracks == null)
{
Log.Debug("Identify: Couldn't identify file");
return false;
}
if (musicBrainzTracks.Count > 0)
{
MusicBrainzTrack musicBrainzTrack = null;
if (musicBrainzTracks.Count == 1 && musicBrainzTracks[0].Releases.Count == 1)
{
musicBrainzTrack = musicBrainzTracks[0];
// Have we got already this album
if (musicBrainzTrack.AlbumId == null || musicBrainzTrack.AlbumId != _musicBrainzAlbum.Id)
{
using (var albumInfo = new MusicBrainzAlbumInfo())
{
_musicBrainzAlbum = albumInfo.GetMusicBrainzAlbumById(musicBrainzTrack.Releases[0].AlbumId);
}
}
musicBrainzTrack.AlbumId = _musicBrainzAlbum.Id;
}
else
{
// Skip the Album selection, if the album been selected already for a previous track
bool albumFound = false;
foreach (var mbtrack in musicBrainzTracks)
{
foreach (var mbRelease in mbtrack.Releases)
{
if (mbRelease.AlbumId == _musicBrainzAlbum.Id)
{
albumFound = true;
musicBrainzTrack = mbtrack;
musicBrainzTrack.AlbumId = mbRelease.AlbumId;
break;
}
}
}
if (!albumFound)
{
var dlgAlbumResults = new MusicBrainzAlbumResults(musicBrainzTracks);
dlgAlbumResults.Owner = TracksGrid.MainForm;
dlgAlbumResults.StartPosition = FormStartPosition.CenterParent;
if (dlgAlbumResults.ShowDialog() == DialogResult.OK)
{
var itemTag = dlgAlbumResults.SelectedListItem as Dictionary<string, MusicBrainzTrack>;
if (itemTag != null)
foreach (var albumId in itemTag.Keys)
{
itemTag.TryGetValue(albumId, out musicBrainzTrack);
if (musicBrainzTrack != null) musicBrainzTrack.AlbumId = albumId;
}
}
dlgAlbumResults.Dispose();
}
}
// We didn't get a track
if (musicBrainzTrack == null)
{
Log.Debug("Identify: No information returned from Musicbrainz");
return false;
}
// Are we still at the same album?
// if not, get the album, so that we have the release date
if (_musicBrainzAlbum.Id != musicBrainzTrack.AlbumId)
{
using (var albumInfo = new MusicBrainzAlbumInfo())
{
Application.DoEvents();
if (ProgressCancelled)
{
return false;
}
_musicBrainzAlbum = albumInfo.GetMusicBrainzAlbumById(musicBrainzTrack.AlbumId);
}
}
track.Title = musicBrainzTrack.Title;
track.Artist = musicBrainzTrack.Artist;
track.Album = _musicBrainzAlbum.Title;
track.AlbumArtist = _musicBrainzAlbum.Artist;
// Get the Disic and Track# from the Album
foreach (var mbTrack in _musicBrainzAlbum.Tracks)
{
if (mbTrack.Id == musicBrainzTrack.Id)
{
track.TrackNumber = Convert.ToUInt32(mbTrack.Number);
track.TrackCount = Convert.ToUInt32(mbTrack.TrackCount);
track.DiscNumber = Convert.ToUInt32(mbTrack.DiscId);
track.DiscCount = Convert.ToUInt32(_musicBrainzAlbum.DiscCount);
break;
}
}
if (_musicBrainzAlbum.Year != null && _musicBrainzAlbum.Year.Length >= 4)
track.Year = Convert.ToInt32(_musicBrainzAlbum.Year.Substring(0, 4));
// Do we have a valid Amazon Album?
if (_musicBrainzAlbum.Amazon != null)
{
// Only write a picture if we don't have a picture OR Overwrite Pictures is set
if (track.Pictures.Count == 0 || Options.MainSettings.OverwriteExistingCovers)
{
var vector = _musicBrainzAlbum.Amazon.AlbumImage;
if (vector != null)
{
var pic = new Core.Common.Picture();
pic.MimeType = "image/jpg";
pic.Description = "";
pic.Type = PictureType.FrontCover;
pic.Data = vector.Data;
track.Pictures.Add(pic);
}
}
}
return true;
}
}
return false;
}
public MusicBrainzAlbum GetMusicBrainzAlbumById(string albumID)
{
MusicBrainzAlbum album = new MusicBrainzAlbum();
string requestString = musicBrainzUrl + string.Format(requestByID, albumID);
string responseXml = Util.GetWebPage(requestString);
if (responseXml == null)
{
return(null);
}
XmlDocument xml = new XmlDocument();
xml.LoadXml(responseXml);
XmlNamespaceManager nsMgr = new XmlNamespaceManager(xml.NameTable);
nsMgr.AddNamespace("m", "http://musicbrainz.org/ns/mmd-1.0#");
XmlNodeList nodes = xml.SelectNodes("/m:metadata/m:release", nsMgr);
if (nodes.Count > 0)
{
album.Id = new Guid(nodes[0].Attributes["id"].InnerXml);
foreach (XmlNode childNode in nodes[0])
{
if (childNode.Name == "title")
{
album.Title = childNode.InnerText;
}
if (childNode.Name == "asin")
{
album.Asin = childNode.InnerText;
}
if (childNode.Name == "artist")
{
foreach (XmlNode artistNode in childNode)
{
if (artistNode.Name == "name")
{
album.Artist = artistNode.InnerText;
break;
}
}
}
if (childNode.Name == "release-event-list")
{
foreach (XmlNode releaseNode in childNode)
{
if (releaseNode.Name == "event")
{
album.Year = releaseNode.Attributes["date"].InnerXml;
}
}
}
if (childNode.Name == "track-list")
{
foreach (XmlNode trackNode in childNode.ChildNodes)
{
MusicBrainzTrack track = new MusicBrainzTrack();
track.Id = new Guid(trackNode.Attributes["id"].InnerXml);
track.AlbumID = album.Id;
track.Album = album.Title;
track.Artist = album.Artist;
foreach (XmlNode trackDetail in trackNode.ChildNodes)
{
if (trackDetail.Name == "title")
{
track.Title = trackDetail.InnerText;
}
if (trackDetail.Name == "duration")
{
track.Duration = Convert.ToInt32(trackDetail.InnerText);
}
}
album.Tracks.Add(track);
}
}
}
if (album.Asin != null)
{
// Now do a lookup on Amazon for the Image Url
using (AmazonAlbumInfo amazonInfo = new AmazonAlbumInfo())
{
AmazonAlbum amazonAlbum = amazonInfo.AmazonAlbumLookup(album.Asin);
album.Amazon = amazonAlbum;
}
}
}
return(album);
}
public MusicBrainzAlbum GetMusicBrainzAlbumById(string albumID)
{
var album = new MusicBrainzAlbum();
album.Id = albumID;
var requestString = musicBrainzUrl + string.Format(requestByID, albumID);
var responseXml = Util.GetWebPage(requestString);
if (responseXml == null)
return null;
var xml = new XmlDocument();
xml.LoadXml(responseXml);
var nsMgr = new XmlNamespaceManager(xml.NameTable);
nsMgr.AddNamespace("m", "http://musicbrainz.org/ns/mmd-2.0#");
// Selecting the Title
var nodes = xml.SelectNodes("/m:metadata/m:release/m:title", nsMgr);
if (nodes == null)
{
return null;
}
album.Title = nodes[0].InnerText;
// Get the Album Artist(s)
nodes = xml.SelectNodes("/m:metadata/m:release/m:artist-credit/m:name-credit/m:artist/m:name", nsMgr);
if (nodes != null && nodes.Count > 0)
{
var artists = new List<string>();
foreach (XmlNode node in nodes)
{
artists.Add(node.InnerText);
}
album.Artist = string.Join(";", artists);
}
// Selecting the Date
nodes = xml.SelectNodes("/m:metadata/m:release/m:date", nsMgr);
if (nodes != null && nodes.Count > 0)
{
string year = nodes[0].InnerText;
if (year.Length > 4)
{
year = year.Substring(0, 4);
}
album.Year = year;
}
else
{
album.Year = string.Empty;
}
// Selecting the Asin
nodes = xml.SelectNodes("/m:metadata/m:release/m:asin", nsMgr);
if (nodes != null && nodes.Count > 0)
{
album.Asin = nodes[0].InnerText;
}
// Selecting the Media
nodes = xml.SelectNodes("/m:metadata/m:release/m:medium-list/m:medium", nsMgr);
if (nodes != null && nodes.Count > 0)
{
int pos = 1;
album.DiscCount = nodes.Count;
foreach (XmlNode node in nodes)
{
foreach (XmlNode childNode in node)
{
if (childNode.Name == "position")
pos = Convert.ToInt32(childNode.InnerText);
if (childNode.Name == "track-list")
{
int trackCount = Convert.ToInt32(childNode.Attributes["count"].Value);
foreach (XmlNode trackNode in childNode.ChildNodes)
{
var track = new MusicBrainzTrack();
track.DiscId = pos;
track.TrackCount = trackCount;
foreach (XmlNode trackDetail in trackNode.ChildNodes)
{
if (trackDetail.Name == "recording")
track.Id = trackDetail.Attributes["id"].InnerXml;
if (trackDetail.Name == "position")
track.Number = Convert.ToInt32(trackDetail.InnerText);
}
album.Tracks.Add(track);
}
}
}
}
}
if (album.Asin != null)
{
var amazonAlbum = new AlbumInfo.AlbumSites.Amazon("", "", null, 0);
album.Amazon = amazonAlbum.AmazonAlbumLookup(album.Asin);
}
return album;
}
