Rezzect/syncplay
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Revert "Allow VLC_MIN_PORT to equal VLC_MAX_PORT"

Browse Source 
This reverts commit 073cc2ce62d74882f0ec9102bcea8b96b3d0bec8.
This commit is contained in:
Et0h 2013-05-04 16:40:46 +01:00
parent 073cc2ce62
commit 3aa56864f8
1 changed files with 215 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

430
syncplay/players/vlc.py
View File

@ -1,216 +1,216 @@
import subprocess import subprocess
import re import re
import threading import threading
from syncplay.players.basePlayer import BasePlayer from syncplay.players.basePlayer import BasePlayer
from syncplay import constants from syncplay import constants
import os import os
import random import random
import socket import socket
import asynchat, asyncore import asynchat, asyncore
from syncplay.messages import getMessage from syncplay.messages import getMessage
import time import time
class VlcPlayer(BasePlayer): class VlcPlayer(BasePlayer):
speedSupported = True speedSupported = True
RE_ANSWER = re.compile(r"(?:^(?P<command>[a-zA-Z_]+)(?:\: )?(?P<argument>.*))") RE_ANSWER = re.compile(r"(?:^(?P<command>[a-zA-Z_]+)(?:\: )?(?P<argument>.*))")
VLC_MIN_PORT = 10000 VLC_MIN_PORT = 10000
VLC_MAX_PORT = 55000 VLC_MAX_PORT = 55000
SLAVE_ARGS = ['--extraintf=luaintf','--lua-intf=syncplay'] SLAVE_ARGS = ['--extraintf=luaintf','--lua-intf=syncplay']
random.seed() random.seed()
vlcport = random.randrange(VLC_MIN_PORT, VLC_MAX_PORT) if (VLC_MIN_PORT < VLC_MAX_PORT) else VLC_MIN_PORT vlcport = random.randrange(VLC_MIN_PORT, VLC_MAX_PORT)
SLAVE_ARGS.append('--lua-config=syncplay={{port=\"{}\"}}'.format(str(vlcport))) SLAVE_ARGS.append('--lua-config=syncplay={{port=\"{}\"}}'.format(str(vlcport)))
def __init__(self, client, playerPath, filePath, args): def __init__(self, client, playerPath, filePath, args):
self._client = client self._client = client
self._paused = None self._paused = None
self._duration = None self._duration = None
self._filename = None self._filename = None
self._filepath = None self._filepath = None
self._durationAsk = threading.Event() self._durationAsk = threading.Event()
self._filenameAsk = threading.Event() self._filenameAsk = threading.Event()
self._pathAsk = threading.Event() self._pathAsk = threading.Event()
self._positionAsk = threading.Event() self._positionAsk = threading.Event()
self._pausedAsk = threading.Event() self._pausedAsk = threading.Event()
self._vlcready = threading.Event() self._vlcready = threading.Event()
try: try:
self._listener = self.__Listener(self, playerPath, filePath, args, self._vlcready) self._listener = self.__Listener(self, playerPath, filePath, args, self._vlcready)
except ValueError: except ValueError:
self._client.ui.showMessage(getMessage("en", "vlc-failed-connection")) self._client.ui.showMessage(getMessage("en", "vlc-failed-connection"))
self._client.stop(True) self._client.stop(True)
return return
self._listener.setDaemon(True) self._listener.setDaemon(True)
self._listener.start() self._listener.start()
if(not self._vlcready.wait(constants.VLC_OPEN_MAX_WAIT_TIME)): if(not self._vlcready.wait(constants.VLC_OPEN_MAX_WAIT_TIME)):
self._vlcready.set() self._vlcready.set()
self._client.ui.showMessage(getMessage("en", "vlc-failed-connection")) self._client.ui.showMessage(getMessage("en", "vlc-failed-connection"))
self._client.stop(True) self._client.stop(True)
self._client.initPlayer(self) self._client.initPlayer(self)
def _fileUpdateClearEvents(self): def _fileUpdateClearEvents(self):
self._durationAsk.clear() self._durationAsk.clear()
self._filenameAsk.clear() self._filenameAsk.clear()
self._pathAsk.clear() self._pathAsk.clear()
def _fileUpdateWaitEvents(self): def _fileUpdateWaitEvents(self):
self._durationAsk.wait() self._durationAsk.wait()
self._filenameAsk.wait() self._filenameAsk.wait()
self._pathAsk.wait() self._pathAsk.wait()
def _onFileUpdate(self): def _onFileUpdate(self):
self._fileUpdateClearEvents() self._fileUpdateClearEvents()
self._getFileInfo() self._getFileInfo()
self._fileUpdateWaitEvents() self._fileUpdateWaitEvents()
self._client.updateFile(self._filename, self._duration, self._filepath) self._client.updateFile(self._filename, self._duration, self._filepath)
self.setPaused(self._client.getGlobalPaused()) self.setPaused(self._client.getGlobalPaused())
self.setPosition(self._client.getGlobalPosition()) self.setPosition(self._client.getGlobalPosition())
def askForStatus(self): def askForStatus(self):
self._positionAsk.clear() self._positionAsk.clear()
self._pausedAsk.clear() self._pausedAsk.clear()
self._listener.sendLine(".") self._listener.sendLine(".")
self._positionAsk.wait() self._positionAsk.wait()
self._pausedAsk.wait() self._pausedAsk.wait()
self._client.updatePlayerStatus(self._paused, self._position) self._client.updatePlayerStatus(self._paused, self._position)
def displayMessage(self, message, duration = constants.OSD_DURATION * 1000): def displayMessage(self, message, duration = constants.OSD_DURATION * 1000):
duration /= 1000 duration /= 1000
self._listener.sendLine('display-osd: {}, {}, {}'.format('top-right', duration, message)) self._listener.sendLine('display-osd: {}, {}, {}'.format('top-right', duration, message))
def setSpeed(self, value): def setSpeed(self, value):
self._listener.sendLine("set-rate: {:.2f}".format(value)) self._listener.sendLine("set-rate: {:.2f}".format(value))
def setPosition(self, value): def setPosition(self, value):
self._position = value self._position = value
self._listener.sendLine("set-position: {}".format(value)) self._listener.sendLine("set-position: {}".format(value))
def setPaused(self, value): def setPaused(self, value):
self._paused = value self._paused = value
self._listener.sendLine('set-playstate: {}'.format("paused" if value else "playing")) self._listener.sendLine('set-playstate: {}'.format("paused" if value else "playing"))
def _getFileInfo(self): def _getFileInfo(self):
self._listener.sendLine("get-duration") self._listener.sendLine("get-duration")
self._listener.sendLine("get-filepath") self._listener.sendLine("get-filepath")
self._listener.sendLine("get-filename") self._listener.sendLine("get-filename")
def lineReceived(self, line): def lineReceived(self, line):
match, name, value = self.RE_ANSWER.match(line), "", "" match, name, value = self.RE_ANSWER.match(line), "", ""
if match: if match:
name, value = match.group('command'), match.group('argument') name, value = match.group('command'), match.group('argument')
if(line == "filepath-change-notification"): if(line == "filepath-change-notification"):
t = threading.Thread(target=self._onFileUpdate) t = threading.Thread(target=self._onFileUpdate)
t.setDaemon(True) t.setDaemon(True)
t.start() t.start()
elif (name == "filepath" and value != "no-input"): elif (name == "filepath" and value != "no-input"):
if("file://" in value): if("file://" in value):
value = value.replace("file://", "") value = value.replace("file://", "")
if(not os.path.isfile(value)): if(not os.path.isfile(value)):
value = value.lstrip("/") value = value.lstrip("/")
self._filepath = value self._filepath = value
self._pathAsk.set() self._pathAsk.set()
elif(name == "duration" and (value != "no-input")): elif(name == "duration" and (value != "no-input")):
self._duration = float(value.replace(",", ".")) self._duration = float(value.replace(",", "."))
self._durationAsk.set() self._durationAsk.set()
elif(name == "playstate"): elif(name == "playstate"):
self._paused = bool(value != 'playing') if(value != "no-input") else self._client.getGlobalPaused() self._paused = bool(value != 'playing') if(value != "no-input") else self._client.getGlobalPaused()
self._pausedAsk.set() self._pausedAsk.set()
elif(name == "position"): elif(name == "position"):
self._position = float(value.replace(",", ".")) if (value != "no-input") else self._client.getGlobalPosition() self._position = float(value.replace(",", ".")) if (value != "no-input") else self._client.getGlobalPosition()
self._positionAsk.set() self._positionAsk.set()
elif(name == "filename"): elif(name == "filename"):
self._filename = value self._filename = value
self._filenameAsk.set() self._filenameAsk.set()
elif (line[:16] == "VLC media player"): elif (line[:16] == "VLC media player"):
self._vlcready.set() self._vlcready.set()
@staticmethod @staticmethod
def run(client, playerPath, filePath, args): def run(client, playerPath, filePath, args):
vlc = VlcPlayer(client, VlcPlayer.getExpandedPath(playerPath), filePath, args) vlc = VlcPlayer(client, VlcPlayer.getExpandedPath(playerPath), filePath, args)
return vlc return vlc
@staticmethod @staticmethod
def getDefaultPlayerPathsList(): def getDefaultPlayerPathsList():
l = [] l = []
for path in constants.VLC_PATHS: for path in constants.VLC_PATHS:
p = VlcPlayer.getExpandedPath(path) p = VlcPlayer.getExpandedPath(path)
if p: if p:
l.append(p) l.append(p)
return l return l
@staticmethod @staticmethod
def isValidPlayerPath(path): def isValidPlayerPath(path):
if("vlc" in path and VlcPlayer.getExpandedPath(path)): if("vlc" in path and VlcPlayer.getExpandedPath(path)):
return True return True
return False return False
@staticmethod @staticmethod
def getExpandedPath(playerPath): def getExpandedPath(playerPath):
if os.access(playerPath, os.X_OK): if os.access(playerPath, os.X_OK):
return playerPath return playerPath
for path in os.environ['PATH'].split(':'): for path in os.environ['PATH'].split(':'):
path = os.path.join(os.path.realpath(path), playerPath) path = os.path.join(os.path.realpath(path), playerPath)
if os.access(path, os.X_OK): if os.access(path, os.X_OK):
return path return path
def drop(self): def drop(self):
self._listener.sendLine('close-vlc') self._listener.sendLine('close-vlc')
self._durationAsk.set() self._durationAsk.set()
self._filenameAsk.set() self._filenameAsk.set()
self._pathAsk.set() self._pathAsk.set()
self._positionAsk.set() self._positionAsk.set()
self._vlcready.set() self._vlcready.set()
self._pausedAsk.set() self._pausedAsk.set()
self._client.stop(False) self._client.stop(False)
class __Listener(threading.Thread, asynchat.async_chat): class __Listener(threading.Thread, asynchat.async_chat):
def __init__(self, playerController, playerPath, filePath, args, vlcReady): def __init__(self, playerController, playerPath, filePath, args, vlcReady):
self.__playerController = playerController self.__playerController = playerController
call = [playerPath] call = [playerPath]
if(filePath): if(filePath):
call.append(filePath) call.append(filePath)
call.extend(playerController.SLAVE_ARGS) call.extend(playerController.SLAVE_ARGS)
if(args): if(args):
call.extend(args) call.extend(args)
self._vlcready = vlcReady self._vlcready = vlcReady
self.__process = subprocess.Popen(call, stderr=subprocess.PIPE) self.__process = subprocess.Popen(call, stderr=subprocess.PIPE)
threading.Thread.__init__(self, name="VLC Listener") threading.Thread.__init__(self, name="VLC Listener")
asynchat.async_chat.__init__(self) asynchat.async_chat.__init__(self)
self.set_terminator("\n") self.set_terminator("\n")
self._ibuffer = [] self._ibuffer = []
self.create_socket(socket.AF_INET, socket.SOCK_STREAM) self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self._sendingData = threading.Lock() self._sendingData = threading.Lock()
def initiate_send(self): def initiate_send(self):
with self._sendingData: with self._sendingData:
asynchat.async_chat.initiate_send(self) asynchat.async_chat.initiate_send(self)
def run(self): def run(self):
self._vlcready.clear() self._vlcready.clear()
time.sleep(constants.VLC_SOCKET_OPEN_WAIT_TIME) time.sleep(constants.VLC_SOCKET_OPEN_WAIT_TIME)
self.connect(('localhost', self.__playerController.vlcport)) self.connect(('localhost', self.__playerController.vlcport))
asyncore.loop() asyncore.loop()
def handle_connect(self): def handle_connect(self):
asynchat.async_chat.handle_connect(self) asynchat.async_chat.handle_connect(self)
self._vlcready.set() self._vlcready.set()
def collect_incoming_data(self, data): def collect_incoming_data(self, data):
self._ibuffer.append(data) self._ibuffer.append(data)
def handle_close(self): def handle_close(self):
asynchat.async_chat.handle_close(self) asynchat.async_chat.handle_close(self)
self.__playerController.drop() self.__playerController.drop()
def found_terminator(self): def found_terminator(self):
# print "received: {}".format("".join(self._ibuffer)) # print "received: {}".format("".join(self._ibuffer))
self.__playerController.lineReceived("".join(self._ibuffer)) self.__playerController.lineReceived("".join(self._ibuffer))
self._ibuffer = [] self._ibuffer = []
def sendLine(self, line): def sendLine(self, line):
if(self.connected): if(self.connected):
# print "send: {}".format(line) # print "send: {}".format(line)
self.push(line + "\n") self.push(line + "\n")