← Back to branch summary

~ubuntu-branches/ubuntu/saucy/radiotray/saucy-proposed

« back to all changes in this revision

Viewing changes to src/AudioPlayerGStreamer.py

  • Committer: Package Import Robot
  • Author(s): Elías Alejandro Año Mendoza
  • Date: 2011-12-28 17:06:38 UTC
  • mfrom: (6.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20111228170638-cym2rxl7boqq8dxr
* New upstream release
* debian/copyright
  + Added new copyright owners

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/AudioPlayerGStreamer.py
24
24
import gst
25
25
from StreamDecoder import StreamDecoder
26
26
from lib.common import USER_AGENT
 
27
from events.EventManager import EventManager
 
28
import logging
27
29
 
28
30
class AudioPlayerGStreamer:
29
31
 
30
 
    def __init__(self, mediator, cfg_provider, log):
 
32
    def __init__(self, mediator, cfg_provider, eventManager):
31
33
        self.mediator = mediator
32
 
        self.log = log
 
34
        self.eventManager = eventManager
33
35
        self.decoder = StreamDecoder(cfg_provider)
34
36
        self.playlist = []
35
37
 
 
38
        self.log = logging.getLogger('radiotray')
 
39
 
36
40
        # init player
37
41
        self.souphttpsrc = gst.element_factory_make("souphttpsrc", "source")
38
42
        self.souphttpsrc.set_property("user-agent", USER_AGENT)
40
44
        self.player = gst.element_factory_make("playbin2", "player")            
41
45
        fakesink = gst.element_factory_make("fakesink", "fakesink")
42
46
        self.player.set_property("video-sink", fakesink)
 
47
        #self.player.set_property("buffer-duration", 10000)
43
48
        bus = self.player.get_bus()
44
49
        bus.add_signal_watch()
45
50
        bus.connect("message", self.on_message)
51
56
        if(urlInfo is not None and urlInfo.isPlaylist()):
52
57
            self.playlist = self.decoder.getPlaylist(urlInfo)
53
58
            if(len(self.playlist) == 0):
54
 
                print "Received empty playlist!"
 
59
                self.log.warn('Received empty playlist!')
55
60
                self.mediator.stop()
56
 
                self.mediator.notifyError(_("Connection Error"), _("Received empty stream from station"))
57
 
            print self.playlist
 
61
                self.eventManager.notify(EventManager.STATION_ERROR, {'error':"Received empty stream from station"})
 
62
            self.log.debug(self.playlist)
58
63
            self.playNextStream()
59
64
 
60
65
        elif(urlInfo is not None and urlInfo.isPlaylist() == False):
61
66
            self.playlist = [urlInfo.getUrl()]
62
67
            self.playNextStream()
63
68
 
64
 
        else:            
65
 
            self.mediator.stop()
66
 
            self.mediator.notifyError(_("Connection Error"), _("Couldn't read stream from station"))
67
 
 
 
69
        else:
 
70
            self.stop()
 
71
            self.eventManager.notify(EventManager.STATION_ERROR, {'error':"Couldn't connect to radio station"})
 
72
            
68
73
 
69
74
    def playNextStream(self):
70
75
        if(len(self.playlist) > 0):
71
76
            stream = self.playlist.pop(0)
72
 
            print "Play " + stream
 
77
            self.log.info('Play "%s"', stream)
73
78
 
74
79
            urlInfo = self.decoder.getMediaStreamInfo(stream)
75
80
            if(urlInfo is not None and urlInfo.isPlaylist() == False):
82
87
                self.playNextStream()
83
88
        else:
84
89
            self.stop()
85
 
            self.mediator.notifyStopped()
 
90
            self.eventManager.notify(EventManager.STATE_CHANGED, {'state':'paused'})
86
91
        self.mediator.updateVolume(self.player.get_property("volume"))
87
92
 
88
93
    def stop(self):
89
94
        self.player.set_state(gst.STATE_NULL)
 
95
        self.eventManager.notify(EventManager.STATE_CHANGED, {'state':'paused'})
90
96
 
91
97
    def volume_up(self, volume_increment):   
92
98
        self.player.set_property("volume", min(self.player.get_property("volume") + volume_increment, 1.0))
98
104
 
99
105
    def on_message(self, bus, message):
100
106
        t = message.type
 
107
 
 
108
        stru = message.structure
 
109
        if(stru != None):
 
110
            name = stru.get_name()
 
111
            self.log.debug(name)
 
112
            if(name == 'redirect'):
 
113
                self.player.set_state(gst.STATE_NULL)
 
114
                stru.foreach(self.redirect, None)
 
115
 
 
116
                
 
117
 
101
118
        if t == gst.MESSAGE_EOS:
102
 
            self.log.log("Received MESSAGE_EOS")
 
119
            self.log.debug("Received MESSAGE_EOS")
103
120
            self.player.set_state(gst.STATE_NULL)
104
121
            self.playNextStream()
105
122
        elif t == gst.MESSAGE_BUFFERING:
108
125
            else:
109
126
                self.player.set_state(gst.STATE_PLAYING)
110
127
        elif t == gst.MESSAGE_ERROR:
111
 
            self.log.log("Received MESSAGE_ERROR")
 
128
            self.log.debug("Received MESSAGE_ERROR")
112
129
            self.player.set_state(gst.STATE_NULL)
113
130
            err, debug = message.parse_error()
114
 
            print err
115
 
            print debug
 
131
            self.log.warn(err)
 
132
            self.log.warn(debug)
116
133
 
117
134
            if(len(self.playlist)>0):
118
135
                self.playNextStream()
119
136
            else:
120
 
                self.mediator.notifyError(err, debug)
 
137
                self.eventManager.notify(EventManager.STATION_ERROR, {'error':debug})
 
138
 
121
139
        elif t == gst.MESSAGE_STATE_CHANGED:
122
 
            self.log.log("Received MESSAGE_STATE_CHANGED")
 
140
            self.log.debug("Received MESSAGE_STATE_CHANGED")
123
141
            oldstate, newstate, pending = message.parse_state_changed()
124
142
 
125
143
            if newstate == gst.STATE_PLAYING:
126
 
                self.mediator.notifyPlaying()
 
144
                station = self.mediator.getContext().station
 
145
                self.eventManager.notify(EventManager.STATE_CHANGED, {'state':'playing', 'station':station})
127
146
            #elif newstate == gst.STATE_NULL:
128
147
                #self.mediator.notifyStopped()
129
148
 
130
149
        elif t == gst.MESSAGE_TAG:
131
150
 
132
151
           taglist = message.parse_tag()
133
 
           title = None
134
 
           artist = None
135
 
 
136
 
           for key in taglist.keys():
137
 
                if (key == 'bitrate'):
138
 
                        self.mediator.bitrate = taglist[key]
139
 
                if (key == 'artist'):
140
 
                        print "ARTIST: " + taglist[key]
141
 
                        artist = taglist[key]
142
 
                if (key == 'title'):
143
 
                        print "TITLE: " + taglist[key]
144
 
                        title = taglist[key]
145
 
                
146
 
           if artist and title:
147
 
               self.mediator.notifySong(artist + " - " + title)
148
 
           elif title:
149
 
               self.mediator.notifySong(title)
150
 
           elif artist:
151
 
               self.mediator.notifySong(artist)
152
 
 
 
152
           station = self.mediator.getContext().station
 
153
           metadata = {}
 
154
 
 
155
           for key in taglist.keys():      
 
156
               metadata[key] = taglist[key]
 
157
 
 
158
           metadata['station'] = station
 
159
           
 
160
           self.eventManager.notify(EventManager.SONG_CHANGED, metadata)
 
161
 
 
162
        return True
 
163
 
 
164
    def redirect(self, name, value, data):
 
165
        if(name == 'new-location'):
 
166
            self.start(value)
153
167
        return True