Run mplayer with -nocache, makes seeking more reliable
[bluplayer] / bluplayer.py
1 #!/usr/bin/python
2
3 import csv
4 import errno
5 import logging
6 import os
7 import subprocess
8 import sys
9 import urllib
10
11 from lxml import etree
12 from PyQt4.QtCore import *
13 from PyQt4.QtGui import *
14
15
16 XHTML = "http://www.w3.org/1999/xhtml"
17 NS = {
18 "xhtml": XHTML,
19 }
20 DEFAULT_PATH = "/usr/local/bin:/usr/bin:/bin"
21
22
23 def set_env_config(name, value):
24 value = os.environ.get(name, value)
25 globals()[name] = value
26
27 def find_path(binary):
28 value = ""
29 paths = os.environ.get("PATH", DEFAULT_PATH).split(":")
30 for path in paths:
31 path = os.path.join(path, binary)
32 if os.path.isfile(path):
33 value = path
34 break
35 return value
36
37 set_env_config("MAKEMKVCON_PATH", find_path("makemkvcon"))
38 set_env_config("MPLAYER_PATH", find_path("mplayer"))
39 set_env_config("MPLAYER_OPTS", None)
40
41
42 def grab_xml(url):
43 f = urllib.urlopen(url)
44 doc = etree.parse(f)
45 f.close()
46 return doc
47
48 def parse_doc(doc):
49 d = {}
50 tds = doc.xpath("//xhtml:td", namespaces=NS)
51 i = 0
52 while i < len(tds)-1:
53 key = tds[i].text
54 value = tds[i+1]
55 for v in value:
56 if v.tag == "{%s}a" % XHTML:
57 value = v.get("href")
58 break
59 else:
60 value = value.text
61
62 d[key] = value
63 i += 2
64 return d
65
66 def get_num_cpus():
67 logging.info("Determing number of CPUs")
68 try:
69 return subprocess.check_output("nproc").strip()
70 except Exception, e:
71 logging.warn("Unable to run nproc: %s", fmt_exc(e))
72 return 1
73
74 def grab_dict(url):
75 doc = grab_xml(url)
76 d = parse_doc(doc)
77 return d
78
79 def fmt_exc(e):
80 return "%s: %s" % (e.__class__.__name__, str(e))
81
82
83 class Title(object):
84 def __init__(self, title_page):
85 self.id = title_page["id"]
86 self.duration = title_page["duration"]
87 self.video_url = title_page["file0"]
88
89 def __str__(self):
90 return "Title%s: %s %s" % (self.id, self.duration, self.video_url)
91
92
93 class MakeMkvCon(object):
94 def __init__(self, params):
95 cmd = [MAKEMKVCON_PATH, "--robot"]
96 cmd.extend(params)
97 logging.info("Running makemkvcon: %s", params)
98 self.p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
99 self.fd = self.p.stdout.fileno()
100 self.buf = ""
101 self.finished = False
102 self.status = None
103
104 def decode_line(self, line):
105 logging.debug("makemkvcon output: %s", line)
106 data = csv.reader([line]).next()
107 key, x0 = data[0].split(":", 1)
108 data[0] = x0
109 return key, data
110
111 def __iter__(self):
112 return self
113
114 def next(self):
115 if self.finished:
116 raise StopIteration()
117 while True:
118 pos = self.buf.find("\n")
119 if pos >= 0:
120 result = self.buf[:pos]
121 self.buf = self.buf[pos+1:]
122 return self.decode_line(result)
123
124 try:
125 data = os.read(self.p.stdout.fileno(), 4096)
126 except OSError, e:
127 if e.errno == errno.EINTR:
128 continue
129 if not data:
130 self.status = self.p.wait()
131 logging.info("makemkvcon exited with status %s", self.status)
132 self.finished = True
133 raise StopIteration()
134
135 self.buf += data
136
137
138 class MPlayer(QObject):
139 play_finished = pyqtSignal()
140 fatal_error = pyqtSignal(str, str)
141
142 def run(self):
143 logging.info("mplayer thread started")
144
145 if not os.path.isfile(MPLAYER_PATH):
146 self.fatal_error.emit(
147 "MPlayer was not found.",
148 "Please install MPlayer. If you already have done so you " +
149 "may set the MPLAYER_PATH environment variable to the " +
150 "absolute path to the mplayer executable."
151 )
152 return
153
154 if MPLAYER_OPTS:
155 self.opts = MPLAYER_OPTS.split()
156 else:
157 self.opts = [
158 "-fs",
159 "-nocache",
160 "-lavdopts", "threads=%s" % get_num_cpus(),
161 "-volume", "100",
162 ]
163
164 def play(self, video_url):
165 video_url = str(video_url)
166 logging.info("Running mplayer: %s", video_url)
167 try:
168 subprocess.check_call([MPLAYER_PATH] + self.opts + [video_url])
169 except Exception, e:
170 self.fatal_error.emit("MPlayer failed to play the video.", fmt_exc(e))
171 finally:
172 self.play_finished.emit()
173
174
175 class MakeMkv(QObject):
176 title_loaded = pyqtSignal(Title)
177 title_load_complete = pyqtSignal()
178 status = pyqtSignal(str)
179 fatal_error = pyqtSignal(str, str)
180
181 def find_disc(self):
182 self.url = "http://192.168.1.114:51001/"
183 makemkvcon = MakeMkvCon(["info", "disc:9999"])
184 disc_number = None
185 for key, line in makemkvcon:
186 if key == "MSG" and line[0] != "5010":
187 self.status.emit(line[3])
188
189 if disc_number is None and key == "DRV" and line[5]:
190 disc_number = line[0]
191 disc_name = line[5]
192 self.status.emit("Found disc %s" % disc_name)
193
194 if makemkvcon.status == 0:
195 return disc_number
196
197 def run_stream(self, disc_number):
198 makemkvcon = MakeMkvCon(["stream", "disc:%s" % disc_number])
199 for key, line in makemkvcon:
200 if key == "MSG" and line[0] == "4500":
201 # Sometimes the port in field 6 is wrong
202 port = line[5].split(":")[1]
203 url = "http://localhost:%s/" % port
204 self.load_titles(url)
205 elif key == "MSG":
206 self.status.emit(line[3])
207
208 if makemkvcon.status != 0:
209 self.fatal_error.emit(
210 "MakeMKV quit unexpectedly.",
211 "makemkvcon exited with code %s" % makemkvcon.status
212 )
213
214 def load_titles(self, url):
215 home_page = grab_dict(url)
216 title_list_page = grab_dict(home_page["titles"])
217 title_count = int(title_list_page["titlecount"])
218 for i in xrange(title_count):
219 title_page = grab_dict(title_list_page["title%d" % i])
220 title = Title(title_page)
221 self.title_loaded.emit(title)
222 self.title_load_complete.emit()
223
224 def run(self):
225 logging.info("makemkv thread started")
226
227 if not os.path.isfile(MAKEMKVCON_PATH):
228 self.fatal_error.emit(
229 "MakeMKV was not found.",
230 "Please install MakeMKV. If you already have done so you " +
231 "may set the MAKEMKVCON_PATH environment variable to the " +
232 "absolute path to the makemkvcon executable."
233 )
234 return
235
236 try:
237 disc_number = self.find_disc()
238 except Exception, e:
239 self.fatal_error.emit("Error searching for disc.", fmt_exc(e))
240 raise
241
242 if not disc_number:
243 self.fatal_error.emit(
244 "No disc found.",
245 "Please insert a BluRay disc and try again."
246 )
247 return
248
249 try:
250 self.run_stream(disc_number)
251 except Exception, e:
252 self.fatal_error.emit("Failed to start MakeMKV.", fmt_exc(e))
253 raise
254
255 logging.info("makemkv thread finished")
256
257
258 class PlayerWindow(QWidget):
259 fatal_error = pyqtSignal(str, str)
260 video_selected = pyqtSignal(str)
261
262 def __init__(self):
263 QWidget.__init__(self)
264
265 self.title_map = {}
266 self.is_playing = False
267
268 self.list_widget = QListWidget(self)
269 self.list_widget.itemActivated.connect(self.handle_activated)
270 self.list_widget.setEnabled(False)
271
272 self.log = QTextEdit(self)
273 self.log.setReadOnly(True)
274
275 self.splitter = QSplitter(Qt.Vertical, self)
276 self.splitter.addWidget(self.list_widget)
277 self.splitter.addWidget(self.log)
278 self.splitter.setSizes([900, 200])
279
280 self.layout = QVBoxLayout(self)
281 self.layout.addWidget(self.splitter)
282 self.setWindowTitle("BluPlayer")
283 self.resize(1200, 700)
284
285 def add_title(self, title):
286 name = "Title %s (%s)" % (int(title.id)+1, title.duration)
287 self.list_widget.addItem(name)
288 self.title_map[name] = title
289
290 def select_longest_title(self):
291 longest_title = None
292 longest_item = None
293 for i in xrange(self.list_widget.count()):
294 item = self.list_widget.item(i)
295 name = str(item.text())
296 title = self.title_map[name]
297 if longest_title is None or title.duration > longest_title.duration:
298 longest_title = title
299 longest_item = item
300 self.list_widget.setCurrentItem(longest_item)
301 self.list_widget.setEnabled(True)
302 self.list_widget.setFocus()
303
304 def add_log_entry(self, text):
305 self.log.append(text)
306
307 def handle_activated(self, item):
308 if self.is_playing:
309 return
310 name = str(item.text())
311 title = self.title_map[name]
312 self.is_playing = True
313 self.list_widget.setEnabled(False)
314 self.video_selected.emit(title.video_url)
315
316 def set_play_finished(self):
317 self.is_playing = False
318 self.list_widget.setEnabled(True)
319 self.list_widget.setFocus()
320
321 def keyPressEvent(self, e):
322 if e.key() in (Qt.Key_Escape, Qt.Key_Backspace):
323 self.close()
324 return
325 QWidget.keyPressEvent(self, e)
326
327 class LoadingDialog(QProgressDialog):
328 def __init__(self, parent):
329 QProgressDialog.__init__(self, parent)
330 self.setWindowModality(Qt.WindowModal);
331 self.setWindowTitle("Loading disc")
332 self.setLabelText("Loading BluRay disc. Please wait...")
333 self.setCancelButtonText("Exit")
334 self.setMinimum(0)
335 self.setMaximum(0)
336
337 class ErrorDialog(QMessageBox):
338 fatal_error = pyqtSignal(str, str)
339
340 def __init__(self, parent):
341 QMessageBox.__init__(self, parent)
342 self.setStandardButtons(QMessageBox.Ok)
343 self.setDefaultButton(QMessageBox.Ok)
344 self.fatal_error.connect(self.configure_popup)
345 self.setWindowTitle("Fatal error")
346 self.has_run = False
347
348 def configure_popup(self, text, detail):
349 if self.has_run:
350 return
351 self.has_run = True
352 self.setText(text)
353 self.setInformativeText(detail)
354 QTimer.singleShot(0, self.show_and_exit)
355
356 def show_and_exit(self):
357 logging.info("showing and exiting")
358 self.exec_()
359 qApp.quit()
360
361 def killall_makemkvcon():
362 logging.info("Stopping any makemkvcon processes")
363 subprocess.Popen(["killall", "--quiet", "makemkvcon"]).wait()
364
365 def main():
366 logging.basicConfig(format="%(levelname)s: %(message)s")
367 logging.getLogger().setLevel(logging.DEBUG)
368 logging.info("Configuring application")
369
370 app = QApplication(sys.argv)
371 app.setQuitOnLastWindowClosed(True)
372
373 default_font = app.font()
374 default_font.setPointSize(16)
375 app.setFont(default_font)
376
377 player_window = PlayerWindow()
378 player_window.show()
379
380 loading_dialog = LoadingDialog(player_window)
381 loading_dialog.show()
382
383 error_dialog = ErrorDialog(player_window)
384
385 makemkv = MakeMkv()
386 makemkv_thread = QThread()
387 makemkv.moveToThread(makemkv_thread)
388 makemkv_thread.started.connect(makemkv.run)
389
390 mplayer = MPlayer()
391 mplayer_thread = QThread()
392 mplayer.moveToThread(mplayer_thread)
393 mplayer_thread.started.connect(mplayer.run)
394
395 makemkv.title_loaded.connect(player_window.add_title)
396 makemkv.title_load_complete.connect(player_window.select_longest_title)
397 makemkv.status.connect(player_window.add_log_entry)
398 makemkv.fatal_error.connect(error_dialog.fatal_error)
399 makemkv.title_load_complete.connect(loading_dialog.reset)
400
401 player_window.video_selected.connect(mplayer.play)
402 mplayer.play_finished.connect(player_window.set_play_finished)
403 mplayer.fatal_error.connect(error_dialog.fatal_error)
404
405 player_window.fatal_error.connect(error_dialog.fatal_error)
406 error_dialog.fatal_error.connect(loading_dialog.reset)
407 loading_dialog.canceled.connect(qApp.quit)
408
409 logging.info("Starting application")
410 makemkv_thread.start()
411 mplayer_thread.start()
412 result = app.exec_()
413
414 logging.info("Shutting down")
415 makemkv_thread.quit()
416 mplayer_thread.quit()
417 killall_makemkvcon()
418 logging.info("Waiting for makemkv thread")
419 makemkv_thread.wait(2000)
420 logging.info("Waiting for mplayer thread")
421 mplayer_thread.wait(2000)
422 logging.info("Exiting...")
423 sys.exit(result)
424
425 if __name__ == "__main__":
426 main()
427