stage_director

1) #! /usr/bin/env python
2) 

3) # BlinkenArea Sync GUI
4) # version 0.1.0 date 2013-11-23
5) # Copyright 2013 Stefan Schuermans <stefan@blinkenarea.org>
6) # Copyleft: GNU public license - http://www.gnu.org/copyleft/gpl.html
7) # a blinkenarea.org project - https://www.blinkenarea.org/
8) 

9) import os
10) from gi.repository import Gtk

11) import gobject

12) import pango

13) import socket
14) import struct

15) import sys

16) import time

17) import playlist

18) import time_fmt
19) 

20) scriptdir = os.path.dirname(os.path.abspath(__file__))
21) 
22) class SyncGui:

23) 

24)   def __init__(self):

25)     """construct a SyncGui object"""

26)     self.builder = Gtk.Builder()
27)     self.builder.add_from_file(scriptdir + "/sync_gui.glade")

28)     self.widMainWindow = self.builder.get_object("MainWindow")

29)     self.widPlaylistView = self.builder.get_object("PlaylistView")
30)     self.widPlaylistStore = self.builder.get_object("PlaylistStore")
31)     self.widPosition = self.builder.get_object("Position")
32)     self.widPositionScale = self.builder.get_object("PositionScale")
33)     self.widPositionAt = self.builder.get_object("PositionAt")
34)     self.widPositionRemaining = self.builder.get_object("PositionRemaining")
35)     self.widBtnPause = self.builder.get_object("Pause")
36)     self.widBtnPlay = self.builder.get_object("Play")

37)     self.widLogoStop = self.builder.get_object("LogoStop")
38)     self.widLogoPlay = self.builder.get_object("LogoPlay")
39)     self.widLogoUdpErr = self.builder.get_object("LogoUdpErr")
40)     self.widLogoUdpOk = self.builder.get_object("LogoUdpOk")

41)     self.widStatus = self.builder.get_object("Status")

42)     handlers = {

43)       "onDestroy":           self.onDestroy,
44)       "onFileOpen":          self.onFileOpen,
45)       "onFileExit":          self.onFileExit,
46)       "onExtrasDestination": self.onExtrasDestination,
47)       "onPlaylistDblClick":  self.onPlaylistDblClick,
48)       "onNewPosition":       self.onNewPosition,
49)       "onPrevious":          self.onPrevious,
50)       "onStop":              self.onStop,
51)       "onPause":             self.onPause,
52)       "onPlay":              self.onPlay,
53)       "onNext":              self.onNext,

54)     }
55)     self.builder.connect_signals(handlers)

56)     self.playlist = playlist.Playlist()

57)     if len(sys.argv) >= 2: # load initial playlist from command line
58)       self.playlist.read(sys.argv[1])

59)     self.playlist.update(self.widPlaylistStore)

60)     self.sock = None

61)     self.stEntryIdx = -1 # no entry selected
62)     self.stName = "" # no current entry name
63)     self.stDuration = 0 # current entry has zero size
64)     self.stPosition = 0 # at begin of current entry
65)     self.stPlaying = False # not playing

66)     self.stDestination = "255.255.255.255" # local LAN broadcast by default
67)     self.setupSock()

68)     self.updateEntry()

69)     self.updateButtonVisibility()

70)     gobject.timeout_add(10, self.onTimer10ms)
71)     gobject.timeout_add(100, self.onTimer100ms)

72) 

73)   def showPosition(self):
74)     """update the position texts next to the position slider"""
75)     # format current time and remaining time
76)     posAt = time_fmt.sec2str(self.stPosition)
77)     posRemaining = time_fmt.sec2str(self.stDuration - self.stPosition)
78)     self.widPositionAt.set_text(posAt)
79)     self.widPositionRemaining.set_text(posRemaining)
80) 
81)   def updatePositionState(self):
82)     """update the position in the state, but not the slider"""
83)     # calculate (virtual) start time of playing
84)     # i.e. the time the playing would have had started to arrive at the
85)     # current position now if it had played continuosly
86)     self.stPlayStart = time.time() - self.stPosition
87)     # update position texts
88)     self.showPosition()
89) 
90)   def updatePosition(self):
91)     """update the position including the position slider"""
92)     # update GUI slider
93)     self.widPositionScale.set_value(self.stPosition)
94)     # update position state
95)     self.updatePositionState()
96) 
97)   def updateDuration(self):
98)     """update the duration (i.e. range for the slider) based on the current
99)        playlist entry"""
100)     # get duration of new playlist entry
101)     self.stDuration = 0
102)     if self.stEntryIdx >= 0:
103)       entry = self.playlist.entries[self.stEntryIdx]
104)       if entry["type"] == "normal":
105)         self.stDuration = entry["duration"]
106)     # set position to begin
107)     self.stPosition = 0
108)     # update value range
109)     self.widPosition.set_upper(self.stDuration)
110)     # update position of slider
111)     self.updatePosition()
112) 

