def __init__(self, args, actor):
super(MplayerPollingThread, self).__init__()
self._actor = actor
import mplayer
if args.debug:
self._player = mplayer.Player()
else:
self._player = mplayer.Player(stderr = subprocess.DEVNULL)
pass
self._refresh_interval = args.refresh_interval
self.queue = queue.SimpleQueue()
self.running = True
pass
def __init__(self, queue):
# set up mplayer
self.player = mplayer.Player(autospawn=False)
self.player.args = ['-really-quiet', '-msglevel', 'global=6']
# set up event handlers
self.playback_finish_handlers = []
self.playback_skip_handlers = []
self.playback_stop_handlers = []
self._event_handlers = {
"playback_finish": [],
"playback_skip": [],
"playback_stop": []
}
self.player.stdout.connect(self._playback_end_event)
# now set up state variables
self.queue = queue # use queue object to fetch next
self.nowPlaying = {}
self._paused = False
self.vol = 100
# then spawn mplayer
self.player.spawn()
self.player.volume = self.vol
def __init__(self):
super().__init__()
import mplayer
self._mp = mplayer.Player()
self._loaded = False
self._playing = False
self._thread_canceller = threading.Event()
def playback_observer():
while True:
if self._thread_canceller.is_set():
return
new_loaded = bool(self._mp.stream_length)
if not self._loaded == new_loaded:
self._loaded = new_loaded
self.trigger_file_change()
is_playing = not self._mp.paused
if not self._playing == is_playing:
self._playing = is_playing
if is_playing:
self.trigger_playback_start()
else:
self.trigger_playback_stop()
time.sleep(1)
t = threading.Thread(target=playback_observer)
t.daemon = True
t.start()
def play():
global player
data = request.forms.get('json', None)
if data is None:
return {'err': '403', 'msg': 'request error'}
print(data)
data = json.loads(data)
files = data.get('files', [])
url = data.get('url')
last = data.get('start', 0)
fullscreen = data.get('fullscreen', False)
volume = data.get('volume')
if url:
format = data.get('format', 'nomal')
files = parse_video(url, format)
if files is None or len(files) == 0:
return {'err': '403', 'msg': 'request error'}
if player is None or not player.is_alive():
player = mplayer.Player()
if fullscreen:
player.fullscreen = bool(fullscreen)
if volume:
player.volume = float(volume)
for fn in files:
player.loadfile(fn, last)
last += 1
return {'last': last}
def __init__(self, font, assets_dir):
rospy.loginfo("Loading font %s assets dir %s", font, assets_dir)
self.assets_dir = assets_dir
self.player = mplayer.Player(
'-nolirc -vo fbdev2:/dev/fb1 -vf scale=128:-3')
#pygame.init()
#rospy.loginfo("pygame init complete")
#pygame.font.init()
#pygame.mouse.set_cursor((8,8),(0,0),(0,0,0,0,0,0,0,0),(0,0,0,0,0,0,0,0))
#pygame.mouse.set_visible(False)
#self.disp = pygame.display.set_mode((HEIGHT, WIDTH))
#rospy.loginfo("Display set mode complete")
# Clear the display to a red background.
# Can pass any tuple of red, green, blue values (from 0 to 255 each).
self.y_offset = 10
# Load default font.
#self.font = pygame.font.Font(font, 16)
#rospy.loginfo("Font load complete")
rospy.Subscriber("robot_commands",
RobotCmd,
self.robot_state,
queue_size=1)
def __init__(self, workingDirectory='songs'):
# set up working directory:
# assert isinstance(workingDirectory, str)
self.workingDirectory = workingDirectory if workingDirectory.endswith(
'/') else workingDirectory + '/'
# set up mplayer
self._mplayer = mplayer.Player(autospawn=False)
self._mplayer.args = ['-really-quiet', '-msglevel', 'global=6']
# set up event handlers (private) and hooks (public)
self._mplayer_event_handlers = {
"playback_finish": [],
"playback_skip": [],
"playback_stop": []
}
# event listeners is a tuple of (event_name, listener)
self._event_listeners = []
self._mplayer.stdout.connect(self._playback_end_event_handler)
# now set up state
self._queue = []
self._now_playing = {}
self._is_playing = False
self._paused = False
self._vol = 100
self._randomize = False
self._loop = False
# then spawn mplayer
self._mplayer.spawn()
self._mplayer.volume = self._vol
def __init__(self, playlist=[], paused=False, pulse=False):
""""""
self._playlist = []
for entry in playlist:
self.append(entry)
self._pause = paused
self._archive = []
if pulse:
self._p = mplayer.Player(args="-ao pulse")
else:
self._p = mplayer.Player()
threading.Thread.__init__(self)
self.daemon = True
self._current = None
self._next = None
def __init__(self):
mplayer.Player.cmd_prefix = mplayer.CmdPrefix.PAUSING_KEEP
if utils.config.Config().mplayer_executable() is not None:
mplayer.Player.exec_path = utils.config.Config(
).mplayer_executable()
mplayer.Player.introspect()
self._player = mplayer.Player()
self._player.args = ['-really-quiet', '-msglevel', 'global=6']
def __init__(self, **kwargs):
super(MPlayer, self).__init__(**kwargs)
self.EOFArgs = "-msglevel global=6"
self.playing = False
self.player = mplayer.Player(args=self.EOFArgs.split())
self.player.stdout.connect(self.handle_player_output)
logger.debug(f'Init MPlayer, {self.player}')
self.onCompleteds = []
def __init__(self, glob=None):
self.player = mplayer.Player(args=('-user-agent',
user_agent)) #, '-ao', 'pulse'))
self.player.cmd_predix = ''
self.queue = Queue.Queue()
self.glob = glob
self.thrd = Thread(target=self._loop, args=(), name="alice")
self.thrd.start()
self.glob.get('threads').append(self.thrd)
def load(self, media, cookies=None):
os.environ["DISPLAY"] = ":0"
args = [
'-fs', '-http-header-fields',
'User-Agent: Mozilla/5.0 (X11; U; Linux i686) Gecko/20071127 Firefox/2.0.0.11'
]
if cookies is not None:
args += ['-cookies', '-cookies-file', cookies, media]
self.mp = mplayer.Player(args=args)
self.loaded = True
def start_playing(uuid, ytid):
global current_uuid, should_be_paused, player
if current_uuid is not None:
stop_playing()
if player is None:
player = mplayer.Player(args=player_args)
assert player.filename is None
if stash.exists(ytid):
current_uuid = uuid
player.loadfile(stash.path_for(ytid))
should_be_paused = False
def audioPlayer(players, audio):
#print('audioPlayer')
'''generates audio players and sets correct settings'''
z = 0
for p in players:
globals()[p] = mplayer.Player()
globals()[p].loadfile(audio[z])
globals()[p].volume = 0
globals()[p].loop = 0
#print(globals()[p])
z += 1
def __init__(self):
self.builder = gtk.Builder()
self.builder.add_from_file(sys.path[0] + "/EDUS2.glade")
# Add a timer and a function to update the progress bar
self.timer = gobject.timeout_add(200, self.progress_bar_updater, self)
self.window = self.builder.get_object("window1")
self.settings_dialog = self.builder.get_object("settings_dialog")
self.add_scan_dialog = self.builder.get_object("add_scan_dialog")
self.quick_add_dialog = self.builder.get_object("quick_add_dialog")
self.quick_add_item = self.builder.get_object("quick_add_item")
self.about_dialog = self.builder.get_object("aboutdialog1")
self.tree = self.builder.get_object("treeview2")
self.list_store1 = self.builder.get_object("treeview")
self.rfid_entry = self.builder.get_object("rfid_entry")
self.rfid_quick_entry = self.builder.get_object("rfid_quick_entry")
self.name_entry = self.builder.get_object("name_entry")
self.quick_add_cur_filename = self.builder.get_object(
"quick_add_cur_filename")
self.filechooser = self.builder.get_object("filechooserbutton1")
self.filechooser_quick = self.builder.get_object(
"filechooserbutton_quick")
self.load_settings_filechooserdialog = self.builder.get_object(
"load_settings_filechooserdialog")
self.save_settings_filechooserdialog = self.builder.get_object(
"save_settings_filechooserdialog")
self.load_settings(sys.path[0] + "/settings.p")
self.builder.connect_signals(self)
# Start mplayer up
self.drawingarea = self.builder.get_object("drawingarea1")
self.drawingarea.set_size_request(640, 480)
self.drawingarea.realize()
xid = self.drawingarea.window.xid
errorLog = open("mplayer.log", 'w')
self.mp = mplayer.Player("-vo x11 -zoom -wid %i" % (xid),
stderr=errorLog)
# Set up treeView to allow multiple item selection for better delete
self.tree.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.mainWindow = self.builder.get_object("window1")
self.mainWindow.connect("key-press-event", self.on_key_press_event)
self.window.show_all()
self.mainWindow.fullscreen()
def play(self, src, time_pos, onCompleted=None):
if os.path.exists(src) or src.startswith('http'):
if onCompleted is not None:
self.onCompleteds.append(onCompleted)
if not self.player.is_alive():
self.player = mplayer.Player(args=self.EOFArgs.split())
self.player.stdout.connect(self.handle_player_output)
logger.debug(f'mplayer play time_pos: {time_pos}')
self.player.loadfile(src)
if time_pos:
self.player.time_pos = time_pos
self.playing = True
else:
logger.critical(f'file path not exists: {src}')
def main(infile, marks, outf):
# Curses initialization
stdscr = curses.initscr()
curses.noecho()
curses.cbreak()
curses.curs_set(False)
# Main screen
maxlines = stdscr.getmaxyx()[0]
scr = stdscr.subwin(maxlines, 32, 0, 0)
scr.nodelay(True)
scr.keypad(True)
# Prepare marks window
mwin = stdscr.subwin(0, 33)
# mwin.scrollok(True)
# mplayer initialization
p = mp.Player()
p.loadfile(infile)
# Start paused
p.pause()
p.time_pos = 0.0
scr.addstr('Total time: ')
scr.addstr(str(p.length))
scr.addstr(' seconds\n')
scr.addstr(6, 0, 'Pause: ' + str(p.paused) + '\n')
scr.addstr(8, 0, 'Default keys:\n')
scr.addstr('Quit: <esc> or q\n')
scr.addstr('Pause: p\n')
scr.addstr('Mark position: <space>\n')
scr.addstr('Manually edit mark: e\n')
scr.addstr('Add manual mark: a\n')
scr.addstr('Remove mark: r\n')
scr.addstr('Faster speed: <Key-Up>\n')
scr.addstr('Slower speed: <Key-Down>\n')
scr.addstr('Rewind: <Key-Left>\n')
scr.addstr('Fast Forward: <Key-Right>\n')
scr.addstr('Scroll down marks: <Key-pgDwn>\n')
scr.addstr('Scroll up marks: <Key-pgUp>\n')
pausedhere = False
moveFirstTime = True
movePos = 0.0
updatemarks.count = 1 # Start showing from the first mark
updatemarks(mwin, marks)
# Main loop
while True:
scr.addstr(1, 0, 'Time: ')
if moveFirstTime:
movePos = p.time_pos
scr.addstr(str(movePos))
scr.addstr(' seconds\n')
scr.refresh()
# updatemarks(mwin, marks, maxlines)
c = scr.getch()
if c == ord('q') or c == 27:
break
elif c == ord(' '): # Space pressed
if not p.paused:
p.pause() # Make sure both screen and file has the same time
pausedhere = True
scr.addstr(2, 0, 'Mark at: ' + str(p.time_pos) + ' seconds\n')
marks.append(p.time_pos)
updatemarks(mwin, marks)
if pausedhere:
pausedhere = False
p.pause()
elif c == ord('e'):
if not p.paused:
p.pause()
pausedhere = True
if len(marks) > 0:
updatemarks(mwin, marks, edit=True)
else:
scr.addstr(5, 0, 'No mark to edit\n')
if pausedhere:
pausedhere = False
p.pause()
elif c == ord('a'):
if not p.paused:
p.pause()
pausedhere = True
updatemarks(mwin, marks, add=True)
if pausedhere:
pausedhere = False
p.pause()
elif c == ord('r'):
if not p.paused:
p.pause()
pausedhere = True
if len(marks) > 0:
updatemarks(mwin, marks, remove=True)
else:
scr.addstr(5, 0, 'No mark to remove\n')
if pausedhere:
pausedhere = False
p.pause()
elif c == ord('p'):
if not moveFirstTime:
moveFirstTime = True
p.time_pos = movePos
p.pause()
scr.addstr(6, 0, 'Pause: ' + str(p.paused) + '\n')
elif c == curses.KEY_UP:
if not p.paused:
p.pause()
pausedhere = True
p.speed_incr(0.05)
scr.addstr(3, 0, 'Speed set at: x' + str(p.speed) + '\n')
if pausedhere:
pausedhere = False
p.pause()
elif c == curses.KEY_DOWN:
if not p.paused:
p.pause()
pausedhere = True
p.speed_incr(-0.05)
scr.addstr(3, 0, 'Speed set at: x' + str(p.speed) + '\n')
if pausedhere:
pausedhere = False
p.pause()
elif c == curses.KEY_LEFT:
if not p.paused:
p.pause()
pausedhere = True
if moveFirstTime:
movePos = p.time_pos
moveFirstTime = False
movePos -= TIME_STEP
scr.addstr(4, 0, 'Back to ' + str(movePos) + ' seconds\n')
if pausedhere:
pausedhere = False
moveFirstTime = True
p.time_pos = movePos
p.pause()
elif c == curses.KEY_RIGHT:
if not p.paused:
p.pause()
pausedhere = True
if moveFirstTime:
movePos = p.time_pos
moveFirstTime = False
movePos += TIME_STEP
scr.addstr(4, 0, 'Forward to ' + str(movePos) + ' seconds\n')
if pausedhere:
pausedhere = False
moveFirstTime = True
p.time_pos = movePos
p.pause()
elif c == curses.KEY_PPAGE:
updatemarks(mwin, marks, pgUp=True)
elif c == curses.KEY_NPAGE:
updatemarks(mwin, marks, pgDwn=True)
# Write the output
if outf is not None:
writebuf(marks, outf)
# Reset terminal to normal operation before quitting
curses.echo()
curses.nocbreak()
curses.curs_set(True)
scr.keypad(False)
stdscr.nodelay(False)
curses.endwin()
sys.exit()
from PyQt4 import QtCore, QtGui, uic
from PyQt4.QtGui import QIcon, QImage, QPixmap
import mplayer, sys, os, json, time
from xml.dom import minidom
from urllib.request import Request, urlopen
path = os.path.dirname(os.path.abspath(__file__)).rsplit('/', 1)
form_class = uic.loadUiType(path[0] + "/" + path[1] + "/internet.ui")[0]
player = mplayer.Player()
class radio(QtGui.QMainWindow, form_class):
def __init__(self, parent=None, settings=None):
QtGui.QWidget.__init__(self, parent)
self.stations = {}
self.setupUi(self)
def loaded():
self.stationList.itemClicked.connect(
lambda: self.setChannel(self.stationList.currentRow()))
self.readChannels()
def focus(self):
pass
def pause(self):
if not player.paused:
player.pause()
def stop(self):
class DanmakuHandler(bili.SimpleDanmakuHandler):
home_path = os.path.expanduser("~")
lib_path = home_path + '/Music/lib/'
all_music = []
to_play_lst = []
p = mplayer.Player()
LOCK = threading.Lock()
cur_user = None
state = 'play'
timer = None
config = bili_config.Config()
sender = bili_sender.Sender(config.cookies)
skip = False
def __init__(self, roomid):
self.roomid = roomid
self.loadMusic()
thread.start_new_thread(self.musicThread, ())
self.db = DBHelper()
def clear(self):
print("\033c")
if self.p.filename: print '正在播放: ', self.p.filename[:-4]
def printHelp(self): print('发 \'点歌\' 进入 点歌模式，在点歌模式下发 \'搜索 关键字\' 搜索列表，在点歌模式下发送 \'点歌 ID\' 完成点歌。发送 \'退出\' 结束点歌。请在五分钟内完成全部操作哦～')
def printToPlay(self):
print '当前待播放列表：'
for u, m in self.to_play_lst: print '%s 点了\t: %s' % (u, m.name)
def loadMusic(self):
origin_music = [f[:-4] for f in os.listdir(self.lib_path) if f[-4:] == '.mp3']
with open('%s/.pybili.ti' % self.home_path, 'w') as f:
f.write('\n'.join(origin_music))
try:
subprocess.Popen('opencc -i %s/.pybili.ti -o %s/.pybili.to -c t2s.json' % (self.home_path, self.home_path), shell=True)
with open('%s/.pybili.to' % self.home_path, 'r') as f:
lst = f.read().split('\n')
self.all_music = [Music(n,s,n) for n, s in zip(origin_music, lst)]
except:
print 'init cc error'
self.all_music = [Music(n,n,n) for n in origin_music]
if DEBUG: print self.all_music
if DEBUG: print self.all_music[0], len(self.all_music)
def playMusic(self, name):
if DEBUG:
print 'player state:', self.p.is_alive()
print 'self state:', self.state
while self.state != 'play': time.sleep(1)
self.p.stop()
self.p.loadfile(self.lib_path + name + '.mp3')
time.sleep(0.5)
if DEBUG: print 'playing ', self.p.filename
self.clear()
if self.cur_user: print '当前操作者：', self.cur_user
self.printToPlay()
self.p.volume = 20
length = self.p.length
self.p.pause()
if DEBUG: print length
for i in xrange(int(length)):
if self.skip:
if DEBUG: print 'skip play ', name, self.p.filename
self.p.stop()
self.skip = False
break
time.sleep(1)
else:
if DEBUG: print 'finish play ', name, self.p.filename
def musicThread(self):
while 1:
if self.to_play_lst:
self.LOCK.acquire()
u, music = self.to_play_lst.pop(0)
self.LOCK.release()
self.playMusic(music.name)
else:
music = random.choice(self.all_music)
self.playMusic(music.name)
if not self.cur_user:
self.printToPlay()
def localTimerThread(self, user):
if self.cur_user == user:
self.cur_user = None
self.clear()
self.printToPlay()
print '五分钟到了哦～'
def match(self, key, music):
if key in music.lower(): return True
keys = key.split(' ')
if len(keys) > 1:
if all(k in music.lower() for k in keys): return True
def search(self, key):
result = []
for i, m in enumerate(self.all_music):
if self.match(key, m.searchKey()): result += [(i+1, m.name)]
if len(result) == 0:
self.sender.sendDanmaku(self.roomid, 'Sorry...这里没有对应的歌')
elif len(result) == 1:
self.addToPlayList(result[0][0])
else:
if self.cur_user != 'klikli': self.sender.sendDanmaku(self.roomid, '搜索 %s 中...' % key)
print '搜索 %s 的结果列表：' % key
for i, t in result:
print '%d\t: %s' % (i, t)
print '切歌时候会导致搜索结果丢失，请注意重新搜索哦'
def addToPlayListByName(self, name):
to_add = Music(name, name, name)
self.LOCK.acquire()
if len(self.to_play_lst) < 10:
if not any([1 for _, music in self.to_play_lst if music.name == to_add.name]):
self.to_play_lst += [(self.cur_user, to_add)]
self.LOCK.release()
self.clear()
self.printToPlay()
self.sender.sendDanmaku(self.roomid, '[%s...]点歌成功' % to_add.name[:15])
def addToPlayList(self, i):
to_add = self.all_music[i-1]
self.addToPlayListByName(to_add.name)
def printFav(self, danmaku):
print DIVIDER
print '%s的收藏列表: ' % danmaku.user
favs = self.db.selectFavorite(danmaku)
for i, name in enumerate(favs):
print '%d, %s' % (i+1, name)
def handleDanmaku(self, danmaku):
super(DanmakuHandler, self).handleDanmaku(danmaku)
body = danmaku.rawData
if danmaku.action == 5:
raw = json.loads(body)
if DEBUG: print raw
if 'info' in raw:
info = raw['info']
user = info[2][1].encode('utf-8')
manager = info[2][2]
content = info[1].encode('utf-8')
if manager and content in ['切歌']:
self.skip = True
if content in ['查看收藏','收藏列表']:
if (not self.cur_user) or (self.cur_user == user):
self.clear()
self.printToPlay()
self.printFav(danmaku)
elif content[:6] in ['收藏']:
try:
if len(content) == 6: to_add = self.p.filename[:-4]
else:
i = int(content[6:].strip())
to_add = self.all_music[i-1].name
self.db.insertFavorite(danmaku, to_add)
self.sender.sendDanmaku(self.roomid, '[%s...]收藏成功' % to_add[:15])
except Exception, e:
if DEBUG: traceback.print_exc()
self.sender.sendDanmaku(self.roomid, '请输入正确的指令哦')
elif content[:6] in ['点歌', '點歌']:
if not self.cur_user:
self.cur_user = user
self.printHelp()
print '当前操作者：' + user
self.timer = threading.Timer(300, self.localTimerThread, (user, ))
self.timer.start()
self.sender.sendDanmaku(self.roomid, '%s开始点歌～' % self.cur_user)
if self.cur_user == user:
k = content[6:].strip()
if not k: return
try:
if k[0] == '@': # play from favorite
i = int(k[1:])
favs = self.db.selectFavorite(danmaku)
self.addToPlayListByName(favs[i-1])
else:
if k.isdigit(): self.addToPlayList(int(k)) # play by id
else: self.search(k.lower()) # search
except Exception, e:
if DEBUG: print e
self.sender.sendDanmaku(self.roomid, '请输入正确的点歌指令哦')
else:
self.sender.sendDanmaku(self.roomid, '%s正在点歌, 请等一下哦' % self.cur_user)
elif user == self.cur_user and content[:6] in ['搜索']:
self.clear()
key = content[6:].strip().lower()
self.search(key)
elif user == self.cur_user and content.lower() in ['退出', 'exit', '结束', 'quit']:
self.sender.sendDanmaku(self.roomid, '欢迎再来点歌哦～')
self.cur_user = None
if self.timer: self.timer.cancel()
self.clear()
self.printToPlay()
elif user == 'klikli' and content == 'reload':
self.loadMusic()
print '重新加载歌曲库...'
def _setupClient(self):
self._client = mplayer.Player()
return True
def __init__(self):
self.player = mplayer.Player()
self._inPlay = False
current_uuid = None
should_be_paused = False
display_video = (os.getenv("MZ_VIDEO") == "true")
xinerama_screen = os.getenv("MZ_XINERAMA_SCREEN")
if display_video:
os.environ["DISPLAY"] = ":0.0"
if xinerama_screen:
player_args = ("-fs", "--xineramascreen=%s" % xinerama_screen)
else:
player_args = ("-fs")
else:
player_args = ("-vo", "null")
player = mplayer.Player(args=player_args)
queue = mqueue.Queue()
stash = mqueue.Stash()
if display_video:
subprocess.check_call(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
"configure-screen.sh"))
def start_playing(uuid, ytid):
global current_uuid, should_be_paused, player
if current_uuid is not None:
stop_playing()
if player is None:
def init_audio():
return mplayer.Player(args=["-ao", "alsa:device=hw=" + str(JACK)])
import RPi.GPIO as GPIO
import time, urllib2, base64
import config
import subprocess
import mplayer
blipper = mplayer.Player()
print "Starting button listener..."
## setup GPIO
GPIO.setmode(GPIO.BCM)
print "Pin address mode set to BCM."
# This can be use to control pianobar instead of bemix.
## open fifo
def pianowrite(cmd):
with open('/home/pi/.config/pianobar/ctl', 'w') as f:
f.write(cmd)
def bemix_remote_command(command):
url = config.SERVER_NOSSL + "/remix/" + config.NODENAME + "/command/" + command
print url
req = urllib2.Request(url)
base64string = base64.standard_b64encode(
'%s:%s' % (config.SECRET_USERNAME, config.SECRET_PASSWORD)).replace(
'\n', '')
req.add_header("Authorization", "Basic %s" % base64string)
res = urllib2.urlopen(req)
def __init__(self, parent=None, settings=None):
QtGui.QWidget.__init__(self, parent)
self.mp3player = mplayer.Player()
def __init__(self):
# Instantiate a new player
self._player = mplayer.Player()
def __init__(self, dir_path):
self.player = mplayer.Player()
self.dir_path = dir_path
