140 lines
4.5 KiB
Python
140 lines
4.5 KiB
Python
import threading
|
|
import subprocess
|
|
|
|
def yt(url, then_callback):
|
|
filename = subprocess.getoutput(f'yt-dlp --print filename "{url}"')
|
|
def run_in_thread():
|
|
proc = subprocess.run(["yt-dlp","-o",'data/%(title)s.%(ext)s',url])
|
|
then_callback(filename)
|
|
thread = threading.Thread(target=run_in_thread)
|
|
thread.start()
|
|
return filename # thread
|
|
|
|
from flask import Flask, render_template, send_from_directory
|
|
from flask_socketio import SocketIO
|
|
|
|
app = Flask(__name__)
|
|
socketio = SocketIO(app)
|
|
|
|
player = None
|
|
|
|
@app.route('/')
|
|
def ws_index(): return render_template('index.html')
|
|
|
|
from urllib.parse import unquote
|
|
@app.route('/data/<path:filename>')
|
|
def ws_data(filename):
|
|
print(unquote(filename))
|
|
return send_from_directory('data',unquote(filename))
|
|
# range_header = request.headers.get('Range', None)
|
|
# byte1, byte2 = 0, None
|
|
# if range_header:
|
|
# match = re.search(r'(\d+)-(\d*)', range_header)
|
|
# groups = match.groups()
|
|
# if groups[0]: byte1 = int(groups[0])
|
|
# if groups[1]: byte2 = int(groups[1])
|
|
# chunk, start, length, file_size = get_chunk(byte1, byte2)
|
|
# resp = Response(chunk, 206, mimetype='video/mp4', content_type='video/mp4', direct_passthrough=True)
|
|
# resp.headers.add('Content-Range', 'bytes {0}-{1}/{2}'.format(start, start + length - 1, file_size))
|
|
# return resp
|
|
|
|
@socketio.on('request_state')
|
|
def ws_request_state(): player.emit_full()
|
|
|
|
@socketio.on('request_url')
|
|
def ws_request_url(url): player.open_url(url)
|
|
|
|
@socketio.on('request_time')
|
|
def ws_request_time(time): player.set_time(time)
|
|
|
|
@socketio.on('request_play')
|
|
def ws_request_play(): player.play()
|
|
|
|
@socketio.on('request_pause')
|
|
def ws_request_pause(): player.pause()
|
|
|
|
### video-player stuff
|
|
import sys
|
|
from PyQt5.QtWidgets import QApplication, QMainWindow, QWidget, QSizePolicy
|
|
from PyQt5.QtCore import Qt, QUrl
|
|
from PyQt5.QtMultimedia import QMediaContent, QMediaPlayer
|
|
from PyQt5.QtMultimediaWidgets import QVideoWidget
|
|
|
|
class VideoWindow(QMainWindow):
|
|
def __init__(self, parent=None):
|
|
super(VideoWindow, self).__init__(parent)
|
|
self.setWindowTitle("piplayer")
|
|
|
|
videoWidget = QVideoWidget()
|
|
videoWidget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
|
|
self.setCentralWidget(videoWidget)
|
|
|
|
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
|
|
self.mediaPlayer.setVideoOutput(videoWidget)
|
|
self.mediaPlayer.stateChanged.connect(self.emit_state)
|
|
self.mediaPlayer.positionChanged.connect(self.emit_time)
|
|
self.mediaPlayer.durationChanged.connect(self.emit_duration)
|
|
self.mediaPlayer.error.connect(self.handleError)
|
|
|
|
# this looks utterly stupid.
|
|
self.showFullScreen()
|
|
size = app.primaryScreen().size()
|
|
self.resize(size.width(), size.height())
|
|
|
|
self.current_file = ""
|
|
self.history = [] # TODO
|
|
|
|
def open_file(self, path):
|
|
self.history.append(path)
|
|
self.current_file=path
|
|
import pathlib
|
|
current_path = pathlib.Path(__file__).parent.resolve()
|
|
abs_path = f"{current_path}/data/{path}"
|
|
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(abs_path)))
|
|
self.play()
|
|
|
|
def emit_duration(self,duration): socketio.emit('duration' ,duration/1000,broadcast=True)
|
|
def emit_time(self,time): socketio.emit('time' ,time /1000,broadcast=True)
|
|
def emit_state(self,state): socketio.emit('state' ,state == QMediaPlayer.PlayingState,broadcast=True)
|
|
def emit_current_file(self): socketio.emit('current_file',self.current_file,broadcast=True)
|
|
|
|
def emit_full(self):
|
|
socketio.emit('current_file',self.current_file)
|
|
socketio.emit('duration' ,self.mediaPlayer.duration()/1000)
|
|
socketio.emit('time' ,self.mediaPlayer.position()/1000)
|
|
socketio.emit('state' ,self.mediaPlayer.state() == QMediaPlayer.PlayingState)
|
|
|
|
def open_url(self, url):
|
|
pass
|
|
print(f"requested {url}")
|
|
def post_dl(filename):
|
|
self.open_file(filename)
|
|
self.emit_full()
|
|
filename = yt(url, post_dl)
|
|
self.history.append(url)
|
|
self.open_file(filename)
|
|
self.emit_full()
|
|
# TODO self.open_file(downloaded_file)
|
|
|
|
def play(self):
|
|
self.mediaPlayer.play()
|
|
self.emit_state(self.mediaPlayer.state())
|
|
|
|
def pause(self):
|
|
self.mediaPlayer.pause()
|
|
self.emit_state(self.mediaPlayer.state())
|
|
|
|
def set_time(self, time):
|
|
self.mediaPlayer.setPosition(int(1000*time))
|
|
self.emit_time(self.mediaPlayer.position())
|
|
|
|
def handleError(self):
|
|
print("Error: " + self.mediaPlayer.errorString())
|
|
|
|
threading.Thread(target=lambda: socketio.run(app,host="0.0.0.0",port=5000)).start()
|
|
|
|
app = QApplication(sys.argv)
|
|
player = VideoWindow()
|
|
sys.exit(app.exec_())
|
|
|