113)   def updateEntry(self):
114)     """update current entry of playlist and duration, position, ..."""

115)     # clear selection of playlist
116)     sel = self.widPlaylistView.get_selection()
117)     if sel:
118)       sel.unselect_all()

119)     # sanity check for entry index
120)     if self.stEntryIdx < -1 or self.stEntryIdx >= len(self.playlist.entries):
121)       self.stEntryIdx = -1

122)     # get name of current entry
123)     self.stName = ""
124)     if self.stEntryIdx >= 0 and \
125)        self.playlist.entries[self.stEntryIdx]["type"] == "normal":
126)       self.stName = self.playlist.entries[self.stEntryIdx]["name"]

127)     # make current entry bold, all others non-bold
128)     def update(model, path, it, user_data):
129)       (idx,) = model.get(it, 0)
130)       if idx == self.stEntryIdx:
131)         weight = pango.WEIGHT_BOLD
132)       else:
133)         weight = pango.WEIGHT_NORMAL
134)       model.set(it, 1, weight)
135)     self.widPlaylistStore.foreach(update, None)

136)     # playing and (no entry or stop entry)
137)     # -> stop playing and update button visibility
138)     if self.stPlaying and (self.stEntryIdx < 0 or \
139)        self.playlist.entries[self.stEntryIdx]["type"] == "stop"):
140)       self.stPlaying = False
141)       self.updateButtonVisibility()

142)     # update duration, position, ...
143)     self.updateDuration()
144) 

145)   def updateButtonVisibility(self):
146)     """update the visibility of the buttons based on if playing or not"""
147)     self.widBtnPause.set_visible(self.stPlaying)
148)     self.widBtnPlay.set_visible(not self.stPlaying)

149)     self.widLogoStop.set_visible(not self.stPlaying)
150)     self.widLogoPlay.set_visible(self.stPlaying)

151) 

152)   def closeSock(self):
153)     """close UDP socket"""

154)     self.widLogoUdpErr.set_visible(True)
155)     self.widLogoUdpOk.set_visible(False)

156)     self.widStatus.remove_all(0)
157)     self.widStatus.push(0, "UDP output ERROR")
158)     if self.sock is not None:
159)       self.sock.close()
160)     self.sock = None
161) 
162)   def setupSock(self):
163)     """create a new UDP socket and "connect" it to the destination address"""
164)     self.closeSock()
165)     try:
166)       self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
167)       self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
168)       self.sock.connect((self.stDestination, 5740))
169)       self.widStatus.remove_all(0)
170)       self.widStatus.push(0, "UDP output to \"" + self.stDestination +
171)                              "\" port 5740")

172)       self.widLogoUdpErr.set_visible(False)
173)       self.widLogoUdpOk.set_visible(True)

174)     except:
175)       self.closeSock()
176) 

177)   def onDestroy(self, widget):

178)     """window will be destroyed"""

179)     Gtk.main_quit()
180) 

181)   def onFileOpen(self, widget):
182)     """File Open clicked in menu"""
183)     #print("DEBUG sync_gui File Open")

184)     # create and run file chooser dialog
185)     dialog = Gtk.FileChooserDialog(
186)       "BlinkenArea Sync GUI - File Open...",
187)       self.widMainWindow, Gtk.FileChooserAction.OPEN,
188)       (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
189)        Gtk.STOCK_OPEN, Gtk.ResponseType.OK))

190)     dialog.set_default_response(Gtk.ResponseType.OK)
191)     filt = Gtk.FileFilter()
192)     filt.set_name("All files")
193)     filt.add_pattern("*")
194)     dialog.add_filter(filt)
195)     response = dialog.run()
196)     if response == Gtk.ResponseType.OK:
197)       # dialog closed with OK -> load new playlist
198)       filename = dialog.get_filename()
199)       self.playlist.read(filename)
200)       self.playlist.update(self.widPlaylistStore)
201)       self.stEntryIdx = -1 # no entry selected
202)       self.stPlaying = False # not playing
203)       self.updateEntry()
204)       self.updateButtonVisibility()

205)     # clean up

206)     dialog.destroy()
207) 
208)   def onFileExit(self, widget):
209)     """File Exit clicked in menu"""
210)     #print("DEBUG sync_gui File Exit")
211)     Gtk.main_quit()
212) 

