class PlayVideo(DisplayEvent):
def __init__(self, frame, settings):
super().__init__(frame, settings)
self.url = QUrl(settings.get("url"))
self.start_time = settings.get("start", 0) * 1000
self.duration = settings.get("duration")
self.loop = settings.get("loop", True)
self.volume = settings.get("volume", 100)
self.playback_rate = settings.get("playbackRate", 1.0)
def do_tick(self):
if self.player:
self.logging.info("position: %s/%s status: %s error: %s" % (
self.player.position(),
self.player.duration(),
self.player.mediaStatus(),
self.player.errorString(),
))
if self.player.errorString():
self.logging.error(self.player.errorString())
self.cancel()
def do_initialize(self):
super().do_initialize()
self.video = QVideoWidget(self.widget)
self.add_widget(self.video)
self.video.show()
self.media = QMediaContent(self.url)
self.playlist = QMediaPlaylist(self.video)
self.playlist.addMedia(self.media)
self.playlist.setPlaybackMode(
QMediaPlaylist.Loop if self.loop else QMediaPlaylist.Sequential)
self.player = QMediaPlayer(self.widget)
self.player.setVideoOutput(self.video)
self.player.setVolume(self.volume)
self.player.setPlaybackRate(self.playback_rate)
def do_run(self):
super().do_run()
self.player.setPlaylist(self.playlist)
self.player.setPosition(self.start_time)
self.player.play()
if self.player.errorString():
self.logging.error(self.player.errorString())
self.cancel()
def do_stop(self):
super().do_stop()
self.player.stop()
def do_reset(self):
self.player = None
self.video = None
class PlayerDialog(QDialog):
def __init__(self, video, dimensions, parent=None):
QDialog.__init__(self,
parent=parent,
flags=QtCore.Qt.WindowSystemMenuHint
| QtCore.Qt.WindowTitleHint
| QtCore.Qt.WindowCloseButtonHint)
uic.loadUi('resources/videoplay.ui', self)
self.videoWidget = QVideoWidget()
self.stageLayout.addWidget(self.videoWidget)
self.stage.setMinimumSize(QtCore.QSize(dimensions[0], dimensions[1]))
self.playbtn.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.seekslider.mousePressEvent = self.__direct_slider_click
self.seekslider.sliderMoved.connect(self.set_position)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.stateChanged.connect(self.__media_state_changed)
self.mediaPlayer.positionChanged.connect(self.__position_changed)
self.mediaPlayer.durationChanged.connect(self.__duration_changed)
self.mediaPlayer.error.connect(self.handle_error)
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(video)))
def __media_state_changed(self, state):
if state == QMediaPlayer.PlayingState:
self.playbtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playbtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
if state == QMediaPlayer.StoppedState:
self.play()
def __direct_slider_click(self, event):
if event.button() == QtCore.Qt.LeftButton:
calc_value = self.seekslider.minimum() + (
(self.seekslider.maximum() - self.seekslider.minimum()) *
event.x()) / self.seekslider.width()
self.seekslider.setValue(calc_value)
self.set_position(calc_value)
event.accept()
QSlider.mousePressEvent(self.seekslider, event)
def __position_changed(self, position):
self.seekslider.setValue(position)
def __duration_changed(self, duration):
self.seekslider.setRange(0, duration)
self.play()
def handle_error(self):
logger.error(self.mediaPlayer.errorString())
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def set_position(self, position):
self.mediaPlayer.setPosition(position)
class Ui_ImageWidget(object):
def setupUi(self, ImageWidget):
ImageWidget.setObjectName("ImageWidget")
ImageWidget.resize(1024, 768)
ImageWidget.setAutoFillBackground(False)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.horizontalLayoutWidget = QtWidgets.QWidget(ImageWidget)
self.horizontalLayoutWidget.setGeometry(QtCore.QRect(0, 0, 1024, 768))
self.horizontalLayoutWidget.setObjectName("horizontalLayoutWidget")
self.horizontalLayout = QtWidgets.QHBoxLayout(self.horizontalLayoutWidget)
self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
self.horizontalLayout.setObjectName("horizontalLayout")
self.imageLabel = QtWidgets.QLabel()
self.imageLabel.setText("")
self.imageLabel.setObjectName("imageLabel")
self.horizontalLayout.addWidget(self.imageLabel)
self.retranslateUi(ImageWidget)
QtCore.QMetaObject.connectSlotsByName(ImageWidget)
def retranslateUi(self, ImageWidget):
_translate = QtCore.QCoreApplication.translate
ImageWidget.setWindowTitle(_translate("ImageWidget", "Form"))
def handleError(self):
print("Error" + self.mediaPlayer.errorString())
class MyWin(QMainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.ui = Ui_VideoPlayer()
self.ui.setupUi(self)
self.media_player = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.media_player_widget = QVideoWidget(self.ui.mid_frame)
self.ui.mid_frame_layout.addWidget(self.media_player_widget)
self.media_player.setVideoOutput(self.media_player_widget)
self.media_player.error.connect(self.handleError)
# fileName="E:/Dropbox/Hobby/PRG/PyWork/FGet/view/qt_ui/files/1.mp4"
# self.media_player.setMedia(QMediaContent(QUrl.fromLocalFile(fileName)))
# fileName="E:/exchange/DiskD/kl/1/road_to_abbi_big-1080.mp4.Epidemz.net_Triksa.com.mp4"
# self.media_player.setMedia(QMediaContent(QUrl.fromLocalFile(fileName)))
self.ui.bn_go.clicked.connect(self.go)
self.media_player.bufferStatusChanged.connect(self.buf)
self.media_player.mediaStatusChanged.connect(self.med)
# url='http://tubedupe.com/get_file/1/693b07616d5019e3e266e772676e3048/56000/56102/56102.mp4'
url = 'http://tubedupe.com/get_file/1/4b274e3f4027b13bf6d6ae5601dd7a09/50000/50768/50768.mp4'
url = 'http://www.mypornovideo.net/video_file/2015/2/830/grudastaja_blondinka_ebetsja_s_kuchejj_muzhikov.flv'
url = "http://im.50f9bc00.493dea4.cdn2b.movies.mxn.com/0/399/399060/NOWATERMARK_IPOD.mp4?s=1423689551&e=1423696751&ri=1227&rs=44&h=d0a58a04acc858983a202b5e8dea575a"
self.media_player.setMedia(QMediaContent(QUrl(url)))
self.media_player.play()
self.media_player.setMuted(True)
print(self.media_player.duration())
print('Done')
def handleError(self):
print('Error: ' + self.media_player.errorString())
def buf(self, percent):
print(percent, '%')
def med(self, media):
print(media)
def go(self):
dur = self.media_player.duration()
pos = self.media_player.position()
print(dur // 1000, pos // 1000)
print(self.media_player.bufferStatus())
# self.hide()
self.media_player.stop()
class Video:
def __init__(self, mainWindow):
self.mainWindow = mainWindow
self.fileName = ''
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoWidget = QVideoWidget()
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(
self.mainWindow.positionChanged)
self.mediaPlayer.durationChanged.connect(
self.mainWindow.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self.mainWindow,
"Open Movie",
QDir.homePath())
if fileName != '':
self.fileName = fileName
def setMediaPlayer(self, fileName):
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(fileName)))
self.mainWindow.playButton.setEnabled(True)
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mainWindow.playButton.setIcon(
self.mainWindow.style().standardIcon(QStyle.SP_MediaPause))
else:
self.mainWindow.playButton.setIcon(
self.mainWindow.style().standardIcon(QStyle.SP_MediaPlay))
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.mainWindow.playButton.setEnabled(False)
self.mainWindow.errorLabel.setText("Error: " +
self.mediaPlayer.errorString())
class songctl(object):
def __init__(self, queue, signals):
self.queue = queue
self.signals = signals
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer.stateChanged.connect(
signals._signal_stateChanged.emit)
self.mediaPlayer.positionChanged.connect(
signals._signal_positionChanged.emit)
self.mediaPlayer.durationChanged.connect(
signals._signal_durationChanged.emit)
#self.mediaPlayer.error.connect(self.handleError)
def handleError(self):
return self.mediaPlayer.errorString()
def play(self, localpath):
print('localpath:{}'.format(localpath))
self.mediaPlayer.stop()
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(localpath)))
self.mediaPlayer.play()
print('开始播放{}'.format('23333'))
class VideoPlayer(QWidget):
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoWidget = QVideoWidget()
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
layout = QVBoxLayout()
layout.addWidget(self.videoWidget)
layout.addLayout(controlLayout)
self.setLayout(layout)
# ПЛЕЕР
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.error.connect(self.handleError)
# ТАЙМЕР
self.timer = QTimer()
self.timer.timeout.connect(self.check)
self.timer.start(1000)
def check(self):
with open('connect.txt', 'r', encoding='utf8') as f:
text = [str(i) for i in f.read().split('|')]
if text[-1]:
fileName = get_path(int(text[-1]))
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.mediaPlayer.play()
with open('connect.txt', 'w', encoding='utf8') as f:
f.write('')
def handleError(self):
print("Error: " + self.mediaPlayer.errorString())
class VideoDisplay(QWidget):
def __init__(self):
super().__init__()
self.video_name = ''
self.wholeStyleSheet = '''
QFrame{
padding-right:0.5px;
padding-left:0.5px;
margin-top:0.5px;
margin-bottom:0.5px;
height:450px;
width:800px;
border:4px solid rgb(0,0,205);
}
'''
self.sliderSheet = '''
QSlider::groove:horizontal {
height: 10px;
background: #63B8FF;
border: 1px solid #3A5FCD;
border-radius: 1px;
padding-left: -1px;
padding-right: -1px;
}
QSlider::sub-page:horizontal {
height: 10px;
background:
qlineargradient(
x1:0, y1:0,
x2:0, y2:1,
stop:0 #B1B1B1,
stop:1 #c4c4c4
);
background:
qlineargradient(
x1:0, y1:0.2,
x2:1, y2:1,
stop:0 #5DCCFF,
stop:1 #1874CD);
border: 1px solid #4A708B;
border-radius: 2px;
}
QSlider::add-page:horizontal { height: 10px;
background: #575757;
border: 0px solid #777;
border-radius: 2px;
}
QSlider::handle:horizontal{
height:14px;
width:15px;
background:
qlineargradient(
x1:0, y1:0,
x2:1, y2:1,
stop:0 #104E8B,
stop:1 #5CACEE);
border: 1px solid #777;
margin-top: -3px;
margin-bottom: -3px;
border-radius: 5px;
}
QSlider::handle:horizontal:hover{
height:14px;
width:15px;
background:
qlineargradient(
x1:1, y1:0,
x2:1, y2:1,
stop:0 #B0E2FF,
stop:1 #FFE1FF);
border: 1px solid #444;
margin-top: -3px;
margin-bottom: -3px;
border-radius: 5px;
}
QSlider::sub-page:horizontal:disabled {
height: 10px;
background: #E0EEEE;
border-color: #838B8B;
}
QSlider::add-page:horizontal:disabled {
height: 10px;
background: #C1CDCD;
border-color: #838B8B;
}
QSlider::handle:horizontal:disabled {
background: #483D8B;
border: 1px solid #696969;
margin-top: -3px;
margin-bottom: -3px;
border-radius: 4px;
}
'''
self.roundBtnSheet = '''
QPushButton{
border-top: 1px transparent;
border-bottom: 1px transparent;
border-right: 7px transparent;
border-left: 7px transparent;
}
'''
self.initUI()
def get_video_name(self):
return self.video_name
def initUI(self):
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoWidget = QVideoWidget()
self.videoWidget.setFixedSize(800, 450)
self.playerFrame = QFrame()
self.playerLayout = QHBoxLayout()
self.playerLayout.addWidget(self.videoWidget)
self.playerFrame.setLayout(self.playerLayout)
self.playerFrame.setStyleSheet(self.wholeStyleSheet)
self.playerWindow = QMainWindow()
self.playerWindow.setCentralWidget(self.playerFrame)
self.openFileBtn = QPushButton(self)
self.openFileBtn.setStyleSheet(self.roundBtnSheet)
self.openFileBtn.setIcon(QIcon('../icons/Folder-Open-icon.png'))
self.openFileBtn.setIconSize(QSize(50, 50))
self.openFileBtn.clicked.connect(self.openFile)
self.playButton = QPushButton(self)
self.playButton.setStyleSheet(self.roundBtnSheet)
self.playButton.setEnabled(False)
self.playButton.setIcon(QIcon('../icons/Play-icon.png'))
self.playButton.setIconSize(QSize(50, 50))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.setStyleSheet(self.sliderSheet)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
self.controlLayout = QHBoxLayout()
self.controlLayout.addWidget(self.openFileBtn)
self.controlLayout.addWidget(self.playButton)
self.controlLayout.addWidget(self.positionSlider)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
self.wholeLayout = QVBoxLayout()
self.wholeLayout.addWidget(self.playerWindow)
self.wholeLayout.addLayout(self.controlLayout)
#self.wholeLayout.addWidget(self.errorLabel)
self.setLayout(self.wholeLayout)
self.setStyleSheet(self.wholeStyleSheet)
def openFile(self, pressed):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
QDir.homePath())
self.video_name = fileName.split('/')[-1]
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
self.playButton.setIcon(QIcon('../icons/Play-icon.png'))
else:
self.mediaPlayer.play()
self.playButton.setIcon(QIcon('../icons/Pause-icon.png'))
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
class VideoPlayer(QWidget):
def __init__(self, aPath, parent=None):
super(VideoPlayer, self).__init__(parent)
self.setAttribute( Qt.WA_NoSystemBackground, True )
self.colorDialog = None
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer.setVolume(80)
self.videoWidget = QVideoWidget(self)
self.lbl = QLineEdit('00:00:00')
self.lbl.setReadOnly(True)
self.lbl.setEnabled(False)
self.lbl.setFixedWidth(60)
self.lbl.setUpdatesEnabled(True)
self.lbl.setStyleSheet(stylesheet(self))
self.elbl = QLineEdit('00:00:00')
self.elbl.setReadOnly(True)
self.elbl.setEnabled(False)
self.elbl.setFixedWidth(60)
self.elbl.setUpdatesEnabled(True)
self.elbl.setStyleSheet(stylesheet(self))
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setFixedWidth(32)
self.playButton.setStyleSheet("background-color: black")
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal, self)
self.positionSlider.setStyleSheet (stylesheet(self))
self.positionSlider.setRange(0, 100)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.positionSlider.sliderMoved.connect(self.handleLabel)
self.positionSlider.setSingleStep(2)
self.positionSlider.setPageStep(20)
self.positionSlider.setAttribute(Qt.WA_TranslucentBackground, True)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(5, 0, 5, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.lbl)
controlLayout.addWidget(self.positionSlider)
controlLayout.addWidget(self.elbl)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.videoWidget)
layout.addLayout(controlLayout)
self.setLayout(layout)
self.myinfo = "©2016\nAxel Schneider\n\nMouse Wheel = Zoom\nUP = Volume Up\nDOWN = Volume Down\n" + \
"LEFT = < 1 Minute\nRIGHT = > 1 Minute\n" + \
"SHIFT+LEFT = < 10 Minutes\nSHIFT+RIGHT = > 10 Minutes\nf = Fullscreen On/Off"
self.widescreen = True
self.setAcceptDrops(True)
self.setWindowTitle("QT5 Player")
self.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.FramelessWindowHint)
self.setGeometry(700, 400, 400, 290)
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu);
self.customContextMenuRequested[QtCore.QPoint].connect(self.contextMenuRequested)
self.hideSlider()
self.show()
self.playFromURL()
#### shortcuts ####
self.shortcut = QShortcut(QKeySequence("q"), self)
self.shortcut.activated.connect(self.handleQuit)
self.shortcut = QShortcut(QKeySequence("u"), self)
self.shortcut.activated.connect(self.playFromURL)
self.shortcut = QShortcut(QKeySequence("o"), self)
self.shortcut.activated.connect(self.openFile)
self.shortcut = QShortcut(QKeySequence(" "), self)
self.shortcut.activated.connect(self.play)
self.shortcut = QShortcut(QKeySequence("f"), self)
self.shortcut.activated.connect(self.handleFullscreen)
self.shortcut = QShortcut(QKeySequence("i"), self)
self.shortcut.activated.connect(self.handleInfo)
self.shortcut = QShortcut(QKeySequence("s"), self)
self.shortcut.activated.connect(self.toggleSlider)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Right), self)
self.shortcut.activated.connect(self.forwardSlider)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Left), self)
self.shortcut.activated.connect(self.backSlider)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Up), self)
self.shortcut.activated.connect(self.volumeUp)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Down), self)
self.shortcut.activated.connect(self.volumeDown)
self.shortcut = QShortcut(QKeySequence(Qt.ShiftModifier + Qt.Key_Right) , self)
self.shortcut.activated.connect(self.forwardSlider10)
self.shortcut = QShortcut(QKeySequence(Qt.ShiftModifier + Qt.Key_Left) , self)
self.shortcut.activated.connect(self.backSlider10)
self.shortcut = QShortcut(QKeySequence("c") , self)
self.shortcut.activated.connect(self.showColorDialog)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.positionChanged.connect(self.handleLabel)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
QDir.homePath(), "Videos (*.mp4 *.ts *.avi *.mpeg *.mpg *.mkv *.VOB *.m4v)")
if fileName != '':
self.loadFilm(fileName)
print("File loaded")
def playFromURL(self):
self.mediaPlayer.pause()
clip = QApplication.clipboard()
myurl = clip.text()
if myurl.startswith("http"):
self.mediaPlayer.setMedia(QMediaContent(QUrl(myurl)))
elif myurl.startswith("/"):
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(myurl)))
else:
return
self.playButton.setEnabled(True)
self.mediaPlayer.play()
self.hideSlider()
print(myurl)
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
mtime = QTime(0,0,0,0)
mtime = mtime.addMSecs(self.mediaPlayer.duration())
self.elbl.setText(mtime.toString())
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
print("Error: " + self.mediaPlayer.errorString())
def handleQuit(self):
self.mediaPlayer.stop()
print("Goodbye ...")
app.quit()
def contextMenuRequested(self,point):
menu = QtWidgets.QMenu()
actionFile = menu.addAction("open File (o)")
actionclipboard = menu.addSeparator()
actionURL = menu.addAction("URL / File from Clipboard (u)")
actionclipboard = menu.addSeparator()
actionToggle = menu.addAction("show / hide Slider (s)")
actionFull = menu.addAction("Fullscreen (f)")
action169 = menu.addAction("16 : 9")
action43 = menu.addAction("4 : 3")
actionColors = menu.addAction("Color Options (c)")
actionSep = menu.addSeparator()
actionInfo = menu.addAction("Info (i)")
actionsep2 = menu.addSeparator()
actionQuit = menu.addAction("Exit (q)")
actionFile.triggered.connect(self.openFile)
actionQuit.triggered.connect(self.handleQuit)
actionFull.triggered.connect(self.handleFullscreen)
actionInfo.triggered.connect(self.handleInfo)
actionToggle.triggered.connect(self.toggleSlider)
actionURL.triggered.connect(self.playFromURL)
action169.triggered.connect(self.screen169)
action43.triggered.connect(self.screen43)
actionColors.triggered.connect(self.showColorDialog)
menu.exec_(self.mapToGlobal(point))
def wheelEvent(self,event):
mwidth = self.frameGeometry().width()
mheight = self.frameGeometry().height()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
mscale = event.angleDelta().y() / 5
if self.widescreen == True:
self.setGeometry(mleft, mtop, mwidth + mscale, (mwidth + mscale) / 1.778)
else:
self.setGeometry(mleft, mtop, mwidth + mscale, (mwidth + mscale) / 1.33)
def screen169(self):
self.widescreen = True
mwidth = self.frameGeometry().width()
mheight = self.frameGeometry().height()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
mratio = 1.778
self.setGeometry(mleft, mtop, mwidth, mwidth / mratio)
def screen43(self):
self.widescreen = False
mwidth = self.frameGeometry().width()
mheight = self.frameGeometry().height()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
mratio = 1.33
self.setGeometry(mleft, mtop, mwidth, mwidth / mratio)
def handleFullscreen(self):
if self.windowState() & QtCore.Qt.WindowFullScreen:
self.showNormal()
print("no Fullscreen")
else:
self.showFullScreen()
print("Fullscreen entered")
def handleInfo(self):
msg = QMessageBox()
msg.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.SplashScreen)
msg.setGeometry(self.frameGeometry().left() + 30, self.frameGeometry().top() + 30, 300, 400)
msg.setIcon(QMessageBox.Information)
msg.setText("QT5 Player")
msg.setInformativeText(self.myinfo)
msg.setStandardButtons(QMessageBox.Close)
msg.exec()
def toggleSlider(self):
if self.positionSlider.isVisible():
self.hideSlider()
else:
self.showSlider()
def hideSlider(self):
self.playButton.hide()
self.lbl.hide()
self.positionSlider.hide()
self.elbl.hide()
mwidth = self.frameGeometry().width()
mheight = self.frameGeometry().height()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
if self.widescreen == True:
self.setGeometry(mleft, mtop, mwidth, mwidth / 1.778)
else:
self.setGeometry(mleft, mtop, mwidth, mwidth / 1.33)
def showSlider(self):
self.playButton.show()
self.lbl.show()
self.positionSlider.show()
self.elbl.show()
mwidth = self.frameGeometry().width()
mheight = self.frameGeometry().height()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
self.positionSlider.setFocus()
if self.widescreen == True:
self.setGeometry(mleft, mtop, mwidth, mwidth / 1.55)
else:
self.setGeometry(mleft, mtop, mwidth, mwidth / 1.33)
def forwardSlider(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() + 1000*60)
def forwardSlider10(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() + 10000*60)
def backSlider(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() - 1000*60)
def backSlider10(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() - 10000*60)
def volumeUp(self):
self.mediaPlayer.setVolume(self.mediaPlayer.volume() + 10)
print("Volume: " + str(self.mediaPlayer.volume()))
def volumeDown(self):
self.mediaPlayer.setVolume(self.mediaPlayer.volume() - 10)
print("Volume: " + str(self.mediaPlayer.volume()))
def mouseMoveEvent(self, event):
if event.buttons() == Qt.LeftButton:
self.move(event.globalPos() \
- QPoint(self.frameGeometry().width() / 2, \
self.frameGeometry().height() / 2))
event.accept()
def dragEnterEvent(self, event):
if event.mimeData().hasUrls():
event.accept()
elif event.mimeData().hasFormat('text/plain'):
event.accept()
else:
event.ignore()
########### drag files #############
def dropEvent(self, event):
if event.mimeData().hasUrls():
f = str(event.mimeData().urls()[0].toLocalFile())
self.loadFilm(f)
elif event.mimeData().hasText():
f = str(event.mimeData().text())
self.mediaPlayer.setMedia(QMediaContent(QUrl(f)))
self.mediaPlayer.play()
def loadFilm(self, f):
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(f)))
self.playButton.setEnabled(True)
self.mediaPlayer.play()
print(str(self.mediaPlayer.media().canonicalResource().resolution()))
def openFileAtStart(self, filelist):
matching = [s for s in filelist if ".myformat" in s]
if len(matching) > 0:
self.loadFilm(matching)
##################### update Label ##################################
def handleLabel(self):
self.lbl.clear()
mtime = QTime(0,0,0,0)
self.time = mtime.addMSecs(self.mediaPlayer.position())
self.lbl.setText(self.time.toString())
###################################################################
def showColorDialog(self):
if self.colorDialog is None:
brightnessSlider = QSlider(Qt.Horizontal)
brightnessSlider.setRange(-100, 100)
brightnessSlider.setValue(self.videoWidget.brightness())
brightnessSlider.sliderMoved.connect(
self.videoWidget.setBrightness)
self.videoWidget.brightnessChanged.connect(
brightnessSlider.setValue)
contrastSlider = QSlider(Qt.Horizontal)
contrastSlider.setRange(-100, 100)
contrastSlider.setValue(self.videoWidget.contrast())
contrastSlider.sliderMoved.connect(self.videoWidget.setContrast)
self.videoWidget.contrastChanged.connect(contrastSlider.setValue)
hueSlider = QSlider(Qt.Horizontal)
hueSlider.setRange(-100, 100)
hueSlider.setValue(self.videoWidget.hue())
hueSlider.sliderMoved.connect(self.videoWidget.setHue)
self.videoWidget.hueChanged.connect(hueSlider.setValue)
saturationSlider = QSlider(Qt.Horizontal)
saturationSlider.setRange(-100, 100)
saturationSlider.setValue(self.videoWidget.saturation())
saturationSlider.sliderMoved.connect(
self.videoWidget.setSaturation)
self.videoWidget.saturationChanged.connect(
saturationSlider.setValue)
layout = QFormLayout()
layout.addRow("Brightness", brightnessSlider)
layout.addRow("Contrast", contrastSlider)
layout.addRow("Hue", hueSlider)
layout.addRow("Saturation", saturationSlider)
button = QPushButton("Close Window")
button.setFixedWidth(120)
layout.addRow(button)
self.colorDialog = QDialog(self)
self.colorDialog.setWindowTitle("Color Options")
self.colorDialog.setLayout(layout)
button.clicked.connect(self.colorDialog.close)
self.colorDialog.setGeometry(300, 250, 300, 100)
self.colorDialog.show()
class VideoPlayer(QWidget):
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
#self.mediaPlayer.setMinmumSize(QtCore.QSize(445, 225))
btnSize = QSize(16, 16)
videoWidget = QVideoWidget()
videoWidget.setMinimumSize(QtCore.QSize(445, 225))
openButton = QPushButton("Open Video")
openButton.setToolTip("Open Video File")
openButton.setStatusTip("Open Video File")
openButton.setFixedHeight(24)
openButton.setIconSize(btnSize)
openButton.setFont(QFont("Noto Sans", 8))
openButton.setIcon(
QIcon.fromTheme("document-open", QIcon("D:/_Qt/img/open.png")))
openButton.clicked.connect(self.abrir)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setFixedHeight(24)
self.playButton.setIconSize(btnSize)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.statusBar = QStatusBar()
self.statusBar.setFont(QFont("Noto Sans", 7))
self.statusBar.setFixedHeight(14)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
#controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
#layout.setMinmumSize(QtCore.QSize(445, 225))
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.statusBar)
self.setLayout(layout)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
self.statusBar.showMessage("Ready")
def abrir(self):
fileName, _ = QFileDialog.getOpenFileName(
self, "Selecciona los mediose", ".",
"Video Files (*.mp4 *.flv *.ts *.mts *.avi)")
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
self.statusBar.showMessage(fileName)
self.play()
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
self.statusBar.showMessage("Error: " + self.mediaPlayer.errorString())
class MainWindow(QMainWindow):
directory_path = ""
video_paths = []
video_infos = []
main_width = 1500
main_height = 800
key_frame_dir = ""
def __init__(self):
super().__init__()
self.tabs = []
self.tab_names = []
self.__initUI()
def __initUI(self):
# Create a widget for window contents
self.central_widget = QWidget(self)
self.setCentralWidget(self.central_widget)
# Create new action
open_action = QAction(QIcon('open.png'), '&Open', self)
open_action.setShortcut('Ctrl+O')
open_action.setStatusTip('Open movie')
open_action.triggered.connect(self.__openDownloadDirectory)
# Create exit action
exit_action = QAction(QIcon('exit.png'), '&Exit', self)
exit_action.setShortcut('Ctrl+Q')
exit_action.setStatusTip('Exit application')
exit_action.triggered.connect(self.close)
# Create menu bar and add action
menu_bar = self.menuBar()
menu = menu_bar.addMenu('&메뉴')
menu.addAction(open_action)
menu.addAction(exit_action)
self.statusBar()
self.setFrameViewWidget()
self.setVideoWidget()
self.setVideoControlWidget()
self.setTabWidget()
self.setMainLayout()
# Set widget to contain window contents
self.central_widget.setLayout(self.main_layout)
self.setGeometry(300, 300, self.main_width, self.main_height)
self.setWindowTitle('Video Previewer')
self.show()
def setFrameViewWidget(self):
self.frame = QLabel(self)
self.frame.setFrameShape(QFrame.Panel)
self.frame.setFixedHeight(self.main_height / 2)
self.frame.setFixedWidth(self.main_width / 3)
self.frame.setStyleSheet("background: white; border:1px solid gray;")
self.frame.setAlignment(Qt.AlignCenter)
def setVideoWidget(self):
self.videoWidget = QVideoWidget()
self.videoWidget.setStyleSheet("background: white; border:1px solid rgb(0, 0, 0);")
self.videoWidget.setFixedWidth(self.main_width / 3)
self.videoWidget.setFixedHeight(self.main_height / 2)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
def setVideoControlWidget(self):
self.play_button = QPushButton()
self.play_button.setEnabled(False)
self.play_button.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.play_button.clicked.connect(self.play)
self.play_button.setFixedWidth(50)
self.position_slider = QSlider(Qt.Horizontal)
self.position_slider.setRange(0, 0)
self.position_slider.sliderMoved.connect(self.setPosition)
self.position_slider.setFixedWidth(self.main_width / 3 - 55)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
self.controlLayout = QGridLayout()
self.controlLayout.setAlignment(Qt.AlignLeft)
self.controlLayout.setAlignment(Qt.AlignTop)
self.controlLayout.addWidget(self.videoWidget, 0, 0, 1, 2)
self.controlLayout.addWidget(self.play_button, 1, 0)
self.controlLayout.addWidget(self.position_slider, 1, 1)
def setMainLayout(self):
self.main_layout = QGridLayout()
self.main_layout.setAlignment(Qt.AlignTop)
self.main_layout.addLayout(self.controlLayout, 1, 0)
self.main_layout.addWidget(self.frame, 2, 0)
self.main_layout.addWidget(self.tabWidget, 0, 1, 3, 3)
# self.main_layout.addWidget(self.errorLabel)
def setVideoTab(self, row_count):
column_headers = ['Thumbnail', 'Name', 'Size', 'Created Date', 'Modified Date']
self.tab_videos = QTableWidget()
self.tab_videos.resize(290, 290)
self.tab_videos.setRowCount(row_count)
self.tab_videos.setColumnCount(5)
self.tab_videos.setHorizontalHeaderLabels(column_headers)
self.tabWidget.addTab(self.tab_videos, "Videos")
def setVideoTabItems(self, videos):
for video in videos:
video_info = os.path.join(self.directory_path, video)
self.video_paths.append(video_info)
self.video_infos.append([
"",
video,
"%.2f MB" % (os.path.getsize(video_info) / (1024.0 * 1024.0)),
time.ctime(os.path.getctime(video_info)),
time.ctime(os.path.getmtime(video_info))
])
for row, video_infos in enumerate(self.video_infos):
for col, video_info in enumerate(video_infos):
self.tab_videos.setItem(row, col, QTableWidgetItem(str(video_infos[col])))
self.tab_videos.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.tab_videos.cellClicked.connect(self.videoCellClicked)
self.tab_videos.cellDoubleClicked.connect(self.videoCellDoubleClicked)
header = self.tab_videos.horizontalHeader()
for idx in range(len(videos)):
header.setSectionResizeMode(idx, QtWidgets.QHeaderView.ResizeToContents)
@pyqtSlot(int, int)
def videoCellClicked(self, row, col):
self.tab_videos.selectRow(row)
cell = self.tab_videos.item(row, 1)
@pyqtSlot(int, int)
def videoCellDoubleClicked(self, row, col):
self.openFile(self.video_paths[row])
self.tab_videos.selectRow(row)
def setFrameTab(self):
self.tab_keyframes = QListWidget()
self.tab_keyframes.setViewMode(QListWidget.IconMode)
self.tab_keyframes.setIconSize(QSize(225, 225))
self.tab_keyframes.itemDoubleClicked.connect(self.frameCellDoubleClicked)
self.tabWidget.addTab(self.tab_keyframes, "Key frames")
def frameCellDoubleClicked(self, item=None):
self.frame.setStyleSheet("background: black")
pixmap = QPixmap(os.path.join(self.key_frame_dir, item.text()))
self.frame.setPixmap(pixmap)
def setTabWidget(self):
self.tabWidget = QTabWidget()
def __openDownloadDirectory(self):
directory_path = str(QFileDialog.getExistingDirectory(self, "Select Directory"))
if directory_path:
self.directory_path = directory_path
videos = os.listdir(self.directory_path)
self.setVideoTab(len(videos))
self.setFrameTab()
self.setVideoTabItems(videos)
else :
print("Info: You didn't select directory. current directory path is \"{}\"".format(self.directory_path))
def openFile(self, fileName):
if fileName != '':
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(fileName)))
self.play_button.setEnabled(True)
ffmpeg = FFmpegWrapper()
ffmpeg.setOptions(video_path=fileName)
if not os.path.isdir(ffmpeg.getOutputDir()):
ffmpeg.runFFmpeg()
keyframelist_file = ffmpeg.getKeyframesPathFile()
detector = darknetDetectorWrapper()
detector.setInputPath(input_paths=keyframelist_file)
detector.setOutputPath(ffmpeg.getOutputDir())
detector.runDarknetDetector()
frame_names = self.readFrames(keyframelist_file)
self.tab_keyframes.clear()
self.key_frame_dir = frame_names[0].replace(frame_names[0].split("\\")[-1],"")
for frame_name in frame_names:
item = QListWidgetItem(QIcon(frame_name), frame_name.split("\\")[-1])
self.tab_keyframes.addItem(item)
def readFrames(self, keyframelist_file):
frame_names = []
with open(keyframelist_file, 'r') as file:
for frame in file:
frame_names.append(frame.split("\n")[0])
return frame_names
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.play_button.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.play_button.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.position_slider.setValue(position)
def durationChanged(self, duration):
self.position_slider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.play_button.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
class VideoPlayer(QWidget):
def __init__(self, aPath, parent=None):
super(VideoPlayer, self).__init__(parent)
#self.setAttribute(Qt.WA_NoSystemBackground, True)
self.colorDialog = None
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer.setVolume(80)
self.videoWidget = QVideoWidget(self)
self.lbl = QLineEdit('00:00:00')
self.lbl.setReadOnly(True)
self.lbl.setEnabled(False)
self.lbl.setFixedWidth(60)
self.lbl.setUpdatesEnabled(True)
#self.lbl.setStyleSheet(stylesheet(self))
self.elbl = QLineEdit('00:00:00')
self.elbl.setReadOnly(True)
self.elbl.setEnabled(False)
self.elbl.setFixedWidth(60)
self.elbl.setUpdatesEnabled(True)
#self.elbl.setStyleSheet(stylesheet(self))
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setFixedWidth(32)
#self.playButton.setStyleSheet("background-color: black")
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
### pointA button
self.apointButton = QPushButton()
self.apointButton.setEnabled(False)
self.apointButton.setFixedWidth(32)
#self.apointButton.setStyleSheet("background-color: black")
self.apointButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaSeekForward))
self.apointButton.clicked.connect(self.setPointA)
### pointB button
self.bpointButton = QPushButton()
self.bpointButton.setEnabled(False)
self.bpointButton.setFixedWidth(32)
#self.bpointButton.setStyleSheet("background-color: black")
self.bpointButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaSeekBackward))
self.bpointButton.clicked.connect(self.setPointB)
### cut button
self.cutButton = QPushButton()
self.cutButton.setEnabled(False)
self.cutButton.setFixedWidth(32)
self.cutButton.setIcon(self.style().standardIcon(
QStyle.SP_DriveFDIcon))
self.cutButton.clicked.connect(self.cut)
self.positionSlider = QSlider(Qt.Horizontal, self)
self.positionSlider.setStyleSheet(stylesheet(self))
self.positionSlider.setRange(0, 100)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.positionSlider.sliderMoved.connect(self.handle_label)
self.positionSlider.setSingleStep(2)
self.positionSlider.setPageStep(20)
#self.positionSlider.setAttribute(Qt.WA_NoSystemBackground, True)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(5, 0, 5, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.apointButton)
controlLayout.addWidget(self.bpointButton)
controlLayout.addWidget(self.cutButton)
controlLayout.addWidget(self.lbl)
controlLayout.addWidget(self.positionSlider)
controlLayout.addWidget(self.elbl)
layout0 = QVBoxLayout()
layout0.setContentsMargins(0, 0, 0, 0)
layout0.addWidget(self.videoWidget)
layout0.addLayout(controlLayout)
self.setLayout(layout0)
self.widescreen = True
self.setAcceptDrops(True)
self.setWindowTitle("QT5 Player")
#self.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.FramelessWindowHint)
self.setGeometry(300, 200, 400, 290)
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.customContextMenuRequested[QtCore.QPoint].connect(
self.contextMenuRequested)
#self.hideSlider()
self.show()
#self.playFromURL()
### shortcuts ###
self.shortcut = QShortcut(QKeySequence('q'), self)
self.shortcut.activated.connect(self.handleQuit)
self.shortcut = QShortcut(QKeySequence('o'), self)
self.shortcut.activated.connect(self.openFile)
self.shortcut = QShortcut(QKeySequence(' '), self)
self.shortcut.activated.connect(self.play)
self.shortcut = QShortcut(QKeySequence('s'), self)
self.shortcut.activated.connect(self.toggleSlider)
self.shortcut = QShortcut(QKeySequence('v'), self)
self.shortcut.activated.connect(self.setPointA)
self.shortcut = QShortcut(QKeySequence('b'), self)
self.shortcut.activated.connect(self.setPointB)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Right), self)
self.shortcut.activated.connect(self.forwardSlider)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Left), self)
self.shortcut.activated.connect(self.backSlider)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Up), self)
self.shortcut.activated.connect(self.volumeUp)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Down), self)
self.shortcut.activated.connect(self.volumeDown)
self.shortcut = QShortcut(
QKeySequence(Qt.ShiftModifier + Qt.Key_Right), self)
self.shortcut.activated.connect(self.forwardSlider10)
self.shortcut = QShortcut(QKeySequence(Qt.ShiftModifier + Qt.Key_Left),
self)
self.shortcut.activated.connect(self.backSlider10)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.positionChanged.connect(self.handle_label)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
self.apoint = 0
self.bpoint = 0
self.inputfile = pathlib.Path()
# self.outputfile = pathlib.Path()
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(
self, 'Open Movie',
QDir.homePath() + '/Desktop',
'Videos (*.mp4 *.ts *.avi *.mpeg *.mpg *.mkv *.VOB *.m4v)')
if fileName != '':
self.load_film(fileName)
print("File loaded")
print(fileName)
self.inputfile = pathlib.Path(fileName)
def getclipFileName(self):
clipFileName = QFileDialog.getSaveFileName(
self, 'Save Clip',
QDir.homePath() + '/Desktop', 'all files(*.*)')
return clipFileName
#def playFromURL(self):
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
mtime = QTime(0, 0, 0, 0)
mtime = mtime.addMSecs(self.mediaPlayer.duration())
self.elbl.setText(mtime.toString())
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
# cut point A function
def setPointA(self):
self.apoint = self.time.toString()
print('A Point ' + self.apoint)
# cut point B function
def setPointB(self):
self.play()
self.bpoint = self.time.toString()
print('B Point ' + self.bpoint)
# cut
def cut(self):
print("Input: ", self.inputfile.resolve())
length = self.lengthCalculation(self.apoint, self.bpoint)
output_file = os.path.splitext(str(
self.inputfile.resolve()))[0] + '__' + re.sub(
':', '_', self.apoint) + '__' + re.sub(
':', '_', self.bpoint
) + self.inputfile.suffix # no ':' allowed in a windows path.
print("Output:", output_file)
command = "ffmpeg -i " + "\"" + str(
self.inputfile.resolve()
) + "\"" + " -ss " + self.apoint + " -t " + length + " -c:v copy -c:a copy " + "\"" + output_file + "\""
print("Executing:\n", command, "\n")
run(command, shell=True)
# cut length calculation
def twodigi(self, str0):
if len(str0) == 1:
str0 = '0' + str0
return str0
def lengthCalculation(self, start, end):
start_s = int(start[:2]) * 3600 + int(start[3:5]) * 60 + int(start[6:])
# print(start_s)
end_s = int(end[:2]) * 3600 + int(end[3:5]) * 60 + int(end[6:])
# print(end_s)
length_s = end_s - start_s
# print(length_s)
hr = self.twodigi(str(length_s // 3600))
mn = self.twodigi(str((length_s % 3600) // 60))
sc = self.twodigi(str(length_s % 60))
length = hr + ':' + mn + ':' + sc
print(length)
return length
def handleError(self):
self.playButton.setEnabled(False)
self.apointButton.setEnabled(False)
self.bpointButton.setEnabled(False)
self.cutButton.setEnabled(False)
print("Error: " + self.mediaPlayer.errorString())
def handleQuit(self):
self.mediaPlayer.stop()
print('Quit.')
app.quit()
def contextMenuRequested(self, point):
menu = QtWidgets.QMenu()
actionFile = menu.addAction('Open File (o)')
actionFile.triggered.connect(self.openFile)
actionToggle = menu.addAction('show / hide Slider (s)')
actionToggle.triggered.connect(self.toggleSlider)
action169 = menu.addAction('16 : 9')
action169.triggered.connect(self.screen169)
action43 = menu.addAction('4 : 3')
action43.triggered.connect(self.screen43)
actionQuit = menu.addAction('Exit (q)')
actionQuit.triggered.connect(self.handleQuit)
menu.exec_(self.mapToGlobal(point))
def wheelEvent(self, event):
mwidth = self.frameGeometry().width()
#mheight = self.frameGeometry().height()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
mscale = event.angleDelta().y() / 5
if self.widescreen == True:
self.setGeometry(mleft, mtop, mwidth + mscale,
(mwidth + mscale) / 1.778)
else:
self.setGeometry(mleft, mtop, mwidth + mscale,
(mwidth + mscale) / 1.33)
def screen169(self):
self.widescreen = True
mwidth = self.frameGeometry().width()
#mheight = self.frameGeometry().height()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
mratio = 1.778
self.setGeometry(mleft, mtop, mwidth, mwidth / mratio)
def screen43(self):
self.widescreen = False
mwidth = self.frameGeometry().width()
#mheight = self.frameGeometry().height()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
mratio = 1.33
self.setGeometry(mleft, mtop, mwidth, mwidth / mratio)
def handleFullscreen(self):
pass
def handleInfo(self):
pass
def toggleSlider(self):
if self.positionSlider.isVisible():
self.hideSlider()
else:
self.showSlider()
def hideSlider(self):
self.playButton.hide()
self.lbl.hide()
self.positionSlider.hide()
self.elbl.hide()
mwidth = self.frameGeometry().width()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
if self.widescreen == True:
self.setGeometry(mleft, mtop, mwidth, mwidth / 1.778)
else:
self.setGeometry(mleft, mtop, mwidth, mwidth / 1.33)
def showSlider(self):
self.playButton.show()
self.lbl.show()
self.positionSlider.show()
self.elbl.show()
mwidth = self.frameGeometry().width()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
self.positionSlider.setFocus()
if self.widescreen == True:
self.setGeometry(mleft, mtop, mwidth, mwidth / 1.55)
else:
self.setGeometry(mleft, mtop, mwidth, mwidth / 1.33)
def forwardSlider(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() + 100 * 60)
def forwardSlider10(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() + 250 * 60)
def backSlider(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() - 100 * 60)
def backSlider10(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() - 250 * 60)
def volumeUp(self):
self.mediaPlayer.setVolume(self.mediaPlayer.volume() + 10)
def volumeDown(self):
self.mediaPlayer.setVolume(self.mediaPlayer.volume() - 10)
'''
def mouseMoveEvent(self, event):
if event.buttons() == Qt.LeftButton:
#self.move(event.globalPos() - QPoint(self.frameGeometry().width() / 2, self.frameGeometry().height() / 2))
self.move(event.globalPos() - QPoint(self.geometry().left(),self.geometry().top()))
event.accept()
'''
def dragEnterEvent(self, event):
if event.mimeData().hasUrls():
event.accept()
elif event.mimeData().hasFormat('text/plain'):
event.accept()
else:
event.ignore()
def dropEvent(self, event):
if event.mimeData().hasUrls():
f = str(event.mimeData().urls()[0].toLocalFile())
self.load_film(f)
self.inputfile = pathlib.Path(f)
elif event.mimeData().hasText():
f = str(event.mimeData().text())
self.mediaPlayer.setMedia(QMediaContent(QUrl(f)))
self.inputfile = pathlib.Path(f)
self.mediaPlayer.play()
def load_film(self, f):
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(f)))
self.playButton.setEnabled(True)
self.apointButton.setEnabled(True)
self.bpointButton.setEnabled(True)
self.cutButton.setEnabled(True)
self.mediaPlayer.play()
def open_file_at_start(self, filelist):
matching = [s for s in filelist if '.myformat' in s]
if len(matching) > 0:
self.load_film(matching)
def handle_label(self):
self.lbl.clear()
mtime = QTime(0, 0, 0, 0)
self.time = mtime.addMSecs(self.mediaPlayer.position())
self.lbl.setText(self.time.toString())
class Window(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("Kanishka Jain")
self.setGeometry(350, 100, 700, 500)
p = self.palette()
p.setColor(QPalette.Window, Qt.black)
self.setPalette(p)
self.init_ui()
self.show()
def init_ui(self):
#create media player object
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
#create videowidget object
videowidget = QVideoWidget()
#create open button
openBtn = QPushButton('Open Video')
openBtn.clicked.connect(self.open_file)
#create button for playing
self.playBtn = QPushButton()
self.playBtn.setEnabled(False)
self.playBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playBtn.clicked.connect(self.play_video)
#create slider
self.slider = QSlider(Qt.Horizontal)
self.slider.setRange(0, 0)
self.slider.sliderMoved.connect(self.set_position)
#create label
self.label = QLabel()
self.label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
#create hbox layout
hboxLayout = QHBoxLayout()
hboxLayout.setContentsMargins(0, 0, 0, 0)
#set widgets to the hbox layout
hboxLayout.addWidget(openBtn)
hboxLayout.addWidget(self.playBtn)
hboxLayout.addWidget(self.slider)
#create vbox layout
vboxLayout = QVBoxLayout()
vboxLayout.addWidget(videowidget)
vboxLayout.addLayout(hboxLayout)
vboxLayout.addWidget(self.label)
self.setLayout(vboxLayout)
self.mediaPlayer.setVideoOutput(videowidget)
#media player signals
self.mediaPlayer.stateChanged.connect(self.mediastate_changed)
self.mediaPlayer.positionChanged.connect(self.position_changed)
self.mediaPlayer.durationChanged.connect(self.duration_changed)
def open_file(self):
filename, _ = QFileDialog.getOpenFileName(self, "Open Video")
if filename != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(filename)))
self.playBtn.setEnabled(True)
def play_video(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediastate_changed(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def position_changed(self, position):
self.slider.setValue(position)
def duration_changed(self, duration):
self.slider.setRange(0, duration)
def set_position(self, position):
self.mediaPlayer.setPosition(position)
def handle_errors(self):
self.playBtn.setEnabled(False)
self.label.setText("Error: " + self.mediaPlayer.errorString())
class VideoPlayer(QWidget):
def __init__(self, aPath, parent=None):
super(VideoPlayer, self).__init__(parent)
self.setAttribute(Qt.WA_NoSystemBackground, True)
self.setAcceptDrops(True)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.StreamPlayback)
self.mediaPlayer.setVolume(80)
self.videoWidget = QVideoWidget(self)
self.videoWidget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.videoWidget.setMinimumSize(QSize(640, 360))
self.lbl = QLineEdit('00:00:00')
self.lbl.setReadOnly(True)
self.lbl.setFixedWidth(70)
self.lbl.setUpdatesEnabled(True)
self.lbl.setStyleSheet(stylesheet(self))
self.elbl = QLineEdit('00:00:00')
self.elbl.setReadOnly(True)
self.elbl.setFixedWidth(70)
self.elbl.setUpdatesEnabled(True)
self.elbl.setStyleSheet(stylesheet(self))
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setFixedWidth(32)
self.playButton.setStyleSheet("background-color: black")
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal, self)
self.positionSlider.setStyleSheet(stylesheet(self))
self.positionSlider.setRange(0, 100)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.positionSlider.sliderMoved.connect(self.handleLabel)
self.positionSlider.setSingleStep(2)
self.positionSlider.setPageStep(20)
self.positionSlider.setAttribute(Qt.WA_TranslucentBackground, True)
self.clip = QApplication.clipboard()
self.process = QProcess(self)
self.process.readyRead.connect(self.dataReady)
self.process.finished.connect(self.playFromURL)
self.myurl = ""
# channel list
self.channelList = QListView(self)
self.channelList.setMinimumSize(QSize(150, 0))
self.channelList.setMaximumSize(QSize(150, 4000))
self.channelList.setFrameShape(QFrame.Box)
self.channelList.setObjectName("channelList")
self.channelList.setStyleSheet("background-color: black; color: #585858;")
self.channelList.setFocus()
# for adding items to list must create a model
self.model = QStandardItemModel()
self.channelList.setModel(self.model)
self.controlLayout = QHBoxLayout()
self.controlLayout.setContentsMargins(5, 0, 5, 0)
self.controlLayout.addWidget(self.playButton)
self.controlLayout.addWidget(self.lbl)
self.controlLayout.addWidget(self.positionSlider)
self.controlLayout.addWidget(self.elbl)
self.mainLayout = QHBoxLayout()
# contains video and cotrol widgets to the left side
self.layout = QVBoxLayout()
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.videoWidget)
self.layout.addLayout(self.controlLayout)
# adds channels list to the right
self.mainLayout.addLayout(self.layout)
self.mainLayout.addWidget(self.channelList)
self.setLayout(self.mainLayout)
self.myinfo = "©2020\nTIVOpy v1.0"
self.widescreen = True
#### shortcuts ####
self.shortcut = QShortcut(QKeySequence("q"), self)
self.shortcut.activated.connect(self.handleQuit)
self.shortcut = QShortcut(QKeySequence("u"), self)
self.shortcut.activated.connect(self.playFromURL)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Space), self)
self.shortcut.activated.connect(self.play)
self.shortcut = QShortcut(QKeySequence(Qt.Key_F), self)
self.shortcut.activated.connect(self.handleFullscreen)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Escape), self)
self.shortcut.activated.connect(self.exitFullscreen)
self.shortcut.activated.connect(self.handleFullscreen)
self.shortcut = QShortcut(QKeySequence("i"), self)
self.shortcut.activated.connect(self.handleInfo)
self.shortcut = QShortcut(QKeySequence("s"), self)
self.shortcut.activated.connect(self.toggleSlider)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Right), self)
self.shortcut.activated.connect(self.forwardSlider)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Left), self)
self.shortcut.activated.connect(self.backSlider)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.positionChanged.connect(self.handleLabel)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
self.populateChannelList()
self.selectChannel()
self.initialPlay()
def playFromURL(self):
self.mediaPlayer.pause()
self.myurl = self.clip.text()
self.mediaPlayer.setMedia(QMediaContent(QUrl(self.myurl)))
self.playButton.setEnabled(True)
self.mediaPlayer.play()
self.hideSlider()
print(self.myurl)
def dataReady(self):
self.myurl = str(self.process.readAll(), encoding='utf8').rstrip() ###
self.myurl = self.myurl.partition("\n")[0]
print(self.myurl)
self.clip.setText(self.myurl)
self.playFromURL()
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
mtime = QTime(0, 0, 0, 0)
mtime = mtime.addMSecs(self.mediaPlayer.duration())
self.elbl.setText(mtime.toString())
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
print("Error: ", self.mediaPlayer.errorString())
def handleQuit(self):
self.mediaPlayer.stop()
print("Goodbye ...")
app.quit()
def contextMenuRequested(self, point):
menu = QMenu()
actionURL = menu.addAction(QIcon.fromTheme("browser"), "URL from Clipboard (u)")
menu.addSeparator()
actionToggle = menu.addAction(QIcon.fromTheme("next"), "Show / Hide Channels (s)")
actionFull = menu.addAction(QIcon.fromTheme("view-fullscreen"), "Fullscreen (f)")
menu.addSeparator()
actionInfo = menu.addAction(QIcon.fromTheme("help-about"), "About (i)")
menu.addSeparator()
actionQuit = menu.addAction(QIcon.fromTheme("application-exit"), "Exit (q)")
actionQuit.triggered.connect(self.handleQuit)
actionFull.triggered.connect(self.handleFullscreen)
actionInfo.triggered.connect(self.handleInfo)
actionToggle.triggered.connect(self.toggleSlider)
actionURL.triggered.connect(self.playFromURL)
menu.exec_(self.mapToGlobal(point))
def wheelEvent(self, event):
mscale = event.angleDelta().y() / 13
self.mediaPlayer.setVolume(self.mediaPlayer.volume() + mscale)
print("Volume: " + str(self.mediaPlayer.volume()))
def mouseDoubleClickEvent(self, event):
if event.buttons() == Qt.LeftButton:
self.handleFullscreen()
def handleFullscreen(self):
if self.windowState() and Qt.WindowFullScreen:
self.showNormal()
else:
self.showFullScreen()
def exitFullscreen(self):
self.showNormal()
def handleInfo(self):
QMessageBox.about(self, "About", self.myinfo)
def toggleSlider(self):
if self.positionSlider.isVisible():
self.hideSlider()
else:
self.showSlider()
def hideSlider(self):
self.channelList.hide()
self.playButton.hide()
self.lbl.hide()
self.positionSlider.hide()
self.elbl.hide()
def showSlider(self):
self.channelList.show()
self.playButton.show()
self.lbl.show()
self.positionSlider.show()
self.elbl.show()
self.channelList.setFocus()
def forwardSlider(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() + 1000 * 60)
def backSlider(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() - 1000 * 60)
def volumeUp(self):
self.mediaPlayer.setVolume(self.mediaPlayer.volume() + 10)
print("Volume: " + str(self.mediaPlayer.volume()))
def volumeDown(self):
self.mediaPlayer.setVolume(self.mediaPlayer.volume() - 10)
print("Volume: " + str(self.mediaPlayer.volume()))
def dragEnterEvent(self, event):
if event.mimeData().hasUrls():
event.accept()
elif event.mimeData().hasText():
event.accept()
else:
event.ignore()
def dropEvent(self, event):
print("drop")
if event.mimeData().hasUrls():
url = event.mimeData().urls()[0].toString()
print("url = ", url)
self.mediaPlayer.stop()
self.mediaPlayer.setMedia(QMediaContent(QUrl(url)))
self.playButton.setEnabled(True)
self.mediaPlayer.play()
elif event.mimeData().hasText():
mydrop = event.mimeData().text()
print("generic url = ", mydrop)
self.mediaPlayer.setMedia(QMediaContent(QUrl(mydrop)))
self.playButton.setEnabled(True)
self.mediaPlayer.play()
self.hideSlider()
def loadFilm(self, f):
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(f)))
self.playButton.setEnabled(True)
self.mediaPlayer.play()
def populateChannelList(self):
# file must be in same directory as the script
FILEPATH = os.path.join(os.path.dirname(os.path.realpath(__file__)), "canaletv.txt")
# lines from file with "channel name" -- "link"
channelArray = []
# split file by line and adding it to the array
with open(FILEPATH) as f:
for line in f:
channelArray.append(line.rstrip())
# dictionary with key = channel name and value = link
self.channelDict = dict(ch.split(" -- ") for ch in channelArray)
for channel in self.channelDict.keys():
item = QStandardItem(channel)
self.model.appendRow(item)
def selectedItemBehavior(self, index):
# gets the link for the selected channel and plays it
itms = self.channelList.selectedIndexes()
for it in itms:
channel = it.data()
link = self.channelDict[channel]
self.mediaPlayer.setMedia(QMediaContent(QUrl(link)))
self.play()
def selectChannel(self):
# selecting channel from sidebar calls selectedItemBehavior
self.selModel = self.channelList.selectionModel()
self.selModel.selectionChanged.connect(self.selectedItemBehavior)
def initialPlay(self):
# play somenting when app opens
self.mediaPlayer.setMedia(QMediaContent(QUrl("https://vid.hls.protv.ro/proxhdn/proxhd_3_34/index.m3u8?1")))
self.play()
def handleLabel(self):
self.lbl.clear()
mtime = QTime(0, 0, 0, 0)
self.time = mtime.addMSecs(self.mediaPlayer.position())
self.lbl.setText(self.time.toString())
class Player(QWidget):
audio_path = "audio"
lyrics_path = "lyrics"
timings_path = os.path.join("lyrics", "timing")
settings_path = "settings.json"
fullScreenChanged = pyqtSignal(bool)
def __init__(self, parent=None):
super(Player, self).__init__(parent)
self.setWindowTitle("SongScreen")
self.setFocusPolicy(Qt.StrongFocus)
self.colorDialog = None
self.trackInfo = ""
self.statusInfo = ""
self.duration = 0
self.player = QMediaPlayer()
self.playlist = QMediaPlaylist()
self.player.setPlaylist(self.playlist)
self.player.durationChanged.connect(self.durationChanged)
self.player.positionChanged.connect(self.positionChanged)
self.player.metaDataChanged.connect(self.metaDataChanged)
# self.playlist.currentIndexChanged.connect(self.playlistPositionChanged)
self.player.mediaStatusChanged.connect(self.statusChanged)
self.player.bufferStatusChanged.connect(self.bufferingProgress)
self.player.videoAvailableChanged.connect(self.videoAvailableChanged)
self.player.error.connect(self.displayErrorMessage)
# self.videoWidget = VideoWidget()
# self.player.setVideoOutput(self.videoWidget)
self.slider = MediaProgressWidget() # QSlider(Qt.Horizontal)
self.markers = []
self.songtext_widget = SongTextWidget()
self.songtext_widget.show()
# self.playlistModel = PlaylistModel()
# self.playlistModel.setPlaylist(self.playlist)
#
# self.playlistView = QListView()
# self.playlistView.setModel(self.playlistModel)
# self.playlistView.setCurrentIndex(
# self.playlistModel.index(self.playlist.currentIndex(), 0))
#
# self.playlistView.activated.connect(self.jump)
self.slider.setRange(0, self.player.duration() / 1000)
self.labelDuration = QLabel()
self.slider.sliderMoved.connect(self.seek)
# openButton = QPushButton("Open", clicked=self.open)
controls = PlayerControlsWidget()
controls.setState(self.player.state())
controls.setVolume(self.player.volume())
# controls.setMuted(controls.isMuted())
controls.play.connect(self.player.play)
controls.pause.connect(self.player.pause)
controls.stop.connect(self.stop_clicked)
# controls.stop.connect(self.videoWidget.update)
# controls.next.connect(self.playlist.next)
# controls.previous.connect(self.previousClicked)
controls.changeVolume.connect(self.player.setVolume)
# controls.changeMuting.connect(self.player.setMuted)
# controls.changeRate.connect(self.player.setPlaybackRate)
self.player.stateChanged.connect(controls.setState)
self.player.stateChanged.connect(self.setState)
self.player.volumeChanged.connect(controls.setVolume)
# self.player.mutedChanged.connect(controls.setMuted)
# self.fullScreenButton = QPushButton("FullScreen")
# self.fullScreenButton.setCheckable(True)
#
# self.colorButton = QPushButton("Color Options...")
# self.colorButton.setEnabled(False)
# self.colorButton.clicked.connect(self.showColorDialog)
displayLayout = QHBoxLayout()
# displayLayout.addWidget(self.videoWidget, 2)
# displayLayout.addWidget(self.songtext_widget)
# displayLayout.addWidget(self.playlistView)
self.song_select_widget = SongSelectWidget()
self.song_select_widget.song_selected.connect(self.load_song)
self.screen_select_widget = ScreenSelectWidget()
self.screen_select_widget.screen_selected.connect(self.display_lyrics_on_screen)
self.screen_select_widget.active_screen = QApplication.desktop().screenNumber(self.songtext_widget)
self.settings_button = QPushButton()
self.settings_button.setText(self.tr("Settings..."))
self.settings_button.clicked.connect(self.show_settings)
sidebarLayout = QVBoxLayout()
sidebarLayout.setContentsMargins(10, 1, 0, 1);
sidebarLayout.addWidget(self.settings_button)
sidebarLayout.addStretch(1);
sidebarLayout.addWidget(self.screen_select_widget)
displayLayout.addWidget(self.song_select_widget)
displayLayout.addLayout(sidebarLayout)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
# controlLayout.addWidget(openButton)
# controlLayout.addStretch(1)
controlLayout.addWidget(controls)
controlLayout.addStretch(1)
controlLayout.addWidget(self.labelDuration)
# controlLayout.addWidget(self.fullScreenButton)
# controlLayout.addWidget(self.colorButton)
layout = QVBoxLayout()
layout.addLayout(displayLayout)
hLayout = QHBoxLayout()
hLayout.addWidget(self.slider)
# hLayout.addWidget(self.labelDuration)
layout.addLayout(hLayout)
layout.addLayout(controlLayout)
self.setLayout(layout)
if not self.player.isAvailable():
QMessageBox.warning(self, "Service not available",
"The QMediaPlayer object does not have a valid service.\n"
"Please check the media service plugins are installed.")
controls.setEnabled(False)
self.playlistView.setEnabled(False)
# openButton.setEnabled(False)
self.colorButton.setEnabled(False)
self.fullScreenButton.setEnabled(False)
self.metaDataChanged()
self._loading_audio = False
self._finished_song = False
self._lyrics_fading = False
self._song_number = -1
self.settings = {
'font_size': 40,
'line_increment': 2,
'lyrics_language': '',
}
self._load_settings()
self.settings_widget = SettingsWidget(self.settings, self.lyrics_path)
self.settings_widget.font_size_changed.connect(self.songtext_widget.set_font_size)
self.settings_widget.line_increment_changed.connect(self.songtext_widget.set_line_increment)
self.settings_widget.language_changed.connect(self._language_changed)
self.song_select_widget.reset(self.available_song_numbers)
@property
def lyrics_language_path(self):
path = QStandardPaths.locate(QStandardPaths.AppDataLocation, self.lyrics_path, QStandardPaths.LocateDirectory)
return os.path.join(path, self.settings['lyrics_language'])
@property
def available_song_numbers(self):
audios = set(
[int(os.path.splitext(filename)[0]) for filename in os.listdir(self.audio_path) if filename[0] != '.'])
try:
lyrics = set(
[int(os.path.splitext(filename)[0])
for filename in os.listdir(self.lyrics_language_path)
if filename[0] != '.']
)
except (ValueError, FileNotFoundError):
lyrics = set()
return sorted(list(audios.intersection(lyrics)))
def show_settings(self):
self.settings_widget.hide()
self.settings_widget.show()
def display_lyrics_on_screen(self, screen_number):
desktop = QApplication.desktop()
if screen_number >= desktop.screenCount():
screen_number = desktop.screenNumber(self)
rect = desktop.availableGeometry(screen_number)
for _ in range(3):
if screen_number != desktop.screenNumber(self):
self.songtext_widget.setWindowFlags(Qt.FramelessWindowHint)
self.songtext_widget.hide()
self.songtext_widget.move(rect.x(), rect.y())
self.songtext_widget.resize(rect.width(), rect.height())
self.songtext_widget.showFullScreen()
else:
self.songtext_widget.setWindowFlags(Qt.WindowTitleHint)
self.songtext_widget.hide()
self.songtext_widget.move(rect.x(), rect.y())
self.songtext_widget.resize(self.songtext_widget.minimumSize())
self.songtext_widget.show()
self.screen_select_widget.active_screen = screen_number
self.activateWindow()
def load_song(self, song_number):
if self._song_number == song_number:
self.seek(0)
else:
if self._song_number > 0:
self._save_timings()
self._song_number = song_number
self.slider.dirty = False
self._load_audio()
self._load_lyrics()
# self.player.play()
def _load_audio(self):
filename = os.path.join(self.audio_path, "{:03}.mp3".format(self._song_number))
self.playlist.clear()
fileInfo = QFileInfo(filename)
if fileInfo.exists():
url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
if fileInfo.suffix().lower() == 'm3u':
self.playlist.load(url)
else:
self.playlist.addMedia(QMediaContent(url))
self._loading_audio = True
self.player.play()
def _load_lyrics(self):
with open(os.path.join(self.lyrics_language_path, "{}.json".format(self._song_number)), 'r') as f:
song_markers = json.load(f)
self.markers = []
for m in song_markers['markers']:
marker = MediaMarker(self.slider, m['name'])
marker.text = m['text']
marker.progress = 0.0
self.markers.append(marker)
self.songtext_widget.title = "{} {}".format(self._song_number, song_markers['title'])
self.songtext_widget.markers = self.markers
self.songtext_widget.fade_in()
try:
with open(os.path.join(self.timings_path, "{}.json".format(self._song_number)), 'r') as f:
timings = json.load(f)
for m, t in zip(self.markers, timings):
m.progress = t
except FileNotFoundError:
pass
self.slider.markers = self.markers
def _language_changed(self, _):
available_song_numbers = self.available_song_numbers
self.song_select_widget.reset(available_song_numbers)
if self._song_number in available_song_numbers:
self._load_lyrics()
# def open(self):
# fileNames, _ = QFileDialog.getOpenFileNames(self, "Open Files")
# self.addToPlaylist(fileNames)
#
# def addToPlaylist(self, fileNames):
# for name in fileNames:
# fileInfo = QFileInfo(name)
# if fileInfo.exists():
# url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
# if fileInfo.suffix().lower() == 'm3u':
# self.playlist.load(url)
# else:
# self.playlist.addMedia(QMediaContent(url))
# else:
# url = QUrl(name)
# if url.isValid():
# self.playlist.addMedia(QMediaContent(url))
def durationChanged(self, duration):
duration /= 1000
self.duration = duration
self.slider.setMaximum(duration)
if self._loading_audio:
self._loading_audio = False
line_total = 0
for marker in self.markers:
line_total += marker.linecount - 1
silence_ratio = 5.0 / self.duration
offset = 1.8 / line_total
linecount = 0
for marker in self.markers:
if marker.progress == 0.0:
marker.progress = offset + (1 - offset) * (1 - silence_ratio) * linecount / line_total
linecount += marker.linecount - 1
self.player.pause()
@property
def _should_fade_out(self):
return self.player.position() / 1000 >= self.duration - 5
def positionChanged(self, progress):
progress /= 1000
if not self.slider.isSliderDown():
self.slider.setValue(progress)
self.updateDurationInfo(progress)
if self.duration > 0:
# if self.player.state() == QMediaPlayer.PlayingState:
self.songtext_widget.progress = progress / self.duration
if self._should_fade_out:
self._fade_out_lyrics()
def _fade_out_lyrics(self):
if not self._lyrics_fading:
self._lyrics_fading = True
self.songtext_widget.fade_out()
def metaDataChanged(self):
if self.player.isMetaDataAvailable():
self.setTrackInfo("%s - %s" % (
self.player.metaData(QMediaMetaData.AlbumArtist),
self.player.metaData(QMediaMetaData.Title)))
def previousClicked(self):
# Go to the previous track if we are within the first 5 seconds of
# playback. Otherwise, seek to the beginning.
if self.player.position() <= 5000:
self.playlist.previous()
else:
self.player.setPosition(0)
def jump(self, index):
if index.isValid():
self.playlist.setCurrentIndex(index.row())
self.player.play()
def seek(self, seconds):
self.player.setPosition(seconds * 1000)
def setState(self, status):
if status == QMediaPlayer.StoppedState:
self._finished_song = True
elif status == QMediaPlayer.PlayingState:
if self._finished_song or (self._lyrics_fading and not self._should_fade_out):
self._finished_song = False
self._lyrics_fading = False
self.songtext_widget.fade_in()
def stop_clicked(self):
self.player.stop()
self._fade_out_lyrics()
def statusChanged(self, status):
self.handleCursor(status)
if status == QMediaPlayer.LoadingMedia:
self.setStatusInfo("Loading...")
elif status == QMediaPlayer.StalledMedia:
self.setStatusInfo("Media Stalled")
elif status == QMediaPlayer.EndOfMedia:
QApplication.alert(self)
elif status == QMediaPlayer.InvalidMedia:
self.displayErrorMessage()
else:
self.setStatusInfo("")
def handleCursor(self, status):
if status in (QMediaPlayer.LoadingMedia, QMediaPlayer.BufferingMedia, QMediaPlayer.StalledMedia):
self.setCursor(Qt.BusyCursor)
else:
self.unsetCursor()
def bufferingProgress(self, progress):
self.setStatusInfo("Buffering %d%" % progress)
def videoAvailableChanged(self, available):
if available:
self.fullScreenButton.clicked.connect(
self.videoWidget.setFullScreen)
self.videoWidget.fullScreenChanged.connect(
self.fullScreenButton.setChecked)
if self.fullScreenButton.isChecked():
self.videoWidget.setFullScreen(True)
else:
self.fullScreenButton.clicked.disconnect(
self.videoWidget.setFullScreen)
self.videoWidget.fullScreenChanged.disconnect(
self.fullScreenButton.setChecked)
self.videoWidget.setFullScreen(False)
self.colorButton.setEnabled(available)
def setTrackInfo(self, info):
self.trackInfo = info
# if self.statusInfo != "":
# self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo))
# else:
# self.setWindowTitle(self.trackInfo)
def setStatusInfo(self, info):
self.statusInfo = info
# if self.statusInfo != "":
# self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo))
# else:
# self.setWindowTitle(self.trackInfo)
def displayErrorMessage(self):
self.setStatusInfo(self.player.errorString())
def updateDurationInfo(self, currentInfo):
duration = self.duration
if currentInfo or duration:
currentTime = QTime((currentInfo / 3600) % 60, (currentInfo / 60) % 60,
currentInfo % 60, (currentInfo * 1000) % 1000)
totalTime = QTime((duration / 3600) % 60, (duration / 60) % 60,
duration % 60, (duration * 1000) % 1000);
format = 'hh:mm:ss' if duration > 3600 else 'mm:ss'
tStr = currentTime.toString(format) + " / " + totalTime.toString(format)
else:
tStr = ""
self.labelDuration.setText(tStr)
def showColorDialog(self):
if self.colorDialog is None:
brightnessSlider = QSlider(Qt.Horizontal)
brightnessSlider.setRange(-100, 100)
brightnessSlider.setValue(self.videoWidget.brightness())
brightnessSlider.sliderMoved.connect(
self.videoWidget.setBrightness)
self.videoWidget.brightnessChanged.connect(
brightnessSlider.setValue)
contrastSlider = QSlider(Qt.Horizontal)
contrastSlider.setRange(-100, 100)
contrastSlider.setValue(self.videoWidget.contrast())
contrastSlider.sliderMoved.connect(self.videoWidget.setContrast)
self.videoWidget.contrastChanged.connect(contrastSlider.setValue)
hueSlider = QSlider(Qt.Horizontal)
hueSlider.setRange(-100, 100)
hueSlider.setValue(self.videoWidget.hue())
hueSlider.sliderMoved.connect(self.videoWidget.setHue)
self.videoWidget.hueChanged.connect(hueSlider.setValue)
saturationSlider = QSlider(Qt.Horizontal)
saturationSlider.setRange(-100, 100)
saturationSlider.setValue(self.videoWidget.saturation())
saturationSlider.sliderMoved.connect(
self.videoWidget.setSaturation)
self.videoWidget.saturationChanged.connect(
saturationSlider.setValue)
layout = QFormLayout()
layout.addRow("Brightness", brightnessSlider)
layout.addRow("Contrast", contrastSlider)
layout.addRow("Hue", hueSlider)
layout.addRow("Saturation", saturationSlider)
button = QPushButton("Close")
layout.addRow(button)
self.colorDialog = QDialog(self)
self.colorDialog.setWindowTitle("Color Options")
self.colorDialog.setLayout(layout)
button.clicked.connect(self.colorDialog.close)
self.colorDialog.show()
def closeEvent(self, close_event):
self._save_timings()
self._save_settings()
self.songtext_widget.close()
self.settings_widget.close()
def keyPressEvent(self, key_event):
if key_event.key() == Qt.Key_Space:
key_event.accept()
if self.player.state() == QMediaPlayer.PlayingState:
self.player.pause()
elif self.player.state() in [QMediaPlayer.PausedState, QMediaPlayer.StoppedState]:
self.player.play()
elif key_event.key() == Qt.Key_M:
key_event.accept()
self.slider.set_closest_marker_to_current_progress()
def _save_timings(self):
if self.slider.dirty:
with open(os.path.join(self.timings_path, "{}.json".format(self._song_number)), 'w') as f:
json.dump([marker.progress for marker in self.markers], f, indent=2)
def _save_settings(self):
# TODO : refactor and use QSettings directly
# with open(self.settings_path, 'w') as f:
self.settings.update({
'lyrics_screen': QApplication.desktop().screenNumber(self.songtext_widget),
'control_window_position': self.pos(),
})
# json.dump(self.settings, f, indent=2)
settings = QSettings("Maccesch", "SongScreen")
for key, value in self.settings.items():
settings.setValue(key, value)
def _load_settings(self):
# try:
# with open(self.settings_path, 'r') as f:
# settings = json.load(f)
settings = QSettings("Maccesch", "SongScreen")
if settings.contains('lyrics_screen'):
self.display_lyrics_on_screen(settings.value('lyrics_screen'))
if settings.contains('control_window_position'):
self.move(settings.value('control_window_position'))
for key in settings.allKeys():
self.settings[key] = settings.value(key)
# self.settings.update(settings)
self.songtext_widget.set_font_size(self.settings['font_size'])
self.songtext_widget.set_line_increment(self.settings['line_increment'])
# except (FileNotFoundError, ValueError):
# pass
if not os.path.exists(self.lyrics_language_path) or not self.settings['lyrics_language']:
languages = list(
filter(lambda p: os.path.isdir(os.path.join(self.lyrics_path, p)) and p != "timings",
os.listdir(self.lyrics_path))
)
self.settings['lyrics_language'] = languages[0] if languages else ""
class Player(Qt.QWidget):
"""docstring for Player"""
fullScreenChanged = Qt.pyqtSignal(bool)
def __init__(self, playlist, parent=None):
# create player
super(Player, self).__init__(parent)
self.trackInfo = ''
self.statusInfo = ''
self.duration = 0
# create player object
self.player = QMediaPlayer()
self.playlist = QMediaPlaylist()
self.name = 'Current playlist'
self.player.setPlaylist(self.playlist)
self.player.durationChanged.connect(self.durationChanged)
self.player.positionChanged.connect(self.positionChanged)
self.player.metaDataChanged.connect(self.metaDataChanged)
self.playlist.currentIndexChanged.connect(self.playlistPositionChanged)
self.player.mediaStatusChanged.connect(self.statusChanged)
self.player.bufferStatusChanged.connect(self.bufferingProgress)
# self.player.videoAvailableChanged.connect(self.videoAvailableChanged)
self.player.error.connect(self.displayErrorMessage)
# connect with VideoWidget
# self.videoWidget = VideoWidget()
# self.player.setVideoOutput(self.videoWidget)
# connect with PlaylistModel
self.playlistModel = PlaylistModel()
self.playlistModel.setPlaylist(self.playlist)
self.playlistView = Qt.QListView()
self.playlistView.setModel(self.playlistModel)
self.playlistView.setCurrentIndex(self.playlistModel.index(
self.playlist.currentIndex(), 0))
# change to next song
self.playlistView.activated.connect(self.jump)
self.slider = Qt.QSlider(QtCore.Qt.Horizontal)
self.slider.setRange(0, self.player.duration() / 1000)
self.labelDuration = Qt.QLabel()
self.slider.sliderMoved.connect(self.seek)
# create histogram
self.labelHistogram = Qt.QLabel()
self.labelHistogram.setText('Histogram: ')
self.histogram = HistogramWidget()
histogramLayout = Qt.QHBoxLayout()
histogramLayout.addWidget(self.labelHistogram)
histogramLayout.addWidget(self.histogram, 1)
# create videoProbe
self.videoProbe = Qt.QVideoProbe()
self.videoProbe.videoFrameProbed.connect(self.histogram.processFrame)
self.videoProbe.setSource(self.player)
# add control
controls = Controllers()
controls.setState(self.player.state())
controls.setVolume(self.player.volume())
controls.setMuted(controls.isMuted())
# connect player's controls with Controllers
controls.play.connect(self.player.play)
controls.pause.connect(self.player.pause)
controls.stop.connect(self.player.stop)
controls.next.connect(self.playlist.next)
controls.previous.connect(self.previousAction)
controls.changeVolume.connect(self.player.setVolume)
controls.changeMuting.connect(self.player.setMuted)
# setPlaybackRate is from QMediaPlayer
controls.changeSpeed.connect(self.player.setPlaybackRate)
# controls.stop.connect(self.videoWidget.update)
self.player.stateChanged.connect(controls.setState)
self.player.volumeChanged.connect(controls.setVolume)
self.player.mutedChanged.connect(controls.setMuted)
# create fullScreenButton
# self.fullScreenButton = Qt.QPushButton('FullScreen')
# self.fullScreenButton.setCheckable(True)
# displayLayout
displayLayout = Qt.QHBoxLayout()
# displayLayout.addWidget(self.videoWidget, 2)
displayLayout.addWidget(self.playlistView)
# controlLayout
controlLayout = Qt.QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
# connect controlLayout with controls
controlLayout.addWidget(controls)
controlLayout.addStretch(1)
# connect controlLayout with fullScreenButton
# controlLayout.addWidget(self.fullScreenButton)
# visualize player
layout = Qt.QVBoxLayout()
layout.addLayout(displayLayout)
# layout for sliding song playing
hLayout = Qt.QHBoxLayout()
hLayout.addWidget(self.slider)
hLayout.addWidget(self.labelDuration)
layout.addLayout(hLayout)
layout.addLayout(controlLayout)
layout.addLayout(histogramLayout)
# set icon
self.setWindowIcon(Qt.QIcon('favicon.ico'))
# create menus
toolBar = Qt.QToolBar()
# create basic actions
self.createActions()
# create simple button to repeat song
self.repeatButton = Qt.QToolButton()
self.repeatButton.setDefaultAction(self.repeatAct)
# create playOnceButton
self.playOnceButton = Qt.QToolButton()
self.playOnceButton.setDefaultAction(self.playOnceAct)
self.playOnceButton.setEnabled(False)
# create shuffleButton
self.shuffleButton = Qt.QToolButton()
self.shuffleButton.setDefaultAction(self.shuffleAct)
# create sequentialButton
self.sequentialButton = Qt.QToolButton()
self.sequentialButton.setDefaultAction(self.sequentialAct)
# create fileButton for fileMenu
fileButton = Qt.QToolButton()
fileButton.setText('File')
fileButton.setPopupMode(Qt.QToolButton.MenuButtonPopup)
fileButton.setMenu(self.popFileMenu())
# create editButton for editMenu
closeButton = Qt.QToolButton()
closeButton.setText('Edit')
closeButton.setDefaultAction(self.fileCloseAct)
# display in toolBar these buttons
toolBar.addWidget(self.repeatButton)
toolBar.addWidget(self.playOnceButton)
toolBar.addWidget(self.shuffleButton)
toolBar.addWidget(self.sequentialButton)
toolBar.addWidget(fileButton)
toolBar.addWidget(closeButton)
# add toolBar to layout of the player
layout.addWidget(toolBar)
layout.addWidget(Qt.QGroupBox())
self.setWindowTitle("Python Music Player")
self.setLayout(layout)
if not self.player.isAvailable():
Qt.QMessageBox(self, 'Unavailable service')
# self.displayErrorMessage()
controls.setEnabled(False)
self.playlistView.setEnabled(False)
self.fullScreenButton.setEnabled(False)
self.metaDataChanged()
self.addToPlaylist(playlist)
# create fileMenu
def popFileMenu(self):
aMenu = Qt.QMenu(self)
aMenu.addAction(self.fileOpenAct)
aMenu.addAction(self.fileCloseAct)
return aMenu
def createActions(self):
self.repeatAct = Qt.QAction('Repeat', self, triggered=self.repeatSong)
self.playOnceAct = Qt.QAction(
'Play once', self, triggered=self.playOnceSong)
self.shuffleAct = Qt.QAction(
'Shuffle', self, triggered=self.playlist.shuffle)
self.sequentialAct = Qt.QAction(
'Sequential', self, triggered=self.playSequential)
self.fileOpenAct = Qt.QAction('Open', self, triggered=self.open)
self.fileOpenAct.setShortcut('Ctrl+O')
self.fileCloseAct = Qt.QAction('Close', self, triggered=self.close)
self.fileCloseAct.setShortcut('Ctrl+Q')
def repeatSong(self):
self.playlist.setPlaybackMode(QMediaPlaylist.CurrentItemInLoop)
self.repeatButton.setEnabled(False)
self.playOnceButton.setEnabled(True)
def playOnceSong(self):
self.playlist.setPlaybackMode(QMediaPlaylist.Sequential)
self.playOnceButton.setEnabled(False)
self.repeatButton.setEnabled(True)
# unproperly used
def playSequential(self):
self.playlist.setPlaybackMode(QMediaPlaylist.Sequential)
# get and display song duration
def durationChanged(self, duration):
duration /= 1000
self.duration = duration
self.slider.setMaximum(duration)
# change slider position
def positionChanged(self, progress):
progress /= 1000
if not self.slider.isSliderDown():
self.slider.setValue(progress)
self.updateDurationInfo(progress)
def updateDurationInfo(self, currentInfo):
duration = self.duration
if currentInfo or duration:
currentTime = QtCore.QTime(
(currentInfo / 3600) % 60, # hours
(currentInfo / 60) % 60, # minutes
currentInfo % 60, # seconds
(currentInfo * 1000) % 1000) # miliseconds
totalTime = QtCore.QTime(
(duration / 3600) % 60, # hours
(duration / 60) % 60, # minutes
duration % 60, # seconds
(duration * 1000) % 1000) # miliseconds
formating = 'hh:mm:ss' if duration > 3600 else 'mm:ss'
toString = (currentTime.toString(formating) + ' / ' +
totalTime.toString(formating))
else:
toString = ''
self.labelDuration.setText(toString)
def metaDataChanged(self):
if self.player.isMetaDataAvailable():
self.setTrackInfo('{0} - {1}'.format(
self.player.metaData(Qt.QMediaMetaData.AlbumArtist),
self.player.metaData(Qt.QMediaMetaData.Title)))
def setTrackInfo(self, info):
self.trackInfo = info
if self.statusInfo:
self.setWindowTitle('{0} | {1}'.format(
self.trackInfo, self.statusInfo))
else:
self.setWindowTitle(self.trackInfo)
def playlistPositionChanged(self, position):
self.playlistView.setCurrentIndex(
self.playlistModel.index(position, 0))
def statusChanged(self, status):
self.handleCursor(status)
if status == QMediaPlayer.LoadingMedia:
self.setStatusInfo('Loading...')
elif status == QMediaPlayer.StalledMedia:
self.setStatusInfo('Media Stalled')
elif status == QMediaPlayer.EndOfMedia:
Qt.QApplication.alert(self)
elif status == QMediaPlayer.InvalidMedia:
self.displayErrorMessage()
else:
self.setStatusInfo('')
def handleCursor(self, status):
if status in [QMediaPlayer.LoadingMedia, QMediaPlayer.BufferingMedia,
QMediaPlayer.StalledMedia]:
self.setCursor(QtCore.Qt.BusyCursor)
else:
self.unsetCursor()
def setStatusInfo(self, info):
self.statusInfo = info
if self.statusInfo:
self.setWindowTitle('{0} | {1}'.format(
self.trackInfo, self.statusInfo))
else:
self.setWindowTitle(self.trackInfo)
def bufferingProgress(self, progress):
self.setStatusInfo('Buffering {0}'.format(progress))
def displayErrorMessage(self):
self.statusInfo(self.player.errorString())
def jump(self, index):
if index.isValid():
self.playlist.setCurrentIndex(index.row())
self.player.play()
def seek(self, seconds):
self.player.setPosition(seconds * 1000)
def previousAction(self):
self.playlist.previous()
def close(self):
choice = Qt.QMessageBox.question(
self,
'Close',
'Close the app?',
Qt.QMessageBox.Yes | Qt.QMessageBox.No)
if choice == Qt.QMessageBox.Yes:
sys.exit()
def open(self):
names, _ = Qt.QFileDialog.getOpenFileNames(self, 'Open Files')
# ['/home/milka/Documents/MusicPlayer/song.mp3']
self.addToPlaylist(names)
def addToPlaylist(self, names):
for name in names:
fileInfo = Qt.QFileInfo(name)
if fileInfo.exists():
url = QtCore.QUrl.fromLocalFile(fileInfo.absoluteFilePath())
# save_to_db song url
create_song(
url.path(), self.duration, playlist_name=self.name)
if fileInfo.suffix().lower() == 'm3u':
self.playlist.load(url)
else:
self.playlist.addMedia(Qt.QMediaContent(url))
else:
url = QtCore.QUrl(name)
if url.isValid():
self.playlist.addMedia(Qt.QMediaContent(url))
class VideoPlayer(QWidget):
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
iconSize = QSize(12, 12)
videoWidget = QVideoWidget()
openButton = QPushButton("Open Video")
openButton.setToolTip("Open Video File")
openButton.setStatusTip("Open Video File")
openButton.setFixedHeight(24)
openButton.setFont(QFont("Noto Sans", 10))
openButton.clicked.connect(self.abrir)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setFixedHeight(24)
self.playButton.setIconSize(iconSize)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
#进度条
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
#音量条
self.volumeSlider = QSlider(Qt.Horizontal)
self.volumeSlider.setRange(0, 100)
self.volumeSlider.sliderMoved.connect(self.setVolume)
self.volumeLabel = QLabel()
self.volumeLabel.setText(" Volume Bar --> ")
self.volumeLabel.setFont(QFont("Noto Sans", 10, QFont.Bold))
#Information bar
self.statusBar = QStatusBar()
self.statusBar.setFont(QFont("Noto Sans", 7))
self.statusBar.setFixedHeight(14)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layoutLine2 = QHBoxLayout()
layoutLine2.setContentsMargins(0, 0, 0, 0)
layoutLine2.addWidget(self.volumeLabel)
layoutLine2.addWidget(self.volumeSlider)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addLayout(layoutLine2)
layout.addWidget(self.statusBar)
self.setLayout(layout)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.volumeChanged.connect(self.volumeChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
self.statusBar.showMessage("Ready")
def abrir(self):
fileName, _ = QFileDialog.getOpenFileName(
self, "Selecciona los mediose", ".",
"Video Files (*.mp4 *.flv *.ts *.mts *.avi)")
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
self.statusBar.showMessage(fileName)
self.play()
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
print("Play state:", state)
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
v = self.volumeSlider.value()
pause = False
global forwardLock
global backwardLock
global upLock
global downLock
f = open("result.txt", "r+")
data = f.readline()
print("Reading txt...")
print("Data read from txt: ", data)
if data == "[4]":
pause = True
self.mediaPlayer.pause()
self.mediaStateChanged(2)
f.close()
while pause:
f = open("result.txt", "r+")
l = f.readline()
if l == "[3]":
pause = False
self.mediaPlayer.play()
self.mediaStateChanged(1)
f.close()
if data == "[3]" and forwardLock == 0:
f.close()
forwardLock = 1
self.setPosition(position + 20000)
f = open("result.txt", "w")
f.write('no motion')
f.close()
elif data != "[3]" and forwardLock == 1:
forwardLock = 0
f.close()
else:
f.close()
if data == "[2]" and backwardLock == 0:
f.close()
backwardLock = 1
if position > 20000:
self.setPosition(position - 20000)
else:
self.setPosition(0)
f = open("result.txt", "w")
f.write('no motion')
f.close()
elif data != "[2]" and backwardLock == 1:
backwardLock = 0
f.close()
else:
f.close()
if data == "[1]" and upLock == 0:
f.close()
upLock = 1
print(v)
if v + 15 > 100:
self.setVolume(100)
else:
v += 15
self.setVolume(v)
print(v)
print("Volume set")
f = open("result.txt", "w")
f.write('no motion')
f.close()
elif data != "[1]" and upLock == 1:
upLock = 0
f.close()
else:
f.close()
if data == "[0]" and downLock == 0:
f.close()
downLock = 1
print(v)
if v - 15 < 0:
self.setVolume(0)
else:
v -= 15
self.setVolume(v)
print(v)
print("Volume set")
f = open("result.txt", "w")
f.write('no motion')
f.close()
elif data != "[0]" and downLock == 1:
downLock = 0
f.close()
else:
f.close()
self.setVolume(v)
print("Position changed:", position)
def volumeChanged(self, value):
self.volumeSlider.setValue(value)
def setVolume(self, value):
self.mediaPlayer.setVolume(value)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
print("Duration changed:", duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
print("Position set:", position)
def handleError(self):
self.playButton.setEnabled(False)
self.statusBar.showMessage("Error: " + self.mediaPlayer.errorString())
class ApplicationVideo(QMainWindow):
def __init__(self):
super().__init__()
self.title = 'Interfaz Video'
self.left = 10
self.top = 10
self.width = 640
self.height = 480
return
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
# Create Open Action
openButton = QAction('&Open', self)
openButton.setShortcut('Cmd+o')
openButton.setStatusTip('Open movie')
openButton.triggered.connect(self.openFile)
# Create Exit Action Button
exitButton = QAction('Exit', self)
exitButton.setShortcut('Cmd+Q')
exitButton.setStatusTip('Exit application')
exitButton.triggered.connect(self.closeInterface)
# Create Menu Bar
mainMenu = self.menuBar()
mainMenu.setNativeMenuBar(
False
) # It's necessary if you are working in OS. Unless, MenuBar doesn't appear.
fileMenu = mainMenu.addMenu('File')
fileMenu.addAction(openButton)
fileMenu.addAction(exitButton)
#-----------------------------------
# Control panel
#----------------------------------
# Play button
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
# State bar
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
# Timer
self.timer = QLabel('00:00:00')
self.timer.setFixedWidth(60)
self.timer.setFixedHeight(10)
self.timer.setUpdatesEnabled(True)
# Error Label
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
# Create layout to control panel
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
controlLayout.addWidget(self.timer)
# -------------------------------------
# Create a widget for windows contents
windowVideo = QWidget(self)
videoWidget = QVideoWidget()
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChangedIcon)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
self.setCentralWidget(windowVideo)
# -------------------------------------
# Group Box Select Temps
# -------------------------------------
#-------------------------------------
# Create layout all interface
#-------------------------------------
layoutInterface = QVBoxLayout()
layoutInterface.addWidget(videoWidget)
layoutInterface.addLayout(controlLayout)
layoutInterface.addWidget(self.errorLabel)
windowVideo.setLayout(layoutInterface)
return
def openFile(self):
print("Choose file to open")
fileName, _ = QFileDialog.getOpenFileName(self, "Choose a video",
QDir.homePath())
print("Opening: %s" % fileName)
if fileName != '':
url = QUrl.fromLocalFile(fileName)
self.mediaPlayer.setMedia(QMediaContent(url))
self.playButton.setEnabled(True)
self.errorLabel.setText(
'') #If video is ok, update content in error label.
return
def closeInterface(self):
print("Closing app...")
sys.exit(0)
def play(self):
# Change the state of video from play to pause. To change icon, call mediaStateChanged
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
print("Pause video...")
else:
self.mediaPlayer.play()
print("Play video...")
return
# Change icon play/pause.
def mediaStateChangedIcon(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
return
# Position Slider
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
return
def positionChanged(self, position):
self.positionSlider.setValue(position)
# This update time label from position in ms
mtime = QTime(0, 0, 0, 0)
mtime = mtime.addMSecs(self.mediaPlayer.position())
self.timer.setText(mtime.toString())
return
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
return
# Error
def handleError(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error:" + self.mediaPlayer.errorString())
return
class VideoWindow(QMainWindow):
def __init__(self, parent=None):
super(VideoWindow, self).__init__(parent)
self.setWindowTitle("RSL Player")
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
videoWidget = QVideoWidget()
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
openAction = QAction(QIcon("open.png"), "&Open", self)
openAction.setShortcut("Ctrl+O")
openAction.setStatusTip("Open movie")
openAction.triggered.connect(self.openFile)
exitAction = QAction(QIcon("exit.png"), "&Exit", self)
exitAction.setShortcut("Ctrl+Q")
exitAction.setStatusTip("Exit application")
exitAction.triggered.connect(self.exitCall)
menuBar = self.menuBar()
fileMenu = menuBar.addMenu("&File")
fileMenu.addAction(openAction)
fileMenu.addAction(exitAction)
wid = QWidget(self)
self.setCentralWidget(wid)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.errorLabel)
wid.setLayout(layout)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
QDir.homePath())
fileName = os.path.basename(os.path.realpath(fileName))
command = "python func.py " + fileName
ret = os.system(command)
path = os.path.abspath("data/test_rsl/ds0/result/")
fileName = path + "/" + fileName + ".avi"
print(fileName)
if fileName != "":
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
def exitCall(self):
sys.exit(app.exec_())
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
class ReframomatController:
# timestamp, top color, bottom color
colors_phase1 = [[0, 0x000001, 0xFDFFFF], \
[10, 0xFF0001, 0x01FFFF], \
[20, 0xFFFF01, 0x0100FF], \
[27, 0xFFFFFD, 0x010000]]
def __init__(self):
if QDesktopWidget().screenCount() > 1:
primaryRect = QDesktopWidget().availableGeometry(0)
secondaryRect = QDesktopWidget().availableGeometry(1)
else:
# "Debug mode" with only one screen.
# Use the top half of the first screen so we can
# look at the console output.
primaryRect = QDesktopWidget().availableGeometry(0)
primaryRect.setHeight(primaryRect.height()/2)
secondaryRect = QRect(primaryRect)
primaryRect.setWidth(primaryRect.width()/2)
secondaryRect.setLeft(primaryRect.width())
self.state = ReframomatState.WELCOME
self.secondWin = AmbilightWindow(secondaryRect)
self.secondWin.show()
self.mainWin = MainWindow(primaryRect, self)
self.mainWin.show()
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer.setVideoOutput(self.mainWin.videoWidget)
self.mediaPlayer.error.connect(self.handleError)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.timer = QTimer(self.mainWin)
self.timer.timeout.connect(self.onTimer)
self.timer.start(100)
def onBuzzerPress(self):
if self.state == ReframomatState.WELCOME:
self.mainWin.videoWidget.show()
self.startVideo("dummy1.mp4")
self.state = ReframomatState.PHASE_1
elif self.state == ReframomatState.PHASE_1:
print("Buzzer in Phase 1")
elif self.state == ReframomatState.PHASE_2:
print("Buzzer in Phase 2")
elif self.state == ReframomatState.PHASE_3:
print("Buzzer in Phase 3")
elif self.state == ReframomatState.END:
self.mainWin.welcomeMsg.setText("Willkommen beim Reframomat!\nDrücke den Buzzer, um loszulegen!")
self.state = ReframomatState.WELCOME
def onTimer(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
if self.state == ReframomatState.PHASE_1:
pos = self.mediaPlayer.position() / 1000
colors1 = self.colors_phase1[0]
colors2 = self.colors_phase1[1]
firstidx = 0
while colors2[0] < pos:
firstidx += 1
if firstidx < len(self.colors_phase1)-1:
colors1 = self.colors_phase1[firstidx]
colors2 = self.colors_phase1[firstidx+1]
else:
break
fadeFactor = min(1, (pos - colors1[0]) / (colors2[0] - colors1[0]))
#print("pos %f, firstidx %i, fade %f" % (pos, firstidx, fadeFactor))
result1 = interpColors(QColor(colors1[1]), QColor(colors2[1]), fadeFactor)
result2 = interpColors(QColor(colors1[2]), QColor(colors2[2]), fadeFactor)
self.secondWin.setColors(result1, result2)
def mediaStateChanged(self):
if self.mediaPlayer.state() == QMediaPlayer.StoppedState:
if self.state == ReframomatState.PHASE_1:
self.startVideo("dummy2.mp4")
self.state = ReframomatState.PHASE_2
elif self.state == ReframomatState.PHASE_2:
self.startVideo("dummy3.mp4")
self.state = ReframomatState.PHASE_3
elif self.state == ReframomatState.PHASE_3:
self.mainWin.videoWidget.hide()
self.mainWin.welcomeMsg.setText("Ende Gelände! Buzz me!")
self.state = ReframomatState.END
def skip(self):
self.mediaPlayer.stop()
def startVideo(self, file):
path = os.path.abspath(file)
url = QUrl.fromLocalFile(path)
content = QMediaContent(url)
self.mediaPlayer.setMedia(content)
self.mediaPlayer.play()
def handleError(self):
print("Error: " + self.mediaPlayer.errorString())
class VideoPlayer(QWidget):
def __init__(self, aPath, parent=None):
super(VideoPlayer, self).__init__(parent)
self.setAttribute(Qt.WA_NoSystemBackground, True)
self.setAcceptDrops(True)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.StreamPlayback)
self.mediaPlayer.mediaStatusChanged.connect(self.printMediaData)
self.mediaPlayer.setVolume(80)
self.videoWidget = QVideoWidget(self)
self.lbl = QLineEdit('00:00:00')
self.lbl.setReadOnly(True)
self.lbl.setFixedWidth(70)
self.lbl.setUpdatesEnabled(True)
self.lbl.setStyleSheet(stylesheet(self))
self.elbl = QLineEdit('00:00:00')
self.elbl.setReadOnly(True)
self.elbl.setFixedWidth(70)
self.elbl.setUpdatesEnabled(True)
self.elbl.setStyleSheet(stylesheet(self))
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setFixedWidth(32)
self.playButton.setStyleSheet("background-color: black")
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal, self)
self.positionSlider.setStyleSheet(stylesheet(self))
self.positionSlider.setRange(0, 100)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.positionSlider.sliderMoved.connect(self.handleLabel)
self.positionSlider.setSingleStep(2)
self.positionSlider.setPageStep(20)
self.positionSlider.setAttribute(Qt.WA_TranslucentBackground, True)
self.clip = QApplication.clipboard()
self.process = QProcess(self)
self.process.readyRead.connect(self.dataReady)
# self.process.started.connect(lambda: print("grabbing YouTube URL"))
self.process.finished.connect(self.playFromURL)
self.myurl = ""
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(5, 0, 5, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.lbl)
controlLayout.addWidget(self.positionSlider)
controlLayout.addWidget(self.elbl)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.videoWidget)
layout.addLayout(controlLayout)
self.setLayout(layout)
self.myinfo = "©2016\nAxel Schneider\n\nMouse Wheel = Zoom\nUP = Volume Up\nDOWN = Volume Down\n" + \
"LEFT = < 1 Minute\nRIGHT = > 1 Minute\n" + \
"SHIFT+LEFT = < 10 Minutes\nSHIFT+RIGHT = > 10 Minutes"
self.widescreen = True
#### shortcuts ####
self.shortcut = QShortcut(QKeySequence("q"), self)
self.shortcut.activated.connect(self.handleQuit)
self.shortcut = QShortcut(QKeySequence("u"), self)
self.shortcut.activated.connect(self.playFromURL)
self.shortcut = QShortcut(QKeySequence("y"), self)
self.shortcut.activated.connect(self.getYTUrl)
self.shortcut = QShortcut(QKeySequence("o"), self)
self.shortcut.activated.connect(self.openFile)
self.shortcut = QShortcut(QKeySequence(" "), self)
self.shortcut.activated.connect(self.play)
self.shortcut = QShortcut(QKeySequence("f"), self)
self.shortcut.activated.connect(self.handleFullscreen)
self.shortcut = QShortcut(QKeySequence("i"), self)
self.shortcut.activated.connect(self.handleInfo)
self.shortcut = QShortcut(QKeySequence("s"), self)
self.shortcut.activated.connect(self.toggleSlider)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Right), self)
self.shortcut.activated.connect(self.forwardSlider)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Left), self)
self.shortcut.activated.connect(self.backSlider)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Up), self)
self.shortcut.activated.connect(self.volumeUp)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Down), self)
self.shortcut.activated.connect(self.volumeDown)
self.shortcut = QShortcut(
QKeySequence(Qt.ShiftModifier + Qt.Key_Right), self)
self.shortcut.activated.connect(self.forwardSlider10)
self.shortcut = QShortcut(QKeySequence(Qt.ShiftModifier + Qt.Key_Left),
self)
self.shortcut.activated.connect(self.backSlider10)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.positionChanged.connect(self.handleLabel)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
print("QT5 Player started")
self.suspend_screensaver()
# msg = QMessageBox.information(self, "Qt5Player", "press o to open file")
self.loadFilm("/home/brian/Dokumente/Qt5PlayerIntro.m4v")
def playFromURL(self):
self.mediaPlayer.pause()
self.myurl = self.clip.text()
self.mediaPlayer.setMedia(QMediaContent(QUrl(self.myurl)))
self.playButton.setEnabled(True)
self.mediaPlayer.play()
self.hideSlider()
print(self.myurl)
def getYTUrl(self):
cmd = "youtube-dl -g -f best " + self.clip.text()
print("grabbing YouTube URL")
self.process.start(cmd)
def dataReady(self):
self.myurl = str(self.process.readAll(), encoding='utf8').rstrip() ###
self.myurl = self.myurl.partition("\n")[0]
print(self.myurl)
self.clip.setText(self.myurl)
self.playFromURL()
def suspend_screensaver(self):
'suspend linux screensaver'
proc = subprocess.Popen(
'gsettings set org.gnome.desktop.screensaver idle-activation-enabled false',
shell=True)
proc.wait()
def resume_screensaver(self):
'resume linux screensaver'
proc = subprocess.Popen(
'gsettings set org.gnome.desktop.screensaver idle-activation-enabled true',
shell=True)
proc.wait()
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(
self, "Open Movie",
QDir.homePath() + "/Videos",
"Media (*.webm *.mp4 *.ts *.avi *.mpeg *.mpg *.mkv *.VOB *.m4v *.3gp *.mp3 *.m4a *.wav *.ogg *.flac *.m3u *.m3u8)"
)
if fileName != '':
self.loadFilm(fileName)
print("File loaded")
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
mtime = QTime(0, 0, 0, 0)
mtime = mtime.addMSecs(self.mediaPlayer.duration())
self.elbl.setText(mtime.toString())
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
print("Error: ", self.mediaPlayer.errorString())
def handleQuit(self):
self.mediaPlayer.stop()
self.resume_screensaver()
print("Goodbye ...")
app.quit()
def contextMenuRequested(self, point):
menu = QMenu()
actionFile = menu.addAction(QIcon.fromTheme("video-x-generic"),
"open File (o)")
actionclipboard = menu.addSeparator()
actionURL = menu.addAction(QIcon.fromTheme("browser"),
"URL from Clipboard (u)")
actionclipboard = menu.addSeparator()
actionYTurl = menu.addAction(QIcon.fromTheme("youtube"),
"URL from YouTube (y)")
actionclipboard = menu.addSeparator()
actionToggle = menu.addAction(QIcon.fromTheme("next"),
"show / hide Slider (s)")
actionFull = menu.addAction(QIcon.fromTheme("view-fullscreen"),
"Fullscreen (f)")
action169 = menu.addAction(QIcon.fromTheme("tv-symbolic"), "16 : 9")
action43 = menu.addAction(QIcon.fromTheme("tv-symbolic"), "4 : 3")
actionSep = menu.addSeparator()
actionInfo = menu.addAction(QIcon.fromTheme("help-about"), "Info (i)")
action5 = menu.addSeparator()
actionQuit = menu.addAction(QIcon.fromTheme("application-exit"),
"Exit (q)")
actionFile.triggered.connect(self.openFile)
actionQuit.triggered.connect(self.handleQuit)
actionFull.triggered.connect(self.handleFullscreen)
actionInfo.triggered.connect(self.handleInfo)
actionToggle.triggered.connect(self.toggleSlider)
actionURL.triggered.connect(self.playFromURL)
actionYTurl.triggered.connect(self.getYTUrl)
action169.triggered.connect(self.screen169)
action43.triggered.connect(self.screen43)
menu.exec_(self.mapToGlobal(point))
def wheelEvent(self, event):
mwidth = self.frameGeometry().width()
mheight = self.frameGeometry().height()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
mscale = event.angleDelta().y() / 5
if self.widescreen == True:
self.setGeometry(mleft, mtop, mwidth + mscale,
(mwidth + mscale) / 1.778)
else:
self.setGeometry(mleft, mtop, mwidth + mscale,
(mwidth + mscale) / 1.33)
def screen169(self):
self.widescreen = True
mwidth = self.frameGeometry().width()
mheight = self.frameGeometry().height()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
mratio = 1.778
self.setGeometry(mleft, mtop, mwidth, mwidth / mratio)
def screen43(self):
self.widescreen = False
mwidth = self.frameGeometry().width()
mheight = self.frameGeometry().height()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
mratio = 1.33
self.setGeometry(mleft, mtop, mwidth, mwidth / mratio)
def handleFullscreen(self):
if self.windowState() & Qt.WindowFullScreen:
QApplication.setOverrideCursor(Qt.ArrowCursor)
self.showNormal()
print("no Fullscreen")
else:
self.showFullScreen()
QApplication.setOverrideCursor(Qt.BlankCursor)
print("Fullscreen entered")
def handleInfo(self):
msg = QMessageBox.about(self, "QT5 Player", self.myinfo)
def toggleSlider(self):
if self.positionSlider.isVisible():
self.hideSlider()
else:
self.showSlider()
def hideSlider(self):
self.playButton.hide()
self.lbl.hide()
self.positionSlider.hide()
self.elbl.hide()
mwidth = self.frameGeometry().width()
mheight = self.frameGeometry().height()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
if self.widescreen == True:
self.setGeometry(mleft, mtop, mwidth, mwidth / 1.778)
else:
self.setGeometry(mleft, mtop, mwidth, mwidth / 1.33)
def showSlider(self):
self.playButton.show()
self.lbl.show()
self.positionSlider.show()
self.elbl.show()
mwidth = self.frameGeometry().width()
mheight = self.frameGeometry().height()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
if self.widescreen == True:
self.setGeometry(mleft, mtop, mwidth, mwidth / 1.55)
else:
self.setGeometry(mleft, mtop, mwidth, mwidth / 1.33)
def forwardSlider(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() + 1000 * 60)
def forwardSlider10(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() + 10000 * 60)
def backSlider(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() - 1000 * 60)
def backSlider10(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() - 10000 * 60)
def volumeUp(self):
self.mediaPlayer.setVolume(self.mediaPlayer.volume() + 10)
print("Volume: " + str(self.mediaPlayer.volume()))
def volumeDown(self):
self.mediaPlayer.setVolume(self.mediaPlayer.volume() - 10)
print("Volume: " + str(self.mediaPlayer.volume()))
def mouseMoveEvent(self, event):
if event.buttons() == Qt.LeftButton:
self.move(event.globalPos() \
- QPoint(self.frameGeometry().width() / 2, \
self.frameGeometry().height() / 2))
event.accept()
def dragEnterEvent(self, event):
if event.mimeData().hasUrls():
event.accept()
elif event.mimeData().hasText():
event.accept()
else:
event.ignore()
def dropEvent(self, event):
if event.mimeData().hasUrls():
url = event.mimeData().urls()[0].toString()
print("url = ", url)
self.mediaPlayer.stop()
self.mediaPlayer.setMedia(QMediaContent(QUrl(url)))
self.playButton.setEnabled(True)
self.mediaPlayer.play()
elif event.mimeData().hasText():
mydrop = event.mimeData().text()
### YouTube url
if "youtube" in mydrop:
print("is YouTube", mydrop)
self.clip.setText(mydrop)
self.getYTUrl()
else:
### normal url
print("generic url = ", mydrop)
self.mediaPlayer.setMedia(QMediaContent(QUrl(mydrop)))
self.playButton.setEnabled(True)
self.mediaPlayer.play()
self.hideSlider()
def loadFilm(self, f):
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(f)))
self.playButton.setEnabled(True)
self.mediaPlayer.play()
def printMediaData(self):
if self.mediaPlayer.mediaStatus() == 6:
if self.mediaPlayer.isMetaDataAvailable():
res = str(self.mediaPlayer.metaData("Resolution")).partition(
"PyQt5.QtCore.QSize(")[2].replace(", ",
" x ").replace(")", "")
print("%s%s" % ("Video Resolution = ", res))
else:
print("no metaData available")
def openFileAtStart(self, filelist):
matching = [s for s in filelist if ".myformat" in s]
if len(matching) > 0:
self.loadFilm(matching)
##################### update Label ##################################
def handleLabel(self):
self.lbl.clear()
mtime = QTime(0, 0, 0, 0)
self.time = mtime.addMSecs(self.mediaPlayer.position())
self.lbl.setText(self.time.toString())
class Window(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("Медиа плеер")
self.setGeometry(350, 100, 700, 500)
self.setWindowIcon(QIcon("Плеер.jpg"))
# обьект создания Медиа плеера
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
# создоем кнопку проигрования
self.playBtn = QPushButton()
# создает кнопку открытия
self.openBtn = QPushButton("Выберите видео")
# создаем гарячию клавишу выбора видео
self.shortcut = QShortcut(QKeySequence("Ctrl+O"), self)
# создаем горячию клавишу выхода
self.exit = QShortcut(QKeySequence("Esc"), self)
# создаем горячию клавишу проигрывания видео
self.playn = QShortcut(QKeySequence("Ctrl+ "), self)
# создаем палзунок видео
self.slider = QSlider(Qt.Horizontal)
# создаем лейбл
self.lebel = QLabel()
# создаем hbox
self.hboxLayot = QHBoxLayout()
# создаем vbox
self.vboxLayout = QVBoxLayout()
p = self.palette()
p.setColor(QPalette.Window, Qt.black)
self.setPalette(p)
self.init_ui()
self.show()
def init_ui(self):
# coздаем видео обьект или типо того
videowidget = QVideoWidget()
# настройка кнопку открытия
self.openBtn.clicked.connect(self.open_file)
# настраеваем кнопку проигрования
self.playBtn.setEnabled(False)
self.playBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playBtn.clicked.connect(self.play_video)
# настраеваем гарячию клавишу выбора видео
self.shortcut.activated.connect(self.open_file)
# настраеваем горячию клавишу выхода
self.exit.activated.connect(end)
# настраеваем горячию клавишу проигрывания видео
self.playn.activated.connect(self.play_video)
# настраеваем палзунок видео
self.slider.setRange(0, 0)
self.slider.sliderMoved.connect(self.set_position)
# настраеваем лейбл
self.lebel.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
# настройка hbox
self.hboxLayot.setContentsMargins(0, 0, 0, 0)
# создаем виджет hbox
self.hboxLayot.addWidget(self.openBtn)
self.hboxLayot.addWidget(self.playBtn)
self.hboxLayot.addWidget(self.slider)
# настройка vbox
self.vboxLayout.addWidget(videowidget)
self.vboxLayout.addLayout(self.hboxLayot)
self.vboxLayout.addWidget(self.lebel)
# сигнал в плеер
self.mediaPlayer.stateChanged.connect(self.mediastate_changed)
self.mediaPlayer.positionChanged.connect(self.position_changed)
self.mediaPlayer.durationChanged.connect(self.duration_ch)
self.setLayout(self.vboxLayout)
self.mediaPlayer.setVideoOutput(videowidget)
def open_file(self):
filename, _ = QFileDialog.getOpenFileName(self, "Открыть видео")
if filename != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(filename)))
self.playBtn.setEnabled(True)
def play_video(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediastate_changed(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def position_changed(self, position):
self.slider.setValue(position)
def duration_ch(self, duration):
self.slider.setRange(0, duration)
def set_position(self, position):
self.mediaPlayer.setPosition(position)
def handel_erroros(self):
self.playBtn.setEnabled(False)
self.label.setText("Фоталка: " + self.mediaPlayer.errorString())
class Player(QWidget):
fullScreenChanged = pyqtSignal(bool)
def __init__(self, playlist, parent=None):
super(Player, self).__init__(parent)
self.colorDialog = None
self.trackInfo = ""
self.statusInfo = ""
self.duration = 0
self.player = QMediaPlayer()
self.playlist = QMediaPlaylist()
self.player.setPlaylist(self.playlist)
self.player.durationChanged.connect(self.durationChanged)
self.player.positionChanged.connect(self.positionChanged)
self.player.metaDataChanged.connect(self.metaDataChanged)
self.playlist.currentIndexChanged.connect(self.playlistPositionChanged)
self.player.mediaStatusChanged.connect(self.statusChanged)
self.player.bufferStatusChanged.connect(self.bufferingProgress)
self.player.videoAvailableChanged.connect(self.videoAvailableChanged)
self.player.error.connect(self.displayErrorMessage)
self.videoWidget = VideoWidget()
self.player.setVideoOutput(self.videoWidget)
self.playlistModel = PlaylistModel()
self.playlistModel.setPlaylist(self.playlist)
self.playlistView = QListView()
self.playlistView.setModel(self.playlistModel)
self.playlistView.setCurrentIndex(
self.playlistModel.index(self.playlist.currentIndex(), 0))
self.playlistView.activated.connect(self.jump)
self.slider = QSlider(Qt.Horizontal)
self.slider.setRange(0, self.player.duration() / 1000)
self.labelDuration = QLabel()
self.slider.sliderMoved.connect(self.seek)
# self.labelHistogram = QLabel()
# self.labelHistogram.setText("Histogram:")
# self.histogram = HistogramWidget()
# histogramLayout = QHBoxLayout()
# histogramLayout.addWidget(self.labelHistogram)
# histogramLayout.addWidget(self.histogram, 1)
self.probe = QVideoProbe()
# self.probe.videoFrameProbed.connect(self.histogram.processFrame)
self.probe.setSource(self.player)
openButton = QPushButton("打开", clicked=self.open)
controls = PlayerControls()
controls.setState(self.player.state())
controls.setVolume(self.player.volume())
controls.setMuted(controls.isMuted())
controls.play.connect(self.player.play)
controls.pause.connect(self.player.pause)
controls.stop.connect(self.player.stop)
controls.next.connect(self.playlist.next)
controls.previous.connect(self.previousClicked)
controls.changeVolume.connect(self.player.setVolume)
controls.changeMuting.connect(self.player.setMuted)
controls.changeRate.connect(self.player.setPlaybackRate)
controls.stop.connect(self.videoWidget.update)
self.player.stateChanged.connect(controls.setState)
self.player.volumeChanged.connect(controls.setVolume)
self.player.mutedChanged.connect(controls.setMuted)
self.fullScreenButton = QPushButton("全屏")
self.fullScreenButton.setCheckable(True)
self.colorButton = QPushButton("颜色选项")
self.colorButton.setEnabled(False)
self.colorButton.clicked.connect(self.showColorDialog)
displayLayout = QHBoxLayout()
displayLayout.addWidget(self.videoWidget, 2)
displayLayout.addWidget(self.playlistView)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addStretch(1)
controlLayout.addWidget(controls)
controlLayout.addStretch(1)
controlLayout.addWidget(self.fullScreenButton)
controlLayout.addWidget(self.colorButton)
layout = QVBoxLayout()
layout.addLayout(displayLayout)
hLayout = QHBoxLayout()
hLayout.addWidget(self.slider)
hLayout.addWidget(self.labelDuration)
layout.addLayout(hLayout)
layout.addLayout(controlLayout)
# layout.addLayout(histogramLayout)
self.setLayout(layout)
if not self.player.isAvailable():
QMessageBox.warning(
self, "Service not available",
"The QMediaPlayer object does not have a valid service.\n"
"Please check the media service plugins are installed.")
controls.setEnabled(False)
self.playlistView.setEnabled(False)
openButton.setEnabled(False)
self.colorButton.setEnabled(False)
self.fullScreenButton.setEnabled(False)
self.metaDataChanged()
self.addToPlaylist(playlist)
def open(self):
fileNames, _ = QFileDialog.getOpenFileNames(self, "Open Files")
self.addToPlaylist(fileNames)
def addToPlaylist(self, fileNames):
for name in fileNames:
fileInfo = QFileInfo(name)
if fileInfo.exists():
url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
if fileInfo.suffix().lower() == 'm3u':
self.playlist.load(url)
else:
self.playlist.addMedia(QMediaContent(url))
else:
url = QUrl(name)
if url.isValid():
self.playlist.addMedia(QMediaContent(url))
def durationChanged(self, duration):
duration /= 1000
self.duration = duration
self.slider.setMaximum(duration)
def positionChanged(self, progress):
progress /= 1000
if not self.slider.isSliderDown():
self.slider.setValue(progress)
self.updateDurationInfo(progress)
def metaDataChanged(self):
if self.player.isMetaDataAvailable():
self.setTrackInfo(
"%s - %s" % (self.player.metaData(QMediaMetaData.AlbumArtist),
self.player.metaData(QMediaMetaData.Title)))
def previousClicked(self):
# Go to the previous track if we are within the first 5 seconds of
# playback. Otherwise, seek to the beginning.
if self.player.position() <= 5000:
self.playlist.previous()
else:
self.player.setPosition(0)
def jump(self, index):
if index.isValid():
self.playlist.setCurrentIndex(index.row())
self.player.play()
def playlistPositionChanged(self, position):
self.playlistView.setCurrentIndex(self.playlistModel.index(
position, 0))
def seek(self, seconds):
self.player.setPosition(seconds * 1000)
def statusChanged(self, status):
self.handleCursor(status)
if status == QMediaPlayer.LoadingMedia:
self.setStatusInfo("Loading...")
elif status == QMediaPlayer.StalledMedia:
self.setStatusInfo("Media Stalled")
elif status == QMediaPlayer.EndOfMedia:
QApplication.alert(self)
elif status == QMediaPlayer.InvalidMedia:
self.displayErrorMessage()
else:
self.setStatusInfo("")
def handleCursor(self, status):
if status in (QMediaPlayer.LoadingMedia, QMediaPlayer.BufferingMedia,
QMediaPlayer.StalledMedia):
self.setCursor(Qt.BusyCursor)
else:
self.unsetCursor()
def bufferingProgress(self, progress):
self.setStatusInfo("Buffering %d%" % progress)
def videoAvailableChanged(self, available):
if available:
self.fullScreenButton.clicked.connect(
self.videoWidget.setFullScreen)
self.videoWidget.fullScreenChanged.connect(
self.fullScreenButton.setChecked)
if self.fullScreenButton.isChecked():
self.videoWidget.setFullScreen(True)
else:
self.fullScreenButton.clicked.disconnect(
self.videoWidget.setFullScreen)
self.videoWidget.fullScreenChanged.disconnect(
self.fullScreenButton.setChecked)
self.videoWidget.setFullScreen(False)
self.colorButton.setEnabled(available)
def setTrackInfo(self, info):
self.trackInfo = info
if self.statusInfo != "":
self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo))
else:
self.setWindowTitle(self.trackInfo)
def setStatusInfo(self, info):
self.statusInfo = info
if self.statusInfo != "":
self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo))
else:
self.setWindowTitle(self.trackInfo)
def displayErrorMessage(self):
self.setStatusInfo(self.player.errorString())
def updateDurationInfo(self, currentInfo):
duration = self.duration
if currentInfo or duration:
currentTime = QTime((currentInfo / 3600) % 60,
(currentInfo / 60) % 60, currentInfo % 60,
(currentInfo * 1000) % 1000)
totalTime = QTime((duration / 3600) % 60, (duration / 60) % 60,
duration % 60, (duration * 1000) % 1000)
format = 'hh:mm:ss' if duration > 3600 else 'mm:ss'
tStr = currentTime.toString(format) + " / " + totalTime.toString(
format)
else:
tStr = ""
self.labelDuration.setText(tStr)
def showColorDialog(self):
if self.colorDialog is None:
brightnessSlider = QSlider(Qt.Horizontal)
brightnessSlider.setRange(-100, 100)
brightnessSlider.setValue(self.videoWidget.brightness())
brightnessSlider.sliderMoved.connect(
self.videoWidget.setBrightness)
self.videoWidget.brightnessChanged.connect(
brightnessSlider.setValue)
contrastSlider = QSlider(Qt.Horizontal)
contrastSlider.setRange(-100, 100)
contrastSlider.setValue(self.videoWidget.contrast())
contrastSlider.sliderMoved.connect(self.videoWidget.setContrast)
self.videoWidget.contrastChanged.connect(contrastSlider.setValue)
hueSlider = QSlider(Qt.Horizontal)
hueSlider.setRange(-100, 100)
hueSlider.setValue(self.videoWidget.hue())
hueSlider.sliderMoved.connect(self.videoWidget.setHue)
self.videoWidget.hueChanged.connect(hueSlider.setValue)
saturationSlider = QSlider(Qt.Horizontal)
saturationSlider.setRange(-100, 100)
saturationSlider.setValue(self.videoWidget.saturation())
saturationSlider.sliderMoved.connect(
self.videoWidget.setSaturation)
self.videoWidget.saturationChanged.connect(
saturationSlider.setValue)
layout = QFormLayout()
layout.addRow("亮度", brightnessSlider)
layout.addRow("对比度", contrastSlider)
layout.addRow("色调", hueSlider)
layout.addRow("饱和度", saturationSlider)
button = QPushButton("关闭")
layout.addRow(button)
self.colorDialog = QDialog(self)
self.colorDialog.setWindowTitle("颜色选项")
self.colorDialog.setLayout(layout)
button.clicked.connect(self.colorDialog.close)
self.colorDialog.show()
class AudioWindow(QMainWindow):
def __init__(self, parent=None):
super(AudioWindow, self).__init__(parent)
self.setWindowTitle("Flac player")
self.mediaPlayer = QMediaPlayer()
self.file_info = None
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.volumeSlider = QSlider(Qt.Vertical)
self.volumeSlider.setRange(0, 0)
self.volumeSlider.setValue(100)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.volumeSlider.sliderMoved.connect(self.setVolume)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
self.info_window = InfoWindow(self.file_info)
# Create new action
openAction = QAction(QIcon('open.png'), '&Open', self)
openAction.setShortcut('Ctrl+O')
openAction.setStatusTip('Open flac file')
openAction.triggered.connect(self.openFile)
# Create exit action
exitAction = QAction(QIcon('exit.png'), '&Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(self.exitCall)
self.infoAction = QAction('&File info', self)
self.infoAction.setStatusTip('Show file info')
self.infoAction.triggered.connect(self.showInfo)
self.infoAction.setEnabled(False)
# Create menu bar and add action
menuBar = self.menuBar()
fileMenu = menuBar.addMenu('&File')
fileMenu.addAction(self.infoAction)
fileMenu.addAction(openAction)
fileMenu.addAction(exitAction)
# Create a widget for window contents
wid = QWidget(self)
self.setCentralWidget(wid)
# Create layouts to place inside widget
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
controlLayout.addWidget(self.volumeSlider)
layout = QVBoxLayout()
layout.addLayout(controlLayout)
layout.addWidget(self.errorLabel)
# Set widget to contain window contents
wid.setLayout(layout)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.volumeChanged.connect(self.volumeChanged)
self.mediaPlayer.error.connect(self.handleError)
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open flac file",
QDir.homePath())
if fileName != '':
try:
self.file_info = AudioFile(fileName)
except ValueError:
self.infoAction.setEnabled(False)
self.errorLabel.setText('Error: file is not flac')
self.mediaPlayer.setMedia(QMediaContent())
self.playButton.setEnabled(False)
self.volumeSlider.setRange(0, 0)
else:
self.infoAction.setEnabled(True)
self.volumeSlider.setRange(0, 100)
self.volumeSlider.setValue(100)
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.errorLabel.setText('')
self.playButton.setEnabled(True)
def exitCall(self):
sys.exit(app.exec_())
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def volumeChanged(self, volume):
self.volumeSlider.setValue(volume)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def setVolume(self, volume):
self.mediaPlayer.setVolume(volume)
def handleError(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
def showInfo(self):
self.info_window = InfoWindow(self.file_info)
self.info_window.show()
class VideoWindow(QMainWindow):
def __init__(self, app, parent=None):
super(VideoWindow, self).__init__(parent)
self.app = app
self.setWindowTitle("sofa")
self.setWindowIcon(QIcon('src/static/img/tofu.png'))
self.rate = 1
self.isNewMark = False
self.openedFile = None
self.initUI()
self.set_default_shortcuts()
self.shortcuts = {}
self.comm = SignalBus.instance()
def initUI(self):
videoWidget = self.create_player()
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
self.create_menu_bar()
self.wid = QWidget(self)
self.setCentralWidget(self.wid)
self.set_layout(videoWidget, self.wid)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
def create_player(self):
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
videoWidget = QVideoWidget()
self.clipsWidget = BadClipsWidget()
self.create_control()
self.playButton.clicked.connect(self.play)
self.speedUpButton.clicked.connect(self.speed)
self.slowDownButton.clicked.connect(self.slow)
self.adv3Button.clicked.connect(partial(self.advance, 3))
self.goBack3Button.clicked.connect(partial(self.back, 3))
self.advanceButton.clicked.connect(partial(self.advance, 10))
self.goBackButton.clicked.connect(partial(self.back, 10))
self.positionSlider.sliderMoved.connect(self.setPosition)
self.cutButton.clicked.connect(self.createMark)
return videoWidget
def set_default_shortcuts(self):
self.playButton.setShortcut(QKeySequence(Qt.Key_Space))
self.speedUpButton.setShortcut(QKeySequence(Qt.Key_Up))
self.slowDownButton.setShortcut(QKeySequence(Qt.Key_Down))
self.advanceButton.setShortcut(QKeySequence(Qt.Key_Right))
self.goBackButton.setShortcut(QKeySequence(Qt.Key_Left))
self.cutButton.setShortcut(QKeySequence(Qt.Key_C))
def create_control(self):
self.playButton = _create_button(
self.style().standardIcon(QStyle.SP_MediaPlay))
self.speedUpButton = _create_button(
self.style().standardIcon(QStyle.SP_MediaSeekForward))
self.slowDownButton = _create_button(
self.style().standardIcon(QStyle.SP_MediaSeekBackward))
self.adv3Button = _create_button(
self.style().standardIcon(QStyle.SP_ArrowRight))
self.advanceButton = _create_button(
self.style().standardIcon(QStyle.SP_MediaSkipForward))
self.goBack3Button = _create_button(
self.style().standardIcon(QStyle.SP_ArrowLeft))
self.goBackButton = _create_button(
self.style().standardIcon(QStyle.SP_MediaSkipBackward))
self.cutButton = _create_button(self.style().standardIcon(
QStyle.SP_MessageBoxCritical))
self.timeBox = QLabel(format_time(0), self)
self.timeBox.setAlignment(Qt.AlignCenter)
self.rateBox = QLabel(str(self.rate) + 'x', self)
self.rateBox.setAlignment(Qt.AlignCenter)
self.hlightSliderTips = HlightSliderTipsWidget()
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
def create_menu_bar(self):
openAction = create_action('open.png', '&Open', 'Ctrl+O', 'Open video',
self.openFile, self)
saveAction = create_action('save.png', '&Save Clips', 'Ctrl+S',
'Save anonimized clips', self.saveClips, self)
exitAction = create_action('exit.png', '&Exit', 'Ctrl+Q', 'Exit',
self.exitCall, self)
menuBar = self.menuBar()
fileMenu = menuBar.addMenu('&File')
fileMenu.addAction(openAction)
fileMenu.addAction(saveAction)
fileMenu.addAction(exitAction)
def set_layout(self, videoWidget, wid):
labellingLayout = QVBoxLayout()
labellingLayout.addWidget(self.clipsWidget)
controlLayout = self.make_control_layout()
videoAreaLayout = QVBoxLayout()
videoWidget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
videoAreaLayout.addWidget(videoWidget)
videoAreaLayout.addLayout(controlLayout)
videoAreaLayout.addWidget(self.errorLabel)
layout = QHBoxLayout()
layout.addLayout(videoAreaLayout, 4)
layout.addLayout(labellingLayout)
wid.setLayout(layout)
def make_control_layout(self):
buttonsLayout = QHBoxLayout()
buttonsLayout.setContentsMargins(0, 0, 0, 0)
buttonsLayout.addWidget(self.timeBox)
buttonsLayout.addWidget(self.slowDownButton)
buttonsLayout.addWidget(self.goBackButton)
buttonsLayout.addWidget(self.goBack3Button)
buttonsLayout.addWidget(self.playButton)
buttonsLayout.addWidget(self.adv3Button)
buttonsLayout.addWidget(self.advanceButton)
buttonsLayout.addWidget(self.speedUpButton)
buttonsLayout.addWidget(self.rateBox)
cutLayout = QHBoxLayout()
cutLayout.setContentsMargins(0, 0, 0, 0)
cutLayout.addSpacerItem(QSpacerItem(200, 5, QSizePolicy.Minimum,
QSizePolicy.Minimum))
cutLayout.addWidget(self.cutButton)
cutLayout.addSpacerItem(QSpacerItem(200, 5, QSizePolicy.Minimum,
QSizePolicy.Minimum))
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.positionSlider)
layout.addWidget(self.hlightSliderTips)
layout.addLayout(buttonsLayout)
layout.addLayout(cutLayout)
return layout
def openFile(self):
self.rawFileName, _ = QFileDialog.getOpenFileName(self, "Open video",
QDir.homePath())
if self.rawFileName != '':
should_process = QMessageBox.question(self.wid, 'Open video',
'Do you want to pre process the video?',
QMessageBox.Yes | QMessageBox.No)
if should_process == QMessageBox.Yes:
self.fileName = TMP_VIDEO_PATH
process = ProcVideoDialog(self.rawFileName, self.fileName, self)
self.comm.videoProcessed.connect(self.openMedia)
else:
self.fileName = self.rawFileName
self.processMetaData()
self.openMedia()
def processMetaData(self):
'''
Get array indicating "suspicious" frames
'''
# open metadata file
self.metaDataFile = self.fileName.rsplit(".", 1)[0] + ".csv"
# get only the array with "colors" (==0: green; !=0: red)
self.colorsArray = get_metadata_colors(self.metaDataFile)
self.hlightSliderTips.setColorsArray(self.colorsArray, useYellow=False)
@pyqtSlot()
def openMedia(self):
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(self.fileName)))
self.openedFile = os.path.basename(self.fileName)
self.setWindowTitle("sofa - " + self.openedFile)
self.playButton.setEnabled(True)
self.speedUpButton.setEnabled(True)
self.slowDownButton.setEnabled(True)
self.advanceButton.setEnabled(True)
self.adv3Button.setEnabled(True)
self.goBackButton.setEnabled(True)
self.goBack3Button.setEnabled(True)
self.cutButton.setEnabled(True)
self.rate = 1
def exitCall(self):
if self.openedFile is not None:
os.remove(self.fileName)
sys.exit(self.app.exec_())
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def slow(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.rate -= 0.5
# TODO: Workaround pt 1
# https://forum.qt.io/topic/88490/change-playback-rate-at-...
# ...runtime-problem-with-position-qmediaplayer/8
currentPos = self.mediaPlayer.position()
# TODO: Workaround pt 1
self.mediaPlayer.setPlaybackRate(self.rate)
# TODO: Workaround pt 2
self.mediaPlayer.setPosition(currentPos)
# TODO: Workaround pt 2: end
self.rateBox.setText(str(self.rate)+'x')
def speed(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.rate += 0.5
# TODO: Workaround pt 1
# https://forum.qt.io/topic/88490/change-playback-rate-at-...
# ...runtime-problem-with-position-qmediaplayer/8
currentPos = self.mediaPlayer.position()
# TODO: Workaround pt 1
self.mediaPlayer.setPlaybackRate(self.rate)
# TODO: Workaround pt 2
self.mediaPlayer.setPosition(currentPos)
# TODO: Workaround pt 2: end
self.rateBox.setText(str(self.rate)+'x')
def advance(self, t=10):
currentPos = self.mediaPlayer.position()
nextPos = currentPos + t*1000
self.setPosition(nextPos)
def back(self, t=10):
currentPos = self.mediaPlayer.position()
nextPos = max(currentPos - t*1000, 0)
self.setPosition(nextPos)
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
self.hlightSliderTips.setValue(position)
self.timeBox.setText(format_time(int(position/1000)))
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
self.hlightSliderTips.setRange(duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
self.speedUpButton.setEnabled(False)
self.slowDownButton.setEnabled(False)
self.advanceButton.setEnabled(False)
self.goBackButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
def saveClips(self):
prefix = os.path.splitext(os.path.basename(self.rawFileName))[0] + \
'_slice_'
dirPath = QFileDialog.getExistingDirectory(self, 'Select Dir')
if dirPath != '':
try:
self.errorLabel.setText('Saving clips... please wait')
video = VideoFileClip(self.fileName)
marks = self.clipsWidget.get_marks()
begin_time = 0.0
for i, m in enumerate(marks):
end_time = float(m[0])
out_path = os.path.join(dirPath, prefix+str(i)+".mp4")
clip = video.subclip(begin_time, end_time)
clip.write_videofile(out_path)
begin_time = float(m[1])
end_video = self.mediaPlayer.duration()/1000
if begin_time < end_video and len(marks) > 0:
i = len(marks)
out_path = os.path.join(dirPath, prefix+str(i)+".mp4")
clip = video.subclip(begin_time)
clip.write_videofile(out_path)
self.errorLabel.setText('Clips saved at ' + dirPath)
QMessageBox.information(self.wid, 'Sucess',
'Clips succesfully saved')
except:
self.errorLabel.setText('Error: Could not save file.')
QMessageBox.warning(self.wid, 'Error',
'Could not save file. Check permissions')
@pyqtSlot()
def createMark(self):
state = self.mediaPlayer.state()
if state == QMediaPlayer.PlayingState or state == \
QMediaPlayer.PausedState:
self.clipsWidget.new_mark(self.mediaPlayer.position()/1000,
self.isNewMark)
self.isNewMark = not self.isNewMark
class VideoWindow(QMainWindow):
def __init__(self, parent=None):
super(VideoWindow, self).__init__(parent)
self.setWindowTitle("Media-Player")
self.resize(1900, 1000)
self.frame_counter = 0
self.volume = 0
self.setStyleSheet("background-color: rgb(0, 0, 0);\n"
"color: rgb(255, 170, 0);\n"
"")
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoWidget = QVideoWidget()
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setStyleSheet(
"background-color: rgb(85, 0, 0); color: rgb(255, 0, 0)")
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
# Create new action
openAction = QAction(QIcon('open.png'), '&Open', self)
openAction.setShortcut('Ctrl+O')
openAction.setStatusTip('Open movie')
openAction.triggered.connect(self.openFile)
# Create exit action
exitAction = QAction(QIcon('exit.png'), '&Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(self.exitCall)
saveAction = QAction(QIcon('save.png'), '&Save', self)
saveAction.setShortcut('Ctrl+S')
saveAction.setStatusTip('Take Screenshot')
saveAction.triggered.connect(self.saveCall)
# Create menu bar and add action
menuBar = self.menuBar()
fileMenu = menuBar.addMenu('&File')
screenshotMenu = menuBar.addMenu('&Screenshot')
#fileMenu.addAction(newAction)
fileMenu.addAction(openAction)
fileMenu.addAction(exitAction)
screenshotMenu.addAction(saveAction)
# Create a widget for window contents
wid = QWidget(self)
self.setCentralWidget(wid)
# Create layouts to place inside widget
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(self.videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.errorLabel)
# Set widget to contain window contents
wid.setLayout(layout)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
QDir.homePath())
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
def exitCall(self):
sys.exit(app.exec_())
def saveCall(self):
self.grabber = VideoFrameGrabber(self.videoWidget, self)
self.mediaPlayer.setVideoOutput(self.grabber)
self.grabber.frame_available.connect(self.save_frame)
def save_frame(self, frame: QImage):
self.frame_counter += 1
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.pause()
if frame is None:
return
frame.save("C:\\Video-Player\\Screenshots\\screenshot" +
str(self.frame_counter) + ".jpg")
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
class VideoPlayer(QWidget):
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
videoWidget = QVideoWidget()
openButton = QPushButton("Open...")
openButton.clicked.connect(self.openFile)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.errorLabel)
self.setLayout(layout)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
QDir.homePath())
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
class Window(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("PyQt5 Media Player")
self.setGeometry(350, 100, 700, 500)
self.setWindowIcon(QIcon('player.png'))
p = self.palette()
p.setColor(QPalette.Window, Qt.black)
self.setPalette(p)
self.init_ui()
self.show()
def init_ui(self):
#create media player object
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
#create videowidget object
videowidget = QVideoWidget()
#create open button
openBtn = QPushButton('Open Video')
openBtn.clicked.connect(self.open_file)
#create button for playing
self.playBtn = QPushButton()
self.playBtn.setEnabled(False)
self.playBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playBtn.clicked.connect(self.play_video)
#create slider
self.slider = QSlider(Qt.Horizontal)
self.slider.setRange(0, 0)
self.slider.sliderMoved.connect(self.set_position)
#create label
self.label = QLabel()
self.label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
#################################
#create image extraction button
imgBtn = QPushButton('Image extraction')
imgBtn.clicked.connect(self.image_extract)
#################################
#create hbox layout
hboxLayout = QHBoxLayout()
hboxLayout.setContentsMargins(0, 0, 0, 0)
#set widgets to the hbox layout
hboxLayout.addWidget(openBtn)
hboxLayout.addWidget(imgBtn)
hboxLayout.addWidget(self.playBtn)
hboxLayout.addWidget(self.slider)
#create vbox layout
vboxLayout = QVBoxLayout()
vboxLayout.addWidget(videowidget)
vboxLayout.addLayout(hboxLayout)
vboxLayout.addWidget(self.label)
self.setLayout(vboxLayout)
self.mediaPlayer.setVideoOutput(videowidget)
#media player signals
self.mediaPlayer.stateChanged.connect(self.mediastate_changed)
self.mediaPlayer.positionChanged.connect(self.position_changed)
self.mediaPlayer.durationChanged.connect(self.duration_changed)
def open_file(self):
filename, _ = QFileDialog.getOpenFileName(self, "Open Video")
if filename != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(filename)))
self.playBtn.setEnabled(True)
def play_video(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediastate_changed(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def position_changed(self, position):
self.slider.setValue(position)
def duration_changed(self, duration):
self.slider.setRange(0, duration)
def set_position(self, position):
self.mediaPlayer.setPosition(position)
def handle_errors(self):
self.playBtn.setEnabled(False)
self.label.setText("Error: " + self.mediaPlayer.errorString())
def image_extract(self):
filename = QFileDialog.getOpenFileName(self)
cap = cv2.VideoCapture(filename)
maxVariance = 0
maxFrame = 0
while (True):
ret, frame = cap.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
m, sd = cv2.meanStdDev(gray)
variance = sd * sd
if variance > maxVariance:
maxVariance = variance
maxFrame = frame
label = QLabel
label.setText('Current variance: ' + variance +
'\nMaximum variance: ' + maxVariance)
vbox = QVBoxLayout()
vbox.addWidget(label)
cap.release()
class MainWidget(QWidget):
def __init__(self):
super(MainWidget, self).__init__()
self._blur = QGraphicsBlurEffect()
self._blur.setBlurRadius(0)
self.image = ImageView()
self.image.setGraphicsEffect(self._blur)
self.video = QVideoWidget()
self.label = QLabel()
self.label.setMaximumHeight(25)
self.label.setStyleSheet('color: rgb(200, 200, 200);')
font = QFont()
font.setPixelSize(20)
font.setWeight(QFont.Bold)
self.label.setFont(font)
self.setLayout(QVBoxLayout())
self.layout().addWidget(self.image)
self.layout().addWidget(self.video)
self.layout().addWidget(self.label)
self.mplayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mplayer.setVideoOutput(self.video)
self.mplayer.error.connect(
lambda: print("Video:", self.mplayer.errorString()))
self.mplayer.mediaStatusChanged.connect(self.state_changed)
self.overlay = QLabel(self)
self.overlay.setFrameStyle(Qt.FramelessWindowHint)
self.overlay.setStyleSheet(
'background-color: rgba(0,0,0,0.7); color: rgba(200,200,200,1);')
self.overlay.setFont(font)
self.overlay.setVisible(False)
self.overlay.setWordWrap(True)
def resize(self):
self.overlay.setGeometry(0, 3 * self.height() // 4 - 50, self.width(),
100)
def resizeEvent(self, event):
super().resizeEvent(event)
self.resize()
def state_changed(self, state):
if state == QMediaPlayer.EndOfMedia:
self.mplayer.setPosition(0)
self.mplayer.play()
@property
def blur(self):
return self._blur.blurRadius()
@blur.setter
def blur(self, value):
self._blur.setBlurRadius(value)
def load(self, pic, *args, **kwargs):
if isinstance(pic, str):
still = path.splitext(pic)[1].lower()[1:] not in ('webm', 'mp4')
else:
still = pic.is_still if pic else True
if still:
self.image.load(pic, *args, **kwargs)
self.video.hide()
self.image.show()
self.mplayer.stop()
else:
url = pic if isinstance(pic, str) else pic.filename
self.mplayer.setMedia(QMediaContent(QUrl.fromLocalFile(url)))
self.mplayer.setMuted(True)
self.mplayer.play()
self.image.hide()
self.video.show()
self.overlay.setVisible(False)
def message(self, msg):
self.label.setText('<div align="center">{}</div>'.format(msg))
def flash(self, msg):
self.overlay.setText('<div align="center">{}</div>'.format(msg))
self.overlay.setVisible(True)
def halt(self):
self.mplayer.stop()
class VideoWindow(QWidget):
sigTimeChanged = pyqtSignal(object)
def __init__(self, project=None, parent=None):
super(VideoWindow, self).__init__(parent)
self.project = project
self.setWindowTitle("Video")
self.mediaPlayer = QMediaPlayer() #None, QMediaPlayer.VideoSurface)
self.last_position = 0
self.position_on_new_file = 0
self.duration = -1
self.waiting_for_file = False
self.media_state_before_file_transition = self.mediaPlayer.state()
self.video_time_offset = 0.0
self.play_icon = QIcon(play_icon_file)
self.clock_icon = QIcon(clock_icon_file)
self.pause_icon = QIcon(pause_icon_file)
videoWidget = QVideoWidget()
self.videoWidget = videoWidget
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.play_icon)
self.playButton.clicked.connect(self.play)
self.timeOffsetButton = QPushButton()
self.timeOffsetButton.setIcon(self.clock_icon)
self.timeOffsetButton.clicked.connect(self.setTimeOffset)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Maximum)
# Create layouts to place inside widget
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(self.timeOffsetButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.errorLabel) # Hide error Label
# Set widget to contain window contents
self.setLayout(layout)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.mediaStatusChanged.connect(self.mediaStatusChanged)
self.mediaPlayer.error.connect(self.handleError)
self.mediaPlayer.setNotifyInterval(40) # 25 fps
if self.project is None:
self.current_time_range = [0, 0]
self.current_file = ''
# self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(self.current_file)))
# self.playButton.setEnabled(True)
# self.mediaPlayer.play()
elif self.project.current_animal.video_files:
self.current_file = self.project.current_animal.video_files[0]
self.current_time_range = [
self.project.current_animal.video_init_time[0],
self.project.current_animal.video_init_time[0] +
self.project.current_animal.video_duration[0]
]
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(self.current_file)))
self.playButton.setEnabled(True)
else:
self.current_file = ''
self.current_time_range = [0, 0]
def setTimeOffset(self):
offset, okpressed = QInputDialog.getDouble(
self,
'Video time offset',
'Offset video time position (seconds)',
value=self.video_time_offset)
if okpressed:
self.video_time_offset = offset
current_position = self.current_time_range[
0] + self.last_position / 1000
self.setGlobalPosition(0)
self.setGlobalPosition(current_position)
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
QDir.homePath())
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
def exitCall(self):
sys.exit(app.exec_())
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.pause_icon)
else:
self.playButton.setIcon(self.play_icon)
def positionChanged(self, position):
# Connected to video player
# print('positionChanged',position,self.last_position,self.waiting_for_file,self.duration,self.current_time_range)
# if self.duration == -1:
# print('positionChanged: no file - duration ==-1')
# return
# if self.waiting_for_file:
# print('positionChanged: Waiting to load file')
# return
# if position == 0:
# print('positionChanged: avoiding setting positions to 0')
# return
if position == 0 or self.waiting_for_file or self.duration == -1 or position == self.last_position:
# avoid position changes on file transitions or repeated signals on same position
return
if position < self.duration - 40: # avoid time changes when switching files
self.last_position = position
self.positionSlider.setValue(position)
self.sigTimeChanged.emit(position / 1000 +
self.current_time_range[0])
else: # position is at the end of file - try to switch to next file
pos = self.current_time_range[1] + .04
print('Trying to jump to next file', self.current_time_range[1],
self.duration, pos)
self.setGlobalPosition(pos)
def durationChanged(self, duration):
# print('duration changed',duration)
self.duration = duration
self.positionSlider.setRange(0, duration)
self.mediaPlayer.setPosition(
self.position_on_new_file
) # if duration changes avoid the position going back to 0
def setPosition(self, position):
# connected to slider
# print('setPosition',position)
self.mediaPlayer.setPosition(
position) # milliseconds since the beginning of the media
def setGlobalPosition(self, pos):
# Connected to project main model sigTimeChanged
# open the right media
if self.current_time_range[0] <= pos <= self.current_time_range[
1]: # correct file opened
position = int((pos - self.current_time_range[0]) * 1000)
if self.mediaPlayer.state() == QMediaPlayer.PlayingState and abs(
position - self.last_position) < 200:
# skip position setting by signal of main model to ensure smooth video plaback
return
# go to correct relative position
self.mediaPlayer.setPosition(position) # UNIX time
return
else:
for i, file in enumerate(self.project.current_animal.video_files
): # search for file to open
arange = [
self.project.current_animal.video_init_time[i] +
self.video_time_offset,
self.project.current_animal.video_init_time[i] +
self.project.current_animal.video_duration[i] +
self.video_time_offset
]
if (arange[0] <= pos <= arange[1]):
print('Changing video file: ', file)
self.current_file = file
self.errorLabel.setText("File: " + self.current_file)
self.current_time_range = arange
self.waiting_for_file = True
self.media_state_before_file_transition = self.mediaPlayer.state(
)
self.mediaPlayer.stop()
position = (pos - self.current_time_range[0]) * 1000
self.position_on_new_file = int(position)
# print('Changing position_on_new_file: ', self.position_on_new_file,pos)
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(file)))
self.playButton.setEnabled(True)
# self.duration = (arange[1]-arange[0])*1000
return
print('no video file found for current position')
self.errorLabel.setText("No video file found for current position")
self.mediaPlayer.stop()
self.mediaPlayer.setMedia(QMediaContent())
self.current_file = ''
self.current_time_range = [0, 0]
# self.duration = 0
self.playButton.setEnabled(False)
self.positionSlider.setRange(0, 0)
self.positionSlider.setValue(0)
def mediaStatusChanged(self, status):
if self.waiting_for_file:
if self.mediaPlayer.mediaStatus() == QMediaPlayer.LoadedMedia:
self.waiting_for_file = False
# print('finished loading file')
# self.mediaPlayer.stop()
self.mediaPlayer.setPosition(self.position_on_new_file)
self.mediaPlayer.play()
time.sleep(.05)
self.mediaPlayer.pause()
if self.media_state_before_file_transition == QMediaPlayer.PlayingState:
self.mediaPlayer.play()
# print('finished setting position on new file')
def handleError(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
print("Video - Error: " + self.mediaPlayer.errorString())
class VideoWindow(QMainWindow):
start_time = 0.0
def __init__(self, parent=None):
super(VideoWindow, self).__init__(parent)
self.setWindowTitle("Video")
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
videoWidget = QVideoWidget()
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
# Create new action
openAction = QAction(QIcon('open.png'), '&Open', self)
openAction.setShortcut('Ctrl+O')
openAction.setStatusTip('Open movie')
openAction.triggered.connect(self.openFile)
# Create exit action
exitAction = QAction(QIcon('exit.png'), '&Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(self.exitCall)
# Create menu bar and add action
menuBar = self.menuBar()
fileMenu = menuBar.addMenu('&File')
#fileMenu.addAction(newAction)
fileMenu.addAction(openAction)
fileMenu.addAction(exitAction)
# Create a widget for window contents
wid = QWidget(self)
self.setCentralWidget(wid)
start_time = time.time()
# Create side layout
mainLayout = QHBoxLayout()
self.label = QtWidgets.QLabel("Faces: ")
self.label.setObjectName("label")
self.label_2 = QtWidgets.QLabel("Total: ")
self.label_2.setObjectName("label_2")
self.label_3 = QtWidgets.QLabel("Tempo: %.2f" %
(time.time() - start_time))
self.label_3.setObjectName("label_3")
self.label_4 = QtWidgets.QLabel("")
self.label_4.setObjectName("Duração: ")
sideLayout = QVBoxLayout()
sideLayout.setContentsMargins(0, 50, 0, 130)
sideLayout.addWidget(self.label)
sideLayout.addWidget(self.label_2)
sideLayout.addWidget(self.label_3)
sideLayout.addWidget(self.label_4)
# Create layouts to place inside widget
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.setContentsMargins(150, 20, 20, 50)
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.errorLabel)
mainLayout.addLayout(sideLayout)
mainLayout.addLayout(layout)
# Set widget to contain window contents
wid.setLayout(mainLayout)
#wid.setLayout(sideLayout)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
QDir.homePath())
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
def exitCall(self):
sys.exit(app.exec_())
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
class Player(QWidget):
muted = muted
auto_play = auto_play
full_screen = full_screen
model = Movies
session = session
def __init__(self):
super().__init__()
self.setGeometry(0, 0, 1560, 300)
from core.view import BaseView
self.base_view = BaseView([], self)
p = self.palette()
p.setColor(QPalette.Window, Qt.black)
self.setPalette(p)
def run_window(self):
self.base_view.set_data(self.id)
self.set_setings()
self.data = self.base_view.data
self.init_ui()
self.show()
self.setWindowTitle(self.data.name)
def set_star(self, stars, id):
Star = None
for star_array in stars:
if star_array.id == id:
Star = star_array
return Star
def set_setings(self):
self.save_setings()
with open('player_setings.JSON') as setings:
data = json.load(setings)
self.muted = data['muted']
self.auto_play = data['auto_play']
self.full_screen = data['full_screen']
def save_setings(self):
array = {
"muted": self.muted,
"auto_play": self.auto_play,
"full_screen": self.full_screen
}
json_array = json.dumps(array)
if Path('player_setings.JSON').is_file() is False:
f = open('player_setings.JSON', "x")
f.write(json_array)
f.close()
def set_player(self):
if self.muted:
self.mute_clicked()
if self.auto_play:
self.play_video()
if self.full_screen:
self.full_screen_switch()
def init_ui(self):
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(self.data.src)))
videowidget = QVideoWidget()
self.playBtn = QPushButton()
self.playBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playBtn.clicked.connect(self.play_video)
self.slider = QSlider(Qt.Horizontal)
self.slider.setRange(0, 0)
self.slider.sliderMoved.connect(self.set_position)
self.show_full_screen_button = QPushButton('Full Screen')
self.show_full_screen_button.clicked.connect(self.full_screen_switch)
self.movie_info_button = QPushButton('Movie')
self.movie_info_button.clicked.connect(self.movie_info)
if self.data.series:
self.series_info_button = QPushButton('Series')
self.series_info_button.clicked.connect(self.series_info)
self.mute = QPushButton()
self.mute.setIcon(self.style().standardIcon(QStyle.SP_MediaVolume))
self.mute.clicked.connect(self.mute_clicked)
self.label = QLabel()
self.label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
hboxLayout = QHBoxLayout()
hboxLayout.setContentsMargins(20, 20, 20, 10)
hboxLayout.addWidget(self.playBtn)
hboxLayout.addWidget(self.slider)
hboxLayout.addWidget(self.mute)
hboxLayout.addWidget(self.movie_info_button)
if self.data.series:
hboxLayout.addWidget(self.series_info_button)
hboxLayout.addWidget(self.show_full_screen_button)
self.set_player()
self.hboxLayout2 = QHBoxLayout()
self.hboxLayout2.setContentsMargins(10, 10, 10, 10)
self.buttons_stars = QButtonGroup()
self.buttons_series = QButtonGroup()
self.add_grup_movies_buttons()
# create vbox layout
vboxLayout = QVBoxLayout()
vboxLayout.addWidget(videowidget)
vboxLayout.addLayout(hboxLayout)
vboxLayout.addLayout(self.hboxLayout2)
vboxLayout.addWidget(self.label)
self.setLayout(vboxLayout)
self.mediaPlayer.setVideoOutput(videowidget)
# media player signals
self.mediaPlayer.stateChanged.connect(self.mediastate_changed)
self.mediaPlayer.positionChanged.connect(self.position_changed)
self.mediaPlayer.durationChanged.connect(self.duration_changed)
def series_info(self):
self.base_view.load_view('series', self.data.series[0])
def movie_info(self):
self.base_view.load_view('movies', self.data)
def buttom_genarator(self, list, fuction, id):
for button in list.buttons():
if button is list.button(id):
fuction(button.data)
def on_movies_series_play(self, id):
self.buttom_genarator(self.buttons_series, self.next_series, id)
def on_movies_star_play(self, id):
self.buttom_genarator(self.buttons_stars, self.next_star, id)
def add_grup_movies_buttons(self):
self.button_series = [
{
'button': self.on_movies_series_play,
'obejct': self.buttons_series
},
]
index = 0
for series in self.data.series:
button = QPushButton('next video in series ' + str(series))
self.hboxLayout2.addWidget(button)
button.data = series
self.button_series[0]['obejct'].addButton(button)
self.button_series[0]['obejct'].buttonClicked[int].connect(
self.button_series[0]['button'])
index = index + 1
self.buttons_star = [
{
'button': self.on_movies_star_play,
'obejct': self.buttons_stars
},
]
index = 0
for star in self.data.stars:
if len(star.movies) > 3:
button = QPushButton('next video with star ' + str(star))
self.hboxLayout2.addWidget(button)
button.data = star
self.buttons_star[0]['obejct'].addButton(button)
self.buttons_star[0]['obejct'].buttonClicked[int].connect(
self.buttons_star[0]['button'])
index = index + 1
def mute_clicked(self):
if self.mediaPlayer.isMuted() is False:
icon = QStyle.SP_MediaVolumeMuted
self.mediaPlayer.setMuted(True)
self.muted = True
else:
icon = QStyle.SP_MediaVolume
self.mediaPlayer.setMuted(False)
self.muted = False
self.mute.setIcon(self.style().standardIcon(icon))
def next_series(self, series):
movies_in_series = self.data.series[0].movies
self.close()
self.base_view.load_view('play', self.faind_item(movies_in_series))
def next_star(self, star):
star = self.set_star(self.data.stars, star.id)
movies_with_star = star.movies
self.close()
self.base_view.load_view('play', self.faind_item(movies_with_star))
def faind_item(self, array):
def faind_item_greater_then_actual_item(array, math_index):
index_item = 0
for item in array:
if index_item > math_index:
return index_item
elif math_index == len(array) - 1:
return 0
index_item = index_item + 1
math_index = ''
index_in_array = 0
for item in array:
if self.data.id == item.id:
math_index = index_in_array
index_in_array = index_in_array + 1
next_item = faind_item_greater_then_actual_item(array, math_index)
return array[next_item]
def full_screen_switch(self):
if self.isFullScreen() is False:
self.showFullScreen()
self.full_screen = True
else:
self.showNormal()
self.full_screen = False
def mute_switch(self):
self.changeMuting.emit(not self.muted)
def play_video(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediastate_changed(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
icon = QStyle.SP_MediaPause
else:
icon = QStyle.SP_MediaPlay
self.playBtn.setIcon(self.style().standardIcon(icon))
def position_changed(self, position):
self.slider.setValue(position)
def duration_changed(self, duration):
self.slider.setRange(0, duration)
def set_position(self, position):
self.mediaPlayer.setPosition(position)
def handle_errors(self):
self.playBtn.setEnabled(False)
self.label.setText("Error: " + self.mediaPlayer.errorString())
def closeEvent(self, QCloseEvent):
os.remove("player_setings.JSON")
self.save_setings()
self.mediaPlayer.stop()
class Player(QWidget):
fullScreenChanged = pyqtSignal(bool)
def __init__(self, playlist, parent=None):
super(Player, self).__init__(parent)
self.colorDialog = None
self.trackInfo = ""
self.statusInfo = ""
self.duration = 0
self.player = QMediaPlayer()
self.playlist = QMediaPlaylist()
self.player.setPlaylist(self.playlist)
self.player.durationChanged.connect(self.durationChanged)
self.player.positionChanged.connect(self.positionChanged)
self.player.metaDataChanged.connect(self.metaDataChanged)
self.playlist.currentIndexChanged.connect(self.playlistPositionChanged)
self.player.mediaStatusChanged.connect(self.statusChanged)
self.player.bufferStatusChanged.connect(self.bufferingProgress)
self.player.videoAvailableChanged.connect(self.videoAvailableChanged)
self.player.error.connect(self.displayErrorMessage)
self.videoWidget = VideoWidget()
self.player.setVideoOutput(self.videoWidget)
self.playlistModel = PlaylistModel()
self.playlistModel.setPlaylist(self.playlist)
self.playlistView = QListView()
self.playlistView.setModel(self.playlistModel)
self.playlistView.setCurrentIndex(
self.playlistModel.index(self.playlist.currentIndex(), 0))
self.playlistView.activated.connect(self.jump)
self.slider = QSlider(Qt.Horizontal)
self.slider.setRange(0, self.player.duration() / 1000)
self.labelDuration = QLabel()
self.slider.sliderMoved.connect(self.seek)
self.labelHistogram = QLabel()
self.labelHistogram.setText("Histogram:")
self.histogram = HistogramWidget()
histogramLayout = QHBoxLayout()
histogramLayout.addWidget(self.labelHistogram)
histogramLayout.addWidget(self.histogram, 1)
self.probe = QVideoProbe()
self.probe.videoFrameProbed.connect(self.histogram.processFrame)
self.probe.setSource(self.player)
openButton = QPushButton("Open", clicked=self.open)
controls = PlayerControls()
controls.setState(self.player.state())
controls.setVolume(self.player.volume())
controls.setMuted(controls.isMuted())
controls.play.connect(self.player.play)
controls.pause.connect(self.player.pause)
controls.stop.connect(self.player.stop)
controls.next.connect(self.playlist.next)
controls.previous.connect(self.previousClicked)
controls.changeVolume.connect(self.player.setVolume)
controls.changeMuting.connect(self.player.setMuted)
controls.changeRate.connect(self.player.setPlaybackRate)
controls.stop.connect(self.videoWidget.update)
self.player.stateChanged.connect(controls.setState)
self.player.volumeChanged.connect(controls.setVolume)
self.player.mutedChanged.connect(controls.setMuted)
self.fullScreenButton = QPushButton("FullScreen")
self.fullScreenButton.setCheckable(True)
self.colorButton = QPushButton("Color Options...")
self.colorButton.setEnabled(False)
self.colorButton.clicked.connect(self.showColorDialog)
displayLayout = QHBoxLayout()
displayLayout.addWidget(self.videoWidget, 2)
displayLayout.addWidget(self.playlistView)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addStretch(1)
controlLayout.addWidget(controls)
controlLayout.addStretch(1)
controlLayout.addWidget(self.fullScreenButton)
controlLayout.addWidget(self.colorButton)
layout = QVBoxLayout()
layout.addLayout(displayLayout)
hLayout = QHBoxLayout()
hLayout.addWidget(self.slider)
hLayout.addWidget(self.labelDuration)
layout.addLayout(hLayout)
layout.addLayout(controlLayout)
layout.addLayout(histogramLayout)
self.setLayout(layout)
if not self.player.isAvailable():
QMessageBox.warning(self, "Service not available",
"The QMediaPlayer object does not have a valid service.\n"
"Please check the media service plugins are installed.")
controls.setEnabled(False)
self.playlistView.setEnabled(False)
openButton.setEnabled(False)
self.colorButton.setEnabled(False)
self.fullScreenButton.setEnabled(False)
self.metaDataChanged()
self.addToPlaylist(playlist)
def open(self):
fileNames, _ = QFileDialog.getOpenFileNames(self, "Open Files")
self.addToPlaylist(fileNames)
def addToPlaylist(self, fileNames):
for name in fileNames:
fileInfo = QFileInfo(name)
if fileInfo.exists():
url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
if fileInfo.suffix().lower() == 'm3u':
self.playlist.load(url)
else:
self.playlist.addMedia(QMediaContent(url))
else:
url = QUrl(name)
if url.isValid():
self.playlist.addMedia(QMediaContent(url))
def durationChanged(self, duration):
duration /= 1000
self.duration = duration
self.slider.setMaximum(duration)
def positionChanged(self, progress):
progress /= 1000
if not self.slider.isSliderDown():
self.slider.setValue(progress)
self.updateDurationInfo(progress)
def metaDataChanged(self):
if self.player.isMetaDataAvailable():
self.setTrackInfo("%s - %s" % (
self.player.metaData(QMediaMetaData.AlbumArtist),
self.player.metaData(QMediaMetaData.Title)))
def previousClicked(self):
# Go to the previous track if we are within the first 5 seconds of
# playback. Otherwise, seek to the beginning.
if self.player.position() <= 5000:
self.playlist.previous()
else:
self.player.setPosition(0)
def jump(self, index):
if index.isValid():
self.playlist.setCurrentIndex(index.row())
self.player.play()
def playlistPositionChanged(self, position):
self.playlistView.setCurrentIndex(
self.playlistModel.index(position, 0))
def seek(self, seconds):
self.player.setPosition(seconds * 1000)
def statusChanged(self, status):
self.handleCursor(status)
if status == QMediaPlayer.LoadingMedia:
self.setStatusInfo("Loading...")
elif status == QMediaPlayer.StalledMedia:
self.setStatusInfo("Media Stalled")
elif status == QMediaPlayer.EndOfMedia:
QApplication.alert(self)
elif status == QMediaPlayer.InvalidMedia:
self.displayErrorMessage()
else:
self.setStatusInfo("")
def handleCursor(self, status):
if status in (QMediaPlayer.LoadingMedia, QMediaPlayer.BufferingMedia, QMediaPlayer.StalledMedia):
self.setCursor(Qt.BusyCursor)
else:
self.unsetCursor()
def bufferingProgress(self, progress):
self.setStatusInfo("Buffering %d%" % progress)
def videoAvailableChanged(self, available):
if available:
self.fullScreenButton.clicked.connect(
self.videoWidget.setFullScreen)
self.videoWidget.fullScreenChanged.connect(
self.fullScreenButton.setChecked)
if self.fullScreenButton.isChecked():
self.videoWidget.setFullScreen(True)
else:
self.fullScreenButton.clicked.disconnect(
self.videoWidget.setFullScreen)
self.videoWidget.fullScreenChanged.disconnect(
self.fullScreenButton.setChecked)
self.videoWidget.setFullScreen(False)
self.colorButton.setEnabled(available)
def setTrackInfo(self, info):
self.trackInfo = info
if self.statusInfo != "":
self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo))
else:
self.setWindowTitle(self.trackInfo)
def setStatusInfo(self, info):
self.statusInfo = info
if self.statusInfo != "":
self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo))
else:
self.setWindowTitle(self.trackInfo)
def displayErrorMessage(self):
self.setStatusInfo(self.player.errorString())
def updateDurationInfo(self, currentInfo):
duration = self.duration
if currentInfo or duration:
currentTime = QTime((currentInfo/3600)%60, (currentInfo/60)%60,
currentInfo%60, (currentInfo*1000)%1000)
totalTime = QTime((duration/3600)%60, (duration/60)%60,
duration%60, (duration*1000)%1000);
format = 'hh:mm:ss' if duration > 3600 else 'mm:ss'
tStr = currentTime.toString(format) + " / " + totalTime.toString(format)
else:
tStr = ""
self.labelDuration.setText(tStr)
def showColorDialog(self):
if self.colorDialog is None:
brightnessSlider = QSlider(Qt.Horizontal)
brightnessSlider.setRange(-100, 100)
brightnessSlider.setValue(self.videoWidget.brightness())
brightnessSlider.sliderMoved.connect(
self.videoWidget.setBrightness)
self.videoWidget.brightnessChanged.connect(
brightnessSlider.setValue)
contrastSlider = QSlider(Qt.Horizontal)
contrastSlider.setRange(-100, 100)
contrastSlider.setValue(self.videoWidget.contrast())
contrastSlider.sliderMoved.connect(self.videoWidget.setContrast)
self.videoWidget.contrastChanged.connect(contrastSlider.setValue)
hueSlider = QSlider(Qt.Horizontal)
hueSlider.setRange(-100, 100)
hueSlider.setValue(self.videoWidget.hue())
hueSlider.sliderMoved.connect(self.videoWidget.setHue)
self.videoWidget.hueChanged.connect(hueSlider.setValue)
saturationSlider = QSlider(Qt.Horizontal)
saturationSlider.setRange(-100, 100)
saturationSlider.setValue(self.videoWidget.saturation())
saturationSlider.sliderMoved.connect(
self.videoWidget.setSaturation)
self.videoWidget.saturationChanged.connect(
saturationSlider.setValue)
layout = QFormLayout()
layout.addRow("Brightness", brightnessSlider)
layout.addRow("Contrast", contrastSlider)
layout.addRow("Hue", hueSlider)
layout.addRow("Saturation", saturationSlider)
button = QPushButton("Close")
layout.addRow(button)
self.colorDialog = QDialog(self)
self.colorDialog.setWindowTitle("Color Options")
self.colorDialog.setLayout(layout)
button.clicked.connect(self.colorDialog.close)
self.colorDialog.show()
