class MainWindowMusicPlayer(QMainWindow):
stopState: bool
def __init__(self):
super().__init__()
self.currentPlaylist = QMediaPlaylist()
self.player = QMediaPlayer()
self.userAction = -1 # 0 - stopped, 1 - playing 2 - paused
self.player.mediaStatusChanged.connect(self.qmp_media_status_changed)
self.player.stateChanged.connect(self.qmp_state_changed)
self.player.positionChanged.connect(self.qmp_position_changed)
self.player.volumeChanged.connect(self.qmp_volume_changed)
self.player.setVolume(60)
# Status bar
self.statusBar().showMessage('No Media'
' :: %d' % self.player.volume())
self.home_screen()
def home_screen(self):
self.setWindowTitle('Music Player')
self.create_menubar()
self.create_toolbar()
controlBar = self.add_controls()
# need to add both information screen
# and control bar to the central widget.
centralWidget = QWidget()
centralWidget.setLayout(controlBar)
self.setCentralWidget(centralWidget)
# Set size of the MainWindow
self.resize(200, 100)
self.show()
def create_menubar(self):
menubar = self.menuBar()
file_menu = menubar.addMenu('File')
file_menu.addAction(self.file_open())
file_menu.addAction(self.song_info())
file_menu.addAction(self.folder_open())
file_menu.addAction(self.exit_action())
def create_toolbar(self):
pass
def add_controls(self):
controlArea = QVBoxLayout()
seekSliderLayout = QHBoxLayout()
controls = QHBoxLayout()
playlistCtrlLayout = QHBoxLayout()
# creating buttons
playBtn = QPushButton('Play') # play button
pauseBtn = QPushButton('Pause') # pause button
stopBtn = QPushButton('Stop') # stop button
volumeDescBtn = QPushButton('V (-)') # Decrease Volume
volumeIncBtn = QPushButton('V (+)') # Increase Volume
# creating playlist controls
prevBtn = QPushButton('Prev Song')
nextBtn = QPushButton('Next Song')
# creating seek slider
seekSlider = QSlider()
seekSlider.setMinimum(0)
seekSlider.setMaximum(100)
seekSlider.setOrientation(Qt.Horizontal)
seekSlider.setTracking(False)
seekSlider.sliderMoved.connect(self.seek_position)
# seekSlider.valueChanged.connect(self.seekPosition)
seekSliderLabel1 = QLabel('0.00')
seekSliderLabel2 = QLabel('0.00')
seekSliderLayout.addWidget(seekSliderLabel1)
seekSliderLayout.addWidget(seekSlider)
seekSliderLayout.addWidget(seekSliderLabel2)
# Add handler for each button. Not using the default slots.
playBtn.clicked.connect(self.play_handler)
pauseBtn.clicked.connect(self.pause_handler)
stopBtn.clicked.connect(self.stop_handler)
volumeDescBtn.clicked.connect(self.decrease_volume)
volumeIncBtn.clicked.connect(self.increase_volume)
# Adding to the horizontal layout
controls.addWidget(volumeDescBtn)
controls.addWidget(playBtn)
controls.addWidget(pauseBtn)
controls.addWidget(stopBtn)
controls.addWidget(volumeIncBtn)
# playlist control button handlers
prevBtn.clicked.connect(self.prev_item_playlist)
nextBtn.clicked.connect(self.next_item_playlist)
playlistCtrlLayout.addWidget(prevBtn)
playlistCtrlLayout.addWidget(nextBtn)
# Adding to the vertical layout
controlArea.addLayout(seekSliderLayout)
controlArea.addLayout(controls)
controlArea.addLayout(playlistCtrlLayout)
return controlArea
# Music playback function
def play_handler(self):
self.userAction = 1
self.statusBar().showMessage('Playing at Volume %d' %
self.player.volume())
if self.player.state() == QMediaPlayer.StoppedState:
if self.player.mediaStatus() == QMediaPlayer.NoMedia:
print(self.currentPlaylist.mediaCount())
if self.currentPlaylist.mediaCount() == 0:
self.open_file()
if self.currentPlaylist.mediaCount() != 0:
self.player.setPlaylist(self.currentPlaylist)
elif self.player.mediaStatus() ==\
QMediaPlayer.LoadedMedia:
self.player.play()
elif self.player.mediaStatus() ==\
QMediaPlayer.BufferedMedia:
self.player.play()
elif self.player.state() == QMediaPlayer.PlayingState:
pass
elif self.player.state() == QMediaPlayer.PausedState:
self.player.play()
# Music pause function
def pause_handler(self):
self.userAction = 2
self.statusBar().showMessage(
'Paused %s at position'
' %s at Volume %d' %
(self.player.metaData(QMediaMetaData.Title),
self.centralWidget().layout().itemAt(0).layout().itemAt(
0).widget().text(), self.player.volume()))
self.player.pause()
# Music stop function
def stop_handler(self):
self.userAction = 0
self.statusBar().showMessage('Stopped at Volume %d' %
(self.player.volume()))
if self.player.state() == QMediaPlayer.PlayingState:
self.stopState = True
self.player.stop()
elif self.player.state() == QMediaPlayer.PausedState:
self.player.stop()
elif self.player.state() == QMediaPlayer.StoppedState:
pass
# Music status change function
def qmp_media_status_changed(self):
if self.player.mediaStatus() == QMediaPlayer.LoadedMedia \
and self.userAction == 1:
durationT = self.player.duration()
self.centralWidget().layout().itemAt(0).layout() \
.itemAt(1).widget().setRange(0, durationT)
self.centralWidget().layout().itemAt(0).layout() \
.itemAt(2).widget().setText(
'%d:%02d' % (int(durationT / 60000),
int((durationT / 1000) % 60)))
self.player.play()
# Music playing change function
def qmp_state_changed(self):
if self.player.state() == QMediaPlayer.StoppedState:
self.player.stop()
# Music time change function
def qmp_position_changed(self, position, senderType=False):
sliderLayout = self.centralWidget().layout().itemAt(0)\
.layout()
if not senderType:
sliderLayout.itemAt(1).widget().setValue(position)
# update the text label
sliderLayout.itemAt(0).widget()\
.setText('%d:%02d' %
(int(position / 60000),
int((position / 1000) % 60)))
def seek_position(self, position):
sender = self.sender()
if isinstance(sender, QSlider):
if self.player.isSeekable():
self.player.setPosition(position)
# Music volume change function
def qmp_volume_changed(self):
msg = self.statusBar().currentMessage()
msg = msg[:-2] + str(self.player.volume())
self.statusBar().showMessage(msg)
# Music volume + change function
def increase_volume(self):
vol = self.player.volume()
vol = min(vol + 5, 100)
self.player.setVolume(vol)
# Music volume - change function
def decrease_volume(self):
vol = self.player.volume()
vol = max(vol - 5, 0)
self.player.setVolume(vol)
# File open function
def file_open(self):
fileAc = QAction(QIcon('icons\\open.png'), 'Open File', self)
fileAc.setShortcut('Ctrl+O')
fileAc.setStatusTip('Open File')
fileAc.triggered.connect(self.open_file)
return fileAc
# File opening function
def open_file(self):
file_Chosen = QFileDialog.getOpenFileUrl(self, 'Open Music File',
expanduser('~'),
'Audio (*.mp3 *.ogg *.wav)',
'*.mp3 *.ogg *.wav')
if file_Chosen is not None:
self.currentPlaylist.addMedia(QMediaContent(file_Chosen[0]))
# Folder open function
def folder_open(self):
folderAc = QAction(QIcon('icons\\open_fld.png'), 'Open Folder', self)
folderAc.setShortcut('Ctrl+D')
folderAc.setStatusTip('Open Folder '
'(Will add all the files in'
' the folder)')
folderAc.triggered.connect(self.add_files)
return folderAc
# Folder opening function
def add_files(self):
folder_Chosen = QFileDialog\
.getExistingDirectory(self,
'Open Music Folder',
expanduser('~'))
if folder_Chosen is not None:
it = QDirIterator(folder_Chosen)
it.next()
while it.hasNext():
if it.fileInfo().isDir() == False\
and it.filePath() != '.':
fInfo = it.fileInfo()
print(it.filePath(), fInfo.suffix())
if fInfo.suffix() in ('mp3', 'ogg', 'wav'):
print('added file ', fInfo.fileName())
self.currentPlaylist. \
addMedia(QMediaContent(
QUrl.fromLocalFile(it.filePath())))
it.next()
# Song information function
def song_info(self):
infoAc = QAction(QIcon('icons\\info.png'), 'Info', self)
infoAc.setShortcut('Ctrl+I')
infoAc.setStatusTip('Displays Current Song Information')
infoAc.triggered.connect(self.display_song_info)
return infoAc
# Show song information
def display_song_info(self):
metaDataKeyList = self.player.availableMetaData()
fullText = '<table class="tftable" border="0">'
for key in metaDataKeyList:
value = self.player.metaData(key)
fullText = \
fullText + '<tr><td>' + key + '</td><td>' + \
str(value) + '</td></tr>'
fullText = fullText + '</table>'
infoBox = QMessageBox(self)
infoBox.setWindowTitle('Detailed Song Information')
infoBox.setTextFormat(Qt.RichText)
infoBox.setText(fullText)
infoBox.addButton('OK', QMessageBox.AcceptRole)
infoBox.show()
# Switch to previous song
def prev_item_playlist(self):
self.player.playlist().previous()
# Switch to next song
def next_item_playlist(self):
self.player.playlist().next()
# exit function
def exit_action(self):
exitAc = QAction(QIcon('icons\\exit.png'), '&Exit', self)
exitAc.setShortcut('Ctrl+Q')
exitAc.setStatusTip('Exit App')
exitAc.triggered.connect(self.close)
return exitAc
# exiting function
@staticmethod
def exit():
sys.exit(app.exec_())
class VidCutter(QWidget):
def __init__(self, parent):
super(VidCutter, self).__init__(parent)
self.parent = parent
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoWidget = VideoWidget()
self.videoService = VideoService(self)
QFontDatabase.addApplicationFont(
os.path.join(self.getAppPath(), 'fonts', 'DroidSansMono.ttf'))
QFontDatabase.addApplicationFont(
os.path.join(self.getAppPath(), 'fonts', 'HelveticaNeue.ttf'))
qApp.setFont(QFont('Helvetica Neue', 10))
self.clipTimes = []
self.inCut = False
self.movieFilename = ''
self.movieLoaded = False
self.timeformat = 'hh:mm:ss'
self.finalFilename = ''
self.totalRuntime = 0
self.initIcons()
self.initActions()
self.toolbar = QToolBar(
floatable=False,
movable=False,
iconSize=QSize(28, 28),
toolButtonStyle=Qt.ToolButtonTextUnderIcon,
styleSheet=
'QToolBar QToolButton { min-width:82px; margin-left:10px; margin-right:10px; font-size:14px; }'
)
self.initToolbar()
self.aboutMenu, self.cliplistMenu = QMenu(), QMenu()
self.initMenus()
self.seekSlider = VideoSlider(parent=self,
sliderMoved=self.setPosition)
self.seekSlider.installEventFilter(self)
self.initNoVideo()
self.cliplist = QListWidget(
sizePolicy=QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding),
contextMenuPolicy=Qt.CustomContextMenu,
uniformItemSizes=True,
iconSize=QSize(100, 700),
dragDropMode=QAbstractItemView.InternalMove,
alternatingRowColors=True,
customContextMenuRequested=self.itemMenu,
styleSheet='QListView::item { margin:10px 5px; }')
self.cliplist.setFixedWidth(185)
self.cliplist.model().rowsMoved.connect(self.syncClipList)
listHeader = QLabel(pixmap=QPixmap(
os.path.join(self.getAppPath(), 'images', 'clipindex.png'), 'PNG'),
alignment=Qt.AlignCenter)
listHeader.setStyleSheet(
'''padding:5px; padding-top:8px; border:1px solid #b9b9b9; border-bottom:none;
background-color:qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 #FFF,
stop: 0.5 #EAEAEA, stop: 0.6 #EAEAEA stop:1 #FFF);'''
)
self.runtimeLabel = QLabel('<div align="right">00:00:00</div>',
textFormat=Qt.RichText)
self.runtimeLabel.setStyleSheet(
'''font-family:Droid Sans Mono; font-size:10pt; color:#FFF;
background:rgb(106, 69, 114) url(:images/runtime.png)
no-repeat left center; padding:2px; padding-right:8px;
border:1px solid #b9b9b9; border-top:none;'''
)
self.clipindexLayout = QVBoxLayout(spacing=0)
self.clipindexLayout.setContentsMargins(0, 0, 0, 0)
self.clipindexLayout.addWidget(listHeader)
self.clipindexLayout.addWidget(self.cliplist)
self.clipindexLayout.addWidget(self.runtimeLabel)
self.videoLayout = QHBoxLayout()
self.videoLayout.setContentsMargins(0, 0, 0, 0)
self.videoLayout.addWidget(self.novideoWidget)
self.videoLayout.addLayout(self.clipindexLayout)
self.timeCounter = QLabel('00:00:00 / 00:00:00',
autoFillBackground=True,
alignment=Qt.AlignCenter,
sizePolicy=QSizePolicy(
QSizePolicy.Expanding,
QSizePolicy.Fixed))
self.timeCounter.setStyleSheet(
'color:#FFF; background:#000; font-family:Droid Sans Mono; font-size:10.5pt; padding:4px;'
)
videoplayerLayout = QVBoxLayout(spacing=0)
videoplayerLayout.setContentsMargins(0, 0, 0, 0)
videoplayerLayout.addWidget(self.videoWidget)
videoplayerLayout.addWidget(self.timeCounter)
self.videoplayerWidget = QWidget(self, visible=False)
self.videoplayerWidget.setLayout(videoplayerLayout)
self.menuButton = QPushButton(icon=self.aboutIcon,
flat=True,
toolTip='About',
statusTip='About',
iconSize=QSize(24, 24),
cursor=Qt.PointingHandCursor)
self.menuButton.setMenu(self.aboutMenu)
self.muteButton = QPushButton(icon=self.unmuteIcon,
flat=True,
toolTip='Mute',
statusTip='Toggle audio mute',
cursor=Qt.PointingHandCursor,
clicked=self.muteAudio)
self.volumeSlider = QSlider(Qt.Horizontal,
toolTip='Volume',
statusTip='Adjust volume level',
cursor=Qt.PointingHandCursor,
value=50,
sizePolicy=QSizePolicy(
QSizePolicy.Fixed,
QSizePolicy.Minimum),
minimum=0,
maximum=100,
sliderMoved=self.setVolume)
self.volumeSlider.setStyleSheet(
'''QSlider::groove:horizontal { height:40px; }
QSlider::sub-page:horizontal { border:1px outset #6A4572; background:#6A4572; margin:2px; }
QSlider::handle:horizontal { image: url(:images/knob.png) no-repeat top left; width:20px; }'''
)
self.saveAction = QPushButton(
self.parent,
icon=self.saveIcon,
text='Save Video',
flat=True,
toolTip='Save Video',
clicked=self.cutVideo,
cursor=Qt.PointingHandCursor,
iconSize=QSize(30, 30),
statusTip='Save video clips merged as a new video file',
enabled=False)
self.saveAction.setStyleSheet(
'''QPushButton { color:#FFF; padding:8px; font-size:12pt;
border:1px inset #481953; border-radius:4px;
background-color:rgb(106, 69, 114); }
QPushButton:!enabled { background-color:rgba(0, 0, 0, 0.1);
color:rgba(0, 0, 0, 0.3); border:1px inset #CDCDCD; }
QPushButton:hover { background-color:rgba(255, 255, 255, 0.8); color:#444; }
QPushButton:pressed { background-color:rgba(218, 218, 219, 0.8); color:#444; }'''
)
controlsLayout = QHBoxLayout()
controlsLayout.addStretch(1)
controlsLayout.addWidget(self.toolbar)
controlsLayout.addSpacerItem(QSpacerItem(20, 1))
controlsLayout.addWidget(self.saveAction)
controlsLayout.addStretch(1)
controlsLayout.addWidget(self.muteButton)
controlsLayout.addWidget(self.volumeSlider)
controlsLayout.addSpacing(1)
controlsLayout.addWidget(self.menuButton)
layout = QVBoxLayout()
layout.setContentsMargins(10, 10, 10, 4)
layout.addLayout(self.videoLayout)
layout.addWidget(self.seekSlider)
layout.addLayout(controlsLayout)
self.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 initNoVideo(self) -> None:
novideoImage = QLabel(alignment=Qt.AlignCenter,
autoFillBackground=False,
pixmap=QPixmap(
os.path.join(self.getAppPath(), 'images',
'novideo.png'), 'PNG'),
sizePolicy=QSizePolicy(
QSizePolicy.Expanding,
QSizePolicy.MinimumExpanding))
novideoImage.setBackgroundRole(QPalette.Dark)
novideoImage.setContentsMargins(0, 20, 0, 20)
self.novideoLabel = QLabel(alignment=Qt.AlignCenter,
autoFillBackground=True,
sizePolicy=QSizePolicy(
QSizePolicy.Expanding,
QSizePolicy.Minimum))
self.novideoLabel.setBackgroundRole(QPalette.Dark)
self.novideoLabel.setContentsMargins(0, 20, 15, 60)
novideoLayout = QVBoxLayout(spacing=0)
novideoLayout.addWidget(novideoImage)
novideoLayout.addWidget(self.novideoLabel, alignment=Qt.AlignTop)
self.novideoMovie = QMovie(
os.path.join(self.getAppPath(), 'images', 'novideotext.gif'))
self.novideoMovie.frameChanged.connect(self.setNoVideoText)
self.novideoMovie.start()
self.novideoWidget = QWidget(self, autoFillBackground=True)
self.novideoWidget.setBackgroundRole(QPalette.Dark)
self.novideoWidget.setLayout(novideoLayout)
def initIcons(self) -> None:
self.appIcon = QIcon(
os.path.join(self.getAppPath(), 'images', 'vidcutter.png'))
self.openIcon = QIcon(
os.path.join(self.getAppPath(), 'images', 'addmedia.png'))
self.playIcon = QIcon(
os.path.join(self.getAppPath(), 'images', 'play.png'))
self.pauseIcon = QIcon(
os.path.join(self.getAppPath(), 'images', 'pause.png'))
self.cutStartIcon = QIcon(
os.path.join(self.getAppPath(), 'images', 'cut-start.png'))
self.cutEndIcon = QIcon(
os.path.join(self.getAppPath(), 'images', 'cut-end.png'))
self.saveIcon = QIcon(
os.path.join(self.getAppPath(), 'images', 'save.png'))
self.muteIcon = QIcon(
os.path.join(self.getAppPath(), 'images', 'muted.png'))
self.unmuteIcon = QIcon(
os.path.join(self.getAppPath(), 'images', 'unmuted.png'))
self.upIcon = QIcon(os.path.join(self.getAppPath(), 'images',
'up.png'))
self.downIcon = QIcon(
os.path.join(self.getAppPath(), 'images', 'down.png'))
self.removeIcon = QIcon(
os.path.join(self.getAppPath(), 'images', 'remove.png'))
self.removeAllIcon = QIcon(
os.path.join(self.getAppPath(), 'images', 'remove-all.png'))
self.successIcon = QIcon(
os.path.join(self.getAppPath(), 'images', 'success.png'))
self.aboutIcon = QIcon(
os.path.join(self.getAppPath(), 'images', 'about.png'))
self.completePlayIcon = QIcon(
os.path.join(self.getAppPath(), 'images', 'complete-play.png'))
self.completeOpenIcon = QIcon(
os.path.join(self.getAppPath(), 'images', 'complete-open.png'))
self.completeRestartIcon = QIcon(
os.path.join(self.getAppPath(), 'images', 'complete-restart.png'))
self.completeExitIcon = QIcon(
os.path.join(self.getAppPath(), 'images', 'complete-exit.png'))
def initActions(self) -> None:
self.openAction = QAction(self.openIcon,
'Add Media',
self,
statusTip='Select media source',
triggered=self.openFile)
self.playAction = QAction(self.playIcon,
'Play Video',
self,
statusTip='Play selected media',
triggered=self.playVideo,
enabled=False)
self.cutStartAction = QAction(self.cutStartIcon,
'Set Start',
self,
toolTip='Set Start',
statusTip='Set start marker',
triggered=self.cutStart,
enabled=False)
self.cutEndAction = QAction(self.cutEndIcon,
'Set End',
self,
statusTip='Set end marker',
triggered=self.cutEnd,
enabled=False)
self.moveItemUpAction = QAction(
self.upIcon,
'Move Up',
self,
statusTip='Move clip position up in list',
triggered=self.moveItemUp,
enabled=False)
self.moveItemDownAction = QAction(
self.downIcon,
'Move Down',
self,
statusTip='Move clip position down in list',
triggered=self.moveItemDown,
enabled=False)
self.removeItemAction = QAction(
self.removeIcon,
'Remove clip',
self,
statusTip='Remove selected clip from list',
triggered=self.removeItem,
enabled=False)
self.removeAllAction = QAction(self.removeAllIcon,
'Clear list',
self,
statusTip='Clear all clips from list',
triggered=self.clearList,
enabled=False)
self.aboutAction = QAction('About %s' % qApp.applicationName(),
self,
statusTip='Credits and acknowledgements',
triggered=self.aboutInfo)
self.aboutQtAction = QAction('About Qt',
self,
statusTip='About Qt',
triggered=qApp.aboutQt)
self.mediaInfoAction = QAction(
'Media Information',
self,
statusTip='Media information from loaded video file',
triggered=self.mediaInfo,
enabled=False)
def initToolbar(self) -> None:
self.toolbar.addAction(self.openAction)
self.toolbar.addAction(self.playAction)
self.toolbar.addSeparator()
self.toolbar.addAction(self.cutStartAction)
self.toolbar.addAction(self.cutEndAction)
self.toolbar.addSeparator()
def initMenus(self) -> None:
self.aboutMenu.addAction(self.mediaInfoAction)
self.aboutMenu.addSeparator()
self.aboutMenu.addAction(self.aboutQtAction)
self.aboutMenu.addAction(self.aboutAction)
self.cliplistMenu.addAction(self.moveItemUpAction)
self.cliplistMenu.addAction(self.moveItemDownAction)
self.cliplistMenu.addSeparator()
self.cliplistMenu.addAction(self.removeItemAction)
self.cliplistMenu.addAction(self.removeAllAction)
def setRunningTime(self, runtime: str) -> None:
self.runtimeLabel.setText('<div align="right">%s</div>' % runtime)
@pyqtSlot(int)
def setNoVideoText(self, frame: int) -> None:
self.novideoLabel.setPixmap(self.novideoMovie.currentPixmap())
def itemMenu(self, pos: QPoint) -> None:
globalPos = self.cliplist.mapToGlobal(pos)
self.moveItemUpAction.setEnabled(False)
self.moveItemDownAction.setEnabled(False)
self.removeItemAction.setEnabled(False)
self.removeAllAction.setEnabled(False)
index = self.cliplist.currentRow()
if index != -1:
if not self.inCut:
if index > 0:
self.moveItemUpAction.setEnabled(True)
if index < self.cliplist.count() - 1:
self.moveItemDownAction.setEnabled(True)
if self.cliplist.count() > 0:
self.removeItemAction.setEnabled(True)
if self.cliplist.count() > 0:
self.removeAllAction.setEnabled(True)
self.cliplistMenu.exec_(globalPos)
def moveItemUp(self) -> None:
index = self.cliplist.currentRow()
tmpItem = self.clipTimes[index]
del self.clipTimes[index]
self.clipTimes.insert(index - 1, tmpItem)
self.renderTimes()
def moveItemDown(self) -> None:
index = self.cliplist.currentRow()
tmpItem = self.clipTimes[index]
del self.clipTimes[index]
self.clipTimes.insert(index + 1, tmpItem)
self.renderTimes()
def removeItem(self) -> None:
index = self.cliplist.currentRow()
del self.clipTimes[index]
if self.inCut and index == self.cliplist.count() - 1:
self.inCut = False
self.initMediaControls()
self.renderTimes()
def clearList(self) -> None:
self.clipTimes.clear()
self.cliplist.clear()
self.inCut = False
self.renderTimes()
self.initMediaControls()
def mediaInfo(self) -> None:
if self.mediaPlayer.isMetaDataAvailable():
content = '<table cellpadding="4">'
for key in self.mediaPlayer.availableMetaData():
val = self.mediaPlayer.metaData(key)
if type(val) is QSize:
val = '%s x %s' % (val.width(), val.height())
content += '<tr><td align="right"><b>%s:</b></td><td>%s</td></tr>\n' % (
key, val)
content += '</table>'
mbox = QMessageBox(windowTitle='Media Information',
windowIcon=self.parent.windowIcon(),
textFormat=Qt.RichText)
mbox.setText('<b>%s</b>' % os.path.basename(
self.mediaPlayer.currentMedia().canonicalUrl().toLocalFile()))
mbox.setInformativeText(content)
mbox.exec_()
else:
QMessageBox.critical(
self.parent, 'Could not retrieve media information',
'''There was a problem in tring to retrieve media information.
This DOES NOT mean there is a problem with the file and you should
be able to continue using it.''')
def aboutInfo(self) -> None:
about_html = '''<style>
a { color:#441d4e; text-decoration:none; font-weight:bold; }
a:hover { text-decoration:underline; }
</style>
<p style="font-size:26pt; font-weight:bold;">%s</p>
<p>
<span style="font-size:13pt;"><b>Version: %s</b></span>
<span style="font-size:10pt;position:relative;left:5px;">( %s )</span>
</p>
<p style="font-size:13px;">
Copyright © 2016 <a href="mailto:[email protected]">Pete Alexandrou</a>
<br/>
Website: <a href="%s">%s</a>
</p>
<p style="font-size:13px;">
Thanks to the folks behind the <b>Qt</b>, <b>PyQt</b> and <b>FFmpeg</b>
projects for all their hard and much appreciated work.
</p>
<p style="font-size:11px;">
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
</p>
<p style="font-size:11px;">
This software uses libraries from the <a href="https://www.ffmpeg.org">FFmpeg</a> project under the
<a href="https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html">LGPLv2.1</a>
</p>''' % (qApp.applicationName(), qApp.applicationVersion(),
platform.architecture()[0], qApp.organizationDomain(),
qApp.organizationDomain())
QMessageBox.about(self.parent, 'About %s' % qApp.applicationName(),
about_html)
def openFile(self) -> None:
filename, _ = QFileDialog.getOpenFileName(self.parent,
caption='Select video',
directory=QDir.homePath())
if filename != '':
self.loadFile(filename)
def loadFile(self, filename: str) -> None:
self.movieFilename = filename
if not os.path.exists(filename):
return
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(filename)))
self.initMediaControls(True)
self.cliplist.clear()
self.clipTimes = []
self.parent.setWindowTitle(
'%s - %s' % (qApp.applicationName(), os.path.basename(filename)))
if not self.movieLoaded:
self.videoLayout.replaceWidget(self.novideoWidget,
self.videoplayerWidget)
self.novideoMovie.stop()
self.novideoMovie.deleteLater()
self.novideoWidget.deleteLater()
self.videoplayerWidget.show()
self.videoWidget.show()
self.movieLoaded = True
if self.mediaPlayer.isVideoAvailable():
self.mediaPlayer.setPosition(1)
self.mediaPlayer.play()
self.mediaPlayer.pause()
def playVideo(self) -> None:
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
self.playAction.setText('Play Video')
else:
self.mediaPlayer.play()
self.playAction.setText('Pause Video')
def initMediaControls(self, flag: bool = True) -> None:
self.playAction.setEnabled(flag)
self.saveAction.setEnabled(False)
self.cutStartAction.setEnabled(flag)
self.cutEndAction.setEnabled(False)
self.mediaInfoAction.setEnabled(flag)
if flag:
self.seekSlider.setRestrictValue(0)
def setPosition(self, position: int) -> None:
self.mediaPlayer.setPosition(position)
def positionChanged(self, progress: int) -> None:
self.seekSlider.setValue(progress)
currentTime = self.deltaToQTime(progress)
totalTime = self.deltaToQTime(self.mediaPlayer.duration())
self.timeCounter.setText('%s / %s' % (currentTime.toString(
self.timeformat), totalTime.toString(self.timeformat)))
@pyqtSlot()
def mediaStateChanged(self) -> None:
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playAction.setIcon(self.pauseIcon)
else:
self.playAction.setIcon(self.playIcon)
def durationChanged(self, duration: int) -> None:
self.seekSlider.setRange(0, duration)
def muteAudio(self, muted: bool) -> None:
if self.mediaPlayer.isMuted():
self.mediaPlayer.setMuted(not self.mediaPlayer.isMuted())
self.muteButton.setIcon(self.unmuteIcon)
self.muteButton.setToolTip('Mute')
else:
self.mediaPlayer.setMuted(not self.mediaPlayer.isMuted())
self.muteButton.setIcon(self.muteIcon)
self.muteButton.setToolTip('Unmute')
def setVolume(self, volume: int) -> None:
self.mediaPlayer.setVolume(volume)
def toggleFullscreen(self) -> None:
self.videoWidget.setFullScreen(not self.videoWidget.isFullScreen())
def cutStart(self) -> None:
self.clipTimes.append([
self.deltaToQTime(self.mediaPlayer.position()), '',
self.captureImage()
])
self.cutStartAction.setDisabled(True)
self.cutEndAction.setEnabled(True)
self.seekSlider.setRestrictValue(self.seekSlider.value() + 1000)
self.mediaPlayer.setPosition(self.seekSlider.restrictValue)
self.inCut = True
self.renderTimes()
def cutEnd(self) -> None:
item = self.clipTimes[len(self.clipTimes) - 1]
selected = self.deltaToQTime(self.mediaPlayer.position())
if selected.__lt__(item[0]):
QMessageBox.critical(
self.parent, 'Invalid END Time',
'The clip end time must come AFTER it\'s start time. Please try again.'
)
return
item[1] = selected
self.cutStartAction.setEnabled(True)
self.cutEndAction.setDisabled(True)
self.seekSlider.setRestrictValue(0)
self.inCut = False
self.renderTimes()
@pyqtSlot(QModelIndex, int, int, QModelIndex, int)
def syncClipList(self, parent: QModelIndex, start: int, end: int,
destination: QModelIndex, row: int) -> None:
if start < row:
index = row - 1
else:
index = row
clip = self.clipTimes.pop(start)
self.clipTimes.insert(index, clip)
def renderTimes(self) -> None:
self.cliplist.clear()
self.seekSlider.setCutMode(self.inCut)
if len(self.clipTimes) > 4:
self.cliplist.setFixedWidth(200)
else:
self.cliplist.setFixedWidth(185)
self.totalRuntime = 0
for item in self.clipTimes:
endItem = ''
if type(item[1]) is QTime:
endItem = item[1].toString(self.timeformat)
self.totalRuntime += item[0].msecsTo(item[1])
listitem = QListWidgetItem()
listitem.setTextAlignment(Qt.AlignVCenter)
if type(item[2]) is QPixmap:
listitem.setIcon(QIcon(item[2]))
self.cliplist.addItem(listitem)
marker = QLabel(
'''<style>b { font-size:8pt; } p { margin:5px; }</style>
<p><b>START</b><br/>%s</p><p><b>END</b><br/>%s</p>'''
% (item[0].toString(self.timeformat), endItem))
self.cliplist.setItemWidget(listitem, marker)
listitem.setFlags(Qt.ItemIsSelectable | Qt.ItemIsDragEnabled
| Qt.ItemIsEnabled)
if len(self.clipTimes) and not self.inCut:
self.saveAction.setEnabled(True)
if self.inCut or len(self.clipTimes) == 0 or not type(
self.clipTimes[0][1]) is QTime:
self.saveAction.setEnabled(False)
self.setRunningTime(
self.deltaToQTime(self.totalRuntime).toString(self.timeformat))
@staticmethod
def deltaToQTime(millisecs: int) -> QTime:
secs = millisecs / 1000
return QTime((secs / 3600) % 60, (secs / 60) % 60, secs % 60,
(secs * 1000) % 1000)
def captureImage(self) -> None:
frametime = self.deltaToQTime(
self.mediaPlayer.position()).addSecs(1).toString(self.timeformat)
inputfile = self.mediaPlayer.currentMedia().canonicalUrl().toLocalFile(
)
imagecap = self.videoService.capture(inputfile, frametime)
if type(imagecap) is QPixmap:
return imagecap
def cutVideo(self) -> bool:
self.setCursor(Qt.BusyCursor)
clips = len(self.clipTimes)
filename, filelist = '', []
source = self.mediaPlayer.currentMedia().canonicalUrl().toLocalFile()
_, sourceext = os.path.splitext(source)
if clips > 0:
self.finalFilename, _ = QFileDialog.getSaveFileName(
self.parent, 'Save video', source,
'Video files (*%s)' % sourceext)
if self.finalFilename != '':
self.saveAction.setDisabled(True)
self.showProgress(clips)
file, ext = os.path.splitext(self.finalFilename)
index = 1
self.progress.setLabelText('Cutting video clips...')
qApp.processEvents()
for clip in self.clipTimes:
duration = self.deltaToQTime(clip[0].msecsTo(
clip[1])).toString(self.timeformat)
filename = '%s_%s%s' % (file, '{0:0>2}'.format(index), ext)
filelist.append(filename)
self.videoService.cut(source, filename,
clip[0].toString(self.timeformat),
duration)
index += 1
if len(filelist) > 1:
self.joinVideos(filelist, self.finalFilename)
else:
QFile.remove(self.finalFilename)
QFile.rename(filename, self.finalFilename)
self.unsetCursor()
self.progress.setLabelText('Complete...')
qApp.processEvents()
self.saveAction.setEnabled(True)
self.progress.close()
self.progress.deleteLater()
self.complete()
self.saveAction.setEnabled(True)
self.unsetCursor()
self.saveAction.setDisabled(True)
return True
self.unsetCursor()
self.saveAction.setDisabled(True)
return False
def joinVideos(self, joinlist: list, filename: str) -> None:
listfile = os.path.normpath(
os.path.join(os.path.dirname(joinlist[0]), '.vidcutter.list'))
fobj = open(listfile, 'w')
for file in joinlist:
fobj.write('file \'%s\'\n' % file.replace("'", "\\'"))
fobj.close()
self.videoService.join(listfile, filename)
try:
QFile.remove(listfile)
for file in joinlist:
if os.path.isfile(file):
QFile.remove(file)
except:
pass
def showProgress(self,
steps: int,
label: str = 'Processing video...') -> None:
self.progress = QProgressDialog(label,
None,
0,
steps,
self.parent,
windowModality=Qt.ApplicationModal,
windowIcon=self.parent.windowIcon(),
minimumDuration=0,
minimumWidth=500)
self.progress.show()
for i in range(steps):
self.progress.setValue(i)
qApp.processEvents()
time.sleep(1)
def complete(self) -> None:
info = QFileInfo(self.finalFilename)
mbox = QMessageBox(windowTitle='Success',
windowIcon=self.parent.windowIcon(),
minimumWidth=500,
iconPixmap=self.successIcon.pixmap(48, 49),
textFormat=Qt.RichText)
mbox.setText(
'''
<style>
table.info { margin:8px; padding:4px 15px; }
td.label { font-weight:bold; font-size:9pt; text-align:right; background-color:#444; color:#FFF; }
td.value { background-color:#FFF !important; font-size:10pt; }
</style>
<p>Your video was successfully created.</p>
<p align="center">
<table class="info" cellpadding="6" cellspacing="0">
<tr>
<td class="label"><b>Filename</b></td>
<td class="value" nowrap>%s</td>
</tr>
<tr>
<td class="label"><b>Size</b></td>
<td class="value">%s</td>
</tr>
<tr>
<td class="label"><b>Runtime</b></td>
<td class="value">%s</td>
</tr>
</table>
</p>
<p>How would you like to proceed?</p>''' %
(QDir.toNativeSeparators(
self.finalFilename), self.sizeof_fmt(int(info.size())),
self.deltaToQTime(self.totalRuntime).toString(self.timeformat)))
play = mbox.addButton('Play', QMessageBox.AcceptRole)
play.setIcon(self.completePlayIcon)
play.clicked.connect(self.openResult)
fileman = mbox.addButton('Open', QMessageBox.AcceptRole)
fileman.setIcon(self.completeOpenIcon)
fileman.clicked.connect(self.openFolder)
end = mbox.addButton('Exit', QMessageBox.AcceptRole)
end.setIcon(self.completeExitIcon)
end.clicked.connect(self.close)
new = mbox.addButton('Restart', QMessageBox.AcceptRole)
new.setIcon(self.completeRestartIcon)
new.clicked.connect(self.startNew)
mbox.setDefaultButton(new)
mbox.setEscapeButton(new)
mbox.exec_()
def sizeof_fmt(self, num: float, suffix: chr = 'B') -> str:
for unit in ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z']:
if abs(num) < 1024.0:
return "%3.1f%s%s" % (num, unit, suffix)
num /= 1024.0
return "%.1f%s%s" % (num, 'Y', suffix)
@pyqtSlot()
def openFolder(self) -> None:
self.openResult(pathonly=True)
@pyqtSlot(bool)
def openResult(self, pathonly: bool = False) -> None:
self.startNew()
if len(self.finalFilename) and os.path.exists(self.finalFilename):
target = self.finalFilename if not pathonly else os.path.dirname(
self.finalFilename)
QDesktopServices.openUrl(QUrl.fromLocalFile(target))
@pyqtSlot()
def startNew(self) -> None:
self.unsetCursor()
self.clearList()
self.seekSlider.setValue(0)
self.seekSlider.setRange(0, 0)
self.mediaPlayer.setMedia(QMediaContent())
self.initNoVideo()
self.videoLayout.replaceWidget(self.videoplayerWidget,
self.novideoWidget)
self.initMediaControls(False)
self.parent.setWindowTitle('%s' % qApp.applicationName())
def wheelEvent(self, event: QWheelEvent) -> None:
if self.mediaPlayer.isVideoAvailable(
) or self.mediaPlayer.isAudioAvailable():
if event.angleDelta().y() > 0:
newval = self.seekSlider.value() - 1000
else:
newval = self.seekSlider.value() + 1000
self.seekSlider.setValue(newval)
self.seekSlider.setSliderPosition(newval)
self.mediaPlayer.setPosition(newval)
event.accept()
def keyPressEvent(self, event: QKeyEvent) -> None:
if self.mediaPlayer.isVideoAvailable(
) or self.mediaPlayer.isAudioAvailable():
addtime = 0
if event.key() == Qt.Key_Left:
addtime = -1000
elif event.key() == Qt.Key_PageUp or event.key() == Qt.Key_Up:
addtime = -10000
elif event.key() == Qt.Key_Right:
addtime = 1000
elif event.key() == Qt.Key_PageDown or event.key() == Qt.Key_Down:
addtime = 10000
elif event.key() == Qt.Key_Enter:
self.toggleFullscreen()
elif event.key(
) == Qt.Key_Escape and self.videoWidget.isFullScreen():
self.videoWidget.setFullScreen(False)
if addtime != 0:
newval = self.seekSlider.value() + addtime
self.seekSlider.setValue(newval)
self.seekSlider.setSliderPosition(newval)
self.mediaPlayer.setPosition(newval)
event.accept()
def mousePressEvent(self, event: QMouseEvent) -> None:
if event.button() == Qt.BackButton and self.cutStartAction.isEnabled():
self.cutStart()
event.accept()
elif event.button(
) == Qt.ForwardButton and self.cutEndAction.isEnabled():
self.cutEnd()
event.accept()
else:
super(VidCutter, self).mousePressEvent(event)
def eventFilter(self, obj: QObject, event: QEvent) -> bool:
if event.type() == QEvent.MouseButtonRelease and isinstance(
obj, VideoSlider):
if obj.objectName() == 'VideoSlider' and (
self.mediaPlayer.isVideoAvailable()
or self.mediaPlayer.isAudioAvailable()):
obj.setValue(
QStyle.sliderValueFromPosition(obj.minimum(),
obj.maximum(), event.x(),
obj.width()))
self.mediaPlayer.setPosition(obj.sliderPosition())
return QWidget.eventFilter(self, obj, event)
@pyqtSlot(QMediaPlayer.Error)
def handleError(self, error: QMediaPlayer.Error) -> None:
self.unsetCursor()
self.startNew()
if error == QMediaPlayer.ResourceError:
QMessageBox.critical(
self.parent, 'Error',
'Invalid media file detected at:<br/><br/><b>%s</b><br/><br/>%s'
% (self.movieFilename, self.mediaPlayer.errorString()))
else:
QMessageBox.critical(self.parent, 'Error',
self.mediaPlayer.errorString())
def getAppPath(self) -> str:
return ':'
def closeEvent(self, event: QCloseEvent) -> None:
self.parent.closeEvent(event)
class VideoEditor(QFrame):
"""
This widget allows to load a video file and zoom onto a specific ROI (region of interest)
"""
meta_data_loaded = pyqtSignal(dict)
@property
def is_playing(self):
"""
True if the video is currently being played.
"""
return self._media_player.state() == QMediaPlayer.PlayingState
@property
def duration(self):
"""
Duration in seconds of the video clip currently loaded.
"""
return self._duration
@property
def start_trim(self):
"""
Gets the duration of the trimmed footage at the beginning of the video clip in seconds.
"""
return self._start_trim
@start_trim.setter
def start_trim(self, value):
"""
Sets how much of the beginning of the clip should be trimmed.
:param value: Footage to cut in seconds
"""
if not self.video_file_open:
return
if value > self.end_trim:
value = self.end_trim
if value < 0:
value = 0
self._start_trim = value
self._start_frame = int(value * self.fps)
self._timeline.setMinimum(value * 1000)
self._current_time.setText('{:10.3f}'.format(
round(self._timeline.value() / self.fps / 1000 - self._start_trim,
3)))
self._total_time.setText('{:10.3f}'.format(self._end_trim -
self._start_trim))
@property
def end_trim(self):
"""
Gets the time in seconds until which the video clip is shown. The rest is trimmed.
"""
return self._end_trim
@end_trim.setter
def end_trim(self, value):
"""
Sets the time in seconds until which the video clip is displayed. Everything beyond is trimmed.
:param value: Time code in seconds until which the video clip shoud be shown
"""
if not self.video_file_open:
return
if value > self._duration_time_code / 1000:
value = self._duration_time_code / 1000
if value < self._start_trim:
value = self._start_trim
self._end_trim = value
self._end_frame = int(value * self.fps)
self._timeline.setMaximum(value * 1000)
self._current_time.setText('{:10.3f}'.format(
round(self._timeline.value() / self.fps / 1000 - self._start_trim,
3)))
self._total_time.setText('{:10.3f}'.format(self._end_trim -
self._start_trim))
@property
def fps(self):
"""
Frames per second of the currently loaded video clip.
"""
return self._fps
@property
def frame_count(self):
"""
Total amount of frames of the currently loaded video clip.
"""
return self._frame_count
@property
def current_frame(self):
"""
Gets the current frame
"""
return self._current_frame
@current_frame.setter
def current_frame(self, value):
"""
Sets the current frame
:param value: frame number
"""
self._current_frame = value
self._allow_frame_counter_update = False
self._media_player.setPosition(self._frame_number_to_time_code(value))
self._allow_frame_counter_update = True
@property
def start_frame(self):
"""
Gets the start frame. (Depends on the trimming of the video clip)
"""
return self._start_frame
@property
def end_frame(self):
"""
Gets the end frame. (Depends on the trimming of the video clip)
"""
return self._end_frame
@property
def video_width(self):
"""
Horizontal resolution of the currently loaded video clip.
"""
return self._video_width
@property
def video_height(self):
"""
Vertical resolution of the currently loaded video clip.
"""
return self._video_height
@property
def video_path(self):
"""
Path of the currently loaded video file.
"""
return self._video_path
@property
def video_file_open(self):
"""
True if a video file is currently opened in the editor.
"""
return self._video_file_open
@property
def roi(self):
"""
Returns a QRect representing the current region of interest. (If None, the entire image is the ROI)
"""
return self._roi
@property
def overlay_layers(self):
return self._image_control.overlay_layers
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.installEventFilter(
self) # start listening for mouse events to capture ROI changes
self.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored
) # make the editor use as much space as possible
self._media_player = QMediaPlayer(self, QMediaPlayer.VideoSurface)
self._media_player.positionChanged.connect(self._player_time_changed_)
self._media_player.metaDataAvailableChanged.connect(
self._meta_data_changed_)
self._grabber = VideoFrameGrabber(self)
self._allow_frame_counter_update = True
self._result_frame = None
self._media_player.setVideoOutput(self._grabber)
self._grabber.frameAvailable.connect(self._frame_ready_)
self._video_file_open = False
self._video_path = None
self._display_image = dict(
) # cache for images that are displayed from the video
self._frame_count = 0
self._duration_time_code = 0
self._duration = 0
self._fps = 1
self._current_frame = 0
self._video_width = 0
self._video_height = 0
self._file_path = None
self._is_playing = False
self._roi = None
self._start_trim = 0
self._end_trim = 0
self._start_frame = 0
self._end_frame = 0
self._layers = list(
) # layers for visualizations on top of the video footage
self._selection_layer = ImageLayer(
enabled=False) # layer for selection indicators
self._selection_rectangle = ImageRectangle(
0, 0, filled=False, border_color=Qt.yellow) # selection rectangle
self._selection_layer.shapes.append(self._selection_rectangle)
self._selection_start = None # start point for selection rectangle
self.time_code_changed = list()
self._layout = QGridLayout()
self._timeline = None
self._current_time = None
self._total_time = None
self._frame_box = None
self._play_button = None
self._stop_button = None
self._next_frame_button = None
self._previous_frame_button = None
self._box_roi_x = None
self._box_roi_y = None
self._box_roi_width = None
self._box_roi_height = None
self._accept_roi_updates_from_boxes = True
self._wait = False
self.setLayout(self._layout)
self._setup_()
def _time_code_to_frame_number_(self, time_code):
"""
Convert time code to frame number
:param time_code: time code (in ms)
:return: frame number
"""
return int(time_code / 1000 * self.fps)
def _frame_number_to_time_code(self, f_number):
"""
Convert frame number to time code
:param f_number: frame number
:return: time code (in ms)
"""
return int(f_number / self.fps * 1000)
def _to_image_space_(self, point: QPoint):
"""
Convert a point on the editor widget in to a point in the video footage.
:param point: point in coordinates of the widget
:return: point in the coordinates of the video footage
"""
control_position = self._image_control.pos(
) # get the position of the video image on the editor
control_size = self._image_control.size(
) # get the size of the video image
dx = (control_size.width() - self._image_control.image_width
) / 2 # get the x offset of the footage in the image
dy = (control_size.height() - self._image_control.image_height
) / 2 # get the y offset of the footage in the image
x = (point.x() - dx -
control_position.x()) / self._image_control.image_scale_x
y = (point.y() - dy -
control_position.y()) / self._image_control.image_scale_y
return QPoint(x, y)
def eventFilter(self, obj, event):
"""
Check for mouse events to edit the ROI
:param obj: object that caused the event
:param event: event parameters (i.e. mouse position on the widget)
"""
if event.type(
) == QEvent.MouseMove: # if the mouse was moved, update the selection size
target = self._to_image_space_(event.pos())
self._selection_rectangle.position = self._selection_start
self._selection_rectangle.width = target.x(
) - self._selection_start.x()
self._selection_rectangle.height = target.y(
) - self._selection_start.y()
self._image_control.update()
elif event.type(
) == QEvent.MouseButtonPress: # if the left mouse button was pressed designate the point as start of the selection
self._selection_layer.enabled = True
target = self._to_image_space_(event.pos())
self._selection_start = target
elif event.type(
) == QEvent.MouseButtonRelease and self._selection_start is not None: # if the button was release the the ROI
self._selection_layer.enabled = False
end_point = self._to_image_space_(event.pos())
# get all possible corner points
x1 = self._selection_start.x()
x2 = end_point.x()
y1 = self._selection_start.y()
y2 = end_point.y()
# find upper left corner of the ROI
roi_x = x1 if x1 < x2 else x2
roi_y = y1 if y1 < y2 else y2
# find extent of the ROI
roi_width = abs(x1 - x2)
roi_height = abs(y1 - y2)
# set the ROI if it was not just a click with no extent
if roi_width > 0 and roi_height > 0:
# take into account if the footage was already focused onto a previous ROI
if self._roi is not None:
roi_x += self._roi.x()
roi_y += self._roi.y()
# update spin box values
self._accept_roi_updates_from_boxes = False # disable ROI changes from the spin boxes
self._box_roi_x.setValue(roi_x)
self._box_roi_y.setValue(roi_y)
self._box_roi_width.setValue(roi_width)
self._box_roi_height.setValue(roi_height)
self._accept_roi_updates_from_boxes = True # enable ROI changes from the spin boxes
self.set_roi(QRect(roi_x, roi_y, roi_width,
roi_height)) # set ROI
self._selection_start = None # remove selection start
return False
def sizeHint(self):
"""
Needed for widget to expand properly on the UI (Should be improved)
"""
return QSize(1200, 1200)
def load(self, path):
"""
Load a video file from the given path
:param path: path of the file
"""
if self.video_file_open: # close current video file if one was open
self.close()
self._media_player.setMedia(QMediaContent(QUrl.fromLocalFile(path)))
self._video_file_open = True
self._media_player.pause()
def _player_time_changed_(self, position):
self._timeline.setValueSilent(position)
if self._allow_frame_counter_update:
self._current_frame = self._time_code_to_frame_number_(position)
# used for updating keyframes
self._image_control.current_frame = self._current_frame
# update the UI
self._current_time.setText('{:10.3f}'.format(
round(position / 1000 - self._start_trim, 3)))
self._frame_box.setText('(frame: {:04})'.format(self.current_frame))
# send event about frame change
for callback in self.time_code_changed:
callback(position / 1000 - self._start_trim)
def _meta_data_changed_(self, available):
if self._media_player.isMetaDataAvailable():
resolution = self._media_player.metaData('Resolution')
self._duration_time_code = self._media_player.metaData(
'Duration') # get duration in ms
self._fps = self._media_player.metaData(
'VideoFrameRate') # get frames per second of the video
self._media_player.setNotifyInterval(1000 / self._fps)
self._frame_count = self._time_code_to_frame_number_(
self._duration_time_code) # get total video frames
self._video_width = resolution.width() # get width of the image
self._video_height = resolution.height() # get height of the image
self.start_trim = 0 # no trimming when video is loaded
self._start_frame = 0 # first frame is also the first frame of the video
self._duration = self._duration_time_code / 1000
self._end_frame = self._frame_count - 1 # don't trim the end of the video
self.end_trim = self.duration # use the duration of the video as trim mark (no trimming)
# set maximum values of the ROI spin boxes
self._box_roi_x.setMaximum(self._video_width)
self._box_roi_width.setMaximum(self._video_width)
self._box_roi_y.setMaximum(self._video_height)
self._box_roi_height.setMaximum(self._video_height)
# update the data on the UI elements
self._total_time.setText('{:10.3f}'.format(self._end_trim -
self._start_trim))
self._frame_box.setText('(Frame: 0000)')
self._timeline.setValue(0)
self._timeline.setMaximum(self._duration_time_code)
self._timeline.setEnabled(True)
self._play_button.setEnabled(True)
self._stop_button.setEnabled(True)
self._next_frame_button.setEnabled(True)
self._previous_frame_button.setEnabled(True)
self.reset_roi()
meta_data = dict()
for key in self._media_player.availableMetaData():
meta_data[key] = self._media_player.metaData(key)
self.meta_data_loaded.emit(meta_data)
def _frame_ready_(self, frame):
if self._roi is not None: # crop the frame to the ROI if one has been specified
self._result_frame = frame.copy(self._roi)
else:
self._result_frame = frame
self._image_control.set_image(self._result_frame)
self._wait = False
if self._media_player.position() > self.end_trim * 1000:
self.pause()
self._media_player.setPosition(self.end_trim * 1000)
elif self._media_player.position() < self.start_trim * 1000:
self.pause()
self._media_player.setPosition(self.start_trim * 1000)
def set_time(self, seconds):
"""
Display the frame that is the closest to the given time
:param seconds: time at which to display the frame in seconds
"""
if not self.video_file_open:
return
self._media_player.setPosition(seconds * 1000)
def get_time(self, frame_number):
"""
Return the time code at the specified frame
:param frame_number: frame number
:return: time code in seconds
"""
if not self.video_file_open: # return zero if no file is opened
return 0
frame_number = self._clamp_frame_number_(frame_number)
return frame_number / self.fps - self._start_trim
@staticmethod
def _to_numpy_array_(frame):
channels = int(frame.byteCount() / frame.width() / frame.height())
bits = frame.bits()
bits.setsize(frame.byteCount())
return np.frombuffer(bits, np.uint8).reshape(frame.height(),
frame.width(), channels)
def get_frame(self, frame_number, wait_for_new_frame=False):
"""
Returns a numpy array containing the video frame at the given frame number
:param frame_number: frame number
:param wait_for_new_frame: Makes sure that a new frame is retrieved before it is returned (otherwise most recent is returned)
:return: numpy array
"""
if not self.video_file_open: # return None if no video file is opened
return None
frame_number = self._clamp_frame_number_(frame_number)
if wait_for_new_frame:
self._wait = True
old_interval = self._media_player.notifyInterval()
self._media_player.setNotifyInterval(1)
self._media_player.setPosition(
self._frame_number_to_time_code(frame_number))
while self._wait:
sleep(0.001)
self._media_player.setNotifyInterval(old_interval)
result_frame = self._result_frame
data = self._to_numpy_array_(result_frame)
return data
def _clamp_frame_number_(self, frame_number):
"""
Clamps the given frame number to an allowed range
:param frame_number: frame number
:return: frame number between 0 and frame_count - 1
"""
if frame_number < self._start_frame:
frame_number = self._start_frame
elif frame_number > self._end_frame:
frame_number = self._end_frame
return int(frame_number)
def _clamp_time_code_(self, time_code):
"""
Clamps the given time code to an allowed range
:param time_code: time code (in ms)
:return: time code (in ms)
"""
if time_code < self._start_trim * 1000:
time_code = self._start_trim * 1000
elif time_code > self._end_trim * 1000:
time_code = self._end_trim * 1000
return time_code
def set_roi(self, rect: QRect):
"""
Sets the region of interest on the video footage.
:param rect: rectangle representing the region of interest
"""
self._roi = rect
self._box_roi_x.setValue(rect.x())
self._box_roi_y.setValue(rect.y())
self._box_roi_width.setValue(rect.width())
self._box_roi_height.setValue(rect.height())
if self._frame_count > 0:
self._display_time_code_(
self._timeline.value()) # update the display
def reset_roi(self):
"""
Reset the region of interest
"""
self._roi = None
# set the full image as ROI on the spin boxes
self._accept_roi_updates_from_boxes = False # stop the spin boxes from updating the ROI
self._box_roi_x.setValue(0)
self._box_roi_y.setValue(0)
self._box_roi_width.setValue(self._video_width)
self._box_roi_height.setValue(self._video_height)
self._accept_roi_updates_from_boxes = True # re-enable the spin boxes to update the ROI
if self._frame_count > 0:
self._display_time_code_(self._timeline.value())
def play(self):
"""
Start playing the video that is currently loaded.
"""
if self.is_playing: # do nothing if the video is already playing
return
self._media_player.play()
self._play_button.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause)) # set pause button icon to pause
def pause(self):
"""
Pauses the video.
"""
self._media_player.pause()
self._play_button.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay)) # set pause button icon to play
def stop(self):
"""
Stop the video and rewind.
"""
self.pause() # stop the video from playing
self._media_player.setPosition(self.start_trim *
1000) # return to the first frame
def next_frame(self):
"""
Skip one frame ahead.
"""
if self.current_frame < self.end_frame:
self.current_frame += 1
def previous_frame(self):
"""
Skip to the previous frame.
"""
if self.current_frame > self.start_frame:
self.current_frame -= 1
def _play_pause_(self):
"""
Play if the video is paused or pause if the video is currently playing.
"""
if self.is_playing:
self.pause()
else:
self.play()
def _display_time_code_(self, time_code):
"""
Displays the requested time code on the widget.
:param time_code: time code (in ms)
"""
if not self.video_file_open: # do nothing if no video file is open
return
time_code = self._clamp_time_code_(time_code) # get proper time code
self._media_player.setPosition(time_code)
def _roi_box_value_changed_(self, *args):
"""
Callback for changes made in the ROI spin boxes. Adjust the ROI accordingly.
"""
if self._accept_roi_updates_from_boxes:
roi_x = self._box_roi_x.value()
roi_y = self._box_roi_y.value()
roi_width = self._box_roi_width.value()
roi_height = self._box_roi_height.value()
self.set_roi(QRect(roi_x, roi_y, roi_width, roi_height))
def close(self):
"""
Closes the video file which is currently opened.
"""
if self._video_file_open:
self._media_player.stop()
self._frame_count = 0 # set the frame count to zero
self._fps = 1 # set the frames per second to zero
self._media_player.setPosition(0) # set the timeline to zero
self._timeline.setEnabled(False) # disable the timeline
self._play_button.setEnabled(False) # disable the play button
self._stop_button.setEnabled(False) # disable the stop button
self._next_frame_button.setEnabled(
True) # disable the skip frame button
self._previous_frame_button.setEnabled(
True) # disable the previous frame button
self._current_time.setText(
'0.000') # set the current time code to zero
self._total_time.setText('0.000') # set the total time to zero
self._frame_box.setText(
'(frame: 0000)') # set the current frame to zero
self._box_roi_x.setMaximum(0) # set the ROI maximum to zero
self._box_roi_width.setMaximum(0) # set the ROI maximum to zero
self._box_roi_y.setMaximum(0) # set the ROI maximum to zero
self._box_roi_height.setMaximum(0) # set the ROI maximum to zero
self.reset_roi() # reset the ROI
def _setup_(self):
self._image_control = ImageRenderWidget()
self._image_control.overlay_layers.append(self._selection_layer)
self._layout.addWidget(self._image_control, 0, 0, 1, 10,
Qt.AlignCenter)
self._timeline = QJumpSlider(Qt.Horizontal)
self._timeline.setEnabled(False)
self._timeline.valueChangedSmart.connect(self._display_time_code_)
self._layout.addWidget(self._timeline, 1, 4)
self._current_time = QLabel('0.000')
self._total_time = QLabel('0.000')
self._frame_box = QLabel('(Frame: 0000)')
self._layout.addWidget(self._current_time, 1, 5)
self._layout.addWidget(QLabel('/'), 1, 6)
self._layout.addWidget(self._total_time, 1, 7)
self._layout.addWidget(QLabel(' s'), 1, 8)
self._layout.addWidget(self._frame_box, 1, 9)
self._play_button = QPushButton()
self._play_button.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
self._play_button.setEnabled(False)
self._play_button.clicked.connect(self._play_pause_)
self._layout.addWidget(self._play_button, 1, 0)
self._stop_button = QPushButton()
self._stop_button.setIcon(self.style().standardIcon(
QStyle.SP_MediaStop))
self._stop_button.setEnabled(False)
self._stop_button.clicked.connect(self.stop)
self._layout.addWidget(self._stop_button, 1, 1)
self._next_frame_button = QPushButton()
self._next_frame_button.setIcon(self.style().standardIcon(
QStyle.SP_MediaSkipForward))
self._next_frame_button.setEnabled(False)
self._next_frame_button.clicked.connect(self.next_frame)
self._layout.addWidget(self._next_frame_button, 1, 3)
self._previous_frame_button = QPushButton()
self._previous_frame_button.setIcon(self.style().standardIcon(
QStyle.SP_MediaSkipBackward))
self._previous_frame_button.setEnabled(False)
self._previous_frame_button.clicked.connect(self.previous_frame)
self._layout.addWidget(self._previous_frame_button, 1, 2)
roi_frame = QFrame()
roi_layout = QHBoxLayout()
roi_frame.setLayout(roi_layout)
roi_frame.setFixedHeight(38)
roi_layout.addWidget(QLabel('ROI: ['))
roi_layout.addWidget(QLabel('x:'))
self._box_roi_x = QSpinBox()
roi_layout.addWidget(self._box_roi_x)
roi_layout.addWidget(QLabel('y:'))
self._box_roi_y = QSpinBox()
roi_layout.addWidget(self._box_roi_y)
roi_layout.addWidget(QLabel('width:'))
self._box_roi_width = QSpinBox()
roi_layout.addWidget(self._box_roi_width)
roi_layout.addWidget(QLabel('height:'))
self._box_roi_height = QSpinBox()
roi_layout.addWidget(self._box_roi_height)
roi_layout.addWidget(QLabel(']'))
roi_reset_button = QPushButton('Reset')
roi_reset_button.clicked.connect(self.reset_roi)
roi_layout.addWidget(roi_reset_button)
self._box_roi_x.valueChanged.connect(self._roi_box_value_changed_)
self._box_roi_y.valueChanged.connect(self._roi_box_value_changed_)
self._box_roi_width.valueChanged.connect(self._roi_box_value_changed_)
self._box_roi_height.valueChanged.connect(self._roi_box_value_changed_)
self._layout.addWidget(roi_frame, 2, 0, 1, 9, Qt.AlignLeft)
class MediaPlayerTab(GalacteekTab):
statePlaying = QMediaPlayer.PlayingState
statePaused = QMediaPlayer.PausedState
stateStopped = QMediaPlayer.StoppedState
def __init__(self, *args, **kw):
super(MediaPlayerTab, self).__init__(*args, **kw)
self.playlistIpfsPath = None
self.playlist = QMediaPlaylist()
self.model = ListModel(self.playlist)
self.playlistsMenu = QMenu(self)
self.playlistsMenu.triggered.connect(self.onPlaylistsMenu)
self.pListWidget = QWidget(self)
self.uipList = ui_mediaplaylist.Ui_MediaPlaylist()
self.uipList.setupUi(self.pListWidget)
self.uipList.savePlaylistButton.clicked.connect(self.onSavePlaylist)
self.uipList.savePlaylistButton.setEnabled(False)
self.uipList.loadPlaylistButton.setPopupMode(QToolButton.InstantPopup)
self.uipList.loadPlaylistButton.setMenu(self.playlistsMenu)
self.clipMenu = QMenu(self)
self.copyPathAction = QAction(getIconIpfsIce(),
iCopyPlaylistPath(),
self,
triggered=self.onCopyPlaylistPath)
self.loadPathAction = QAction(getIconIpfsIce(),
iLoadPlaylistFromPath(),
self,
triggered=self.onLoadPlaylistPath)
self.copyPathAction.setEnabled(False)
self.clipMenu.addAction(self.copyPathAction)
self.clipMenu.addAction(self.loadPathAction)
self.uipList.clipPlaylistButton.setPopupMode(QToolButton.InstantPopup)
self.uipList.clipPlaylistButton.setMenu(self.clipMenu)
self.uipList.clearButton.clicked.connect(self.onClearPlaylist)
self.uipList.nextButton.clicked.connect(self.onPlaylistNext)
self.uipList.previousButton.clicked.connect(self.onPlaylistPrevious)
self.uipList.nextButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaSkipForward))
self.uipList.previousButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaSkipBackward))
self.pListView = self.uipList.listView
self.pListView.mousePressEvent = self.playlistMousePressEvent
self.pListView.setModel(self.model)
self.pListView.setResizeMode(QListView.Adjust)
self.pListView.setMinimumWidth(self.width() / 2)
self.duration = None
self.playerState = None
self.player = QMediaPlayer(self)
self.player.setPlaylist(self.playlist)
self.videoWidget = MPlayerVideoWidget(self.player, self)
self.useUpdates(True)
self.videoWidget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.player.setVideoOutput(self.videoWidget)
self.player.error.connect(self.onError)
self.player.stateChanged.connect(self.onStateChanged)
self.player.metaDataChanged.connect(self.onMetaData)
self.player.durationChanged.connect(self.mediaDurationChanged)
self.player.positionChanged.connect(self.mediaPositionChanged)
self.player.videoAvailableChanged.connect(self.onVideoAvailable)
self.pListView.activated.connect(self.onListActivated)
self.playlist.currentIndexChanged.connect(self.playlistPositionChanged)
self.playlist.currentMediaChanged.connect(self.playlistMediaChanged)
self.playlist.mediaInserted.connect(self.playlistMediaInserted)
self.playlist.mediaRemoved.connect(self.playlistMediaRemoved)
self.togglePList = QToolButton(self)
self.togglePList.setIcon(self.style().standardIcon(
QStyle.SP_ArrowRight))
self.togglePList.setFixedSize(32, 128)
self.togglePList.clicked.connect(self.onTogglePlaylist)
self.clipboardMediaItem = None
self.clipboardButton = QToolButton(clicked=self.onClipboardClicked)
self.clipboardButton.setIcon(getIconClipboard())
self.clipboardButton.setEnabled(False)
self.clipboardButton.setToolTip('Load media from clipboard')
self.pinButton = QToolButton(clicked=self.onPinMediaClicked)
self.pinButton.setIcon(getIcon('pin.png'))
self.processClipboardItem(self.app.clipTracker.current, force=True)
self.app.clipTracker.currentItemChanged.connect(self.onClipItemChange)
self.playButton = QToolButton(clicked=self.onPlayClicked)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.pauseButton = QToolButton(clicked=self.onPauseClicked)
self.pauseButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
self.pauseButton.setEnabled(False)
self.stopButton = QToolButton(clicked=self.onStopClicked)
self.stopButton.setIcon(self.style().standardIcon(QStyle.SP_MediaStop))
self.stopButton.setEnabled(False)
self.fullscreenButton = QToolButton(clicked=self.onFullScreen)
self.fullscreenButton.setIcon(getIcon('fullscreen.png'))
self.fullscreenButton.setToolTip(iFullScreen())
self.seekSlider = QSlider(Qt.Horizontal, sliderMoved=self.onSeek)
self.seekSlider.sliderReleased.connect(self.onSliderReleased)
self.seekSlider.setObjectName('mediaPlayerSlider')
self.durationLabel = QLabel()
vLayout = QVBoxLayout()
hLayoutControls = QHBoxLayout()
hLayoutControls.setContentsMargins(0, 0, 0, 0)
hLayoutControls.addWidget(self.clipboardButton)
hLayoutControls.addWidget(self.pinButton)
hLayoutControls.addWidget(self.playButton)
hLayoutControls.addWidget(self.pauseButton)
hLayoutControls.addWidget(self.stopButton)
hLayoutControls.addWidget(self.seekSlider)
hLayoutControls.addWidget(self.durationLabel)
hLayoutControls.addWidget(self.fullscreenButton)
vLayout.addWidget(self.videoWidget)
vLayout.addLayout(hLayoutControls)
hLayout = QHBoxLayout()
hLayout.addLayout(vLayout)
hLayout.addWidget(self.pListWidget)
hLayout.addWidget(self.togglePList)
self.pListWidget.hide()
self.vLayout.addLayout(hLayout)
self.update()
self.videoWidget.changeFocus()
@property
def isPlaying(self):
return self.playerState == self.statePlaying
@property
def isPaused(self):
return self.playerState == self.statePaused
@property
def isStopped(self):
return self.playerState == self.stateStopped
def useUpdates(self, updates=True):
# Enable widget updates or not on the video widget
self.videoWidget.setUpdatesEnabled(updates)
def update(self):
self.app.task(self.updatePlaylistsMenu)
def onFullScreen(self):
self.videoWidget.viewFullScreen(True)
def onClearPlaylist(self):
self.copyPathAction.setEnabled(False)
self.player.stop()
self.clearPlaylist()
def onLoadPlaylistPath(self):
current = self.app.clipTracker.getCurrent()
if current:
self.app.task(self.loadPlaylistFromPath, current.path)
def onCopyPlaylistPath(self):
if self.playlistIpfsPath:
self.app.setClipboardText(self.playlistIpfsPath)
def onPinMediaClicked(self):
currentMedia = self.playlist.currentMedia()
if currentMedia.isNull():
return messageBox(iNoMediaInPlaylist())
ensure(self.pinMedia(currentMedia))
@ipfsOp
async def pinMedia(self, ipfsop, media):
mediaUrl = qurlPercentDecode(media.canonicalUrl())
path = IPFSPath(mediaUrl, autoCidConv=True)
if path.valid:
await ipfsop.ctx.pin(str(path), qname='mediaplayer')
@ipfsOp
async def updatePlaylistsMenu(self, ipfsop):
currentList = [
action.text() for action in self.playlistsMenu.actions()
]
listing = await ipfsop.filesList(self.profile.pathPlaylists)
for entry in listing:
if entry['Name'] in currentList:
continue
action = QAction(entry['Name'], self)
action.setData(entry)
self.playlistsMenu.addAction(action)
def playlistShowContextMenu(self, event):
selModel = self.pListView.selectionModel()
idx = self.pListView.indexAt(event.pos())
if not idx.isValid():
return
path = self.model.data(idx)
if path:
selModel.reset()
selModel.select(idx, QItemSelectionModel.Select)
menu = QMenu(self)
menu.addAction(getIcon('clear-all.png'), iPlaylistRemoveMedia(),
functools.partial(self.onRemoveMediaFromIndex, idx))
menu.exec_(event.globalPos())
def onRemoveMediaFromIndex(self, idx):
self.playlist.removeMedia(idx.row())
def playlistMousePressEvent(self, event):
if event.button() == Qt.RightButton:
self.pListView.selectionModel().reset()
self.playlistShowContextMenu(event)
else:
if not self.pListView.indexAt(event.pos()).isValid():
self.deselectPlaylistItems()
QListView.mousePressEvent(self.pListView, event)
def onPlaylistsMenu(self, action):
entry = action.data()
self.app.task(self.loadPlaylistFromPath, joinIpfs(entry['Hash']))
def onSavePlaylist(self):
paths = self.playlistGetPaths()
listName = inputText(title=iPlaylistName(), label=iPlaylistName())
if not listName:
return
obj = JSONPlaylistV1(listName=listName, itemPaths=paths)
self.app.task(self.savePlaylist, obj, listName)
@ipfsOp
async def savePlaylist(self, ipfsop, obj, name):
objPath = os.path.join(self.profile.pathPlaylists, name)
exists = await ipfsop.filesStat(objPath)
if exists:
await ipfsop.filesRm(objPath)
ent = await ipfsop.client.core.add_json(obj.root)
if ent:
await ipfsop.filesLinkFp(ent, objPath)
self.playlistIpfsPath = joinIpfs(ent['Hash'])
self.copyPathAction.setEnabled(True)
self.update()
@ipfsOp
async def loadPlaylistFromPath(self, ipfsop, path):
try:
obj = await ipfsop.jsonLoad(path)
except Exception:
return messageBox(iCannotLoadPlaylist())
if obj is None:
return messageBox(iCannotLoadPlaylist())
try:
# Assume v1 format for now, when the format evolves we'll just
# use json validation
pList = JSONPlaylistV1(data=obj)
self.clearPlaylist()
for item in pList.items():
self.queueFromPath(item['path'])
self.playlistIpfsPath = path
self.copyPathAction.setEnabled(True)
except Exception:
return messageBox(iCannotLoadPlaylist())
def playlistMediaInserted(self, start, end):
self.uipList.savePlaylistButton.setEnabled(
self.playlist.mediaCount() > 0)
def playlistMediaRemoved(self, start, end):
self.uipList.savePlaylistButton.setEnabled(
self.playlist.mediaCount() > 0)
self.model.modelReset.emit()
def playlistGetPaths(self):
return [u.path() for u in self.playlistGetUrls()]
def playlistGetUrls(self):
urls = []
for idx in range(0, self.playlist.mediaCount()):
media = self.playlist.media(idx)
urls.append(media.canonicalUrl())
return urls
def onClipItemChange(self, item):
self.processClipboardItem(item)
def processClipboardItem(self, item, force=False):
if not item:
return
def analyzeMimeType(cItem):
if cItem.mimeCategory in ['audio', 'video', 'image']:
self.clipboardMediaItem = cItem
self.clipboardButton.setEnabled(True)
self.clipboardButton.setToolTip(cItem.path)
else:
self.clipboardButton.setEnabled(False)
self.clipboardButton.setToolTip(iClipboardEmpty())
if force:
analyzeMimeType(item)
else:
item.mimeTypeAvailable.connect(lambda mType: analyzeMimeType(item))
def onClipboardClicked(self):
if self.clipboardMediaItem:
self.playFromPath(self.clipboardMediaItem.path)
else:
messageBox('Not a multimedia resource')
def onSliderReleased(self):
pass
def onPlaylistNext(self):
self.playlist.next()
def onPlaylistPrevious(self):
self.playlist.previous()
def onPlayClicked(self):
self.player.play()
def onPauseClicked(self):
if self.isPlaying:
self.player.pause()
elif self.isPaused:
self.player.play()
def onStopClicked(self):
self.player.stop()
self.player.setPosition(0)
self.seekSlider.setValue(0)
self.seekSlider.setRange(0, 0)
def onSeek(self, seconds):
if self.player.isSeekable():
self.player.setPosition(seconds * 1000)
def onTogglePlaylist(self):
self.pListWidget.setVisible(self.pListWidget.isHidden())
def onError(self, error):
messageBox(iPlayerError(error))
def onStateChanged(self, state):
self.playerState = state
self.updateControls(state)
def updateControls(self, state):
if self.isStopped:
self.stopButton.setEnabled(False)
self.pauseButton.setEnabled(False)
self.playButton.setEnabled(True)
self.seekSlider.setEnabled(False)
self.duration = None
elif self.isPlaying:
self.seekSlider.setRange(0, self.player.duration() / 1000)
self.seekSlider.setEnabled(True)
self.pauseButton.setEnabled(True)
self.playButton.setEnabled(False)
self.stopButton.setEnabled(True)
def onListActivated(self, index):
if index.isValid():
self.playlist.setCurrentIndex(index.row())
self.player.play()
def onMetaData(self):
# Unfinished
if self.player.isMetaDataAvailable():
availableKeys = self.player.availableMetaData()
for key in availableKeys:
self.player.metaData(key)
def playFromUrl(self, url, mediaName=None):
if self.isPlaying:
self.player.stop()
cUrls = self.playlistGetUrls()
for u in cUrls:
if u.toString() == url.toString():
return messageBox(iAlreadyInPlaylist())
media = QMediaContent(url)
if self.playlist.addMedia(media):
count = self.model.rowCount()
if count > 0:
self.playlist.setCurrentIndex(count - 1)
self.player.play()
def playFromPath(self, path, mediaName=None):
mediaUrl = self.app.subUrl(path)
self.playFromUrl(mediaUrl)
def queueFromPath(self, path, playLast=False, mediaName=None):
mediaUrl = self.app.subUrl(path)
self.playlist.addMedia(QMediaContent(mediaUrl))
if playLast:
count = self.playlist.mediaCount()
if count > 0:
self.player.stop()
self.playlist.setCurrentIndex(count - 1)
self.player.play()
def clearPlaylist(self):
self.playlist.clear()
self.pListView.reset()
def playlistPositionChanged(self, position):
self.pListView.setCurrentIndex(self.model.index(position, 0))
def deselectPlaylistItems(self):
self.pListView.selectionModel().reset()
def playlistMediaChanged(self, media):
selModel = self.pListView.selectionModel()
self.deselectPlaylistItems()
self.model.modelReset.emit()
idx = self.model.index(self.playlist.currentIndex(), 0)
if idx.isValid():
selModel.select(idx, QItemSelectionModel.Select)
def onVideoAvailable(self, available):
if available:
if self.isPlaying:
self.useUpdates(False)
elif self.isStopped or self.isPaused:
self.useUpdates(True)
else:
self.useUpdates(True)
def mediaDurationChanged(self, duration):
self.duration = duration / 1000
self.seekSlider.setMaximum(self.duration)
def mediaPositionChanged(self, progress):
progress /= 1000
if self.duration:
cTime = durationConvert(progress)
tTime = durationConvert(self.duration)
self.durationLabel.setText('{0} ({1})'.format(
cTime.toString(), tTime.toString()))
if not self.seekSlider.isSliderDown():
self.seekSlider.setValue(progress)
async def onClose(self):
self.player.stop()
self.player.setMedia(QMediaContent(None))
return True
def playerAvailable(self):
return mediaPlayerAvailable(player=self.player)
class VidCutter(QWidget):
def __init__(self, parent):
super(VidCutter, self).__init__(parent)
self.novideoWidget = QWidget(self, autoFillBackground=True)
self.parent = parent
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoWidget = VideoWidget(self)
self.videoService = VideoService(self)
QFontDatabase.addApplicationFont(
MainWindow.get_path('fonts/DroidSansMono.ttf'))
QFontDatabase.addApplicationFont(
MainWindow.get_path('fonts/OpenSans.ttf'))
fontSize = 12 if sys.platform == 'darwin' else 10
appFont = QFont('Open Sans', fontSize, 300)
qApp.setFont(appFont)
self.clipTimes = []
self.inCut = False
self.movieFilename = ''
self.movieLoaded = False
self.timeformat = 'hh:mm:ss'
self.finalFilename = ''
self.totalRuntime = 0
self.initIcons()
self.initActions()
self.toolbar = QToolBar(floatable=False,
movable=False,
iconSize=QSize(40, 36))
self.toolbar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.toolbar.setStyleSheet('''QToolBar { spacing:10px; }
QToolBar QToolButton { border:1px solid transparent; min-width:95px; font-size:11pt; font-weight:400;
border-radius:5px; padding:1px 2px; color:#444; }
QToolBar QToolButton:hover { border:1px inset #6A4572; color:#6A4572; background-color:rgba(255, 255, 255, 0.85); }
QToolBar QToolButton:pressed { border:1px inset #6A4572; color:#6A4572; background-color:rgba(255, 255, 255, 0.25); }
QToolBar QToolButton:disabled { color:#999; }''')
self.initToolbar()
self.appMenu, self.cliplistMenu = QMenu(), QMenu()
self.initMenus()
self.seekSlider = VideoSlider(parent=self,
sliderMoved=self.setPosition)
self.initNoVideo()
self.cliplist = QListWidget(
sizePolicy=QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding),
contextMenuPolicy=Qt.CustomContextMenu,
uniformItemSizes=True,
iconSize=QSize(100, 700),
dragDropMode=QAbstractItemView.InternalMove,
alternatingRowColors=True,
customContextMenuRequested=self.itemMenu,
dragEnabled=True)
self.cliplist.setStyleSheet(
'QListView { border-radius:0; border:none; border-left:1px solid #B9B9B9; '
+
'border-right:1px solid #B9B9B9; } QListView::item { padding:10px 0; }'
)
self.cliplist.setFixedWidth(185)
self.cliplist.model().rowsMoved.connect(self.syncClipList)
listHeader = QLabel(pixmap=QPixmap(
MainWindow.get_path('images/clipindex.png'), 'PNG'),
alignment=Qt.AlignCenter)
listHeader.setStyleSheet(
'''padding:5px; padding-top:8px; border:1px solid #b9b9b9;
background-color:qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 #FFF,
stop: 0.5 #EAEAEA, stop: 0.6 #EAEAEA stop:1 #FFF);'''
)
self.runtimeLabel = QLabel('<div align="right">00:00:00</div>',
textFormat=Qt.RichText)
self.runtimeLabel.setStyleSheet(
'''font-family:Droid Sans Mono; font-size:10pt; color:#FFF;
background:rgb(106, 69, 114) url(:images/runtime.png)
no-repeat left center; padding:2px; padding-right:8px;
border:1px solid #B9B9B9;''')
self.clipindexLayout = QVBoxLayout(spacing=0)
self.clipindexLayout.setContentsMargins(0, 0, 0, 0)
self.clipindexLayout.addWidget(listHeader)
self.clipindexLayout.addWidget(self.cliplist)
self.clipindexLayout.addWidget(self.runtimeLabel)
self.videoLayout = QHBoxLayout()
self.videoLayout.setContentsMargins(0, 0, 0, 0)
self.videoLayout.addWidget(self.novideoWidget)
self.videoLayout.addLayout(self.clipindexLayout)
self.timeCounter = QLabel('00:00:00 / 00:00:00',
autoFillBackground=True,
alignment=Qt.AlignCenter,
sizePolicy=QSizePolicy(
QSizePolicy.Expanding,
QSizePolicy.Fixed))
self.timeCounter.setStyleSheet(
'color:#FFF; background:#000; font-family:Droid Sans Mono; font-size:10.5pt; padding:4px;'
)
videoplayerLayout = QVBoxLayout(spacing=0)
videoplayerLayout.setContentsMargins(0, 0, 0, 0)
videoplayerLayout.addWidget(self.videoWidget)
videoplayerLayout.addWidget(self.timeCounter)
self.videoplayerWidget = QWidget(self, visible=False)
self.videoplayerWidget.setLayout(videoplayerLayout)
self.muteButton = QPushButton(icon=self.unmuteIcon,
flat=True,
toolTip='Mute',
statusTip='Toggle audio mute',
iconSize=QSize(16, 16),
cursor=Qt.PointingHandCursor,
clicked=self.muteAudio)
self.volumeSlider = QSlider(Qt.Horizontal,
toolTip='Volume',
statusTip='Adjust volume level',
cursor=Qt.PointingHandCursor,
value=50,
minimum=0,
maximum=100,
sliderMoved=self.setVolume)
self.menuButton = QPushButton(
icon=self.menuIcon,
flat=True,
toolTip='Menu',
statusTip='Media + application information',
iconSize=QSize(24, 24),
cursor=Qt.PointingHandCursor)
self.menuButton.setMenu(self.appMenu)
toolbarLayout = QHBoxLayout()
toolbarLayout.addWidget(self.toolbar)
toolbarLayout.setContentsMargins(2, 2, 2, 2)
toolbarGroup = QGroupBox()
toolbarGroup.setFlat(False)
toolbarGroup.setCursor(Qt.PointingHandCursor)
toolbarGroup.setLayout(toolbarLayout)
toolbarGroup.setStyleSheet(
'''QGroupBox { background-color:rgba(0, 0, 0, 0.1);
border:1px inset #888; border-radius:5px; }''')
controlsLayout = QHBoxLayout(spacing=0)
controlsLayout.addStretch(1)
controlsLayout.addWidget(toolbarGroup)
controlsLayout.addStretch(1)
controlsLayout.addWidget(self.muteButton)
controlsLayout.addWidget(self.volumeSlider)
controlsLayout.addSpacing(1)
controlsLayout.addWidget(self.menuButton)
layout = QVBoxLayout()
layout.setContentsMargins(10, 10, 10, 4)
layout.addLayout(self.videoLayout)
layout.addWidget(self.seekSlider)
layout.addSpacing(5)
layout.addLayout(controlsLayout)
layout.addSpacing(2)
self.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 initNoVideo(self) -> None:
novideoImage = QLabel(
alignment=Qt.AlignCenter,
autoFillBackground=False,
pixmap=QPixmap(MainWindow.get_path('images/novideo.png'), 'PNG'),
sizePolicy=QSizePolicy(QSizePolicy.Expanding,
QSizePolicy.MinimumExpanding))
novideoImage.setBackgroundRole(QPalette.Dark)
novideoImage.setContentsMargins(0, 20, 0, 20)
self.novideoLabel = QLabel(alignment=Qt.AlignCenter,
autoFillBackground=True,
sizePolicy=QSizePolicy(
QSizePolicy.Expanding,
QSizePolicy.Minimum))
self.novideoLabel.setBackgroundRole(QPalette.Dark)
self.novideoLabel.setContentsMargins(0, 20, 15, 60)
novideoLayout = QVBoxLayout(spacing=0)
novideoLayout.addWidget(novideoImage)
novideoLayout.addWidget(self.novideoLabel, alignment=Qt.AlignTop)
self.novideoMovie = QMovie(
MainWindow.get_path('images/novideotext.gif'))
self.novideoMovie.frameChanged.connect(self.setNoVideoText)
self.novideoMovie.start()
self.novideoWidget.setBackgroundRole(QPalette.Dark)
self.novideoWidget.setLayout(novideoLayout)
def initIcons(self) -> None:
self.appIcon = QIcon(MainWindow.get_path('images/vidcutter.png'))
self.openIcon = icon('fa.film',
color='#444',
color_active='#6A4572',
scale_factor=0.9)
self.playIcon = icon('fa.play-circle-o',
color='#444',
color_active='#6A4572',
scale_factor=1.1)
self.pauseIcon = icon('fa.pause-circle-o',
color='#444',
color_active='#6A4572',
scale_factor=1.1)
self.cutStartIcon = icon('fa.scissors',
scale_factor=1.15,
color='#444',
color_active='#6A4572')
endicon_normal = icon('fa.scissors', scale_factor=1.15,
color='#444').pixmap(QSize(36, 36)).toImage()
endicon_active = icon('fa.scissors',
scale_factor=1.15,
color='#6A4572').pixmap(QSize(36, 36)).toImage()
self.cutEndIcon = QIcon()
self.cutEndIcon.addPixmap(
QPixmap.fromImage(
endicon_normal.mirrored(horizontal=True, vertical=False)),
QIcon.Normal, QIcon.Off)
self.cutEndIcon.addPixmap(
QPixmap.fromImage(
endicon_active.mirrored(horizontal=True, vertical=False)),
QIcon.Active, QIcon.Off)
self.saveIcon = icon('fa.video-camera',
color='#6A4572',
color_active='#6A4572')
self.muteIcon = QIcon(MainWindow.get_path('images/muted.png'))
self.unmuteIcon = QIcon(MainWindow.get_path('images/unmuted.png'))
self.upIcon = icon('ei.caret-up', color='#444')
self.downIcon = icon('ei.caret-down', color='#444')
self.removeIcon = icon('ei.remove', color='#B41D1D')
self.removeAllIcon = icon('ei.trash', color='#B41D1D')
self.successIcon = QIcon(MainWindow.get_path('images/success.png'))
self.menuIcon = icon('fa.cog', color='#444', scale_factor=1.15)
self.completePlayIcon = icon('fa.play', color='#444')
self.completeOpenIcon = icon('fa.folder-open', color='#444')
self.completeRestartIcon = icon('fa.retweet', color='#444')
self.completeExitIcon = icon('fa.sign-out', color='#444')
self.mediaInfoIcon = icon('fa.info-circle', color='#444')
self.updateCheckIcon = icon('fa.cloud-download', color='#444')
def initActions(self) -> None:
self.openAction = QAction(self.openIcon,
'Open',
self,
statusTip='Open media file',
triggered=self.openMedia)
self.playAction = QAction(self.playIcon,
'Play',
self,
statusTip='Play media file',
triggered=self.playMedia,
enabled=False)
self.cutStartAction = QAction(self.cutStartIcon,
' Start',
self,
toolTip='Start',
statusTip='Set clip start marker',
triggered=self.setCutStart,
enabled=False)
self.cutEndAction = QAction(self.cutEndIcon,
' End',
self,
toolTip='End',
statusTip='Set clip end marker',
triggered=self.setCutEnd,
enabled=False)
self.saveAction = QAction(self.saveIcon,
'Save',
self,
statusTip='Save clips to a new video file',
triggered=self.cutVideo,
enabled=False)
self.moveItemUpAction = QAction(
self.upIcon,
'Move up',
self,
statusTip='Move clip position up in list',
triggered=self.moveItemUp,
enabled=False)
self.moveItemDownAction = QAction(
self.downIcon,
'Move down',
self,
statusTip='Move clip position down in list',
triggered=self.moveItemDown,
enabled=False)
self.removeItemAction = QAction(
self.removeIcon,
'Remove clip',
self,
statusTip='Remove selected clip from list',
triggered=self.removeItem,
enabled=False)
self.removeAllAction = QAction(self.removeAllIcon,
'Clear list',
self,
statusTip='Clear all clips from list',
triggered=self.clearList,
enabled=False)
self.mediaInfoAction = QAction(
self.mediaInfoIcon,
'Media information',
self,
statusTip='View current media file information',
triggered=self.mediaInfo,
enabled=False)
self.updateCheckAction = QAction(
self.updateCheckIcon,
'Check for updates...',
self,
statusTip='Check for application updates',
triggered=self.updateCheck)
self.aboutQtAction = QAction('About Qt',
self,
statusTip='About Qt',
triggered=qApp.aboutQt)
self.aboutAction = QAction('About %s' % qApp.applicationName(),
self,
statusTip='Credits and licensing',
triggered=self.aboutInfo)
def initToolbar(self) -> None:
self.toolbar.addAction(self.openAction)
self.toolbar.addAction(self.playAction)
self.toolbar.addAction(self.cutStartAction)
self.toolbar.addAction(self.cutEndAction)
self.toolbar.addAction(self.saveAction)
def initMenus(self) -> None:
self.appMenu.addAction(self.mediaInfoAction)
self.appMenu.addAction(self.updateCheckAction)
self.appMenu.addSeparator()
self.appMenu.addAction(self.aboutQtAction)
self.appMenu.addAction(self.aboutAction)
self.cliplistMenu.addAction(self.moveItemUpAction)
self.cliplistMenu.addAction(self.moveItemDownAction)
self.cliplistMenu.addSeparator()
self.cliplistMenu.addAction(self.removeItemAction)
self.cliplistMenu.addAction(self.removeAllAction)
@staticmethod
def getSpacer() -> QWidget:
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
return spacer
def setRunningTime(self, runtime: str) -> None:
self.runtimeLabel.setText('<div align="right">%s</div>' % runtime)
@pyqtSlot(int)
def setNoVideoText(self) -> None:
self.novideoLabel.setPixmap(self.novideoMovie.currentPixmap())
def itemMenu(self, pos: QPoint) -> None:
globalPos = self.cliplist.mapToGlobal(pos)
self.moveItemUpAction.setEnabled(False)
self.moveItemDownAction.setEnabled(False)
self.removeItemAction.setEnabled(False)
self.removeAllAction.setEnabled(False)
index = self.cliplist.currentRow()
if index != -1:
if not self.inCut:
if index > 0:
self.moveItemUpAction.setEnabled(True)
if index < self.cliplist.count() - 1:
self.moveItemDownAction.setEnabled(True)
if self.cliplist.count() > 0:
self.removeItemAction.setEnabled(True)
if self.cliplist.count() > 0:
self.removeAllAction.setEnabled(True)
self.cliplistMenu.exec_(globalPos)
def moveItemUp(self) -> None:
index = self.cliplist.currentRow()
tmpItem = self.clipTimes[index]
del self.clipTimes[index]
self.clipTimes.insert(index - 1, tmpItem)
self.renderTimes()
def moveItemDown(self) -> None:
index = self.cliplist.currentRow()
tmpItem = self.clipTimes[index]
del self.clipTimes[index]
self.clipTimes.insert(index + 1, tmpItem)
self.renderTimes()
def removeItem(self) -> None:
index = self.cliplist.currentRow()
del self.clipTimes[index]
if self.inCut and index == self.cliplist.count() - 1:
self.inCut = False
self.initMediaControls()
self.renderTimes()
def clearList(self) -> None:
self.clipTimes.clear()
self.cliplist.clear()
self.inCut = False
self.renderTimes()
self.initMediaControls()
def mediaInfo(self) -> None:
if self.mediaPlayer.isMetaDataAvailable():
content = '<table cellpadding="4">'
for key in self.mediaPlayer.availableMetaData():
val = self.mediaPlayer.metaData(key)
if type(val) is QSize:
val = '%s x %s' % (val.width(), val.height())
content += '<tr><td align="right"><b>%s:</b></td><td>%s</td></tr>\n' % (
key, val)
content += '</table>'
mbox = QMessageBox(windowTitle='Media Information',
windowIcon=self.parent.windowIcon(),
textFormat=Qt.RichText)
mbox.setText('<b>%s</b>' % os.path.basename(
self.mediaPlayer.currentMedia().canonicalUrl().toLocalFile()))
mbox.setInformativeText(content)
mbox.exec_()
else:
QMessageBox.critical(
self.parent, 'MEDIA ERROR',
'<h3>Could not probe media file.</h3>' +
'<p>An error occurred while analyzing the media file for its metadata details.'
+
'<br/><br/><b>This DOES NOT mean there is a problem with the file and you should '
+ 'be able to continue using it.</b></p>')
def aboutInfo(self) -> None:
about_html = '''<style>
a { color:#441d4e; text-decoration:none; font-weight:bold; }
a:hover { text-decoration:underline; }
</style>
<div style="min-width:650px;">
<p style="font-size:26pt; font-weight:bold; color:#6A4572;">%s</p>
<p>
<span style="font-size:13pt;"><b>Version: %s</b></span>
<span style="font-size:10pt;position:relative;left:5px;">( %s )</span>
</p>
<p style="font-size:13px;">
Copyright © 2016 <a href="mailto:[email protected]">Pete Alexandrou</a>
<br/>
Website: <a href="%s">%s</a>
</p>
<p style="font-size:13px;">
Thanks to the folks behind the <b>Qt</b>, <b>PyQt</b> and <b>FFmpeg</b>
projects for all their hard and much appreciated work.
</p>
<p style="font-size:11px;">
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
</p>
<p style="font-size:11px;">
This software uses libraries from the <a href="https://www.ffmpeg.org">FFmpeg</a> project under the
<a href="https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html">LGPLv2.1</a>
</p></div>''' % (qApp.applicationName(), qApp.applicationVersion(),
platform.architecture()[0], qApp.organizationDomain(),
qApp.organizationDomain())
QMessageBox.about(self.parent, 'About %s' % qApp.applicationName(),
about_html)
def openMedia(self) -> None:
filename, _ = QFileDialog.getOpenFileName(self.parent,
caption='Select video',
directory=QDir.homePath())
if filename != '':
self.loadFile(filename)
def loadFile(self, filename: str) -> None:
self.movieFilename = filename
if not os.path.exists(filename):
return
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(filename)))
self.initMediaControls(True)
self.cliplist.clear()
self.clipTimes = []
self.parent.setWindowTitle(
'%s - %s' % (qApp.applicationName(), os.path.basename(filename)))
if not self.movieLoaded:
self.videoLayout.replaceWidget(self.novideoWidget,
self.videoplayerWidget)
self.novideoMovie.stop()
self.novideoMovie.deleteLater()
self.novideoWidget.deleteLater()
self.videoplayerWidget.show()
self.videoWidget.show()
self.movieLoaded = True
if self.mediaPlayer.isVideoAvailable():
self.mediaPlayer.setPosition(1)
self.mediaPlayer.play()
self.mediaPlayer.pause()
def playMedia(self) -> None:
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
self.playAction.setText('Play')
else:
self.mediaPlayer.play()
self.playAction.setText('Pause')
def initMediaControls(self, flag: bool = True) -> None:
self.playAction.setEnabled(flag)
self.saveAction.setEnabled(False)
self.cutStartAction.setEnabled(flag)
self.cutEndAction.setEnabled(False)
self.mediaInfoAction.setEnabled(flag)
if flag:
self.seekSlider.setRestrictValue(0)
def setPosition(self, position: int) -> None:
self.mediaPlayer.setPosition(position)
def positionChanged(self, progress: int) -> None:
self.seekSlider.setValue(progress)
currentTime = self.deltaToQTime(progress)
totalTime = self.deltaToQTime(self.mediaPlayer.duration())
self.timeCounter.setText('%s / %s' % (currentTime.toString(
self.timeformat), totalTime.toString(self.timeformat)))
@pyqtSlot()
def mediaStateChanged(self) -> None:
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playAction.setIcon(self.pauseIcon)
else:
self.playAction.setIcon(self.playIcon)
def durationChanged(self, duration: int) -> None:
self.seekSlider.setRange(0, duration)
def muteAudio(self) -> None:
if self.mediaPlayer.isMuted():
self.muteButton.setIcon(self.unmuteIcon)
self.muteButton.setToolTip('Mute')
else:
self.muteButton.setIcon(self.muteIcon)
self.muteButton.setToolTip('Unmute')
self.mediaPlayer.setMuted(not self.mediaPlayer.isMuted())
def setVolume(self, volume: int) -> None:
self.mediaPlayer.setVolume(volume)
def toggleFullscreen(self) -> None:
self.videoWidget.setFullScreen(not self.videoWidget.isFullScreen())
def setCutStart(self) -> None:
self.clipTimes.append([
self.deltaToQTime(self.mediaPlayer.position()), '',
self.captureImage()
])
self.cutStartAction.setDisabled(True)
self.cutEndAction.setEnabled(True)
self.seekSlider.setRestrictValue(self.seekSlider.value(), True)
self.inCut = True
self.renderTimes()
def setCutEnd(self) -> None:
item = self.clipTimes[len(self.clipTimes) - 1]
selected = self.deltaToQTime(self.mediaPlayer.position())
if selected.__lt__(item[0]):
QMessageBox.critical(
self.parent, 'Invalid END Time',
'The clip end time must come AFTER it\'s start time. Please try again.'
)
return
item[1] = selected
self.cutStartAction.setEnabled(True)
self.cutEndAction.setDisabled(True)
self.seekSlider.setRestrictValue(0, False)
self.inCut = False
self.renderTimes()
@pyqtSlot(QModelIndex, int, int, QModelIndex, int)
def syncClipList(self, parent: QModelIndex, start: int, end: int,
destination: QModelIndex, row: int) -> None:
if start < row:
index = row - 1
else:
index = row
clip = self.clipTimes.pop(start)
self.clipTimes.insert(index, clip)
def renderTimes(self) -> None:
self.cliplist.clear()
if len(self.clipTimes) > 4:
self.cliplist.setFixedWidth(200)
else:
self.cliplist.setFixedWidth(185)
self.totalRuntime = 0
for item in self.clipTimes:
endItem = ''
if type(item[1]) is QTime:
endItem = item[1].toString(self.timeformat)
self.totalRuntime += item[0].msecsTo(item[1])
listitem = QListWidgetItem()
listitem.setTextAlignment(Qt.AlignVCenter)
if type(item[2]) is QPixmap:
listitem.setIcon(QIcon(item[2]))
self.cliplist.addItem(listitem)
marker = QLabel(
'''<style>b { font-size:7pt; } p { margin:2px 5px; }</style>
<p><b>START</b><br/>%s<br/><b>END</b><br/>%s</p>'''
% (item[0].toString(self.timeformat), endItem))
marker.setStyleSheet('border:none;')
self.cliplist.setItemWidget(listitem, marker)
listitem.setFlags(Qt.ItemIsSelectable | Qt.ItemIsDragEnabled
| Qt.ItemIsEnabled)
if len(self.clipTimes) and not self.inCut:
self.saveAction.setEnabled(True)
if self.inCut or len(self.clipTimes) == 0 or not type(
self.clipTimes[0][1]) is QTime:
self.saveAction.setEnabled(False)
self.setRunningTime(
self.deltaToQTime(self.totalRuntime).toString(self.timeformat))
@staticmethod
def deltaToQTime(millisecs: int) -> QTime:
secs = millisecs / 1000
return QTime((secs / 3600) % 60, (secs / 60) % 60, secs % 60,
(secs * 1000) % 1000)
def captureImage(self) -> QPixmap:
frametime = self.deltaToQTime(self.mediaPlayer.position()).toString(
self.timeformat)
inputfile = self.mediaPlayer.currentMedia().canonicalUrl().toLocalFile(
)
imagecap = self.videoService.capture(inputfile, frametime)
if type(imagecap) is QPixmap:
return imagecap
def cutVideo(self) -> bool:
clips = len(self.clipTimes)
filename, filelist = '', []
source = self.mediaPlayer.currentMedia().canonicalUrl().toLocalFile()
_, sourceext = os.path.splitext(source)
if clips > 0:
self.finalFilename, _ = QFileDialog.getSaveFileName(
self.parent, 'Save video', source,
'Video files (*%s)' % sourceext)
if self.finalFilename == '':
return False
qApp.setOverrideCursor(Qt.BusyCursor)
self.saveAction.setDisabled(True)
self.showProgress(clips)
file, ext = os.path.splitext(self.finalFilename)
index = 1
self.progress.setLabelText('Cutting media files...')
qApp.processEvents()
for clip in self.clipTimes:
duration = self.deltaToQTime(clip[0].msecsTo(
clip[1])).toString(self.timeformat)
filename = '%s_%s%s' % (file, '{0:0>2}'.format(index), ext)
filelist.append(filename)
self.videoService.cut(source, filename,
clip[0].toString(self.timeformat),
duration)
index += 1
if len(filelist) > 1:
self.joinVideos(filelist, self.finalFilename)
else:
QFile.remove(self.finalFilename)
QFile.rename(filename, self.finalFilename)
self.progress.setLabelText('Complete...')
self.progress.setValue(100)
qApp.processEvents()
self.progress.close()
self.progress.deleteLater()
qApp.restoreOverrideCursor()
self.complete()
return True
return False
def joinVideos(self, joinlist: list, filename: str) -> None:
listfile = os.path.normpath(
os.path.join(os.path.dirname(joinlist[0]), '.vidcutter.list'))
fobj = open(listfile, 'w')
for file in joinlist:
fobj.write('file \'%s\'\n' % file.replace("'", "\\'"))
fobj.close()
self.videoService.join(listfile, filename)
QFile.remove(listfile)
for file in joinlist:
if os.path.isfile(file):
QFile.remove(file)
def updateCheck(self) -> None:
self.updater = Updater()
self.updater.updateAvailable.connect(self.updateHandler)
self.updater.start()
def updateHandler(self, updateExists: bool, version: str = None):
if updateExists:
if Updater.notify_update(self, version) == QMessageBox.AcceptRole:
self.updater.install_update(self)
else:
Updater.notify_no_update(self)
def showProgress(self,
steps: int,
label: str = 'Analyzing media...') -> None:
self.progress = QProgressDialog(label,
None,
0,
steps,
self.parent,
windowModality=Qt.ApplicationModal,
windowIcon=self.parent.windowIcon(),
minimumDuration=0,
minimumWidth=500)
self.progress.show()
for i in range(steps):
self.progress.setValue(i)
qApp.processEvents()
time.sleep(1)
def complete(self) -> None:
info = QFileInfo(self.finalFilename)
mbox = QMessageBox(windowTitle='VIDEO PROCESSING COMPLETE',
minimumWidth=500,
textFormat=Qt.RichText)
mbox.setText(
'''
<style>
table.info { margin:6px; padding:4px 15px; }
td.label { font-weight:bold; font-size:10.5pt; text-align:right; }
td.value { font-size:10.5pt; }
</style>
<table class="info" cellpadding="4" cellspacing="0">
<tr>
<td class="label"><b>File:</b></td>
<td class="value" nowrap>%s</td>
</tr>
<tr>
<td class="label"><b>Size:</b></td>
<td class="value">%s</td>
</tr>
<tr>
<td class="label"><b>Length:</b></td>
<td class="value">%s</td>
</tr>
</table><br/>''' %
(QDir.toNativeSeparators(
self.finalFilename), self.sizeof_fmt(int(info.size())),
self.deltaToQTime(self.totalRuntime).toString(self.timeformat)))
play = mbox.addButton('Play', QMessageBox.AcceptRole)
play.setIcon(self.completePlayIcon)
play.clicked.connect(self.openResult)
fileman = mbox.addButton('Open', QMessageBox.AcceptRole)
fileman.setIcon(self.completeOpenIcon)
fileman.clicked.connect(self.openFolder)
end = mbox.addButton('Exit', QMessageBox.AcceptRole)
end.setIcon(self.completeExitIcon)
end.clicked.connect(self.close)
new = mbox.addButton('Restart', QMessageBox.AcceptRole)
new.setIcon(self.completeRestartIcon)
new.clicked.connect(self.parent.restart)
mbox.setDefaultButton(new)
mbox.setEscapeButton(new)
mbox.adjustSize()
mbox.exec_()
def sizeof_fmt(self, num: float, suffix: chr = 'B') -> str:
for unit in ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z']:
if abs(num) < 1024.0:
return "%3.1f%s%s" % (num, unit, suffix)
num /= 1024.0
return "%.1f%s%s" % (num, 'Y', suffix)
@pyqtSlot()
def openFolder(self) -> None:
self.openResult(pathonly=True)
@pyqtSlot(bool)
def openResult(self, pathonly: bool = False) -> None:
self.parent.restart()
if len(self.finalFilename) and os.path.exists(self.finalFilename):
target = self.finalFilename if not pathonly else os.path.dirname(
self.finalFilename)
QDesktopServices.openUrl(QUrl.fromLocalFile(target))
@pyqtSlot()
def startNew(self) -> None:
qApp.restoreOverrideCursor()
self.clearList()
self.seekSlider.setValue(0)
self.seekSlider.setRange(0, 0)
self.mediaPlayer.setMedia(QMediaContent())
self.initNoVideo()
self.videoLayout.replaceWidget(self.videoplayerWidget,
self.novideoWidget)
self.initMediaControls(False)
self.parent.setWindowTitle('%s' % qApp.applicationName())
def wheelEvent(self, event: QWheelEvent) -> None:
if self.mediaPlayer.isVideoAvailable(
) or self.mediaPlayer.isAudioAvailable():
if event.angleDelta().y() > 0:
newval = self.seekSlider.value() - 1000
else:
newval = self.seekSlider.value() + 1000
self.seekSlider.setValue(newval)
self.seekSlider.setSliderPosition(newval)
self.mediaPlayer.setPosition(newval)
event.accept()
def keyPressEvent(self, event: QKeyEvent) -> None:
if self.mediaPlayer.isVideoAvailable(
) or self.mediaPlayer.isAudioAvailable():
addtime = 0
if event.key() == Qt.Key_Left:
addtime = -1000
elif event.key() == Qt.Key_PageUp or event.key() == Qt.Key_Up:
addtime = -10000
elif event.key() == Qt.Key_Right:
addtime = 1000
elif event.key() == Qt.Key_PageDown or event.key() == Qt.Key_Down:
addtime = 10000
elif event.key() == Qt.Key_Enter:
self.toggleFullscreen()
elif event.key(
) == Qt.Key_Escape and self.videoWidget.isFullScreen():
self.videoWidget.setFullScreen(False)
if addtime != 0:
newval = self.seekSlider.value() + addtime
self.seekSlider.setValue(newval)
self.seekSlider.setSliderPosition(newval)
self.mediaPlayer.setPosition(newval)
event.accept()
def mousePressEvent(self, event: QMouseEvent) -> None:
if event.button() == Qt.BackButton and self.cutStartAction.isEnabled():
self.setCutStart()
event.accept()
elif event.button(
) == Qt.ForwardButton and self.cutEndAction.isEnabled():
self.setCutEnd()
event.accept()
else:
super(VidCutter, self).mousePressEvent(event)
@pyqtSlot(QMediaPlayer.Error)
def handleError(self, error: QMediaPlayer.Error) -> None:
qApp.restoreOverrideCursor()
self.startNew()
if error == QMediaPlayer.ResourceError:
QMessageBox.critical(
self.parent, 'INVALID MEDIA',
'Invalid media file detected at:<br/><br/><b>%s</b><br/><br/>%s'
% (self.movieFilename, self.mediaPlayer.errorString()))
else:
QMessageBox.critical(self.parent, 'ERROR NOTIFICATION',
self.mediaPlayer.errorString())
def closeEvent(self, event: QCloseEvent) -> None:
self.parent.closeEvent(event)
class DBPlayer(QWidget):
# signal
signaltxt = pyqtSignal(str)
signalnum = pyqtSignal(int)
def __init__(self):
super(DBPlayer, self).__init__()
self.setMaximumSize(16777215, 35)
# Init Player
self.messtitle = TITL_PROG
self.namemedia = ''
self.albumname = ''
self.currentPlaylist = QMediaPlaylist()
self.player = QMediaPlayer()
self.player.stateChanged.connect(self.qmp_stateChanged)
self.player.positionChanged.connect(self.qmp_positionChanged)
self.player.volumeChanged.connect(self.qmp_volumeChanged)
self.player.durationChanged.connect(self.qmp_durationChanged)
self.player.setVolume(60)
# Init GUI
self.setLayout(self.addControls())
self.infoBox = None
def addControls(self):
# buttons
self.playBtn = QPushButton()
self.playBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playBtn.setStyleSheet('border: 0px;')
stopBtn = QPushButton()
stopBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaStop))
stopBtn.setStyleSheet('border: 0px;')
prevBtn = QPushButton()
prevBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaSkipBackward))
prevBtn.setStyleSheet('border: 0px;')
nextBtn = QPushButton()
nextBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaSkipForward))
nextBtn.setStyleSheet('border: 0px;')
volumeDescBtn = QPushButton('▼')
volumeDescBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaVolume))
volumeDescBtn.setMaximumWidth(30)
volumeDescBtn.setStyleSheet('border: 0px;')
volumeIncBtn = QPushButton('▲')
volumeIncBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaVolume))
volumeIncBtn.setMaximumWidth(40)
volumeIncBtn.setStyleSheet('border: 0px;')
infoBtn = QPushButton()
infoBtn.setIcon(self.style().standardIcon(
QStyle.SP_FileDialogContentsView))
infoBtn.setStyleSheet('border: 0px;')
# seek slider
self.seekSlider = QSlider(Qt.Horizontal, self)
self.seekSlider.setMinimum(0)
self.seekSlider.setMaximum(100)
self.seekSlider.setTracking(False)
# labels position start/end
self.seekSliderLabel1 = QLabel('0:00')
self.seekSliderLabel2 = QLabel('0:00')
# layout
controlArea = QHBoxLayout()
controlArea.addWidget(prevBtn)
controlArea.addWidget(self.playBtn)
controlArea.addWidget(stopBtn)
controlArea.addWidget(nextBtn)
controlArea.addWidget(self.seekSliderLabel1)
controlArea.addWidget(self.seekSlider)
controlArea.addWidget(self.seekSliderLabel2)
controlArea.addWidget(infoBtn)
controlArea.addWidget(volumeDescBtn)
controlArea.addWidget(volumeIncBtn)
# link buttons to media
self.seekSlider.sliderMoved.connect(self.seekPosition)
self.playBtn.clicked.connect(self.playHandler)
stopBtn.clicked.connect(self.stopHandler)
volumeDescBtn.clicked.connect(self.decreaseVolume)
volumeIncBtn.clicked.connect(self.increaseVolume)
prevBtn.clicked.connect(self.prevItemPlaylist)
nextBtn.clicked.connect(self.nextItemPlaylist)
infoBtn.clicked.connect(self.displaySongInfo)
return controlArea
def playHandler(self):
if self.player.state() == QMediaPlayer.PlayingState:
self.player.pause()
message = (' [Paused at position %s]' %
self.seekSliderLabel1.text())
self.messtitle = self.namemedia + message
self.signaltxt.emit(self.messtitle)
else:
if self.player.state() == QMediaPlayer.StoppedState:
if self.player.mediaStatus() == QMediaPlayer.NoMedia:
if self.currentPlaylist.mediaCount() != 0:
self.player.setPlaylist(self.currentPlaylist)
elif self.player.mediaStatus() == QMediaPlayer.LoadedMedia:
self.player.play()
elif self.player.mediaStatus() == QMediaPlayer.BufferedMedia:
self.player.play()
elif self.player.state() == QMediaPlayer.PlayingState:
pass
elif self.player.state() == QMediaPlayer.PausedState:
self.player.play()
if self.player.volume() is not None and self.player.state(
) == QMediaPlayer.PlayingState:
message = ' [Volume %d]' % self.player.volume()
self.messtitle = self.namemedia + message
self.signaltxt.emit(self.messtitle)
def stopHandler(self):
if self.player.state() == QMediaPlayer.PlayingState:
self.stopState = True
self.player.stop()
elif self.player.state() == QMediaPlayer.PausedState:
self.player.stop()
elif self.player.state() == QMediaPlayer.StoppedState:
pass
if self.player.volume() is not None and self.player.state(
) == QMediaPlayer.PlayingState:
self.messtitle = self.namemedia + (' [Stopped]')
self.signaltxt.emit(self.messtitle)
def qmp_stateChanged(self):
if self.player.state() == QMediaPlayer.StoppedState:
self.player.stop()
# buttons icon play/pause change
if self.player.state() == QMediaPlayer.PlayingState:
self.playBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def qmp_positionChanged(self, position):
# update position slider
self.seekSlider.setValue(position)
# update the text label
self.seekSliderLabel1.setText(
'%d:%02d' % (int(position / 60000), int((position / 1000) % 60)))
def seekPosition(self, position):
sender = self.sender()
if isinstance(sender, QSlider):
if self.player.isSeekable():
self.player.setPosition(position)
def qmp_volumeChanged(self):
if self.player.volume() is not None:
message = (' [Playing at Volume %d]' % (self.player.volume()))
if self.namemedia != '':
self.messtitle = self.namemedia + message
else:
self.messtitle = "Initialisation player " + message
self.signaltxt.emit(self.messtitle)
def qmp_durationChanged(self, duration):
self.seekSlider.setRange(0, duration)
self.seekSliderLabel2.setText(
'%d:%02d' % (int(duration / 60000), int((duration / 1000) % 60)))
nummedia = self.currentPlaylist.mediaCount()
curmedia = self.currentPlaylist.currentIndex()
#artist = self.player.metaData(QMediaMetaData.Author)
#tittle = self.player.metaData(QMediaMetaData.Title)
self.namemedia = path.basename(self.homMed[curmedia])
self.namemedia = '[%02d/%02d' % (
curmedia + 1, nummedia) + '] "' + self.namemedia + '"'
self.buildPlaylist()
message = (' [Playing at Volume %d]' % (self.player.volume()))
if self.player.volume() is not None and self.player.state(
) == QMediaPlayer.PlayingState:
self.messtitle = self.namemedia + message
self.signaltxt.emit(self.messtitle)
def buildPlaylist(self):
"""Build play list."""
nummedia = self.currentPlaylist.mediaCount()
curmedia = self.currentPlaylist.currentIndex() + 1
compteur = 1
self.textplaylist = '<b>' + self.albumname + '</b>'
self.textplaylist += '<table class="tftable" border="0">'
for namemedia in self.homMed:
media = path.basename(namemedia)
media = '[%02d/%02d' % (compteur, nummedia) + '] "' + media + '"'
if curmedia == compteur:
self.textplaylist += '<tr><td><b>' + media + '</b></td></tr>'
else:
self.textplaylist += '<tr><td>' + media + '</td></tr>'
compteur += 1
self.textplaylist = self.textplaylist + '</table>'
self.playBtn.setToolTip(self.textplaylist)
self.signalnum.emit(curmedia - 1)
def increaseVolume(self):
"""Volume +."""
vol = self.player.volume()
vol = min(vol + 5, 100)
self.player.setVolume(vol)
def decreaseVolume(self):
"""Volume -."""
vol = self.player.volume()
vol = max(vol - 5, 0)
self.player.setVolume(vol)
def prevItemPlaylist(self):
self.player.playlist().previous()
if self.currentPlaylist.currentIndex() == -1:
self.player.playlist().previous()
def nextItemPlaylist(self):
self.player.playlist().next()
if self.currentPlaylist.currentIndex() == -1:
self.player.playlist().next()
def addMediaslist(self, listmedias, position, albumname):
if self.currentPlaylist.mediaCount() > 0:
self.currentPlaylist.removeMedia(0,
self.currentPlaylist.mediaCount())
self.player.stop()
self.stopHandler()
self.currentPlaylist.removeMedia(0, self.currentPlaylist.mediaCount())
self.albumname = albumname
if listmedias:
self.homMed = listmedias
for media in self.homMed:
self.currentPlaylist.addMedia(
QMediaContent(QUrl.fromLocalFile(media)))
self.currentPlaylist.setCurrentIndex(position)
self.playHandler()
def displaySongInfo(self):
# extract datas
metaDataKeyList = self.player.availableMetaData()
fullText = '<table class="tftable" border="0">'
for key in metaDataKeyList:
value = str(self.player.metaData(key)).replace("'", "").replace(
"[", "").replace("]", "")
if key == 'Duration':
value = '%d:%02d' % (int(
int(value) / 60000), int((int(value) / 1000) % 60))
fullText = fullText + '<tr><td>' + key + '</td><td>' + value + '</td></tr>'
fullText = fullText + '</table>'
# re-init
if self.infoBox is not None:
self.infoBox.destroy()
# infos box
self.infoBox = QMessageBox(self)
self.infoBox.setWindowTitle('Detailed Song Information')
self.infoBox.setTextFormat(Qt.RichText)
self.infoBox.addButton('OK', QMessageBox.AcceptRole)
self.infoBox.setText(fullText)
self.infoBox.show()
