def _splice_callback(self, src, result, data):
tmp_file, iostream = data
iostream.close_async(
GLib.PRIORITY_LOW, None, self._close_iostream_callback, None)
try:
src.splice_finish(result)
except GLib.Error as error:
logger.warning("Error: {}, {}".format(error.domain, error.message))
self.emit('unavailable')
return
success, cache_path = MediaArt.get_path(
self._artist, self._album, "album")
if not success:
self.emit('unavailable')
return
try:
# FIXME: I/O blocking
MediaArt.file_to_jpeg(tmp_file.get_path(), cache_path)
except GLib.Error as error:
logger.warning("Error: {}, {}".format(error.domain, error.message))
self.emit('unavailable')
return
self.emit('retrieved')
tmp_file.delete_async(
GLib.PRIORITY_LOW, None, self._delete_callback, None)
def _splice_callback(self, src, result, data):
tmp_file, iostream = data
iostream.close_async(GLib.PRIORITY_LOW, None,
self._close_iostream_callback, None)
try:
src.splice_finish(result)
except GLib.Error as error:
logger.warning("Error: {}, {}".format(error.domain, error.message))
self.emit('unavailable')
return
success, cache_path = MediaArt.get_path(self._artist, self._album,
"album")
if not success:
self.emit('unavailable')
return
try:
# FIXME: I/O blocking
MediaArt.file_to_jpeg(tmp_file.get_path(), cache_path)
except GLib.Error as error:
logger.warning("Error: {}, {}".format(error.domain, error.message))
self.emit('unavailable')
return
self.emit('retrieved')
tmp_file.delete_async(GLib.PRIORITY_LOW, None, self._delete_callback,
None)
def _splice_callback(self, src, result, data):
tmp_file, iostream = data
iostream.close_async(
GLib.PRIORITY_LOW, None, self._close_iostream_callback, None)
try:
src.splice_finish(result)
except GLib.Error as error:
logger.warning("Error: {}, {}".format(error.domain, error.message))
self._coreartist.props.cached_thumbnail_uri = ""
return
success, cache_path = MediaArt.get_path(self._artist, None, "artist")
if not success:
self._coreartist.props.cached_thumbnail_uri = ""
return
try:
# FIXME: I/O blocking
MediaArt.file_to_jpeg(tmp_file.get_path(), cache_path)
except GLib.Error as error:
logger.warning("Error: {}, {}".format(error.domain, error.message))
self._coreartist.props.cached_thumbnail_uri = ""
return
self._in_cache()
tmp_file.delete_async(
GLib.PRIORITY_LOW, None, self._delete_callback, None)
def splice_cb(src, result, data):
tmp_file, iostream = data
try:
src.splice_finish(result)
except Exception as err:
logger.warn("Error: %s, %s", err.__class__, err)
art_retrieved(False)
return
success, cache_path = MediaArt.get_path(artist, album, "album")
try:
# FIXME: I/O blocking
MediaArt.file_to_jpeg(tmp_file.get_path(), cache_path)
except Exception as err:
logger.warn("Error: %s, %s", err.__class__, err)
art_retrieved(False)
return
art_retrieved(True)
tmp_file.delete_async(GLib.PRIORITY_LOW,
None,
delete_cb,
None)
def lookup_worker(self, item, width, height, callback, itr, artist, album):
try:
width = width or -1
height = height or -1
path = MediaArt.get_path(artist, album, "album", None)[0]
if not os.path.exists(path):
self.cached_thumb_not_found(item, album, artist, path, callback, itr)
self.read_cached_pixbuf(path, width, height, callback, itr)
except Exception as e:
logger.warn("Error: %s" % e)
def query(self, coresong):
"""Start the local query
:param CoreSong coresong: The CoreSong object to search art for
"""
try:
if coresong.props.url is None:
self.emit('unavailable')
return
except AttributeError:
self.emit('unavailable')
return
# FIXME: coresong can be a CoreAlbum
try:
self._album = coresong.props.album
except AttributeError:
self._album = coresong.props.title
self._artist = coresong.props.artist
self._coresong = coresong
try:
discoverer = GstPbutils.Discoverer.new(Gst.SECOND)
except GLib.Error as error:
logger.warning("Error: {}, {}".format(error.domain, error.message))
self._lookup_cover_in_directory()
return
discoverer.connect('discovered', self._discovered)
discoverer.start()
success, path = MediaArt.get_path(self._artist, self._album, "album")
if not success:
self.emit('unavailable')
discoverer.stop()
return
self._path = path
success = discoverer.discover_uri_async(self._coresong.props.url)
if not success:
logger.warning("Could not add url to discoverer.")
self.emit('unavailable')
discoverer.stop()
return
def _lookup_embedded(self, item, art_size, callback, itr):
"""Lookup embedded cover
Lookup embedded art through Gst.Discoverer. If found
copy locally and call _lookup_local to finish retrieving
suitable art, otherwise follow up with _lookup_remote.
"""
album = utils.get_album_title(item)
artist = utils.get_artist_name(item)
success, cache_path = MediaArt.get_path(artist, album, "album")
if not success:
self._lookup_remote(item, art_size, callback, itr)
self._discoverer_items[item.get_url()] = [
item, art_size, callback, itr, cache_path
]
self._discoverer.discover_uri_async(item.get_url())
def lookup_worker(self, item, width, height, callback, itr, artist, album):
try:
if artist in self.blacklist and album in self.blacklist[artist]:
self.finish(item, None, None, callback, itr)
return
path = MediaArt.get_path(artist, album, "album", None)[0]
while path in self.queue:
sleep(0.5)
self.queue.append(path)
if not os.path.exists(path):
GLib.idle_add(self.cached_thumb_not_found, item, width, height, path, callback, itr, artist, album)
return
width = width or -1
height = height or -1
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale(path, width, height, True)
self.finish(item, _make_icon_frame(pixbuf), path, callback, itr)
except Exception as e:
logger.warn("Error: %s" % e)
def query(self, media):
"""Start the local query
:param Grl.Media media: The media object to search art for
"""
if media.get_url() is None:
self.emit('unavailable')
return
self._album = utils.get_album_title(media)
self._artist = utils.get_artist_name(media)
self._media = media
try:
discoverer = GstPbutils.Discoverer.new(Gst.SECOND)
except GLib.Error as error:
logger.warning("Error: {}, {}".format(error.domain, error.message))
self._lookup_cover_in_directory()
return
discoverer.connect('discovered', self._discovered)
discoverer.start()
success, path = MediaArt.get_path(self._artist, self._album, "album")
if not success:
self.emit('unavailable')
discoverer.stop()
return
self._path = path
success = discoverer.discover_uri_async(self._media.get_url())
if not success:
logger.warning("Could not add url to discoverer.")
self.emit('unavailable')
discoverer.stop()
return
def splice_cb(src, result, data):
tmp_file, iostream = data
try:
src.splice_finish(result)
except Exception as err:
logger.warn("Error: %s, %s", err.__class__, err)
art_retrieved(False)
return
success, cache_path = MediaArt.get_path(artist, album, "album")
try:
# FIXME: I/O blocking
MediaArt.file_to_jpeg(tmp_file.get_path(), cache_path)
except Exception as err:
logger.warn("Error: %s, %s", err.__class__, err)
art_retrieved(False)
return
art_retrieved(True)
tmp_file.delete_async(GLib.PRIORITY_LOW, None, delete_cb, None)
def query(self, media):
"""Start the local query
:param Grl.Media media: The media object to search art for
"""
if media.get_url() is None:
self.emit('unavailable')
return
self._album = utils.get_album_title(media)
self._artist = utils.get_artist_name(media)
self._media = media
try:
discoverer = GstPbutils.Discoverer.new(Gst.SECOND)
except GLib.Error as error:
logger.warning("Error: {}, {}".format(error.domain, error.message))
self._lookup_cover_in_directory()
return
discoverer.connect('discovered', self._discovered)
discoverer.start()
success, path = MediaArt.get_path(self._artist, self._album, "album")
if not success:
self.emit('unavailable')
discoverer.stop()
return
self._path = path
success = discoverer.discover_uri_async(self._media.get_url())
if not success:
logger.warning("Could not add url to discoverer.")
self.emit('unavailable')
discoverer.stop()
return
def lookup_worker(self, item, width, height, callback, itr, artist, album):
try:
if artist in self.blacklist and album in self.blacklist[artist]:
self.finish(item, None, None, callback, itr, width, height)
return
path = None
mediaart_tuple = MediaArt.get_path(artist, album, "album")
for i in mediaart_tuple:
if isinstance(i, str):
path = i
break
if not os.path.exists(path):
GLib.idle_add(self.cached_thumb_not_found, item, width, height, path, callback, itr, artist, album)
return
width = width or -1
height = height or -1
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale(path, width, height, True)
self.finish(item, _make_icon_frame(pixbuf), path, callback, itr, width, height)
except Exception as e:
logger.warn("Error: %s", e)
def lookup_worker(self, item, width, height, callback, itr, artist, album):
try:
if artist in self.blacklist and album in self.blacklist[artist]:
self.finish(item, None, None, callback, itr)
return
path = None
mediaart_tuple = MediaArt.get_path(artist, album, "album")
for i in mediaart_tuple:
if isinstance(i, str):
path = i
break
if not os.path.exists(path):
GLib.idle_add(self.cached_thumb_not_found, item, width, height, path, callback, itr, artist, album)
return
width = width or -1
height = height or -1
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale(path, width, height, True)
self.finish(item, _make_icon_frame(pixbuf), path, callback, itr)
except Exception as e:
logger.warn("Error: %s" % e)
