import dbus
import dbus.service
+import jamaendo
+
log = logging.getLogger(__name__)
class _Player(object):
# On maemo use software decoding to workaround some bugs their gst:
# 1. Weird volume bugs in playbin when playing ogg or wma files
# 2. When seeking the DSPs sometimes lie about the real position info
- if util.platform == 'maemo':
+ if True:
+ self._maemo_setup_playbin_player(uri)
+ elif util.platform == 'maemo':
if not self._maemo_setup_hardware_player(filetype):
self._maemo_setup_software_player()
log.debug( 'Using software decoding (maemo)' )
self.player.set_state(gst.STATE_NULL)
self.player = None
+ def _maemo_setup_playbin_player(self, url):
+ self.player = gst.parse_launch("playbin2 uri=%s" % (url,))
+ self.filesrc = self.player
+ self.filesrc_property = 'uri'
+ self.volume_control = self.player
+ self.volume_multiplier = 1.
+ self.volume_property = 'volume'
+
def _maemo_setup_hardware_player( self, filetype ):
""" Setup a hardware player for mp3 or aac audio using
dspaacsink or dspmp3sink """
if t == gst.MESSAGE_EOS:
self.eos_callback()
-
+ log.info("End of stream")
+ elif t == gst.MESSAGE_STATE_CHANGED:
+ old, new, pending = message.parse_state_changed()
+ log.info("State changed: %s -> %s -> %s", old, new, pending)
elif t == gst.MESSAGE_ERROR:
err, debug = message.parse_error()
log.critical( 'Error: %s %s', err, debug )
self.stop()
+ else:
+ log.info("? %s", message.type)
def set_eos_callback(self, cb):
self.eos_callback = cb
}
# Connect status signals
- self.audio_proxy.connect_to_signal( "state_changed",
+ self._audio.connect_to_signal( "state_changed",
self._on_state_changed )
- self.audio_proxy.connect_to_signal( "end_of_stream",
+ self._audio.connect_to_signal( "end_of_stream",
lambda x: self._call_eos() )
# Connect error signals
for error, msg in error_signals.iteritems():
- self.audio_proxy.connect_to_signal(error, lambda *x: self._error(msg))
+ self._audio.connect_to_signal(error, lambda *x: self._error(msg))
def _error(self, msg):
log.error(msg)
states = ("playing", "paused", "stopped")
self.__state = state if state in states else 'none'
- PlayerBackend = OssoPlayer
-else:
- PlayerBackend = GStreamer
+# PlayerBackend = OssoPlayer
+#else:
+PlayerBackend = GStreamer
class Playlist(object):
- class Entry(object):
- def __init__(self, data):
- if isinstance(data, dict):
- self.id = data['id']
- self.name = data['name']
- self.numalbum = int(data['numalbum'])
- self.url = data['mp3']
- self.type = 'mp3'
- elif isinstance(data, basestring): # assume URI
- self.id = 0
- self.name = ''
- self.numalbum = 0
- self.url = data
- self.type = 'mp3'
- def __str__(self):
- return "{%s}" % (", ".join([str(self.name), str(self.numalbum), str(self.url)]))
-
def __init__(self, items = []):
if items is None:
items = []
- self.items = [Playlist.Entry(item) for item in items]
- self.current = -1
+ for item in items:
+ assert(isinstance(item, jamaendo.Track))
+ self.items = items
+ self._current = -1
def add(self, item):
- self.items.append(Playlist.Entry(item))
+ if isinstance(item, list):
+ for i in item:
+ assert(isinstance(i, jamaendo.Track))
+ self.items.extend(item)
+ else:
+ self.items.append(item)
def next(self):
if self.has_next():
- self.current = self.current + 1
- return self.items[self.current]
+ self._current = self._current + 1
+ return self.items[self._current]
+ return None
+
+ def prev(self):
+ if self.has_prev():
+ self._current = self._current - 1
+ return self.items[self._current]
return None
def has_next(self):
- return self.current < (len(self.items)-1)
+ return self._current < (len(self.items)-1)
+
+ def has_prev(self):
+ return self._current > 0
+
+ def current(self):
+ if self._current >= 0:
+ return self.items[self._current]
+ return None
+
+ def current_index(self):
+ return self._current
+
+ def size(self):
+ print type(self)
+ return len(self.items)
+
+ def __repr__(self):
+ return "Playlist(%s)"%(", ".join([str(item) for item in self.items]))
class Player(Playlist):
def __init__(self):
self.backend = PlayerBackend()
self.backend.set_eos_callback(self._on_eos)
- self.playlist = None
+ self.playlist = Playlist()
def play(self, playlist = None):
if playlist:
self.playlist = playlist
- if self.playlist is not None:
+ elif self.playlist is None:
+ self.playlist = Playlist()
+ if self.playlist.size():
if self.playlist.has_next():
entry = self.playlist.next()
log.debug("playing %s", entry)
- self.backend.play_url(entry.type, entry.url)
+ self.backend.play_url('mp3', entry.mp3_url())
def pause(self):
self.backend.pause()
self.stop()
def prev(self):
- pass
+ if self.playlist.has_prev():
+ entry = self.playlist.prev()
+ log.debug("playing %s", entry)
+ self.backend.play_url('mp3', entry.mp3_url())
def _on_eos(self):
log.debug("EOS!")
self.next()
+
+the_player = Player() # the player instance
projects / jamaendo / blobdiff