public override void LoadModelFromDisc()
{
Clear();
LocalDisc mb_disc = LocalDisc.GetFromDevice(Volume.DeviceNode);
if (mb_disc == null)
{
throw new ApplicationException("Could not read contents of the disc. Platform may not be supported.");
}
TimeSpan[] durations = mb_disc.GetTrackDurations();
for (int i = 0, n = durations.Length; i < n; i++)
{
AudioCdTrackInfo track = new AudioCdTrackInfo(this, Volume.DeviceNode, i);
track.TrackNumber = i + 1;
track.TrackCount = n;
track.DiscNumber = 1;
track.Duration = durations[i];
track.ArtistName = ArtistInfo.UnknownArtistName;
track.AlbumTitle = AlbumInfo.UnknownAlbumTitle;
track.TrackTitle = String.Format(Catalog.GetString("Track {0}"), track.TrackNumber);
track.FileSize = PCM_FACTOR * (uint)track.Duration.TotalSeconds;
Add(track);
duration += track.Duration;
file_size += track.FileSize;
}
EnabledCount = Count;
Reload();
ThreadPool.QueueUserWorkItem(LoadDiscMetadata, mb_disc);
}
private void OnMetadataQueryStarted(LocalDisc mb_disc)
{
metadata_query_success = false;
metadata_query_start_time = DateTime.Now;
Log.InformationFormat("Querying MusicBrainz for Disc Release ({0})", mb_disc.Id);
ThreadAssist.ProxyToMain(delegate {
EventHandler handler = MetadataQueryStarted;
if (handler != null)
{
handler(this, EventArgs.Empty);
}
});
}
private void LoadDiscMetadata(object state)
{
try {
LocalDisc mb_disc = (LocalDisc)state;
OnMetadataQueryStarted(mb_disc);
Release release = Release.Query(mb_disc).First();
if (release == null || release.Score < 100)
{
OnMetadataQueryFinished(false);
return;
}
var tracks = release.GetTracks();
if (tracks.Count != Count)
{
OnMetadataQueryFinished(false);
return;
}
disc_title = release.GetTitle();
int disc_number = 1;
int i = 0;
foreach (Disc disc in release.GetDiscs())
{
i++;
if (disc.Id == mb_disc.Id)
{
disc_number = i;
}
}
DateTime release_date = DateTime.MaxValue;
foreach (Event release_event in release.GetEvents())
{
if (release_event.Date != null)
{
try {
// Handle "YYYY" dates
var date_str = release_event.Date;
DateTime date = DateTime.Parse(
date_str.Length > 4 ? date_str : date_str + "-01",
ApplicationContext.InternalCultureInfo
);
if (date < release_date)
{
release_date = date;
}
} catch {
}
}
}
DatabaseArtistInfo artist = new DatabaseArtistInfo();
var mb_artist = release.GetArtist();
artist.Name = mb_artist.GetName();
artist.NameSort = mb_artist.GetSortName();
artist.MusicBrainzId = mb_artist.Id;
bool is_compilation = false;
DatabaseAlbumInfo album = new DatabaseAlbumInfo();
album.Title = disc_title;
album.ArtistName = artist.Name;
album.MusicBrainzId = release.Id;
album.ReleaseDate = release_date == DateTime.MaxValue ? DateTime.MinValue : release_date;
i = 0;
foreach (Track track in tracks)
{
AudioCdTrackInfo model_track = (AudioCdTrackInfo)this[i++];
var mb_track_artist = track.GetArtist();
model_track.MusicBrainzId = track.Id;
model_track.TrackTitle = track.GetTitle();
model_track.ArtistName = mb_track_artist.GetName();
model_track.AlbumTitle = disc_title;
model_track.DiscNumber = disc_number;
model_track.Album = album;
model_track.Artist = new DatabaseArtistInfo();
model_track.Artist.Name = model_track.ArtistName;
model_track.Artist.NameSort = mb_track_artist.GetSortName();
model_track.Artist.MusicBrainzId = mb_track_artist.Id;
if (release_date != DateTime.MinValue)
{
model_track.Year = release_date.Year;
}
if (!is_compilation && mb_track_artist.Id != artist.MusicBrainzId)
{
is_compilation = true;
}
}
if (is_compilation)
{
album.IsCompilation = true;
for (i = 0; i < tracks.Count; i++)
{
AudioCdTrackInfo model_track = (AudioCdTrackInfo)this[i];
model_track.IsCompilation = true;
model_track.AlbumArtist = artist.Name;
model_track.AlbumArtistSort = artist.NameSort;
}
}
OnMetadataQueryFinished(true);
} catch (Exception ex) {
Log.DebugException(ex);
OnMetadataQueryFinished(false);
}
}
internal override void ScanningThreadMain(PlatformIO.DriveInfo drive,
AudioCdVolume volume,
BufferedVolumeItemWriter writer)
{
if (Options.ComputeHashs)
{
SendScannerWarning(S._("Hashcode generation not implemented for audio cds yet."));
volume.IsHashed = false;
}
AudioCdRootVolumeItem root = GetNewVolumeItem <AudioCdRootVolumeItem>(VolumeDatabase.ID_NONE,
"/",
null,
MetadataStore.Empty,
VolumeItemType.AudioCdRootVolumeItem);
LocalDisc localdisc = LocalDisc.GetFromDevice(drive.Device);
if (localdisc == null)
{
throw new ApplicationException("Could not read contents of the audio cd");
}
TimeSpan[] durations = localdisc.GetTrackDurations();
List <AudioTrackVolumeItem> items = new List <AudioTrackVolumeItem>();
for (int i = 0; i < durations.Length; i++)
{
AudioTrackVolumeItem item = GetNewVolumeItem <AudioTrackVolumeItem>(root.ItemID,
"Track " + (i + 1),
MIME_TYPE_AUDIO_TRACK,
MetadataStore.Empty,
VolumeItemType.AudioTrackVolumeItem);
item.SetAudioTrackVolumeItemFields(durations[i]);
items.Add(item);
VolumeInfo.Tracks++;
VolumeInfo.Duration = VolumeInfo.Duration.Add(durations[i]);
}
// retrieve musicbrainz metadata
// (the metadata field of AudioTrackVolumeItems is set
// depending on the EnableMusicBrainz flag)
if (Options.EnableMusicBrainz)
{
try {
// may throw MusicBrainzNotFoundException
Release release = Release.Query(localdisc).PerfectMatch();
CheckForCancellationRequest();
if (release == null)
{
SendScannerWarning(S._("No MusicBrainz metadata available for this disc."));
}
else
{
var tracks = release.GetTracks();
if (tracks.Count != items.Count)
{
SendScannerWarning(S._("The trackcount retrieved from MusicBrainz does not match the trackcount of the local disc. Skipped."));
}
else
{
string albumTitle = release.GetTitle();
int releaseYear = GetReleaseYear(release);
for (int i = 0; i < tracks.Count; i++)
{
items[i].Name = tracks[i].GetTitle();
items[i].MetaData = GetMetadata(tracks[i], albumTitle, releaseYear);
}
volume.Title = albumTitle;
// preset category
ReleaseType rtype = release.GetReleaseType();
if (rtype == ReleaseType.Album ||
rtype == ReleaseType.EP ||
rtype == ReleaseType.Compilation ||
rtype == ReleaseType.Remix)
{
volume.Category = PRESELECTED_CATEGORY;
}
}
}
} catch (MusicBrainzNotFoundException) {
SendScannerWarning(S._("Error connecting to MusicBrainz server."));
}
}
volume.SetAudioCdVolumeFields(VolumeInfo.Tracks, VolumeInfo.Duration);
// write items
if (this.HasDB)
{
writer.Write(root);
foreach (AudioTrackVolumeItem item in items)
{
writer.Write(item);
}
}
}