213)   def onExtrasDestination(self, widget):
214)     """Extras Destination Address clicked in menu"""
215)     #print("DEBUG sync_gui Extras Destination")
216)     # run input dialog to ask for new destination
217)     dialog = self.builder.get_object("DialogDestination")
218)     cur = self.builder.get_object("DiaDestCur")
219)     new = self.builder.get_object("DiaDestNew")
220)     cur.set_text(self.stDestination)
221)     new.set_text(self.stDestination)
222)     response = dialog.run()
223)     if response == 1:
224)       self.stDestination = new.get_text()
225)     # hide input dialog
226)     dialog.hide()
227)     # re-create UDP socket
228)     self.setupSock()
229) 

230)   def onPlaylistDblClick(self, widget, row, col):
231)     """playlist entry has been double-clicked"""
232)     # get index of selected entry
233)     idx = -1
234)     sel = self.widPlaylistView.get_selection()
235)     if sel is not None:
236)       (model, it) = sel.get_selected()
237)       if it is not None:

238)         (idx,) = model.get(it, 0)

239)     #print("DEBUG sync_gui playlist double-click idx=%d" % (idx))

240)     # update playlist entry
241)     self.stEntryIdx = idx

242)     # set position to zero if playing
243)     if self.stPlaying:
244)       self.stPosition = 0

245)     # update entry
246)     self.updateEntry()

247) 

248)   def onNewPosition(self, widget, scroll, value):

249)     """slider has been moved to a new position"""

250)     #print("DEBUG sync_gui new position " + str(value));

251)     # clamp position to valid range
252)     if value < 0:
253)       value = 0
254)     if value > self.stDuration:
255)       value = self.stDuration
256)     # update current position - and play start time if playing
257)     self.stPosition = value
258)     # update position state (do not touch the slider)
259)     self.updatePositionState()

260) 

261)   def onPrevious(self, widget):

262)     """previous button as been pressed"""

263)     #print("DEBUG sync_gui previous")
264)     # go to begin of previous entry (with wrap around)
265)     self.stPosition = 0
266)     self.stEntryIdx = self.stEntryIdx - 1
267)     if self.stEntryIdx < 0:
268)       self.stEntryIdx = len(self.playlist.entries) - 1
269)     self.updateEntry()

270) 
271)   def onStop(self, widget):

272)     """stop button has been pressed"""

273)     #print("DEBUG sync_gui stop")

274)     self.stPlaying = False
275)     self.stPosition = 0 # stop goes back to begin
276)     self.updatePosition()
277)     self.updateButtonVisibility()

278) 
279)   def onPause(self, widget):

280)     """pause button has been pressed"""

281)     #print("DEBUG sync_gui pause")

282)     self.stPlaying = False
283)     self.updateButtonVisibility()

284) 
285)   def onPlay(self, widget):

286)     """play button has been pressed"""

287)     #print("DEBUG sync_gui play")

288)     self.stPlaying = True
289)     self.updatePosition()
290)     self.updateButtonVisibility()

291) 
292)   def onNext(self, widget):

293)     """next button has been pressed"""

294)     #print("DEBUG sync_gui next")
295)     # go to begin of next entry (with wrap around)
296)     self.stPosition = 0
297)     self.stEntryIdx = self.stEntryIdx + 1
298)     if self.stEntryIdx >= len(self.playlist.entries):
299)       self.stEntryIdx = 0
300)     self.updateEntry()

301) 
302)   def onTimer10ms(self):
303)     """timer callback, every 10ms"""
304)     # update position if playing
305)     if self.stPlaying:
306)       self.stPosition = time.time() - self.stPlayStart

307)       if self.stPosition >= self.stDuration:
308)         # end of entry reached --> go to begin of next entry (with wrap around)
309)         self.stPosition = 0
310)         self.stEntryIdx = self.stEntryIdx + 1
311)         if self.stEntryIdx >= len(self.playlist.entries):
312)           self.stEntryIdx = 0
313)         self.updateEntry()
314)       else:
315)         self.updatePosition()

316)     # request being called again
317)     return True

318) 
319)   def onTimer100ms(self):
320)     """timer callback, every 100ms"""
321)     # send sync packet

322)     if self.sock is not None:
323)       flags = 0
324)       if self.stPlaying:
325)         flags = flags | 1
326)       name = self.stName
327)       pos_ms = round(self.stPosition * 1000)
328)       data = "PoSy" + struct.pack("!I64sI", flags, name, pos_ms)
329)       try:
330)         self.sock.send(data)
331)       except:
332)         self.closeSock()
333)     # request being called again
334)     return True

335) 
336) # main application entry point

337) if __name__ == "__main__":
338)   app = SyncGui()
339)   Gtk.main()
340)