def restore(self):
text = config.get("browsers", "query_text").decode("utf-8")
entry = self.__search
entry.set_text(text)
# update_filter expects a parsable query
if Query.is_parsable(text):
self.__update_filter(entry, text, scroll_up=False, restore=True)
keys = config.get("browsers", "albums").split("\n")
# FIXME: If albums is "" then it could be either all albums or
# no albums. If it's "" and some other stuff, assume no albums,
# otherwise all albums.
self.__inhibit()
if keys == [""]:
self.view.set_cursor((0,))
else:
def select_fun(row):
album = row[0]
if not album: # all
return False
return album.str_key in keys
self.view.select_by_func(select_fun)
self.__uninhibit()
def test_get_columns_migrated(self):
self.failIf(config.get("settings", "headers", None))
columns = "~album,~#replaygain_track_gain,foobar"
config.set("settings", "columns", columns)
self.failUnlessEqual(get_columns(),
["~album", "~#replaygain_track_gain", "foobar"])
self.failIf(config.get("settings", "headers", None))
def refresh_cb(button):
from quodlibet.library import library
from quodlibet.util import copool
paths = util.split_scan_dirs(config.get("settings", "scan"))
exclude = config.get("library", "exclude").split(":")
copool.add(library.rebuild,
paths, False, exclude, cofuncid="library", funcid="library")
def __init__(self):
super(PreferencesWindow.Tagging, self).__init__(spacing=12)
self.set_border_width(12)
self.title = _("Tags")
vbox = gtk.VBox(spacing=6)
cb = ConfigCheckButton(_("Auto-save tag changes"),
'editing', 'auto_save_changes',
populate=True)
cb.set_tooltip_text(_("Save changes to tags without confirmation "
"when editing multiple files"))
vbox.pack_start(cb, expand=False)
cb = ConfigCheckButton(_("Show _programmatic tags"),
'editing', 'alltags', populate=True)
cb.set_tooltip_text(
_("Access all tags, including machine-generated ones "
"e.g. MusicBrainz or Replay Gain tags"))
vbox.pack_start(cb, expand=False)
hb = gtk.HBox(spacing=6)
e = UndoEntry()
e.set_text(config.get("editing", "split_on"))
e.connect('changed', self.__changed, 'editing', 'split_on')
e.set_tooltip_text(
_("A list of separators to use when splitting tag values. "
"The list is space-separated"))
l = gtk.Label(_("Split _on:"))
l.set_use_underline(True)
l.set_mnemonic_widget(e)
hb.pack_start(l, expand=False)
hb.pack_start(e)
vbox.pack_start(hb, expand=False)
vb2 = gtk.VBox(spacing=6)
cb = ConfigCheckButton(_("Save ratings and play _counts"),
"editing", "save_to_songs", populate=True)
vb2.pack_start(cb)
hb = gtk.HBox(spacing=6)
lab = gtk.Label(_("_Email:"))
entry = UndoEntry()
entry.set_tooltip_text(_("Ratings and play counts will be set "
"for this email address"))
entry.set_text(config.get("editing", "save_email"))
entry.connect('changed', self.__changed, 'editing', 'save_email')
hb.pack_start(lab, expand=False)
hb.pack_start(entry)
lab.set_mnemonic_widget(entry)
lab.set_use_underline(True)
vb2.pack_start(hb)
f = qltk.Frame(_("Tag Editing"), child=vbox)
self.pack_start(f, expand=False)
f = qltk.Frame(_("Ratings"), child=vb2)
self.pack_start(f, expand=False)
self.show_all()
def __init__(self):
print_d("Starting Soundcloud API...")
super(SoundcloudApiClient, self).__init__(self.API_ROOT)
self.access_token = config.get("browsers", "soundcloud_token", None)
self.online = bool(self.access_token)
self.user_id = config.get("browsers", "soundcloud_user_id", None)
if not self.user_id:
self._get_me()
self.username = None
def test_get_columns_migrates(self):
self.failIf(config.get("settings", "headers", None))
self.failIf(config.get("settings", "columns", None))
headers = "~album ~#replaygain_track_gain foobar"
config.set("settings", "headers", headers)
columns = get_columns()
self.failUnlessEqual(columns, ["~album", "~#replaygain_track_gain",
"foobar"])
self.failIf(config.get("settings", "headers", None))
def test_get_set_columns(self):
self.failIf(config.get("settings", "headers", None))
self.failIf(config.get("settings", "columns", None))
columns = ["first", "won't", "two words", "4"]
set_columns(columns)
self.failUnlessEqual(columns, get_columns())
columns += ["~~another~one"]
set_columns(columns)
self.failUnlessEqual(columns, get_columns())
self.failIf(config.get("settings", "headers", None))
def restore(self):
try:
name = config.get("browsers", "playlist")
except config.Error as e:
print_d("Couldn't get last playlist from config: %s" % e)
else:
self.__view.select_by_func(lambda r: r[0].name == name, one=True)
try:
text = config.get("browsers", "query_text")
except config.Error as e:
print_d("Couldn't get last search string from config: %s" % e)
else:
self._set_text(text)
def connect(self):
'''Moved from __init__ to ensure we always read the current
configuration data'''
self._host = config.get("connection", "hostname")
self._port = config.get("connection", "port")
self._password = config.get("connection", "password")
try:
self._client.connect(self._host, self._port)
# Catch socket errors
except IOError as (errno, strerror):
raise PollerError("Could not connect to '%s': %s" %
(self._host, strerror))
def _get_order(self, shuffle):
"""Get the active order for shuffle/inorder mode"""
first_matching = None
if shuffle:
name = config.get("memory", "order_shuffle")
else:
name = config.get("memory", "order")
for order in ORDERS:
if order.is_shuffle == shuffle:
first_matching = first_matching or order
if order.name == name:
return order
return first_matching
def restore(self):
try:
text = config.get("browsers", "query_text")
except config.Error:
return
self._set_text(text)
def __init__(self, tag, value):
super(SplitPerson, self).__init__(label=self.title, use_underline=True)
self.set_image(Gtk.Image.new_from_icon_name(
Icons.EDIT_FIND_REPLACE, Gtk.IconSize.MENU))
spls = config.get("editing", "split_on").decode(
'utf-8', 'replace').split()
self.set_sensitive(bool(split_people(value, spls)[1]))
def __post_read(self):
email = config.get("editing", "save_email").strip()
maps = {"rating": float, "playcount": int}
for keyed_key, func in maps.items():
for subkey in ["", ":" + const.EMAIL, ":" + email]:
key = keyed_key + subkey
if key in self:
try:
self["~#" + keyed_key] = func(self[key])
except ValueError:
pass
del(self[key])
if "metadata_block_picture" in self:
self.has_images = True
del(self["metadata_block_picture"])
if "coverart" in self:
self.has_images = True
del(self["coverart"])
if "coverartmime" in self:
del(self["coverartmime"])
self.__post_read_total("tracktotal", "totaltracks", "tracknumber")
self.__post_read_total("disctotal", "totaldiscs", "discnumber")
def plugin_on_song_started(self, song):
if (song is None and config.get("memory", "order") != "onesong" and
not app.player.paused):
browser = app.window.browser
if not browser.can_filter('album'):
return
albumlib = app.library.albums
albumlib.load()
if browser.can_filter_albums():
keys = browser.list_albums()
values = [albumlib[k] for k in keys]
else:
keys = set(browser.list("album"))
values = [a for a in albumlib if a("album") in keys]
if self.use_weights:
# Select 3% of albums, or at least 3 albums
nr_albums = int(min(len(values), max(0.03 * len(values), 3)))
chosen_albums = random.sample(values, nr_albums)
album_scores = sorted(self._score(chosen_albums))
for score, album in album_scores:
print_d("%0.2f scored by %s" % (score, album("album")))
album = max(album_scores)[1]
else:
album = random.choice(values)
if album is not None:
self.schedule_change(album)
def refresh(self):
"""Reread the current pipeline config and refresh the list"""
self.handler_block(self.__sig)
model = self.get_model()
model.clear()
self.__fill_model(model)
if not len(model):
self.handler_unblock(self.__sig)
# Translators: Unknown audio output device.
model.append(row=["", _("Unknown")])
self.set_active(0)
self.set_sensitive(False)
return
self.set_sensitive(True)
# Translators: Default audio output device.
model.insert(0, row=["", _("Default")])
dev = config.get("player", "gst_device")
for row in model:
if row[self.DEVICE] == dev:
self.set_active_iter(row.iter)
break
self.handler_unblock(self.__sig)
# If no dev was found, change to default so the config gets reset
if self.get_active() == -1:
self.set_active(0)
def tag_editing_vbox(self):
"""Returns a new VBox containing all tag editing widgets"""
vbox = Gtk.VBox(spacing=6)
cb = CCB(_("Auto-save tag changes"), 'editing',
'auto_save_changes', populate=True,
tooltip=_("Save changes to tags without confirmation "
"when editing multiple files"))
vbox.pack_start(cb, False, True, 0)
hb = Gtk.HBox(spacing=6)
e = UndoEntry()
e.set_text(config.get("editing", "split_on"))
e.connect('changed', self.__changed, 'editing', 'split_on')
e.set_tooltip_text(
_("A list of separators to use when splitting tag values. "
"The list is space-separated"))
def do_revert_split(button, section, option):
config.reset(section, option)
e.set_text(config.get(section, option))
split_revert = Button(_("_Revert"), Icons.DOCUMENT_REVERT)
split_revert.connect("clicked", do_revert_split, "editing",
"split_on")
l = Gtk.Label(label=_("Split _on:"))
l.set_use_underline(True)
l.set_mnemonic_widget(e)
hb.pack_start(l, False, True, 0)
hb.pack_start(e, True, True, 0)
hb.pack_start(split_revert, False, True, 0)
vbox.pack_start(hb, False, True, 0)
return vbox
def config_get(key, default=''):
"""Returns value for 'key' from config. If key is missing *or empty*,
return default."""
try:
return (config.get("plugins", "scrobbler_%s" % key) or default)
except config.Error:
return default
def restore(self):
try:
names = config.get("browsers", "audiofeeds").split("\t")
except:
pass
else:
self.__view.select_by_func(lambda r: r[0].name in names)
def restore(self):
try:
paths = config.get("browsers", "filesystem").split("\n")
except config.Error:
pass
else:
self.__select_paths(paths)
def get_init_select_dir():
scandirs = util.split_scan_dirs(config.get("settings", "scan"))
if scandirs and os.path.isdir(scandirs[-1]):
# start with last added directory
return scandirs[-1]
else:
return const.HOME
def restore(self):
try:
text = config.get("browsers", "query_text")
except Exception:
return
self._text = text
def __init__(self):
super(ScanBox, self).__init__(spacing=6)
self.model = model = gtk.ListStore(str)
view = RCMHintedTreeView(model)
view.set_fixed_height_mode(True)
view.set_headers_visible(False)
view.set_tooltip_text(_("Songs in the listed folders will be "
"added to the library during a library refresh"))
menu = gtk.Menu()
remove_item = gtk.ImageMenuItem(gtk.STOCK_REMOVE)
menu.append(remove_item)
menu.show_all()
view.connect('popup-menu', self.__popup, menu)
remove_item.connect_object('activate', self.__remove, view)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_IN)
sw.add(view)
sw.set_size_request(-1, max(sw.size_request()[1], 100))
render = gtk.CellRendererText()
render.set_property('ellipsize', pango.ELLIPSIZE_END)
def cdf(column, cell, model, iter):
row = model[iter]
cell.set_property('text', util.unexpand(row[0]))
column = gtk.TreeViewColumn(None, render)
column.set_cell_data_func(render, cdf)
column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
view.append_column(column)
add = gtk.Button(stock=gtk.STOCK_ADD)
add.connect("clicked", self.__add)
remove = gtk.Button(stock=gtk.STOCK_REMOVE)
selection = view.get_selection()
selection.set_mode(gtk.SELECTION_MULTIPLE)
selection.connect("changed", self.__select_changed, remove)
selection.emit("changed")
remove.connect_object("clicked", self.__remove, view)
vbox = gtk.VBox(spacing=6)
vbox.pack_start(add, expand=False)
vbox.pack_start(remove, expand=False)
self.pack_start(sw)
self.pack_start(vbox, expand=False)
self.show_all()
paths = util.split_scan_dirs(config.get("settings", "scan"))
paths = map(util.fsdecode, paths)
for path in paths:
model.append(row=[path])
def init(librarian):
"""May raise PlayerError"""
try:
driver = config.get("settings", "xine_driver")
except:
driver = None
return XinePlaylistPlayer(driver, librarian)
def background_filter():
bg = config.get("browsers", "background").decode('utf-8')
if not bg:
return
try:
return Query(bg, SongList.star).search
except Query.error:
pass
def __init__(self, tag, value):
super(SplitValues, self).__init__(
label=_("Split into _Multiple Values"), use_underline=True)
self.set_image(Gtk.Image.new_from_icon_name(
Icons.EDIT_FIND_REPLACE, Gtk.IconSize.MENU))
spls = config.get("editing", "split_on").decode(
'utf-8', 'replace').split()
self.set_sensitive(len(split_value(value, spls)) > 1)
def __cols_changed(self, songlist):
headers = [col.header_name for col in songlist.get_columns()]
try: headers.remove('~current')
except ValueError: pass
if len(headers) == len(config.get("settings", "headers").split()):
# Not an addition or removal (handled separately)
config.set("settings", "headers", " ".join(headers))
SongList.headers = headers
def get_headers():
# QL <= 2.1 saved the headers tab-separated, but had a space-separated
# default value, so check for that.
headers = config.get("browsers", "panes")
if headers == "~people album":
return headers.split()
else:
return headers.split("\t")
def __init__(self):
try:
self._times = config.get("plugins", self._pref_name).split(' ')[:7]
except:
pass
else:
self._times = (self._times + ["HH:MM"] * 7)[:7]
GLib.timeout_add(30000, self._check)
def enabled(self):
self.__enabled = True
self.__init_defaults()
theme = config.get("plugins", self.CONFIG_THEME, None)
self.__set_theme(theme)
self.__set_dark(self.__get_dark())
def restore(cls, library, player):
"""restore saved browser windows"""
value = config.get("memory", "open_browsers", "")
for name in value.split():
kind = browsers.get(name)
browser = cls(kind, library, player)
browser.show_maybe()
def __create_menu(self, player, library):
def add_view_items(ag):
act = Action(name="Information",
label=_('_Information'),
icon_name=Icons.DIALOG_INFORMATION)
act.connect('activate', self.__current_song_info)
ag.add_action(act)
act = Action(name="Jump",
label=_('_Jump to Playing Song'),
icon_name=Icons.GO_JUMP)
self.__jump_to_current(True, None, True)
act.connect('activate', self.__jump_to_current)
ag.add_action_with_accel(act, "<Primary>J")
def add_top_level_items(ag):
ag.add_action(Action(name="File", label=_("_File")))
ag.add_action(Action(name="Song", label=_("_Song")))
ag.add_action(Action(name="View", label=_('_View')))
ag.add_action(Action(name="Browse", label=_("_Browse")))
ag.add_action(Action(name="Control", label=_('_Control')))
ag.add_action(Action(name="Help", label=_('_Help')))
ag = Gtk.ActionGroup.new('QuodLibetWindowActions')
add_top_level_items(ag)
add_view_items(ag)
act = Action(name="AddFolders",
label=_(u'_Add a Folder…'),
icon_name=Icons.LIST_ADD)
act.connect('activate', self.open_chooser)
ag.add_action_with_accel(act, "<Primary>O")
act = Action(name="AddFiles",
label=_(u'_Add a File…'),
icon_name=Icons.LIST_ADD)
act.connect('activate', self.open_chooser)
ag.add_action(act)
act = Action(name="AddLocation",
label=_(u'_Add a Location…'),
icon_name=Icons.LIST_ADD)
act.connect('activate', self.open_location)
ag.add_action(act)
act = Action(name="BrowseLibrary",
label=_('Open _Browser'),
icon_name=Icons.EDIT_FIND)
ag.add_action(act)
act = Action(name="Preferences",
label=_('_Preferences'),
icon_name=Icons.PREFERENCES_SYSTEM)
act.connect('activate', self.__preferences)
ag.add_action(act)
act = Action(name="Plugins",
label=_('_Plugins'),
icon_name=Icons.SYSTEM_RUN)
act.connect('activate', self.__plugins)
ag.add_action(act)
act = Action(name="Quit",
label=_('_Quit'),
icon_name=Icons.APPLICATION_EXIT)
act.connect('activate', lambda *x: self.destroy())
ag.add_action_with_accel(act, "<Primary>Q")
act = Action(name="EditTags",
label=_('Edit _Tags'),
icon_name=Icons.DOCUMENT_PROPERTIES)
act.connect('activate', self.__current_song_prop)
ag.add_action(act)
act = Action(name="EditBookmarks", label=_(u"Edit Bookmarks…"))
connect_obj(act, 'activate', self.__edit_bookmarks, library.librarian,
player)
ag.add_action_with_accel(act, "<Primary>B")
act = Action(name="Previous",
label=_('Pre_vious'),
icon_name=Icons.MEDIA_SKIP_BACKWARD)
act.connect('activate', self.__previous_song)
ag.add_action_with_accel(act, "<Primary>comma")
act = Action(name="PlayPause",
label=_('_Play'),
icon_name=Icons.MEDIA_PLAYBACK_START)
act.connect('activate', self.__play_pause)
ag.add_action_with_accel(act, "<Primary>space")
act = Action(name="Next",
label=_('_Next'),
icon_name=Icons.MEDIA_SKIP_FORWARD)
act.connect('activate', self.__next_song)
ag.add_action_with_accel(act, "<Primary>period")
act = ToggleAction(name="StopAfter", label=_("Stop After This Song"))
ag.add_action_with_accel(act, "<shift>space")
# access point for the tray icon
self.stop_after = act
act = Action(name="Shortcuts", label=_("_Keyboard Shortcuts"))
act.connect('activate', self.__keyboard_shortcuts)
ag.add_action_with_accel(act, "<Primary>question")
act = Action(name="About",
label=_("_About"),
icon_name=Icons.HELP_ABOUT)
act.connect('activate', self.__show_about)
ag.add_action_with_accel(act, None)
act = Action(name="OnlineHelp",
label=_("Online Help"),
icon_name=Icons.HELP_BROWSER)
def website_handler(*args):
util.website(const.ONLINE_HELP)
act.connect('activate', website_handler)
ag.add_action_with_accel(act, "F1")
act = Action(name="SearchHelp", label=_("Search Help"))
def search_help_handler(*args):
util.website(const.SEARCH_HELP)
act.connect('activate', search_help_handler)
ag.add_action_with_accel(act, None)
act = Action(name="CheckUpdates",
label=_("_Check for Updates…"),
icon_name=Icons.NETWORK_SERVER)
def check_updates_handler(*args):
d = UpdateDialog(self)
d.run()
d.destroy()
act.connect('activate', check_updates_handler)
ag.add_action_with_accel(act, None)
act = Action(name="RefreshLibrary",
label=_("_Scan Library"),
icon_name=Icons.VIEW_REFRESH)
act.connect('activate', self.__rebuild, False)
ag.add_action(act)
current = config.get("memory", "browser")
try:
browsers.get(current)
except ValueError:
current = browsers.name(browsers.default)
first_action = None
for Kind in browsers.browsers:
name = browsers.name(Kind)
index = browsers.index(name)
action_name = "View" + Kind.__name__
act = RadioAction(name=action_name,
label=Kind.accelerated_name,
value=index)
act.join_group(first_action)
first_action = first_action or act
if name == current:
act.set_active(True)
ag.add_action_with_accel(act, "<Primary>%d" % ((index + 1) % 10, ))
assert first_action
self._browser_action = first_action
def action_callback(view_action, current_action):
current = browsers.name(
browsers.get(current_action.get_current_value()))
self._select_browser(view_action, current, library, player)
first_action.connect("changed", action_callback)
for Kind in browsers.browsers:
action = "Browser" + Kind.__name__
label = Kind.accelerated_name
name = browsers.name(Kind)
index = browsers.index(name)
act = Action(name=action, label=label)
def browser_activate(action, Kind):
LibraryBrowser.open(Kind, library, player)
act.connect('activate', browser_activate, Kind)
ag.add_action_with_accel(act,
"<Primary><alt>%d" % ((index + 1) % 10, ))
ui = Gtk.UIManager()
ui.insert_action_group(ag, -1)
menustr = MENU % {
"views": browser_menu_items(),
"browsers": secondary_browser_menu_items(),
"filters_menu": FilterMenu.MENU
}
ui.add_ui_from_string(menustr)
self._filter_menu = FilterMenu(library, player, ui)
# Cute. So. UIManager lets you attach tooltips, but when they're
# for menu items, they just get ignored. So here I get to actually
# attach them.
ui.get_widget("/Menu/File/RefreshLibrary").set_tooltip_text(
_("Check for changes in your library"))
return ui
def CODECS(self):
codecs = ["utf-8"]
codecs_conf = config.get("editing", "id3encoding")
codecs.extend(codecs_conf.strip().split())
codecs.append("iso-8859-1")
return codecs
def __init__(self):
super(PreferencesWindow.Browsers, self).__init__(spacing=12)
self.set_border_width(12)
self.title = _("Browsers")
# Search
vb = Gtk.VBox(spacing=6)
hb = Gtk.HBox(spacing=6)
l = Gtk.Label(label=_("_Global filter:"))
l.set_use_underline(True)
e = ValidatingEntry(QueryValidator)
e.set_text(config.get("browsers", "background"))
e.connect('changed', self._entry, 'background', 'browsers')
e.set_tooltip_text(_("Apply this query in addition to all others"))
l.set_mnemonic_widget(e)
hb.pack_start(l, False, True, 0)
hb.pack_start(e, True, True, 0)
vb.pack_start(hb, False, True, 0)
# Translators: The heading of the preference group, no action
f = qltk.Frame(C_("heading", "Search"), child=vb)
self.pack_start(f, False, True, 0)
# Ratings
vb = Gtk.VBox(spacing=6)
c1 = CCB(_("Confirm _multiple ratings"),
'browsers',
'rating_confirm_multiple',
populate=True,
tooltip=_("Ask for confirmation before changing the "
"rating of multiple songs at once"))
c2 = CCB(_("Enable _one-click ratings"),
'browsers',
'rating_click',
populate=True,
tooltip=_("Enable rating by clicking on the rating "
"column in the song list"))
vbox = Gtk.VBox(spacing=6)
vbox.pack_start(c1, False, True, 0)
vbox.pack_start(c2, False, True, 0)
f = qltk.Frame(_("Ratings"), child=vbox)
self.pack_start(f, False, True, 0)
# Album Art
vb = Gtk.VBox(spacing=6)
c = CCB(_("_Use rounded corners on thumbnails"),
'albumart',
'round',
populate=True,
tooltip=_("Round the corners of album artwork thumbnail "
"images."))
c.connect('toggled', self.__toggle_round_corners)
vb.pack_start(c, False, True, 0)
# Filename choice algorithm config
cb = CCB(_("Prefer _embedded art"),
'albumart',
'prefer_embedded',
populate=True,
tooltip=_("Choose to use artwork embedded in the audio "
"(where available) over other sources"))
vb.pack_start(cb, False, True, 0)
hb = Gtk.HBox(spacing=3)
cb = CCB(_("_Fixed image filename:"),
'albumart',
'force_filename',
populate=True,
tooltip=_("The single image filename to use if "
"selected"))
hb.pack_start(cb, False, True, 0)
entry = UndoEntry()
entry.set_tooltip_text(
_("The album art image file to use when forced"))
entry.set_text(config.get("albumart", "filename"))
entry.connect('changed', self.__changed_text, 'filename')
# Disable entry when not forcing
entry.set_sensitive(cb.get_active())
cb.connect('toggled', self.__toggled_force_filename, entry)
hb.pack_start(entry, True, True, 0)
vb.pack_start(hb, False, True, 0)
f = qltk.Frame(_("Album Art"), child=vb)
self.pack_start(f, False, True, 0)
for child in self.get_children():
child.show_all()
def main(argv=None):
if argv is None:
argv = sys_argv
import quodlibet
config_file = os.path.join(quodlibet.get_user_dir(), "config")
quodlibet.init_cli(config_file=config_file)
try:
# we want basic commands not to import gtk (doubles process time)
assert "gi.repository.Gtk" not in sys.modules
sys.modules["gi.repository.Gtk"] = None
startup_actions, cmds_todo = process_arguments(argv)
finally:
sys.modules.pop("gi.repository.Gtk", None)
quodlibet.init()
from quodlibet import app
from quodlibet.qltk import add_signal_watch
add_signal_watch(app.quit)
import quodlibet.player
import quodlibet.library
from quodlibet import config
from quodlibet import browsers
from quodlibet import util
app.name = "Quod Libet"
app.description = _("Music player and music library manager")
app.id = "io.github.quodlibet.QuodLibet"
app.process_name = "quodlibet"
quodlibet.set_application_info(app)
library_path = os.path.join(quodlibet.get_user_dir(), "songs")
print_d("Initializing main library (%s)" % (
quodlibet.util.path.unexpand(library_path)))
library = quodlibet.library.init(library_path)
app.library = library
# this assumes that nullbe will always succeed
from quodlibet.player import PlayerError
wanted_backend = environ.get(
"QUODLIBET_BACKEND", config.get("player", "backend"))
try:
player = quodlibet.player.init_player(wanted_backend, app.librarian)
except PlayerError:
print_exc()
player = quodlibet.player.init_player("nullbe", app.librarian)
app.player = player
environ["PULSE_PROP_media.role"] = "music"
environ["PULSE_PROP_application.icon_name"] = app.icon_name
browsers.init()
from quodlibet.qltk.songlist import SongList, get_columns
headers = get_columns()
SongList.set_all_column_headers(headers)
for opt in config.options("header_maps"):
val = config.get("header_maps", opt)
util.tags.add(opt, val)
in_all = ("~filename ~uri ~#lastplayed ~#rating ~#playcount ~#skipcount "
"~#added ~#bitrate ~current ~#laststarted ~basename "
"~dirname").split()
for Kind in browsers.browsers:
if Kind.headers is not None:
Kind.headers.extend(in_all)
Kind.init(library)
pm = quodlibet.init_plugins("no-plugins" in startup_actions)
if hasattr(player, "init_plugins"):
player.init_plugins()
from quodlibet.qltk import unity
unity.init("io.github.quodlibet.QuodLibet.desktop", player)
from quodlibet.qltk.songsmenu import SongsMenu
SongsMenu.init_plugins()
from quodlibet.util.cover import CoverManager
app.cover_manager = CoverManager()
app.cover_manager.init_plugins()
from quodlibet.plugins.playlist import PLAYLIST_HANDLER
PLAYLIST_HANDLER.init_plugins()
from quodlibet.plugins.query import QUERY_HANDLER
QUERY_HANDLER.init_plugins()
from gi.repository import GLib
from quodlibet.commands import registry as cmd_registry, CommandError
def exec_commands(*args):
for cmd in cmds_todo:
try:
resp = cmd_registry.run(app, *cmd)
except CommandError:
pass
else:
if resp is not None:
print_(resp, end="", flush=True)
from quodlibet.qltk.quodlibetwindow import QuodLibetWindow, PlayerOptions
# Call exec_commands after the window is restored, but make sure
# it's after the mainloop has started so everything is set up.
app.window = window = QuodLibetWindow(
library, player,
restore_cb=lambda:
GLib.idle_add(exec_commands, priority=GLib.PRIORITY_HIGH))
app.player_options = PlayerOptions(window)
from quodlibet.qltk.window import Window
from quodlibet.plugins.events import EventPluginHandler
from quodlibet.plugins.gui import UserInterfacePluginHandler
pm.register_handler(EventPluginHandler(library.librarian, player,
app.window.songlist))
pm.register_handler(UserInterfacePluginHandler())
from quodlibet.mmkeys import MMKeysHandler
from quodlibet.remote import Remote, RemoteError
from quodlibet.qltk.tracker import SongTracker, FSInterface
try:
from quodlibet.qltk.dbus_ import DBusHandler
except ImportError:
DBusHandler = None
mmkeys_handler = MMKeysHandler(app)
mmkeys_handler.start()
current_path = os.path.join(quodlibet.get_user_dir(), "current")
fsiface = FSInterface(current_path, player)
remote = Remote(app, cmd_registry)
try:
remote.start()
except RemoteError:
exit_(1, True)
if DBusHandler is not None:
DBusHandler(player, library)
tracker = SongTracker(library.librarian, player, window.playlist)
from quodlibet import session
session_client = session.init(app)
quodlibet.enable_periodic_save(save_library=True)
if ("start-playing" in startup_actions or
(config.getboolean("player", "restore_playing", False) and
config.getboolean("player", "is_playing", False))):
player.paused = False
if "start-hidden" in startup_actions:
Window.prevent_inital_show(True)
# restore browser windows
from quodlibet.qltk.browser import LibraryBrowser
GLib.idle_add(LibraryBrowser.restore, library, player,
priority=GLib.PRIORITY_HIGH)
def before_quit():
print_d("Saving active browser state")
try:
app.browser.save()
except NotImplementedError:
pass
print_d("Shutting down player device %r." % player.version_info)
player.destroy()
quodlibet.run(window, before_quit=before_quit)
app.player_options.destroy()
quodlibet.finish_first_session("quodlibet")
mmkeys_handler.quit()
remote.stop()
fsiface.destroy()
tracker.destroy()
quodlibet.library.save()
config.save()
session_client.close()
print_d("Finished shutdown.")
if app.is_restarting:
os.execv(sys.executable, [sys.executable] + sys.argv)
def __init_pipeline(self):
"""Creates a gstreamer pipeline. Returns True on success."""
if self.bin:
return True
pipeline = config.get("player", "gst_pipeline")
try:
pipeline, self._pipeline_desc = GStreamerSink(pipeline)
except PlayerError as e:
self._error(e)
return False
if self._use_eq and Gst.ElementFactory.find('equalizer-10bands'):
# The equalizer only operates on 16-bit ints or floats, and
# will only pass these types through even when inactive.
# We push floats through to this point, then let the second
# audioconvert handle pushing to whatever the rest of the
# pipeline supports. As a bonus, this seems to automatically
# select the highest-precision format supported by the
# rest of the chain.
filt = Gst.ElementFactory.make('capsfilter', None)
filt.set_property('caps',
Gst.Caps.from_string('audio/x-raw,format=F32LE'))
eq = Gst.ElementFactory.make('equalizer-10bands', None)
self._eq_element = eq
self.update_eq_values()
conv = Gst.ElementFactory.make('audioconvert', None)
resample = Gst.ElementFactory.make('audioresample', None)
pipeline = [filt, eq, conv, resample] + pipeline
# playbin2 has started to control the volume through pulseaudio,
# which means the volume property can change without us noticing.
# Use our own volume element for now until this works with PA.
self._vol_element = Gst.ElementFactory.make('volume', None)
pipeline.insert(0, self._vol_element)
# Get all plugin elements and append audio converters.
# playbin already includes one at the end
plugin_pipeline = []
for plugin in self._get_plugin_elements():
plugin_pipeline.append(plugin)
plugin_pipeline.append(
Gst.ElementFactory.make('audioconvert', None))
plugin_pipeline.append(
Gst.ElementFactory.make('audioresample', None))
pipeline = plugin_pipeline + pipeline
bufbin = Gst.Bin()
for element in pipeline:
assert element is not None, pipeline
bufbin.add(element)
PIPELINE_ERROR = PlayerError(_("Could not create GStreamer pipeline"))
if len(pipeline) > 1:
if not link_many(pipeline):
print_w("Linking the GStreamer pipeline failed")
self._error(PIPELINE_ERROR)
return False
# Test to ensure output pipeline can preroll
bufbin.set_state(Gst.State.READY)
result, state, pending = bufbin.get_state(timeout=STATE_CHANGE_TIMEOUT)
if result == Gst.StateChangeReturn.FAILURE:
bufbin.set_state(Gst.State.NULL)
print_w("Prerolling the GStreamer pipeline failed")
self._error(PIPELINE_ERROR)
return False
# Make the sink of the first element the sink of the bin
gpad = Gst.GhostPad.new('sink', pipeline[0].get_static_pad('sink'))
bufbin.add_pad(gpad)
self.bin = Gst.ElementFactory.make('playbin', None)
assert self.bin
bus = self.bin.get_bus()
bus.add_signal_watch()
self.__bus_id = bus.connect('message', self.__message, self._librarian)
self.bin = BufferingWrapper(self.bin, self)
self.__atf_id = self.bin.connect('about-to-finish',
self.__about_to_finish)
# set buffer duration
duration = config.getfloat("player", "gst_buffer")
self._set_buffer_duration(int(duration * 1000))
# connect playbin to our pluing/volume/eq pipeline
self.bin.set_property('audio-sink', bufbin)
# by default playbin will render video -> suppress using fakesink
fakesink = Gst.ElementFactory.make('fakesink', None)
self.bin.set_property('video-sink', fakesink)
# disable all video/text decoding in playbin
GST_PLAY_FLAG_VIDEO = 1 << 0
GST_PLAY_FLAG_TEXT = 1 << 2
flags = self.bin.get_property("flags")
flags &= ~(GST_PLAY_FLAG_VIDEO | GST_PLAY_FLAG_TEXT)
self.bin.set_property("flags", flags)
# find the (uri)decodebin after setup and use autoplug-sort
# to sort elements like decoders
def source_setup(*args):
def autoplug_sort(decode, pad, caps, factories):
def set_prio(x):
i, f = x
i = {"mad": -1, "mpg123audiodec": -2}.get(f.get_name(), i)
return (i, f)
return zip(*sorted(map(set_prio, enumerate(factories))))[1]
for e in iter_to_list(self.bin.iterate_recurse):
try:
e.connect("autoplug-sort", autoplug_sort)
except TypeError:
pass
else:
break
self.__source_setup_id = self.bin.connect("source-setup", source_setup)
# ReplayGain information gets lost when destroying
self.volume = self.volume
if self.song:
self.bin.set_property('uri', self.song("~uri"))
return True
def cover(self):
# TODO: Deserves some refactoring
if not self.song.is_file:
return None
base = self.song('~dirname')
images = []
# Issue 374: Specify artwork filename
if config.getboolean("albumart", "force_filename"):
path = os.path.join(base, config.get("albumart", "filename"))
if os.path.isfile(path):
images = [(100, path)]
else:
get_ext = lambda s: os.path.splitext(s)[1].lstrip('.')
entries = []
try:
entries = os.listdir(base)
except EnvironmentError:
pass
fns = []
for entry in entries:
lentry = entry.lower()
if get_ext(lentry) in self.cover_exts:
fns.append((None, entry))
if lentry in self.cover_subdirs:
subdir = os.path.join(base, entry)
sub_entries = []
try:
sub_entries = os.listdir(subdir)
except EnvironmentError:
pass
for sub_entry in sub_entries:
lsub_entry = sub_entry.lower()
if get_ext(lsub_entry) in self.cover_exts:
fns.append((entry, sub_entry))
for sub, fn in fns:
dec_lfn = fsdecode(fn, False).lower()
score = 0
# check for the album label number
labelid = self.song.get("labelid", "").lower()
if labelid and labelid in dec_lfn:
score += 20
# Track-related keywords
keywords = [
k.lower().strip() for k in [
self.song("artist"),
self.song("albumartist"),
self.song("album")
] if len(k) > 1
]
score += 2 * sum(map(dec_lfn.__contains__, keywords))
# Generic keywords
score += 3 * sum(
r.search(dec_lfn) is not None
for r in self.cover_positive_regexes)
negs = sum(
r.search(dec_lfn) is not None
for r in self.cover_negative_regexes)
score -= 2 * negs
#print("[%s - %s]: Album art \"%s\" scores %d (%s neg)." % (
# self("artist"), self("title"), fn, score, negs))
if score > 0:
if sub is not None:
fn = os.path.join(sub, fn)
images.append((score, os.path.join(base, fn)))
images.sort(reverse=True)
for score, path in images:
# could be a directory
if not os.path.isfile(path):
continue
try:
return file(path, "rb")
except IOError:
print_w("Failed reading album art \"%s\"" % path)
return None
def main(argv):
import quodlibet
quodlibet.init_cli()
try:
# we want basic commands not to import gtk (doubles process time)
assert "gi.repository.Gtk" not in sys.modules
sys.modules["gi.repository.Gtk"] = None
startup_actions, cmds_todo = process_arguments(argv)
finally:
sys.modules.pop("gi.repository.Gtk", None)
quodlibet.init()
from quodlibet import app
from quodlibet.qltk import add_signal_watch, Icons
add_signal_watch(app.quit)
import quodlibet.player
import quodlibet.library
from quodlibet import config
from quodlibet import browsers
from quodlibet import util
app.name = "Quod Libet"
app.id = "quodlibet"
quodlibet.set_application_info(Icons.QUODLIBET, app.id, app.name)
config.init(os.path.join(quodlibet.get_user_dir(), "config"))
library_path = os.path.join(quodlibet.get_user_dir(), "songs")
print_d("Initializing main library (%s)" %
(quodlibet.util.path.unexpand(library_path)))
library = quodlibet.library.init(library_path)
app.library = library
# this assumes that nullbe will always succeed
from quodlibet.player import PlayerError
wanted_backend = os.environ.get("QUODLIBET_BACKEND",
config.get("player", "backend"))
backend_traceback = None
for backend in [wanted_backend, "nullbe"]:
try:
player = quodlibet.player.init_player(backend, app.librarian)
except PlayerError:
backend_traceback = format_exc()
else:
break
app.player = player
os.environ["PULSE_PROP_media.role"] = "music"
os.environ["PULSE_PROP_application.icon_name"] = "quodlibet"
browsers.init()
from quodlibet.qltk.songlist import SongList, get_columns
headers = get_columns()
SongList.set_all_column_headers(headers)
for opt in config.options("header_maps"):
val = config.get("header_maps", opt)
util.tags.add(opt, val)
in_all = ("~filename ~uri ~#lastplayed ~#rating ~#playcount ~#skipcount "
"~#added ~#bitrate ~current ~#laststarted ~basename "
"~dirname").split()
for Kind in browsers.browsers:
if Kind.headers is not None:
Kind.headers.extend(in_all)
Kind.init(library)
pm = quodlibet.init_plugins("no-plugins" in startup_actions)
if hasattr(player, "init_plugins"):
player.init_plugins()
from quodlibet.qltk import unity
unity.init("quodlibet.desktop", player)
from quodlibet.qltk.songsmenu import SongsMenu
SongsMenu.init_plugins()
from quodlibet.util.cover import CoverManager
app.cover_manager = CoverManager()
app.cover_manager.init_plugins()
from quodlibet.plugins.playlist import PLAYLIST_HANDLER
PLAYLIST_HANDLER.init_plugins()
from quodlibet.plugins.query import QUERY_HANDLER
QUERY_HANDLER.init_plugins()
from gi.repository import GLib
def exec_commands(*args):
for cmd in cmds_todo:
try:
resp = cmd_registry.run(app, *cmd)
except CommandError:
pass
else:
if resp is not None:
print_(resp, end="")
from quodlibet.qltk.quodlibetwindow import QuodLibetWindow, PlayerOptions
# Call exec_commands after the window is restored, but make sure
# it's after the mainloop has started so everything is set up.
app.window = window = QuodLibetWindow(
library,
player,
restore_cb=lambda: GLib.idle_add(exec_commands,
priority=GLib.PRIORITY_HIGH))
app.player_options = PlayerOptions(window)
from quodlibet.qltk.debugwindow import MinExceptionDialog
from quodlibet.qltk.window import on_first_map
if backend_traceback is not None:
def show_backend_error(window):
d = MinExceptionDialog(
window, _("Audio Backend Failed to Load"),
_("Loading the audio backend '%(name)s' failed. "
"Audio playback will be disabled.") %
{"name": wanted_backend}, backend_traceback)
d.run()
# so we show the main window first
on_first_map(app.window, show_backend_error, app.window)
from quodlibet.plugins.events import EventPluginHandler
pm.register_handler(EventPluginHandler(library.librarian, player))
from quodlibet.mmkeys import MMKeysHandler
from quodlibet.remote import Remote, RemoteError
from quodlibet.commands import registry as cmd_registry, CommandError
from quodlibet.qltk.tracker import SongTracker, FSInterface
try:
from quodlibet.qltk.dbus_ import DBusHandler
except ImportError:
DBusHandler = lambda player, library: None
mmkeys_handler = MMKeysHandler(app)
mmkeys_handler.start()
current_path = os.path.join(quodlibet.get_user_dir(), "current")
fsiface = FSInterface(current_path, player)
remote = Remote(app, cmd_registry)
try:
remote.start()
except RemoteError:
exit_(1, True)
DBusHandler(player, library)
tracker = SongTracker(library.librarian, player, window.playlist)
from quodlibet.qltk import session
session.init("quodlibet")
quodlibet.enable_periodic_save(save_library=True)
if "start-playing" in startup_actions:
player.paused = False
# restore browser windows
from quodlibet.qltk.browser import LibraryBrowser
GLib.idle_add(LibraryBrowser.restore,
library,
player,
priority=GLib.PRIORITY_HIGH)
def before_quit():
print_d("Saving active browser state")
try:
app.browser.save()
except NotImplementedError:
pass
print_d("Shutting down player device %r." % player.version_info)
player.destroy()
quodlibet.main(window, before_quit=before_quit)
app.player_options.destroy()
quodlibet.finish_first_session(app.id)
mmkeys_handler.quit()
remote.stop()
fsiface.destroy()
tracker.destroy()
quodlibet.library.save()
config.save()
print_d("Finished shutdown.")
def scan_dirs(self):
return config.get('settings', 'scan')
def config_get(key, default=None):
return config.get('plugins', f"lastfmsync_{key}", default)
def PluginPreferences(self, parent): # pylint: disable=C0103
"""Set and unset preferences from gui or config file."""
def bool_changed(widget):
"""Boolean setting changed."""
if widget.get_active():
setattr(self.configuration, widget.get_name(), True)
else:
setattr(self.configuration, widget.get_name(), False)
config.set('plugins', 'autoqueue_%s' % widget.get_name(),
widget.get_active() and 'true' or 'false')
def str_changed(entry, key):
"""String setting changed."""
value = entry.get_text()
config.set('plugins', 'autoqueue_%s' % key, value)
setattr(self.configuration, key, value)
def int_changed(entry, key):
"""Integer setting changed."""
value = entry.get_text()
if value:
config.set('plugins', 'autoqueue_%s' % key, value)
setattr(self.configuration, key, int(value))
table = Gtk.Table()
table.set_col_spacings(3)
i = 0
j = 0
for setting in BOOL_SETTINGS:
button = Gtk.CheckButton(label=BOOL_SETTINGS[setting]['label'])
button.set_name(setting)
button.set_active(
config.get("plugins", "autoqueue_%s" %
setting).lower() == 'true')
button.connect('toggled', bool_changed)
table.attach(button, i, i + 1, j, j + 1)
if i == 1:
i = 0
j += 1
else:
i += 1
for setting in INT_SETTINGS:
j += 1
label = Gtk.Label('%s:' % INT_SETTINGS[setting]['label'])
entry = Gtk.Entry()
table.attach(label,
0,
1,
j,
j + 1,
xoptions=Gtk.AttachOptions.FILL
| Gtk.AttachOptions.SHRINK)
table.attach(entry,
1,
2,
j,
j + 1,
xoptions=Gtk.AttachOptions.FILL
| Gtk.AttachOptions.SHRINK)
entry.connect('changed', int_changed, setting)
try:
entry.set_text(config.get('plugins', 'autoqueue_%s' % setting))
except:
pass
for setting in STR_SETTINGS:
j += 1
label = Gtk.Label('%s:' % STR_SETTINGS[setting]['label'])
entry = ValidatingEntry()
table.attach(label,
0,
1,
j,
j + 1,
xoptions=Gtk.AttachOptions.FILL
| Gtk.AttachOptions.SHRINK)
table.attach(entry,
1,
2,
j,
j + 1,
xoptions=Gtk.AttachOptions.FILL
| Gtk.AttachOptions.SHRINK)
entry.connect('changed', str_changed, setting)
try:
entry.set_text(config.get('plugins', 'autoqueue_%s' % setting))
except:
pass
return table
def __init__(self, player, debug=False):
super(GstPlayerPreferences, self).__init__(spacing=6)
e = UndoEntry()
e.set_tooltip_text(
_("The GStreamer output pipeline used for "
"playback. Leave blank for the default pipeline. "
"In case the pipeline contains a sink, "
"it will be used instead of the default one."))
e.set_text(config.get('player', 'gst_pipeline'))
def changed(entry):
config.set('player', 'gst_pipeline', entry.get_text())
e.connect('changed', changed)
pipe_label = Gtk.Label(label=_('_Output pipeline:'))
pipe_label.set_use_underline(True)
pipe_label.set_mnemonic_widget(e)
apply_button = Button(_("_Apply"))
def format_buffer(scale, value):
return _("%.1f seconds") % value
def scale_changed(scale):
duration_msec = int(scale.get_value() * 1000)
player._set_buffer_duration(duration_msec)
duration = config.getfloat("player", "gst_buffer")
scale = Gtk.HScale.new(
Gtk.Adjustment(value=duration, lower=0.2, upper=10))
scale.set_value_pos(Gtk.PositionType.RIGHT)
scale.set_show_fill_level(True)
scale.connect('format-value', format_buffer)
scale.connect('value-changed', scale_changed)
buffer_label = Gtk.Label(label=_('_Buffer duration:'))
buffer_label.set_use_underline(True)
buffer_label.set_mnemonic_widget(scale)
def rebuild_pipeline(*args):
player._rebuild_pipeline()
apply_button.connect('clicked', rebuild_pipeline)
gapless_button = ConfigCheckButton(_('Disable _gapless playback'),
"player",
"gst_disable_gapless",
populate=True)
gapless_button.set_alignment(0.0, 0.5)
gapless_button.set_tooltip_text(
_("Disabling gapless playback can avoid track changing problems "
"with some GStreamer versions"))
widgets = [
(pipe_label, e, apply_button),
(buffer_label, scale, None),
]
table = Gtk.Table(n_rows=len(widgets), n_columns=3)
table.set_col_spacings(6)
table.set_row_spacings(6)
for i, (left, middle, right) in enumerate(widgets):
left.set_alignment(0.0, 0.5)
table.attach(left,
0,
1,
i,
i + 1,
xoptions=Gtk.AttachOptions.FILL
| Gtk.AttachOptions.SHRINK)
if right:
table.attach(middle, 1, 2, i, i + 1)
table.attach(right,
2,
3,
i,
i + 1,
xoptions=Gtk.AttachOptions.FILL
| Gtk.AttachOptions.SHRINK)
else:
table.attach(middle, 1, 3, i, i + 1)
table.attach(gapless_button, 0, 3, 2, 3)
self.pack_start(table, True, True, 0)
if debug:
def print_bin(player):
player._print_pipeline()
b = Button("Print Pipeline", Icons.DIALOG_INFORMATION)
connect_obj(b, 'clicked', print_bin, player)
self.pack_start(b, True, True, 0)
def __init__(self, library, player, headless=False, restore_cb=None):
super(QuodLibetWindow, self).__init__(dialog=False)
self.__destroyed = False
self.__update_title(player)
self.set_default_size(600, 480)
main_box = Gtk.VBox()
self.add(main_box)
self.side_book = qltk.Notebook()
# get the playlist up before other stuff
self.songlist = MainSongList(library, player)
self.songlist.connect("key-press-event", self.__songlist_key_press)
self.songlist.connect_after('drag-data-received',
self.__songlist_drag_data_recv)
self.song_scroller = ScrolledWindow()
self.song_scroller.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
self.song_scroller.set_shadow_type(Gtk.ShadowType.IN)
self.song_scroller.add(self.songlist)
self.qexpander = QueueExpander(library, player)
self.qexpander.set_no_show_all(True)
self.qexpander.set_visible(config.getboolean("memory", "queue"))
def on_queue_visible(qex, param):
config.set("memory", "queue", str(qex.get_visible()))
self.qexpander.connect("notify::visible", on_queue_visible)
self.playlist = PlaylistMux(player, self.qexpander.model,
self.songlist.model)
self.__player = player
# create main menubar, load/restore accelerator groups
self.__library = library
ui = self.__create_menu(player, library)
accel_group = ui.get_accel_group()
self.add_accel_group(accel_group)
def scroll_and_jump(*args):
self.__jump_to_current(True, None, True)
keyval, mod = Gtk.accelerator_parse("<Primary><shift>J")
accel_group.connect(keyval, mod, 0, scroll_and_jump)
# custom accel map
accel_fn = os.path.join(quodlibet.get_user_dir(), "accels")
Gtk.AccelMap.load(accel_fn)
# save right away so we fill the file with example comments of all
# accels
Gtk.AccelMap.save(accel_fn)
menubar = ui.get_widget("/Menu")
# Since https://git.gnome.org/browse/gtk+/commit/?id=b44df22895c79
# toplevel menu items show an empty 16x16 image. While we don't
# need image items there UIManager creates them by default.
# Work around by removing the empty GtkImages
for child in menubar.get_children():
if isinstance(child, Gtk.ImageMenuItem):
child.set_image(None)
main_box.pack_start(menubar, False, True, 0)
top_bar = TopBar(self, player, library)
main_box.pack_start(top_bar, False, True, 0)
self.top_bar = top_bar
self.__browserbox = Align(bottom=3)
self.__paned = paned = ConfigRHPaned("memory", "sidebar_pos", 0.25)
paned.pack1(self.__browserbox, resize=True)
# We'll pack2 when necessary (when the first sidebar plugin is set up)
main_box.pack_start(paned, True, True, 0)
play_order = PlayOrderWidget(self.songlist.model, player)
statusbox = StatusBarBox(play_order, self.qexpander)
self.order = play_order
self.statusbar = statusbox.statusbar
main_box.pack_start(Align(statusbox, border=3, top=-3), False, True, 0)
self.songpane = SongListPaned(self.song_scroller, self.qexpander)
self.songpane.show_all()
try:
orders = []
for e in config.getstringlist('memory', 'sortby', []):
orders.append((e[1:], int(e[0])))
except ValueError:
pass
else:
self.songlist.set_sort_orders(orders)
self.browser = None
self.ui = ui
main_box.show_all()
self._playback_error_dialog = None
connect_destroy(player, 'song-started', self.__song_started)
connect_destroy(player, 'paused', self.__update_paused, True)
connect_destroy(player, 'unpaused', self.__update_paused, False)
# make sure we redraw all error indicators before opening
# a dialog (blocking the main loop), so connect after default handlers
connect_after_destroy(player, 'error', self.__player_error)
# connect after to let SongTracker update stats
connect_after_destroy(player, "song-ended", self.__song_ended)
# set at least the playlist. the song should be restored
# after the browser emits the song list
player.setup(self.playlist, None, 0)
self.__restore_cb = restore_cb
self.__first_browser_set = True
restore_browser = not headless
try:
self._select_browser(self, config.get("memory", "browser"),
library, player, restore_browser)
except:
config.set("memory", "browser", browsers.name(browsers.default))
config.save()
raise
self.songlist.connect('popup-menu', self.__songs_popup_menu)
self.songlist.connect('columns-changed', self.__cols_changed)
self.songlist.connect('columns-changed', self.__hide_headers)
self.songlist.info.connect("changed", self.__set_totals)
lib = library.librarian
connect_destroy(lib, 'changed', self.__song_changed, player)
targets = [("text/uri-list", Gtk.TargetFlags.OTHER_APP, DND_URI_LIST)]
targets = [Gtk.TargetEntry.new(*t) for t in targets]
self.drag_dest_set(Gtk.DestDefaults.ALL, targets, Gdk.DragAction.COPY)
self.connect('drag-data-received', self.__drag_data_received)
if not headless:
on_first_map(self, self.__configure_scan_dirs, library)
if config.getboolean('library', 'refresh_on_start'):
self.__rebuild(None, False)
self.connect("key-press-event", self.__key_pressed, player)
self.connect("destroy", self.__destroy)
self.enable_window_tracking("quodlibet")
def restore(self):
try:
name = config.get("browsers", "playlist")
except Exception:
return
self.__view.select_by_func(lambda r: r[0].name == name, one=True)
def test_raw_config_is_standard(s):
s.assertEquals(config.get('display', 'duration_format'),
DurationFormat.STANDARD)
def get_path():
default = os.path.join(quodlibet.get_user_dir(), "current.cover")
return config.get("plugins", __name__, default=default)
def __init__(self, activator):
super(Preferences, self).__init__(spacing=12)
self.set_border_width(6)
ccb = ConfigCheckButton(_("Hide main window on close"), 'plugins',
'trayicon_window_hide')
ccb.set_active(get_hide_window())
self.pack_start(ccb, False, True, 0)
combo = Gtk.ComboBoxText()
combo.append_text(
_("Scroll wheel adjusts volume\n"
"Shift and scroll wheel changes song"))
combo.append_text(
_("Scroll wheel changes song\n"
"Shift and scroll wheel adjusts volume"))
combo.set_active(
int(config.getboolean("plugins", "icon_modifier_swap", False)))
combo.connect('changed', self.__changed_combo)
self.pack_start(qltk.Frame(_("Scroll _Wheel"), child=combo), True,
True, 0)
box = Gtk.VBox(spacing=12)
table = Gtk.Table(n_rows=2, n_columns=4)
table.set_row_spacings(6)
table.set_col_spacings(12)
cbs = []
for i, tag in enumerate([
"genre", "artist", "album", "discnumber", "part",
"tracknumber", "title", "version"
]):
cb = Gtk.CheckButton(label=util.tag(tag))
cb.tag = tag
cbs.append(cb)
table.attach(cb, i % 3, i % 3 + 1, i // 3, i // 3 + 1)
box.pack_start(table, True, True, 0)
entry = Gtk.Entry()
box.pack_start(entry, False, True, 0)
preview = Gtk.Label()
preview.set_ellipsize(Pango.EllipsizeMode.END)
ev = Gtk.EventBox()
ev.add(preview)
box.pack_start(ev, False, True, 0)
frame = qltk.Frame(_("Tooltip Display"), child=box)
frame.get_label_widget().set_mnemonic_widget(entry)
self.pack_start(frame, True, True, 0)
for cb in cbs:
cb.connect('toggled', self.__changed_cb, cbs, entry)
entry.connect('changed', self.__changed_entry, cbs, preview)
try:
entry.set_text(config.get("plugins", "icon_tooltip"))
except:
entry.set_text(
"<album|<album~discnumber~part~tracknumber~title~version>|"
"<artist~title~version>>")
for child in self.get_children():
child.show_all()
def restore(self):
text = config.get("browsers", "query_text").decode("utf-8")
self.__searchbar.set_text(text)
self.__query_changed(None, text, restore=True)
def write(self):
with translate_errors():
audio = self.Kind(self['~filename'])
if audio.tags is None:
audio.add_tags()
tag = audio.tags
# prefill TMCL with the ones we can't read
mcl = tag.get("TMCL", mutagen.id3.TMCL(encoding=3, people=[]))
mcl.people = [(r, n) for (r, n) in mcl.people
if not self.__validate_name(r)]
# delete all TXXX/COMM we can read except empty COMM
for frame in ["COMM:", "TXXX:"]:
for t in tag.getall(frame + "QuodLibet:"):
if t.desc and self.__validate_name(t.desc):
del tag[t.HashKey]
for key in ["UFID:http://musicbrainz.org",
"TMCL",
"POPM:%s" % const.EMAIL,
"POPM:%s" % config.get("editing", "save_email")]:
if key in tag:
del(tag[key])
for key, id3name in self.SDI.items():
tag.delall(id3name)
if key not in self:
continue
enc = encoding_for(self[key])
Kind = mutagen.id3.Frames[id3name]
text = self[key].split("\n")
if id3name == "WOAR":
for t in text:
tag.add(Kind(url=t))
else:
tag.add(Kind(encoding=enc, text=text))
dont_write = (RG_KEYS
| set(self.TXXX_MAP.values())
| {"genre", "comment", "musicbrainz_trackid", "lyrics"})
if "musicbrainz_trackid" in self.realkeys():
f = mutagen.id3.UFID(
owner="http://musicbrainz.org",
data=self["musicbrainz_trackid"].encode("utf-8"))
tag.add(f)
# Issue 439 - Only write valid ISO 639-2 codes to TLAN (else TXXX)
tag.delall("TLAN")
if "language" in self:
langs = self["language"].split("\n")
if all([lang in ISO_639_2 for lang in langs]):
# Save value(s) to TLAN tag. Guaranteed to be ASCII here
tag.add(mutagen.id3.TLAN(encoding=3, text=langs))
dont_write.add("language")
else:
print_w(
f"Not using invalid language {self['language']!r} in TLAN")
# Filter out known keys, and ones set not to write [generically].
dont_write |= self.SDI.keys()
keys_to_write = (k for k in self.realkeys()
if k not in dont_write)
for key in keys_to_write:
enc = encoding_for(self[key])
if key.startswith("performer:"):
mcl.people.append((key.split(":", 1)[1], self[key]))
continue
f = mutagen.id3.TXXX(
encoding=enc, text=self[key].split("\n"),
desc=u"QuodLibet::%s" % key)
tag.add(f)
if mcl.people:
tag.add(mcl)
if "genre" in self:
enc = encoding_for(self["genre"])
t = self["genre"].split("\n")
tag.add(mutagen.id3.TCON(encoding=enc, text=t))
else:
try:
del(tag["TCON"])
except KeyError:
pass
tag.delall("COMM:")
if "comment" in self:
enc = encoding_for(self["comment"])
t = self["comment"].split("\n")
tag.add(mutagen.id3.COMM(encoding=enc, text=t, desc=u"",
lang="\x00\x00\x00"))
tag.delall("USLT")
if "lyrics" in self:
enc = encoding_for(self["lyrics"])
if not ("~lyricslanguage" in self and
# language has to be a 3 byte ISO 639-2 code
self["~lyricslanguage"] in ISO_639_2):
self["~lyricslanguage"] = "und" # undefined
# lyrics are single string, not array
tag.add(mutagen.id3.USLT(encoding=enc, text=self["lyrics"],
desc=self.get("~lyricsdescription", ""),
lang=self["~lyricslanguage"]))
# Delete old foobar replaygain ..
for frame in tag.getall("TXXX"):
if frame.desc.lower() in RG_KEYS:
del tag[frame.HashKey]
# .. write new one
for k in RG_KEYS:
# Add new ones
if k in self:
value = self[k]
tag.add(mutagen.id3.TXXX(encoding=encoding_for(value),
text=value.split("\n"),
desc=k.upper()))
# we shouldn't delete all, but we use unknown ones as fallback, so make
# sure they don't come back after reloading
for t in tag.getall("RVA2"):
if t.channel == 1:
del tag[t.HashKey]
for k in ["track", "album"]:
if ('replaygain_%s_gain' % k) in self:
try:
gain = float(self["replaygain_%s_gain" % k].split()[0])
except (ValueError, IndexError):
gain = 0
try:
peak = float(self["replaygain_%s_peak" % k])
except (ValueError, KeyError):
peak = 0
# https://github.com/quodlibet/quodlibet/issues/1027
peak = max(min(1.9, peak), 0)
gain = max(min(63.9, gain), -64)
f = mutagen.id3.RVA2(desc=k, channel=1, gain=gain, peak=peak)
tag.add(f)
for key in self.TXXX_MAP:
try:
del(tag["TXXX:" + key])
except KeyError:
pass
for key in self.PAM_XXXT:
if key in self.SDI:
# we already write it back using non-TXXX frames
continue
if key in self:
value = self[key]
f = mutagen.id3.TXXX(encoding=encoding_for(value),
text=value.split("\n"),
desc=self.PAM_XXXT[key])
tag.add(f)
if (config.getboolean("editing", "save_to_songs") and
(self.has_rating or self.get("~#playcount", 0) != 0)):
email = config.get("editing", "save_email").strip()
email = email or const.EMAIL
t = mutagen.id3.POPM(email=email,
rating=int(255 * self("~#rating")),
count=self.get("~#playcount", 0))
tag.add(t)
with translate_errors():
audio.save()
self.sanitize()
def config_get(key, default=None):
return config.get('plugins', 'spotify_%s' % key, default)
def config_get(key, default=None):
return config.get('plugins', 'lastfmsync_%s' % key, default)
def __init__(self, parent=None):
if self.is_not_unique():
return
super(PluginWindow, self).__init__()
self.set_title(_("Plugins"))
self.set_default_size(700, 500)
self.set_transient_for(parent)
self.enable_window_tracking("plugin_prefs")
paned = Paned()
vbox = Gtk.VBox()
vbox.set_property("margin-top", 3)
sw = ScrolledWindow()
sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.ALWAYS)
model = ObjectStore()
filter_model = ObjectModelFilter(child_model=model)
self._list_view = tv = PluginListView()
tv.set_model(filter_model)
tv.set_rules_hint(True)
tv.connect("plugin-toggled", self.__plugin_toggled)
fb = Gtk.HBox(spacing=6)
enabled_combo = PluginEnabledFilterCombo()
enabled_combo.connect("changed", lambda s: filter_model.refilter())
enabled_combo.set_tooltip_text("Filter by plugin state / tag")
fb.pack_start(enabled_combo, True, True, 0)
self._enabled_combo = enabled_combo
type_combo = PluginTypeFilterCombo()
type_combo.connect("changed", lambda s: filter_model.refilter())
type_combo.set_tooltip_text("Filter by plugin type")
fb.pack_start(type_combo, True, True, 0)
self._type_combo = type_combo
filter_entry = UndoSearchEntry()
filter_entry.set_tooltip_text("Filter by plugin name or description")
filter_entry.connect("changed", lambda s: filter_model.refilter())
self._filter_entry = filter_entry
sw.add(tv)
sw.set_shadow_type(Gtk.ShadowType.IN)
bbox = Gtk.HBox(homogeneous=True, spacing=6)
errors = qltk.Button(_("Show _Errors"), Icons.DIALOG_WARNING)
errors.set_focus_on_click(False)
errors.connect('clicked', self.__show_errors)
errors.set_no_show_all(True)
bbox.pack_start(errors, True, True, 0)
pref_box = PluginPreferencesContainer()
if const.DEBUG:
refresh = qltk.Button(_("_Refresh"), Icons.VIEW_REFRESH)
refresh.set_focus_on_click(False)
refresh.connect('clicked', self.__refresh, tv, pref_box, errors,
enabled_combo)
bbox.pack_start(refresh, True, True, 0)
filter_box = Gtk.VBox(spacing=6)
filter_box.pack_start(fb, False, True, 0)
filter_box.pack_start(filter_entry, False, True, 0)
vbox.pack_start(Align(filter_box, border=6, right=-6), False, False, 0)
vbox.pack_start(sw, True, True, 0)
vbox.pack_start(Align(bbox, border=6, right=-6), False, True, 0)
paned.pack1(vbox, False, False)
close = qltk.Button(_("_Close"), Icons.WINDOW_CLOSE)
close.connect('clicked', lambda *x: self.destroy())
bb_align = Align(halign=Gtk.Align.END, valign=Gtk.Align.END)
bb = Gtk.HButtonBox()
bb.set_layout(Gtk.ButtonBoxStyle.END)
bb.pack_start(close, True, True, 0)
bb_align.add(bb)
selection = tv.get_selection()
selection.connect('changed', self.__selection_changed, pref_box)
selection.emit('changed')
right_box = Gtk.VBox(spacing=12)
right_box.pack_start(pref_box, True, True, 0)
self.use_header_bar()
if not self.has_close_button():
right_box.pack_start(bb_align, True, True, 0)
paned.pack2(Align(right_box, border=12), True, False)
paned.set_position(275)
self.add(paned)
self.__refill(tv, pref_box, errors, enabled_combo)
self.connect('destroy', self.__destroy)
filter_model.set_visible_func(
self.__filter, (filter_entry, enabled_combo, type_combo))
self.get_child().show_all()
filter_entry.grab_focus()
restore_id = config.get("memory", "plugin_selection")
tv.select_by_plugin_id(restore_id)
def __get_repeat_class(self):
name = config.get("memory", "repeat_mode", None)
return self._repeat_orders.by_name(name) or RepeatSongForever
def do_revert_split(button, section, option):
config.reset(section, option)
e.set_text(config.get(section, option))
def __get_shuffle_class(self):
name = config.get("memory", "shuffle_mode", None)
return self._shuffle_orders.by_name(name) or OrderShuffle
def ratings_vbox(self):
"""Returns a new VBox containing all ratings widgets"""
vb = Gtk.VBox(spacing=6)
# Default Rating
model = Gtk.ListStore(float)
default_combo = Gtk.ComboBox(model=model)
default_lab = Gtk.Label(label=_("_Default rating:"))
default_lab.set_use_underline(True)
default_lab.set_alignment(0, 0.5)
def draw_rating(column, cell, model, it, data):
num = model[it][0]
text = "%0.2f: %s" % (num, util.format_rating(num))
cell.set_property('text', text)
def default_rating_changed(combo, model):
it = combo.get_active_iter()
if it is None:
return
RATINGS.default = model[it][0]
qltk.redraw_all_toplevels()
def populate_default_rating_model(combo, num):
model = combo.get_model()
model.clear()
deltas = []
default = RATINGS.default
precision = RATINGS.precision
for i in range(0, num + 1):
r = i * precision
model.append(row=[r])
deltas.append((abs(default - r), i))
active = sorted(deltas)[0][1]
print_d("Choosing #%d (%.2f), closest to current %.2f" %
(active, precision * active, default))
combo.set_active(active)
cell = Gtk.CellRendererText()
default_combo.pack_start(cell, True)
default_combo.set_cell_data_func(cell, draw_rating, None)
default_combo.connect('changed', default_rating_changed, model)
default_lab.set_mnemonic_widget(default_combo)
def refresh_default_combo(num):
populate_default_rating_model(default_combo, num)
# Rating Scale
model = Gtk.ListStore(int)
scale_combo = Gtk.ComboBox(model=model)
scale_lab = Gtk.Label(label=_("Rating _scale:"))
scale_lab.set_use_underline(True)
scale_lab.set_mnemonic_widget(scale_combo)
cell = Gtk.CellRendererText()
scale_combo.pack_start(cell, False)
num = RATINGS.number
for i in [1, 2, 3, 4, 5, 6, 8, 10]:
it = model.append(row=[i])
if i == num:
scale_combo.set_active_iter(it)
def draw_rating_scale(column, cell, model, it, data):
num_stars = model[it][0]
text = "%d: %s" % (num_stars, RATINGS.full_symbol * num_stars)
cell.set_property('text', text)
def rating_scale_changed(combo, model):
it = combo.get_active_iter()
if it is None:
return
RATINGS.number = num = model[it][0]
refresh_default_combo(num)
refresh_default_combo(RATINGS.number)
scale_combo.set_cell_data_func(cell, draw_rating_scale, None)
scale_combo.connect('changed', rating_scale_changed, model)
default_align = Align(halign=Gtk.Align.START)
default_align.add(default_lab)
scale_align = Align(halign=Gtk.Align.START)
scale_align.add(scale_lab)
grid = Gtk.Grid(column_spacing=6, row_spacing=6)
grid.add(scale_align)
grid.add(scale_combo)
grid.attach(default_align, 0, 1, 1, 1)
grid.attach(default_combo, 1, 1, 1, 1)
vb.pack_start(grid, False, False, 6)
# Bayesian Factor
bayesian_factor = config.getfloat("settings",
"bayesian_rating_factor", 0.0)
adj = Gtk.Adjustment.new(bayesian_factor, 0.0, 10.0, 0.5, 0.5, 0.0)
bayes_spin = Gtk.SpinButton(adjustment=adj, numeric=True)
bayes_spin.set_digits(1)
bayes_spin.connect('changed', self.__changed_and_signal_library,
'settings', 'bayesian_rating_factor')
bayes_spin.set_tooltip_text(
_("Bayesian Average factor (C) for aggregated ratings.\n"
"0 means a conventional average, higher values mean that "
"albums with few tracks will have less extreme ratings. "
"Changing this value triggers a re-calculation for all "
"albums."))
bayes_label = Gtk.Label(label=_("_Bayesian averaging amount:"))
bayes_label.set_use_underline(True)
bayes_label.set_mnemonic_widget(bayes_spin)
# Save Ratings
hb = Gtk.HBox(spacing=6)
hb.pack_start(bayes_label, False, True, 0)
hb.pack_start(bayes_spin, False, True, 0)
vb.pack_start(hb, True, True, 0)
cb = CCB(_("Save ratings and play _counts"),
"editing",
"save_to_songs",
populate=True)
vb.pack_start(cb, True, True, 0)
hb = Gtk.HBox(spacing=6)
lab = Gtk.Label(label=_("_Email:"))
entry = UndoEntry()
entry.set_tooltip_text(
_("Ratings and play counts will be set "
"for this email address"))
entry.set_text(config.get("editing", "save_email"))
entry.connect('changed', self.__changed, 'editing', 'save_email')
hb.pack_start(lab, False, True, 0)
hb.pack_start(entry, True, True, 0)
lab.set_mnemonic_widget(entry)
lab.set_use_underline(True)
vb.pack_start(hb, True, True, 0)
return vb
def config_get(cls, name, default=""):
"""Gets a config string value for this plugin"""
return config.get(PM.CONFIG_SECTION, cls._config_key(name), default)
def getter(section, option):
return decode(config.get(section, option))
def __init__(self, filename):
with translate_errors():
audio = self.Kind(filename)
if audio.tags is None:
audio.add_tags()
tag = audio.tags
self._parse_info(audio.info)
for frame in tag.values():
if frame.FrameID == "APIC" and len(frame.data):
self.has_images = True
continue
elif frame.FrameID == "TCON":
self["genre"] = "\n".join(frame.genres)
continue
elif (frame.FrameID == "UFID" and
frame.owner == "http://musicbrainz.org"):
self["musicbrainz_trackid"] = frame.data.decode("utf-8",
"replace")
continue
elif frame.FrameID == "POPM":
rating = frame.rating / 255.0
if frame.email == const.EMAIL:
try:
self.setdefault("~#playcount", frame.count)
except AttributeError:
pass
self.setdefault("~#rating", rating)
elif frame.email == config.get("editing", "save_email"):
try:
self["~#playcount"] = frame.count
except AttributeError:
pass
self["~#rating"] = rating
continue
elif frame.FrameID == "COMM" and frame.desc == "":
name = "comment"
elif frame.FrameID in ["COMM", "TXXX"]:
if frame.desc.startswith("QuodLibet::"):
name = frame.desc[11:]
elif frame.desc in self.TXXX_MAP:
name = self.TXXX_MAP[frame.desc]
else:
continue
elif frame.FrameID == "RVA2":
self.__process_rg(frame)
continue
elif frame.FrameID == "TMCL":
for role, name in frame.people:
key = self.__validate_name("performer:" + role)
if key:
self.add(key, name)
continue
elif frame.FrameID == "TLAN":
self["language"] = "\n".join(frame.text)
continue
elif frame.FrameID == "USLT":
name = "lyrics"
else:
name = self.IDS.get(frame.FrameID, "").lower()
name = self.__validate_name(name)
if not name:
continue
name = name.lower()
id3id = frame.FrameID
if id3id.startswith("T"):
text = "\n".join(map(str, frame.text))
elif id3id == "COMM":
text = "\n".join(frame.text)
elif id3id == "USLT":
# lyrics are single string, not list
text = frame.text
self["~lyricsdescription"] = frame.desc
self["~lyricslanguage"] = frame.lang
elif id3id.startswith("W"):
text = frame.url
frame.encoding = 0
else:
continue
if not text:
continue
text = self.__distrust_latin1(text, frame.encoding)
if text is None:
continue
if name in self:
self[name] += "\n" + text
else:
self[name] = text
self[name] = self[name].strip()
# to catch a missing continue above
del name
# foobar2000 writes long dates in a TXXX DATE tag, leaving the TDRC
# tag out. Read the TXXX DATE, but only if the TDRC tag doesn't exist
# to avoid reverting or duplicating tags in existing libraries.
if audio.tags and "date" not in self:
for frame in tag.getall('TXXX:DATE'):
self["date"] = "\n".join(map(str, frame.text))
# Read TXXX replaygain and replace previously read values from RVA2
for frame in tag.getall("TXXX"):
k = frame.desc.lower()
if k in RG_KEYS:
self[str(k)] = u"\n".join(map(str, frame.text))
self.sanitize(filename)
def test_mapping(self):
c = PluginConfig("some")
c.set("foo", "bar")
self.assertEqual(config.get("plugins", "some_foo"), "bar")
def __init_pipeline(self):
"""Creates a gstreamer pipeline. Returns True on success."""
if self.bin:
return True
# reset error state
self.error = False
pipeline = config.get("player", "gst_pipeline")
try:
pipeline, self._pipeline_desc = GStreamerSink(pipeline)
except PlayerError as e:
self._error(e)
return False
if self._use_eq and Gst.ElementFactory.find('equalizer-10bands'):
# The equalizer only operates on 16-bit ints or floats, and
# will only pass these types through even when inactive.
# We push floats through to this point, then let the second
# audioconvert handle pushing to whatever the rest of the
# pipeline supports. As a bonus, this seems to automatically
# select the highest-precision format supported by the
# rest of the chain.
filt = Gst.ElementFactory.make('capsfilter', None)
filt.set_property('caps',
Gst.Caps.from_string('audio/x-raw,format=F32LE'))
eq = Gst.ElementFactory.make('equalizer-10bands', None)
self._eq_element = eq
self.update_eq_values()
conv = Gst.ElementFactory.make('audioconvert', None)
resample = Gst.ElementFactory.make('audioresample', None)
pipeline = [filt, eq, conv, resample] + pipeline
# playbin2 has started to control the volume through pulseaudio,
# which means the volume property can change without us noticing.
# Use our own volume element for now until this works with PA.
self._int_vol_element = Gst.ElementFactory.make('volume', None)
pipeline.insert(0, self._int_vol_element)
# Get all plugin elements and append audio converters.
# playbin already includes one at the end
plugin_pipeline = []
for plugin in self._get_plugin_elements():
plugin_pipeline.append(plugin)
plugin_pipeline.append(
Gst.ElementFactory.make('audioconvert', None))
plugin_pipeline.append(
Gst.ElementFactory.make('audioresample', None))
pipeline = plugin_pipeline + pipeline
bufbin = Gst.Bin()
for element in pipeline:
assert element is not None, pipeline
bufbin.add(element)
if len(pipeline) > 1:
if not link_many(pipeline):
print_w("Linking the GStreamer pipeline failed")
self._error(
PlayerError(_("Could not create GStreamer pipeline")))
return False
# see if the sink provides a volume property, if yes, use it
sink_element = pipeline[-1]
if isinstance(sink_element, Gst.Bin):
sink_element = iter_to_list(sink_element.iterate_recurse)[-1]
self._ext_vol_element = None
if hasattr(sink_element.props, "volume"):
self._ext_vol_element = sink_element
# In case we use the sink volume directly we can increase buffering
# without affecting the volume change delay too much and safe some
# CPU time... (2x default for now).
if hasattr(sink_element.props, "buffer_time"):
sink_element.set_property("buffer-time", 400000)
def ext_volume_notify(*args):
# gets called from a thread
GLib.idle_add(self.notify, "volume")
self._ext_vol_element.connect("notify::volume", ext_volume_notify)
self._ext_mute_element = None
if hasattr(sink_element.props, "mute") and \
sink_element.get_factory().get_name() != "directsoundsink":
# directsoundsink has a mute property but it doesn't work
# https://bugzilla.gnome.org/show_bug.cgi?id=755106
self._ext_mute_element = sink_element
def mute_notify(*args):
# gets called from a thread
GLib.idle_add(self.notify, "mute")
self._ext_mute_element.connect("notify::mute", mute_notify)
# Make the sink of the first element the sink of the bin
gpad = Gst.GhostPad.new('sink', pipeline[0].get_static_pad('sink'))
bufbin.add_pad(gpad)
bin_ = Gst.ElementFactory.make('playbin', None)
assert bin_
self.bin = BufferingWrapper(bin_, self)
self._seeker = Seeker(self.bin, self)
bus = bin_.get_bus()
bus.add_signal_watch()
self.__bus_id = bus.connect('message', self.__message, self._librarian)
self.__atf_id = self.bin.connect('about-to-finish',
self.__about_to_finish)
# set buffer duration
duration = config.getfloat("player", "gst_buffer")
self._set_buffer_duration(int(duration * 1000))
# connect playbin to our pluing/volume/eq pipeline
self.bin.set_property('audio-sink', bufbin)
# by default playbin will render video -> suppress using fakesink
fakesink = Gst.ElementFactory.make('fakesink', None)
self.bin.set_property('video-sink', fakesink)
# disable all video/text decoding in playbin
GST_PLAY_FLAG_VIDEO = 1 << 0
GST_PLAY_FLAG_TEXT = 1 << 2
flags = self.bin.get_property("flags")
flags &= ~(GST_PLAY_FLAG_VIDEO | GST_PLAY_FLAG_TEXT)
self.bin.set_property("flags", flags)
if not self.has_external_volume:
# Restore volume/ReplayGain and mute state
self.props.volume = self._volume
self.mute = self._mute
# ReplayGain information gets lost when destroying
self._reset_replaygain()
if self.song:
self.bin.set_property('uri', self.song("~uri"))
return True