private void RefreshArtworkFor(Feed feed)
{
if (!String.IsNullOrEmpty(feed.ImageUrl) && !CoverArtSpec.CoverExists(PodcastService.ArtworkIdFor(feed)))
{
Banshee.Kernel.Scheduler.Schedule(new PodcastImageFetchJob(feed), Banshee.Kernel.JobPriority.BelowNormal);
}
}
public void Fetch()
{
if (feed.ImageUrl == null)
{
return;
}
string cover_art_id = PodcastService.ArtworkIdFor(feed);
if (cover_art_id == null)
{
return;
}
else if (CoverArtSpec.CoverExists(cover_art_id))
{
return;
}
else if (!InternetConnected)
{
return;
}
if (SaveHttpStreamCover(new Uri(feed.ImageUrl), cover_art_id, null))
{
Banshee.Sources.Source src = ServiceManager.SourceManager.ActiveSource;
if (src != null && (src is PodcastSource || src.Parent is PodcastSource))
{
(src as Banshee.Sources.DatabaseSource).Reload();
}
return;
}
}
private void FetchForTrack(DatabaseTrackInfo track)
{
bool save = true;
try {
if (String.IsNullOrEmpty(track.AlbumTitle) || track.AlbumTitle == Catalog.GetString("Unknown Album") ||
String.IsNullOrEmpty(track.ArtistName) || track.ArtistName == Catalog.GetString("Unknown Artist"))
{
// Do not try to fetch album art for these
}
else
{
IMetadataLookupJob job = MetadataService.Instance.CreateJob(track);
job.Run();
}
} catch (System.Threading.ThreadAbortException) {
save = false;
throw;
} catch (Exception e) {
Log.Exception(e);
} finally {
if (save)
{
bool have_cover_art = CoverArtSpec.CoverExists(track.ArtistName, track.AlbumTitle);
ServiceManager.DbConnection.Execute(
"INSERT OR REPLACE INTO CoverArtDownloads (AlbumID, Downloaded, LastAttempt) VALUES (?, ?, ?)",
track.AlbumId, have_cover_art, DateTime.Now);
}
}
}
private void RefreshArtworkFor(Feed feed)
{
if (feed.LastDownloadTime != DateTime.MinValue && !CoverArtSpec.CoverExists(PodcastService.ArtworkIdFor(feed)))
{
Banshee.Kernel.Scheduler.Schedule(new PodcastImageFetchJob(feed), Banshee.Kernel.JobPriority.BelowNormal);
}
}
public string getArtId()
{
string aaid = CoverArtSpec.CreateArtistAlbumId(_performer, _title);
if (!CoverArtSpec.CoverExists(aaid))
{
if (File.Exists(_img_full_path))
{
string path = CoverArtSpec.GetPathForNewFile(aaid, _img_full_path);
if (!File.Exists(path))
{
File.Copy(_img_full_path, path);
}
}
}
else
{
if (File.Exists(_img_full_path))
{
string path = CoverArtSpec.GetPathForNewFile(aaid, _img_full_path);
if (File.Exists(path))
{
File.Delete(path);
}
if (!File.Exists(path))
{
File.Copy(_img_full_path, path);
}
}
}
return(aaid);
}
private Actor GetActorForAlbumInfo(AlbumInfo info)
{
Actor actor = null;
if (info == null || info.ArtworkId == null)
{
return(null);
}
if (actor_cache.TryGetValue(info.ArtworkId, out actor))
{
return(actor);
}
if (!CoverArtSpec.CoverExists(info.ArtworkId))
{
return(null);
}
actor = new AlbumArtActor(info, ActorSize)
{
Parent = this
};
actor_cache.Add(info.ArtworkId, actor);
return(actor);
}
public override void Run()
{
if (!OnlineMetadataServiceJob.TrackConditionsMet(Track) ||
GetAlbumUrl(Track) == null)
{
return;
}
string artwork_id = Track.ArtworkId;
if (artwork_id == null || CoverArtSpec.CoverExists(artwork_id) || !InternetConnected)
{
return;
}
Uri data_uri = new Uri(base_uri, String.Format("/{0}/data.xml", GetAlbumUrl(Track)));
XmlDocument doc = new XmlDocument();
HttpWebResponse response = GetHttpStream(data_uri);
if (response == null)
{
return;
}
string [] content_types = response.Headers.GetValues("Content-Type");
if (content_types.Length == 0 || content_types[0] != "text/xml")
{
response.Close();
return;
}
using (Stream stream = response.GetResponseStream()) {
doc.Load(stream);
}
XmlNode art_node = doc.DocumentElement.SelectSingleNode("/album/art/album-art[@size='large']/img");
if (art_node != null && art_node.Attributes["src"] != null)
{
// awesome hack to get high resolution cover art from Rhapsody
string second_attempt = art_node.Attributes["src"].Value;
string first_attempt = second_attempt.Replace("170x170", "500x500");
if (SaveHttpStreamCover(new Uri(first_attempt), artwork_id, null) ||
SaveHttpStreamCover(new Uri(second_attempt), artwork_id, null))
{
Log.Debug("Downloaded cover art from Rhapsody", artwork_id);
StreamTag tag = new StreamTag();
tag.Name = CommonTags.AlbumCoverId;
tag.Value = artwork_id;
AddTag(tag);
}
}
response.Close();
}
public override void Run()
{
if (track == null || CoverArtSpec.CoverExists(track.ArtworkId))
{
return;
}
Fetch();
}
public bool Lookup()
{
if (Track == null || (Track.MediaAttributes & TrackMediaAttributes.Podcast) != 0)
{
return(false);
}
string artwork_id = Track.ArtworkId;
if (artwork_id == null)
{
return(false);
}
else if (CoverArtSpec.CoverExists(artwork_id))
{
return(false);
}
else if (!InternetConnected)
{
return(false);
}
if (asin == null)
{
asin = FindAsin();
if (asin == null)
{
return(false);
}
}
if (SaveHttpStreamCover(new Uri(String.Format(AmazonUriFormat, asin)), artwork_id,
new string [] { "image/gif" }))
{
Log.Debug("Downloaded cover art from Amazon", artwork_id);
StreamTag tag = new StreamTag();
tag.Name = CommonTags.AlbumCoverId;
tag.Value = artwork_id;
AddTag(tag);
return(true);
}
return(false);
}
private void FetchForTrack(DatabaseTrackInfo track)
{
bool save = true;
try {
IMetadataLookupJob job = MetadataService.Instance.CreateJob(track);
job.Run();
} catch (System.Threading.ThreadAbortException) {
save = false;
throw;
} catch (Exception e) {
Log.Error(e);
} finally {
if (save)
{
bool have_cover_art = CoverArtSpec.CoverExists(track.ArtistName, track.AlbumTitle);
ServiceManager.DbConnection.Execute(
"INSERT OR REPLACE INTO CoverArtDownloads (AlbumID, Downloaded, LastAttempt) VALUES (?, ?, ?)",
track.AlbumId, have_cover_art, DateTime.Now);
}
}
}
protected override void AddTrackToDevice(DatabaseTrackInfo track, SafeUri fromUri)
{
if (track.PrimarySourceId == DbId)
{
return;
}
SafeUri new_uri = new SafeUri(GetTrackPath(track, System.IO.Path.GetExtension(fromUri)));
// If it already is on the device but it's out of date, remove it
//if (File.Exists(new_uri) && File.GetLastWriteTime(track.Uri.LocalPath) > File.GetLastWriteTime(new_uri))
//RemoveTrack(new MassStorageTrackInfo(new SafeUri(new_uri)));
if (!File.Exists(new_uri))
{
Directory.Create(System.IO.Path.GetDirectoryName(new_uri.LocalPath));
File.Copy(fromUri, new_uri, false);
DatabaseTrackInfo copied_track = new DatabaseTrackInfo(track);
copied_track.PrimarySource = this;
copied_track.Uri = new_uri;
// Write the metadata in db to the file on the DAP if it has changed since file was modified
// to ensure that when we load it next time, it's data will match what's in the database
// and the MetadataHash will actually match. We do this by comparing the time
// stamps on files for last update of the db metadata vs the sync to file.
// The equals on the inequality below is necessary for podcasts who often have a sync and
// update time that are the same to the second, even though the album metadata has changed in the
// DB to the feedname instead of what is in the file. It should be noted that writing the metadata
// is a small fraction of the total copy time anyway.
if (track.LastSyncedStamp >= Hyena.DateTimeUtil.ToDateTime(track.FileModifiedStamp))
{
Log.DebugFormat("Copying Metadata to File Since Sync time >= Updated Time");
bool write_metadata = Metadata.SaveTrackMetadataService.WriteMetadataEnabled.Value;
bool write_ratings_and_playcounts = Metadata.SaveTrackMetadataService.WriteRatingsAndPlayCountsEnabled.Value;
Banshee.Streaming.StreamTagger.SaveToFile(copied_track, write_metadata, write_ratings_and_playcounts);
}
copied_track.Save(false);
}
if (CoverArtSize > -1 && !String.IsNullOrEmpty(CoverArtFileType) &&
!String.IsNullOrEmpty(CoverArtFileName) && (FolderDepth == -1 || FolderDepth > 0))
{
SafeUri cover_uri = new SafeUri(System.IO.Path.Combine(System.IO.Path.GetDirectoryName(new_uri.LocalPath),
CoverArtFileName));
string coverart_id = track.ArtworkId;
if (!File.Exists(cover_uri) && CoverArtSpec.CoverExists(coverart_id))
{
Gdk.Pixbuf pic = null;
if (CoverArtSize == 0)
{
if (CoverArtFileType == "jpg" || CoverArtFileType == "jpeg")
{
SafeUri local_cover_uri = new SafeUri(Banshee.Base.CoverArtSpec.GetPath(coverart_id));
Banshee.IO.File.Copy(local_cover_uri, cover_uri, false);
}
else
{
pic = artwork_manager.LookupPixbuf(coverart_id);
}
}
else
{
pic = artwork_manager.LookupScalePixbuf(coverart_id, CoverArtSize);
}
if (pic != null)
{
try {
byte [] bytes = pic.SaveToBuffer(CoverArtFileType);
System.IO.Stream cover_art_file = File.OpenWrite(cover_uri, true);
cover_art_file.Write(bytes, 0, bytes.Length);
cover_art_file.Close();
} catch (GLib.GException) {
Log.DebugFormat("Could not convert cover art to {0}, unsupported filetype?", CoverArtFileType);
} finally {
Banshee.Collection.Gui.ArtworkManager.DisposePixbuf(pic);
}
}
}
}
}
public override void Run()
{
if (Track == null || (Track.MediaAttributes & TrackMediaAttributes.Podcast) != 0)
{
return;
}
string artwork_id = Track.ArtworkId;
if (artwork_id == null || CoverArtSpec.CoverExists(artwork_id) || !ServiceManager.Get <Network> ().Connected)
{
return;
}
// Lastfm uses double url-encoding in their current 1.2 api for albuminfo.
string lastfmArtist = HttpUtility.UrlEncode(HttpUtility.UrlEncode(Track.AlbumArtist));
string lastfmAlbum = HttpUtility.UrlEncode(HttpUtility.UrlEncode(Track.AlbumTitle));
Lastfm.Data.LastfmAlbumData album = null;
try {
album = new Lastfm.Data.LastfmAlbumData(lastfmArtist, lastfmAlbum);
} catch {
return;
}
// AllUrls is an array with [small,medium,large] coverart url
string [] album_cover_urls = album.AlbumCoverUrls.AllUrls();
// Select the URL for the coverart with highest resolution
string best_url = String.Empty;
foreach (string url in album_cover_urls)
{
if (!String.IsNullOrEmpty(url))
{
best_url = url;
}
}
// No URL's found
if (String.IsNullOrEmpty(best_url) || best_url.Contains("noimage"))
{
//string upload_url = String.Format ("http://www.last.fm/music/{0}/{1}/+images", lastfmArtist, lastfmAlbum);
//Log.DebugFormat ("No coverart provided by lastfm. (you can upload it here: {0}) - {1} ", upload_url, Track.ArtworkId);
return;
}
// Hack: You can get higher resolution artwork by replacing 130X130 with 300x300 in lastfm hosted albumart
string high_res_url = null;
if (best_url.Contains("130x130"))
{
high_res_url = best_url.Replace("130x130", "300x300");
}
// Hack: You can get higher resolution artwork from Amazon too (lastfm sometimes uses amazon links)
if (best_url.Contains("MZZZZZZZ"))
{
high_res_url = best_url.Replace("MZZZZZZZ", "LZZZZZZZ");
}
// Download the cover
try {
if ((high_res_url != null && SaveHttpStreamCover(new Uri(high_res_url), artwork_id, null)) ||
SaveHttpStreamCover(new Uri(best_url), artwork_id, null))
{
if (best_url.Contains("amazon"))
{
Log.Debug("Downloaded cover art from Amazon", artwork_id);
}
else
{
Log.Debug("Downloaded cover art from Lastfm", artwork_id);
}
StreamTag tag = new StreamTag();
tag.Name = CommonTags.AlbumCoverId;
tag.Value = artwork_id;
AddTag(tag);
}
} catch (Exception e) {
Log.Exception("Cover art found on Lastfm, but downloading it failed. Probably server under high load or dead link", e);
}
}
public bool Lookup()
{
if (!OnlineMetadataServiceJob.TrackConditionsMet(Track))
{
return(false);
}
string artwork_id = Track.ArtworkId;
if (artwork_id == null)
{
return(false);
}
else if (CoverArtSpec.CoverExists(artwork_id))
{
return(false);
}
else if (!InternetConnected)
{
return(false);
}
DatabaseTrackInfo dbtrack;
dbtrack = Track as DatabaseTrackInfo;
Release release;
// If we have the MBID of the album, we can do a direct MusicBrainz lookup
if (dbtrack != null && dbtrack.AlbumMusicBrainzId != null)
{
release = Release.Get(dbtrack.AlbumMusicBrainzId);
if (!String.IsNullOrEmpty(release.GetAsin()) && SaveCover(String.Format(AmazonUriFormat, release.GetAsin())))
{
return(true);
}
// Otherwise we do a MusicBrainz search
}
else
{
ReleaseQueryParameters parameters = new ReleaseQueryParameters();
parameters.Title = Track.AlbumTitle;
parameters.Artist = Track.AlbumArtist;
if (dbtrack != null)
{
parameters.TrackCount = dbtrack.TrackCount;
}
Query <Release> query = Release.Query(parameters);
release = query.PerfectMatch();
foreach (Release r in query.Best())
{
if (!String.IsNullOrEmpty(r.GetAsin()) && SaveCover(String.Format(AmazonUriFormat, r.GetAsin())))
{
return(true);
}
}
}
if (release == null)
{
return(false);
}
// No success with ASIN, let's try with other linked URLs
ReadOnlyCollection <UrlRelation> relations = release.GetUrlRelations();
foreach (UrlRelation relation in relations)
{
foreach (CoverArtSite site in CoverArtSites)
{
Match m = site.Regex.Match(relation.Target.AbsoluteUri);
if (m.Success)
{
string [] parameters = new string [m.Groups.Count];
for (int i = 1; i < m.Groups.Count; i++)
{
parameters[i - 1] = m.Groups[i].Value;
}
String uri = String.Format(site.ImgURI, parameters);
if (SaveCover(uri))
{
return(true);
}
}
}
if (relation.Type == "CoverArtLink" && SaveCover(relation.Target.AbsoluteUri))
{
return(true);
}
}
return(false);
}
public void CommitToIpod(IPod.Device device)
{
track = track ?? device.TrackDatabase.CreateTrack();
ExternalId = track.Id;
try {
track.Uri = new Uri(Uri.AbsoluteUri);
} catch (Exception e) {
Log.Exception("Failed to create System.Uri for iPod track", e);
device.TrackDatabase.RemoveTrack(track);
}
track.AlbumArtist = AlbumArtist;
track.BitRate = BitRate;
track.BPM = (short)Bpm;
track.Comment = Comment;
track.Composer = Composer;
track.DateAdded = DateAdded;
track.TotalDiscs = DiscCount;
track.DiscNumber = DiscNumber;
track.Duration = Duration;
track.Size = (int)FileSize;
track.Grouping = Grouping;
track.IsCompilation = IsCompilation;
track.LastPlayed = LastPlayed;
track.PlayCount = PlayCount;
track.TotalTracks = TrackCount;
track.TrackNumber = TrackNumber;
track.Year = Year;
track.DateReleased = ReleaseDate;
track.Album = AlbumTitle;
track.Artist = ArtistName;
track.Title = TrackTitle;
track.Genre = Genre;
switch (Rating)
{
case 1: track.Rating = IPod.TrackRating.Zero; break;
case 2: track.Rating = IPod.TrackRating.Two; break;
case 3: track.Rating = IPod.TrackRating.Three; break;
case 4: track.Rating = IPod.TrackRating.Four; break;
case 5: track.Rating = IPod.TrackRating.Five; break;
default: track.Rating = IPod.TrackRating.Zero; break;
}
if (HasAttribute(TrackMediaAttributes.Podcast))
{
track.DateReleased = ReleaseDate;
track.Description = description;
track.RememberPosition = true;
track.NotPlayedMark = track.PlayCount == 0;
}
if (HasAttribute(TrackMediaAttributes.VideoStream))
{
if (HasAttribute(TrackMediaAttributes.Podcast))
{
track.Type = IPod.MediaType.VideoPodcast;
}
else if (HasAttribute(TrackMediaAttributes.Music))
{
track.Type = IPod.MediaType.MusicVideo;
}
else if (HasAttribute(TrackMediaAttributes.Movie))
{
track.Type = IPod.MediaType.Movie;
}
else if (HasAttribute(TrackMediaAttributes.TvShow))
{
track.Type = IPod.MediaType.TVShow;
}
else
{
track.Type = IPod.MediaType.Video;
}
}
else
{
if (HasAttribute(TrackMediaAttributes.Podcast))
{
track.Type = IPod.MediaType.Podcast;
}
else if (HasAttribute(TrackMediaAttributes.AudioBook))
{
track.Type = IPod.MediaType.Audiobook;
}
else if (HasAttribute(TrackMediaAttributes.Music))
{
track.Type = IPod.MediaType.Audio;
}
else
{
track.Type = IPod.MediaType.Audio;
}
}
if (CoverArtSpec.CoverExists(ArtworkId))
{
SetIpodCoverArt(device, track, CoverArtSpec.GetPath(ArtworkId));
}
}
public void CommitToIpod(GPod.ITDB database)
{
bool addTrack = IpodTrack == null;
if (IpodTrack == null)
{
IpodTrack = new GPod.Track();
}
var track = IpodTrack;
track.Compilation = IsCompilation;
track.AlbumArtist = AlbumArtist;
track.Bitrate = BitRate;
track.Samplerate = (ushort)SampleRate;
track.BPM = (short)Bpm;
track.Comment = Comment;
track.Composer = Composer;
track.TimeAdded = DateTime.Now;
track.CDs = DiscCount;
track.CDNumber = DiscNumber;
track.TrackLength = (int)Duration.TotalMilliseconds;
track.Size = (int)FileSize;
track.Grouping = Grouping;
try {
track.TimePlayed = LastPlayed;
} catch {
Hyena.Log.InformationFormat("Couldn't set TimePlayed to '{0}'", LastPlayed);
}
track.PlayCount = (uint)PlayCount;
track.Tracks = TrackCount;
track.TrackNumber = TrackNumber;
track.Year = Year;
try {
track.TimeReleased = ReleaseDate;
} catch {
Hyena.Log.InformationFormat("Couldn't set TimeReleased to '{0}'", ReleaseDate);
}
track.Album = AlbumTitle;
track.Artist = ArtistName;
track.Title = TrackTitle;
track.Genre = Genre;
track.SortArtist = ArtistNameSort;
track.SortAlbum = AlbumTitleSort;
track.SortAlbumArtist = AlbumArtistSort;
track.SortTitle = TrackTitleSort;
track.Rating = ((Rating >= 1) && (Rating <= 5)) ? (uint)Rating : 0;
if (HasAttribute(TrackMediaAttributes.Podcast))
{
track.Description = description;
track.RememberPlaybackPosition = true;
track.SkipWhenShuffling = true;
track.Flag4 = (byte)1;
track.MarkUnplayed = (track.PlayCount == 0);
}
track.MediaType = GPod.MediaType.Audio;
if (HasAttribute(TrackMediaAttributes.VideoStream))
{
if (HasAttribute(TrackMediaAttributes.Podcast))
{
track.MediaType = GPod.MediaType.Podcast | GPod.MediaType.Movie;
}
else if (HasAttribute(TrackMediaAttributes.Music))
{
if (HasAttribute(TrackMediaAttributes.TvShow))
{
track.MediaType = GPod.MediaType.MusicTVShow;
}
else
{
track.MediaType = GPod.MediaType.MusicVideo;
}
}
else if (HasAttribute(TrackMediaAttributes.Movie))
{
track.MediaType = GPod.MediaType.Movie;
}
else if (HasAttribute(TrackMediaAttributes.TvShow))
{
track.MediaType = GPod.MediaType.TVShow;
}
else
{
// I dont' think AudioVideo should be used here; upon loading the tracks
// into Banshee, audio files often have AudioVideo (aka MediaType == 0) too.
//track.MediaType = GPod.MediaType.AudioVideo;
track.MediaType = GPod.MediaType.Movie;
}
}
else
{
if (HasAttribute(TrackMediaAttributes.Podcast))
{
track.MediaType = GPod.MediaType.Podcast;
}
else if (HasAttribute(TrackMediaAttributes.AudioBook))
{
track.MediaType = GPod.MediaType.Audiobook;
}
else if (HasAttribute(TrackMediaAttributes.Music))
{
track.MediaType = GPod.MediaType.Audio;
}
else
{
track.MediaType = GPod.MediaType.Audio;
}
}
if (addTrack)
{
track.Filetype = mimetype;
database.Tracks.Add(IpodTrack);
database.MasterPlaylist.Tracks.Add(IpodTrack);
if (HasAttribute(TrackMediaAttributes.Podcast) && database.Device.SupportsPodcast)
{
database.PodcastsPlaylist.Tracks.Add(IpodTrack);
}
database.CopyTrackToIPod(track, Uri.LocalPath);
Uri = new SafeUri(GPod.ITDB.GetLocalPath(database.Device, track));
ExternalId = (long)IpodTrack.DBID;
}
if (CoverArtSpec.CoverExists(ArtworkId))
{
string path = CoverArtSpec.GetPath(ArtworkId);
if (!track.ThumbnailsSet(path))
{
Log.Error(String.Format("Could not set cover art for {0}.", path));
}
}
else
{
track.ThumbnailsRemoveAll();
}
}
