class MusicList(QListWidget):
def __init__(self):
super(MusicList, self).__init__()
self.__musicList = []
self.setFixedWidth(250)
self.setFont(QFont('宋体', 10,))
self.setObjectName('musicList')
self.setStyleSheet('#musicList{background-color: rgba(0, 0, 0, 120); color: "green";} #musicList:item{height: 25;}')
self.itemDoubleClicked.connect(self.music_double_clicked)
# 初始化多媒体播放器和播放列表
self.player = QMediaPlayer()
self.playlist = QMediaPlaylist(self.player)
self.player.setPlaylist(self.playlist)
def add_music_item(self, file_names):
for file in file_names:
self.addItem(file.split('/')[-1])
self.playlist.addMedia(QMediaContent(QUrl.fromLocalFile(file)))
def music_double_clicked(self):
music_list_index = self.currentRow()
self.music_play(music_list_index)
def music_play(self, music_list_index):
self.playlist.setCurrentIndex(music_list_index)
self.player.play()
def add_network_music(self, music_name, music_url):
print(music_name)
self.addItem(music_name)
self.playlist.addMedia(QMediaContent(QUrl(music_url)))
class VideoPlayer(QVideoWidget):
def __init__(self):
super(VideoPlayer, self).__init__()
self._player = QMediaPlayer()
self._playlist = QMediaPlaylist()
self._stopped = True
# プレイリストに動画を追加
def addMedia(self, media_file):
media_content = QMediaContent(QUrl.fromLocalFile(media_file))
self._playlist.addMedia(media_content)
# クリックでポーズ・再生の切り替え
def mousePressEvent(self, event):
if self._stopped:
self.play()
else:
self._player.pause()
self._stopped = True
# ダブルクリックで動画を読み込み，再生
def mouseDoubleClickEvent(self, event):
self._player.setVideoOutput(self)
self._player.setPlaylist(self._playlist)
self.play()
def play(self):
self._player.play()
self._stopped = False
class Player(QGraphicsVideoItem):
def __init__(self, parent=None):
super().__init__()
self.parent = parent
self.player = QMediaPlayer()
self.player.setVideoOutput(self)
def playerPlayOrOpen(self, arg=None):
if type(arg) == list and len(arg) > 1:
content = QMediaContent(QUrl.fromLocalFile(arg[1]))
self.player.setMedia(content)
self.play()
def addVideo(self, video):
content = QMediaContent(QUrl.fromLocalFile(video))
self.player.setMedia(content)
self.play()
def sliderChanged(self, pos):
self.player.setPosition(pos)
def mouseDoubleClickEvent(self, event):
if not self.parent.isFullScreen():
self.parent.showFullScreen()
else:
self.parent.showNormal()
def play(self):
self.player.play()
def stop(self):
self.player.stop()
def pause(self):
self.player.pause()
def setMuted(self, mute):
self.player.setMuted(mute)
def mutedState(self):
if self.player.isMuted():
self.setMuted(False)
else:
self.setMuted(True)
def isMuted(self):
return self.player.isMuted()
def setVolume(self, value):
self.player.setVolume(value)
def volume(self):
return self.player.volume()
class MediaPlayer(metaclass=Observable):
class Error(Enum):
none = QMediaPlayer.NoError
unsupported_format = QMediaPlayer.FormatError
access_denied = QMediaPlayer.AccessDeniedError
closed = signal()
playing = signal(Track)
stopped = signal(Track)
error_occurred = signal(Track)
def __init__(self):
self._media_library = create_media_library()
self._playlist = []
self._player = QMediaPlayer()
self._player.stateChanged.connect(self._state_changed)
self._player.mediaStatusChanged.connect(self._media_status_changed)
def play(self, track):
self._playlist.append(track)
self._player.setMedia(self._media_library.fetch(track.filename))
self._player.play()
def stop(self):
self._player.stop()
def _media_status_changed(self, state):
if state == QMediaPlayer.BufferedMedia:
self._error = QMediaPlayer.NoError
self.playing.emit(self._playlist[0])
elif state == QMediaPlayer.InvalidMedia:
# On windows 8, we only get an InvalidMedia status in case of error,
# so we need to keep track of the error that occurred
self._error = QMediaPlayer.FormatError
@property
def error(self):
return MediaPlayer.Error(self._player.error() or self._error)
def _state_changed(self, state):
if state == QMediaPlayer.StoppedState and self.error is not MediaPlayer.Error.none:
self.error_occurred.emit(self._playlist.pop(0), self.error)
elif state == QMediaPlayer.StoppedState:
self.stopped.emit(self._playlist.pop(0))
def dispose(self):
self._player.stop()
# force the deletion of the player on windows because windows
# doesn't release the handle and prevents further instanciations
sip.delete(self._player)
self._player = None
self._media_library.dispose()
self.closed.emit()
class VideoPlayerWidget(QWidget):
def __init__(self, parent=None):
super(VideoPlayerWidget, self).__init__(parent)
self.scene = QGraphicsScene(self)
self.scene.setBackgroundBrush(QBrush(QColor(0, 0, 0, 255)))
self.graphics_view = QGraphicsView(self.scene)
self.graphics_view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphics_view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphics_view.setFrameStyle(0)
self.graphics_view.setStyleSheet("QGraphicsView {background: transparent; border: 3px; outline: none;}")
self.video_item = QGraphicsVideoItem()
self.scene.addItem(self.video_item)
self.layout = QVBoxLayout(self)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.graphics_view)
self.media_player = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.media_player.setVideoOutput(self.video_item)
self.video_need_replay = False
self.video_seek_durcation = 3000 # in milliseconds
def resizeEvent(self, event):
self.video_item.setSize(QSizeF(event.size().width(), event.size().height()))
QWidget.resizeEvent(self, event)
def play(self, url):
self.media_player.setMedia(QMediaContent(QUrl.fromLocalFile(url)))
self.media_player.play()
def seek_forward(self):
video_position = self.media_player.position()
self.media_player.setPosition(video_position + self.video_seek_durcation)
def seek_backward(self):
video_position = self.media_player.position()
self.media_player.setPosition(max(video_position - self.video_seek_durcation, 0))
def keyPressEvent(self, event):
if event.key() == Qt.Key_Space:
if self.media_player.state() == QMediaPlayer.PlayingState:
self.media_player.pause()
self.video_need_replay = False
else:
self.media_player.play()
self.video_need_replay = True
elif event.key() == Qt.Key_H:
self.seek_backward()
elif event.key() == Qt.Key_L:
self.seek_forward()
def __alarm(self):
if not self.go:
return;
self.timer.stop()
player = QMediaPlayer(self);
player.setMedia(QMediaContent(QUrl.fromLocalFile(self.music)));
player.setVolume(100);
player.play();
self.setEnabled(False)
QMessageBox.critical(self, "ALERTA", "TIME TO DIE<br>" + self.ui.groupBox.title(), QMessageBox.Yes)
self.setEnabled(True)
player.stop()
player.deleteLater()
class Window(QWidget):
"""
The main window of the application. Houses a media player and related
controls.
"""
def __init__(self):
super().__init__()
layout = QVBoxLayout()
self.slider = QSlider(Qt.Horizontal)
btnOpen = QPushButton("Open")
btnPlay = QPushButton("Play")
self.player = QMediaPlayer()
tl = Timeline(None, None)
tlscroll = QScrollArea()
tlscroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
tlscroll.setWidget(tl)
btnOpen.clicked.connect(self.open)
btnPlay.clicked.connect(self.play)
self.player.durationChanged.connect(self.durationChanged)
self.player.positionChanged.connect(self.positionChanged)
layout.addWidget(self.slider)
layout.addWidget(btnOpen)
layout.addWidget(btnPlay)
layout.addWidget(tlscroll)
self.setLayout(layout)
def open(self):
fileName = QFileDialog.getOpenFileName(self, "Open File")[0]
fileInfo = QFileInfo(fileName)
if fileInfo.exists():
url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
self.changeMedia(QMediaContent(url))
def play(self):
self.player.play()
def changeMedia(self, mediaContent):
self.player.setMedia(mediaContent)
def durationChanged(self, duration):
self.slider.setRange(0, duration)
def positionChanged(self, position):
self.slider.setValue(position)
def main():
app = QApplication(sys.argv)
# Create media player, read media URL from first command line argument
player = QMediaPlayer()
media = QMediaContent(QUrl(sys.argv[1]))
player.setMedia(media)
# Create and set video output widget
video = QVideoWidget()
player.setVideoOutput(video)
video.show()
player.play()
sys.exit(app.exec_())
class Video(QDialog):
def __init__(self, video, parent=None):
super(Video, self).__init__(parent)
self.ui = Ui_Video()
self.ui.setupUi(self)
self.video = video
self.setWindowTitle("Video - %s" % video.title)
self.ui.urlEdit.setText(video.url)
self.ui.titleLabel.setText(video.title)
self.ui.durationLabel.setText(unicode(video.duration))
self.ui.authorLabel.setText(unicode(video.author))
self.ui.dateLabel.setText(unicode(video.date))
if video.rating_max:
self.ui.ratingLabel.setText('%s / %s' % (video.rating, video.rating_max))
else:
self.ui.ratingLabel.setText('%s' % video.rating)
self.mediaPlayer = QMediaPlayer()
self.mediaPlayer.durationChanged.connect(self._setMax)
self.mediaPlayer.seekableChanged.connect(self.ui.seekSlider.setEnabled)
self.mediaPlayer.positionChanged.connect(self._slide)
self.ui.seekSlider.valueChanged.connect(self.mediaPlayer.setPosition)
mc = QMediaContent(QUrl(video.url))
self.mediaPlayer.setMedia(mc)
self.ui.videoPlayer.setMediaObject(self.mediaPlayer)
self.mediaPlayer.play()
@Slot('qint64')
def _slide(self, pos):
blocking = self.ui.seekSlider.blockSignals(True)
self.ui.seekSlider.setValue(pos)
self.ui.seekSlider.blockSignals(blocking)
@Slot('qint64')
def _setMax(self, duration):
self.ui.seekSlider.setMaximum(duration)
def closeEvent(self, event):
self.mediaPlayer.stop()
event.accept()
def hideEvent(self, event):
self.mediaPlayer.stop()
event.accept()
class AudioPlayBack():
def __init__(self):
self.__audioPlayback = QMediaPlayer()
self.__audioPlayback.setVolume(50)
self.__audioPlayback.positionChanged.connect(self.onTick)
pass
def onTick(self, e=None):
print(self.__audioPlayback.position(), self.__audioPlayback.state())
Event.dis(AudioPlaybackEvent.TICK, self.__audioPlayback.position())
pass
def load(self, path):
content = QMediaContent(QUrl(path))
self.__audioPlayback.setMedia(content)
self.__audioPlayback.play()
pass
def seek(self, position):
self.__audioPlayback.setPosition(position)
pass
def play(self):
if self.__audioPlayback.state() == QMediaPlayer.PausedState:
self.__audioPlayback.play()
pass
pass
def pause(self):
if self.__audioPlayback.state() == QMediaPlayer.PlayingState:
self.__audioPlayback.pause()
pass
pass
# 0~100
def setVolume(self, vol):
self.__audioPlayback.setVolume(vol)
pass
class Speaker(QObject):
def __init__(self, parent=None):
super(Speaker,self).__init__(parent)
self.player = QMediaPlayer(self)
try:
self.backup = steel.available_engines()[0]()
self.backup.set("rate", 150)
except:
self.backup = None
print("Could not start a backup offline speaker.")
@pyqtSlot(str, str)
def speak(self, name, text, lang="pt-br"):
fpath = "./speeches/" + name + ".mp3"
if not os.path.isdir("./speeches"):
os.mkdir("./speeches")
if not os.path.isfile(fpath):
print("Running TTS...")
try:
data = urlencode( [("tl", lang), ("q", text), ("ie", "UTF-8")] )
bin_data = data.encode("utf8")
req = Request("http://translate.google.com/translate_tts", bin_data, {"User-Agent":"My agent !"})
fin = urlopen(req)
mp3 = fin.read()
fout = open(fpath, "wb")
fout.write(mp3)
fout.close()
except Exception as exc:
print("Error trying to get TTS file:", str(exc))
if self.backup != None:
print("Proceeding to use backup speaker...")
self.backup.speak(text)
return
self.player.stop()
self.player.setMedia(QMediaContent(QUrl.fromLocalFile(QFileInfo(fpath).absoluteFilePath())))
self.player.play()
class VideoWindow(QMainWindow):
def __init__(self, parent=None):
super(VideoWindow, self).__init__(parent)
self.setWindowTitle("PyQt Video Player Widget Example - pythonprogramminglanguage.com")
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
videoWidget = QVideoWidget()
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
# Create new action
openAction = QAction(QIcon('open.png'), '&Open', self)
openAction.setShortcut('Ctrl+O')
openAction.setStatusTip('Open movie')
openAction.triggered.connect(self.openFile)
# Create exit action
exitAction = QAction(QIcon('exit.png'), '&Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(self.exitCall)
# Create menu bar and add action
menuBar = self.menuBar()
fileMenu = menuBar.addMenu('&File')
#fileMenu.addAction(newAction)
fileMenu.addAction(openAction)
fileMenu.addAction(exitAction)
# Create a widget for window contents
wid = QWidget(self)
self.setCentralWidget(wid)
# Create layouts to place inside widget
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.errorLabel)
# Set widget to contain window contents
wid.setLayout(layout)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
QDir.homePath())
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
def exitCall(self):
sys.exit(app.exec_())
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
class Player(QWidget):
fullScreenChanged = pyqtSignal(bool)
def __init__(self, playlist, parent=None):
super(Player, self).__init__(parent)
self.colorDialog = None
self.trackInfo = ""
self.statusInfo = ""
self.duration = 0
self.player = QMediaPlayer()
self.playlist = QMediaPlaylist()
self.player.setPlaylist(self.playlist)
self.player.durationChanged.connect(self.durationChanged)
self.player.positionChanged.connect(self.positionChanged)
self.player.metaDataChanged.connect(self.metaDataChanged)
self.playlist.currentIndexChanged.connect(self.playlistPositionChanged)
self.player.mediaStatusChanged.connect(self.statusChanged)
self.player.bufferStatusChanged.connect(self.bufferingProgress)
self.player.videoAvailableChanged.connect(self.videoAvailableChanged)
self.player.error.connect(self.displayErrorMessage)
self.videoWidget = VideoWidget()
self.player.setVideoOutput(self.videoWidget)
self.playlistModel = PlaylistModel()
self.playlistModel.setPlaylist(self.playlist)
self.playlistView = QListView()
self.playlistView.setModel(self.playlistModel)
self.playlistView.setCurrentIndex(
self.playlistModel.index(self.playlist.currentIndex(), 0))
self.playlistView.activated.connect(self.jump)
self.slider = QSlider(Qt.Horizontal)
self.slider.setRange(0, self.player.duration() / 1000)
self.labelDuration = QLabel()
self.slider.sliderMoved.connect(self.seek)
self.labelHistogram = QLabel()
self.labelHistogram.setText("Histogram:")
self.histogram = HistogramWidget()
histogramLayout = QHBoxLayout()
histogramLayout.addWidget(self.labelHistogram)
histogramLayout.addWidget(self.histogram, 1)
self.probe = QVideoProbe()
self.probe.videoFrameProbed.connect(self.histogram.processFrame)
self.probe.setSource(self.player)
openButton = QPushButton("Open", clicked=self.open)
controls = PlayerControls()
controls.setState(self.player.state())
controls.setVolume(self.player.volume())
controls.setMuted(controls.isMuted())
controls.play.connect(self.player.play)
controls.pause.connect(self.player.pause)
controls.stop.connect(self.player.stop)
controls.next.connect(self.playlist.next)
controls.previous.connect(self.previousClicked)
controls.changeVolume.connect(self.player.setVolume)
controls.changeMuting.connect(self.player.setMuted)
controls.changeRate.connect(self.player.setPlaybackRate)
controls.stop.connect(self.videoWidget.update)
self.player.stateChanged.connect(controls.setState)
self.player.volumeChanged.connect(controls.setVolume)
self.player.mutedChanged.connect(controls.setMuted)
self.fullScreenButton = QPushButton("FullScreen")
self.fullScreenButton.setCheckable(True)
self.colorButton = QPushButton("Color Options...")
self.colorButton.setEnabled(False)
self.colorButton.clicked.connect(self.showColorDialog)
displayLayout = QHBoxLayout()
displayLayout.addWidget(self.videoWidget, 2)
displayLayout.addWidget(self.playlistView)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addStretch(1)
controlLayout.addWidget(controls)
controlLayout.addStretch(1)
controlLayout.addWidget(self.fullScreenButton)
controlLayout.addWidget(self.colorButton)
layout = QVBoxLayout()
layout.addLayout(displayLayout)
hLayout = QHBoxLayout()
hLayout.addWidget(self.slider)
hLayout.addWidget(self.labelDuration)
layout.addLayout(hLayout)
layout.addLayout(controlLayout)
layout.addLayout(histogramLayout)
self.setLayout(layout)
if not self.player.isAvailable():
QMessageBox.warning(
self, "Service not available",
"The QMediaPlayer object does not have a valid service.\n"
"Please check the media service plugins are installed.")
controls.setEnabled(False)
self.playlistView.setEnabled(False)
openButton.setEnabled(False)
self.colorButton.setEnabled(False)
self.fullScreenButton.setEnabled(False)
self.metaDataChanged()
self.addToPlaylist(playlist)
def open(self):
fileNames, _ = QFileDialog.getOpenFileNames(self, "Open Files")
self.addToPlaylist(fileNames)
def addToPlaylist(self, fileNames):
for name in fileNames:
fileInfo = QFileInfo(name)
if fileInfo.exists():
url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
if fileInfo.suffix().lower() == 'm3u':
self.playlist.load(url)
else:
self.playlist.addMedia(QMediaContent(url))
else:
url = QUrl(name)
if url.isValid():
self.playlist.addMedia(QMediaContent(url))
def durationChanged(self, duration):
duration /= 1000
self.duration = duration
self.slider.setMaximum(duration)
def positionChanged(self, progress):
progress /= 1000
if not self.slider.isSliderDown():
self.slider.setValue(progress)
self.updateDurationInfo(progress)
def metaDataChanged(self):
if self.player.isMetaDataAvailable():
self.setTrackInfo(
"%s - %s" % (self.player.metaData(QMediaMetaData.AlbumArtist),
self.player.metaData(QMediaMetaData.Title)))
def previousClicked(self):
# Go to the previous track if we are within the first 5 seconds of
# playback. Otherwise, seek to the beginning.
if self.player.position() <= 5000:
self.playlist.previous()
else:
self.player.setPosition(0)
def jump(self, index):
if index.isValid():
self.playlist.setCurrentIndex(index.row())
self.player.play()
def playlistPositionChanged(self, position):
self.playlistView.setCurrentIndex(self.playlistModel.index(
position, 0))
def seek(self, seconds):
self.player.setPosition(seconds * 1000)
def statusChanged(self, status):
self.handleCursor(status)
if status == QMediaPlayer.LoadingMedia:
self.setStatusInfo("Loading...")
elif status == QMediaPlayer.StalledMedia:
self.setStatusInfo("Media Stalled")
elif status == QMediaPlayer.EndOfMedia:
QApplication.alert(self)
elif status == QMediaPlayer.InvalidMedia:
self.displayErrorMessage()
else:
self.setStatusInfo("")
def handleCursor(self, status):
if status in (QMediaPlayer.LoadingMedia, QMediaPlayer.BufferingMedia,
QMediaPlayer.StalledMedia):
self.setCursor(Qt.BusyCursor)
else:
self.unsetCursor()
def bufferingProgress(self, progress):
self.setStatusInfo("Buffering %d%" % progress)
def videoAvailableChanged(self, available):
if available:
self.fullScreenButton.clicked.connect(
self.videoWidget.setFullScreen)
self.videoWidget.fullScreenChanged.connect(
self.fullScreenButton.setChecked)
if self.fullScreenButton.isChecked():
self.videoWidget.setFullScreen(True)
else:
self.fullScreenButton.clicked.disconnect(
self.videoWidget.setFullScreen)
self.videoWidget.fullScreenChanged.disconnect(
self.fullScreenButton.setChecked)
self.videoWidget.setFullScreen(False)
self.colorButton.setEnabled(available)
def setTrackInfo(self, info):
self.trackInfo = info
if self.statusInfo != "":
self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo))
else:
self.setWindowTitle(self.trackInfo)
def setStatusInfo(self, info):
self.statusInfo = info
if self.statusInfo != "":
self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo))
else:
self.setWindowTitle(self.trackInfo)
def displayErrorMessage(self):
self.setStatusInfo(self.player.errorString())
def updateDurationInfo(self, currentInfo):
duration = self.duration
if currentInfo or duration:
currentTime = QTime((currentInfo / 3600) % 60,
(currentInfo / 60) % 60, currentInfo % 60,
(currentInfo * 1000) % 1000)
totalTime = QTime((duration / 3600) % 60, (duration / 60) % 60,
duration % 60, (duration * 1000) % 1000)
format = 'hh:mm:ss' if duration > 3600 else 'mm:ss'
tStr = currentTime.toString(format) + " / " + totalTime.toString(
format)
else:
tStr = ""
self.labelDuration.setText(tStr)
def showColorDialog(self):
if self.colorDialog is None:
brightnessSlider = QSlider(Qt.Horizontal)
brightnessSlider.setRange(-100, 100)
brightnessSlider.setValue(self.videoWidget.brightness())
brightnessSlider.sliderMoved.connect(
self.videoWidget.setBrightness)
self.videoWidget.brightnessChanged.connect(
brightnessSlider.setValue)
contrastSlider = QSlider(Qt.Horizontal)
contrastSlider.setRange(-100, 100)
contrastSlider.setValue(self.videoWidget.contrast())
contrastSlider.sliderMoved.connect(self.videoWidget.setContrast)
self.videoWidget.contrastChanged.connect(contrastSlider.setValue)
hueSlider = QSlider(Qt.Horizontal)
hueSlider.setRange(-100, 100)
hueSlider.setValue(self.videoWidget.hue())
hueSlider.sliderMoved.connect(self.videoWidget.setHue)
self.videoWidget.hueChanged.connect(hueSlider.setValue)
saturationSlider = QSlider(Qt.Horizontal)
saturationSlider.setRange(-100, 100)
saturationSlider.setValue(self.videoWidget.saturation())
saturationSlider.sliderMoved.connect(
self.videoWidget.setSaturation)
self.videoWidget.saturationChanged.connect(
saturationSlider.setValue)
layout = QFormLayout()
layout.addRow("Brightness", brightnessSlider)
layout.addRow("Contrast", contrastSlider)
layout.addRow("Hue", hueSlider)
layout.addRow("Saturation", saturationSlider)
button = QPushButton("Close")
layout.addRow(button)
self.colorDialog = QDialog(self)
self.colorDialog.setWindowTitle("Color Options")
self.colorDialog.setLayout(layout)
button.clicked.connect(self.colorDialog.close)
self.colorDialog.show()
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 NotifierFrame(QWidget, Ui_notifierFrame):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.cleanUp_button.setIcon(QIcon(IconFile.button_clear))
self.table_model = NotificationHistoryModel(self)
self.notification_table.setModel(self.table_model)
if settings.sound_notifications == None:
settings.sound_notifications = default_sound_notifications
# In case loading the settings inserted bad values:
settings.sound_notifications = {
t
for t in settings.sound_notifications
if t in notification_sound_base
}
self.media_player = QMediaPlayer()
self.notification_table.doubleClicked.connect(
self.notificationDoubleClicked)
self.cleanUp_button.clicked.connect(
self.table_model.clearNotifications)
# Menu
self.PTTturnsOffSounds_action = QAction(
'Mute on PTT (recommended if no headset)', self)
self.PTTturnsOffSounds_action.setCheckable(True)
self.PTTturnsOffSounds_action.setChecked(
settings.PTT_mutes_sound_notifications)
self.PTTturnsOffSounds_action.toggled.connect(self.togglePTTmute)
self.sound_menu = QMenu()
self.sound_menu.addAction(self.PTTturnsOffSounds_action)
self.sound_menu.addSeparator()
for t in Notification.types: # iterate on this to control order of entries in menu
if t in notification_sound_base: # only notifications with sounds go in the sound toggle menu
action = QAction(Notification.tstr(t), self)
action.setCheckable(True)
self.sound_menu.addAction(action)
action.setChecked(t in settings.sound_notifications)
action.toggled.connect(lambda b: self.enableSound(t, b))
self.sounds_menuButton.setMenu(self.sound_menu)
# Notification signals
env.radar.emergencySquawk.connect(self.catchEmergencySquawk)
env.radar.pathConflict.connect(lambda: self.notify(
Notification.CONFLICT_WARNING, 'Anticipated conflict'))
env.radar.nearMiss.connect(lambda: self.notify(
Notification.SEPARATION_INCIDENT, 'Loss of separation!'))
env.radar.runwayIncursion.connect(self.catchRwyIncursion)
signals.cpdlcAcftConnected.connect(self.catchCpdlcInit)
signals.cpdlcMessageReceived.connect(self.catchCpdlcMessage)
signals.cpdlcProblem.connect(self.catchCpdlcProblem)
signals.sessionStarted.connect(self.catchSessionStarted)
signals.sessionEnded.connect(
lambda: self.notify(Notification.GUI_INFO, 'Session ended.'))
signals.sessionPaused.connect(
lambda: self.notify(Notification.GUI_INFO, 'Simulation paused.'))
signals.sessionResumed.connect(
lambda: self.notify(Notification.GUI_INFO, 'Simulation resumed.'))
signals.newWeather.connect(self.catchNewWeather)
signals.voiceMsgNotRecognised.connect(
lambda: self.notify(Notification.UNRECOGNISED_VOICE_INSTR,
'Voice instruction not recognised.'))
signals.newATC.connect(self.catchNewATC)
signals.newFPL.connect(self.catchNewFlightPlan)
signals.stripAutoPrinted.connect(self.catchStripAutoPrinted)
signals.controlledContactLost.connect(self.catchLostLinkedContact)
signals.incomingRadioChatMsg.connect(
lambda msg: self.notify(Notification.RADIO_CHAT_MSG, None))
signals.incomingAtcTextMsg.connect(self.catchIncomingAtcMsg)
signals.aircraftIdentification.connect(
self.catchAircraftIdentification)
signals.receiveStrip.connect(self.catchStripReceived)
signals.wilco.connect(lambda: self.playSound(wilco_beep))
def playSound(self, sound):
self.media_player.setMedia(sound)
self.media_player.play()
def notify(self, t, msg, dblClick=None):
if msg != None:
signals.statusBarMsg.emit(msg)
if t in icon_files:
self.table_model.addNotification(t, msg, dblClick)
self.notification_table.scrollToBottom()
if settings.notification_sounds_enabled and not settings.session_start_sound_lock \
and t in settings.sound_notifications \
and not (settings.transmitting_radio and settings.PTT_mutes_sound_notifications):
self.playSound(notification_sound_base[t])
def notifyAlarmClockTimedOut(self, timer):
self.notify(Notification.ALARM_TIMEOUT,
'Alarm clock %s timed out' % timer)
## USER ACTIONS/TOGGLES
def enableSound(self, t, toggle):
if toggle:
settings.sound_notifications.add(t)
else:
settings.sound_notifications.remove(t)
def togglePTTmute(self, toggle):
settings.PTT_mutes_sound_notifications = toggle
def notificationDoubleClicked(self):
try:
notification = self.table_model.history[
self.notification_table.selectedIndexes()[0].row()]
except IndexError:
return
if notification.double_click_function != None:
notification.double_click_function()
## REACTING TO GUI SIGNALS
def catchNewATC(self, callsign):
if settings.session_manager.session_type == SessionType.FLIGHTGEAR_MP:
self.notify(Notification.ATC_CONNECTED, '%s connected' % callsign)
def catchIncomingAtcMsg(self, msg):
if msg.isPrivate():
self.notify(Notification.ATC_CHAT_MSG,
'%s: "%s"' % (msg.sender(), msg.txtOnly()))
elif settings.ATC_chatroom_msg_notifications:
self.notify(Notification.ATC_CHAT_MSG, 'ATC chat room message')
def catchCpdlcInit(self, callsign):
if settings.session_manager.session_type != SessionType.TEACHER:
f = lambda cs=callsign: signals.cpdlcWindowRequest.emit(cs)
self.notify(Notification.CPDLC_MSG,
'Data link established with %s' % callsign,
dblClick=f)
def catchCpdlcMessage(self, callsign, msg):
f = lambda cs=callsign: signals.cpdlcWindowRequest.emit(cs)
if settings.session_manager.session_type == SessionType.TEACHER:
self.notify(Notification.CPDLC_MSG,
'CPDLC transmission to %s' % callsign,
dblClick=f)
elif msg.type() == CpdlcMessage.FREE_TEXT:
self.notify(Notification.CPDLC_MSG,
'CPDLC text message from %s' % callsign,
dblClick=f)
def catchCpdlcProblem(self, callsign, pb):
f = lambda cs=callsign: signals.cpdlcWindowRequest.emit(cs)
self.notify(Notification.CPDLC_PROBLEM,
'CPDLC problem with %s' % callsign,
dblClick=f)
def catchLostLinkedContact(self, strip, pos):
cs = strip.callsign(fpl=True)
msg = 'Radar contact lost'
if cs != None:
msg += ' for ' + cs
msg += ' ' + map_loc_str(pos)
f = lambda coords=pos: signals.indicatePoint.emit(coords)
self.notify(Notification.LOST_LINKED_CONTACT, msg, dblClick=f)
def catchAircraftIdentification(self, strip, acft, modeS):
if strip.linkedAircraft(
) is not acft: # could already be hard linked if XPDR was turned off and back on (avoid too many signals)
if modeS:
msg = 'Callsign %s identified (mode S)' % strip.lookup(
FPL.CALLSIGN)
else:
msg = 'XPDR code %04o identified' % strip.lookup(
assigned_SQ_detail)
f = lambda coords=acft.coords(): signals.indicatePoint.emit(coords)
self.notify(Notification.RADAR_IDENTIFICATION, msg, dblClick=f)
def catchStripReceived(self, strip):
fromATC = strip.lookup(received_from_detail)
if fromATC != None:
self.notify(Notification.STRIP_RECEIVED,
'Strip received from %s' % fromATC)
def catchStripAutoPrinted(self, strip, reason):
msg = 'Strip printed'
cs = strip.callsign(fpl=True)
if cs != None:
msg += ' for ' + cs
if reason != None:
msg += '; ' + reason
self.notify(Notification.STRIP_AUTO_PRINTED, msg)
def catchSessionStarted(self):
txt = {
SessionType.SOLO: 'Solo session started',
SessionType.FLIGHTGEAR_MP: 'FlightGear multi-player connected',
SessionType.STUDENT: 'Student session beginning',
SessionType.TEACHER: 'Teacher session beginning'
}[settings.session_manager.session_type]
self.notify(Notification.GUI_INFO, txt)
def catchNewWeather(self, station, weather):
if station == settings.primary_METAR_station:
self.notify(Notification.WEATHER_UPDATE,
'Weather update: %s' % weather.METAR())
def catchNewFlightPlan(self, new_fpl):
if new_fpl[FPL.ICAO_DEP] == settings.location_code or new_fpl[
FPL.
ICAO_ARR] == settings.location_code: #STYLE use findAirfield?
f = lambda fpl=new_fpl: signals.FPLeditRequest.emit(fpl)
self.notify(Notification.FPL_FILED,
'FPL filed for %s' % settings.location_code,
dblClick=f)
def catchEmergencySquawk(self, acft):
f = lambda coords=acft.coords(): signals.indicatePoint.emit(coords)
self.notify(Notification.EMG_SQUAWK,
'Aircraft squawking emergency',
dblClick=f)
def catchRwyIncursion(self, phyrwy, acft):
rwy = env.airport_data.physicalRunwayNameFromUse(phyrwy)
f = lambda coords=acft.coords(): signals.indicatePoint.emit(coords)
self.notify(Notification.RWY_INCURSION,
'Runway %s incursion!' % rwy,
dblClick=f)
class VideoWindow(QMainWindow):
def __init__(self, parent=None):
super(VideoWindow, self).__init__(parent)
self.setWindowTitle("Beat timestamp editor")
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
videoWidget = QVideoWidget()
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.setText("Play")
self.playButton.clicked.connect(self.play)
#add timestamp
self.add = QPushButton()
self.add.setEnabled(False)
self.add.setIcon(self.style().standardIcon(QStyle.SP_DialogApplyButton))
self.add.setText("Add")
self.add.clicked.connect(self.add_timestamp)
#clear timestamps
self.clear = QPushButton()
self.clear.setEnabled(False)
self.clear.setIcon(self.style().standardIcon(QStyle.SP_DialogCancelButton))
self.clear.setText("Clear")
self.clear.clicked.connect(self.clear_timestamps)
#--------------------
#timestamp list
self.list = QLabel()
self.list.setText("Timestamps: ")
self.list.setWordWrap(True)
#*------------------
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
# Create new action
openAction = QAction(QIcon('open.png'), '&Open', self)
openAction.setShortcut('Ctrl+O')
openAction.setStatusTip('Open movie')
openAction.triggered.connect(self.openFile)
# Create exit action
exitAction = QAction(QIcon('exit.png'), '&Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(self.exitCall)
#Create save action
self.saveAction = QAction(QIcon('save.png'), '&Save', self)
self.saveAction.setShortcut('Ctrl+S')
self.saveAction.setStatusTip('Save .txt file')
self.saveAction.triggered.connect(self.saveFile)
self.saveAction.setEnabled(False)
# Create menu bar and add action
menuBar = self.menuBar()
fileMenu = menuBar.addMenu('&File')
#fileMenu.addAction(newAction)
fileMenu.addAction(openAction)
fileMenu.addAction(self.saveAction)
fileMenu.addAction(exitAction)
# Create a widget for window contents
wid = QWidget(self)
self.setCentralWidget(wid)
# Create layouts to place inside widget
controlLayout = QGridLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(self.playButton,0,0)
controlLayout.addWidget(self.positionSlider,0,1)
controlLayout.addWidget(self.add,1,0)
controlLayout.addWidget(self.list,1,1,2,1)
controlLayout.addWidget(self.clear,2,0)
layout = QVBoxLayout()
layout.addLayout(controlLayout)
layout.addWidget(self.errorLabel)
# Set widget to contain window contents
wid.setLayout(layout)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
def saveFile(self):
global audio_path
path = audio_path
file = ntpath.basename(path)
text_file = open(file + " - data.txt", "w")
justgimmedata = sorted(timestamps, key=float)
for i in justgimmedata:
text_file.write(str(i) + "\n")
text_file.close()
def clear_timestamps(self):
del timestamps[:]
self.clear.setEnabled(False)
output="Timestamps: "
self.list.setText(output)
def add_timestamp(self):
print("timestamp added: ", self.mediaPlayer.position())
timestamps.append(self.mediaPlayer.position()/1000)
iwannadie = sorted(timestamps, key=float)
output="Timestamps: "+str(' '.join(str(iwannadie)))
self.list.setText(output)
self.clear.setEnabled(True)
def openFile(self):
fileName = filedialog.askopenfilename(filetypes=(("Audio Files", ".wav .mp3"), ("All Files", "*.*")))
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
global audio_path
audio_path = fileName
self.playButton.setEnabled(True)
self.add.setEnabled(True)
self.saveAction.setEnabled(True)
def exitCall(self):
sys.exit(app.exec_())
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
self.playButton.setText("Play")
else:
self.mediaPlayer.play()
self.playButton.setText("Pause")
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
class jaabaGUI(QMainWindow):
""" controller for the blob labeling GUI"""
def __init__(self,parent=None):
QMainWindow.__init__(self,parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
#add new slider
# self.positionSlider=QSlider(Qt.Horizontal)
# self.positionSlider.setGeometry (800,800,100,30)
# self.positionSlider.setRange(0, 0)
# self.positionSlider.sliderMoved.connect(self.setPosition)
#setup Video
#video player
self.mediaPlayer1 = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer2 = QMediaPlayer(None, QMediaPlayer.VideoSurface)
#self.mediaPlayer.metaDataChanged.connect(self.metaDataChanged)
self.mediaPlayer1.durationChanged.connect(self.durationChanged)
self.mediaPlayer1.positionChanged.connect(self.positionChanged)
self.mediaPlayer2.positionChanged.connect(self.positionChanged)
#visualizetion
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
#self.scene.setBackgroundBrush(Qt.black)
self.videoItem1 = QGraphicsVideoItem()
self.videoItem2 = QGraphicsVideoItem()
self.scene.addItem(self.videoItem1)
self.scene.addItem(self.videoItem2)
self.mediaPlayer1.setVideoOutput(self.videoItem1)
self.mediaPlayer2.setVideoOutput(self.videoItem2)
#slide bar
print self.ui.horizontalSlider
self.ui.horizontalSlider.setRange(0, 0)
self.ui.horizontalSlider.sliderMoved.connect(self.setPosition)
# self.ui.horizontalSlider.sliderPressed.connect(self.sliderPressed)
#print self.ui.graphicsView.width()/2,self.ui.graphicsView.height()
#self.videoItem1.setSize(QSizeF(self.ui.graphicsView.width()/2,self.ui.graphicsView.height()))
#self.videoItem2.setSize(QSizeF(self.ui.graphicsView.width()*10,self.ui.graphicsView.height()*10))
# self.videoItem2.setSize(graphicsView.size())
#self.videoItem2.setOffset(QPointF(500,500))
#self.videoItem2.setOffset(QPointF(self.ui.graphicsView.width()/2,0))
#self.videoItem2.setPos(QPointF(0,0))
# print self.ui.graphicsView.width(), self.ui.graphicsView.height()
# print self.ui.graphicsView.size()
# print self.videoItem2.boundingRect().width(), self.videoItem2.boundingRect().height()
# print self.ui.graphicsView.sceneRect()
#self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
#callbacks
self.ui.actionQuit.triggered.connect(self.quit)
self.ui.actionLoad_Project.triggered.connect(self.loadVideo)
#self.ui.buttonPlay.clicked[bool].connect(self.setToggleText)
self.ui.buttonPlay.clicked.connect(self.play)
#print self.ui.graphicsView.sizeHint()
#initialization
self.loaded = False
self.videoFilename = None
self.frame_count=None
self.width=None
self.height=None
self.frame_trans=None
# ###actions starts from here###
def quit(self):
QApplication.quit()
def loadVideo(self):
self.writeLog("Loading video...")
self.videoFilename = QFileDialog.getOpenFileName(self, 'Open File', '.')[0]
if not self.videoFilename:
self.writeLog("User cancelled - no video loaded")
return
else:
cap=cv2.VideoCapture(self.videoFilename)
self.frame_count=cap.get(cv2.CAP_PROP_FRAME_COUNT)
self.width=cap.get(3)
self.height=cap.get(4)
self.mediaPlayer2.setMedia(QMediaContent(QUrl.fromLocalFile(self.videoFilename )))
self.mediaPlayer1.setMedia(QMediaContent(QUrl.fromLocalFile(self.videoFilename )))
self.ui.buttonPlay.setEnabled(True)
# self.mediaPlayer2.setVideoOutput(self.videoItem2)
# self.mediaPlayer1.setVideoOutput(self.videoItem1)
# size= self.videoItem2.nativeSize()
# print size
#print self.mediaPlayer.duration()
#print self.mediaPlayer.metaData()
self.writeLog("Video loaded!")
def play(self):
self.videoItem1.setAspectRatioMode(0)
self.videoItem2.setAspectRatioMode(0)
self.scene.setSceneRect(0,0,self.ui.graphicsView.width(),self.ui.graphicsView.height())
self.videoItem1.setSize(QSizeF(self.ui.graphicsView.width()/2,self.ui.graphicsView.height()))
self.videoItem2.setSize(QSizeF(self.ui.graphicsView.width()/2,self.ui.graphicsView.height()))
self.videoItem1.setPos(QPointF(0,0))
self.videoItem2.setPos(QPointF(self.ui.graphicsView.width()/2,0))
#self.ui.graphicsView.setGeometry(0,0, 600,800)
#print 'graphicsView size', self.ui.graphicsView.size()
#print 'graphicsScene size', self.scene.sceneRect()
#self.videoItem2.setSize(QSizeF(1000,300))
#print 'graphicsVideoItem size',self.videoItem2.size()
# print 'item x',self.videoItem2.scenePos().x()
# print 'item y', self.videoItem2.scenePos().y()
# print 'item x',self.videoItem1.scenePos().x()
# print 'item y', self.videoItem1.scenePos().y()
if self.mediaPlayer1.state() == QMediaPlayer.PlayingState:
self.ui.buttonPlay.setIcon(self.ui.style().standardIcon(PyQt5.QtWidgets.QStyle.SP_MediaPlay))
self.ui.buttonPlay.setText("Play")
self.mediaPlayer1.pause()
self.writeLog("Video paused")
else:
self.ui.buttonPlay.setIcon(self.ui.style().standardIcon(PyQt5.QtWidgets.QStyle.SP_MediaPause))
self.ui.buttonPlay.setText("Stop")
self.mediaPlayer1.play()
self.writeLog("Playing video")
if self.mediaPlayer2.state() == QMediaPlayer.PlayingState:
self.mediaPlayer2.pause()
else:
self.mediaPlayer2.play()
#size= self.videoItem2.nativeSize()
# print self.mediaPlayer.duration()
#print self.mediaPlayer.metaData()
# print self.ui.graphicsView.width(), self.ui.graphicsView.height()
# print self.ui.graphicsView.size()
# print self.videoItem2.boundingRect().width(), self.videoItem2.boundingRect().height()
# print self.ui.graphicsView.sceneRect()
# print self.scene.sceneRect()
# print self.ui.graphicsView.sizeHint()
def setPosition(self, position):
self.mediaPlayer1.setPosition(position)
self.mediaPlayer2.setPosition(position)
# when position of media changed, set slider and text box accordingly.
def positionChanged(self, position):
self.ui.horizontalSlider.setValue(position)
if isinstance(self.frame_trans,float):
# print type(position),position
# print type(self.frame_trans),self.frame_trans
# print position/self.frame_trans
self.ui.lineEdit.setText(str(int(round(position/self.frame_trans,0))))
self.writeLog(str(position))
def durationChanged(self, duration):
self.ui.horizontalSlider.setRange(0, duration)
self.frame_trans=self.mediaPlayer1.duration()/self.frame_count
print self.frame_trans
def writeLog(self,text):
self.ui.log.setText(text)
def play(self, i):
"""播放指定的歌曲"""
if hasattr(self, "playList"):
self.playList.setCurrentIndex(i) # 切换到第几首
QMediaPlayer.play(self) # 播放一次
class BackWindow(QWidget):
def __init__(self, parent=None):
super(BackWindow, self).__init__(parent)
self.init_ui()
self.w = None
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.main_mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
# self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
self.main_mediaPlayer.positionChanged.connect(self.positionChanged)
self.main_mediaPlayer.durationChanged.connect(self.durationChanged)
self.main_mediaPlayer.error.connect(self.handleError)
self._playlist = QMediaPlaylist()
#self.addMedia("movie/movie1.wmv")
self.init_play_list()
self._stopped = True
self.mediaPlayer.setVideoOutput(self.ui.videoWidget)
self.mediaPlayer.setPlaylist(self._playlist)
self.main_mediaPlayer.setPlaylist(self._playlist)
def init_ui(self):
ui_path = "ui/MediaPlayer.ui"
print ui_path
self.ui = loadUi(ui_path, self)
self.ui.playButton.clicked.connect(self.play_movie)
self.ui.nextButton.clicked.connect(self.next_movie)
self.ui.launchButton.clicked.connect(self.launch_window)
self.ui.positionSlider.setRange(0, 0)
self.ui.positionSlider.sliderMoved.connect(self.setPosition)
def init_play_list(self):
movies = glob.glob(os.path.dirname("__file__") + "movie/*")
#sort movies
for movie in movies:
self.addMedia(movie)
self.ui.listWidget.addItem(movie)
# プレイリストに動画を追加
def addMedia(self, media_file):
media_content = QMediaContent(QUrl.fromLocalFile(media_file))
self._playlist.addMedia(media_content)
""" def mousePressEvent(self, event):
if self._stopped:
self.play()
else:
self.mediaPlayer.pause()
self._stopped = True
"""
def play_movie(self):
if self._stopped:
# self.mediaPlayer.setVideoOutput(self.ui.videoWidget)
# self.mediaPlayer.setPlaylist(self._playlist)
self.mediaPlayer.play()
self.main_mediaPlayer.play()
self._stopped = False
self.ui.playButton.setText("pause")
else:
self.mediaPlayer.pause()
self.main_mediaPlayer.pause()
self._stopped = True
self.ui.playButton.setText("play")
def next_movie(self):
self._playlist.next()
def back_movie(self):
pass
def launch_window(self):
print "aaaaaaaaa"
self.w = MainWindow()
#self.w.show()
self.main_mediaPlayer.setVideoOutput(self.w.ui.videoWidget)
def positionChanged(self, position):
self.ui.positionSlider.setValue(position)
def durationChanged(self, duration):
self.ui.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
self.main_mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
class VideoPlayer(QWidget):
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
videoWidget = QVideoWidget()
openButton = QPushButton("Open...")
openButton.clicked.connect(self.openFile)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.errorLabel)
self.setLayout(layout)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
QDir.homePath())
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
class VideoPlayer(QWidget):
def __init__(self, aPath, parent=None):
super(VideoPlayer, self).__init__(parent)
self.setAttribute(Qt.WA_NoSystemBackground, True)
self.setAcceptDrops(True)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.StreamPlayback)
self.mediaPlayer.mediaStatusChanged.connect(self.printMediaData)
self.mediaPlayer.setVolume(80)
self.videoWidget = QVideoWidget(self)
self.setAcceptDrops(True)
self.setWindowTitle("QT5 Player")
self.setWindowIcon(QIcon.fromTheme("multimedia-video-player"))
self.setWindowFlags(Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint)
self.setGeometry(100, 300, 600, 380)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested[QPoint].connect(
self.contextMenuRequested)
self.show()
self.widescreen = True
self.lbl = QLineEdit('00:00:00')
self.lbl.setReadOnly(True)
self.lbl.setFixedWidth(70)
self.lbl.setUpdatesEnabled(True)
self.lbl.setStyleSheet(stylesheet(self))
self.elbl = QLineEdit('00:00:00')
self.elbl.setReadOnly(True)
self.elbl.setFixedWidth(70)
self.elbl.setUpdatesEnabled(True)
self.elbl.setStyleSheet(stylesheet(self))
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setFixedWidth(32)
self.playButton.setStyleSheet("background-color: black")
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal, self)
self.positionSlider.setStyleSheet(stylesheet(self))
self.positionSlider.setRange(0, 100)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.positionSlider.sliderMoved.connect(self.handleLabel)
self.positionSlider.setSingleStep(2)
self.positionSlider.setPageStep(20)
self.positionSlider.setAttribute(Qt.WA_TranslucentBackground, True)
self.clip = QApplication.clipboard()
self.myurl = ""
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(5, 0, 5, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.lbl)
controlLayout.addWidget(self.positionSlider)
controlLayout.addWidget(self.elbl)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.videoWidget)
layout.addLayout(controlLayout)
self.setLayout(layout)
self.myinfo = "©2016\nAxel Schneider\n\nMouse Wheel = Zoom\nUP = Volume Up\nDOWN = Volume Down\n" + \
"LEFT = < 1 Minute\nRIGHT = > 1 Minute\n" + \
"SHIFT+LEFT = < 10 Minutes\nSHIFT+RIGHT = > 10 Minutes"
self.widescreen = True
self.hideSlider()
#### shortcuts ####
self.shortcut = QShortcut(QKeySequence("q"), self)
self.shortcut.activated.connect(self.handleQuit)
self.shortcut = QShortcut(QKeySequence(" "), self)
self.shortcut.activated.connect(self.play)
self.shortcut = QShortcut(QKeySequence("f"), self)
self.shortcut.activated.connect(self.handleFullscreen)
self.shortcut = QShortcut(QKeySequence("i"), self)
self.shortcut.activated.connect(self.handleInfo)
self.shortcut = QShortcut(QKeySequence("s"), self)
self.shortcut.activated.connect(self.toggleSlider)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Right), self)
self.shortcut.activated.connect(self.forwardSlider)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Left), self)
self.shortcut.activated.connect(self.backSlider)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Up), self)
self.shortcut.activated.connect(self.volumeUp)
self.shortcut = QShortcut(QKeySequence(Qt.Key_Down), self)
self.shortcut.activated.connect(self.volumeDown)
self.shortcut = QShortcut(
QKeySequence(Qt.ShiftModifier + Qt.Key_Right), self)
self.shortcut.activated.connect(self.forwardSlider10)
self.shortcut = QShortcut(QKeySequence(Qt.ShiftModifier + Qt.Key_Left),
self)
self.shortcut.activated.connect(self.backSlider10)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.positionChanged.connect(self.handleLabel)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
print("QT5 Player started")
self.suspend_screensaver()
def playMyURL(self, url):
self.mediaPlayer.stop()
print("myurl =", url)
self.mediaPlayer.setMedia(QMediaContent(QUrl(url)))
self.playButton.setEnabled(True)
self.mediaPlayer.play()
self.hideSlider()
def suspend_screensaver(self):
'suspend linux screensaver'
proc = subprocess.Popen(
'gsettings set org.gnome.desktop.screensaver idle-activation-enabled false',
shell=True)
proc.wait()
def resume_screensaver(self):
'resume linux screensaver'
proc = subprocess.Popen(
'gsettings set org.gnome.desktop.screensaver idle-activation-enabled true',
shell=True)
proc.wait()
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
mtime = QTime(0, 0, 0, 0)
mtime = mtime.addMSecs(self.mediaPlayer.duration())
self.elbl.setText(mtime.toString())
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
print("Error: ", self.mediaPlayer.errorString())
def handleQuit(self):
self.mediaPlayer.stop()
self.resume_screensaver()
print("Player versteckt ...")
self.close()
def contextMenuRequested(self, point):
menu = QMenu()
actionToggle = menu.addAction(QIcon.fromTheme("next"),
"show / hide Slider (s)")
actionFull = menu.addAction(QIcon.fromTheme("view-fullscreen"),
"Fullscreen (f)")
action169 = menu.addAction(QIcon.fromTheme("tv-symbolic"), "16 : 9")
action43 = menu.addAction(QIcon.fromTheme("tv-symbolic"), "4 : 3")
actionSep = menu.addSeparator()
actionInfo = menu.addAction(QIcon.fromTheme("help-about"), "Info (i)")
action5 = menu.addSeparator()
actionQuit = menu.addAction(QIcon.fromTheme("application-exit"),
"Exit (q)")
actionQuit.triggered.connect(self.handleQuit)
actionFull.triggered.connect(self.handleFullscreen)
actionInfo.triggered.connect(self.handleInfo)
actionToggle.triggered.connect(self.toggleSlider)
action169.triggered.connect(self.screen169)
action43.triggered.connect(self.screen43)
menu.exec_(self.mapToGlobal(point))
def wheelEvent(self, event):
mwidth = self.frameGeometry().width()
mheight = self.frameGeometry().height()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
mscale = event.angleDelta().y() / 5
if self.widescreen == True:
self.setGeometry(mleft, mtop, mwidth + mscale,
(mwidth + mscale) / 1.778)
else:
self.setGeometry(mleft, mtop, mwidth + mscale,
(mwidth + mscale) / 1.33)
def screen169(self):
self.widescreen = True
mwidth = self.frameGeometry().width()
mheight = self.frameGeometry().height()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
mratio = 1.778
self.setGeometry(mleft, mtop, mwidth, mwidth / mratio)
def screen43(self):
self.widescreen = False
mwidth = self.frameGeometry().width()
mheight = self.frameGeometry().height()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
mratio = 1.33
self.setGeometry(mleft, mtop, mwidth, mwidth / mratio)
def handleFullscreen(self):
if self.windowState() & Qt.WindowFullScreen:
QApplication.setOverrideCursor(Qt.ArrowCursor)
self.showNormal()
print("no Fullscreen")
else:
self.showFullScreen()
QApplication.setOverrideCursor(Qt.BlankCursor)
print("Fullscreen entered")
def handleInfo(self):
msg = QMessageBox.about(self, "QT5 Player", self.myinfo)
def toggleSlider(self):
if self.positionSlider.isVisible():
self.hideSlider()
else:
self.showSlider()
def hideSlider(self):
self.playButton.hide()
self.lbl.hide()
self.positionSlider.hide()
self.elbl.hide()
mwidth = self.frameGeometry().width()
mheight = self.frameGeometry().height()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
if self.widescreen == True:
self.setGeometry(mleft, mtop, mwidth, mwidth / 1.778)
else:
self.setGeometry(mleft, mtop, mwidth, mwidth / 1.33)
def showSlider(self):
self.playButton.show()
self.lbl.show()
self.positionSlider.show()
self.elbl.show()
mwidth = self.frameGeometry().width()
mheight = self.frameGeometry().height()
mleft = self.frameGeometry().left()
mtop = self.frameGeometry().top()
if self.widescreen == True:
self.setGeometry(mleft, mtop, mwidth, mwidth / 1.55)
else:
self.setGeometry(mleft, mtop, mwidth, mwidth / 1.33)
def forwardSlider(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() + 1000 * 60)
def forwardSlider10(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() + 10000 * 60)
def backSlider(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() - 1000 * 60)
def backSlider10(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() - 10000 * 60)
def volumeUp(self):
self.mediaPlayer.setVolume(self.mediaPlayer.volume() + 10)
print("Volume: " + str(self.mediaPlayer.volume()))
def volumeDown(self):
self.mediaPlayer.setVolume(self.mediaPlayer.volume() - 10)
print("Volume: " + str(self.mediaPlayer.volume()))
def mouseMoveEvent(self, event):
if event.buttons() == Qt.LeftButton:
self.move(event.globalPos() \
- QPoint(self.frameGeometry().width() / 2, \
self.frameGeometry().height() / 2))
event.accept()
def dragEnterEvent(self, event):
if event.mimeData().hasUrls():
event.accept()
elif event.mimeData().hasText():
event.accept()
else:
event.ignore()
def dropEvent(self, event):
if event.mimeData().hasUrls():
url = event.mimeData().urls()[0].toString()
print("url = ", url)
self.mediaPlayer.stop()
self.mediaPlayer.setMedia(QMediaContent(QUrl(url)))
self.playButton.setEnabled(True)
self.mediaPlayer.play()
elif event.mimeData().hasText():
mydrop = event.mimeData().text()
### YouTube url
if "youtube" in mydrop:
print("is YouTube", mydrop)
self.clip.setText(mydrop)
self.getYTUrl()
else:
### normal url
print("generic url = ", mydrop)
self.mediaPlayer.setMedia(QMediaContent(QUrl(mydrop)))
self.playButton.setEnabled(True)
self.mediaPlayer.play()
self.hideSlider()
def loadFilm(self, f):
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(f)))
self.playButton.setEnabled(True)
self.mediaPlayer.play()
def printMediaData(self):
if self.mediaPlayer.mediaStatus() == 6:
if self.mediaPlayer.isMetaDataAvailable():
res = str(self.mediaPlayer.metaData("Resolution")).partition(
"PyQt5.QtCore.QSize(")[2].replace(", ",
" x ").replace(")", "")
print("%s%s" % ("Video Resolution = ", res))
else:
print("no metaData available")
def openFileAtStart(self, filelist):
matching = [s for s in filelist if ".myformat" in s]
if len(matching) > 0:
self.loadFilm(matching)
##################### update Label ##################################
def handleLabel(self):
self.lbl.clear()
mtime = QTime(0, 0, 0, 0)
self.time = mtime.addMSecs(self.mediaPlayer.position())
self.lbl.setText(self.time.toString())
class VideoWindow(QWidget):
def __init__(self):
super(VideoWindow, self).__init__()
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
videoWidget = QVideoWidget()
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
# Create layouts to place inside widget
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.setSpacing(0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.errorLabel)
# layout.addWidget(self.start_btn)
# Set widget to contain window contents
self.setLayout(layout)
videoWidget.setFullScreen(False)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
class VideoPlayer(QWidget):
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoItem = QGraphicsVideoItem()
self.videoItem.setSize(QSizeF(640, 480))
scene = QGraphicsScene(self)
graphicsView = QGraphicsView(scene)
scene.addItem(self.videoItem)
rotateSlider = QSlider(Qt.Horizontal)
rotateSlider.setRange(-180, 180)
rotateSlider.setValue(0)
rotateSlider.valueChanged.connect(self.rotateVideo)
openButton = QPushButton("Open...")
openButton.clicked.connect(self.openFile)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(graphicsView)
layout.addWidget(rotateSlider)
layout.addLayout(controlLayout)
self.setLayout(layout)
self.mediaPlayer.setVideoOutput(self.videoItem)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
def sizeHint(self):
return QSize(800, 600)
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
QDir.homePath())
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def rotateVideo(self, angle):
x = self.videoItem.boundingRect().width() / 2.0
y = self.videoItem.boundingRect().height() / 2.0
self.videoItem.setTransform(QTransform().translate(
x, y).rotate(angle).translate(-x, -y))
class VideoPlayer(QWidget):
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
btnSize = QSize(16, 16)
videoWidget = QVideoWidget()
self.playButton = QPushButton()
self.playButton.setFixedHeight(24)
self.playButton.setIconSize(btnSize)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.statusBar = QStatusBar()
self.statusBar.setFont(QFont("Arial", 7))
self.statusBar.setFixedHeight(14)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.statusBar)
self.setLayout(layout)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
self.statusBar.showMessage("Ready")
def play(self):
self.playButton.setEnabled(False)
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(path)))
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.close()
self.examen3 = Examen3()
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
self.statusBar.showMessage("Error: " + self.mediaPlayer.errorString())
print(self.mediaPlayer.errorString())
class Cracker(object):
"""Logic for running the Cracker program"""
SPEAKER = {Polly.__name__: Polly, Espeak.__name__: Espeak}
_logger = logging.getLogger(__name__)
def __init__(self, app: QApplication):
super().__init__()
self.app = app
self.config = Configuration()
_ = self.config.read_config()
self.player = QMediaPlayer()
self.speaker: AbstractSpeaker = self.get_speaker(
self.config.speaker, self.player)
self.textParser = TextParser(config_path=self.config.parser_config)
self.gui = MainWindow(self.config, speakers=self.SPEAKER)
self.gui.speaker = self.speaker
self.gui.player = self.player
self.key_manager = KeyBoardManager(self.app)
# Event on closing GUI application
self.gui.closeAppEvent.connect(self._close)
self._last_pid = None
def _close(self):
"Handles closing whole application"
self.key_manager.stop()
def get_speaker(self, speaker_name, player) -> AbstractSpeaker:
if speaker_name == Polly.__name__:
if "profile_name" in self.config.default_values:
profile_name = self.config.default_values["profile_name"]
return Polly(player, profile_name)
else:
return Polly(player)
elif speaker_name == Espeak.__name__:
return Espeak(player)
raise ValueError(
f"No speaker was selected. Provided speaker name '{speaker_name}'")
def run(self):
self.gui.init()
self.set_action()
self.gui.show()
def reduce_text(self):
text = self.gui.textEdit.toPlainText()
new_text = self.textParser.reduce_text(text)
self.gui.textEdit.setText(new_text)
def reduce_cite(self):
text = self.gui.textEdit.toPlainText()
new_text = self.textParser.reduce_cite(text)
self.gui.textEdit.setText(new_text)
def wiki_text(self):
"""Sets the text box with wikipedia specific cleaned text.
Example of this is removing `citation needed` and other references.
"""
text = self.gui.textEdit.toPlainText()
text = self.textParser.wiki_text(text)
self.gui.textEdit.setText(text)
def read_text_area(self):
"""Reads out text in the text_box with selected speaker."""
self.stop_text()
text = self.gui.textEdit.toPlainText(
) # TODO: toHtml() gives more control
self.textParser.parser_rules = self.config.regex_config
text = self.textParser.reduce_text(text)
self._read(text)
def toggle_read_text_clipboard(self):
"""Reads out text from the clipboard with selected speaker."""
if self.player.state() == QMediaPlayer.PlayingState:
self.stop_text()
self.player.stop()
else:
self.stop_text()
text = self.app.clipboard().text()
self.textParser.parser_rules = self.config.regex_config
text = self.textParser.reduce_text(text)
self._read(text)
def _read(self, text):
speaker_config = self._prepare_config()
self._last_pid = self.speaker.read_text(text, **speaker_config)
def toggle_read(self):
if self.player.state() == QMediaPlayer.PausedState:
self.player.play()
else:
self.player.pause()
def stop_text(self):
self.speaker.stop_text()
def _prepare_config(self):
config = dict(rate=self.gui.rate,
volume=self.gui.volume,
voice=self.gui.config.voice)
return config
def change_speaker(self, speaker_name):
"""Action on changing speaker.
Important: Each speaker has its own configuration. These values should be updated on change."""
self.speaker = self.SPEAKER[speaker_name](self.player)
self.gui.change_speaker(speaker_name)
def set_action(self):
self.gui.stop_action.triggered.connect(self.stop_text)
self.gui.read_action.triggered.connect(self.read_text_area)
self.gui.clipboard_read_action.triggered.connect(
self.toggle_read_text_clipboard)
self.gui.toggle_action.triggered.connect(self.toggle_read)
self.gui.reduce_action.triggered.connect(self.reduce_text)
self.gui.wiki_action.triggered.connect(self.wiki_text)
self.gui.speakerW.currentTextChanged.connect(self.change_speaker)
self.key_manager.GlobalReadSignal.connect(
self.toggle_read_text_clipboard)
args = (["space", "control", "shift"], )
p = Thread(target=self.key_manager.run, args=args)
p.start()
class GameWindow(QWidget):
def __init__(self, parent=None):
super(GameWindow,self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoWidget = QVideoWidget()
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.stringLabel = QLabel()
self.stringLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
self.stringLabel.setTextFormat(Qt.RichText)
self.stringLabel.setAlignment(Qt.AlignHCenter)
layout = QVBoxLayout()
layout.addWidget(self.videoWidget)
layout.addWidget(self.stringLabel)
self.setLayout(layout)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
def openFile(self, fileName):
if fileName != '':
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(fileName)))
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def playV(self, file, rate, visibility, labelString):
self.position = 0
self.startPos = 0
self.duration = 0
self.durChanged = False
self.stopPos = False
self.openFile(file)
self.mediaPlayer.setPlaybackRate(rate)
if visibility:
self.videoWidget.show()
self.stringLabel.show()
self.stringLabel.setText(labelString)
else:
self.videoWidget.hide()
self.stringLabel.show()
self.stringLabel.setText(labelString)
self.play()
def closeEvent(self, event):
event.ignore()
self.mediaPlayer.stop()
super(GameWindow, self).closeEvent(event)
def positionChanged(self, pos):
self.position = pos
if not self.durChanged and self.position > 0:
self.durationChanged(self.mediaPlayer.duration())
self.durChanged = True
if self.startPos > 0 and not self.stopPos and not self.videoWidget.isVisible():
if self.position > self.startPos + 20000:
self.play()
self.stopPos = True
def durationChanged(self, dur):
self.duration = dur
if self.duration > 40000 and not self.videoWidget.isVisible():
self.startPos = random.randint(5000, self.duration - 25000)
self.mediaPlayer.setPosition(self.startPos)
def showPoints(self, pointsString):
self.videoWidget.hide()
self.stringLabel.show()
self.stringLabel.setText(pointsString)
class Pencere(QWidget):
def __init__(self):
super().__init__()
self.durum = False
self.i = 0
self.git()
def git(self):
v_box = QVBoxLayout()
h_box = QHBoxLayout()
self.media = QMediaPlayer()
self.media.setMedia(
QMediaContent(
QUrl.fromLocalFile("C:/Users/Asus/Downloads/Payback.mp3")))
self.buton = QPushButton("Oku")
self.yazi = QLabel("Gelen Değer: ")
self.yazi2 = QLabel("0")
self.yazi3 = QLabel("1")
self.ledbuton = QPushButton("Yak")
self.ledbutonsondur = QPushButton("Sondur")
self.butonmuzik = QPushButton("Çal")
h_box.addWidget(self.buton)
h_box.addWidget(self.yazi)
h_box.addWidget(self.yazi2)
h_box.addWidget(self.ledbuton)
h_box.addWidget(self.ledbutonsondur)
h_box.addWidget(self.butonmuzik)
h_box.addWidget(self.yazi3)
h_box.addStretch()
v_box.addLayout(h_box)
v_box.addStretch()
self.setLayout(v_box)
self.buton.clicked.connect(self.oku)
self.ledbuton.clicked.connect(self.Yak)
self.ledbutonsondur.clicked.connect(self.Sondur)
self.butonmuzik.clicked.connect(self.cal)
self.setGeometry(100, 100, 50, 50)
self.show()
#veri_yolu.flushInput()
def oku(self):
self.timer = QTimer()
self.timer.timeout.connect(self.tekrarla)
self.timer.start(10)
def tekrarla(self):
gelen_deger = veri_yolu.readline()
gelen_deger = gelen_deger[:-2]
#
gelen_deger = gelen_deger.decode("utf-8")
if (
self.i != 0
): #ilk okumada gelen \x ten kaçmak için.bu ifade döndürülemiyor int e.
self.yazi2.setText(gelen_deger)
self.ses = int(int(gelen_deger) * 100 / 1024)
self.media.setVolume(self.ses)
#self.ses = round(int(self.yazi2.text()) * 100 / 1024)
#self.media.setVolume(self.ses)
self.i += 1
def Yak(self):
veri_yolu.write(b'1')
def Sondur(self):
veri_yolu.write(b'0')
def cal(self):
self.media.play()
class PlaybackPanel(SpecialLabel):
desktop_lyric_state_changed_signal = pyqtSignal(bool)
playmode_changed_signal = pyqtSignal(int, int)
media_player_notify_signal = pyqtSignal(int)
muted_changed_signal = pyqtSignal(int)
mark_favorite_completed_signal = pyqtSignal()
current_media_changed_signal = pyqtSignal()
music_ended_signal = pyqtSignal()
update_window_lyric_signal = pyqtSignal(str, str)
show_artist_info_signal = pyqtSignal(str)
dont_hide_main_window_signal = pyqtSignal()
def __init__(self, parent=None):
super(PlaybackPanel, self).__init__(parent)
self.initial_mediaplayer()
self.create_actions()
self.setup_ui()
self.create_connections()
self.initial_params()
def create_connections(self):
self.artistHeadLabel.clicked.connect(self.show_artist_info)
self.desktopLyric.hide_desktop_lyric_signal.connect(self.desktop_lyric_closed)
self.seekSlider.valueChanged.connect(self.slider_value_changed)
self.seekSlider.sliderPressed.connect(self.slider_pressed)
self.seekSlider.sliderReleased.connect(self.seek)
self.mediaPlayer.positionChanged.connect(self.tick)
self.mediaPlayer.mutedChanged.connect(self.muted_changed_signal.emit)
self.mediaPlayer.stateChanged.connect(self.state_changed)
self.mediaPlayer.durationChanged.connect(self.duration_changed)
self.mediaPlayer.mediaStatusChanged.connect(self.media_status_changed)
self.mediaPlayer.currentMediaChanged.connect(self.current_media_changed)
def initial_mediaplayer(self):
self.mediaPlayer = QMediaPlayer()
self.mediaPlayer.setNotifyInterval(500)
self.set_volume(globalSettings.Volume)
def initial_params(self):
self.playlist = None
self.artistName = "Zheng-Yejian"
self.clickPlayFlag = False # 用来标志一首歌是否是主动点击选中的
self.timerFlag = False
self.timeStart = 0
self.timeSpan = 0
self.sourcePath = ""
self.errorType = Configures.NoError
self.currentSourceRow = -1
self.nearPlayedSongs = []
self.downloadDir = globalSettings.DownloadfilesPath
self.songinfosManager = SonginfosManager()
self.totalTime = Configures.ZeroTime
self.playmode = Configures.PlaymodeRandom # 播放模式指示器
playlistTemp = Playlist()
playlistTemp.fill_list(Configures.PlaylistFavorite)
self.lovedSongs = playlistTemp.get_titles()
def set_playlist(self, playlist):
self.playlist = playlist
self.currentSourceRow = self.playlist.get_current_row()
def create_actions(self):
self.nextAction = QAction(QIcon(IconsHub.ControlNext), "下一首", self, enabled=True, triggered=self.next_song)
self.playAction = QAction(QIcon(IconsHub.ControlPlay), "播放/暂停", self, enabled=True, triggered=self.play_music)
self.previousAction = QAction(
QIcon(IconsHub.ControlPrevious), "上一首", self, enabled=True, triggered=self.previous_song
)
self.stopAction = QAction(
QIcon(IconsHub.ControlStop), "停止", self, enabled=True, triggered=self.stop_music_but_timing
)
def get_play_button_action(self):
return self.playAction
def get_previous_button_action(self):
return self.previousAction
def get_next_button_action(self):
return self.nextAction
def get_stop_button_action(self):
return self.stopAction
def set_download_dir(self, dir):
self.downloadDir = dir
def get_loved_songs(self):
return self.lovedSongs
def get_songinfos_manager(self):
return self.songinfosManager
def setup_ui(self):
self.setFixedHeight(50)
# 桌面歌词标签
self.desktopLyric = desktop_lyric.DesktopLyric()
self.desktopLyric.set_color(globalSettings.DesktoplyricColors)
# 3个标签
self.artistHeadLabel = LabelButton()
self.artistHeadLabel.setToolTip(self.tr("查看歌手信息"))
self.artistHeadLabel.setFixedSize(QSize(42, 42))
self.artistHeadLabel.setScaledContents(True)
self.artistHeadLabel.setPixmap(QPixmap(IconsHub.Anonymous))
self.musicTitleLabel = NewLabel()
self.musicTitleLabel.setObjectName("musicTitleLabel")
self.musicTitleLabel.setFixedSize(QSize(370, 20))
self.musicTitleLabel.setText("Zheng-Yejian._.XYPLAYER")
self.timeLabel = QLabel("00:00/00:00")
self.timeLabel.setObjectName("timeLabel")
self.timeLabel.setFixedHeight(20)
self.timeLabel.setAlignment(Qt.AlignRight and Qt.AlignVCenter)
# 五个基本按键
self.playmodeButton = QToolButton(clicked=self.change_playmode)
self.playmodeButton.setFocusPolicy(Qt.NoFocus)
self.playmodeButton.setIcon(QIcon(IconsHub.PlaymodeRandom))
self.playmodeButton.setIconSize(QSize(25, 25))
self.playmodeButton.setToolTip("随机播放")
self.favoriteButton = QToolButton(clicked=self.mark_as_favorite)
self.favoriteButton.setFocusPolicy(Qt.NoFocus)
self.favoriteButton.setToolTip("收藏")
self.favoriteButton.setIcon(QIcon(IconsHub.Favorites))
self.favoriteButton.setIconSize(QSize(20, 20))
self.previousButton = QToolButton()
self.previousButton.setFocusPolicy(Qt.NoFocus)
self.previousButton.setIconSize(QSize(40, 40))
self.previousButton.setShortcut(QKeySequence("Ctrl + Left"))
self.previousButton.setDefaultAction(self.previousAction)
self.playButton = QToolButton()
self.playButton.setFocusPolicy(Qt.NoFocus)
self.playButton.setIconSize(QSize(40, 40))
self.playButton.setShortcut(QKeySequence("Ctrl + Down"))
self.playButton.setDefaultAction(self.playAction)
self.nextButton = QToolButton()
self.nextButton.setFocusPolicy(Qt.NoFocus)
self.nextButton.setIconSize(QSize(40, 40))
self.nextButton.setFocusPolicy(Qt.NoFocus)
self.nextButton.setShortcut(QKeySequence("Ctrl + Right"))
self.nextButton.setDefaultAction(self.nextAction)
self.desktopLyricButton = QToolButton(clicked=self.show_desktop_lyric)
self.desktopLyricButton.setToolTip(self.tr("桌面歌词"))
self.desktopLyricButton.setFocusPolicy(Qt.NoFocus)
self.desktopLyricButton.setIcon(QIcon(IconsHub.DesktopLyric))
self.desktopLyricButton.setIconSize(QSize(25, 25))
self.seekSlider = QSlider(Qt.Horizontal)
self.seekSlider.setObjectName("seekSlider")
self.seekSlider.setFixedHeight(20)
self.seekSlider.setFocusPolicy(Qt.NoFocus)
self.seekSlider.setRange(0, 0)
hbox1 = QHBoxLayout()
hbox1.addWidget(self.favoriteButton)
hbox1.addWidget(self.musicTitleLabel)
hbox1.addStretch()
hbox1.addWidget(self.timeLabel)
vbox1 = QVBoxLayout()
vbox1.addLayout(hbox1)
vbox1.setSpacing(5)
vbox1.addWidget(self.seekSlider)
mainLayout = QHBoxLayout(self)
mainLayout.setContentsMargins(2, 0, 0, 0)
mainLayout.addWidget(self.artistHeadLabel)
mainLayout.addWidget(self.previousButton)
mainLayout.addWidget(self.playButton)
mainLayout.addWidget(self.nextButton)
mainLayout.addLayout(vbox1)
mainLayout.addWidget(self.playmodeButton)
mainLayout.addWidget(self.desktopLyricButton)
def show_desktop_lyric(self):
if self.desktopLyric.isHidden():
beToOff = True
self.desktopLyric.show()
self.desktopLyric.original_place()
else:
beToOff = False
self.desktopLyric.hide()
self.desktop_lyric_state_changed_signal.emit(beToOff)
def desktop_lyric_closed(self):
self.desktop_lyric_state_changed_signal.emit(False)
def change_playmode(self):
oldPlaymode = self.playmode
if self.playmode == Configures.PlaymodeRandom:
self.set_new_playmode(Configures.PlaymodeOrder)
elif self.playmode == Configures.PlaymodeOrder:
self.set_new_playmode(Configures.PlaymodeSingle)
elif self.playmode == Configures.PlaymodeSingle:
self.set_new_playmode(Configures.PlaymodeRandom)
self.playmode_changed_signal.emit(oldPlaymode, self.playmode)
def set_new_playmode(self, playmode):
self.playmode = playmode
if playmode == Configures.PlaymodeRandom:
iconPath = IconsHub.PlaymodeRandom
toolTip = Configures.PlaymodeRandomText
elif playmode == Configures.PlaymodeOrder:
iconPath = IconsHub.PlaymodeOrder
toolTip = Configures.PlaymodeOrderText
else:
iconPath = IconsHub.PlaymodeSingle
toolTip = Configures.PlaymodeSingleText
self.playmodeButton.setIcon(QIcon(iconPath))
self.playmodeButton.setToolTip(toolTip)
def ui_initial(self):
self.mediaPlayer.stop()
self.totalTime = "00:00"
self.playAction.setIcon(QIcon(IconsHub.ControlPlay))
self.musicTitleLabel.setText("Zheng-Yejian._.XYPLAYER")
self.artistName = "Zheng-Yejian"
self.artistHeadLabel.setPixmap(QPixmap(IconsHub.Anonymous))
self.seekSlider.setRange(0, 0)
self.favoriteButton.setIcon(QIcon(IconsHub.Favorites))
self.favoriteButton.setToolTip("收藏")
self.timeLabel.setText("00:00/00:00")
def set_volume(self, volume):
self.mediaPlayer.setVolume(volume)
def set_muted(self, muted):
self.mediaPlayer.setMuted(muted)
def tick(self):
currentTime = self.mediaPlayer.position()
self.seekSlider.setValue(currentTime)
cTime = format_position_to_mmss(currentTime // 1000)
self.timeLabel.setText(cTime + "/" + self.totalTime)
self.media_player_notify_signal.emit(currentTime)
def slider_value_changed(self, value):
cTime = format_position_to_mmss(value // 1000)
self.timeLabel.setText("%s/%s" % (cTime, self.totalTime))
self.media_player_notify_signal.emit(value)
def slider_pressed(self):
self.mediaPlayer.positionChanged.disconnect(self.tick)
def seek(self):
if self.mediaPlayer.state() == QMediaPlayer.StoppedState:
self.mediaPlayer.play()
self.mediaPlayer.setPosition(self.seekSlider.value())
else:
self.mediaPlayer.setPosition(self.seekSlider.value())
self.mediaPlayer.play()
self.mediaPlayer.positionChanged.connect(self.tick)
def duration_changed(self, duration):
self.seekSlider.setMaximum(duration)
exactTotalTime = format_position_to_mmss(self.mediaPlayer.duration() // 1000)
self.timeLabel.setText("%s/%s" % (Configures.ZeroTime, exactTotalTime))
if self.totalTime != exactTotalTime:
self.totalTime = exactTotalTime
self.playlist.set_music_time_at(self.currentSourceRow, exactTotalTime)
def check_favorite(self):
if self.currentSourceRow >= 0:
if self.playlist.get_music_title_at(self.currentSourceRow) in self.lovedSongs:
self.favoriteButton.setIcon(QIcon(IconsHub.Favorites))
self.favoriteButton.setToolTip("取消收藏")
else:
self.favoriteButton.setIcon(QIcon(IconsHub.FavoritesNo))
self.favoriteButton.setToolTip("收藏")
if self.playlist.get_name() == Configures.PlaylistFavorite:
self.favoriteButton.setToolTip("收藏")
def mark_as_favorite(self):
if (
self.playlist.get_name() == Configures.PlaylistFavorite
or not self.playlist.length()
or self.currentSourceRow < 0
):
return
path = self.playlist.get_music_path_at(self.currentSourceRow)
title = self.playlist.get_music_title_at(self.currentSourceRow)
if self.playlist.get_name() == Configures.PlaylistOnline:
musicName = get_full_music_name_from_title(title)
musicPath = os.path.join(self.downloadDir, musicName)
musicPathO = os.path.join(Configures.MusicsDir, musicName)
if not os.path.exists(musicPath) and not os.path.exists(musicPathO):
QMessageBox.information(self, "提示", "请先下载该歌曲再添加喜欢！")
return
if os.path.exists(musicPath):
path = musicPath
else:
path = musicPathO
elif not os.path.exists(path):
QMessageBox.information(self, "提示", "路径'" + "%s" % path + "'无效，无法标记喜欢！")
return
playlistTemp = Playlist()
playlistTemp.fill_list(Configures.PlaylistFavorite)
if title in self.lovedSongs:
playlistTemp.remove_item_at(self.lovedSongs.index(title))
playlistTemp.commit_records()
self.lovedSongs.remove(title)
self.favoriteButton.setIcon(QIcon(IconsHub.FavoritesNo))
self.favoriteButton.setToolTip("收藏")
else:
playlistTemp.add_item_from_path(path)
playlistTemp.commit_records()
self.lovedSongs.append(title)
self.favoriteButton.setIcon(QIcon(IconsHub.Favorites))
self.favoriteButton.setToolTip("取消收藏")
self.mark_favorite_completed_signal.emit()
def show_artist_info(self):
if self.artistName:
self.show_artist_info_signal.emit(self.artistName)
def decide_to_play_or_pause(self, row):
if row != self.currentSourceRow:
self.set_media_source_at_row(row, clickPlayFlag=True)
elif self.mediaPlayer.state() in (QMediaPlayer.PausedState, QMediaPlayer.StoppedState):
self.mediaPlayer.play()
elif self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
def set_media_source_at_row(self, row, clickPlayFlag=False):
if not self.playlist.length() or row < 0:
return
self.stop_music()
self.clickPlayFlag = clickPlayFlag
self.playlist.set_current_row(row)
sourcePath = self.playlist.get_music_path_at(row)
self.title = self.playlist.get_music_title_at(row)
self.sourceTrace = "local" if self.playlist.get_music_id_at(row) == Configures.LocalMusicId else "online"
self.artistName, self.musicName = get_artist_and_musicname_from_title(self.title)
self.playlistName = self.playlist.get_name()
self.totalTime = self.playlist.get_music_time_at(row)
self.album = self.playlist.get_music_album_at(row)
self.errorType = Configures.NoError
isAnUrl = False
if not os.path.exists(sourcePath):
if self.playlist.get_name() == Configures.PlaylistOnline:
if sourcePath == Configures.NoLink:
musicId = self.playlist.get_music_id_at(row)
sourcePath = SearchOnline.get_song_link(musicId)
if sourcePath:
self.playlist.set_music_path_at(row, sourcePath)
else:
self.errorType = Configures.UrlError
isAnUrl = True
else:
self.errorType = Configures.PathError
sourcePath = "/usr/share/sounds/error_happened.ogg"
if self.errorType == Configures.NoError:
self.sourcePath = sourcePath
self.musicFileName = get_base_name_from_path(sourcePath)
self.playedDate = get_time_of_now()
self.songinfosManager.update_datas_of_item(
self.musicFileName,
self.playedDate,
self.musicName,
self.artistName,
self.totalTime,
self.album,
self.playlistName,
)
if not self.timerFlag:
self.timerFlag = True
self.timeSpan = 0
if isAnUrl:
url = QUrl(sourcePath)
else:
url = QUrl.fromLocalFile(sourcePath)
self.play_from_url(url)
else:
self.timerFlag = False
self.dont_hide_main_window_signal.emit()
if self.errorType == Configures.DisnetError:
QMessageBox.critical(
self, "错误", "联网出错！\n无法联网播放歌曲'%s'！\n您最好在网络畅通时下载该曲目！" % self.playlist.get_music_title_at(row)
)
elif self.errorType == Configures.PathError:
QMessageBox.information(self, "提示", "路径'%s'无效，请尝试重新下载并添加对应歌曲！" % self.playlist.get_music_path_at(row))
def play_from_url(self, url):
mediaContent = QMediaContent(url)
self.mediaPlayer.setMedia(mediaContent)
self.mediaPlayer.play()
def state_changed(self, newState):
if self and newState in [QMediaPlayer.PlayingState, QMediaPlayer.PausedState, QMediaPlayer.StoppedState]:
if not self.playlist.length():
return
iconPath = IconsHub.ControlPause
if newState in [QMediaPlayer.StoppedState, QMediaPlayer.PausedState]:
iconPath = IconsHub.ControlPlay
icon = QIcon(iconPath)
self.playAction.setIcon(icon)
if self.timerFlag:
if newState == QMediaPlayer.PlayingState:
self.timeStart = time.time()
else:
self.timeSpan += time.time() - self.timeStart
def media_status_changed(self, status):
if status == QMediaPlayer.EndOfMedia:
self.music_finished()
def music_finished(self):
if self.errorType == Configures.NoError:
self.next_song()
def play_music(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def stop_music_but_timing(self):
self.mediaPlayer.stop()
self.seekSlider.setValue(0)
self.media_player_notify_signal.emit(-0.5)
def stop_music(self):
self.stop_music_but_timing()
if self.timerFlag:
self.timerFlag = False
InfosList = [
self.playedDate,
self.musicFileName,
self.musicName,
self.artistName,
self.album,
"%i" % change_mmss_to_seconds(self.totalTime),
"%.1f" % self.timeSpan,
self.playlistName,
self.sourcePath,
"%i" % (self.title in self.lovedSongs),
self.sourceTrace,
Configures.Playmodes[self.playmode],
"%i" % self.clickPlayFlag,
]
log_playback_history(organized_list_as_str(InfosList))
self.songinfosManager.update_time_span_relate_of_item(self.musicFileName, self.timeSpan, self.clickPlayFlag)
self.clickPlayFlag = False
def get_next_random_row(self):
listTemp = list(self.playlist.get_ids() - set(self.nearPlayedSongs))
ran = random.randint(0, len(listTemp) - 1)
return self.playlist.get_items_queue().index(listTemp[ran])
def get_next_single_row(self):
nextRow = self.currentSourceRow
if nextRow < 0:
nextRow = 0
return nextRow
def get_next_order_row(self, reverse=False):
if reverse:
if self.currentSourceRow < 0:
self.currentSourceRow = 0
return (self.currentSourceRow - 1) % self.playlist.length()
return (self.currentSourceRow + 1) % self.playlist.length()
def previous_song(self):
self.play_source_on_next_row(reverse=True)
def next_song(self):
self.play_source_on_next_row()
def play_source_on_next_row(self, reverse=False):
if not self.playlist.length():
return
if self.mediaPlayer.position() > 20:
self.music_ended_signal.emit()
nextRow = 0
if self.playmode == Configures.PlaymodeRandom:
nextRow = self.get_next_random_row()
elif self.playmode == Configures.PlaymodeOrder:
nextRow = self.get_next_order_row(reverse)
elif self.playmode == Configures.PlaymodeSingle:
nextRow = self.get_next_single_row()
self.set_media_source_at_row(nextRow)
def current_media_changed(self):
if not self.playlist.length():
return
self.current_media_changed_signal.emit()
self.update_parameters()
self.update_near_played_queue()
self.check_favorite()
def update_parameters(self):
self.currentSourceRow = self.playlist.get_current_row()
self.musicTitleLabel.setText(self.title)
self.playAction.setText(self.musicName)
imagePath = SearchOnline.get_artist_image_path(self.artistName)
if imagePath:
pixmap = QPixmap(imagePath)
else:
pixmap = QPixmap(IconsHub.Anonymous)
self.artistHeadLabel.setPixmap(pixmap)
musicId = self.playlist.get_music_id_at(self.currentSourceRow)
self.update_window_lyric_signal.emit(self.title, musicId)
def update_near_played_queue(self):
self.currentSourceId = self.playlist.get_music_path_at(self.currentSourceRow)
if self.playlist.get_name() == Configures.PlaylistOnline:
self.currentSourceId = self.playlist.get_music_id_at(self.currentSourceRow)
if self.currentSourceId not in self.nearPlayedSongs:
self.nearPlayedSongs.append(self.currentSourceId)
while len(self.nearPlayedSongs) >= self.playlist.length() * 4 / 5:
del self.nearPlayedSongs[0]
def add_title_into_loved_songs(self, title):
self.lovedSongs.append(title)
class MainInterface(QMainWindow):
def __init__(self, screen_scale_rate, user):
super(MainInterface, self).__init__()
self.rate = screen_scale_rate # 屏幕缩放比例
self.lock_sign = 0
self.user = user
self.get_settin()
self.init_ui()
self._padding = 5 # 设置边界宽度为5
# 设置鼠标跟踪判断扳机默认值
# reference: https://blog.csdn.net/qq_38528972/article/details/78573591
self._move_drag = False
self._corner_drag = False
self._bottom_drag = False
self._right_drag = False
self._right_rect = []
self._bottom_rect = []
self._corner_rect = []
self.image = None
self.load_local_img = False
self.load_local_img_path = folder_path
self.save_result_path = [folder_path] # 写成list, 传入方式为引用, 便于修改
def init_ui(self):
# 窗口尺寸
self.resize(800 * self.rate, 120 * self.rate)
self.setMouseTracking(True) # 设置widget鼠标跟踪
# 窗口无标题栏、窗口置顶、窗口透明
self.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.FramelessWindowHint)
# Mac系统下隐藏标题栏同时窗口透明会造成窗口不能伸缩
self.setAttribute(Qt.WA_TranslucentBackground)
# self.setWindowOpacity(0.7)
# 窗口图标
self.icon = QIcon()
self.icon.addPixmap(QPixmap(folder_path + "/config/logo.ico"),
QIcon.Normal, QIcon.On)
self.setWindowIcon(self.icon)
# 系统托盘
self.tray = QSystemTrayIcon(self)
self.tray.setIcon(self.icon)
self.tray.activated.connect(self.show)
self.tray.show()
# 鼠标样式
# self.pixmap = QPixmap(folder_path + '/config/光标.png')
# self.cursor = QCursor(self.pixmap, 0, 0)
# self.setCursor(self.cursor)
# 工具栏标签
self.titleLabel = QLabel(self)
self.titleLabel.setGeometry(0, 0, 800 * self.rate, 30 * self.rate)
self.titleLabel.setStyleSheet(
"background-color:rgba(62, 62, 62, 0.01)")
self.Font = QFont()
self.Font.setFamily("华康方圆体W7")
self.Font.setPointSize(15)
# 翻译框
self.translateText = QTextBrowser(self)
self.translateText.setGeometry(0, 30 * self.rate, 1500 * self.rate,
90 * self.rate)
self.translateText.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.translateText.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.translateText.setStyleSheet("border-width:0;\
border-style:outset;\
border-top:0px solid #e8f3f9;\
color:white;\
font-weight: bold;\
background-color:rgba(62, 62, 62, %s)"
% (self.horizontal))
self.translateText.setFont(self.Font)
# 翻译框加入描边文字
self.format = QTextCharFormat()
self.format.setTextOutline(
QPen(QColor('#1E90FF'), 0.7, Qt.SolidLine, Qt.RoundCap,
Qt.RoundJoin))
self.translateText.mergeCurrentCharFormat(self.format)
self.translateText.append("欢迎~ 么么哒~")
self.format.setTextOutline(
QPen(QColor('#FF69B4'), 0.7, Qt.SolidLine, Qt.RoundCap,
Qt.RoundJoin))
self.translateText.mergeCurrentCharFormat(self.format)
self.translateText.append("点击设置修改待识别语言类型")
self.format.setTextOutline(
QPen(QColor('#674ea7'), 0.7, Qt.SolidLine, Qt.RoundCap,
Qt.RoundJoin))
self.translateText.mergeCurrentCharFormat(self.format)
self.translateText.append("点击截屏按钮选择识图区域")
# 翻译框根据内容自适应大小
self.document = self.translateText.document()
self.document.contentsChanged.connect(self.textAreaChanged)
# 此Label用于当鼠标进入界面时给出颜色反应
self.dragLabel = QLabel(self)
self.dragLabel.setObjectName("dragLabel")
self.dragLabel.setGeometry(0, 0, 4000 * self.rate, 2000 * self.rate)
# 截屏范围按钮
self.RangeButton = QPushButton(qticon('fa.crop', color='white'), "",
self)
self.RangeButton.setIconSize(QSize(20, 20))
self.RangeButton.setGeometry(
QRect(193 * self.rate, 5 * self.rate, 20 * self.rate,
20 * self.rate))
self.RangeButton.setToolTip(
'<b>截屏识别图片 ScreenShot Range</b><br>框选要识别的区域')
self.RangeButton.setStyleSheet("background-color:rgba(62, 62, 62, 0);")
self.RangeButton.setCursor(QCursor(Qt.PointingHandCursor))
self.RangeButton.hide()
# 运行按钮
self.StartButton = QPushButton(qticon('fa.play', color='white'), "",
self)
self.StartButton.setIconSize(QSize(20, 20))
self.StartButton.setGeometry(
QRect(233 * self.rate, 5 * self.rate, 20 * self.rate,
20 * self.rate))
self.StartButton.setToolTip(
'<b>识别 Recognize</b><br>点击开始（手动）<br>开始/停止（自动）')
self.StartButton.setStyleSheet("background: transparent")
self.StartButton.clicked.connect(self.start_login)
self.StartButton.setCursor(QCursor(Qt.PointingHandCursor))
self.StartButton.hide()
# 手动打开文件按钮
self.OpenButton = QPushButton(
qticon('fa.folder-open-o', color='white'), "", self)
self.OpenButton.setIconSize(QSize(20, 20))
self.OpenButton.setGeometry(
QRect(273 * self.rate, 5 * self.rate, 20 * self.rate,
20 * self.rate))
self.OpenButton.setToolTip('<b>打开识别图片 Open image</b><br> 识别本地图片')
self.OpenButton.setStyleSheet("background-color:rgba(62, 62, 62, 0);")
self.OpenButton.setCursor(QCursor(Qt.PointingHandCursor))
self.OpenButton.clicked.connect(self.open_image)
self.OpenButton.hide()
# 复制按钮
self.CopyButton = QPushButton(qticon('fa.copy', color='white'), "",
self)
self.CopyButton.setIconSize(QSize(20, 20))
self.CopyButton.setGeometry(
QRect(313 * self.rate, 5 * self.rate, 20 * self.rate,
20 * self.rate))
self.CopyButton.setToolTip('<b>复制 Copy</b><br>将当前识别到的文本<br>复制至剪贴板')
self.CopyButton.setStyleSheet("background-color:rgba(62, 62, 62, 0);")
self.CopyButton.setCursor(QCursor(Qt.PointingHandCursor))
self.CopyButton.clicked.connect(lambda: copy(self.original))
self.CopyButton.hide()
# 朗读原文按钮
self.playVoiceButton = QPushButton(qticon('fa.music', color='white'),
"", self)
self.playVoiceButton.setIconSize(QSize(20, 20))
self.playVoiceButton.setGeometry(
QRect(353 * self.rate, 5 * self.rate, 20 * self.rate,
20 * self.rate))
self.playVoiceButton.setToolTip('<b>朗读原文 Play Voice</b><br>朗读识别到的原文')
self.playVoiceButton.setStyleSheet("background: transparent")
self.playVoiceButton.clicked.connect(self.play_voice)
self.playVoiceButton.setCursor(QCursor(Qt.PointingHandCursor))
self.playVoiceButton.hide()
# 翻译模式按钮
self.switchBtn = SwitchBtn(self)
self.switchBtn.setGeometry(393 * self.rate, 5 * self.rate,
50 * self.rate, 20 * self.rate)
self.switchBtn.setToolTip('<b>模式 Mode</b><br>手动识别/自动识别')
self.switchBtn.checkedChanged.connect(self.getState)
self.switchBtn.setCursor(QCursor(Qt.PointingHandCursor))
self.switchBtn.hide()
# 识别原文字类型提示框
languageFont = QFont()
languageFont.setFamily("华康方圆体W7")
languageFont.setPointSize(10)
self.languageText = QPushButton(self)
self.languageText.setIconSize(QSize(20, 20))
self.languageText.setGeometry(
QRect(463 * self.rate, 5 * self.rate, 45 * self.rate,
20 * self.rate))
self.languageText.setToolTip(
'<b>待识别的原文类型 </b><br>Original Language Type')
self.languageText.setStyleSheet("border-width:0;\
border-style:outset;\
border-top:0px solid #e8f3f9;\
color:white;\
background-color:rgba(143, 143, 143, 0)"
)
self.languageText.setCursor(QCursor(Qt.PointingHandCursor))
self.languageText.setText(
config.letter_chinese_dict[self.data["language"]])
self.languageText.setFont(languageFont)
self.languageText.hide()
# 设置按钮
self.SettinButton = QPushButton(qticon('fa.cog', color='white'), "",
self)
self.SettinButton.setIconSize(QSize(20, 20))
self.SettinButton.setGeometry(
QRect(518 * self.rate, 5 * self.rate, 20 * self.rate,
20 * self.rate))
self.SettinButton.setToolTip('<b>设置 Settin</b>')
self.SettinButton.setStyleSheet(
"background-color:rgba(62, 62, 62, 0);")
self.SettinButton.setCursor(QCursor(Qt.PointingHandCursor))
self.SettinButton.hide()
# 锁按钮
self.LockButton = QPushButton(qticon('fa.lock', color='white'), "",
self)
self.LockButton.setIconSize(QSize(20, 20))
self.LockButton.setGeometry(
QRect(562 * self.rate, 5 * self.rate, 20 * self.rate,
20 * self.rate))
self.LockButton.setToolTip('<b>锁定翻译界面 Lock</b>')
self.LockButton.setStyleSheet("background-color:rgba(62, 62, 62, 0);")
self.LockButton.setCursor(QCursor(Qt.PointingHandCursor))
self.LockButton.clicked.connect(self.lock)
self.LockButton.hide()
# 最小化按钮
self.MinimizeButton = QPushButton(qticon('fa.minus', color='white'),
"", self)
self.MinimizeButton.setIconSize(QSize(20, 20))
self.MinimizeButton.setGeometry(
QRect(602 * self.rate, 5 * self.rate, 20 * self.rate,
20 * self.rate))
self.MinimizeButton.setToolTip('<b>最小化 Minimize</b>')
self.MinimizeButton.setStyleSheet(
"background-color:rgba(62, 62, 62, 0);")
self.MinimizeButton.setCursor(QCursor(Qt.PointingHandCursor))
self.MinimizeButton.clicked.connect(self.showMinimized)
self.MinimizeButton.hide()
# 退出按钮
self.QuitButton = QPushButton(qticon('fa.times', color='white'), "",
self)
self.QuitButton.setIconSize(QSize(20, 20))
self.QuitButton.setGeometry(
QRect(642 * self.rate, 5 * self.rate, 20 * self.rate,
20 * self.rate))
self.QuitButton.setToolTip('<b>退出程序 Quit</b>')
self.QuitButton.setStyleSheet("background-color:rgba(62, 62, 62, 0);")
self.QuitButton.setCursor(QCursor(Qt.PointingHandCursor))
self.QuitButton.hide()
# 右下角用于拉伸界面的控件 mac系统应该注释掉
self.statusbar = QStatusBar(self)
self.statusbar.setStyleSheet("background-color:rgba(62, 62, 62, 0);")
self.setStatusBar(self.statusbar)
# 锁定界面
def lock(self):
try:
if self.lock_sign == 0:
self.LockButton.setIcon(qticon('fa.unlock', color='white'))
self.dragLabel.hide()
self.lock_sign = 1
if self.horizontal == 0.01:
self.horizontal = 0
else:
self.LockButton.setIcon(qticon('fa.lock', color='white'))
self.LockButton.setStyleSheet(
"background-color:rgba(62, 62, 62, 0);")
self.dragLabel.show()
self.lock_sign = 0
if self.horizontal == 0:
self.horizontal = 0.01
self.translateText.setStyleSheet("border-width:0;\
border-style:outset;\
border-top:0px solid #e8f3f9;\
color:white;\
font-weight: bold;\
background-color:rgba(62, 62, 62, %s)"
% (self.horizontal))
except Exception:
write_error(format_exc())
# 当翻译内容改变时界面自适应窗口大小
def textAreaChanged(self):
newHeight = self.document.size().height()
width = self.width()
self.resize(width, newHeight + 30 * self.rate)
self.translateText.setGeometry(0, 30 * self.rate, width, newHeight)
# 判断翻译模式键状态
def getState(self, checked):
if checked:
self.mode = True
else:
self.mode = False
with open(folder_path + '/config/settin.json') as file:
data = load(file)
data["sign"] = 1
with open(folder_path + '/config/settin.json', 'w') as file:
dump(data, file, indent=2)
self.StartButton.setIcon(qticon('fa.play', color='white'))
# 鼠标移动事件
def mouseMoveEvent(self, e: QMouseEvent):
if self.lock_sign == 1:
return
try:
self._endPos = e.pos() - self._startPos
self.move(self.pos() + self._endPos)
except Exception:
write_error(format_exc())
# 鼠标移动事件 mac
# def mouseMoveEvent(self, QMouseEvent):
# if self.lock_sign == 1:
# return
#
# # 判断鼠标位置切换鼠标手势
# if QMouseEvent.pos() in self._corner_rect:
# self.setCursor(Qt.SizeFDiagCursor)
# elif QMouseEvent.pos() in self._bottom_rect:
# self.setCursor(Qt.SizeVerCursor)
# elif QMouseEvent.pos() in self._right_rect:
# self.setCursor(Qt.SizeHorCursor)
# else:
# self.setCursor(self.cursor)
# # self.setCursor(Qt.ArrowCursor)
#
# # 当鼠标左键点击不放及满足点击区域的要求后，分别实现不同的窗口调整
# if Qt.LeftButton and self._right_drag:
# # 右侧调整窗口宽度
# self.resize(QMouseEvent.pos().x(), self.height())
# QMouseEvent.accept()
# elif Qt.LeftButton and self._bottom_drag:
# # 下侧调整窗口高度
# self.resize(self.width(), QMouseEvent.pos().y())
# QMouseEvent.accept()
# elif Qt.LeftButton and self._corner_drag:
# # 右下角同时调整高度和宽度
# self.resize(QMouseEvent.pos().x(), QMouseEvent.pos().y())
# QMouseEvent.accept()
# elif Qt.LeftButton and self._move_drag:
# # 标题栏拖放窗口位置
# self.move(QMouseEvent.globalPos() - self.move_drag_position)
# QMouseEvent.accept()
# # 鼠标按下事件
def mousePressEvent(self, e: QMouseEvent):
if self.lock_sign == 1:
return
try:
if e.button() == Qt.LeftButton:
self._isTracking = True
self._startPos = QPoint(e.x(), e.y())
except Exception:
write_error(format_exc())
# 鼠标按下事件 mac
# def mousePressEvent(self, event):
#
# if self.lock_sign == 1:
# return
#
# try:
# # 重写鼠标点击的事件
# if (event.button() == Qt.LeftButton) and (event.pos() in self._corner_rect):
# # 鼠标左键点击右下角边界区域
# self._corner_drag = True
# event.accept()
# elif (event.button() == Qt.LeftButton) and (event.pos() in self._right_rect):
# # 鼠标左键点击右侧边界区域
# self._right_drag = True
# event.accept()
# elif (event.button() == Qt.LeftButton) and (event.pos() in self._bottom_rect):
# # 鼠标左键点击下侧边界区域
# self._bottom_drag = True
# event.accept()
# elif (event.button() == Qt.LeftButton) and (event.y() < self.height()):
# # 鼠标左键点击区域
# self._move_drag = True
# self.move_drag_position = event.globalPos() - self.pos()
# event.accept()
# except Exception:
# write_error(format_exc())
# # 鼠标松开事件
def mouseReleaseEvent(self, e: QMouseEvent):
if self.lock_sign == 1:
return
try:
if e.button() == Qt.LeftButton:
self._isTracking = False
self._startPos = None
self._endPos = None
except Exception:
write_error(format_exc())
# 鼠标松开事件 mac
# def mouseReleaseEvent(self, e: QMouseEvent):
# if self.lock_sign == 1:
# return
#
# try:
# if e.button() == Qt.LeftButton:
# self._isTracking = False
# self._startPos = None
# self._endPos = None
#
# # 鼠标释放后，各扳机复位
# self._move_drag = False
# self._corner_drag = False
# self._bottom_drag = False
# self._right_drag = False
# except Exception:
# write_error(format_exc())
# 鼠标进入控件事件
def enterEvent(self, QEvent):
if self.lock_sign == 1:
self.LockButton.show()
self.LockButton.setStyleSheet(
"background-color:rgba(62, 62, 62, 0.7);")
return
try:
# 显示所有顶部工具栏控件
self.switchBtn.show()
self.StartButton.show()
self.SettinButton.show()
self.RangeButton.show()
self.OpenButton.show()
self.CopyButton.show()
self.QuitButton.show()
self.MinimizeButton.show()
self.playVoiceButton.show()
self.LockButton.show()
self.languageText.show()
self.setStyleSheet(
'QLabel#dragLabel {background-color:rgba(62, 62, 62, 0.3)}')
except Exception:
write_error(format_exc())
def resizeEvent(self, QResizeEvent):
# 重新调整边界范围以备实现鼠标拖放缩放窗口大小，采用三个列表生成式生成三个列表
self._right_rect = [
QPoint(x, y) for x in range(self.width() - self._padding,
self.width() + 1)
for y in range(1,
self.height() - self._padding)
]
self._bottom_rect = [
QPoint(x, y) for x in range(1,
self.width() - self._padding)
for y in range(self.height() - self._padding,
self.height() + 1)
]
self._corner_rect = [
QPoint(x, y) for x in range(self.width() - self._padding,
self.width() + 1)
for y in range(self.height() - self._padding,
self.height() + 1)
]
# 鼠标离开控件事件
def leaveEvent(self, QEvent):
try:
# 重置所有控件的位置和大小
width = (self.width() * 213) / 800
height = self.height() - 30
self.RangeButton.setGeometry(
QRect(width - 20 * self.rate, 5 * self.rate, 20 * self.rate,
20 * self.rate))
self.StartButton.setGeometry(
QRect(width + 20 * self.rate, 5 * self.rate, 20 * self.rate,
20 * self.rate))
self.OpenButton.setGeometry(
QRect(width + 60 * self.rate, 5 * self.rate, 20 * self.rate,
20 * self.rate))
self.CopyButton.setGeometry(
QRect(width + 100 * self.rate, 5 * self.rate, 20 * self.rate,
20 * self.rate))
self.playVoiceButton.setGeometry(
QRect(width + 140 * self.rate, 5 * self.rate, 20 * self.rate,
20 * self.rate))
self.switchBtn.setGeometry(
QRect(width + 180 * self.rate, 5 * self.rate, 50 * self.rate,
20 * self.rate))
self.languageText.setGeometry(width + 250 * self.rate,
5 * self.rate, 45 * self.rate,
20 * self.rate)
self.SettinButton.setGeometry(
QRect(width + 305 * self.rate, 5 * self.rate, 20 * self.rate,
20 * self.rate))
self.LockButton.setGeometry(
QRect(width + 345 * self.rate, 5 * self.rate, 24 * self.rate,
20 * self.rate))
self.MinimizeButton.setGeometry(
QRect(width + 389 * self.rate, 5 * self.rate, 20 * self.rate,
20 * self.rate))
self.QuitButton.setGeometry(
QRect(width + 429 * self.rate, 5 * self.rate, 20 * self.rate,
20 * self.rate))
self.translateText.setGeometry(0, 30 * self.rate, self.width(),
height * self.rate)
# 隐藏所有顶部工具栏控件
self.switchBtn.hide()
self.StartButton.hide()
self.SettinButton.hide()
self.RangeButton.hide()
self.OpenButton.hide()
self.CopyButton.hide()
self.QuitButton.hide()
self.MinimizeButton.hide()
self.playVoiceButton.hide()
self.LockButton.hide()
self.languageText.hide()
self.setStyleSheet('QLabel#dragLabel {background-color:none}')
except Exception:
write_error(format_exc())
# 获取界面预设参数
def get_settin(self):
with open(folder_path + '/config/settin.json') as file:
self.data = load(file)
# 翻译模式预设
self.mode = False
# 原文预设值
self.original = ''
# 透明度预设
self.horizontal = (self.data["horizontal"]) / 100
if self.horizontal == 0:
self.horizontal = 0.01
# 各翻译源线程状态标志
self.thread_state = 0
def start_login(self):
with open(folder_path + '/config/settin.json') as file:
data = load(file)
if data["sign"] % 2 == 0:
data["sign"] += 1
with open(folder_path + '/config/settin.json', 'w') as file:
dump(data, file, indent=2)
self.StartButton.setIcon(qticon('fa.play', color='white'))
else:
thread = TranslateThread(self, self.mode)
thread.use_translate_signal.connect(self.use_translate)
thread.start()
thread.exec()
# 创造翻译线程
def creat_thread(self, fun, original, data, translate_type):
self.thread_state += 1 # 线程开始，增加线程数
translation_source = UseTranslateThread(fun, original, data,
translate_type)
thread = Thread(target=translation_source.run)
thread.setDaemon(True)
translation_source.use_translate_signal.connect(self.display_text)
thread.start()
# 并发执行所有翻译源
def use_translate(self, signal_list, original, data, result_with_location,
translate_result):
# 翻译界面清屏
self.translateText.clear()
# 设定翻译时的字体类型和大小
self.Font.setFamily(data["fontType"])
self.Font.setPointSize(data["fontSize"])
self.translateText.setFont(self.Font)
if "original" in signal_list or "error" in signal_list:
if data["vis_result"] == "True":
self.vis_res = VisResult(np_img=self.image,
result=result_with_location,
configs=data,
translate_result=translate_result,
save_path=self.save_result_path)
self.vis_res.result_signal.connect(self.display_modify_text)
self.vis_res.show()
if translate_result == '':
self.creat_thread(None, original, data, "original")
else:
if data['showOriginal'] == "True":
self.creat_thread(None, original, data, "original")
self.creat_thread(None, translate_result, data, "translated")
# 将翻译结果打印
def display_text(self, result, data, translate_type):
try:
if data["showColorType"] == "False":
self.format.setTextOutline(
QPen(QColor(data["fontColor"][translate_type]), 0.7,
Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
self.translateText.mergeCurrentCharFormat(self.format)
self.translateText.append(result)
else:
self.translateText.append(
"<font color=%s>%s</font>" %
(data["fontColor"][translate_type], result))
# 保存译文
self.save_text(result, translate_type)
self.thread_state -= 1 # 线程结束，减少线程数
except Exception:
write_error(format_exc())
# 将修改后的结果打印
def display_modify_text(self, result, data, translate_type,
translate_result):
self.translateText.clear()
if data["showColorType"] == "False":
if translate_result == '':
self.format.setTextOutline(
QPen(QColor(data["fontColor"][translate_type]), 0.7,
Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
self.translateText.mergeCurrentCharFormat(self.format)
self.translateText.append(result)
else:
if data["showOriginal"] == "True":
self.format.setTextOutline(
QPen(QColor(data["fontColor"][translate_type]), 0.7,
Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
self.translateText.mergeCurrentCharFormat(self.format)
self.translateText.append(result)
self.format.setTextOutline(
QPen(QColor(data["fontColor"]['translated']), 0.7,
Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
self.translateText.mergeCurrentCharFormat(self.format)
self.translateText.append(translate_result)
else:
if translate_result == '':
self.translateText.append(
"<font color=%s>%s</font>" %
(data["fontColor"][translate_type], result))
else:
if data["showOriginal"] == "True":
self.translateText.append(
"<font color=%s>%s</font>" %
(data["fontColor"][translate_type], result))
self.translateText.append(
"<font color=%s>%s</font>" %
(data["fontColor"]['translated'], translate_result))
self.original = result
# 语音朗读
def play_voice(self):
if not self.original:
return
try:
# thread = Thread(target=Voice, args=(self.original,))
# thread.setDaemon(True)
# thread.start()
self.player = None
flag, voice_file = Voice(self.original).save_voice()
if flag:
file = QUrl.fromLocalFile(voice_file)
content = QMediaContent(file)
self.player = QMediaPlayer()
self.player.setMedia(content)
self.player.play()
except Exception:
write_error(format_exc())
def save_text(self, text, translate_type):
if translate_type == "caiyunPrivate":
content = "\n[私人翻译]\n%s" % text
else:
content = ""
with open(folder_path + "/config/识别结果.txt", "a+",
encoding="utf-8") as file:
file.write(content)
def open_image(self):
file_choose, file_type = QFileDialog.getOpenFileName(
self, "选取文件", self.load_local_img_path,
"jpg (*.jpg);; png (*.png);; jpeg (*.jpeg);;All Files (*)")
img = imread(file_choose)
if img is not None:
self.load_local_img_path = dirname(file_choose)
self.image = img
self.load_local_img = True
self.start_login()
class QGisMap(QtWidgets.QWidget, Ui_Form):
def __init__(self,projectfile,MainWidget):
QtWidgets.QMainWindow.__init__(self)
if os.name == 'nt':
ffmpeg = os.path.dirname(__file__)[0:-18]+'/Video_UAV_Tracker/FFMPEG/ffmpeg.exe'
versione = 'ffmpeg.exe'
else:
ffmpeg = os.path.dirname(__file__)+'/FFMPEG/./ffmpeg'
versione = 'ffmpeg'
if os.path.exists(ffmpeg) == True:
self.setupUi(self)
self.setWindowFlags(Qt.WindowStaysOnTopHint)
self.Main = MainWidget
self.projectfile = projectfile
with open(self.projectfile,'r') as File:
for line in File:
if line[0:19] == 'Video file location':
self.videoFile = line.split('=')[-1][1:-1]
elif line[0:23] == 'Video start at msecond:':
self.fps = (1 / (float(line.split()[7]))) * 1000
self.StartMsecond = int(line.split()[4])
elif line[0:4] == 'DB =':
DB = line.split('=')[-1][1:-1]
if DB == 'None':
self.DB = None
else:
self.DB = DB
break
self.pushButton_3.setCheckable(True)
self.EnableMapTool = False
self.ExtractTool = 0
self.dockWidget_4.hide()
self.GPXList = []
self.positionMarker=PositionMarker(self.Main.iface.mapCanvas())
self.muteButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaVolume))
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
self.player = QMediaPlayer()
self.player.setVideoOutput(self.video_frame)
self.playButton.clicked.connect(self.PlayPause)
self.muteButton.clicked.connect(self.MuteUnmute)
self.toolButton_11.clicked.connect(self.SkipBackward)
self.toolButton_12.clicked.connect(self.SkipForward)
self.SkipBacktoolButton_8.clicked.connect(self.BackwardFrame)
self.SkipFortoolButton_9.clicked.connect(self.ForwardFrame)
self.toolButton_4.clicked.connect(self.ExtractToolbar)
self.toolButton_5.clicked.connect(self.close)
self.pushButtonCut_2.clicked.connect(self.ExtractCommand)
self.pushButtonCutA_6.clicked.connect(self.ExtractFromA)
self.pushButtonCutB_6.clicked.connect(self.ExtractToB)
self.pushButton_5.clicked.connect(self.CancelVertex)
self.progressBar.hide()
self.Main.pushButton_2.hide()
self.Main.pushButton_8.hide()
self.Main.groupBox.show()
self.Main.groupBox_4.hide()
self.ExtractA = False
self.ExtractB = False
self.ExtractedDirectory = None
self.pushButtonCut_2.setEnabled(False)
self.toolButton_6.setEnabled(False)
self.LoadGPXVideoFromPrj(self.projectfile)
else:
ret = QMessageBox.warning(self, "Warning", 'missing ffmpeg binaries, please download it from https://github.com/sagost/VideoUavTracker/blob/master/FFMPEG/'+versione+' and paste it in /.qgis3/python/plugins/Video_UAV_Tracker/FFMPEG/ ', QMessageBox.Ok)
self.close()
def LoadGPXVideoFromPrj(self,VideoGisPrj):
self.Polyline = []
with open(VideoGisPrj,'r') as File:
Counter = 0
for line in File:
if Counter < 5:
pass
else:
line = line.split()
lat = float(line[0])
lon = float(line[1])
ele = float(line[2])
speed = float(line[3])
course = float(line[4])
time = line[5]
Point = [lat,lon,ele,speed,course,time]
qgsPoint = QgsPoint(lon,lat)
self.Polyline.append(qgsPoint)
self.GPXList.append(Point)
Counter = Counter + 1
self.GpsLayer = QgsVectorLayer("LineString?crs=epsg:4326", self.videoFile.split('.')[-2].split('/')[-1], "memory")
self.pr = self.GpsLayer.dataProvider()
feat = QgsFeature()
feat.setGeometry(QgsGeometry.fromPolyline(self.Polyline))
self.pr.addFeatures([feat])
self.GpsLayer.updateExtents()
if self.DB != None:
try:
self.DBLayer = QgsVectorLayer(self.DB,self.DB.split('.')[-2].split('/')[-1],'ogr')
QgsProject.instance().addMapLayers([self.DBLayer,self.GpsLayer])
self.AddPointMapTool = AddPointTool(self.Main.iface.mapCanvas(),self.DBLayer,self)
self.toolButton_6.clicked.connect(self.AddPointTool)
self.toolButton_6.setEnabled(True)
except:
ret = QMessageBox.warning(self, "Warning", str(self.DB)+' is not a valid shapefile.', QMessageBox.Ok)
return
else:
QgsProject.instance().addMapLayers([self.GpsLayer])
self.duration = len(self.GPXList)
self.ExtractToB = self.duration
self.horizontalSlider.setSingleStep(1000)
self.horizontalSlider.setMinimum(0)
self.horizontalSlider.setMaximum(len(self.GPXList)*1000)
url = QUrl.fromLocalFile(str(self.videoFile))
mc = QMediaContent(url)
self.player.setMedia(mc)
self.player.setPosition(self.StartMsecond)
self.player.play()
self.horizontalSlider.sliderMoved.connect(self.setPosition)
self.player.stateChanged.connect(self.mediaStateChanged)
self.player.positionChanged.connect(self.positionChanged)
self.pushButton_3.clicked.connect(self.MapTool)
self.skiptracktool = SkipTrackTool( self.Main.iface.mapCanvas(),self.GpsLayer , self)
def AddPointTool(self):
self.Main.iface.mapCanvas().setMapTool(self.AddPointMapTool)
def MapTool(self):
if self.EnableMapTool == False:
self.Main.iface.mapCanvas().setMapTool(self.skiptracktool)
self.pushButton_3.setChecked(True)
self.EnableMapTool = True
else:
self.Main.iface.mapCanvas().unsetMapTool(self.skiptracktool)
self.pushButton_3.setChecked(False)
self.EnableMapTool = False
def closeEvent(self, *args, **kwargs):
try:
self.player.stop()
self.Main.iface.mapCanvas().scene().removeItem(self.positionMarker)
self.CancelVertex()
self.Main.pushButton_2.show()
#self.Main.horizontalSpacer_2.show()
self.Main.groupBox.hide()
self.Main.pushButton_8.show()
self.Main.groupBox_4.show()
self.dockWidget_2.close()
except:
pass
return QtWidgets.QWidget.closeEvent(self, *args, **kwargs)
def mediaStateChanged(self, state):
if self.player.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
def setPosition(self, position):
self.player.setPosition(position+self.StartMsecond)
def secTotime(self,seconds):
m, s = divmod(seconds, 60)
h, m = divmod(m, 60)
return "%d:%02d:%02d" % (h, m, s)
def positionChanged(self, progress):
if progress < self.StartMsecond:
self.player.setPosition(self.StartMsecond)
progress = self.StartMsecond
AssociatedGps = round((progress - self.StartMsecond )/1000)
self.DisplayPoint(AssociatedGps)
totalTime = self.secTotime(self.duration)
actualTime = self.secTotime((progress - self.StartMsecond )/1000)
self.replayPosition_label.setText(actualTime + ' / '+totalTime)
if not self.horizontalSlider.isSliderDown():
self.horizontalSlider.setValue(progress - self.StartMsecond )
def DisplayPoint(self,Point):
if Point >= len(self.GPXList):
Point = len(self.GPXList) - 1
gpx = self.GPXList[Point]
lat = round(gpx[0],7)
lon = round(gpx[1],7)
ele = gpx[2]
speed = gpx[3]
course = gpx[4]
time = gpx[5]
Point = QgsPointXY()
Point.set(lon, lat)
canvas = self.Main.iface.mapCanvas()
crsSrc = QgsCoordinateReferenceSystem(4326) # .gpx is in WGS 84
crsDest = QgsProject.instance().crs()
xform = QgsCoordinateTransform(crsSrc, crsDest)
self.positionMarker.setHasPosition(True)
self.Point = xform.transform(Point)
self.positionMarker.newCoords(self.Point)
self.positionMarker.angle = float(course)
extent = canvas.extent()
boundaryExtent=QgsRectangle(extent)
boundaryExtent.scale(0.7)
if not boundaryExtent.contains(QgsRectangle(Point, self.Point)):
extentCenter= self.Point
newExtent=QgsRectangle(
extentCenter.x()-extent.width()/2,
extentCenter.y()-extent.height()/2,
extentCenter.x()+extent.width()/2,
extentCenter.y()+extent.height()/2
)
self.Main.iface.mapCanvas().setExtent(newExtent)
self.Main.iface.mapCanvas().refresh()
self.Main.label_14.setText('GPS Time: '+str(time))
self.Main.label_15.setText('Course: '+"%.2f" % (course))
self.Main.label_16.setText('Ele: '+"%.2f" %(ele))
self.Main.label_17.setText('Speed m/s: '+"%.2f" %(speed))
self.Main.label_19.setText('Lat : '+str(lat))
self.Main.label_18.setText('Lon : '+str(lon))
def MuteUnmute(self):
if self.player.mediaStatus() == 6 :
if self.player.isMuted() == 1:
self.player.setMuted(0)
self.muteButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaVolume))
elif self.player.isMuted() == 0:
self.player.setMuted(1)
self.muteButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaVolumeMuted))
def SkipForward(self):
position = self.player.position()
self.player.setPosition(position+1000)
def SkipBackward(self):
position = self.player.position()
self.player.setPosition(position-1000)
def ForwardFrame(self):
position = self.player.position()
self.player.setPosition(position+int(self.fps))
def BackwardFrame(self):
position = self.player.position()
self.player.setPosition(position-int(self.fps))
def PlayPause(self):
if self.player.state() == QMediaPlayer.PlayingState:
self.player.pause()
else:
self.player.play()
def findNearestPointInRecording(self, x,y):
ClickPt = QgsPoint(x,y)
Low = ClickPt.distanceSquared(self.Polyline[0])
NearPoint = 0
Counter = 0
for Point in self.Polyline:
dist = ClickPt.distanceSquared(Point)
if dist < Low:
Low = dist
NearPoint = Counter
Counter = Counter + 1
else:
Counter = Counter + 1
self.setPosition(NearPoint*1000)
def ExtractSingleFrameOnTime(self, pos, outputfile):
if os.name == 'nt':
ffmpeg = ('"'+os.path.dirname(__file__)[0:-18]+'/Video_UAV_Tracker/FFMPEG/ffmpeg.exe'+'"')
os.popen(str(ffmpeg)+' -ss '+str(pos/1000)+' -i '+str('"' +self.videoFile+ '"')+ ' -t 1 '+str('"'+outputfile+'"'))
else:
ffmpeg = os.path.dirname(__file__)+'/FFMPEG/./ffmpeg'
os.system(str(ffmpeg)+' -ss '+str(pos/1000)+' -i '+str(self.videoFile)+' -t 1 '+str(outputfile))
def AddPoint(self,x,y):
self.Main.iface.mapCanvas().unsetMapTool(self.AddPointMapTool)
Point = QgsPointXY(x,y)
pos = self.player.position()
if self.player.state() == QMediaPlayer.PlayingState:
self.player.pause()
a = self.DBLayer.name()
last_desc = '///'
LayerName =str(a)
last_desc2 = LayerName + ' Point N '
directory = str(self.DB.split('.')[0])+'_Image/'
if not os.path.exists(directory):
os.makedirs(directory)
fc = int(self.DBLayer.featureCount())
self.ExtractSingleFrameOnTime(pos,directory+LayerName+'_'+str(fc)+'_.jpg')
fields = self.DBLayer.fields()
attributes = []
lat,lon = Point.y(), Point.x()
for field in fields:
a = str(field.name())
b = str(field.typeName())
if a == 'id':
fcnr = fc
attributes.append(fcnr)
elif a == 'Lon(WGS84)':
attributes.append(str(lon))
elif a == 'Lat(WGS84)':
attributes.append(str(lat))
elif a == 'Image link':
attributes.append(str(directory+LayerName+'_'+str(fc)+'_.jpg'))
else:
if b == 'String':
(a,ok) = QInputDialog.getText(
self.Main.iface.mainWindow(),
"Attributes",
a + ' = String',
QLineEdit.Normal)
attributes.append(a)
elif b == 'Real':
(a,ok) = QInputDialog.getDouble(
self.Main.iface.mainWindow(),
"Attributes",
a + ' = Real', decimals = 10)
attributes.append(a)
elif b == 'Integer64':
(a,ok) = QInputDialog.getInt(
self.Main.iface.mainWindow(),
"Attributes",
a + ' = Integer')
attributes.append(a)
feature = QgsFeature()
feature.setGeometry(QgsGeometry.fromPoint(Point))
feature.setAttributes(attributes)
self.DBLayer.startEditing()
self.DBLayer.addFeature(feature)
self.DBLayer.commitChanges()
self.DBLayer.triggerRepaint()
def ExtractCommand(self):
if self.ExtractToB <= self.ExtractFromA:
ret = QMessageBox.warning(self, "Warning", '"To B" point must be after "from A" point', QMessageBox.Ok)
self.CancelVertex()
else:
if os.name == 'nt':
ffmpeg = '"'+os.path.dirname(__file__)[0:-18]+'/Video_UAV_Tracker/FFMPEG/ffmpeg.exe'+'"'
else:
ffmpeg = os.path.dirname(__file__)+'/FFMPEG/./ffmpeg'
Directory,_ = QFileDialog.getSaveFileName(caption= 'Save georeferenced images')
if Directory:
self.progressBar.show()
self.progressBar.setValue(0)
start = self.ExtractFromA
if self.comboBox_6.currentText() == 'seconds':
finish = self.ExtractToB - self.ExtractFromA
fps = self.doubleSpinBox_2.value()
if fps < 1.0:
fps = 1.0 / fps
elif fps > 1:
fps = 1.0 / fps
if os.name == 'nt':
os.popen(str(ffmpeg+ ' -ss ' + str(start) + ' -i '+ str('"'+self.videoFile+'"')+ ' -t ' + str(finish) + ' -vf fps=' + str(fps) + ' ' + '"'+Directory + '_%d.png'+'"'))
else:
os.system(ffmpeg+' -ss '+ str(start) + ' -i '+ str(self.videoFile) + ' -t ' + str(finish) + ' -vf fps=' + str(fps) + ' ' + Directory + '_%d.png')
else:
txtGPSFile = open(Directory + 'UTM_Coordinates.txt', 'w')
txtGPSFile.close()
txtGPSFile = open(Directory+ 'UTM_Coordinates.txt', 'a')
txtGPSFile.write('filename # East UTM # North UTM # Ele '+ '\n')
finish = self.ExtractToB
meters = self.doubleSpinBox_2.value()
Timerange = range(start, finish + 1)
RemainToUseMeterTotal = 0
if os.name == 'nt':
os.popen(ffmpeg+' -ss '+ str(start) + ' -i '+ str('"'+self.videoFile+'"') + ' -frames:v 1 ' + '"'+Directory + '_sec_' + str(start)+'.00.png'+'"')
else:
os.system(ffmpeg+' -ss '+ str(start) + ' -i '+ str(self.videoFile) + ' -frames:v 1 ' + Directory + '_sec_' + str(start)+'.00.png')
lonUTM, latUTM,quotainutile = self.transform_wgs84_to_utm(float(self.GPXList[start][1]) , float(self.GPXList[start][0]))
ele = float(self.GPXList[start][2])
txtGPSFile.write(str(Directory.split('/')[-1]) + '_sec_' + str(start)+'.00.png,'+' '+ str(lonUTM) + ', '+ str(latUTM) + ', ' + str(ele) + '\n')
for i in Timerange:
progessBarValue = ((i-start) * 100) // len(Timerange)
self.progressBar.setValue(int(progessBarValue))
latitude1,longitude1 = float(self.GPXList[i][0]) ,float(self.GPXList[i][1])
latitude2,longitude2 = float(self.GPXList[i+1][0]) ,float(self.GPXList[i+1][1])
ele1 = float(self.GPXList[i][2])
ele2 = float(self.GPXList[i+1][2])
Calculus = Geodesic.WGS84.Inverse(latitude1, longitude1, latitude2, longitude2)
DistanceBetweenPoint = Calculus['s12']
Azimuth = Calculus['azi2']
SpeedMeterSecond = DistanceBetweenPoint #GPS refresh rate is actually 1, change parameter for different rates
# Time = 1
if RemainToUseMeterTotal == 0:
if DistanceBetweenPoint >= meters:
decimalSecondToAdd = meters / DistanceBetweenPoint
RemainToUseMeter = DistanceBetweenPoint - meters
if os.name == 'nt':
os.popen(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str('"'+self.videoFile+'"') + ' -frames:v 1 ' +'"'+ Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png'+'"')
else:
os.system(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str(self.videoFile) + ' -frames:v 1 ' + Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png')
CalculusDirect = Geodesic.WGS84.Direct(latitude1, longitude1, Azimuth,decimalSecondToAdd* SpeedMeterSecond)
X,Y,quotainutile = self.transform_wgs84_to_utm(CalculusDirect['lon2'],CalculusDirect['lat2'] )
Z = ele1 + decimalSecondToAdd*(ele2 - ele1)
txtGPSFile.write(str(Directory.split('/')[-1]) + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4]+'.png,' + ' ' + str(X) + ', ' + str(Y) + ', ' + str(Z) + '\n')
while RemainToUseMeter > meters:
decimalSecondToAddMore = meters / SpeedMeterSecond
RemainToUseMeter = RemainToUseMeter - meters
decimalSecondToAdd = decimalSecondToAdd + decimalSecondToAddMore
if os.name == 'nt':
os.popen(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str('"'+self.videoFile+'"') + ' -frames:v 1 ' +'"'+ Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png'+'"')
else:
os.system(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str(self.videoFile) + ' -frames:v 1 ' + Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png')
CalculusDirect = Geodesic.WGS84.Direct(latitude1, longitude1, Azimuth,decimalSecondToAdd* SpeedMeterSecond)
X,Y,quotainutile = self.transform_wgs84_to_utm(CalculusDirect['lon2'],CalculusDirect['lat2'] )
Z = ele1 + decimalSecondToAdd*(ele2 - ele1)
txtGPSFile.write(str(Directory.split('/')[-1]) + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4]+'.png,' + ' ' + str(X) + ', ' + str(Y) + ', ' + str(Z) + '\n')
if RemainToUseMeter == meters:
decimalSecondToAddMore = meters / SpeedMeterSecond
RemainToUseMeter = RemainToUseMeter - meters
decimalSecondToAdd = decimalSecondToAdd + decimalSecondToAddMore
if os.name == 'nt':
os.popen(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str('"'+self.videoFile+'"') + ' -frames:v 1 ' +'"'+ Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png'+'"')
else:
os.system(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str(self.videoFile) + ' -frames:v 1 ' + Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png')
CalculusDirect = Geodesic.WGS84.Direct(latitude1, longitude1, Azimuth,decimalSecondToAdd* SpeedMeterSecond)
X,Y,quotainutile = self.transform_wgs84_to_utm(CalculusDirect['lon2'],CalculusDirect['lat2'] )
Z = ele1 + decimalSecondToAdd*(ele2 - ele1)
txtGPSFile.write(str(Directory.split('/')[-1]) + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4]+'.png,' + ' ' +str(X) + ', ' + str(Y) + ', ' + str(Z) + '\n')
RemainToUseMeterTotal = 0
elif RemainToUseMeter < meters:
RemainToUseMeterTotal = RemainToUseMeter
pass
else:
RemainToUseMeterTotal = meters - DistanceBetweenPoint
elif RemainToUseMeterTotal > 0:
if DistanceBetweenPoint >= (meters - RemainToUseMeterTotal) :
decimalSecondToAdd = (meters - RemainToUseMeterTotal) / DistanceBetweenPoint
RemainToUseMeter = DistanceBetweenPoint - (meters - RemainToUseMeterTotal)
if os.name == 'nt':
os.popen(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str('"'+self.videoFile+'"') + ' -frames:v 1 ' +'"'+ Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png'+'"')
else:
os.system(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str(self.videoFile) + ' -frames:v 1 ' + Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png')
CalculusDirect = Geodesic.WGS84.Direct(latitude1, longitude1, Azimuth,decimalSecondToAdd* SpeedMeterSecond)
X,Y,quotainutile = self.transform_wgs84_to_utm(CalculusDirect['lon2'],CalculusDirect['lat2'] )
Z = ele1 + decimalSecondToAdd*(ele2 - ele1)
txtGPSFile.write(str(Directory.split('/')[-1]) + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4]+'.png,' + ' ' + str(X) + ', ' + str(Y) + ', ' + str(Z) + '\n')
while RemainToUseMeter > meters:
decimalSecondToAddMore = meters / SpeedMeterSecond
RemainToUseMeter = RemainToUseMeter - meters
decimalSecondToAdd = decimalSecondToAdd + decimalSecondToAddMore
if os.name == 'nt':
os.popen(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str('"'+self.videoFile+'"') + ' -frames:v 1 ' +'"'+ Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png'+'"')
else:
os.system(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str(self.videoFile) + ' -frames:v 1 ' + Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png')
CalculusDirect = Geodesic.WGS84.Direct(latitude1, longitude1, Azimuth,decimalSecondToAdd* SpeedMeterSecond)
X,Y,quotainutile = self.transform_wgs84_to_utm(CalculusDirect['lon2'],CalculusDirect['lat2'] )
Z = ele1 + decimalSecondToAdd*(ele2 - ele1)
txtGPSFile.write(str(Directory.split('/')[-1]) + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4]+'.png,' + ' ' + str(X) + ', ' + str(Y) + ', ' + str(Z) + '\n')
if RemainToUseMeter == meters:
decimalSecondToAddMore = meters / SpeedMeterSecond
RemainToUseMeter = RemainToUseMeter - meters
decimalSecondToAdd = decimalSecondToAdd + decimalSecondToAddMore
if os.name == 'nt':
os.popen(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str('"'+self.videoFile+'"') + ' -frames:v 1 ' +'"'+ Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png'+'"')
else:
os.system(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str(self.videoFile) + ' -frames:v 1 ' + Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png')
CalculusDirect = Geodesic.WGS84.Direct(latitude1, longitude1, Azimuth,decimalSecondToAdd* SpeedMeterSecond)
X,Y,quotainutile = self.transform_wgs84_to_utm(CalculusDirect['lon2'],CalculusDirect['lat2'] )
Z = ele1 + decimalSecondToAdd*(ele2 - ele1)
txtGPSFile.write(str(Directory.split('/')[-1]) + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4]+'.png,' + ' ' + str(X) + ', ' + str(Y) + ', ' + str(Z) + '\n')
RemainToUseMeterTotal = 0
elif RemainToUseMeter < meters:
RemainToUseMeterTotal = RemainToUseMeter
else:
RemainToUseMeterTotal = (meters - DistanceBetweenPoint) + RemainToUseMeterTotal
txtGPSFile.close()
self.progressBar.hide()
def ExtractFromA(self):
if self.ExtractA == True:
self.Main.iface.mapCanvas().scene().removeItem(self.ExtractAVertex)
self.ExtractA = False
self.ExtractFromA = round((self.player.position()- self.StartMsecond )/1000)
canvas = self.Main.iface.mapCanvas()
crsSrc = QgsCoordinateReferenceSystem(4326) # .gpx is in WGS 84
crsDest = QgsProject.instance().crs()
xform = QgsCoordinateTransform(crsSrc, crsDest)
latitude,longitude = self.Polyline[self.ExtractFromA].y(), self.Polyline[self.ExtractFromA].x()
self.ExtractAVertex = QgsVertexMarker(canvas)
self.ExtractAVertex.setCenter(xform.transform(QgsPointXY(longitude, latitude)))
self.ExtractAVertex.setColor(QColor(0,255,0))
self.ExtractAVertex.setIconSize(10)
self.ExtractAVertex.setIconType(QgsVertexMarker.ICON_X)
self.ExtractAVertex.setPenWidth(10)
self.ExtractA = True
if self.ExtractB == True:
self.pushButtonCut_2.setEnabled(True)
else:
self.pushButtonCut_2.setEnabled(False)
def ExtractToB(self):
if self.ExtractB == True:
self.Main.iface.mapCanvas().scene().removeItem(self.ExtractBVertex)
self.ExtractB = False
self.ExtractToB = round((self.player.position()- self.StartMsecond )/1000)
if self.ExtractA == True:
if self.ExtractToB > self.ExtractFromA:
canvas = self.Main.iface.mapCanvas()
crsSrc = QgsCoordinateReferenceSystem(4326) # .gpx is in WGS 84
crsDest = QgsProject.instance().crs()
xform = QgsCoordinateTransform(crsSrc, crsDest)
latitude,longitude = self.Polyline[self.ExtractToB].y(), self.Polyline[self.ExtractToB].x()
self.ExtractBVertex = QgsVertexMarker(canvas)
self.ExtractBVertex.setCenter(xform.transform(QgsPointXY(longitude, latitude)))
self.ExtractBVertex.setColor(QColor(255,0,0))
self.ExtractBVertex.setIconSize(10)
self.ExtractBVertex.setIconType(QgsVertexMarker.ICON_X)
self.ExtractBVertex.setPenWidth(10)
self.ExtractB = True
self.pushButtonCut_2.setEnabled(True)
else:
self.pushButtonCut_2.setEnabled(False)
def CancelVertex(self):
if self.ExtractA == True:
self.Main.iface.mapCanvas().scene().removeItem(self.ExtractAVertex)
self.ExtractA = False
if self.ExtractB == True:
self.Main.iface.mapCanvas().scene().removeItem(self.ExtractBVertex)
self.ExtractB = False
self.pushButtonCut_2.setEnabled(False)
def ExtractToolbar(self):
if self.ExtractTool == 0:
self.dockWidget_4.show()
self.ExtractTool = 1
else:
self.dockWidget_4.hide()
self.ExtractTool = 0
def transform_wgs84_to_utm(self, lon, lat):
def get_utm_zone(longitude):
return (int(1+(longitude+180.0)/6.0))
def is_northern(latitude):
"""
Determines if given latitude is a northern for UTM
"""
if (latitude < 0.0):
return 0
else:
return 1
utm_coordinate_system = osr.SpatialReference()
utm_coordinate_system.SetWellKnownGeogCS("WGS84") # Set geographic coordinate system to handle lat/lon
utm_coordinate_system.SetUTM(get_utm_zone(lon), is_northern(lat))
wgs84_coordinate_system = utm_coordinate_system.CloneGeogCS() # Clone ONLY the geographic coordinate system
wgs84_to_utm_transform = osr.CoordinateTransformation(wgs84_coordinate_system, utm_coordinate_system) # (<from>, <to>)
return wgs84_to_utm_transform.TransformPoint(lon, lat, 0) # returns easting, northing, altitude
class VideoPlayer(QWidget):
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
btnSize = QSize(16, 16)
videoWidget = QVideoWidget()
openButton = QPushButton("Open Video")
openButton.setToolTip("Open Video File")
openButton.setStatusTip("Open Video File")
openButton.setFixedHeight(24)
openButton.setIconSize(btnSize)
openButton.setFont(QFont("Noto Sans", 8))
openButton.setIcon(
QIcon.fromTheme("document-open", QIcon("D:/_Qt/img/open.png")))
openButton.clicked.connect(self.abrir)
speedButton = QPushButton("speedVideo")
speedButton.setToolTip("Open Video File")
speedButton.setStatusTip("Open Video File")
speedButton.setFixedHeight(24)
speedButton.setIconSize(btnSize)
speedButton.setFont(QFont("Noto Sans", 8))
speedButton.setIcon(
QIcon.fromTheme("document-open", QIcon("D:/_Qt/img/open.png")))
speedButton.clicked.connect(self.speed)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setFixedHeight(24)
self.playButton.setIconSize(btnSize)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = slider.Slider(QtCore.Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.positionSlider.sliderPressed.connect(self.setPosition)
self.positionSlider.sliderReleased.connect(self.setPosition)
self.statusBar = QStatusBar()
self.statusBar.setFont(QFont("Noto Sans", 7))
self.statusBar.setFixedHeight(14)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addWidget(speedButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.statusBar)
self.setLayout(layout)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
self.statusBar.showMessage("Ready")
def abrir(self):
num = 0
cmd = "ffmpeg -y -i " + "PART/" + str(
num
) + ".mkv " + "-filter_complex \"[0:v]setpts=2.0*PTS[v];[0:a]atempo=0.5[a]\" -map \"[v]\" -map \"[a]\" " + str(
num) + ".mkv"
#cmd = "ffmpeg -y -i "+ "PART/" + str(num) + ".mkv" + " -filter:v \"setpts=2.0*PTS\" "+ str(num) + ".mkv"
os.system(cmd)
player.setWindowTitle("CLONES")
fileName = "/home/flo/tmp/Movie-SongMaker/0.mkv"
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
self.statusBar.showMessage(fileName)
self.play()
def speed(self):
num = 0
cmd = "ffmpeg -y -i " + "PART/" + str(
num
) + ".mkv " + "-filter_complex \"[0:v]setpts=1.0*PTS[v];[0:a]atempo=1.0[a]\" -map \"[v]\" -map \"[a]\" " + str(
num) + ".mkv"
#cmd = "ffmpeg -y -i "+ "PART/" + str(num) + ".mkv" + " -filter:v \"setpts=2.0*PTS\" "+ str(num) + ".mkv"
os.system(cmd)
player.setWindowTitle("CLONES")
fileName = "/home/flo/tmp/Movie-SongMaker/0.mkv"
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
self.statusBar.showMessage(fileName)
self.play()
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
self.statusBar.showMessage("Error: " + self.mediaPlayer.errorString())
class App(QMainWindow):
def __init__(self):
super().__init__()
self.player = QMediaPlayer()
self.playlist = QMediaPlaylist()
self.title = 'PyTunes'
self.left = 300
self.top = 300
self.width = 300
self.height = 150
self.color = 0 # 0- toggle to dark 1- toggle to light
self.userAction = -1 # 0- stopped, 1- playing 2-paused
self.initUI()
def initUI(self):
# Add file menu
menubar = self.menuBar()
filemenu = menubar.addMenu('File')
windowmenu = menubar.addMenu('Window')
fileAct = QAction('Open File', self)
folderAct = QAction('Open Folder', self)
themeAct = QAction('Toggle light/dark theme', self)
fileAct.setShortcut('Ctrl+O')
folderAct.setShortcut('Ctrl+D')
themeAct.setShortcut('Ctrl+T')
filemenu.addAction(fileAct)
filemenu.addAction(folderAct)
windowmenu.addAction(themeAct)
fileAct.triggered.connect(self.openFile)
folderAct.triggered.connect(self.addFiles)
themeAct.triggered.connect(self.toggleColors)
self.addControls()
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.toggleColors()
self.show()
def addControls(self):
wid = QWidget(self)
self.setCentralWidget(wid)
# Add song controls
volumeslider = QSlider(Qt.Horizontal, self)
volumeslider.setFocusPolicy(Qt.NoFocus)
volumeslider.valueChanged[int].connect(self.changeVolume)
volumeslider.setValue(100)
playBtn = QPushButton('Play') # play button
pauseBtn = QPushButton('Pause') # pause button
stopBtn = QPushButton('Stop') # stop button
# Add playlist controls
prevBtn = QPushButton('Prev')
shuffleBtn = QPushButton('Shuffle')
nextBtn = QPushButton('Next')
# Add button layouts
controlArea = QVBoxLayout() # centralWidget
controls = QHBoxLayout()
playlistCtrlLayout = QHBoxLayout()
# Add buttons to song controls layout
controls.addWidget(playBtn)
controls.addWidget(pauseBtn)
controls.addWidget(stopBtn)
# Add buttons to playlist controls layout
playlistCtrlLayout.addWidget(prevBtn)
playlistCtrlLayout.addWidget(shuffleBtn)
playlistCtrlLayout.addWidget(nextBtn)
# Add to vertical layout
controlArea.addWidget(volumeslider)
controlArea.addLayout(controls)
controlArea.addLayout(playlistCtrlLayout)
wid.setLayout(controlArea)
# Connect each signal to their appropriate function
playBtn.clicked.connect(self.playhandler)
pauseBtn.clicked.connect(self.pausehandler)
stopBtn.clicked.connect(self.stophandler)
prevBtn.clicked.connect(self.prevSong)
shuffleBtn.clicked.connect(self.shufflelist)
nextBtn.clicked.connect(self.nextSong)
self.statusBar()
self.playlist.currentMediaChanged.connect(self.songChanged)
def openFile(self):
song = QFileDialog.getOpenFileName(
self, "Open Song", "~", "Sound Files (*.mp3 *.ogg *.wav *.m4a)")
if song[0] != '':
url = QUrl.fromLocalFile(song[0])
if self.playlist.mediaCount() == 0:
self.playlist.addMedia(QMediaContent(url))
self.player.setPlaylist(self.playlist)
self.player.play()
self.userAction = 1
else:
self.playlist.addMedia(QMediaContent(url))
def addFiles(self):
if self.playlist.mediaCount() != 0:
self.folderIterator()
else:
self.folderIterator()
self.player.setPlaylist(self.playlist)
self.player.playlist().setCurrentIndex(0)
self.player.play()
self.userAction = 1
def folderIterator(self):
folderChosen = QFileDialog.getExistingDirectory(
self, 'Open Music Folder', '~')
if folderChosen != None:
it = QDirIterator(folderChosen)
it.next()
while it.hasNext():
if it.fileInfo().isDir() == False and it.filePath() != '.':
fInfo = it.fileInfo()
if fInfo.suffix() in ('mp3', 'ogg', 'wav', 'm4a'):
self.playlist.addMedia(
QMediaContent(QUrl.fromLocalFile(it.filePath())))
it.next()
if it.fileInfo().isDir() == False and it.filePath() != '.':
fInfo = it.fileInfo()
if fInfo.suffix() in ('mp3', 'ogg', 'wav', 'm4a'):
self.playlist.addMedia(
QMediaContent(QUrl.fromLocalFile(it.filePath())))
def playhandler(self):
if self.playlist.mediaCount() == 0:
self.openFile()
elif self.playlist.mediaCount() != 0:
self.player.play()
self.userAction = 1
def pausehandler(self):
self.userAction = 2
self.player.pause()
def stophandler(self):
self.userAction = 0
self.player.stop()
self.playlist.clear()
self.statusBar().showMessage("Stopped and cleared playlist")
def changeVolume(self, value):
self.player.setVolume(value)
def prevSong(self):
if self.playlist.mediaCount() == 0:
self.openFile()
elif self.playlist.mediaCount() != 0:
self.player.playlist().previous()
def shufflelist(self):
self.playlist.shuffle()
def nextSong(self):
if self.playlist.mediaCount() == 0:
self.openFile()
elif self.playlist.mediaCount() != 0:
self.player.playlist().next()
def songChanged(self, media):
if not media.isNull():
url = media.canonicalUrl()
self.statusBar().showMessage(url.fileName())
def toggleColors(self):
app.setStyle("Fusion")
palette = QPalette()
if self.color == 0:
palette.setColor(QPalette.Window, QColor(53, 53, 53))
palette.setColor(QPalette.WindowText, Qt.white)
palette.setColor(QPalette.Base, QColor(25, 25, 25))
palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
palette.setColor(QPalette.ToolTipBase, Qt.white)
palette.setColor(QPalette.ToolTipText, Qt.white)
palette.setColor(QPalette.Text, Qt.white)
palette.setColor(QPalette.Button, QColor(53, 53, 53))
palette.setColor(QPalette.ButtonText, Qt.white)
palette.setColor(QPalette.BrightText, Qt.red)
palette.setColor(QPalette.Link, QColor(235, 101, 54))
palette.setColor(QPalette.Highlight, QColor(235, 101, 54))
palette.setColor(QPalette.HighlightedText, Qt.black)
app.setPalette(palette)
self.color = 1
elif self.color == 1:
palette.setColor(QPalette.Window, Qt.white)
palette.setColor(QPalette.WindowText, Qt.black)
palette.setColor(QPalette.Base, QColor(240, 240, 240))
palette.setColor(QPalette.AlternateBase, Qt.white)
palette.setColor(QPalette.ToolTipBase, Qt.white)
palette.setColor(QPalette.ToolTipText, Qt.white)
palette.setColor(QPalette.Text, Qt.black)
palette.setColor(QPalette.Button, Qt.white)
palette.setColor(QPalette.ButtonText, Qt.black)
palette.setColor(QPalette.BrightText, Qt.red)
palette.setColor(QPalette.Link, QColor(66, 155, 248))
palette.setColor(QPalette.Highlight, QColor(66, 155, 248))
palette.setColor(QPalette.HighlightedText, Qt.black)
app.setPalette(palette)
self.color = 0
class MusicPlayer(QMainWindow):
"""MusicPlayer houses all of elements that directly interact with the main window."""
def __init__(self, parent=None):
"""Initialize the QMainWindow widget.
The window title, window icon, and window size are initialized here as well
as the following widgets: QMediaPlayer, QMediaPlaylist, QMediaContent, QMenuBar,
QToolBar, QLabel, QPixmap, QSlider, QDockWidget, QListWidget, QWidget, and
QVBoxLayout. The connect signals for relavant widgets are also initialized.
"""
super(MusicPlayer, self).__init__(parent)
self.setWindowTitle('Mosaic')
window_icon = utilities.resource_filename('mosaic.images', 'icon.png')
self.setWindowIcon(QIcon(window_icon))
self.resize(defaults.Settings().window_size, defaults.Settings().window_size + 63)
# Initiates Qt objects to be used by MusicPlayer
self.player = QMediaPlayer()
self.playlist = QMediaPlaylist()
self.playlist_location = defaults.Settings().playlist_path
self.content = QMediaContent()
self.menu = self.menuBar()
self.toolbar = QToolBar()
self.art = QLabel()
self.pixmap = QPixmap()
self.slider = QSlider(Qt.Horizontal)
self.duration_label = QLabel()
self.playlist_dock = QDockWidget('Playlist', self)
self.library_dock = QDockWidget('Media Library', self)
self.playlist_view = QListWidget()
self.library_view = library.MediaLibraryView()
self.library_model = library.MediaLibraryModel()
self.preferences = configuration.PreferencesDialog()
self.widget = QWidget()
self.layout = QVBoxLayout(self.widget)
self.duration = 0
self.playlist_dock_state = None
self.library_dock_state = None
# Sets QWidget() as the central widget of the main window
self.setCentralWidget(self.widget)
self.layout.setContentsMargins(0, 0, 0, 0)
self.art.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
# Initiates the playlist dock widget and the library dock widget
self.addDockWidget(defaults.Settings().dock_position, self.playlist_dock)
self.playlist_dock.setWidget(self.playlist_view)
self.playlist_dock.setVisible(defaults.Settings().playlist_on_start)
self.playlist_dock.setFeatures(QDockWidget.DockWidgetClosable)
self.addDockWidget(defaults.Settings().dock_position, self.library_dock)
self.library_dock.setWidget(self.library_view)
self.library_dock.setVisible(defaults.Settings().media_library_on_start)
self.library_dock.setFeatures(QDockWidget.DockWidgetClosable)
self.tabifyDockWidget(self.playlist_dock, self.library_dock)
# Sets the range of the playback slider and sets the playback mode as looping
self.slider.setRange(0, self.player.duration() / 1000)
self.playlist.setPlaybackMode(QMediaPlaylist.Sequential)
# OSX system menu bar causes conflicts with PyQt5 menu bar
if sys.platform == 'darwin':
self.menu.setNativeMenuBar(False)
# Initiates Settings in the defaults module to give access to settings.toml
defaults.Settings()
# Signals that connect to other methods when they're called
self.player.metaDataChanged.connect(self.display_meta_data)
self.slider.sliderMoved.connect(self.seek)
self.player.durationChanged.connect(self.song_duration)
self.player.positionChanged.connect(self.song_position)
self.player.stateChanged.connect(self.set_state)
self.playlist_view.itemActivated.connect(self.activate_playlist_item)
self.library_view.activated.connect(self.open_media_library)
self.playlist.currentIndexChanged.connect(self.change_index)
self.playlist.mediaInserted.connect(self.initialize_playlist)
self.playlist_dock.visibilityChanged.connect(self.dock_visiblity_change)
self.library_dock.visibilityChanged.connect(self.dock_visiblity_change)
self.preferences.dialog_media_library.media_library_line.textChanged.connect(self.change_media_library_path)
self.preferences.dialog_view_options.dropdown_box.currentIndexChanged.connect(self.change_window_size)
self.art.mousePressEvent = self.press_playback
# Creating the menu controls, media controls, and window size of the music player
self.menu_controls()
self.media_controls()
self.load_saved_playlist()
def menu_controls(self):
"""Initiate the menu bar and add it to the QMainWindow widget."""
self.file = self.menu.addMenu('File')
self.edit = self.menu.addMenu('Edit')
self.playback = self.menu.addMenu('Playback')
self.view = self.menu.addMenu('View')
self.help_ = self.menu.addMenu('Help')
self.file_menu()
self.edit_menu()
self.playback_menu()
self.view_menu()
self.help_menu()
def media_controls(self):
"""Create the bottom toolbar and controls used for media playback."""
self.addToolBar(Qt.BottomToolBarArea, self.toolbar)
self.toolbar.setMovable(False)
play_icon = utilities.resource_filename('mosaic.images', 'md_play.png')
self.play_action = QAction(QIcon(play_icon), 'Play', self)
self.play_action.triggered.connect(self.player.play)
stop_icon = utilities.resource_filename('mosaic.images', 'md_stop.png')
self.stop_action = QAction(QIcon(stop_icon), 'Stop', self)
self.stop_action.triggered.connect(self.player.stop)
previous_icon = utilities.resource_filename('mosaic.images', 'md_previous.png')
self.previous_action = QAction(QIcon(previous_icon), 'Previous', self)
self.previous_action.triggered.connect(self.previous)
next_icon = utilities.resource_filename('mosaic.images', 'md_next.png')
self.next_action = QAction(QIcon(next_icon), 'Next', self)
self.next_action.triggered.connect(self.playlist.next)
repeat_icon = utilities.resource_filename('mosaic.images', 'md_repeat_none.png')
self.repeat_action = QAction(QIcon(repeat_icon), 'Repeat', self)
self.repeat_action.setShortcut('R')
self.repeat_action.triggered.connect(self.repeat_song)
self.toolbar.addAction(self.play_action)
self.toolbar.addAction(self.stop_action)
self.toolbar.addAction(self.previous_action)
self.toolbar.addAction(self.next_action)
self.toolbar.addAction(self.repeat_action)
self.toolbar.addWidget(self.slider)
self.toolbar.addWidget(self.duration_label)
def file_menu(self):
"""Add a file menu to the menu bar.
The file menu houses the Open File, Open Multiple Files, Open Playlist,
Open Directory, and Exit Application menu items.
"""
self.open_action = QAction('Open File', self)
self.open_action.setShortcut('O')
self.open_action.triggered.connect(self.open_file)
self.open_multiple_files_action = QAction('Open Multiple Files', self)
self.open_multiple_files_action.setShortcut('M')
self.open_multiple_files_action.triggered.connect(self.open_multiple_files)
self.open_playlist_action = QAction('Open Playlist', self)
self.open_playlist_action.setShortcut('CTRL+P')
self.open_playlist_action.triggered.connect(self.open_playlist)
self.open_directory_action = QAction('Open Directory', self)
self.open_directory_action.setShortcut('D')
self.open_directory_action.triggered.connect(self.open_directory)
self.save_playlist_action = QAction('Save Playlist', self)
self.save_playlist_action.setShortcut('CTRL+S')
self.save_playlist_action.triggered.connect(self.save_playlist)
self.exit_action = QAction('Quit', self)
self.exit_action.setShortcut('CTRL+Q')
self.exit_action.triggered.connect(self.closeEvent)
self.file.addAction(self.open_action)
self.file.addAction(self.open_multiple_files_action)
self.file.addAction(self.open_playlist_action)
self.file.addAction(self.open_directory_action)
self.file.addSeparator()
self.file.addAction(self.save_playlist_action)
self.file.addSeparator()
self.file.addAction(self.exit_action)
def edit_menu(self):
"""Add an edit menu to the menu bar.
The edit menu houses the preferences item that opens a preferences dialog
that allows the user to customize features of the music player.
"""
self.preferences_action = QAction('Preferences', self)
self.preferences_action.setShortcut('CTRL+SHIFT+P')
self.preferences_action.triggered.connect(lambda: self.preferences.exec_())
self.edit.addAction(self.preferences_action)
def playback_menu(self):
"""Add a playback menu to the menu bar.
The playback menu houses
"""
self.play_playback_action = QAction('Play', self)
self.play_playback_action.setShortcut('P')
self.play_playback_action.triggered.connect(self.player.play)
self.stop_playback_action = QAction('Stop', self)
self.stop_playback_action.setShortcut('S')
self.stop_playback_action.triggered.connect(self.player.stop)
self.previous_playback_action = QAction('Previous', self)
self.previous_playback_action.setShortcut('B')
self.previous_playback_action.triggered.connect(self.previous)
self.next_playback_action = QAction('Next', self)
self.next_playback_action.setShortcut('N')
self.next_playback_action.triggered.connect(self.playlist.next)
self.playback.addAction(self.play_playback_action)
self.playback.addAction(self.stop_playback_action)
self.playback.addAction(self.previous_playback_action)
self.playback.addAction(self.next_playback_action)
def view_menu(self):
"""Add a view menu to the menu bar.
The view menu houses the Playlist, Media Library, Minimalist View, and Media
Information menu items. The Playlist item toggles the playlist dock into and
out of view. The Media Library items toggles the media library dock into and
out of view. The Minimalist View item resizes the window and shows only the
menu bar and player controls. The Media Information item opens a dialog that
shows information relevant to the currently playing song.
"""
self.dock_action = self.playlist_dock.toggleViewAction()
self.dock_action.setShortcut('CTRL+ALT+P')
self.library_dock_action = self.library_dock.toggleViewAction()
self.library_dock_action.setShortcut('CTRL+ALT+L')
self.minimalist_view_action = QAction('Minimalist View', self)
self.minimalist_view_action.setShortcut('CTRL+ALT+M')
self.minimalist_view_action.setCheckable(True)
self.minimalist_view_action.triggered.connect(self.minimalist_view)
self.view_media_info_action = QAction('Media Information', self)
self.view_media_info_action.setShortcut('CTRL+SHIFT+M')
self.view_media_info_action.triggered.connect(self.media_information_dialog)
self.view.addAction(self.dock_action)
self.view.addAction(self.library_dock_action)
self.view.addSeparator()
self.view.addAction(self.minimalist_view_action)
self.view.addSeparator()
self.view.addAction(self.view_media_info_action)
def help_menu(self):
"""Add a help menu to the menu bar.
The help menu houses the about dialog that shows the user information
related to the application.
"""
self.about_action = QAction('About', self)
self.about_action.setShortcut('H')
self.about_action.triggered.connect(lambda: about.AboutDialog().exec_())
self.help_.addAction(self.about_action)
def open_file(self):
"""Open the selected file and add it to a new playlist."""
filename, success = QFileDialog.getOpenFileName(self, 'Open File', '', 'Audio (*.mp3 *.flac)', '', QFileDialog.ReadOnly)
if success:
file_info = QFileInfo(filename).fileName()
playlist_item = QListWidgetItem(file_info)
self.playlist.clear()
self.playlist_view.clear()
self.playlist.addMedia(QMediaContent(QUrl().fromLocalFile(filename)))
self.player.setPlaylist(self.playlist)
playlist_item.setToolTip(file_info)
self.playlist_view.addItem(playlist_item)
self.playlist_view.setCurrentRow(0)
self.player.play()
def open_multiple_files(self):
"""Open the selected files and add them to a new playlist."""
filenames, success = QFileDialog.getOpenFileNames(self, 'Open Multiple Files', '', 'Audio (*.mp3 *.flac)', '', QFileDialog.ReadOnly)
if success:
self.playlist.clear()
self.playlist_view.clear()
for file in natsort.natsorted(filenames, alg=natsort.ns.PATH):
file_info = QFileInfo(file).fileName()
playlist_item = QListWidgetItem(file_info)
self.playlist.addMedia(QMediaContent(QUrl().fromLocalFile(file)))
self.player.setPlaylist(self.playlist)
playlist_item.setToolTip(file_info)
self.playlist_view.addItem(playlist_item)
self.playlist_view.setCurrentRow(0)
self.player.play()
def open_playlist(self):
"""Load an M3U or PLS file into a new playlist."""
playlist, success = QFileDialog.getOpenFileName(self, 'Open Playlist', '', 'Playlist (*.m3u *.pls)', '', QFileDialog.ReadOnly)
if success:
playlist = QUrl.fromLocalFile(playlist)
self.playlist.clear()
self.playlist_view.clear()
self.playlist.load(playlist)
self.player.setPlaylist(self.playlist)
for song_index in range(self.playlist.mediaCount()):
file_info = self.playlist.media(song_index).canonicalUrl().fileName()
playlist_item = QListWidgetItem(file_info)
playlist_item.setToolTip(file_info)
self.playlist_view.addItem(playlist_item)
self.playlist_view.setCurrentRow(0)
self.player.play()
def save_playlist(self):
"""Save the media in the playlist dock as a new M3U playlist."""
playlist, success = QFileDialog.getSaveFileName(self, 'Save Playlist', '', 'Playlist (*.m3u)', '')
if success:
saved_playlist = "{}.m3u" .format(playlist)
self.playlist.save(QUrl().fromLocalFile(saved_playlist), "m3u")
def load_saved_playlist(self):
"""Load the saved playlist if user setting permits."""
saved_playlist = "{}/.m3u" .format(self.playlist_location)
if os.path.exists(saved_playlist):
playlist = QUrl().fromLocalFile(saved_playlist)
self.playlist.load(playlist)
self.player.setPlaylist(self.playlist)
for song_index in range(self.playlist.mediaCount()):
file_info = self.playlist.media(song_index).canonicalUrl().fileName()
playlist_item = QListWidgetItem(file_info)
playlist_item.setToolTip(file_info)
self.playlist_view.addItem(playlist_item)
self.playlist_view.setCurrentRow(0)
def open_directory(self):
"""Open the selected directory and add the files within to an empty playlist."""
directory = QFileDialog.getExistingDirectory(self, 'Open Directory', '', QFileDialog.ReadOnly)
if directory:
self.playlist.clear()
self.playlist_view.clear()
for dirpath, __, files in os.walk(directory):
for filename in natsort.natsorted(files, alg=natsort.ns.PATH):
file = os.path.join(dirpath, filename)
if filename.endswith(('mp3', 'flac')):
self.playlist.addMedia(QMediaContent(QUrl().fromLocalFile(file)))
playlist_item = QListWidgetItem(filename)
playlist_item.setToolTip(filename)
self.playlist_view.addItem(playlist_item)
self.player.setPlaylist(self.playlist)
self.playlist_view.setCurrentRow(0)
self.player.play()
def open_media_library(self, index):
"""Open a directory or file from the media library into an empty playlist."""
self.playlist.clear()
self.playlist_view.clear()
if self.library_model.fileName(index).endswith(('mp3', 'flac')):
self.playlist.addMedia(QMediaContent(QUrl().fromLocalFile(self.library_model.filePath(index))))
self.playlist_view.addItem(self.library_model.fileName(index))
elif self.library_model.isDir(index):
directory = self.library_model.filePath(index)
for dirpath, __, files in os.walk(directory):
for filename in natsort.natsorted(files, alg=natsort.ns.PATH):
file = os.path.join(dirpath, filename)
if filename.endswith(('mp3', 'flac')):
self.playlist.addMedia(QMediaContent(QUrl().fromLocalFile(file)))
playlist_item = QListWidgetItem(filename)
playlist_item.setToolTip(filename)
self.playlist_view.addItem(playlist_item)
self.player.setPlaylist(self.playlist)
self.player.play()
def display_meta_data(self):
"""Display the current song's metadata in the main window.
If the current song contains metadata, its cover art is extracted and shown in
the main window while the track number, artist, album, and track title are shown
in the window title.
"""
if self.player.isMetaDataAvailable():
file_path = self.player.currentMedia().canonicalUrl().toLocalFile()
(album, artist, title, track_number, *__, artwork) = metadata.metadata(file_path)
try:
self.pixmap.loadFromData(artwork)
except TypeError:
self.pixmap = QPixmap(artwork)
meta_data = '{} - {} - {} - {}' .format(track_number, artist, album, title)
self.setWindowTitle(meta_data)
self.art.setScaledContents(True)
self.art.setPixmap(self.pixmap)
self.layout.addWidget(self.art)
def initialize_playlist(self, start):
"""Display playlist and reset playback mode when media inserted into playlist."""
if start == 0:
if self.library_dock.isVisible():
self.playlist_dock.setVisible(True)
self.playlist_dock.show()
self.playlist_dock.raise_()
if self.playlist.playbackMode() != QMediaPlaylist.Sequential:
self.playlist.setPlaybackMode(QMediaPlaylist.Sequential)
repeat_icon = utilities.resource_filename('mosaic.images', 'md_repeat_none.png')
self.repeat_action.setIcon(QIcon(repeat_icon))
def press_playback(self, event):
"""Change the playback of the player on cover art mouse event.
When the cover art is clicked, the player will play the media if the player is
either paused or stopped. If the media is playing, the media is set
to pause.
"""
if event.button() == 1 and configuration.Playback().cover_art_playback.isChecked():
if (self.player.state() == QMediaPlayer.StoppedState or
self.player.state() == QMediaPlayer.PausedState):
self.player.play()
elif self.player.state() == QMediaPlayer.PlayingState:
self.player.pause()
def seek(self, seconds):
"""Set the position of the song to the position dragged to by the user."""
self.player.setPosition(seconds * 1000)
def song_duration(self, duration):
"""Set the slider to the duration of the currently played media."""
duration /= 1000
self.duration = duration
self.slider.setMaximum(duration)
def song_position(self, progress):
"""Move the horizontal slider in sync with the duration of the song.
The progress is relayed to update_duration() in order
to display the time label next to the slider.
"""
progress /= 1000
if not self.slider.isSliderDown():
self.slider.setValue(progress)
self.update_duration(progress)
def update_duration(self, current_duration):
"""Calculate the time played and the length of the song.
Both of these times are sent to duration_label() in order to display the
times on the toolbar.
"""
duration = self.duration
if current_duration or duration:
time_played = QTime((current_duration / 3600) % 60, (current_duration / 60) % 60,
(current_duration % 60), (current_duration * 1000) % 1000)
song_length = QTime((duration / 3600) % 60, (duration / 60) % 60, (duration % 60),
(duration * 1000) % 1000)
if duration > 3600:
time_format = "hh:mm:ss"
else:
time_format = "mm:ss"
time_display = "{} / {}" .format(time_played.toString(time_format), song_length.toString(time_format))
else:
time_display = ""
self.duration_label.setText(time_display)
def set_state(self, state):
"""Change the icon in the toolbar in relation to the state of the player.
The play icon changes to the pause icon when a song is playing and
the pause icon changes back to the play icon when either paused or
stopped.
"""
if self.player.state() == QMediaPlayer.PlayingState:
pause_icon = utilities.resource_filename('mosaic.images', 'md_pause.png')
self.play_action.setIcon(QIcon(pause_icon))
self.play_action.triggered.connect(self.player.pause)
elif (self.player.state() == QMediaPlayer.PausedState or self.player.state() == QMediaPlayer.StoppedState):
self.play_action.triggered.connect(self.player.play)
play_icon = utilities.resource_filename('mosaic.images', 'md_play.png')
self.play_action.setIcon(QIcon(play_icon))
def previous(self):
"""Move to the previous song in the playlist.
Moves to the previous song in the playlist if the current song is less
than five seconds in. Otherwise, restarts the current song.
"""
if self.player.position() <= 5000:
self.playlist.previous()
else:
self.player.setPosition(0)
def repeat_song(self):
"""Set the current media to repeat and change the repeat icon accordingly.
There are four playback modes: repeat none, repeat all, repeat once, and shuffle.
Clicking the repeat button cycles through each playback mode.
"""
if self.playlist.playbackMode() == QMediaPlaylist.Sequential:
self.playlist.setPlaybackMode(QMediaPlaylist.Loop)
repeat_on_icon = utilities.resource_filename('mosaic.images', 'md_repeat_all.png')
self.repeat_action.setIcon(QIcon(repeat_on_icon))
elif self.playlist.playbackMode() == QMediaPlaylist.Loop:
self.playlist.setPlaybackMode(QMediaPlaylist.CurrentItemInLoop)
repeat_on_icon = utilities.resource_filename('mosaic.images', 'md_repeat_once.png')
self.repeat_action.setIcon(QIcon(repeat_on_icon))
elif self.playlist.playbackMode() == QMediaPlaylist.CurrentItemInLoop:
self.playlist.setPlaybackMode(QMediaPlaylist.Random)
repeat_icon = utilities.resource_filename('mosaic.images', 'md_shuffle.png')
self.repeat_action.setIcon(QIcon(repeat_icon))
elif self.playlist.playbackMode() == QMediaPlaylist.Random:
self.playlist.setPlaybackMode(QMediaPlaylist.Sequential)
repeat_icon = utilities.resource_filename('mosaic.images', 'md_repeat_none.png')
self.repeat_action.setIcon(QIcon(repeat_icon))
def activate_playlist_item(self, item):
"""Set the active media to the playlist item dobule-clicked on by the user."""
current_index = self.playlist_view.row(item)
if self.playlist.currentIndex() != current_index:
self.playlist.setCurrentIndex(current_index)
if self.player.state() != QMediaPlayer.PlayingState:
self.player.play()
def change_index(self, row):
"""Highlight the row in the playlist of the active media."""
self.playlist_view.setCurrentRow(row)
def minimalist_view(self):
"""Resize the window to only show the menu bar and audio controls."""
if self.minimalist_view_action.isChecked():
if self.playlist_dock.isVisible():
self.playlist_dock_state = True
if self.library_dock.isVisible():
self.library_dock_state = True
self.library_dock.close()
self.playlist_dock.close()
QTimer.singleShot(10, lambda: self.resize(500, 0))
else:
self.resize(defaults.Settings().window_size, defaults.Settings().window_size + 63)
if self.library_dock_state:
self.library_dock.setVisible(True)
if self.playlist_dock_state:
self.playlist_dock.setVisible(True)
def dock_visiblity_change(self, visible):
"""Change the size of the main window when the docks are toggled."""
if visible and self.playlist_dock.isVisible() and not self.library_dock.isVisible():
self.resize(defaults.Settings().window_size + self.playlist_dock.width() + 6,
self.height())
elif visible and not self.playlist_dock.isVisible() and self.library_dock.isVisible():
self.resize(defaults.Settings().window_size + self.library_dock.width() + 6,
self.height())
elif visible and self.playlist_dock.isVisible() and self.library_dock.isVisible():
self.resize(defaults.Settings().window_size + self.library_dock.width() + 6,
self.height())
elif (not visible and not self.playlist_dock.isVisible() and not
self.library_dock.isVisible()):
self.resize(defaults.Settings().window_size, defaults.Settings().window_size + 63)
def media_information_dialog(self):
"""Show a dialog of the current song's metadata."""
if self.player.isMetaDataAvailable():
file_path = self.player.currentMedia().canonicalUrl().toLocalFile()
else:
file_path = None
dialog = information.InformationDialog(file_path)
dialog.exec_()
def change_window_size(self):
"""Change the window size of the music player."""
self.playlist_dock.close()
self.library_dock.close()
self.resize(defaults.Settings().window_size, defaults.Settings().window_size + 63)
def change_media_library_path(self, path):
"""Change the media library path to the new path selected in the preferences dialog."""
self.library_model.setRootPath(path)
self.library_view.setModel(self.library_model)
self.library_view.setRootIndex(self.library_model.index(path))
def closeEvent(self, event):
"""Override the PyQt close event in order to handle save playlist on close."""
playlist = "{}/.m3u" .format(self.playlist_location)
if defaults.Settings().save_playlist_on_close:
self.playlist.save(QUrl().fromLocalFile(playlist), "m3u")
else:
if os.path.exists(playlist):
os.remove(playlist)
QApplication.quit()
class VideoWindow(QMainWindow):
def __init__(self):
super().__init__()
self.title = "video player"
self.left = 500
self.top = 300
self.width = 800
self.height = 600
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoWidget = QVideoWidget()
self.playButton = QPushButton()
self.grabPictureButton = QPushButton("Grab")
self.positionSlider = QSlider(Qt.Horizontal)
self.errorLabel = QLabel()
self.frameCounter = 0
#list và table, có 2 loại dùng cái nào tuỳ em
self.listWidget = QListWidget()
self.tableWidget = QTableWidget(0, 3) #0 là số hàng 3 là số cột
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
#menu
menuBar = self.menuBar()
fileMenu = menuBar.addMenu('&File')
openAction = QAction(QIcon('open.png'), '&Open', self)
openAction.triggered.connect(self.openFile)
exitAction = QAction(QIcon('exit.png'), '&Exit', self)
exitAction.triggered.connect(self.exitCall)
screenshotAction = QAction(QIcon('screenshot.png'), '&Screenshot',
self)
screenshotAction.setShortcut('Ctrl+S')
screenshotAction.setStatusTip('Screenshot scenes')
screenshotAction.triggered.connect(self.grab)
fileMenu.addAction(openAction)
fileMenu.addAction(screenshotAction)
fileMenu.addAction(exitAction)
# nút play, nút chụp và thanh kéo
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.grabPictureButton.setEnabled(False)
self.grabPictureButton.setIcon(QIcon('grabpick.png'))
self.grabPictureButton.setToolTip('click to grab current frame')
self.grabPictureButton.clicked.connect(self.grab)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
# Hộp điều khiển chứa nút play và slider
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.grabPictureButton)
controlLayout.addWidget(self.positionSlider)
# Hộp chứa video và hộp điều khiển
vboxlayout = QVBoxLayout()
vboxlayout.addWidget(self.videoWidget)
vboxlayout.addLayout(controlLayout)
vboxlayout.addWidget(self.errorLabel)
#add vào table với list như này nhé
x = 1
y = 2
t = 45
self.listWidget.addItem('X Y T ')
self.listWidget.addItem(str(x) + ' ' + str(y) + ' ' + str(t))
self.tableWidget.insertRow(0)
self.tableWidget.insertRow(1)
self.tableWidget.setItem(0, 0, QTableWidgetItem("X"))
self.tableWidget.setItem(0, 1, QTableWidgetItem("Y"))
self.tableWidget.setItem(0, 2, QTableWidgetItem("T"))
self.tableWidget.setItem(1, 0, QTableWidgetItem(str(x)))
self.tableWidget.setItem(1, 1, QTableWidgetItem(str(y)))
self.tableWidget.setItem(1, 2, QTableWidgetItem(str(t)))
layout = QGridLayout(self)
layout.addLayout(vboxlayout, 0, 0)
layout.addWidget(self.listWidget, 0, 1)
layout.addWidget(self.tableWidget, 0, 2)
wid = QWidget(self)
self.setCentralWidget(wid)
wid.setLayout(layout)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
self.show()
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
QDir.homePath())
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
self.grabPictureButton.setEnabled(True)
def exitCall(self):
sys.exit(app.exec_())
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
self.mediaPlayer.setVideoOutput(self.videoWidget)
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def grab(self):
self.grabber = VideoFrameGrabber(self.videoWidget, self)
self.mediaPlayer.setVideoOutput(self.grabber)
self.grabber.frameAvailable.connect(self.process_frame)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.play()
def process_frame(self, image):
filename = "screenshot" + str(self.frameCounter).zfill(6)
self.path = 'C:/Users/donam/OneDrive/Desktop/temp'
image.save(self.path + '/{}.png'.format(str(filename)))
self.frameCounter += 1
def handleError(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
class QDeckDirtyDozenWidget(QWidget):
deckpath = None
grid = None
selectDeck = pyqtSignal()
dataset = None
#audio_data = None
audioPlayer = None
curent_audio_deck_id = None
last_random_audio = None
""" holds one of DISPLAY_COMBO_ITEMS: """
test_mode = 'image'
def __init__(self):
super().__init__()
def initialize(self, deckpath):
self.deckpath = deckpath
self.clear()
self.audioPlayer = QMediaPlayer()
db_path = path.join(deckpath, "database.sqlite")
self.dbAdapter = DeckDbAdapter()
self.dbAdapter.initialize(db_path)
self.dataset = self.dbAdapter.selectDeckDirtyDozenItems()
deck_select_button = QPushButton("<<<")
deck_select_button.clicked.connect(self.selectDeckButtonClicked)
replay_audio_button = QPushButton("replay audio")
replay_audio_button.setIcon(QIcon.fromTheme('media-playback-start'))
replay_audio_button.clicked.connect(self.replayAudioClicked)
select_display_combo_label = QLabel('select display:')
select_display_combo_label.setAlignment(QtCore.Qt.AlignRight)
select_display_combo = QComboBox()
select_display_combo.addItems(DISPLAY_COMBO_ITEMS)
select_display_combo.setCurrentIndex(
DISPLAY_COMBO_ITEMS.index(self.test_mode))
select_display_combo.currentIndexChanged.connect(
self.selectDisplayCurrentIndexChanged)
if not self.layout():
self.grid = QGridLayout()
self.grid.setContentsMargins(0, 0, 0, 0)
self.grid.addWidget(deck_select_button, 0, 0)
self.grid.addWidget(select_display_combo_label, 0, 1)
self.grid.addWidget(select_display_combo, 0, 2)
self.grid.addWidget(replay_audio_button, 0, 3)
for i, value in enumerate(self.dataset, COLUMNS):
label = QClickLabel()
if self.test_mode == 'image':
preview_pixmap = QPixmap()
try:
preview_pixmap.load(path.join(deckpath, value["image"]))
except (KeyError, TypeError):
try:
preview_pixmap.load(
path.join(deckpath, value["svg_filename"]))
except (KeyError, TypeError):
pass
scaled_pixmap = preview_pixmap.scaled(
QtCore.QSize(200, 200), QtCore.Qt.KeepAspectRatio)
label.setGeometry(scaled_pixmap.rect())
label.setPixmap(scaled_pixmap)
elif self.test_mode == 'name':
label.setText(value['name'])
elif self.test_mode == 'word':
label.setText(value['word'])
elif self.test_mode == 'translation':
label.setText(value['translation'])
label.setAlignment(QtCore.Qt.AlignCenter)
label.clicked.connect(
functools.partial(self.labelClicked, value["rowid"]))
self.grid.addWidget(label, int(i / COLUMNS), i % COLUMNS)
self.setLayout(self.grid)
self.playRandomAudio()
def clear(self):
if self.grid:
for i in range(0, self.layout().count()):
widget = self.layout().itemAt(i).widget()
widget.setVisible(False)
#for widget in self.findChildren:
#print(widget)
#if self.grid:
## just reparent the layout to a temporary one for delete it
#QWidget().setLayout(self.grid)
def selectDeckButtonClicked(self):
self.selectDeck.emit()
def labelClicked(self, row_id):
try:
if row_id == self.current_audio_deck_id:
self.playRandomAudio()
except AttributeError:
""" we probably have no audio file in this module """
pass
def playRandomAudio(self):
try:
selector = randint(0, len(self.dataset) - 1)
""" we do not want the same audio played multiple times on a row """
depth = 0
while selector == self.last_random_audio:
selector = randint(0, len(self.dataset) - 1)
""" to avoid infinite loops with just one element """
depth += 1
if depth > 20:
break
self.last_random_audio = selector
filename = self.dataset[selector]["filename"]
self.current_audio_deck_id = self.dataset[selector]["rowid"]
filepath = path.join(self.deckpath, filename)
url = QtCore.QUrl.fromLocalFile(
QtCore.QFileInfo(filepath).absoluteFilePath())
content = QMediaContent(url)
self.audioPlayer.setMedia(content)
self.audioPlayer.play()
except ValueError:
""" probably an empty deck. just do nothing"""
pass
def replayAudioClicked(self):
self.audioPlayer.play()
def selectDisplayCurrentIndexChanged(self, test):
selected_label = DISPLAY_COMBO_ITEMS[test]
self.clear()
self.test_mode = selected_label
self.initialize(self.deckpath)
class VideoWindow(QMainWindow):
def __init__(self, parent=None):
super(VideoWindow, self).__init__(parent)
self.setWindowTitle(
"PyQt Video Player Widget Example - pythonprogramminglanguage.com")
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
videoWidget = QVideoWidget()
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile("resources/movie/movie1.wmv")))
self.playButton = QPushButton()
self.playButton.setEnabled(True)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
# Create a widget for window contents
wid = QWidget(self)
self.setCentralWidget(wid)
# Create layouts to place inside widget
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.errorLabel)
# Set widget to contain window contents
wid.setLayout(layout)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
class Player(QWidget):
def __init__(self, playlist, playlist_copy, parent=None):
super().__init__(parent)
uic.loadUi('player.ui', self)
# Устанавливаем начальное значение громкости музыки
self.volume = 50
# Создаем объект список для плейлиста, это нужно для перемешки треков в функции mix.
# Является копией оригинального плейлиста
self.playlist_list = playlist_copy
# Создаем плейлист и плеер
self.playlist = playlist
self.playlist.setPlaybackMode(QMediaPlaylist.Loop)
self.player = QMediaPlayer()
# Задаем начальную громкость плееру
self.player.setVolume(self.volume)
self.player.setPlaylist(self.playlist)
# self.slider.setFocusPolicy(Qt.NoFocus)
self.slider.valueChanged[int].connect(self.changeValue)
self.pushButton.clicked.connect(self.play_music)
self.pushButton_2.clicked.connect(self.next)
self.pushButton_3.clicked.connect(self.prev)
self.pushButton_4.clicked.connect(self.mix)
self.pushButton_5.clicked.connect(self.pause)
def mix(self):
# Останавливаем плеер и очищаем плейлист
self.player.stop()
self.playlist.clear()
# С помощью копии перемешиваем треки в сам плейлист
playlist_copy = self.playlist_list
for i in range(len(self.playlist_list)):
track = random.choice(playlist_copy)
del playlist_copy[playlist_copy.index(track)]
self.playlist.addMedia(track)
# Добавляем плейлист в плеер и запускаем плеер
self.player.setPlaylist(self.playlist)
self.player.play()
def next(self):
self.playlist.next()
print(self.playlist.currentMedia().canonicalUrl())
def prev(self):
self.playlist.previous()
print(self.playlist.currentMedia().canonicalUrl())
def play_music(self):
self.player.play()
def changeValue(self, value):
self.volume = value
self.player.setVolume(self.volume)
def closeEvent(self, event):
self.playlist.clear()
self.player.stop()
def pause(self):
self.player.pause()
class VideoWindow(QMainWindow):
def __init__(self, parent=None):
super(VideoWindow, self).__init__(parent)
self.setWindowTitle(
"PyQt Video Player Widget Example - pythonprogramminglanguage.com")
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.camera = QCamera(0)
self.cameraviewfinder = QCameraViewfinder()
self.cameramode = self.camera.CaptureMode(2)
self.cameraimgcap = QCameraImageCapture(self.camera)
videoWidget = QVideoWidget()
self.imageView = QLabel("add a image file")
self.imageView.setAlignment(Qt.AlignCenter)
self.playButton = QPushButton()
self.playButton.setEnabled(True)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.scene1 = QGraphicsScene()
self.view1 = QGraphicsView(self.scene1)
# Create new action
# Create exit action
# Create a widget for window contents
wid = QWidget(self)
self.setCentralWidget(wid)
# Create layouts to place inside widget
# controlLayout = QHBoxLayout()
# controlLayout.setContentsMargins(0, 0, 0, 0)
# controlLayout.addWidget(self.playButton)
# controlLayout.addWidget(self.positionSlider)
videolayout = QVBoxLayout()
videolayout.addWidget(videoWidget)
# videolayout.addLayout(controlLayout)
# Set widget to contain window contents
layout = QHBoxLayout()
layout.addLayout(videolayout)
layout.addWidget(self.cameraviewfinder)
# layout.addWidget(self.view1)
wid.setLayout(layout)
self.mediaPlayer.setVideoOutput(videoWidget)
self.cameraviewfinder.show()
self.camera.setViewfinder(self.cameraviewfinder)
def exitCall(self):
sys.exit(app.exec_())
def play(self):
self.showFullScreen()
fileName = 'D:\\桌面\\some.mp4'
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
self.cameraviewfinder.resize(640, 480)
self.camera.start()
self.mediaPlayer.play()
camera_capture = cv2.VideoCapture(0)
while True:
ret, camera_frame = camera_capture.read()
if ret:
self.displayImage(camera_frame)
else:
break
camera_capture.release()
cv2.destroyAllWindows()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def displayImage(self, img):
self.scene1.clear()
pixMap = QPixmap(img)
w, h = pixMap.width(), pixMap.height()
self.scene1.addPixmap(pixMap)
self.view1.fitInView(QRectF(0, 0, w, h), Qt.KeepAspectRatio)
self.scene1.update()
class NativeVideoDialog(QMainWindow):
def __init__(self):
super().__init__()
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
video_widget = QVideoWidget()
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.set_position)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
# Create exit action
exit_action = QAction(QIcon('exit.png'), '&Exit', self)
exit_action.setShortcut('Ctrl+Q')
exit_action.setStatusTip('Close window')
exit_action.triggered.connect(self.exit_call)
# Create a widget for window contents
wid = QWidget(self)
self.setCentralWidget(wid)
# Create layouts to place inside widget
control_layout = QHBoxLayout()
control_layout.setContentsMargins(0, 0, 0, 0)
control_layout.addWidget(self.playButton)
control_layout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(video_widget)
layout.addLayout(control_layout)
layout.addWidget(self.errorLabel)
# Set widget to contain window contents
wid.setLayout(layout)
self.mediaPlayer.setVideoOutput(video_widget)
self.mediaPlayer.stateChanged.connect(self.media_state_changed)
self.mediaPlayer.positionChanged.connect(self.position_changed)
self.mediaPlayer.durationChanged.connect(self.duration_changed)
self.mediaPlayer.error.connect(self.handle_error)
def open_file_for_playing(self, file_name):
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(file_name)))
self.playButton.setEnabled(True)
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def media_state_changed(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
def position_changed(self, position):
self.positionSlider.setValue(position)
def duration_changed(self, duration):
self.positionSlider.setRange(0, duration)
def set_position(self, position):
self.mediaPlayer.setPosition(position)
def handle_error(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
def exit_call(self):
self.close()
cap = cv2.VideoCapture(webcam)
cv2.imshow('window', cv2.imread('images/Smile_detection_intro3.png'))
while True:
ret, frame = cap.read()
if ret:
frame = resize(frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
saveImage(frame)
rgb_frame = frame[:, :, ::-1]
gray = preproc(frame)
faces = detector(rgb_frame, 1)
if len(faces) > 0:
toRightN, toLeftN, eyeRightN, eyeLeftN, faceDN = getValues(
faces, gray)
break
else:
break
cap.release()
cv2.destroyAllWindows()
player.play()
wgt_video.showFullScreen()
detectorThread.start()
timerThread.start()
app.exec_()
class clipEditor(QMainWindow):
downloaded_more_scripts = pyqtSignal()
def __init__(self, videoWrapper):
QtWidgets.QWidget.__init__(self)
uic.loadUi(f"{current_path}/UI/ClipEditor.ui", self)
try:
self.setWindowIcon(QIcon('Assets/twitchlogo.png'))
except Exception as e:
pass
#Variables and stuff for the editor to send to the video generator
self.videoWrapper = videoWrapper
self.mainCommentIndex = 0
self.populateTreeWidget()
self.treeWidget.currentItemChanged.connect(self.setSelection)
self.treeWidget.clicked.connect(self.setSelection)
self.downloaded_more_scripts.connect(self.receiveMoreClips)
self.introClipPath = None
self.firstClipPath = None
self.intervalClipPath = None
self.outroClipPath = None
self.keep = []
self.skipped_paths = []
self.endCut = []
self.startCut = []
self.clipStatus = []
self.firstTwoClips = []
#All of the stuff to make the clip editor work
self.playlist = QMediaPlaylist()
vid_path = QUrl.fromLocalFile(f'{current_path}/VideoFiles')
self.mediaPlayer = QMediaPlayer()
self.playPauseButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
#self.addClipsToPlaylist()
self.mediaPlayer.stateChanged.connect(self.playPauseMedia)
self.mediaPlayer.setVideoOutput(self.clipPlayer)
self.mediaPlayer.setPlaylist(self.playlist)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.videoDurationSlider.sliderMoved.connect(self.setPosition)
self.endCutSlider.sliderMoved.connect(self.getEndCut)
self.startCutSlider.sliderMoved.connect(self.getStartCut)
self.audioSlider.sliderMoved.connect(self.audioChanged)
self.defaultIntro.stateChanged.connect(self.defaultIntroToggle)
self.chooseFirstClip.clicked.connect(self.firstClipFileDialog)
self.chooseIntro.clicked.connect(self.introFileDialog)
self.chooseInterval.clicked.connect(self.intervalFileDialog)
self.chooseOutro.clicked.connect(self.outroFileDialog)
self.noBackgroundMusic.clicked.connect(self.muteBackgroundVolume)
self.timer = QTimer(self, interval=1)
self.timer.start()
self.timer.timeout.connect(self.updateMusicCats)
self.endCutSlider.sliderPressed.connect(self.getEndCut)
self.startCutSlider.sliderPressed.connect(self.getStartCut)
self.mediaPlayer.positionChanged.connect(self.vidTimeStamp)
self.playPauseButton.clicked.connect(self.play)
#self.skipButton.clicked.connect(self.skipClip)
self.skipButton.clicked.connect(self.skipComment)
#self.backButton.clicked.connect(self.previousClip)
#self.keepButton.clicked.connect(self.keepClip)
#self.takeScreenshot.clicked.connect(self.screenshotCall)
self.downloadMore.clicked.connect(self.downloadMoreScripts)
self.keepButton.clicked.connect(self.keepComment)
self.exportButton.clicked.connect(self.videoExportConfirmation)
self.moveDown.clicked.connect(self.moveClipDown)
self.moveUp.clicked.connect(self.moveClipUp)
#self.nextButton.clicked.connect(self.nextClip)
self.playlist.currentIndexChanged.connect(self.checkForLastClip)
if settings.enforceInterval:
self.loadDefaultInterval()
else:
self.chooseInterval.setEnabled(False)
self.defaultInterval.setEnabled(False)
if settings.enforceIntro:
self.loadDefaultIntro()
else:
self.chooseIntro.setEnabled(False)
self.defaultIntro.setEnabled(False)
self.loadDefaultColours()
if settings.enforceOutro:
self.loadDefaultOutro()
else:
self.chooseOutro.setEnabled(False)
self.defaultOutro.setEnabled(False)
if not settings.enforceFirstClip:
self.chooseFirstClip.setEnabled(False)
self.updateDisplay()
def updateMusicCats(self):
try:
if not self.lastCheckedMusicOptions == client.music_categories:
self.musicOption.clear()
self.lastCheckedMusicOptions = client.music_categories
self.musicOption.addItems(client.music_categories)
except Exception as e:
self.musicOption.clear()
self.lastCheckedMusicOptions = client.music_categories
self.musicOption.addItems(client.music_categories)
def muteBackgroundVolume(self):
self.backgroundVolume.setText("0")
def audioChanged(self):
position = self.audioSlider.sliderPosition()
self.mediaPlayer.setVolume(position)
self.volumeClip.setText("Volume: %s" % position)
def defaultIntroToggle(self):
print(self.defaultIntro.isChecked())
def receiveMoreClips(self):
self.populateTreeWidget()
def downloadMoreScripts(self):
self.gameSelect = ClipDownloadMenu(self)
self.gameSelect.show()
pass
def moveClipDown(self):
self.videoWrapper.scriptWrapper.moveUp(self.mainCommentIndex)
self.updateDisplay()
def moveClipUp(self):
self.videoWrapper.scriptWrapper.moveDown(self.mainCommentIndex)
self.updateDisplay()
def updateDisplay(self):
#self.scriptWrapper.saveScriptWrapper()
self.getCurrentWidget(self.mainCommentIndex).setForeground(0, QtGui.QBrush(QtGui.QColor("blue")))
twitchclip = self.videoWrapper.scriptWrapper.getCommentInformation(self.mainCommentIndex)
mp4file = twitchclip.mp4
video_duration = twitchclip.vid_duration
start_cut = twitchclip.start_cut
end_cut = twitchclip.end_cut
audio = twitchclip.audio
self.startCutSlider.setValue(start_cut)
self.endCutSlider.setValue(end_cut)
self.clipTitle.setText(f'{twitchclip.streamer_name}-{twitchclip.clip_name}')
self.updateClipDuration()
self.mediaPlayer.stop()
if len(mp4file.split("/")) > 2:
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(f'{mp4file}')));
else:
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(f'TempClips/{mp4file}.mp4')))
self.mediaPlayer.setVolume(audio * 100)
self.volumeClip.setText("Volume: %s" % (audio * 100))
self.audioSlider.setValue(audio * 100)
self.estTime.setText(str(self.videoWrapper.scriptWrapper.getEstimatedVideoTime()))
self.videoLength.setText(f'{round(video_duration, 1)}')
self.startCutLabel.setText(f'Start: {round(start_cut / 1000, 1)}')
self.endCutLabel.setText(f'End: {end_cut}')
self.mediaPlayer.play()
self.clipCountLabel.setText(f"Clip {self.mainCommentIndex+1}/{len(self.videoWrapper.scriptWrapper.rawScript)}")
def setSelection(self):
try:
self.currentTreeWidget = self.treeWidget.currentItem()
if self.currentTreeWidget.parent() is None:
self.mainCommentIndex = int(str(self.currentTreeWidget.text(0)).split(" ")[1])
self.updateColors()
self.updateDisplay()
except Exception:
print("error trying to update selection index")
def getCurrentWidget(self, x):
return self.getTopLevelByName("Vid %s" % str(x))
def incrimentSelection(self):
if not self.mainCommentIndex + 1 > self.videoWrapper.scriptWrapper.getCommentAmount() - 1:
self.mainCommentIndex += 1
def updateColors(self):
for x, mainComment in enumerate(self.videoWrapper.scriptWrapper.scriptMap):
self.selectedMainComment = self.getTopLevelByName("Vid %s" % str(x))
if mainComment is True:
self.selectedMainComment.setForeground(0, QtGui.QBrush(QtGui.QColor("green")))
else:
self.selectedMainComment.setForeground(0, QtGui.QBrush(QtGui.QColor("red")))
def keepComment(self):
self.videoWrapper.scriptWrapper.setCommentStart(self.mainCommentIndex, self.startCutSlider.sliderPosition())
self.videoWrapper.scriptWrapper.setCommentEnd(self.mainCommentIndex, self.endCutSlider.sliderPosition())
self.videoWrapper.scriptWrapper.setCommentAudio(self.mainCommentIndex, self.audioSlider.sliderPosition() / 100)
self.videoWrapper.scriptWrapper.keep(self.mainCommentIndex)
self.incrimentSelection()
self.updateColors()
self.updateDisplay()
def skipComment(self):
self.videoWrapper.scriptWrapper.setCommentStart(self.mainCommentIndex, self.startCutSlider.sliderPosition())
self.videoWrapper.scriptWrapper.setCommentEnd(self.mainCommentIndex, self.endCutSlider.sliderPosition())
self.videoWrapper.scriptWrapper.setCommentAudio(self.mainCommentIndex, self.audioSlider.sliderPosition() / 100)
self.videoWrapper.scriptWrapper.skip(self.mainCommentIndex)
self.updateColors()
self.nextMainComment()
self.updateDisplay()
def nextMainComment(self):
if not self.mainCommentIndex + 1 > self.videoWrapper.scriptWrapper.getCommentAmount() - 1:
self.mainCommentIndex += 1
self.selectedMainComment = self.getTopLevelByName("Main Comment %s" % str(self.mainCommentIndex))
def populateTreeWidget(self):
self.treeWidget.clear()
for i, clip in enumerate(self.videoWrapper.scriptWrapper.rawScript):
treeParentName = "Vid %s"%str(i)
self.addTopLevel(treeParentName)
self.selectedMainComment = self.getTopLevelByName("Vid %s" % str(0))
self.updateColors()
def getTopLevelByName(self, name):
for index in range(self.treeWidget.topLevelItemCount()):
item = self.treeWidget.topLevelItem(index)
if item.text(0) == name:
return item
return None
def addTopLevel(self, name):
if self.getTopLevelByName(name) is None:
QTreeWidgetItem(self.treeWidget, [name])
def checkForLastClip(self):
if self.playlist.currentIndex() == len(self.startCut) - 1:
self.playlist.setPlaybackMode(0)
def updateClipDuration(self):
twitchclip = self.videoWrapper.scriptWrapper.getCommentInformation(self.mainCommentIndex)
duration = round(twitchclip.vid_duration - (self.startCutSlider.sliderPosition() / 1000) - (self.endCutSlider.sliderPosition() / 1000), 1)
self.clipDurationLabel.setText(f'Clip Duration: {duration}')
#Getting the timestamp for the video player
def vidTimeStamp(self):
self.timeStamp.setText(f"00:{self.getPositionInSecs()}")
#Controlling the play/pause of the videos, kinda obvious
def playPauseMedia(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playPauseButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.playPauseButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
#Giving the play button function
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
#This makes the duration slider move with the video
def positionChanged(self, position):
self.videoDurationSlider.setValue(position)
#Sets the range of each slider to the duration of each video
def durationChanged(self, duration):
self.videoDurationSlider.setRange(0, duration)
self.endCutSlider.setRange(0, duration)
self.startCutSlider.setRange(0, duration)
#This is to control the position of the video in the media player so I can control the video with the duration slider
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
self.mediaPlayer.play()
def introFileDialog(self):
options = QFileDialog.Options()
fileName, _ = QFileDialog.getOpenFileName(self,"Select The Intro Clip", f"{current_path}/Intros","All Files (*);;MP4 Files (*.mp4)", options=options)
if fileName:
try:
vid = cv2.VideoCapture(fileName)
height = vid.get(cv2.CAP_PROP_FRAME_HEIGHT)
width = vid.get(cv2.CAP_PROP_FRAME_WIDTH)
if width != int(1920) or height != int(1080):
self.uploadFail("Incorrect resolution for file %s.\n Resolution was %sx%s, required 1920x1080" % (fileName, width, height))
else:
self.introClipPath = fileName
self.chooseIntro.setText("Reselect Intro")
except Exception as e:
self.uploadFail("Error occured uploading file \n %s" % (e))
def outroFileDialog(self):
options = QFileDialog.Options()
fileName, _ = QFileDialog.getOpenFileName(self,"Select The Outro Clip", f"{current_path}/Outros","All Files (*);;MP4 Files (*.mp4)", options=options)
if fileName:
try:
vid = cv2.VideoCapture(fileName)
height = vid.get(cv2.CAP_PROP_FRAME_HEIGHT)
width = vid.get(cv2.CAP_PROP_FRAME_WIDTH)
if int(width) != 1920 or int(height) != 1080:
self.uploadFail("Incorrect resolution for file %s.\n Resolution was %sx%s, required 1920x1080" % (fileName, width, height))
else:
self.outroClipPath = fileName
self.chooseOutro.setText("Reselect Outro")
except Exception as e:
self.uploadFail("Error occured uploading file \n %s" % (e))
def intervalFileDialog(self):
options = QFileDialog.Options()
fileName, _ = QFileDialog.getOpenFileName(self,"Select The Interval Clip", f"{current_path}/Intervals","All Files (*);;MP4 Files (*.mp4)", options=options)
if fileName:
try:
vid = cv2.VideoCapture(fileName)
height = vid.get(cv2.CAP_PROP_FRAME_HEIGHT)
width = vid.get(cv2.CAP_PROP_FRAME_WIDTH)
if int(width) != 1920 or int(height) != 1080:
self.uploadFail("Incorrect resolution for file %s.\n Resolution was %sx%s, required 1920x1080" % (fileName, width, height))
else:
self.intervalClipPath = fileName
self.chooseInterval.setText("Reselect Interval")
except Exception as e:
self.uploadFail("Error occured uploading file \n %s" % (e))
def firstClipFileDialog(self):
options = QFileDialog.Options()
fileName, _ = QFileDialog.getOpenFileName(self,"Select The First Clip", f"{current_path}/FirstClips","All Files (*);;MP4 Files (*.mp4)", options=options)
if fileName:
# name = len(fileName.split("/"))
# self.firstClipPath = (fileName.split("/")[name-1])
try:
vid = cv2.VideoCapture(fileName)
height = vid.get(cv2.CAP_PROP_FRAME_HEIGHT)
width = vid.get(cv2.CAP_PROP_FRAME_WIDTH)
if int(width) != 1920 or int(height) != 1080:
self.uploadFail("Incorrect resolution for file %s.\n Resolution was %sx%s, required 1920x1080" % (fileName, width, height))
else:
self.firstClipPath = fileName
name = len(self.firstClipPath.split("/"))
new_name = (self.firstClipPath.split("/")[name-1]).replace(".mp4", "")
self.firstClipCred.setText(new_name)
firstClip = scriptwrapper.DownloadedTwitchClipWrapper("", "", "", "", None)
firstClip.streamer_name = new_name
firstClip.mp4 = self.firstClipPath
firstClip.upload = True
media_info = MediaInfo.parse(self.firstClipPath)
duration = media_info.tracks[0].duration / 1000
firstClip.vid_duration = float(duration)
self.videoWrapper.scriptWrapper.addClipAtStart(firstClip)
self.populateTreeWidget()
self.chooseFirstClip.setText("Reselect First Clip")
except Exception as e:
self.uploadFail("Error occured uploading file \n %s" % (e))
def saveDefaultIntro(self):
with open(f'Save Data/defaultintro.save', 'wb') as pickle_file:
pickle.dump(self.introClip, pickle_file)
def saveDefaultInterval(self):
with open(f'Save Data/defaultinterval.save', 'wb') as pickle_file:
pickle.dump(self.intervalClipPath, pickle_file)
def saveDefaultColours(self):
with open(f'Save Data/defaultcolours.save', 'wb') as pickle_file:
pickle.dump([self.mainColour.currentText(), self.outlineColour.currentText()], pickle_file)
def saveDefaultOutro(self):
with open(f'Save Data/defaultoutro.save', 'wb') as pickle_file:
pickle.dump(self.outroClipPath, pickle_file)
def loadDefaultIntro(self):
if os.path.exists("Save Data/defaultintro.save"):
with open(f'Save Data/defaultintro.save', 'rb') as pickle_file:
self.introClip = pickle.load(pickle_file)
self.introClipPath = self.introClip.mp4
self.defaultIntro.setChecked(True)
self.chooseIntro.setText("Reselect Intro")
def loadDefaultInterval(self):
if os.path.exists("Save Data/defaultinterval.save"):
with open(f'Save Data/defaultinterval.save', 'rb') as pickle_file:
self.intervalClip = pickle.load(pickle_file)
self.intervalClipPath = self.intervalClip
self.defaultInterval.setChecked(True)
self.chooseInterval.setText("Reselect Interval")
def loadDefaultOutro(self):
if os.path.exists("Save Data/defaultoutro.save"):
with open(f'Save Data/defaultoutro.save', 'rb') as pickle_file:
self.outroClip = pickle.load(pickle_file)
self.outroClipPath = self.outroClip
self.defaultOutro.setChecked(True)
self.chooseOutro.setText("Reselect Outro")
def loadDefaultColours(self):
if os.path.exists("Save Data/defaultcolours.save"):
with open(f'Save Data/defaultcolours.save', 'rb') as pickle_file:
colours = pickle.load(pickle_file)
colour1 = colours[0]
colour2 = colours[1]
index1 = self.mainColour.findText(colour1, QtCore.Qt.MatchFixedString)
if index1 >= 0:
self.mainColour.setCurrentIndex(index1)
index2 = self.outlineColour.findText(colour2, QtCore.Qt.MatchFixedString)
if index2 >= 0:
self.outlineColour.setCurrentIndex(index2)
self.defaultColor.setChecked(True)
#Collecting all of the information for video generator
def exportVideo(self):
intervalCheck = True if (self.intervalClipPath is not None and settings.enforceInterval) or not settings.enforceInterval else False
firstClipCheck = True if (self.firstClipPath is not None and settings.enforceFirstClip) or not settings.enforceFirstClip else False
introClipCheck = True if (self.introClipPath is not None and settings.enforceIntro) or not settings.enforceIntro else False
outroClipCheck = True if (self.outroClipPath is not None and settings.enforceOutro) or not settings.enforceOutro else False
if intervalCheck is True and firstClipCheck is True and introClipCheck is True and outroClipCheck is True:
self.mediaPlayer.stop()
final_clips = self.videoWrapper.scriptWrapper.getFinalClips()
self.videoWrapper.colour1 = self.mainColour.currentText()
self.videoWrapper.colour2 = self.outlineColour.currentText()
self.videoWrapper.background_audio = self.backgroundVolume.text()
self.videoWrapper.audio_cat = self.musicOption.currentText()
with_intro = []
if settings.enforceIntro:
self.introClip = scriptwrapper.DownloadedTwitchClipWrapper("", "", " ", "", None)
self.introClip.streamer_name = None
self.introClip.mp4 = self.introClipPath
self.introClip.isIntro = True
self.introClip.isInterval = False
self.introClip.upload = True
self.introClip.isUsed = True
media_info_intro = MediaInfo.parse(self.introClipPath)
duration_intro = media_info_intro.tracks[0].duration / 1000
self.introClip.vid_duration = float(duration_intro)
if settings.enforceInterval:
self.intervalClip = scriptwrapper.DownloadedTwitchClipWrapper("", "", " ", "", None)
self.intervalClip.streamer_name = None
self.intervalClip.mp4 = self.intervalClipPath
self.intervalClip.isInterval = True
self.intervalClip.isIntro = False
self.intervalClip.upload = True
self.intervalClip.isUsed = True
media_info_interval = MediaInfo.parse(self.intervalClipPath)
duration_interval = media_info_interval.tracks[0].duration / 1000
self.intervalClip.vid_duration = float(duration_interval)
if settings.enforceOutro:
self.outroClip = scriptwrapper.DownloadedTwitchClipWrapper("", "", " ", "", None)
self.outroClip.streamer_name = None
self.outroClip.mp4 = self.outroClipPath
self.outroClip.isOutro = True
self.outroClip.upload = True
self.outroClip.isUsed = True
media_info_outro = MediaInfo.parse(self.outroClipPath)
duration_outro = media_info_outro.tracks[0].duration / 1000
self.outroClip.vid_duration = float(duration_outro)
if self.defaultIntro.isChecked():
self.saveDefaultIntro()
if self.defaultInterval.isChecked():
self.saveDefaultInterval()
if self.defaultColor.isChecked():
self.saveDefaultColours()
if self.defaultOutro.isChecked():
self.saveDefaultOutro()
for i, clip in enumerate(final_clips):
clip.colour1 = self.mainColour.currentText()
clip.colour2 = self.outlineColour.currentText()
with_intro.append(clip)
if i == 0:
if settings.enforceInterval:
with_intro.append(self.intervalClip)
if settings.enforceIntro:
with_intro.append(self.introClip)
if settings.enforceOutro:
with_intro.append(self.outroClip)
self.videoWrapper.final_clips = with_intro
self.clipupload = ClipUploadMenu(self.videoWrapper)
self.clipupload.show()
else:
print("Choose intro clip and first clip")
#Converting the video duration/position to seconds so it makes sense
def getPositionInSecs(self):
try:
index = self.playlist.currentIndex()
vid_position = self.mediaPlayer.position()
vid_duration = self.mediaPlayer.duration()
vid_percentage = (vid_position / vid_duration)
twitchclip = self.videoWrapper.scriptWrapper.getCommentInformation(self.mainCommentIndex)
return int(twitchclip.vid_duration * vid_percentage)
except:
pass
#Gets the value of the start position and also updates the text, kinda not needed to get the value but whatever
def getStartCut(self):
sCut = self.getSliderPositionInSecs(self.startCutSlider)
self.startCutLabel.setText(f'Start: {sCut}')
self.mediaPlayer.setPosition(self.startCutSlider.sliderPosition())
return sCut
#Same same
def getEndCut(self):
eCut = self.getSliderPositionInSecs(self.endCutSlider)
twitchclip = self.videoWrapper.scriptWrapper.getCommentInformation(self.mainCommentIndex)
video_duration = twitchclip.vid_duration
self.mediaPlayer.setPosition((video_duration * 1000) - self.endCutSlider.sliderPosition())
self.endCutLabel.setText(f'End: {video_duration - eCut}')
return eCut
#Gets the position of the startCutSlider in seconds
def getSliderPositionInSecs(self, slider):
try:
vid_position = slider.sliderPosition()
if vid_position is None:
vid_position = 0
vid_duration = self.mediaPlayer.duration()
vid_percentage = (vid_position / vid_duration)
twitchclip = self.videoWrapper.scriptWrapper.getCommentInformation(self.mainCommentIndex)
self.updateClipDuration()
self.mediaPlayer.play()
return round(twitchclip.vid_duration * vid_percentage, 1)
except:
pass
def videoExportConfirmation(self):
msg = 'Is the video long enough?\nIs everything properly cut?'
buttonReply = QMessageBox.information(self, 'Video Export Confirmation', msg, QMessageBox.Yes | QMessageBox.Cancel, QMessageBox.Cancel)
if buttonReply == QMessageBox.Yes:
try:
volume_test = float(self.backgroundVolume.text())
except Exception:
print("audio is not of float format")
return
intervalCheck = True if (self.intervalClipPath is not None and settings.enforceInterval) or not settings.enforceInterval else False
firstClipCheck = True if (self.firstClipPath is not None and settings.enforceFirstClip) or not settings.enforceFirstClip else False
introClipCheck = True if (self.introClipPath is not None and settings.enforceIntro) or not settings.enforceIntro else False
outroClipCheck = True if (self.outroClipPath is not None and settings.enforceOutro) or not settings.enforceOutro else False
msg = "Could not publish due to the following reasons: \n"
if not intervalCheck:
msg += "No interval selected, but interval expected (see config.ini)\n"
if not firstClipCheck:
msg += "No first clip selected, but first clip expected (see config.ini)\n"
if not introClipCheck:
msg += "No intro clip selected, but intro expected (see config.ini)\n"
if not outroClipCheck:
msg += "No outro clip selected, but outro expected (see config.ini)\n"
amountClips = len(self.videoWrapper.scriptWrapper.getKeptClips())
if amountClips < 2:
msg += "Not enough clips! Need at least two clips to be kept."
if intervalCheck is False or firstClipCheck is False or introClipCheck is False or outroClipCheck is False or amountClips < 2:
self.publishFail(msg)
return
self.mediaPlayer.stop()
self.close()
self.exportVideo()
print('Yes clicked.')
if buttonReply == QMessageBox.Cancel:
print('Cancel')
def uploadFail(self, msg):
buttonReply = QMessageBox.information(self, 'Upload fail', msg, QMessageBox.Ok)
def publishFail(self, msg):
buttonReply = QMessageBox.information(self, 'Publish fail', msg, QMessageBox.Ok)
class Window(QtWidgets.QDialog):
def __init__(self):
super().__init__()
self.setGeometry(50, 50, 300, 400)
self.setWindowTitle("Rolev Player")
# LIBRARY ROOT DIR FOLDER
self.search_label = QtWidgets.QLabel("Select a music folder:", self)
self.search_label.setGeometry(10, 5, 205, 10)
self.btn_root_folder = QtWidgets.QPushButton("Browse", self)
self.btn_root_folder.setGeometry(215, 20, 75, 25)
# the text field of the currently selected root directory
self.dir_text_field = QtWidgets.QLineEdit(self)
self.dir_text_field.setGeometry(10, 20, 200, 25)
self.btn_root_folder.clicked.connect(self.on_btn_root_folder)
# CURRENT MEDIA LABEL
self.current_media_label = QtWidgets.QLabel("Now Playing: ", self)
self.current_media_label.setGeometry(10, 260, 250, 15)
# CURRENT ALBUM COVER
self.current_album_cover = QtWidgets.QLabel("Image", self)
self.current_album_cover.setGeometry(10, 180, 75, 75)
self.current_album_cover.setScaledContents(True)
# ARTIST DROP BOX
self.artist_select_label = QtWidgets.QLabel("Artist", self)
self.artist_select_label.setGeometry(10, 50, 250, 25)
self.artist_select = QtWidgets.QComboBox(self)
self.artist_select.setGeometry(10, 70, 250, 25)
self.artist_select.activated[str].connect(self.on_artist_selection)
# ALBUMS DROP BOX
self.album_select_label = QtWidgets.QLabel("Albums", self)
self.album_select_label.setGeometry(10, 90, 250, 25)
self.album_select = QtWidgets.QComboBox(self)
self.album_select.setGeometry(10, 110, 250, 25)
self.album_select.activated[str].connect(self.on_album_selection)
# SONGS DROP BOX
self.song_select_label = QtWidgets.QLabel("Current Playlist", self)
self.song_select_label.setGeometry(10, 130, 250, 25)
self.song_select = QtWidgets.QComboBox(self)
self.song_select.setGeometry(10, 150, 250, 25)
self.song_select.activated[str].connect(self.on_song_selection)
# PLAYLIST
self.playlist = QMediaPlaylist()
self.playlist.currentIndexChanged.connect(self.meta_data_changed)
# MEDIA PLAYER
self.player = QMediaPlayer()
self.player.setPlaylist(self.playlist)
self.player.playlist().setPlaybackMode(QMediaPlaylist.Loop)
self.player.setVolume(50)
self.player.durationChanged.connect(self.on_dur_change)
self.player.positionChanged.connect(self.on_pos_change)
# VOLUME SLIDER
self.slider_volume_label = QtWidgets.QLabel("Volume", self)
self.slider_volume_label.setGeometry(10, 345, 50, 25)
self.slider_volume = QtWidgets.QSlider(QtCore.Qt.Horizontal, self)
self.slider_volume.setGeometry(60, 350, 130, 20)
self.slider_volume.setRange(0, 100)
self.slider_volume.setValue(50)
self.slider_volume.valueChanged.connect(self.volume_change)
# PROGRESS SLIDER
self.slider_progress_label = QtWidgets.QLabel("Progress", self)
self.slider_progress_label.setGeometry(10, 315, 50, 25)
self.slider_progress = QtWidgets.QSlider(QtCore.Qt.Horizontal, self)
self.slider_progress.setGeometry(60, 320, 130, 20)
self.slider_progress.sliderMoved.connect(self.progress_change)
# LYRICS SEARCH
self.btn_lyrics = QtWidgets.QPushButton("Search\n Lyrics", self)
self.btn_lyrics.setGeometry(220, 310, 70, 80)
self.btn_lyrics.clicked.connect(self.on_lyrics)
# ALBUM INFO SEARCH
self.btn_album_info = QtWidgets.QPushButton(
"Search\nAlbum\nInfo", self)
self.btn_album_info.setGeometry(105, 180, 75, 75)
self.btn_album_info.clicked.connect(self.on_album_info)
# ARTIST INFO SEARCH
self.btn_artist_info = QtWidgets.QPushButton(
"Search\nArtist\nInfo", self)
self.btn_artist_info.setGeometry(200, 180, 75, 75)
self.btn_artist_info.clicked.connect(self.on_artist_info)
# PREV SONG BUTTON
self.btn_prev = QtWidgets.QPushButton("Prev", self)
self.btn_prev.setGeometry(10, 280, 75, 25)
self.btn_prev.clicked.connect(self.on_btn_prev)
# NEXT SONG BUTTON
self.btn_next = QtWidgets.QPushButton("Next", self)
self.btn_next.setGeometry(200, 280, 75, 25)
self.btn_next.clicked.connect(self.on_btn_next)
# PLAY/PAUSE BUTTON
self.btn_play_pause = QtWidgets.QPushButton("Play", self)
self.btn_play_pause.setGeometry(105, 280, 75, 30)
self.btn_play_pause.clicked.connect(self.on_btn_play_pause)
self.show()
def on_btn_root_folder(self):
self.root_dir = QtWidgets.QFileDialog().getExistingDirectory()
self.dir_text_field.setText(self.root_dir)
self.library = LibraryLoader.load_music_from_dir(
self.dir_text_field.text())
self.artist_select.clear()
self.album_select.clear()
self.song_select.clear()
self.playlist.clear()
self.btn_play_pause.setText("Play")
self.artist_select.addItem("All Artists")
for artist in self.library:
self.artist_select.addItem(artist)
for album in self.library[artist]:
self.album_select.addItem(album)
self.load_all_songs()
def on_artist_selection(self):
current_artist = self.artist_select.currentText()
self.album_select.clear()
self.song_select.clear()
self.playlist.clear()
self.btn_play_pause.setText("Play")
self.album_select.addItem("All Albums")
if current_artist == "All Artists":
for artist in self.library:
for album in self.library[artist]:
self.album_select.addItem(album)
self.load_all_songs()
else:
for album in self.library[current_artist]:
self.album_select.addItem(album)
self.load_all_from_artist(current_artist)
def load_all_songs(self):
for artist in self.library:
for album in self.library[artist]:
for song in self.library[artist][album]:
self.song_select.addItem(song[0])
self.playlist.addMedia(
QMediaContent(QtCore.QUrl.fromLocalFile(song[1])))
def load_all_from_artist(self, artist):
for album in self.library[artist]:
for song in self.library[artist][album]:
self.song_select.addItem(song[0])
self.playlist.addMedia(
QMediaContent(QtCore.QUrl.fromLocalFile(song[1])))
def on_album_selection(self):
current_artist = self.artist_select.currentText()
current_album = self.album_select.currentText()
self.song_select.clear()
self.playlist.clear()
self.btn_play_pause.setText("Play")
if current_album == "All Albums" and current_artist == "All Artists":
self.load_all_songs()
elif current_album == "All Albums":
self.load_all_from_artist(current_artist)
elif current_artist == "All Artists":
for artist in self.library:
for album in self.library[artist]:
if album == self.album_select.currentText():
for song in self.library[artist][album]:
self.song_select.addItem(song[0])
self.playlist.addMedia(
QMediaContent(
QtCore.QUrl.fromLocalFile(song[1])))
else:
for song in self.library[current_artist][current_album]:
self.song_select.addItem(song[0])
self.playlist.addMedia(
QMediaContent(QtCore.QUrl.fromLocalFile(song[1])))
def on_song_selection(self):
index = self.song_select.currentIndex()
self.playlist.setCurrentIndex(index)
# GETTING THE CURRENT SONG METADATA
# Returns a SONG OBJECT and not the current song title
# For the title of the currently playing song use get_current_title()
def get_current_song(self):
curr_url = self.playlist.currentMedia().canonicalUrl().toString()[8:]
if curr_url:
return LibraryLoader.create_song(curr_url)
def get_current_artist(self):
if self.get_current_song() is not None:
return self.get_current_song().artist
def get_current_album(self):
if self.get_current_song() is not None:
return self.get_current_song().album
def get_current_path(self):
if self.get_current_song() is not None:
return self.get_current_song().path
def get_current_album_path(self):
if self.get_current_path() is not None:
return self.get_current_path().rsplit("/", 1)[0]
def get_current_title(self):
if self.get_current_song() is not None:
return self.get_current_song().name
def on_lyrics(self):
if self.get_current_song() is not None:
curr_artist = self.get_current_artist()
curr_song = self.get_current_title()
found_lyrics = RequestLyrics.search_song_lyrics(
curr_artist, curr_song)
choice = QtWidgets.QMessageBox.question(
self, "Lyrics", found_lyrics[0],
QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
if choice == QtWidgets.QMessageBox.Yes:
webbrowser.open(found_lyrics[1])
else:
QtWidgets.QMessageBox.information(
self, "Lyrics", "No lyrics found or no media is loaded!")
def on_album_info(self):
album = self.get_current_album()
artist = self.get_current_artist()
if (album is None) or (artist is None):
print("Please, load a song first!")
else:
artist_info, album_info = AlbumArtwork.album_artist_info(
artist, album)
if album_info is not None:
webbrowser.open(album_info)
def on_artist_info(self):
album = self.get_current_album()
artist = self.get_current_artist()
if (album is None) or (artist is None):
print("Please, load a song first!")
else:
artist_info, album_info = AlbumArtwork.album_artist_info(
artist, album)
if artist_info is not None:
webbrowser.open(artist_info)
def on_btn_play_pause(self):
if self.player.state() in (0, 2):
self.player.play()
if self.player.state() == 1:
self.btn_play_pause.setText("Pause")
else:
self.player.pause()
self.btn_play_pause.setText("Play")
def on_btn_next(self):
self.player.playlist().next()
def on_btn_prev(self):
self.player.playlist().previous()
def on_dur_change(self, length):
self.slider_progress.setMaximum(length)
def on_pos_change(self, position):
self.slider_progress.setValue(position)
def volume_change(self):
volume = self.slider_volume.value()
self.player.setVolume(volume)
def progress_change(self):
position = self.slider_progress.value()
self.player.setPosition(position)
def meta_data_changed(self):
now_playing = self.get_current_title()
self.current_media_label.setText("Now Playing: " + now_playing)
# Updating the currently playing album cover
curr_album_path = self.get_current_album_path()
curr_album = self.get_current_album()
curr_artist = self.get_current_artist()
cover_url = AlbumArtwork.album_cover(
curr_album_path, curr_artist, curr_album)
self.current_album_cover.setPixmap(QPixmap(cover_url))
Scrobbler.scrobble(self.get_current_artist(), self.get_current_title())
class EventAction():
def __init__(self):
#self.parent = parent
self.isLoop = 0 #0循环列表，1单曲循环
self.isRandom = 0 #0不随机，1随机
self.fileList = [] #曲目名称列表
self.randomList =[] #播放列表
self.soundID = 0 #当前歌曲ID
self.playStat = False #当前播放状态 （0未播放，1播放）
self.openPath = "F:/mp3/" #歌曲目录
self.isPreview = 0 #试用开关，0正常播放，1列表中的歌曲每首歌曲放10秒
self.currentVolume = 0.1#默认的起始音量
self.isInitPlay = 1 #是否是初始播放
#==>>打开目录
self.config=configparser.ConfigParser()
self.config.read('config.ini')
self.openDir()
#打开目录<<==
self.playObj = QMediaPlayer()
self.currentImg = "" #当前图片
self.songText = {} #歌词
self.songTextKey=[] #歌词KEY
#打开歌曲目录
def openDir(self):
self.openPath = self.config.get('Save','musicPath')
isMusicDir = os.path.isdir(self.openPath)#检查是否为目录
if isMusicDir:
dirFile = os.listdir(self.openPath)#目录中的所有文件
#遍历有效音乐文件
i=0;
for file in dirFile:
fileName,fileType=os.path.splitext(file)
if fileType==".mp3" or fileType==".wav":
self.fileList.append(file)
self.randomList.append(i)
i+=1
if self.isRandom==1:
self.shuffleMusic(1)
#随机（打乱播放顺序）
def shuffleMusic(self,isshuffle):
if isshuffle:
random.shuffle(self.randomList)#乱序
else:
self.randomList.sort()#排序
#初始化播放
def initPlay(self):
self.soundID = int(self.config.get('Save','soundID'))
self.playStat = self.config.get('Save','playStat')
self.pastTime = self.config.getint('Save','pastTime')
self.currentVolume = self.config.getint('Save','volume')
self.isRandom = self.config.getint('Save','isRandom')
self.isLoop = self.config.getint('Save','isLoop')
if self.soundID!="":
self.play(self.soundID)
if self.isRandom:#打乱列表
self.shuffleMusic(1)
self.playObj.setVolume(self.currentVolume)
#播放
def play(self,i):
source = self.openPath + self.fileList[i]
self.playObj.setMedia(QMediaContent(QUrl.fromLocalFile(source)))
#解析文件中的ID3V2
self.currentImg = ""
f = QFile(source)
if f.open(QIODevice.ReadOnly):
#读取标签
headData = f.read(10)
data = headData[:0]
if self.id3v2(headData):#检测是否有ID3
#标签的大小计算
tag = headData[6:10]
tagSize = (tag[0]&0x7f)*0x200000+(tag[1]&0x7f)*0x4000+(tag[2]&0x7f)*0x80+(tag[3]&0x7f)
data =f.read(tagSize)
while len(data)>10:
data = self.resolve(data)
f.close()
self.playObj.play()
def testPlay(self):
#ps =QMediaMetaData()
#print("QMediaMetaData",ps)
#print("metaData",self.playObj.metaData(QMediaMetaData.Title))
#print("position",self.playObj.position())
#print("playlist",self.playObj.playlist)
#print("availability",self.playObj.availability())
#print("bufferStatus",self.playObj.bufferStatus())
#print("currentMedia",self.playObj.currentMedia())
#print("currentNetworkConfiguration",self.playObj.currentNetworkConfiguration())
#print("duration",self.playObj.duration())
#print("error",self.playObj.error())
#print("errorString",self.playObj.errorString())
#print("isAudioAvailable",self.playObj.isAudioAvailable())
#print("isMuted",self.playObj.isMuted())
#print("isSeekable",self.playObj.isSeekable())
#print("media",self.playObj.media())
#print("media:::::::A",self.playObj.media().canonicalResource().audioBitRate())
#print("media:::::::B",self.playObj.media().canonicalResource().audioCodec())
#print("media:::::::C",self.playObj.media().canonicalResource().channelCount())
#print("media:::::::D",self.playObj.media().canonicalResource().dataSize())
#print("media:::::::e",self.playObj.media().canonicalResource().isNull())
#print("media:::::::f",self.playObj.media().canonicalResource().language())
#print("media:::::::g",self.playObj.media().canonicalResource().mimeType())
#print("media:::::::h",self.playObj.media().canonicalResource().request())
#print("isVideoAvailable",self.playObj.isVideoAvailable())
#print("mediaStatus",self.playObj.mediaStatus())
#print("mediaStream",self.playObj.mediaStream())
#print("playbackRate",self.playObj.playbackRate())
#print("state",self.playObj.state())
#print("volume",self.playObj.volume())
# print("volume",self.playObj.filename)
pass
#换歌之前先停止，释放内存
def stopPlay(self):
self.playObj.pause()
#上一首
def prevPlay(self):
self.stopPlay()
if self.isRandom:
key = self.searchID(self.soundID)-1
if key<0:
key=0
self.soundID = self.randomList[key]
else:
self.soundID-=1
if self.soundID< 0:
self.soundID = len(self.randomList)-1
self.play(self.soundID)
#下一首
def nextPlay(self):
self.stopPlay()
if self.isRandom:
key = self.searchID(self.soundID)+1
if key>(len(self.randomList)-1):
key=len(self.randomList)-1
self.soundID = self.randomList[key]
else:
self.soundID+=1
if self.soundID > (len(self.randomList)-1):
self.soundID = 0
#print("next:::",self.soundID)
self.play(self.soundID)
#快退
def rewindPlay(self):
#print("<<")
rewindTime = int(self.playObj.position()) - 10*1000
if rewindTime < 0:
rewindTime = 0
self.playObj.setPosition(rewindTime)
#快进
def forwardPlay(self):
#print(">>")
forwardTime = int(self.playObj.position()) + 10*1000
if forwardTime > int(self.playObj.duration()):
forwardTime = int(self.playObj.duration())
self.playObj.setPosition(forwardTime)
#播放/暂停
def playORpause(self):
if self.playObj.state()==1:
self.playObj.pause()
else:
self.playObj.play()
#音量加
def raisevolPlay(self):
self.playObj.setVolume(self.playObj.volume()+10)
self.currentVolume = self.playObj.volume()
#音量减
def lowervolPlay(self):
self.playObj.setVolume(self.playObj.volume()-10)
self.currentVolume = self.playObj.volume()
#静音
def mutePlay(self):
if self.playObj.isMuted():
self.playObj.setMuted(False)
else:
self.playObj.setMuted(True)
#volume
#跟据v找K
def searchID(self,v):
for index, item in enumerate(self.randomList):
if item ==v:
return index
return 0
#解析文件中是否有id3v2
def id3v2(self,headData):
if str(headData[:3],encoding=("utf-8")) != "ID3":
return False
return True
#解析文件中的歌词与图片
def resolve(self,data):
tagName = str(data[:4],encoding=("utf-8"))
size = data[4:8]
#sizeS = size[0]*0x1000000 + size[1]*0x10000 + size[2]*0x100 + size[3]
sizeS=int.from_bytes(size, byteorder='big')
flags = data[8:10]
tagContent = data[10:sizeS+10]
if tagName=="TEXT":#歌词
#print("歌词")
condingType=int.from_bytes(tagContent[:1], byteorder='big')
if condingType == 0:#0代表字符使用ISO-8859-1编码方式；
try:
content = str(tagContent[1:],encoding="gbk")
except:
content =""
elif condingType == 1:#1代表字符使用UTF-16编码方式；
try:
content = str(tagContent[1:],encoding="UTF-16")
except:
content =""
elif condingType == 2:#2代表字符使用 UTF-16BE编码方式；
content =""
elif condingType == 3:#3代表字符使用UTF-8编码方式。
try:
content = str(tagContent[1:],encoding="UTF-8")
except:
content =""
if content!="":
temp={}
self.songTextKey=[]
contentSplit = content.splitlines()
for k in range(len(contentSplit)):
if contentSplit[k][1].isdigit():
xxx = contentSplit[k].split("]")
tempKey = "%d" %(int(xxx[0][1:3])*60 +int(xxx[0][4:6]) )
temp[str(tempKey)] = xxx[1]
self.songTextKey.append(tempKey)
else:
endKey = contentSplit[k].find("]",0)
self.songTextKey.append(k)
temp[str(k)] = contentSplit[k][1:endKey]
self.songText = temp
else:
self.songText = {}
elif tagName=="APIC":#图片
#print("图片")
self.currentImg = tagContent[17:]
return data[10+sizeS:]
import sys
from PyQt5.QtWidgets import QApplication
from PyQt5.QtMultimedia import QMediaPlayer, QMediaContent
from PyQt5.QtCore import QUrl
if __name__ == '__main__':
app = QApplication(sys.argv)
path = '/home/zetta/音乐/周柏豪._.哦.mp3'
mediaContent = QMediaContent(QUrl.fromLocalFile(path))
player = QMediaPlayer()
player.setMedia(mediaContent)
player.play()
sys.exit(app.exec_())
class AudioPlayer(QObject):
songPositionChanged = pyqtSignal(int)
songDurationChanged = pyqtSignal(int)
stateChanged = pyqtSignal(int)
playlistChanged = pyqtSignal(QMediaPlaylist, int)
currentSongChanged = pyqtSignal(str, str, bytes)
currentSelectionChanged = pyqtSignal(UUID, int)
customPlaylistCreated = pyqtSignal(UUID, str)
libraryPlaylistCreated = pyqtSignal(UUID)
addedToLibraryPlaylist = pyqtSignal(UUID, list)
addedToCustomPlaylist = pyqtSignal(UUID, list)
updatedLibraryPlaylist = pyqtSignal(UUID, list)
playlistRemoved = pyqtSignal(UUID)
def __init__(self, volumeLevel=40, playbackMode=QMediaPlaylist.Sequential,
parent=None):
super(AudioPlayer, self).__init__(parent)
self.__player = QMediaPlayer()
self.__player.setVolume(volumeLevel)
self.__player.currentMediaChanged.connect(self._onMediaChanged)
self.__player.stateChanged.connect(
lambda state: self.stateChanged.emit(int(state)))
self.__player.positionChanged.connect(
lambda x: self.songPositionChanged.emit(x))
self.__player.durationChanged.connect(
lambda x: self.songDurationChanged.emit(x))
self.__playlistManager = PlaylistManger()
self.__playlistManager.customPlaylistCreated.connect(
lambda uuid, name: self.customPlaylistCreated.emit(uuid, name))
self.__playlistManager.libraryPlaylistCreated.connect(
lambda p: self.libraryPlaylistCreated.emit(p))
self.__playlistManager.currentPlaylistChanged.connect(
self._onChangedPlaylist)
self.__playlistManager.currentPlaylistChanged.connect(
lambda p, i: self.playlistChanged.emit(p, i))
self.__playlistManager.playlistRemoved.connect(
lambda uuid: self.playlistRemoved.emit(uuid))
self.__playlistManager.addedToLibraryPlaylist.connect(
lambda uuid, l: self.addedToLibraryPlaylist.emit(uuid, l))
self.__playlistManager.addedToCustomPlaylist.connect(
lambda uuid, l: self.addedToCustomPlaylist.emit(uuid, l))
self.__playlistManager.updatedLibraryPlaylist.connect(
lambda uuid, l: self.updatedLibraryPlaylist.emit(uuid, l))
def createCustomPlaylist(self, name=None, urls=None):
self.__playlistManager.createCustomPlaylist(name, urls)
def createLibraryPlaylist(self, urls=None):
self.__playlistManager.createLibraryPlaylist(urls)
def addToLibraryPlaylist(self, url=None):
self.__playlistManager.addToLibraryPlaylist(url)
def updateLibraryPlaylist(self, url=None):
self.__playlistManager.updateLibraryPlaylist(url)
def renamePlaylist(self, uuid, newName):
self.__playlistManager.renamePlaylist(uuid, newName)
def addSongsToCustomPlaylist(self, uuid, urls=[]):
self.__playlistManager.addSongsToCustomPlaylist(uuid, urls)
def removeSong(self, uuid, row):
self.__playlistManager.removeSong(uuid, row)
def setPlaylist(self, uuid, index=0):
if (self.__player.playlist() and
self.__playlistManager.isCurrentPlaylist(uuid)):
if index == self.__player.playlist().currentIndex():
if self.__player.state() == QMediaPlayer.PlayingState:
self.__player.pause()
else:
self.__player.play()
else:
self.__player.playlist().setCurrentIndex(index)
else:
self.__playlistManager.setPlaylist(uuid, index)
def hasLibraryPlaylist(self):
return self.__playlistManager.hasLibraryPlaylist()
def removePlaylist(self, uuid):
self.__playlistManager.removePlaylist(uuid)
def getCurrentPlaylist(self):
self.__playlistManager.getCurrentPlaylist()
def getCurrentQMediaPlaylist(self):
self.__player.playlist()
def isPlayerAvailable(self):
return self.__player.isAvailable()
def getDuration(self):
return self.__player.duration()
def getPlayer(self):
return self.__player
def getState(self):
return self.__player.state()
def play(self):
if self.__player.playlist():
self.__player.play()
def pause(self):
if self.__player.playlist():
self.__player.pause()
def stop(self):
if self.__player.playlist():
self.__player.stop()
def previousEnhanced(self, sameSongMillis):
if self.__player.position() <= sameSongMillis:
self.previous()
else:
self.__player.setPosition(0)
def previous(self):
if self.__player.playlist():
self.__player.playlist().previous()
def next(self):
if self.__player.playlist():
self.__player.playlist().next()
def setVolume(self, value):
self.__player.setVolume(value)
def setPosition(self, milliseconds):
self.__player.setPosition(milliseconds)
def playlistCurrentIndex(self):
if self.__player.playlist():
return self.__player.playlist().currentIndex()
def setCurrentPlaylistIndex(self, index):
if self.__player.playlist():
self.__player.playlist().setCurrentIndex(index)
def _onChangedPlaylist(self, playlist, index, playIt=False):
self.__player.setPlaylist(playlist)
if playlist:
playlist.setCurrentIndex(index)
if playIt:
self.play()
def _onMediaChanged(self, media):
if media.isNull() and self.__player.playlist():
self.__player.playlist().setCurrentIndex(0)
media = self.__player.playlist().media(0)
if media.isNull():
return
title, artist, cover = self.__playlistManager.getBasicSongInfo(media)
self.currentSongChanged.emit(title, artist, cover)
uuid = self.__playlistManager.getCurrentPlaylistUuid()
index = self.__playlistManager.getCurrentSongIndex()
self.currentSelectionChanged.emit(uuid, index)
# def saveSettings(self):
# # settings = QSettings(QSettings.IniFormat, QSettings.UserScope,
# # QCoreApplication.organizationName(),
# # QCoreApplication.applicationName())
# # settings.beginGroup("music_player")
# # # if self.__playlistManager.getLibraryPlaylist():
# # # libraryDirectories = self.__playlistManager.getLibraryPlaylist().getDirectories()
# # # settings.beginWriteArray('library_playlist',
# # # len(libraryDirectories))
# # # for index, value in enumerate(libraryDirectories):
# # # settings.setArrayIndex(index)
# # # settings.setValue("url", value)
# # # settings.endArray()
# # customPlaylists = self.__playlistManager.getCustomPlaylists()
# # settings.beginWriteArray('custom_playlists',
# # len(customPlaylists))
# # for index, value in enumerate(customPlaylists):
# # settings.setArrayIndex(index)
# # playlistName = settings.value('name', value.getName())
# # playlistUrls = value.getAddedSongUrls()
# # settings.beginWriteArray(playlistName,
# # len(playlistUrls))
# # for i, v in enumerate(playlistUrls):
# # settings.setArrayIndex(i)
# # settings.setValue("url", v)
# # settings.endArray()
# # settings.endArray()
# # settings.endGroup()
# # if self.__playlistManager.getLibraryPlaylist():
# # libraryDirectories = self.__playlistManager.getLibraryPlaylist().getDirectories()
# # settings.beginWriteArray('library_playlist',
# # len(libraryDirectories))
# # for index, value in enumerate(libraryDirectories):
# # settings.setArrayIndex(index)
# # settings.setValue("url", value)
# # settings.endArray()
# customPlaylists = self.__playlistManager.getCustomPlaylists()
# for playlist in customPlaylists:
# playlistName = playlist.getName()
# for url in playlist:
# pass
# def restoreSettings(self):
# settings = QSettings(QSettings.IniFormat, QSettings.UserScope,
# QCoreApplication.organizationName(),
# QCoreApplication.applicationName())
# settings.beginGroup("music_player")
# # size = settings.beginReadArray('library_playlist')
# # libraryDirectories = []
# # for i in range(size):
# # settings.setArrayIndex(i)
# # libraryDirectories.append(settings.value("url"))
# # settings.endArray()
# customPlaylists = {}
# size = settings.beginReadArray('custom_playlists')
# for i in range(size):
# urls = []
# settings.setArrayIndex(i)
# playlistName = settings.value('name')
# print(playlistName)
# size2 = settings.beginReadArray(playlistName)
# for j in range(size2):
# settings.setArrayIndex(j)
# url = settings.value("url")
# urls.append(url)
# settings.endArray()
# customPlaylists[playlistName] = urls
# settings.endArray()
# settings.endGroup()
# print('-------')
# print(customPlaylists)
# settings = QSettings(QCoreApplication.organizationName(),
# QCoreApplication.applicationName())
# settings.beginGroup("music_player")
# size = settings.beginReadArray('library_playlist')
# if not size == 0:
# for i in range(0, size):
# settings.setArrayIndex(i)
# url = settings.value("url")
# settings.endArray()
# if url:
# from audio.playlist_models import DirectoryPlaylist
# playlist = DirectoryPlaylist()
# playlist.add_directory(url)
# self.addAndSetPlaylist(playlist, 2)
# settings.endGroup()
pass
class Player(Qt.QWidget):
"""docstring for Player"""
fullScreenChanged = Qt.pyqtSignal(bool)
def __init__(self, playlist, parent=None):
# create player
super(Player, self).__init__(parent)
self.trackInfo = ''
self.statusInfo = ''
self.duration = 0
# create player object
self.player = QMediaPlayer()
self.playlist = QMediaPlaylist()
self.name = 'Current playlist'
self.player.setPlaylist(self.playlist)
self.player.durationChanged.connect(self.durationChanged)
self.player.positionChanged.connect(self.positionChanged)
self.player.metaDataChanged.connect(self.metaDataChanged)
self.playlist.currentIndexChanged.connect(self.playlistPositionChanged)
self.player.mediaStatusChanged.connect(self.statusChanged)
self.player.bufferStatusChanged.connect(self.bufferingProgress)
# self.player.videoAvailableChanged.connect(self.videoAvailableChanged)
self.player.error.connect(self.displayErrorMessage)
# connect with VideoWidget
# self.videoWidget = VideoWidget()
# self.player.setVideoOutput(self.videoWidget)
# connect with PlaylistModel
self.playlistModel = PlaylistModel()
self.playlistModel.setPlaylist(self.playlist)
self.playlistView = Qt.QListView()
self.playlistView.setModel(self.playlistModel)
self.playlistView.setCurrentIndex(self.playlistModel.index(
self.playlist.currentIndex(), 0))
# change to next song
self.playlistView.activated.connect(self.jump)
self.slider = Qt.QSlider(QtCore.Qt.Horizontal)
self.slider.setRange(0, self.player.duration() / 1000)
self.labelDuration = Qt.QLabel()
self.slider.sliderMoved.connect(self.seek)
# create histogram
self.labelHistogram = Qt.QLabel()
self.labelHistogram.setText('Histogram: ')
self.histogram = HistogramWidget()
histogramLayout = Qt.QHBoxLayout()
histogramLayout.addWidget(self.labelHistogram)
histogramLayout.addWidget(self.histogram, 1)
# create videoProbe
self.videoProbe = Qt.QVideoProbe()
self.videoProbe.videoFrameProbed.connect(self.histogram.processFrame)
self.videoProbe.setSource(self.player)
# add control
controls = Controllers()
controls.setState(self.player.state())
controls.setVolume(self.player.volume())
controls.setMuted(controls.isMuted())
# connect player's controls with Controllers
controls.play.connect(self.player.play)
controls.pause.connect(self.player.pause)
controls.stop.connect(self.player.stop)
controls.next.connect(self.playlist.next)
controls.previous.connect(self.previousAction)
controls.changeVolume.connect(self.player.setVolume)
controls.changeMuting.connect(self.player.setMuted)
# setPlaybackRate is from QMediaPlayer
controls.changeSpeed.connect(self.player.setPlaybackRate)
# controls.stop.connect(self.videoWidget.update)
self.player.stateChanged.connect(controls.setState)
self.player.volumeChanged.connect(controls.setVolume)
self.player.mutedChanged.connect(controls.setMuted)
# create fullScreenButton
# self.fullScreenButton = Qt.QPushButton('FullScreen')
# self.fullScreenButton.setCheckable(True)
# displayLayout
displayLayout = Qt.QHBoxLayout()
# displayLayout.addWidget(self.videoWidget, 2)
displayLayout.addWidget(self.playlistView)
# controlLayout
controlLayout = Qt.QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
# connect controlLayout with controls
controlLayout.addWidget(controls)
controlLayout.addStretch(1)
# connect controlLayout with fullScreenButton
# controlLayout.addWidget(self.fullScreenButton)
# visualize player
layout = Qt.QVBoxLayout()
layout.addLayout(displayLayout)
# layout for sliding song playing
hLayout = Qt.QHBoxLayout()
hLayout.addWidget(self.slider)
hLayout.addWidget(self.labelDuration)
layout.addLayout(hLayout)
layout.addLayout(controlLayout)
layout.addLayout(histogramLayout)
# set icon
self.setWindowIcon(Qt.QIcon('favicon.ico'))
# create menus
toolBar = Qt.QToolBar()
# create basic actions
self.createActions()
# create simple button to repeat song
self.repeatButton = Qt.QToolButton()
self.repeatButton.setDefaultAction(self.repeatAct)
# create playOnceButton
self.playOnceButton = Qt.QToolButton()
self.playOnceButton.setDefaultAction(self.playOnceAct)
self.playOnceButton.setEnabled(False)
# create shuffleButton
self.shuffleButton = Qt.QToolButton()
self.shuffleButton.setDefaultAction(self.shuffleAct)
# create sequentialButton
self.sequentialButton = Qt.QToolButton()
self.sequentialButton.setDefaultAction(self.sequentialAct)
# create fileButton for fileMenu
fileButton = Qt.QToolButton()
fileButton.setText('File')
fileButton.setPopupMode(Qt.QToolButton.MenuButtonPopup)
fileButton.setMenu(self.popFileMenu())
# create editButton for editMenu
closeButton = Qt.QToolButton()
closeButton.setText('Edit')
closeButton.setDefaultAction(self.fileCloseAct)
# display in toolBar these buttons
toolBar.addWidget(self.repeatButton)
toolBar.addWidget(self.playOnceButton)
toolBar.addWidget(self.shuffleButton)
toolBar.addWidget(self.sequentialButton)
toolBar.addWidget(fileButton)
toolBar.addWidget(closeButton)
# add toolBar to layout of the player
layout.addWidget(toolBar)
layout.addWidget(Qt.QGroupBox())
self.setWindowTitle("Python Music Player")
self.setLayout(layout)
if not self.player.isAvailable():
Qt.QMessageBox(self, 'Unavailable service')
# self.displayErrorMessage()
controls.setEnabled(False)
self.playlistView.setEnabled(False)
self.fullScreenButton.setEnabled(False)
self.metaDataChanged()
self.addToPlaylist(playlist)
# create fileMenu
def popFileMenu(self):
aMenu = Qt.QMenu(self)
aMenu.addAction(self.fileOpenAct)
aMenu.addAction(self.fileCloseAct)
return aMenu
def createActions(self):
self.repeatAct = Qt.QAction('Repeat', self, triggered=self.repeatSong)
self.playOnceAct = Qt.QAction(
'Play once', self, triggered=self.playOnceSong)
self.shuffleAct = Qt.QAction(
'Shuffle', self, triggered=self.playlist.shuffle)
self.sequentialAct = Qt.QAction(
'Sequential', self, triggered=self.playSequential)
self.fileOpenAct = Qt.QAction('Open', self, triggered=self.open)
self.fileOpenAct.setShortcut('Ctrl+O')
self.fileCloseAct = Qt.QAction('Close', self, triggered=self.close)
self.fileCloseAct.setShortcut('Ctrl+Q')
def repeatSong(self):
self.playlist.setPlaybackMode(QMediaPlaylist.CurrentItemInLoop)
self.repeatButton.setEnabled(False)
self.playOnceButton.setEnabled(True)
def playOnceSong(self):
self.playlist.setPlaybackMode(QMediaPlaylist.Sequential)
self.playOnceButton.setEnabled(False)
self.repeatButton.setEnabled(True)
# unproperly used
def playSequential(self):
self.playlist.setPlaybackMode(QMediaPlaylist.Sequential)
# get and display song duration
def durationChanged(self, duration):
duration /= 1000
self.duration = duration
self.slider.setMaximum(duration)
# change slider position
def positionChanged(self, progress):
progress /= 1000
if not self.slider.isSliderDown():
self.slider.setValue(progress)
self.updateDurationInfo(progress)
def updateDurationInfo(self, currentInfo):
duration = self.duration
if currentInfo or duration:
currentTime = QtCore.QTime(
(currentInfo / 3600) % 60, # hours
(currentInfo / 60) % 60, # minutes
currentInfo % 60, # seconds
(currentInfo * 1000) % 1000) # miliseconds
totalTime = QtCore.QTime(
(duration / 3600) % 60, # hours
(duration / 60) % 60, # minutes
duration % 60, # seconds
(duration * 1000) % 1000) # miliseconds
formating = 'hh:mm:ss' if duration > 3600 else 'mm:ss'
toString = (currentTime.toString(formating) + ' / ' +
totalTime.toString(formating))
else:
toString = ''
self.labelDuration.setText(toString)
def metaDataChanged(self):
if self.player.isMetaDataAvailable():
self.setTrackInfo('{0} - {1}'.format(
self.player.metaData(Qt.QMediaMetaData.AlbumArtist),
self.player.metaData(Qt.QMediaMetaData.Title)))
def setTrackInfo(self, info):
self.trackInfo = info
if self.statusInfo:
self.setWindowTitle('{0} | {1}'.format(
self.trackInfo, self.statusInfo))
else:
self.setWindowTitle(self.trackInfo)
def playlistPositionChanged(self, position):
self.playlistView.setCurrentIndex(
self.playlistModel.index(position, 0))
def statusChanged(self, status):
self.handleCursor(status)
if status == QMediaPlayer.LoadingMedia:
self.setStatusInfo('Loading...')
elif status == QMediaPlayer.StalledMedia:
self.setStatusInfo('Media Stalled')
elif status == QMediaPlayer.EndOfMedia:
Qt.QApplication.alert(self)
elif status == QMediaPlayer.InvalidMedia:
self.displayErrorMessage()
else:
self.setStatusInfo('')
def handleCursor(self, status):
if status in [QMediaPlayer.LoadingMedia, QMediaPlayer.BufferingMedia,
QMediaPlayer.StalledMedia]:
self.setCursor(QtCore.Qt.BusyCursor)
else:
self.unsetCursor()
def setStatusInfo(self, info):
self.statusInfo = info
if self.statusInfo:
self.setWindowTitle('{0} | {1}'.format(
self.trackInfo, self.statusInfo))
else:
self.setWindowTitle(self.trackInfo)
def bufferingProgress(self, progress):
self.setStatusInfo('Buffering {0}'.format(progress))
def displayErrorMessage(self):
self.statusInfo(self.player.errorString())
def jump(self, index):
if index.isValid():
self.playlist.setCurrentIndex(index.row())
self.player.play()
def seek(self, seconds):
self.player.setPosition(seconds * 1000)
def previousAction(self):
self.playlist.previous()
def close(self):
choice = Qt.QMessageBox.question(
self,
'Close',
'Close the app?',
Qt.QMessageBox.Yes | Qt.QMessageBox.No)
if choice == Qt.QMessageBox.Yes:
sys.exit()
def open(self):
names, _ = Qt.QFileDialog.getOpenFileNames(self, 'Open Files')
# ['/home/milka/Documents/MusicPlayer/song.mp3']
self.addToPlaylist(names)
def addToPlaylist(self, names):
for name in names:
fileInfo = Qt.QFileInfo(name)
if fileInfo.exists():
url = QtCore.QUrl.fromLocalFile(fileInfo.absoluteFilePath())
# save_to_db song url
create_song(
url.path(), self.duration, playlist_name=self.name)
if fileInfo.suffix().lower() == 'm3u':
self.playlist.load(url)
else:
self.playlist.addMedia(Qt.QMediaContent(url))
else:
url = QtCore.QUrl(name)
if url.isValid():
self.playlist.addMedia(Qt.QMediaContent(url))
class Ui_MainWindow(QWidget):
def __init__(self, feature=feature):
super().__init__()
self.feature = feature
self.points_CAM1 = []
self.points_CAM2 = []
self.points_CAM3 = []
self.numWarning = 0
def setupUi(self, Form):
Form.setObjectName("Form")
Form.resize(1048, 375)
self.verticalLayout_4 = QtWidgets.QVBoxLayout(Form)
self.verticalLayout_4.setObjectName("verticalLayout_4")
self.tabWidget = QtWidgets.QTabWidget(Form)
self.tabWidget.setObjectName("tabWidget")
self.tab = QtWidgets.QWidget()
self.tab.setObjectName("tab")
# View CAM 1
self.gridLayout = QtWidgets.QGridLayout(self.tab)
self.gridLayout.setHorizontalSpacing(20)
self.gridLayout.setObjectName("gridLayout")
self.verticalLayout_3 = QtWidgets.QVBoxLayout()
self.verticalLayout_3.setSpacing(10)
self.verticalLayout_3.setObjectName("verticalLayout_3")
self.CAM1 = QtWidgets.QLabel(self.tab)
self.CAM1.setMinimumSize(QtCore.QSize(320, 240))
self.CAM1.setMaximumSize(QtCore.QSize(426, 400))
self.CAM1.setFrameShape(QtWidgets.QFrame.Box)
self.CAM1.setObjectName("CAM1")
self.verticalLayout_3.addWidget(self.CAM1)
self.horizontalLayout_6 = QtWidgets.QHBoxLayout()
self.horizontalLayout_6.setObjectName("horizontalLayout_6")
self.startCAM1 = QtWidgets.QPushButton(self.tab)
self.startCAM1.setObjectName("startCAM1")
self.horizontalLayout_6.addWidget(self.startCAM1)
self.carProtectionCAM1 = QtWidgets.QPushButton(self.tab)
self.carProtectionCAM1.setObjectName("carProtectionCAM1")
self.horizontalLayout_6.addWidget(self.carProtectionCAM1)
self.monitorAreaCAM1 = QtWidgets.QPushButton(self.tab)
self.monitorAreaCAM1.setObjectName("monitorAreaCAM1")
self.horizontalLayout_6.addWidget(self.monitorAreaCAM1)
self.verticalLayout_3.addLayout(self.horizontalLayout_6)
self.horizontalLayout_7 = QtWidgets.QHBoxLayout()
self.horizontalLayout_7.setObjectName("horizontalLayout_7")
self.stopCAM1 = QtWidgets.QPushButton(self.tab)
self.stopCAM1.setEnabled(False)
self.stopCAM1.setObjectName("stopCAM1")
self.horizontalLayout_7.addWidget(self.stopCAM1)
self.personSearchingCAM1 = QtWidgets.QPushButton(self.tab)
self.personSearchingCAM1.setObjectName("personSearchingCAM1")
self.horizontalLayout_7.addWidget(self.personSearchingCAM1)
self.illegalCAM1 = QtWidgets.QPushButton(self.tab)
self.illegalCAM1.setObjectName("illegalCAM1")
self.horizontalLayout_7.addWidget(self.illegalCAM1)
self.verticalLayout_3.addLayout(self.horizontalLayout_7)
self.gridLayout.addLayout(self.verticalLayout_3, 0, 0, 1, 1)
self.verticalLayout = QtWidgets.QVBoxLayout()
self.verticalLayout.setSpacing(10)
self.verticalLayout.setObjectName("verticalLayout")
# View CAM 2
self.CAM2 = QtWidgets.QLabel(self.tab)
self.CAM2.setMinimumSize(QtCore.QSize(320, 240))
self.CAM2.setMaximumSize(QtCore.QSize(426, 400))
self.CAM2.setFrameShape(QtWidgets.QFrame.Box)
self.CAM2.setObjectName("CAM2")
self.verticalLayout.addWidget(self.CAM2)
self.horizontalLayout_2 = QtWidgets.QHBoxLayout()
self.horizontalLayout_2.setObjectName("horizontalLayout_2")
self.startCAM2 = QtWidgets.QPushButton(self.tab)
self.startCAM2.setObjectName("startCAM2")
self.horizontalLayout_2.addWidget(self.startCAM2)
self.carProtectionCAM2 = QtWidgets.QPushButton(self.tab)
self.carProtectionCAM2.setObjectName("carProtectionCAM2")
self.horizontalLayout_2.addWidget(self.carProtectionCAM2)
self.monitorAreaCAM2 = QtWidgets.QPushButton(self.tab)
self.monitorAreaCAM2.setObjectName("monitorAreaCAM2")
self.horizontalLayout_2.addWidget(self.monitorAreaCAM2)
self.verticalLayout.addLayout(self.horizontalLayout_2)
self.horizontalLayout_3 = QtWidgets.QHBoxLayout()
self.horizontalLayout_3.setObjectName("horizontalLayout_3")
self.stopCAM2 = QtWidgets.QPushButton(self.tab)
self.stopCAM2.setEnabled(False)
self.stopCAM2.setObjectName("stopCAM2")
self.horizontalLayout_3.addWidget(self.stopCAM2)
self.personSearchingCAM2 = QtWidgets.QPushButton(self.tab)
self.personSearchingCAM2.setObjectName("personSearchingCAM2")
self.horizontalLayout_3.addWidget(self.personSearchingCAM2)
self.illegalCAM2 = QtWidgets.QPushButton(self.tab)
self.illegalCAM2.setObjectName("illegalCAM2")
self.horizontalLayout_3.addWidget(self.illegalCAM2)
self.verticalLayout.addLayout(self.horizontalLayout_3)
self.gridLayout.addLayout(self.verticalLayout, 0, 1, 1, 1)
self.verticalLayout_2 = QtWidgets.QVBoxLayout()
self.verticalLayout_2.setSpacing(10)
self.verticalLayout_2.setObjectName("verticalLayout_2")
# View CAM 3
self.CAM3 = QtWidgets.QLabel(self.tab)
self.CAM3.setMinimumSize(QtCore.QSize(320, 240))
self.CAM3.setMaximumSize(QtCore.QSize(426, 400))
self.CAM3.setFrameShape(QtWidgets.QFrame.Box)
self.CAM3.setObjectName("CAM3")
self.verticalLayout_2.addWidget(self.CAM3)
self.horizontalLayout_4 = QtWidgets.QHBoxLayout()
self.horizontalLayout_4.setObjectName("horizontalLayout_4")
self.startCAM3 = QtWidgets.QPushButton(self.tab)
self.startCAM3.setObjectName("startCAM3")
self.horizontalLayout_4.addWidget(self.startCAM3)
self.carProtectionCAM3 = QtWidgets.QPushButton(self.tab)
self.carProtectionCAM3.setObjectName("carProtectionCAM3")
self.horizontalLayout_4.addWidget(self.carProtectionCAM3)
self.monitorAreaCAM3 = QtWidgets.QPushButton(self.tab)
self.monitorAreaCAM3.setObjectName("monitorAreaCAM3")
self.horizontalLayout_4.addWidget(self.monitorAreaCAM3)
self.verticalLayout_2.addLayout(self.horizontalLayout_4)
self.horizontalLayout_5 = QtWidgets.QHBoxLayout()
self.horizontalLayout_5.setObjectName("horizontalLayout_5")
self.stopCAM3 = QtWidgets.QPushButton(self.tab)
self.stopCAM3.setEnabled(False)
self.stopCAM3.setObjectName("stopCAM3")
self.horizontalLayout_5.addWidget(self.stopCAM3)
self.personSearchingCAM3 = QtWidgets.QPushButton(self.tab)
self.personSearchingCAM3.setObjectName("personSearchingCAM3")
self.horizontalLayout_5.addWidget(self.personSearchingCAM3)
self.illegalCAM3 = QtWidgets.QPushButton(self.tab)
self.illegalCAM3.setObjectName("illegalCAM3")
self.horizontalLayout_5.addWidget(self.illegalCAM3)
self.verticalLayout_2.addLayout(self.horizontalLayout_5)
self.gridLayout.addLayout(self.verticalLayout_2, 0, 2, 1, 1)
self.tabWidget.addTab(self.tab, "")
# Media Tab
self.tab_2 = QtWidgets.QWidget()
self.tab_2.setObjectName("tab_2")
self.tabWidget.addTab(self.tab_2, "")
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
videowidget = QVideoWidget()
self.openBtn = QtWidgets.QPushButton('Open Video')
self.playBtn = QtWidgets.QPushButton()
self.playBtn.setEnabled(False)
self.playBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.stopBtn = QtWidgets.QPushButton()
self.stopBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaStop))
self.slowBtn = QtWidgets.QPushButton()
self.slowBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaSeekBackward))
self.fastBtn = QtWidgets.QPushButton()
self.fastBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaSeekForward))
self.volumeBtn = QtWidgets.QPushButton()
self.volumeBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaVolume))
self.fullscreenBtn = QPushButton("Full Screen")
self.slider = QSlider(Qt.Horizontal)
self.slider.setRange(0, 0)
self.volume_slider = QSlider(Qt.Horizontal)
self.volume_slider.setRange(0, 100)
self.volume_slider.setValue(100)
self.label_2_1 = QLabel()
self.label_2_1.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
self.label_2_2 = QLabel()
hboxLayout_2_1 = QHBoxLayout()
hboxLayout_2_2 = QHBoxLayout()
hboxLayout_2_3 = QHBoxLayout()
hboxLayout_2_1.addWidget(self.slider)
hboxLayout_2_2.addWidget(self.openBtn)
hboxLayout_2_2.addWidget(self.stopBtn)
hboxLayout_2_2.addWidget(self.slowBtn)
hboxLayout_2_2.addWidget(self.playBtn)
hboxLayout_2_2.addWidget(self.fastBtn)
hboxLayout_2_2.addWidget(self.volumeBtn)
hboxLayout_2_2.addWidget(self.volume_slider)
hboxLayout_2_2.addStretch(1)
hboxLayout_2_2.addWidget(self.fullscreenBtn)
hboxLayout_2_3.addWidget(videowidget)
vboxLayout_2_1 = QVBoxLayout()
vboxLayout_2_1.addLayout(hboxLayout_2_3)
vboxLayout_2_1.addLayout(hboxLayout_2_1)
vboxLayout_2_1.addLayout(hboxLayout_2_2)
vboxLayout_2_1.addWidget(self.label_2_1)
self.tab_2.setLayout(vboxLayout_2_1)
# Setting CAM 1
self.tab_3 = QtWidgets.QWidget()
self.tab_3.setObjectName("tab_3")
self.gridLayout_2 = QtWidgets.QGridLayout(self.tab_3)
self.gridLayout_2.setHorizontalSpacing(20)
self.gridLayout_2.setObjectName("gridLayout_2")
self.verticalLayout_5 = QtWidgets.QVBoxLayout()
self.verticalLayout_5.setSpacing(10)
self.verticalLayout_5.setObjectName("verticalLayout_5")
self.CAM1_draw = QtWidgets.QLabel(self.tab_3)
self.CAM1_draw.setMinimumSize(QtCore.QSize(320, 240))
self.CAM1_draw.setMaximumSize(QtCore.QSize(426, 400))
self.CAM1_draw.setFrameShape(QtWidgets.QFrame.Box)
self.CAM1_draw.setObjectName("CAM1_draw")
self.verticalLayout_5.addWidget(self.CAM1_draw)
self.horizontalLayout_8 = QtWidgets.QHBoxLayout()
self.horizontalLayout_8.setObjectName("horizontalLayout_8")
self.drawCAM1 = QtWidgets.QPushButton(self.tab_3)
self.drawCAM1.setObjectName("drawCAM1")
self.horizontalLayout_8.addWidget(self.drawCAM1)
self.removeCAM1 = QtWidgets.QPushButton(self.tab_3)
self.removeCAM1.setObjectName("removeCAM1")
self.horizontalLayout_8.addWidget(self.removeCAM1)
self.verticalLayout_5.addLayout(self.horizontalLayout_8)
self.gridLayout_2.addLayout(self.verticalLayout_5, 0, 0, 1, 1)
self.verticalLayout_6 = QtWidgets.QVBoxLayout()
self.verticalLayout_6.setSpacing(10)
self.verticalLayout_6.setObjectName("verticalLayout_6")
# Setting CAM 2
self.CAM2_draw = QtWidgets.QLabel(self.tab_3)
self.CAM2_draw.setMinimumSize(QtCore.QSize(320, 240))
self.CAM2_draw.setMaximumSize(QtCore.QSize(426, 400))
self.CAM2_draw.setFrameShape(QtWidgets.QFrame.Box)
self.CAM2_draw.setObjectName("CAM2_draw")
self.verticalLayout_6.addWidget(self.CAM2_draw)
self.horizontalLayout_10 = QtWidgets.QHBoxLayout()
self.horizontalLayout_10.setObjectName("horizontalLayout_10")
self.drawCAM2 = QtWidgets.QPushButton(self.tab_3)
self.drawCAM2.setObjectName("drawCAM2")
self.horizontalLayout_10.addWidget(self.drawCAM2)
self.removeCAM2 = QtWidgets.QPushButton(self.tab_3)
self.removeCAM2.setObjectName("removeCAM2")
self.horizontalLayout_10.addWidget(self.removeCAM2)
self.verticalLayout_6.addLayout(self.horizontalLayout_10)
self.gridLayout_2.addLayout(self.verticalLayout_6, 0, 1, 1, 1)
self.verticalLayout_7 = QtWidgets.QVBoxLayout()
self.verticalLayout_7.setSpacing(10)
self.verticalLayout_7.setObjectName("verticalLayout_7")
# Setting CAM 3
self.CAM3_draw = QtWidgets.QLabel(self.tab_3)
self.CAM3_draw.setMinimumSize(QtCore.QSize(320, 240))
self.CAM3_draw.setMaximumSize(QtCore.QSize(426, 400))
self.CAM3_draw.setFrameShape(QtWidgets.QFrame.Box)
self.CAM3_draw.setObjectName("CAM3_draw")
self.verticalLayout_7.addWidget(self.CAM3_draw)
self.horizontalLayout_12 = QtWidgets.QHBoxLayout()
self.horizontalLayout_12.setObjectName("horizontalLayout_12")
self.drawCAM3 = QtWidgets.QPushButton(self.tab_3)
self.drawCAM3.setObjectName("drawCAM3")
self.horizontalLayout_12.addWidget(self.drawCAM3)
self.removeCAM3 = QtWidgets.QPushButton(self.tab_3)
self.removeCAM3.setObjectName("removeCAM3")
self.horizontalLayout_12.addWidget(self.removeCAM3)
self.verticalLayout_7.addLayout(self.horizontalLayout_12)
self.gridLayout_2.addLayout(self.verticalLayout_7, 0, 2, 1, 1)
self.tabWidget.addTab(self.tab_3, "")
self.verticalLayout_4.addWidget(self.tabWidget)
# Setup Connect
# Setup enable
self.removeCAM1.setEnabled(False)
self.removeCAM2.setEnabled(False)
self.removeCAM3.setEnabled(False)
# Setup choosing feature
self.carProtectionCAM1.setVisible(self.feature['car1'])
self.carProtectionCAM2.setVisible(self.feature['car2'])
self.carProtectionCAM3.setVisible(self.feature['car3'])
self.illegalCAM1.setVisible(self.feature['illegal1'])
self.illegalCAM2.setVisible(self.feature['illegal2'])
self.illegalCAM3.setVisible(self.feature['illegal3'])
self.monitorAreaCAM1.setVisible(self.feature['mpa1'])
self.monitorAreaCAM1.toggle()
self.monitorAreaCAM1.setCheckable(True)
self.monitorAreaCAM2.setVisible(self.feature['mpa2'])
self.monitorAreaCAM3.setVisible(self.feature['mpa3'])
self.personSearchingCAM1.setVisible(self.feature['person1'])
self.personSearchingCAM2.setVisible(self.feature['person2'])
self.personSearchingCAM3.setVisible(self.feature['person3'])
# setup media player
self.mediaPlayer.setVideoOutput(videowidget)
self.openBtn.clicked.connect(self.open_file)
self.playBtn.clicked.connect(self.play_video)
self.stopBtn.clicked.connect(self.stop_video)
self.fastBtn.clicked.connect(self.fast)
self.slowBtn.clicked.connect(self.slow)
self.volumeBtn.clicked.connect(self.mute)
self.fullscreenBtn.clicked.connect(self.fullscreen)
self.volume_slider.sliderMoved.connect(self.set_volume)
self.slider.sliderMoved.connect(self.set_position)
self.mediaPlayer.stateChanged.connect(self.mediastate_changed)
self.mediaPlayer.positionChanged.connect(self.position_changed)
self.mediaPlayer.durationChanged.connect(self.duration_changed)
# setup image processing
# create a timer
self.timer = QTimer()
self.timer2 = QTimer()
self.timer3 = QTimer()
# set timer timeout callback function
self.timer.timeout.connect(self.viewCam1)
self.startCAM1.clicked.connect(self.start_view1)
self.stopCAM1.clicked.connect(self.stop_view1)
self.timer2.timeout.connect(self.viewCam2)
self.startCAM2.clicked.connect(self.start_view2)
self.stopCAM2.clicked.connect(self.stop_view2)
self.timer3.timeout.connect(self.viewCam3)
self.startCAM3.clicked.connect(self.start_view3)
self.stopCAM3.clicked.connect(self.stop_view3)
self.CAM1_draw.mousePressEvent = self.mouseEventCAM1
self.CAM2_draw.mousePressEvent = self.mouseEventCAM2
self.CAM3_draw.mousePressEvent = self.mouseEventCAM3
self.drawCAM1.clicked.connect(self.startDrawAreaCAM1)
self.removeCAM1.clicked.connect(self.removeAreaCAM1)
self.drawCAM2.clicked.connect(self.startDrawAreaCAM2)
self.removeCAM2.clicked.connect(self.removeAreaCAM2)
self.drawCAM3.clicked.connect(self.startDrawAreaCAM3)
self.removeCAM3.clicked.connect(self.removeAreaCAM3)
self.retranslateUi(Form)
self.tabWidget.setCurrentIndex(0)
QtCore.QMetaObject.connectSlotsByName(Form)
# All function
# Function retranslateUI
def retranslateUi(self, Form):
_translate = QtCore.QCoreApplication.translate
Form.setWindowTitle(_translate("Form", "Form"))
self.CAM1.setText(_translate("Form", "IP CAM 1"))
self.startCAM1.setText(_translate("Form", "Start"))
self.carProtectionCAM1.setText(_translate("Form", "Car protection"))
self.monitorAreaCAM1.setText(
_translate("Form", "Monitor prohibited area"))
self.stopCAM1.setText(_translate("Form", "Stop"))
self.personSearchingCAM1.setText(_translate("Form",
"Person searching"))
self.illegalCAM1.setText(_translate("Form", "Illegal access action"))
self.CAM2.setText(_translate("Form", "IP CAM 2"))
self.startCAM2.setText(_translate("Form", "Start"))
self.carProtectionCAM2.setText(_translate("Form", "Car protection"))
self.monitorAreaCAM2.setText(
_translate("Form", "Monitor prohibited area"))
self.stopCAM2.setText(_translate("Form", "Stop"))
self.personSearchingCAM2.setText(_translate("Form",
"Person searching"))
self.illegalCAM2.setText(_translate("Form", "Illegal access action"))
self.CAM3.setText(_translate("Form", "IP CAM 3"))
self.startCAM3.setText(_translate("Form", "Start"))
self.carProtectionCAM3.setText(_translate("Form", "Car protection"))
self.monitorAreaCAM3.setText(
_translate("Form", "Monitor prohibited area"))
self.stopCAM3.setText(_translate("Form", "Stop"))
self.personSearchingCAM3.setText(_translate("Form",
"Person searching"))
self.illegalCAM3.setText(_translate("Form", "Illegal access action"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab),
_translate("Form", "3 IP CAMs"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_2),
_translate("Form", "PLAY RECORD"))
self.CAM1_draw.setText(_translate("Form", "TextLabel"))
self.drawCAM1.setText(_translate("Form", "Draw"))
self.removeCAM1.setText(_translate("Form", "Clear"))
self.CAM2_draw.setText(_translate("Form", "TextLabel"))
self.drawCAM2.setText(_translate("Form", "Draw"))
self.removeCAM2.setText(_translate("Form", "Clear"))
self.CAM3_draw.setText(_translate("Form", "TextLabel"))
self.drawCAM3.setText(_translate("Form", "Draw"))
self.removeCAM3.setText(_translate("Form", "Clear"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_3),
_translate("Form", "SETTING"))
# Function for media player
def open_file(self):
filename, _ = QFileDialog.getOpenFileName(self, "Open Video")
if filename != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(filename)))
self.playBtn.setEnabled(True)
def play_video(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def stop_video(self):
self.mediaPlayer.stop()
def mediastate_changed(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def position_changed(self, position):
self.slider.setValue(position)
def duration_changed(self, duration):
self.slider.setRange(0, duration)
def set_position(self, position):
self.mediaPlayer.setPosition(position)
print(position)
def set_volume(self, volume):
self.mediaPlayer.setVolume(volume)
def mute(self):
if not self.mediaPlayer.isMuted():
self.mediaPlayer.setMuted(True)
self.volumeBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaVolumeMuted))
else:
self.mediaPlayer.setMuted(False)
self.volumeBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaVolume))
def handle_errors(self):
self.playBtn.setEnabled(False)
self.label.setText("Error: " + self.mediaPlayer.errorString())
self.startCAM1.clicked.connect(self.start)
self.stopCAM1.clicked.connect(self.stop)
def fullscreen(self):
if self.windowState() & Qt.WindowFullScreen:
QApplication.setOverrideCursor(Qt.ArrowCursor)
self.showNormal()
print("no Fullscreen")
else:
Form.showFullScreen()
QApplication.setOverrideCursor(Qt.BlankCursor)
print("Fullscreen entered")
def fast(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() + 10 * 60)
def slow(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() - 10 * 60)
# Function for image processing
def image_to_QImage(self, image, label: QLabel):
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image = cv2.resize(image, (label.width(), label.height()))
height, width, channel = image.shape
step = channel * width
return QImage(image.data, width, height, step, QImage.Format_RGB888)
def start_view1(self):
self.stopCAM1.setEnabled(True)
self.startCAM1.setEnabled(False)
self.vs1 = VideoStream(src=IP_CAM_ADDRESS['CAM1'])
self.flag_CAM1 = self.vs1.flag
if self.vs1.flag:
self.vs1.start()
now = datetime.now()
self.savePath1 = self.createDir('IP_CAM_1')
self.startTime1 = str(now.day) + ' - ' + str(now.hour) + 'h' + str(
now.minute) + ' - '
fourcc = cv2.VideoWriter_fourcc(*'XVID')
self.outVivdeo = cv2.VideoWriter(
self.savePath1 + 'output.avi', fourcc, 30,
(int(self.vs1.stream.get(3)), int(self.vs1.stream.get(4))))
self.timer.start(20)
else:
self.startCAM1.setEnabled(True)
self.stopCAM1.setEnabled(False)
image = cv2.imread('no-connection.jpg')
self.CAM1.setPixmap(
QPixmap.fromImage(self.image_to_QImage(image, self.CAM1)))
def viewCam1(self):
image = self.vs1.read()
self.outVivdeo.write(image)
self.CAM1.setPixmap(
QPixmap.fromImage(self.image_to_QImage(image, self.CAM1)))
if self.feature['mpa1'] and self.monitorAreaCAM1.isChecked():
image, self.numWarning = detectObject(image,
self.points_CAM1,
flag_Warning=1,
numWarning=self.numWarning)
self.CAM1_draw.setPixmap(
QPixmap.fromImage(
self.image_to_QImage(
self.drawArea(image, self.points_CAM1, self.CAM1_draw),
self.CAM1_draw)))
def stop_view1(self):
self.startCAM1.setEnabled(True)
self.stopCAM1.setEnabled(False)
self.timer.stop()
self.vs1.stop()
image = cv2.imread('stopVideo.png')
self.CAM1.setPixmap(
QPixmap.fromImage(self.image_to_QImage(image, self.CAM1)))
now = datetime.now()
fileName = self.startTime1 + str(now.hour) + 'h' + str(
now.minute) + '.avi'
os.rename(self.savePath1 + 'output.avi', self.savePath1 + fileName)
def start_view2(self):
self.stopCAM2.setEnabled(True)
self.startCAM2.setEnabled(False)
self.vs2 = VideoStream(src=IP_CAM_ADDRESS['CAM2'])
print('ok')
if self.vs2.flag:
self.vs2.start()
now = datetime.now()
self.savePath2 = self.createDir('IP_CAM_2')
self.startTime2 = str(now.day) + ' - ' + str(now.hour) + 'h' + str(
now.minute) + ' - '
fourcc = cv2.VideoWriter_fourcc(*'XVID')
self.outVivdeo2 = cv2.VideoWriter(
self.savePath2 + 'output2.avi', fourcc, 30,
(int(self.vs2.stream.get(3)), int(self.vs2.stream.get(4))))
self.timer2.start(20)
else:
self.startCAM2.setEnabled(True)
self.stopCAM2.setEnabled(False)
image = cv2.imread('no-connection.jpg')
self.CAM2.setPixmap(
QPixmap.fromImage(self.image_to_QImage(image, self.CAM2)))
def viewCam2(self):
image = self.vs2.read()
self.outVivdeo2.write(image)
self.CAM2.setPixmap(
QPixmap.fromImage(self.image_to_QImage(image, self.CAM2)))
def stop_view2(self):
self.startCAM2.setEnabled(True)
self.stopCAM2.setEnabled(False)
self.timer2.stop()
self.vs2.stop()
image = cv2.imread('stopVideo.png')
self.CAM2.setPixmap(
QPixmap.fromImage(self.image_to_QImage(image, self.CAM2)))
now = datetime.now()
fileName = self.startTime2 + str(now.hour) + 'h' + str(
now.minute) + '.avi'
os.rename(self.savePath2 + 'output2.avi', self.savePath2 + fileName)
# def viewCam(self):
# # while True:
# ret, image = self.cap.read()
# self.outVivdeo.write(image)
# self.CAM1.setPixmap(QPixmap.fromImage(self.image_to_QImage(image, self.CAM1)))
# if self.feature['mpa1'] and self.monitorAreaCAM1.isChecked():
# image, self.numWarning = detectObject(image, self.points_CAM1, flag_Warning=1, numWarning=self.numWarning)
# self.CAM1_draw.setPixmap(QPixmap.fromImage(self.image_to_QImage(self.drawArea(image, self.points_CAM1, self.CAM1_draw), self.CAM1_draw)))
# def start_view(self):
# self.stopCAM1.setEnabled(True)
# self.startCAM1.setEnabled(False)
# self.cap = cv2.VideoCapture(IP_CAM_ADDRESS['CAM1'])
# self.flag_CAM1 = self.cap.isOpened()
# if self.cap.isOpened():
# now = datetime.now()
# self.savePath1 = self.createDir('IP_CAM_1')
# self.startTime1 = str(now.day)+' - '+str(now.hour)+'h'+str(now.minute)+ ' - '
# fourcc = cv2.VideoWriter_fourcc(*'XVID')
# self.outVivdeo = cv2.VideoWriter(self.savePath1+'output.avi', fourcc, 30, (int(self.cap.get(3)), int(self.cap.get(4))))
# self.timer.start(0)
# else:
# self.startCAM1.setEnabled(True)
# self.stopCAM1.setEnabled(False)
# image = cv2.imread('no-connection.jpg')
# self.CAM1.setPixmap(QPixmap.fromImage(self.image_to_QImage(image, self.CAM1)))
# def stop_view(self):
# self.startCAM1.setEnabled(True)
# self.stopCAM1.setEnabled(False)
# self.timer.stop()
# self.cap.release()
# self.outVivdeo.release()
# print("ok")
# image = cv2.imread('stopVideo.png')
# self.CAM1.setPixmap(QPixmap.fromImage(self.image_to_QImage(image, self.CAM1)))
# print('ok2')
# now = datetime.now()
# fileName = self.startTime1+str(now.hour)+'h'+str(now.minute)+'.avi'
# os.rename(self.savePath1+'output.avi', self.savePath1+fileName)
# def viewCam2(self):
# ret, image = self.cap2.read()
# self.outVivdeo2.write(image)
# self.CAM2_draw.setPixmap(QPixmap.fromImage(self.image_to_QImage(self.drawArea(image, self.points_CAM2, self.CAM2_draw), self.CAM2_draw)))
# self.CAM2.setPixmap(QPixmap.fromImage(self.image_to_QImage(image, self.CAM2)))
# def start_view2(self):
# if not self.timer2.isActive():
# self.stopCAM2.setEnabled(True)
# self.startCAM2.setEnabled(False)
# self.cap2 = cv2.VideoCapture(IP_CAM_ADDRESS['CAM2'])
# self.flag_CAM2 = self.cap2.isOpened()
# if self.cap2.isOpened():
# now = datetime.now()
# self.savePath2 = self.createDir('IP_CAM_2')
# self.startTime2 = str(now.day)+' - '+str(now.hour)+'h'+str(now.minute)+ ' - '
# # fourcc = cv2.VideoWriter_fourcc(*'mp4v')
# fourcc = cv2.VideoWriter_fourcc(*'XVID')
# self.outVivdeo2 = cv2.VideoWriter(self.savePath2+'output2.avi', fourcc, 30, (int(self.cap2.get(3)), int(self.cap2.get(4))))
# self.timer2.start(0)
# else:
# self.startCAM2.setEnabled(True)
# self.stopCAM2.setEnabled(False)
# image = cv2.imread('no-connection.jpg')
# self.CAM2.setPixmap(QPixmap.fromImage(self.image_to_QImage(image, self.CAM2)))
# def stop_view2(self):
# self.startCAM2.setEnabled(True)
# self.stopCAM2.setEnabled(False)
# self.timer2.stop()
# self.outVivdeo2.release()
# image = cv2.imread('stopVideo.png')
# self.CAM2.setPixmap(QPixmap.fromImage(self.image_to_QImage(image, self.CAM2)))
# self.cap2.release()
# now = datetime.now()
# fileName = self.startTime2+str(now.hour)+'h'+str(now.minute)+'.avi'
# os.rename(self.savePath2+'output2.avi', self.savePath2+fileName)
def viewCam3(self):
ret, image = self.cap3.read()
self.outVivdeo3.write(image)
self.CAM3_draw.setPixmap(
QPixmap.fromImage(
self.image_to_QImage(
self.drawArea(image, self.points_CAM3, self.CAM3_draw),
self.CAM3_draw)))
self.CAM3.setPixmap(
QPixmap.fromImage(self.image_to_QImage(image, self.CAM3)))
def start_view3(self):
if not self.timer3.isActive():
self.stopCAM3.setEnabled(True)
self.startCAM3.setEnabled(False)
self.cap3 = cv2.VideoCapture(IP_CAM_ADDRESS['CAM3'])
self.flag_CAM3 = self.cap3.isOpened()
if self.cap3.isOpened():
now = datetime.now()
self.savePath3 = self.createDir('IP_CAM_3')
self.startTime3 = str(now.day) + ' - ' + str(
now.hour) + 'h' + str(now.minute) + ' - '
# fourcc = cv2.VideoWriter_fourcc(*'mp4v')
fourcc = cv2.VideoWriter_fourcc(*'XVID')
self.outVivdeo3 = cv2.VideoWriter(
self.savePath3 + 'output3.avi', fourcc, 30,
(int(self.cap3.get(3)), int(self.cap3.get(4))))
self.timer3.start(0)
else:
self.startCAM3.setEnabled(True)
self.stopCAM3.setEnabled(False)
image = cv2.imread('no-connection.jpg')
self.CAM3.setPixmap(
QPixmap.fromImage(self.image_to_QImage(image, self.CAM3)))
def stop_view3(self):
self.startCAM3.setEnabled(True)
self.stopCAM3.setEnabled(False)
self.timer3.stop()
self.outVivdeo3.release()
image = cv2.imread('stopVideo.png')
self.CAM3.setPixmap(
QPixmap.fromImage(self.image_to_QImage(image, self.CAM3)))
self.cap3.release()
now = datetime.now()
fileName = self.startTime3 + str(now.hour) + 'h' + str(
now.minute) + '.avi'
os.rename(self.savePath3 + 'output3.avi', self.savePath3 + fileName)
def createDir(self, IP_CAM_Number: str):
now = datetime.now()
year = now.year
month = MONTH[now.month]
curPath = os.getcwd()
if not path.exists(curPath + '/IVA'):
os.mkdir(curPath + '/IVA')
if not path.exists(curPath + '/IVA/' + IP_CAM_Number):
os.mkdir(curPath + '/IVA/' + IP_CAM_Number)
# check path exists
if path.exists(curPath + '/IVA/' + IP_CAM_Number + '/' + str(year)):
if path.exists(curPath + '/IVA/' + IP_CAM_Number + '/' +
str(year) + '/' + month):
return curPath + '/IVA/' + IP_CAM_Number + '/' + str(
year) + '/' + month + '/'
else:
os.mkdir(curPath + '/IVA/' + IP_CAM_Number + '/' + str(year) +
'/' + month)
return curPath + '/IVA/' + IP_CAM_Number + '/' + str(
year) + '/' + month + '/'
else:
os.mkdir(curPath + '/IVA/' + IP_CAM_Number + '/' + str(year))
if path.exists(curPath + '/IVA/' + IP_CAM_Number + '/' +
str(year) + '/' + month):
return curPath + '/IVA/' + IP_CAM_Number + '/' + str(
year) + '/' + month + '/'
else:
os.mkdir(curPath + '/IVA/' + IP_CAM_Number + '/' + str(year) +
'/' + month)
return curPath + '/IVA/' + IP_CAM_Number + '/' + str(
year) + '/' + month + '/'
# Create Mouse Event for draw protected area
def mouseEventCAM1(self, event):
if self.removeCAM1.isEnabled() and (
not self.startCAM1.isEnabled()) and self.flag_CAM1 == True:
# print(self.CAM1_draw.width(), self.CAM1_draw.height())
x = event.pos().x()
y = event.pos().y()
print(x, y)
x = round((x / self.CAM1_draw.width()), 10)
y = round((y / self.CAM1_draw.height()), 10)
self.points_CAM1.append([x, y])
print("Position clicked is ({}, {})".format(
int(x * self.CAM1_draw.width()),
int(y * self.CAM1_draw.height())))
# print(self.points_CAM1)
def mouseEventCAM2(self, event):
if self.removeCAM2.isEnabled() and (
not self.startCAM2.isEnabled()) and self.flag_CAM2 == True:
x = event.pos().x()
y = event.pos().y()
self.points_CAM2.append([x, y])
print("Position clicked is ({}, {})".format(x, y))
def mouseEventCAM3(self, event):
if self.removeCAM3.isEnabled() and (
not self.startCAM3.isEnabled()) and self.flag_CAM3 == True:
x = event.pos().x()
y = event.pos().y()
self.points_CAM3.append([x, y])
print("Position clicked is ({}, {})".format(x, y))
def startDrawAreaCAM1(self):
self.drawCAM1.setEnabled(False)
self.removeCAM1.setEnabled(True)
def removeAreaCAM1(self):
while len(self.points_CAM1):
self.points_CAM1.pop()
self.drawCAM1.setEnabled(True)
self.removeCAM1.setEnabled(False)
def startDrawAreaCAM2(self):
self.drawCAM2.setEnabled(False)
self.removeCAM2.setEnabled(True)
def removeAreaCAM2(self):
while len(self.points_CAM2):
self.points_CAM2.pop()
self.drawCAM2.setEnabled(True)
self.removeCAM2.setEnabled(False)
def startDrawAreaCAM3(self):
self.drawCAM3.setEnabled(False)
self.removeCAM3.setEnabled(True)
def removeAreaCAM3(self):
while len(self.points_CAM3):
self.points_CAM3.pop()
self.drawCAM3.setEnabled(True)
self.removeCAM3.setEnabled(False)
def drawArea(self, image, points: list, qlabel: QtWidgets.QLabel):
image_draw = image.copy()
(width, height) = image.shape[:2]
image_draw = cv2.resize(image_draw, (qlabel.width(), qlabel.height()))
if len(points) > 1:
point1 = []
for point in points:
x = int(point[0] * qlabel.width())
y = int(point[1] * qlabel.height())
point1.append((x, y))
cv2.polylines(image_draw, np.array([point1]), 1, (255, 0, 0), 1)
b, g, r = cv2.split(image_draw)
cv2.fillPoly(b, np.array([point1]), (0, 255, 0))
cv2.fillPoly(r, np.array([point1]), (0, 255, 0))
image_draw = cv2.merge([b, g, r])
return image_draw
# Function for IVA tasks
def monitorProhibitedArea(self, frame, points: list, flag_Warning: int):
pass
class Player(QWidget):
audio_path = "audio"
lyrics_path = "lyrics"
timings_path = os.path.join("lyrics", "timing")
settings_path = "settings.json"
fullScreenChanged = pyqtSignal(bool)
def __init__(self, parent=None):
super(Player, self).__init__(parent)
self.setWindowTitle("SongScreen")
self.setFocusPolicy(Qt.StrongFocus)
self.colorDialog = None
self.trackInfo = ""
self.statusInfo = ""
self.duration = 0
self.player = QMediaPlayer()
self.playlist = QMediaPlaylist()
self.player.setPlaylist(self.playlist)
self.player.durationChanged.connect(self.durationChanged)
self.player.positionChanged.connect(self.positionChanged)
self.player.metaDataChanged.connect(self.metaDataChanged)
# self.playlist.currentIndexChanged.connect(self.playlistPositionChanged)
self.player.mediaStatusChanged.connect(self.statusChanged)
self.player.bufferStatusChanged.connect(self.bufferingProgress)
self.player.videoAvailableChanged.connect(self.videoAvailableChanged)
self.player.error.connect(self.displayErrorMessage)
# self.videoWidget = VideoWidget()
# self.player.setVideoOutput(self.videoWidget)
self.slider = MediaProgressWidget() # QSlider(Qt.Horizontal)
self.markers = []
self.songtext_widget = SongTextWidget()
self.songtext_widget.show()
# self.playlistModel = PlaylistModel()
# self.playlistModel.setPlaylist(self.playlist)
#
# self.playlistView = QListView()
# self.playlistView.setModel(self.playlistModel)
# self.playlistView.setCurrentIndex(
# self.playlistModel.index(self.playlist.currentIndex(), 0))
#
# self.playlistView.activated.connect(self.jump)
self.slider.setRange(0, self.player.duration() / 1000)
self.labelDuration = QLabel()
self.slider.sliderMoved.connect(self.seek)
# openButton = QPushButton("Open", clicked=self.open)
controls = PlayerControlsWidget()
controls.setState(self.player.state())
controls.setVolume(self.player.volume())
# controls.setMuted(controls.isMuted())
controls.play.connect(self.player.play)
controls.pause.connect(self.player.pause)
controls.stop.connect(self.stop_clicked)
# controls.stop.connect(self.videoWidget.update)
# controls.next.connect(self.playlist.next)
# controls.previous.connect(self.previousClicked)
controls.changeVolume.connect(self.player.setVolume)
# controls.changeMuting.connect(self.player.setMuted)
# controls.changeRate.connect(self.player.setPlaybackRate)
self.player.stateChanged.connect(controls.setState)
self.player.stateChanged.connect(self.setState)
self.player.volumeChanged.connect(controls.setVolume)
# self.player.mutedChanged.connect(controls.setMuted)
# self.fullScreenButton = QPushButton("FullScreen")
# self.fullScreenButton.setCheckable(True)
#
# self.colorButton = QPushButton("Color Options...")
# self.colorButton.setEnabled(False)
# self.colorButton.clicked.connect(self.showColorDialog)
displayLayout = QHBoxLayout()
# displayLayout.addWidget(self.videoWidget, 2)
# displayLayout.addWidget(self.songtext_widget)
# displayLayout.addWidget(self.playlistView)
self.song_select_widget = SongSelectWidget()
self.song_select_widget.song_selected.connect(self.load_song)
self.screen_select_widget = ScreenSelectWidget()
self.screen_select_widget.screen_selected.connect(self.display_lyrics_on_screen)
self.screen_select_widget.active_screen = QApplication.desktop().screenNumber(self.songtext_widget)
self.settings_button = QPushButton()
self.settings_button.setText(self.tr("Settings..."))
self.settings_button.clicked.connect(self.show_settings)
sidebarLayout = QVBoxLayout()
sidebarLayout.setContentsMargins(10, 1, 0, 1);
sidebarLayout.addWidget(self.settings_button)
sidebarLayout.addStretch(1);
sidebarLayout.addWidget(self.screen_select_widget)
displayLayout.addWidget(self.song_select_widget)
displayLayout.addLayout(sidebarLayout)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
# controlLayout.addWidget(openButton)
# controlLayout.addStretch(1)
controlLayout.addWidget(controls)
controlLayout.addStretch(1)
controlLayout.addWidget(self.labelDuration)
# controlLayout.addWidget(self.fullScreenButton)
# controlLayout.addWidget(self.colorButton)
layout = QVBoxLayout()
layout.addLayout(displayLayout)
hLayout = QHBoxLayout()
hLayout.addWidget(self.slider)
# hLayout.addWidget(self.labelDuration)
layout.addLayout(hLayout)
layout.addLayout(controlLayout)
self.setLayout(layout)
if not self.player.isAvailable():
QMessageBox.warning(self, "Service not available",
"The QMediaPlayer object does not have a valid service.\n"
"Please check the media service plugins are installed.")
controls.setEnabled(False)
self.playlistView.setEnabled(False)
# openButton.setEnabled(False)
self.colorButton.setEnabled(False)
self.fullScreenButton.setEnabled(False)
self.metaDataChanged()
self._loading_audio = False
self._finished_song = False
self._lyrics_fading = False
self._song_number = -1
self.settings = {
'font_size': 40,
'line_increment': 2,
'lyrics_language': '',
}
self._load_settings()
self.settings_widget = SettingsWidget(self.settings, self.lyrics_path)
self.settings_widget.font_size_changed.connect(self.songtext_widget.set_font_size)
self.settings_widget.line_increment_changed.connect(self.songtext_widget.set_line_increment)
self.settings_widget.language_changed.connect(self._language_changed)
self.song_select_widget.reset(self.available_song_numbers)
@property
def lyrics_language_path(self):
path = QStandardPaths.locate(QStandardPaths.AppDataLocation, self.lyrics_path, QStandardPaths.LocateDirectory)
return os.path.join(path, self.settings['lyrics_language'])
@property
def available_song_numbers(self):
audios = set(
[int(os.path.splitext(filename)[0]) for filename in os.listdir(self.audio_path) if filename[0] != '.'])
try:
lyrics = set(
[int(os.path.splitext(filename)[0])
for filename in os.listdir(self.lyrics_language_path)
if filename[0] != '.']
)
except (ValueError, FileNotFoundError):
lyrics = set()
return sorted(list(audios.intersection(lyrics)))
def show_settings(self):
self.settings_widget.hide()
self.settings_widget.show()
def display_lyrics_on_screen(self, screen_number):
desktop = QApplication.desktop()
if screen_number >= desktop.screenCount():
screen_number = desktop.screenNumber(self)
rect = desktop.availableGeometry(screen_number)
for _ in range(3):
if screen_number != desktop.screenNumber(self):
self.songtext_widget.setWindowFlags(Qt.FramelessWindowHint)
self.songtext_widget.hide()
self.songtext_widget.move(rect.x(), rect.y())
self.songtext_widget.resize(rect.width(), rect.height())
self.songtext_widget.showFullScreen()
else:
self.songtext_widget.setWindowFlags(Qt.WindowTitleHint)
self.songtext_widget.hide()
self.songtext_widget.move(rect.x(), rect.y())
self.songtext_widget.resize(self.songtext_widget.minimumSize())
self.songtext_widget.show()
self.screen_select_widget.active_screen = screen_number
self.activateWindow()
def load_song(self, song_number):
if self._song_number == song_number:
self.seek(0)
else:
if self._song_number > 0:
self._save_timings()
self._song_number = song_number
self.slider.dirty = False
self._load_audio()
self._load_lyrics()
# self.player.play()
def _load_audio(self):
filename = os.path.join(self.audio_path, "{:03}.mp3".format(self._song_number))
self.playlist.clear()
fileInfo = QFileInfo(filename)
if fileInfo.exists():
url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
if fileInfo.suffix().lower() == 'm3u':
self.playlist.load(url)
else:
self.playlist.addMedia(QMediaContent(url))
self._loading_audio = True
self.player.play()
def _load_lyrics(self):
with open(os.path.join(self.lyrics_language_path, "{}.json".format(self._song_number)), 'r') as f:
song_markers = json.load(f)
self.markers = []
for m in song_markers['markers']:
marker = MediaMarker(self.slider, m['name'])
marker.text = m['text']
marker.progress = 0.0
self.markers.append(marker)
self.songtext_widget.title = "{} {}".format(self._song_number, song_markers['title'])
self.songtext_widget.markers = self.markers
self.songtext_widget.fade_in()
try:
with open(os.path.join(self.timings_path, "{}.json".format(self._song_number)), 'r') as f:
timings = json.load(f)
for m, t in zip(self.markers, timings):
m.progress = t
except FileNotFoundError:
pass
self.slider.markers = self.markers
def _language_changed(self, _):
available_song_numbers = self.available_song_numbers
self.song_select_widget.reset(available_song_numbers)
if self._song_number in available_song_numbers:
self._load_lyrics()
# def open(self):
# fileNames, _ = QFileDialog.getOpenFileNames(self, "Open Files")
# self.addToPlaylist(fileNames)
#
# def addToPlaylist(self, fileNames):
# for name in fileNames:
# fileInfo = QFileInfo(name)
# if fileInfo.exists():
# url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
# if fileInfo.suffix().lower() == 'm3u':
# self.playlist.load(url)
# else:
# self.playlist.addMedia(QMediaContent(url))
# else:
# url = QUrl(name)
# if url.isValid():
# self.playlist.addMedia(QMediaContent(url))
def durationChanged(self, duration):
duration /= 1000
self.duration = duration
self.slider.setMaximum(duration)
if self._loading_audio:
self._loading_audio = False
line_total = 0
for marker in self.markers:
line_total += marker.linecount - 1
silence_ratio = 5.0 / self.duration
offset = 1.8 / line_total
linecount = 0
for marker in self.markers:
if marker.progress == 0.0:
marker.progress = offset + (1 - offset) * (1 - silence_ratio) * linecount / line_total
linecount += marker.linecount - 1
self.player.pause()
@property
def _should_fade_out(self):
return self.player.position() / 1000 >= self.duration - 5
def positionChanged(self, progress):
progress /= 1000
if not self.slider.isSliderDown():
self.slider.setValue(progress)
self.updateDurationInfo(progress)
if self.duration > 0:
# if self.player.state() == QMediaPlayer.PlayingState:
self.songtext_widget.progress = progress / self.duration
if self._should_fade_out:
self._fade_out_lyrics()
def _fade_out_lyrics(self):
if not self._lyrics_fading:
self._lyrics_fading = True
self.songtext_widget.fade_out()
def metaDataChanged(self):
if self.player.isMetaDataAvailable():
self.setTrackInfo("%s - %s" % (
self.player.metaData(QMediaMetaData.AlbumArtist),
self.player.metaData(QMediaMetaData.Title)))
def previousClicked(self):
# Go to the previous track if we are within the first 5 seconds of
# playback. Otherwise, seek to the beginning.
if self.player.position() <= 5000:
self.playlist.previous()
else:
self.player.setPosition(0)
def jump(self, index):
if index.isValid():
self.playlist.setCurrentIndex(index.row())
self.player.play()
def seek(self, seconds):
self.player.setPosition(seconds * 1000)
def setState(self, status):
if status == QMediaPlayer.StoppedState:
self._finished_song = True
elif status == QMediaPlayer.PlayingState:
if self._finished_song or (self._lyrics_fading and not self._should_fade_out):
self._finished_song = False
self._lyrics_fading = False
self.songtext_widget.fade_in()
def stop_clicked(self):
self.player.stop()
self._fade_out_lyrics()
def statusChanged(self, status):
self.handleCursor(status)
if status == QMediaPlayer.LoadingMedia:
self.setStatusInfo("Loading...")
elif status == QMediaPlayer.StalledMedia:
self.setStatusInfo("Media Stalled")
elif status == QMediaPlayer.EndOfMedia:
QApplication.alert(self)
elif status == QMediaPlayer.InvalidMedia:
self.displayErrorMessage()
else:
self.setStatusInfo("")
def handleCursor(self, status):
if status in (QMediaPlayer.LoadingMedia, QMediaPlayer.BufferingMedia, QMediaPlayer.StalledMedia):
self.setCursor(Qt.BusyCursor)
else:
self.unsetCursor()
def bufferingProgress(self, progress):
self.setStatusInfo("Buffering %d%" % progress)
def videoAvailableChanged(self, available):
if available:
self.fullScreenButton.clicked.connect(
self.videoWidget.setFullScreen)
self.videoWidget.fullScreenChanged.connect(
self.fullScreenButton.setChecked)
if self.fullScreenButton.isChecked():
self.videoWidget.setFullScreen(True)
else:
self.fullScreenButton.clicked.disconnect(
self.videoWidget.setFullScreen)
self.videoWidget.fullScreenChanged.disconnect(
self.fullScreenButton.setChecked)
self.videoWidget.setFullScreen(False)
self.colorButton.setEnabled(available)
def setTrackInfo(self, info):
self.trackInfo = info
# if self.statusInfo != "":
# self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo))
# else:
# self.setWindowTitle(self.trackInfo)
def setStatusInfo(self, info):
self.statusInfo = info
# if self.statusInfo != "":
# self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo))
# else:
# self.setWindowTitle(self.trackInfo)
def displayErrorMessage(self):
self.setStatusInfo(self.player.errorString())
def updateDurationInfo(self, currentInfo):
duration = self.duration
if currentInfo or duration:
currentTime = QTime((currentInfo / 3600) % 60, (currentInfo / 60) % 60,
currentInfo % 60, (currentInfo * 1000) % 1000)
totalTime = QTime((duration / 3600) % 60, (duration / 60) % 60,
duration % 60, (duration * 1000) % 1000);
format = 'hh:mm:ss' if duration > 3600 else 'mm:ss'
tStr = currentTime.toString(format) + " / " + totalTime.toString(format)
else:
tStr = ""
self.labelDuration.setText(tStr)
def showColorDialog(self):
if self.colorDialog is None:
brightnessSlider = QSlider(Qt.Horizontal)
brightnessSlider.setRange(-100, 100)
brightnessSlider.setValue(self.videoWidget.brightness())
brightnessSlider.sliderMoved.connect(
self.videoWidget.setBrightness)
self.videoWidget.brightnessChanged.connect(
brightnessSlider.setValue)
contrastSlider = QSlider(Qt.Horizontal)
contrastSlider.setRange(-100, 100)
contrastSlider.setValue(self.videoWidget.contrast())
contrastSlider.sliderMoved.connect(self.videoWidget.setContrast)
self.videoWidget.contrastChanged.connect(contrastSlider.setValue)
hueSlider = QSlider(Qt.Horizontal)
hueSlider.setRange(-100, 100)
hueSlider.setValue(self.videoWidget.hue())
hueSlider.sliderMoved.connect(self.videoWidget.setHue)
self.videoWidget.hueChanged.connect(hueSlider.setValue)
saturationSlider = QSlider(Qt.Horizontal)
saturationSlider.setRange(-100, 100)
saturationSlider.setValue(self.videoWidget.saturation())
saturationSlider.sliderMoved.connect(
self.videoWidget.setSaturation)
self.videoWidget.saturationChanged.connect(
saturationSlider.setValue)
layout = QFormLayout()
layout.addRow("Brightness", brightnessSlider)
layout.addRow("Contrast", contrastSlider)
layout.addRow("Hue", hueSlider)
layout.addRow("Saturation", saturationSlider)
button = QPushButton("Close")
layout.addRow(button)
self.colorDialog = QDialog(self)
self.colorDialog.setWindowTitle("Color Options")
self.colorDialog.setLayout(layout)
button.clicked.connect(self.colorDialog.close)
self.colorDialog.show()
def closeEvent(self, close_event):
self._save_timings()
self._save_settings()
self.songtext_widget.close()
self.settings_widget.close()
def keyPressEvent(self, key_event):
if key_event.key() == Qt.Key_Space:
key_event.accept()
if self.player.state() == QMediaPlayer.PlayingState:
self.player.pause()
elif self.player.state() in [QMediaPlayer.PausedState, QMediaPlayer.StoppedState]:
self.player.play()
elif key_event.key() == Qt.Key_M:
key_event.accept()
self.slider.set_closest_marker_to_current_progress()
def _save_timings(self):
if self.slider.dirty:
with open(os.path.join(self.timings_path, "{}.json".format(self._song_number)), 'w') as f:
json.dump([marker.progress for marker in self.markers], f, indent=2)
def _save_settings(self):
# TODO : refactor and use QSettings directly
# with open(self.settings_path, 'w') as f:
self.settings.update({
'lyrics_screen': QApplication.desktop().screenNumber(self.songtext_widget),
'control_window_position': self.pos(),
})
# json.dump(self.settings, f, indent=2)
settings = QSettings("Maccesch", "SongScreen")
for key, value in self.settings.items():
settings.setValue(key, value)
def _load_settings(self):
# try:
# with open(self.settings_path, 'r') as f:
# settings = json.load(f)
settings = QSettings("Maccesch", "SongScreen")
if settings.contains('lyrics_screen'):
self.display_lyrics_on_screen(settings.value('lyrics_screen'))
if settings.contains('control_window_position'):
self.move(settings.value('control_window_position'))
for key in settings.allKeys():
self.settings[key] = settings.value(key)
# self.settings.update(settings)
self.songtext_widget.set_font_size(self.settings['font_size'])
self.songtext_widget.set_line_increment(self.settings['line_increment'])
# except (FileNotFoundError, ValueError):
# pass
if not os.path.exists(self.lyrics_language_path) or not self.settings['lyrics_language']:
languages = list(
filter(lambda p: os.path.isdir(os.path.join(self.lyrics_path, p)) and p != "timings",
os.listdir(self.lyrics_path))
)
self.settings['lyrics_language'] = languages[0] if languages else ""
class Controller:
def __init__(self, view, log):
self.log = log
self.view = view
self._player = QMediaPlayer()
self._player.mediaStatusChanged.connect(self._player_status_changed)
self._player.mediaChanged.connect(self._player_media_changed)
self._player.currentMediaChanged.connect(self._player_current_media_changed)
self._player.stateChanged.connect(self._player_state_changed)
self._player.positionChanged.connect(self._player_position_changed)
self._player.durationChanged.connect(self._player_duration_changed)
self._searched_tracks = []
self.playlists = []
self.playing_playlist = 0
self.last_colored_item = None
def _player_status_changed(self, status):
self.log.debug('_player_status_changed: %s', str(status))
if status in [QMediaPlayer.EndOfMedia, QMediaPlayer.InvalidMedia]:
self.next()
if status in [QMediaPlayer.EndOfMedia, QMediaPlayer.NoMedia, QMediaPlayer.UnknownMediaStatus,
QMediaPlayer.InvalidMedia]:
self.view.set_title()
else:
try:
pos = self.playlists[self.playing_playlist].active_track
if pos >= 0:
track = self.playlists[self.playing_playlist].tracks[pos]
self.view.set_title(track.title)
self.update_list_position(pos)
except IndexError:
self.log.error('Index error in _player_status_changed')
def _player_media_changed(self, media):
self.log.debug('_player_media_changed: %s' % str(media))
def _player_current_media_changed(self, media):
self.log.debug('_player_current_media_changed: %s' % str(media))
def _player_state_changed(self, state):
self.log.debug('_player_state_changed: %s' % str(state))
def _player_duration_changed(self, duration):
self.log.debug('_player_duration_changed: %s' % str(duration))
self.view.track_position.setMaximum(duration)
def _player_position_changed(self, pos):
self.view.track_position.setValue(pos)
def volume_changed(self, value):
self._player.setVolume(value)
def update_status(self):
total_duration = 0
playlist_index = self.view.tabs.currentIndex()
for track in self.playlists[playlist_index].tracks:
total_duration += track.duration
self.view.playlist_status.setText("%i tracks. Total duration %i:%02i:%02i:%02i" %
(self.playlists[playlist_index].count(), total_duration // 86400,
total_duration // 3600 % 24,
total_duration // 60 % 60, total_duration % 60))
def add_track(self, track, playlist_index=None):
if playlist_index is None:
playlist_index = self.view.tabs.currentIndex()
self.playlists[playlist_index].add(track)
self.view.tabs.widget(playlist_index).addItem(track.title)
def remove_track(self, track_pos=None):
if track_pos is None:
track_pos = self.view.tabs.currentWidget().currentRow()
if track_pos != -1:
self.view.tabs.currentWidget().takeItem(track_pos)
playlist_index = self.view.tabs.currentIndex()
self.playlists[playlist_index].remove(track_pos)
self.update_status()
def remove_all_tracks(self):
playlist_index = self.view.tabs.currentIndex()
self.playlists[playlist_index].clear()
self.view.tabs.currentWidget().clear()
self.update_status()
def next(self):
self.log.debug('next')
# if we close last tab with current track, after it ended, we stop playing
# todo: need check, that if we close not last tab with current song, we also need stop after song ended
if self.playing_playlist >= len(self.playlists):
return
next_pos = self.playlists[self.playing_playlist].get_next_track(shuffle=bool(self.view.shuffle.checkState()))
if next_pos is not None:
self.playlists[self.playing_playlist].active_track = next_pos
url = self.playlists[self.playing_playlist].tracks[next_pos].stream_url()
self._player.setMedia(QMediaContent(QUrl(url)))
self.play()
def previous(self):
self.log.debug('previous')
prev_pos = self.playlists[self.playing_playlist].get_prev_track(shuffle=bool(self.view.shuffle.checkState()))
if prev_pos is not None:
self.playlists[self.playing_playlist].active_track = prev_pos
url = self.playlists[self.playing_playlist].tracks[prev_pos].stream_url()
self._player.setMedia(QMediaContent(QUrl(url)))
self.play()
def play(self):
self.log.debug('play')
self._player.play()
def pause(self):
self.log.debug('pause')
self._player.pause()
def update_list_position(self, position):
showed_list = self.view.tabs.currentWidget()
if self.last_colored_item:
self.last_colored_item.setBackground(QBrush())
if (position >= 0) and (position <= showed_list.count()):
self.last_colored_item = showed_list.item(position)
self.last_colored_item.setBackground(QBrush(QColor('red')))
def change_track(self):
self.log.debug('change_track')
playlist_index = self.view.tabs.currentIndex()
self.playing_playlist = playlist_index
position = self.view.tabs.currentWidget().currentRow()
self.playlists[self.playing_playlist].active_track = position
self.log.debug('position: %i' % position)
url = self.playlists[self.playing_playlist].tracks[position].stream_url()
self._player.setMedia(QMediaContent(QUrl(url)))
if self._player.state() in [QMediaPlayer.StoppedState, QMediaPlayer.PausedState]:
self.play()
def change_track_position(self):
self._player.setPosition(self.view.track_position.value())
def remove_dublicates(self):
selected_playlist = self.view.tabs.currentIndex()
playlist = self.playlists[selected_playlist]
processed_ids = []
position_for_removing = []
for index in range(len(playlist.tracks)):
if playlist.tracks[index].id in processed_ids:
position_for_removing.append(index)
else:
processed_ids.append(playlist.tracks[index].id)
self.log.debug('tracks count: %i' % len(playlist.tracks))
counter = 0
for index in reversed(position_for_removing):
self.log.debug('track index for removing: %i' % index)
self.remove_track(track_pos=index)
counter += 1
self.log.info('Removed %i tracks.' % counter)
def save_track(self, playlist_pos=None, track_pos=None):
if track_pos is None:
track_pos = self.view.tabs.currentWidget().currentRow()
if playlist_pos is None:
playlist_pos = self.view.tabs.currentIndex()
playlist = self.playlists[playlist_pos]
track = playlist.tracks[track_pos]
track.save()
def download_playlist(self):
selected_playlist = self.view.tabs.currentIndex()
playlist = self.playlists[selected_playlist]
for track_pos in range(playlist.count()):
self.log.info('Saving %i/%s track...' % (track_pos+1, playlist.count()))
self.save_track(playlist_pos=selected_playlist, track_pos=track_pos)
self.log.info('Saving done.')
def load_playlist(self):
playlist_index = self.view.tabs.currentIndex()
playlist = self.playlists[playlist_index]
loaded_playlist = sc_load_playlist(playlist.name)
if not loaded_playlist:
self.log.error('Playlist not exists.')
return
self.remove_all_tracks()
for track in loaded_playlist:
self.add_track(track)
self.update_status()
def save_playlist(self):
playlist_index = self.view.tabs.currentIndex()
playlist = self.playlists[playlist_index]
sc_save_playlist(playlist.name, playlist)
def add_playlist(self, name):
self.playlists.append(Playlist(name))
def remove_playlist(self, index):
self.log.debug('remove playlist with index = %i' % index)
del (self.playlists[index])
def search_tracks(self):
self.view.search_list.clear()
tracks = sc_search_tracks(self.view.input.text())
self._searched_tracks = tracks
total_duration = 0
for track in self._searched_tracks:
self.view.search_list.addItem(track.title)
total_duration += track.duration
self.view.search_status.setText("Founded %i tracks. Total duration %i:%02i:%02i:%02i" %
(len(self._searched_tracks),
total_duration // 86400000, total_duration // 3600000 % 24,
total_duration // 60000 % 60, total_duration // 1000 % 60))
def search_similar(self):
self.view.search_list.clear()
position = self.view.tabs.currentWidget().currentRow()
playlist_index = self.view.tabs.currentIndex()
track = self.playlists[playlist_index].tracks[position]
related_tracks = track.search_related()
self._searched_tracks = related_tracks
total_duration = 0
for track in self._searched_tracks:
self.view.search_list.addItem(track.title)
total_duration += track.duration
self.view.search_status.setText("Founded %i tracks. Total duration %i:%02i:%02i:%02i" %
(len(self._searched_tracks),
total_duration // 86400000, total_duration // 3600000 % 24,
total_duration // 60000 % 60, total_duration // 1000 % 60))
def clicked_add_track(self):
position = self.view.search_list.currentRow()
self.add_track(self._searched_tracks[position])
def clicked_add_all_tracks(self):
for row in range(self.view.search_list.count()):
self.add_track(self._searched_tracks[row])
def load_current_state(self):
if not os.path.isfile('state.pickle'):
return
f = open('state.pickle', 'rb')
state = pickle.load(f)
f.close()
loaded_playlists = state['playlists']
self.log.debug('loaded %i playlists.' % len(loaded_playlists))
for i in range(len(loaded_playlists) - len(self.playlists)):
self.view.tab_add()
self.playlists.clear()
index = 0
for playlist in loaded_playlists:
self.log.debug('playlist: %s, len: %i' % (playlist.name, len(playlist.tracks)))
self.add_playlist(playlist.name)
for track in playlist.tracks:
self.add_track(track, playlist_index=index)
index += 1
self.log.debug(len(self.playlists))
self.log.debug('curent tab: %i' % state['current_playlist'])
self.view.tabs.setCurrentIndex(state['current_playlist'])
self.log.debug('volume: %i' % state['volume'])
self.view.volume.setValue(state['volume'])
self.view.shuffle.setCheckState(state['shuffle'])
def save_current_state(self):
state = dict()
self.log.debug('playlists count: %i' % len(self.playlists))
state['playlists'] = self.playlists
state['current_playlist'] = self.view.tabs.currentIndex()
state['volume'] = self.view.volume.value()
state['shuffle'] = self.view.shuffle.checkState()
f = open('state.pickle', 'wb')
pickle.dump(state, f)
f.close()
class Player(QGraphicsVideoItem):
isSubtitle = pyqtSignal(bool)
subtitlePos = pyqtSignal(int)
def __init__(self, parent=None):
super().__init__()
self.parent = parent
self.player = QMediaPlayer()
self.player.setVolume(int(settings().value("Player/volume") or 100))
self.player.setVideoOutput(self)
self.timer = QTimer(self)
self.timer.timeout.connect(self.timerPos)
self.player.currentMediaChanged.connect(self.signalStart)
self.player.currentMediaChanged.connect(self.parent.subtitleitem.subtitleControl)
self.player.currentMediaChanged.connect(self.videoConfigure)
"""self.player.mediaStatusChanged.connect(self.metadata)
def metadata(self, data):
if data and self.player.isMetaDataAvailable():
print(self.player.metaData("VideoCodec"))"""
def videoConfigure(self, media):
video_name = os.path.basename(media.canonicalUrl().toLocalFile())
videos = settings().value("Player/video_names") or []
videos_time = settings().value("Player/videos_time") or []
try:
self.player.setPosition(int(videos_time[videos.index(video_name)]))
except ValueError:
pass
def timerStart(self):
self.timer.start(200)
def signalStart(self, content):
srt = content.canonicalUrl().toLocalFile().split(".")
srt.pop(-1)
srt.append("srt")
srt = ".".join(srt)
if QFile.exists(srt):
self.isSubtitle.emit(True)
self.timer.start(100)
else:
self.isSubtitle.emit(False)
self.timer.stop()
def timerPos(self):
self.subtitlePos.emit(self.player.position())
def playerPlayOrOpen(self, arg=None):
if type(arg) == list and len(arg) > 1:
content = QMediaContent(QUrl.fromLocalFile(arg[1]))
self.player.setMedia(content)
self.play()
def addVideo(self, video):
content = QMediaContent(QUrl.fromLocalFile(video))
self.player.setMedia(content)
self.play()
def addYoutubeVideo(self, video):
dm = DownloadManager(self)
content = QMediaContent(dm.addUrl(video))
self.player.setMedia(content)
self.play()
def sliderChanged(self, pos):
self.player.setPosition(pos)
def play(self):
self.player.play()
def stop(self):
self.player.stop()
def pause(self):
self.player.pause()
def setMuted(self, mute):
self.player.setMuted(mute)
def mutedState(self):
if self.player.isMuted():
self.setMuted(False)
else:
self.setMuted(True)
def isMuted(self):
return self.player.isMuted()
def setVolume(self, value):
self.player.setVolume(value)
def volume(self):
return self.player.volume()
class Ui_Form(QWidget):
def __init__(self):
super().__init__()
self.points_CAM1 = []
self.points_CAM2 = []
self.points_CAM3 = []
def setupUi(self, Form):
Form.setObjectName("Form")
self.tabWidget = QtWidgets.QTabWidget(Form)
self.tabWidget.setObjectName("tabWidget")
self.multiTab = QtWidgets.QWidget()
self.multiTab.setObjectName("multiTab")
# cam1
self.cam_1 = QtWidgets.QWidget(self.multiTab)
self.cam_1.setObjectName("cam_1")
self.CAM1 = QtWidgets.QLabel(self.cam_1)
self.CAM1.setFrameShape(QtWidgets.QFrame.Box)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.CAM1.sizePolicy().hasHeightForWidth())
self.CAM1.setSizePolicy(sizePolicy)
self.CAM1.setMinimumSize(QtCore.QSize(320, 240))
self.CAM1.setMaximumSize(QtCore.QSize(400, 320))
self.CAM1.setSizeIncrement(QtCore.QSize(3, 2))
self.CAM1.setScaledContents(True)
self.CAM1.setObjectName("CAM1")
self.startCAM1 = QtWidgets.QPushButton(self.cam_1)
self.startCAM1.setObjectName("startCAM1")
self.stopCAM1 = QtWidgets.QPushButton(self.cam_1)
self.stopCAM1.setObjectName("stopCAM1")
self.reIDBtn_1 = QtWidgets.QPushButton(self.cam_1)
self.reIDBtn_1.setObjectName("reIDBtn_1")
self.falldetectionBtn_1 = QtWidgets.QPushButton(self.cam_1)
self.falldetectionBtn_1.setObjectName("falldetectionBtn_1")
self.peoplecntBtn_1 = QtWidgets.QPushButton(self.cam_1)
self.peoplecntBtn_1.setObjectName("peoplecntBtn_1")
self.areaprotectionBtn_1 = QtWidgets.QPushButton(self.cam_1)
self.areaprotectionBtn_1.setObjectName("areaprotectionBtn_1")
layoutCam_1 = QGridLayout(self.cam_1)
layoutCam_1.addWidget(self.CAM1, 0, 0, 7, 3)
layoutCam_1.addWidget(self.startCAM1, 8, 0)
layoutCam_1.addWidget(self.stopCAM1, 9, 0)
layoutCam_1.addWidget(self.reIDBtn_1, 8, 1)
layoutCam_1.addWidget(self.falldetectionBtn_1, 8, 2)
layoutCam_1.addWidget(self.peoplecntBtn_1, 9, 1)
layoutCam_1.addWidget(self.areaprotectionBtn_1, 9, 2)
self.cam_1.setLayout(layoutCam_1)
# Setting Multi_tab Cam 2
self.cam_2 = QtWidgets.QWidget(self.multiTab)
self.cam_2.setObjectName("cam_2")
self.CAM2 = QtWidgets.QLabel(self.cam_2)
self.CAM2.setFrameShape(QtWidgets.QFrame.Box)
self.CAM2.setSizePolicy(sizePolicy)
self.CAM2.setMinimumSize(QtCore.QSize(320, 240))
self.CAM2.setMaximumSize(QtCore.QSize(400, 320))
self.CAM2.setSizeIncrement(QtCore.QSize(3, 2))
self.CAM2.setObjectName("CAM2")
self.CAM2.setScaledContents(True)
self.peoplecntBtn_2 = QtWidgets.QPushButton(self.cam_2)
self.peoplecntBtn_2.setObjectName("peoplecntBtn_2")
self.falldetectionBtn_2 = QtWidgets.QPushButton(self.cam_2)
self.falldetectionBtn_2.setObjectName("falldetectionBtn_2")
self.reIDBtn_2 = QtWidgets.QPushButton(self.cam_2)
self.reIDBtn_2.setObjectName("reIDBtn_2")
self.stop_CAM2 = QtWidgets.QPushButton(self.cam_2)
self.stop_CAM2.setObjectName("stop_CAM2")
self.start_CAM2 = QtWidgets.QPushButton(self.cam_2)
self.start_CAM2.setObjectName("start_CAM2")
self.areaprotectionBtn_2 = QtWidgets.QPushButton(self.cam_2)
self.areaprotectionBtn_2.setObjectName("areaprotectionBtn_2")
layoutCam_2 = QGridLayout(self.cam_2)
layoutCam_2.addWidget(self.CAM2, 0, 0, 7, 3)
layoutCam_2.addWidget(self.start_CAM2, 8, 0)
layoutCam_2.addWidget(self.stop_CAM2, 9, 0)
layoutCam_2.addWidget(self.reIDBtn_2, 8, 1)
layoutCam_2.addWidget(self.falldetectionBtn_2, 8, 2)
layoutCam_2.addWidget(self.peoplecntBtn_2, 9, 1)
layoutCam_2.addWidget(self.areaprotectionBtn_2, 9, 2)
self.cam_2.setLayout(layoutCam_2)
# Setting Multi_tab Cam 3
self.cam_3 = QtWidgets.QWidget(self.multiTab)
self.cam_3.setObjectName("cam_3")
self.CAM3 = QtWidgets.QLabel(self.cam_3)
self.CAM3.setFrameShape(QtWidgets.QFrame.Box)
self.CAM3.setSizePolicy(sizePolicy)
self.CAM3.setMinimumSize(QtCore.QSize(320, 240))
self.CAM3.setMaximumSize(QtCore.QSize(400, 320))
self.CAM3.setSizeIncrement(QtCore.QSize(3, 2))
self.CAM3.setObjectName("CAM3")
self.CAM3.setScaledContents(True)
self.peoplecntBtn_3 = QtWidgets.QPushButton(self.cam_3)
self.peoplecntBtn_3.setObjectName("peoplecntBtn_3")
self.falldetectionBtn_3 = QtWidgets.QPushButton(self.cam_3)
self.falldetectionBtn_3.setObjectName("falldetectionBtn_3")
self.reIDBtn_3 = QtWidgets.QPushButton(self.cam_3)
self.reIDBtn_3.setObjectName("reIDBtn_3")
self.stop_CAM3 = QtWidgets.QPushButton(self.cam_3)
self.stop_CAM3.setObjectName("stop_CAM3")
self.start_CAM3 = QtWidgets.QPushButton(self.cam_3)
self.start_CAM3.setObjectName("start_CAM3")
self.areaprotectionBtn_3 = QtWidgets.QPushButton(self.cam_3)
self.areaprotectionBtn_3.setObjectName("areaprotectionBtn_3")
layoutCam_3 = QGridLayout(self.cam_3)
layoutCam_3.addWidget(self.CAM3, 0, 0, 7, 3)
layoutCam_3.addWidget(self.start_CAM3, 8, 0)
layoutCam_3.addWidget(self.stop_CAM3, 9, 0)
layoutCam_3.addWidget(self.reIDBtn_3, 8, 1)
layoutCam_3.addWidget(self.falldetectionBtn_3, 8, 2)
layoutCam_3.addWidget(self.peoplecntBtn_3, 9, 1)
layoutCam_3.addWidget(self.areaprotectionBtn_3, 9, 2)
self.cam_3.setLayout(layoutCam_3)
# Setting layout multi_tab
layoutMultitab = QGridLayout(self.multiTab)
layoutMultitab.addWidget(self.cam_1, 0, 0)
layoutMultitab.addWidget(self.cam_2, 0, 1)
layoutMultitab.addWidget(self.cam_3, 0, 2)
self.multiTab.setLayout(layoutMultitab)
self.tabWidget.addTab(self.multiTab, "")
# Media Player
self.playRec = QtWidgets.QWidget()
self.playRec.setObjectName("playRec")
self.tabWidget.addTab(self.playRec, "")
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
videowidget = QVideoWidget()
self.openBtn = QtWidgets.QPushButton('Open Video')
self.playBtn = QtWidgets.QPushButton()
self.playBtn.setEnabled(False)
self.playBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.stopBtn = QtWidgets.QPushButton()
self.stopBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaStop))
self.slowBtn = QtWidgets.QPushButton()
self.slowBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaSeekBackward))
self.fastBtn = QtWidgets.QPushButton()
self.fastBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaSeekForward))
self.volumeBtn = QtWidgets.QPushButton()
self.volumeBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaVolume))
self.fullscreenBtn = QPushButton("Full Screen")
self.slider = QSlider(Qt.Horizontal)
self.slider.setRange(0, 0)
self.volume_slider = QSlider(Qt.Horizontal)
self.volume_slider.setRange(0, 100)
self.volume_slider.setValue(100)
self.label_2_1 = QLabel()
self.label_2_1.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
self.label_2_2 = QLabel()
hboxLayout_2_1 = QHBoxLayout()
hboxLayout_2_2 = QHBoxLayout()
hboxLayout_2_3 = QHBoxLayout()
hboxLayout_2_1.addWidget(self.slider)
hboxLayout_2_2.addWidget(self.openBtn)
hboxLayout_2_2.addWidget(self.stopBtn)
hboxLayout_2_2.addWidget(self.slowBtn)
hboxLayout_2_2.addWidget(self.playBtn)
hboxLayout_2_2.addWidget(self.fastBtn)
hboxLayout_2_2.addWidget(self.volumeBtn)
hboxLayout_2_2.addWidget(self.volume_slider)
hboxLayout_2_2.addStretch(1)
hboxLayout_2_2.addWidget(self.fullscreenBtn)
hboxLayout_2_3.addWidget(videowidget)
vboxLayout_2_1 = QVBoxLayout()
vboxLayout_2_1.addLayout(hboxLayout_2_3)
vboxLayout_2_1.addLayout(hboxLayout_2_1)
vboxLayout_2_1.addLayout(hboxLayout_2_2)
vboxLayout_2_1.addWidget(self.label_2_1)
self.playRec.setLayout(vboxLayout_2_1)
#Tab Setting
self.setting = QtWidgets.QWidget()
self.setting.setObjectName("setting")
self.tabWidget.addTab(self.setting, "")
# Cam 1
self.camSetting_1 = QtWidgets.QWidget(self.setting)
self.camSetting_1.setObjectName("camSetting_1")
self.CAM1_Draw = QtWidgets.QLabel(self.camSetting_1)
self.CAM1_Draw.setFrameShape(QtWidgets.QFrame.Box)
self.CAM1_Draw.setSizePolicy(sizePolicy)
self.CAM1_Draw.setMinimumSize(QtCore.QSize(320, 240))
self.CAM1_Draw.setMaximumSize(QtCore.QSize(400, 320))
self.CAM1_Draw.setSizeIncrement(QtCore.QSize(3, 2))
self.CAM1_Draw.setObjectName("CAM1_Draw")
self.draw_CAM1 = QtWidgets.QPushButton(self.camSetting_1)
self.draw_CAM1.setObjectName("draw_CAM1")
self.remove_CAM1 = QtWidgets.QPushButton(self.camSetting_1)
self.remove_CAM1.setObjectName("remove_CAM1")
layoutCamSetting_1 = QGridLayout()
layoutCamSetting_1.addWidget(self.CAM1_Draw, 0, 0, 7, 4)
layoutCamSetting_1.addWidget(self.draw_CAM1, 8, 1)
layoutCamSetting_1.addWidget(self.remove_CAM1, 8, 2)
self.camSetting_1.setLayout(layoutCamSetting_1)
#camSetting 2
self.camSetting_2 = QtWidgets.QWidget(self.setting)
self.camSetting_2.setObjectName("camSetting_2")
self.CAM2_Draw = QtWidgets.QLabel(self.camSetting_2)
self.CAM2_Draw.setFrameShape(QtWidgets.QFrame.Box)
self.CAM2_Draw.setSizePolicy(sizePolicy)
self.CAM2_Draw.setMinimumSize(QtCore.QSize(320, 240))
self.CAM2_Draw.setMaximumSize(QtCore.QSize(400, 320))
self.CAM2_Draw.setSizeIncrement(QtCore.QSize(3, 2))
self.CAM2_Draw.setObjectName("CAM2_Draw")
self.draw_CAM2 = QtWidgets.QPushButton(self.camSetting_2)
self.draw_CAM2.setObjectName("draw_CAM2")
self.remove_CAM2 = QtWidgets.QPushButton(self.camSetting_2)
self.remove_CAM2.setObjectName("remove_CAM2")
layoutCamSetting_2 = QGridLayout()
layoutCamSetting_2.addWidget(self.CAM2_Draw, 0, 0, 7, 4)
layoutCamSetting_2.addWidget(self.draw_CAM2, 8, 1)
layoutCamSetting_2.addWidget(self.remove_CAM2, 8, 2)
self.camSetting_2.setLayout(layoutCamSetting_2)
#camSeting 3
self.camSetting_3 = QtWidgets.QWidget(self.setting)
self.camSetting_3.setObjectName("camSetting_3")
self.CAM3_Draw = QtWidgets.QLabel(self.camSetting_3)
self.CAM3_Draw.setFrameShape(QtWidgets.QFrame.Box)
self.CAM3_Draw.setSizePolicy(sizePolicy)
self.CAM3_Draw.setMinimumSize(QtCore.QSize(320, 240))
self.CAM3_Draw.setMaximumSize(QtCore.QSize(400, 320))
self.CAM3_Draw.setSizeIncrement(QtCore.QSize(3, 2))
self.CAM3_Draw.setObjectName("CAM3_Draw")
self.draw_CAM3 = QtWidgets.QPushButton(self.camSetting_3)
self.draw_CAM3.setObjectName("draw_CAM3")
self.remove_CAM3 = QtWidgets.QPushButton(self.camSetting_3)
self.remove_CAM3.setObjectName("remove_CAM3")
layoutCamSetting_3 = QGridLayout()
layoutCamSetting_3.addWidget(self.CAM3_Draw, 0, 0, 7, 4)
layoutCamSetting_3.addWidget(self.draw_CAM3, 8, 1)
layoutCamSetting_3.addWidget(self.remove_CAM3, 8, 2)
self.camSetting_3.setLayout(layoutCamSetting_3)
#layout Setting
layoutSetting = QGridLayout()
layoutSetting.addWidget(self.camSetting_1, 0, 0)
layoutSetting.addWidget(self.camSetting_2, 0, 1)
layoutSetting.addWidget(self.camSetting_3, 0, 2)
self.setting.setLayout(layoutSetting)
self.mediaPlayer.setVideoOutput(videowidget)
self.openBtn.clicked.connect(self.open_file)
self.playBtn.clicked.connect(self.play_video)
self.stopBtn.clicked.connect(self.stop_video)
self.fastBtn.clicked.connect(self.fast)
self.slowBtn.clicked.connect(self.slow)
self.volumeBtn.clicked.connect(self.mute)
self.fullscreenBtn.clicked.connect(self.fullscreen)
self.volume_slider.sliderMoved.connect(self.set_volume)
self.slider.sliderMoved.connect(self.set_position)
self.mediaPlayer.stateChanged.connect(self.mediastate_changed)
self.mediaPlayer.positionChanged.connect(self.position_changed)
self.mediaPlayer.durationChanged.connect(self.duration_changed)
self.startCAM1.setEnabled(True)
self.start_CAM2.setEnabled(True)
self.start_CAM3.setEnabled(True)
self.stopCAM1.setEnabled(False)
self.stop_CAM2.setEnabled(False)
self.stop_CAM3.setEnabled(False)
# create a timer
self.timer = QTimer()
self.timer2 = QTimer()
self.timer3 = QTimer()
# set timer timeout callback function
self.timer.timeout.connect(self.viewCam)
self.startCAM1.clicked.connect(self.start_view)
self.stopCAM1.clicked.connect(self.stop_view)
self.timer2.timeout.connect(self.viewCam2)
self.start_CAM2.clicked.connect(self.start_view2)
self.stop_CAM2.clicked.connect(self.stop_view2)
self.timer3.timeout.connect(self.viewCam3)
self.start_CAM3.clicked.connect(self.start_view3)
self.stop_CAM3.clicked.connect(self.stop_view3)
self.CAM1_Draw.mousePressEvent = self.mouseEventCAM1
self.CAM2_Draw.mousePressEvent = self.mouseEventCAM2
self.CAM3_Draw.mousePressEvent = self.mouseEventCAM3
self.draw_CAM1.clicked.connect(self.startDrawAreaCAM1)
self.remove_CAM1.clicked.connect(self.removeAreaCAM1)
self.draw_CAM2.clicked.connect(self.startDrawAreaCAM2)
self.remove_CAM2.clicked.connect(self.removeAreaCAM2)
self.draw_CAM3.clicked.connect(self.startDrawAreaCAM3)
self.remove_CAM3.clicked.connect(self.removeAreaCAM3)
self.retranslateUi(Form)
QtCore.QMetaObject.connectSlotsByName(Form)
a = QVBoxLayout()
a.addWidget(self.tabWidget)
Form.setLayout(a)
# all function
def retranslateUi(self, Form):
_translate = QtCore.QCoreApplication.translate
Form.setWindowTitle(_translate("Form", "Form"))
self.CAM1.setText(_translate("Form", "Cam 1"))
self.peoplecntBtn_1.setText(_translate("Form", "People Counting"))
self.falldetectionBtn_1.setText(_translate("Form", "Fall Detection"))
self.reIDBtn_1.setText(_translate("Form", "Person Re-ID"))
self.stopCAM1.setText(_translate("Form", "Stop"))
self.startCAM1.setText(_translate("Form", "Start"))
self.areaprotectionBtn_1.setText(_translate("Form", "Area Protection"))
self.CAM2.setText(_translate("Form", "cam 2"))
self.peoplecntBtn_2.setText(_translate("Form", "People Counting"))
self.falldetectionBtn_2.setText(_translate("Form", "Fall Detection"))
self.reIDBtn_2.setText(_translate("Form", "Person Re-ID"))
self.stop_CAM2.setText(_translate("Form", "Stop"))
self.start_CAM2.setText(_translate("Form", "Start"))
self.areaprotectionBtn_2.setText(_translate("Form", "Area Protection"))
self.CAM3.setText(_translate("Form", "cam 3"))
self.peoplecntBtn_3.setText(_translate("Form", "People Counting"))
self.falldetectionBtn_3.setText(_translate("Form", "Fall Detection"))
self.reIDBtn_3.setText(_translate("Form", "Person Re-ID"))
self.stop_CAM3.setText(_translate("Form", "Stop"))
self.start_CAM3.setText(_translate("Form", "Start"))
self.areaprotectionBtn_3.setText(_translate("Form", "Area Protection"))
self.CAM1_Draw.setText(_translate("Form", "cam 1"))
self.draw_CAM1.setText(_translate("Form", "Draw"))
self.remove_CAM1.setText(_translate("Form", "Clean"))
self.CAM2_Draw.setText(_translate("Form", "cam 2"))
self.draw_CAM2.setText(_translate("Form", "Draw"))
self.remove_CAM2.setText(_translate("Form", "Clean"))
self.CAM3_Draw.setText(_translate("Form", "cam 3"))
self.draw_CAM3.setText(_translate("Form", "Draw"))
self.remove_CAM3.setText(_translate("Form", "Clean"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.multiTab),
_translate("Form", "Multi_IPCam"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.playRec),
_translate("Form", "Play Record"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.setting),
_translate("Form", "Setting"))
def open_file(self):
filename, _ = QFileDialog.getOpenFileName(self, "Open Video")
if filename != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(filename)))
self.playBtn.setEnabled(True)
def play_video(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def stop_video(self):
self.mediaPlayer.stop()
def mediastate_changed(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def position_changed(self, position):
self.slider.setValue(position)
def duration_changed(self, duration):
self.slider.setRange(0, duration)
def set_position(self, position):
self.mediaPlayer.setPosition(position)
print(position)
def set_volume(self, volume):
self.mediaPlayer.setVolume(volume)
def mute(self):
if not self.mediaPlayer.isMuted():
self.mediaPlayer.setMuted(True)
self.volumeBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaVolumeMuted))
else:
self.mediaPlayer.setMuted(False)
self.volumeBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaVolume))
def handle_errors(self):
self.playBtn.setEnabled(False)
self.label.setText("Error: " + self.mediaPlayer.errorString())
self.startCAM1.clicked.connect(self.start)
self.stopCAM1.clicked.connect(self.stop)
def fullscreen(self):
if self.windowState() & Qt.WindowFullScreen:
QApplication.setOverrideCursor(Qt.ArrowCursor)
self.showNormal()
print("no Fullscreen")
else:
Form.showFullScreen()
QApplication.setOverrideCursor(Qt.BlankCursor)
print("Fullscreen entered")
def fast(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() + 10 * 60)
def slow(self):
self.mediaPlayer.setPosition(self.mediaPlayer.position() - 10 * 60)
def image_to_QImage(self, image, label):
# print(label.width(), label.height())
# image = cv2.resize(image, (label.width(), label.height()))
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
height, width, channel = image.shape
# print(height, width, channel)
step = channel * width
return QImage(image.data, width, height, step, QImage.Format_RGB888)
def viewCam(self):
ret, image = self.cap.read()
self.outVivdeo.write(image)
self.CAM1_Draw.setPixmap(
QPixmap.fromImage(
self.image_to_QImage(
self.drawArea(image, self.points_CAM1, self.CAM1_Draw),
self.CAM1_Draw)))
self.CAM1.setPixmap(
QPixmap.fromImage(self.image_to_QImage(image, self.CAM1)))
def start_view(self):
if not self.timer.isActive():
self.stopCAM1.setEnabled(True)
self.startCAM1.setEnabled(False)
self.cap = cv2.VideoCapture(IP_CAM_ADDRESS['CAM1'])
self.flag_CAM1 = self.cap.isOpened()
if self.cap.isOpened():
now = datetime.now()
self.savePath1 = self.createDir('IP_CAM_1')
self.startTime1 = str(now.day) + ' - ' + str(
now.hour) + 'h' + str(now.minute) + ' - '
# fourcc = cv2.VideoWriter_fourcc(*'mp4v')
fourcc = cv2.VideoWriter_fourcc(*'XVID')
self.outVivdeo = cv2.VideoWriter(
self.savePath1 + 'output.avi', fourcc, 30,
(int(self.cap.get(3)), int(self.cap.get(4))))
self.timer.start(0)
else:
self.startCAM1.setEnabled(True)
self.stopCAM1.setEnabled(False)
image = cv2.imread('no-connection.jpg')
self.CAM1.setPixmap(
QPixmap.fromImage(self.image_to_QImage(image, self.CAM1)))
def stop_view(self):
self.startCAM1.setEnabled(True)
self.stopCAM1.setEnabled(False)
self.timer.stop()
self.cap.release()
self.outVivdeo.release()
print("ok")
image = cv2.imread('stopVideo.png')
self.CAM1.setPixmap(
QPixmap.fromImage(self.image_to_QImage(image, self.CAM1)))
print('ok2')
now = datetime.now()
fileName = self.startTime1 + str(now.hour) + 'h' + str(
now.minute) + '.avi'
os.rename(self.savePath1 + 'output.avi', self.savePath1 + fileName)
def viewCam2(self):
ret, image = self.cap2.read()
self.outVivdeo2.write(image)
self.CAM2_Draw.setPixmap(
QPixmap.fromImage(
self.image_to_QImage(
self.drawArea(image, self.points_CAM2, self.CAM2_Draw),
self.CAM2_Draw)))
self.CAM2.setPixmap(
QPixmap.fromImage(self.image_to_QImage(image, self.CAM2)))
def start_view2(self):
if not self.timer2.isActive():
self.stop_CAM2.setEnabled(True)
self.start_CAM2.setEnabled(False)
self.cap2 = cv2.VideoCapture(IP_CAM_ADDRESS['CAM2'])
self.flag_CAM2 = self.cap2.isOpened()
if self.cap2.isOpened():
now = datetime.now()
self.savePath2 = self.createDir('IP_CAM_2')
self.startTime2 = str(now.day) + ' - ' + str(
now.hour) + 'h' + str(now.minute) + ' - '
# fourcc = cv2.VideoWriter_fourcc(*'mp4v')
fourcc = cv2.VideoWriter_fourcc(*'XVID')
self.outVivdeo2 = cv2.VideoWriter(
self.savePath2 + 'output2.avi', fourcc, 30,
(int(self.cap2.get(3)), int(self.cap2.get(4))))
self.timer2.start(0)
else:
self.start_CAM2.setEnabled(True)
self.stop_CAM2.setEnabled(False)
image = cv2.imread('no-connection.jpg')
self.CAM2.setPixmap(
QPixmap.fromImage(self.image_to_QImage(image, self.CAM2)))
def stop_view2(self):
self.start_CAM2.setEnabled(True)
self.stop_CAM2.setEnabled(False)
self.timer2.stop()
self.outVivdeo2.release()
image = cv2.imread('stopVideo.png')
self.CAM2.setPixmap(
QPixmap.fromImage(self.image_to_QImage(image, self.CAM2)))
self.cap2.release()
now = datetime.now()
fileName = self.startTime2 + str(now.hour) + 'h' + str(
now.minute) + '.avi'
os.rename(self.savePath2 + 'output2.avi', self.savePath2 + fileName)
def viewCam3(self):
ret, image = self.cap3.read()
self.outVivdeo3.write(image)
self.CAM3_Draw.setPixmap(
QPixmap.fromImage(
self.image_to_QImage(
self.drawArea(image, self.points_CAM3, self.CAM3_Draw),
self.CAM3_Draw)))
self.CAM3.setPixmap(
QPixmap.fromImage(self.image_to_QImage(image, self.CAM3)))
def start_view3(self):
if not self.timer3.isActive():
self.stop_CAM3.setEnabled(True)
self.start_CAM3.setEnabled(False)
self.cap3 = cv2.VideoCapture(IP_CAM_ADDRESS['CAM3'])
self.flag_CAM3 = self.cap3.isOpened()
if self.cap3.isOpened():
now = datetime.now()
self.savePath3 = self.createDir('IP_CAM_3')
self.startTime3 = str(now.day) + ' - ' + str(
now.hour) + 'h' + str(now.minute) + ' - '
# fourcc = cv2.VideoWriter_fourcc(*'mp4v')
fourcc = cv2.VideoWriter_fourcc(*'XVID')
self.outVivdeo3 = cv2.VideoWriter(
self.savePath3 + 'output3.avi', fourcc, 30,
(int(self.cap3.get(3)), int(self.cap3.get(4))))
self.timer3.start(0)
else:
self.start_CAM3.setEnabled(True)
self.stop_CAM3.setEnabled(False)
image = cv2.imread('no-connection.jpg')
self.CAM3.setPixmap(
QPixmap.fromImage(self.image_to_QImage(image, self.CAM3)))
def stop_view3(self):
self.start_CAM3.setEnabled(True)
self.stop_CAM3.setEnabled(False)
self.timer3.stop()
self.outVivdeo3.release()
image = cv2.imread('stopVideo.png')
self.CAM3.setPixmap(
QPixmap.fromImage(self.image_to_QImage(image, self.CAM3)))
self.cap3.release()
now = datetime.now()
fileName = self.startTime3 + str(now.hour) + 'h' + str(
now.minute) + '.avi'
os.rename(self.savePath3 + 'output3.avi', self.savePath3 + fileName)
def createDir(self, IP_CAM_Number: str):
now = datetime.now()
year = now.year
month = MONTH[now.month]
curPath = os.getcwd()
if not path.exists(curPath + '/IVA'):
os.mkdir(curPath + '/IVA')
if not path.exists(curPath + '/IVA/' + IP_CAM_Number):
os.mkdir(curPath + '/IVA/' + IP_CAM_Number)
# check path exists
if path.exists(curPath + '/IVA/' + IP_CAM_Number + '/' + str(year)):
if path.exists(curPath + '/IVA/' + IP_CAM_Number + '/' +
str(year) + '/' + month):
return curPath + '/IVA/' + IP_CAM_Number + '/' + str(
year) + '/' + month + '/'
else:
os.mkdir(curPath + '/IVA/' + IP_CAM_Number + '/' + str(year) +
'/' + month)
return curPath + '/IVA/' + IP_CAM_Number + '/' + str(
year) + '/' + month + '/'
else:
os.mkdir(curPath + '/IVA/' + IP_CAM_Number + '/' + str(year))
if path.exists(curPath + '/IVA/' + IP_CAM_Number + '/' +
str(year) + '/' + month):
return curPath + '/IVA/' + IP_CAM_Number + '/' + str(
year) + '/' + month + '/'
else:
os.mkdir(curPath + '/IVA/' + IP_CAM_Number + '/' + str(year) +
'/' + month)
return curPath + '/IVA/' + IP_CAM_Number + '/' + str(
year) + '/' + month + '/'
# Create Mouse Event for draw protected area
def mouseEventCAM1(self, event):
if self.remove_CAM1.isEnabled() and (
not self.startCAM1.isEnabled()) and self.flag_CAM1 == True:
x = event.pos().x()
y = event.pos().y()
self.points_CAM1.append([x, y])
print("Position clicked is ({}, {})".format(x, y))
def mouseEventCAM2(self, event):
if self.remove_CAM2.isEnabled() and (
not self.start_CAM2.isEnabled()) and self.flag_CAM2 == True:
x = event.pos().x()
y = event.pos().y()
self.points_CAM2.append([x, y])
print("Position clicked is ({}, {})".format(x, y))
def mouseEventCAM3(self, event):
if self.remove_CAM3.isEnabled() and (
not self.start_CAM3.isEnabled()) and self.flag_CAM3 == True:
x = event.pos().x()
y = event.pos().y()
self.points_CAM3.append([x, y])
print("Position clicked is ({}, {})".format(x, y))
def startDrawAreaCAM1(self):
self.draw_CAM1.setEnabled(False)
self.remove_CAM1.setEnabled(True)
def removeAreaCAM1(self):
while len(self.points_CAM1):
self.points_CAM1.pop()
self.draw_CAM1.setEnabled(True)
self.remove_CAM1.setEnabled(False)
def startDrawAreaCAM2(self):
self.draw_CAM2.setEnabled(False)
self.remove_CAM2.setEnabled(True)
def removeAreaCAM2(self):
while len(self.points_CAM2):
self.points_CAM2.pop()
self.draw_CAM2.setEnabled(True)
self.remove_CAM2.setEnabled(False)
def startDrawAreaCAM3(self):
self.draw_CAM3.setEnabled(False)
self.remove_CAM3.setEnabled(True)
def removeAreaCAM3(self):
while len(self.points_CAM3):
self.points_CAM3.pop()
self.draw_CAM3.setEnabled(True)
self.remove_CAM3.setEnabled(False)
def drawArea(self, image, points: list, qlabel: QtWidgets.QLabel):
image_draw = image.copy()
image_draw = cv2.resize(image_draw, (qlabel.width(), qlabel.height()))
if len(points) > 1:
cv2.polylines(image_draw, np.array([points]), 1, (255, 0, 0), 1)
b, g, r = cv2.split(image_draw)
cv2.fillPoly(b, np.array([points]), (0, 255, 0))
cv2.fillPoly(r, np.array([points]), (0, 255, 0))
image_draw = cv2.merge([b, g, r])
return image_draw
class MainWindow(QMainWindow):
"""docstring for MainWindow"""
def __init__(self):
super(MainWindow, self).__init__()
self.setupUi(self)
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(800, 600)
self.centralwidget = QtWidgets.QWidget(MainWindow)
gridlayout = QGridLayout(self.centralwidget)
hlayout = QHBoxLayout()
self.button1 = QPushButton(' add image ')
self.button3 = QPushButton('add video')
self.button2 = QPushButton('remove')
self.playbutton = QPushButton('play')
self.stopbutton = QPushButton('stop')
hlayout.addWidget(self.button1)
hlayout.addWidget(self.button3)
hlayout.addWidget(self.button2)
hlayout.addWidget(self.playbutton)
hlayout.addWidget(self.stopbutton)
self.scene = QGraphicsScene()
self.item = QGraphicsPixmapItem()
imgpath = 'C:\\Users\Administrator\Pictures\Saved Pictures\\1.jpg'
self.item.setPixmap(QtGui.QPixmap(imgpath))
self.scene.addItem(self.item)
self.graphicsview = QGraphicsView()
self.graphicsview.setScene(self.scene)
self.tabwidget = QTabWidget()
vlayout = QVBoxLayout()
vlayout.addLayout(hlayout)
vlayout.addWidget(self.tabwidget)
MainWindow.setCentralWidget(self.centralwidget)
gridlayout.addLayout(vlayout, 0, 0, 1, 1)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
self.button1.clicked.connect(self.addTab)
self.button2.clicked.connect(self.closeTab)
self.button3.clicked.connect(self.addVideo)
self.playbutton.clicked.connect(self.palyMedia)
self.stopbutton.clicked.connect(self.stopMedia)
pass
def addTab(self, signal):
scene = QGraphicsScene()
item = QGraphicsPixmapItem()
# imgpath = 'C:/Users/liesmars/Desktop/1.jpg'
item.setPixmap(QtGui.QPixmap(imgpath))
scene.addItem(item)
graphicsview = QGraphicsView()
graphicsview.setScene(scene)
self.tabwidget.addTab(graphicsview, "tab2")
self.tabwidget.setCurrentWidget(graphicsview)
def addVideo(self, signal):
videowidget = QVideoWidget()
self.videoplayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoplayer.setVideoOutput(videowidget)
# videopath = 'C:/Users/liesmars/Desktop/1.mp4'
self.videoplayer.setMedia(QMediaContent(QUrl.fromLocalFile(videopath)))
self.tabwidget.addTab(videowidget, "tab4")
self.tabwidget.setCurrentWidget(videowidget)
def closeTab(self):
tabID = self.tabwidget.currentIndex()
self.tabwidget.removeTab(tabID)
pass
def palyMedia(self, signal):
self.videoplayer.play()
pass
def stopMedia(self, signal):
self.videoplayer.pause()
pass
class DPlayerCore(QWidget):
def __init__(self):
"""Initialize player and load playlist if any."""
super().__init__()
self.player = QMediaPlayer()
self.playlist = QMediaPlaylist()
self.player.setPlaylist(self.playlist)
self.shuffling = False
self.repeatingPlaylist = False
self.repeatingSong = False
self.musicOrder = []
self.loadPlaylist(QUrl(
'file://{}/lastListened.m3u'.format(os.getcwd())))
self.lyricsApi = 'http://api.musixmatch.com/ws/1.1/'
self.lyricsApiKey = '4b364f0652e471aa50813a22cdf830ea'
self.lastFMapi = 'http://ws.audioscrobbler.com/2.0/'
self.lastFMapikey = '052c43a00a4fc294bb3c9e0c38bdf710'
self.lastFMsecret = '14c66392fa9c6c142a41ccc2b0674e19'
self.username = None
self.password = None
self.network = None
self.error = 'Something went wrong! Try again later.'
def play(self):
"""Start the player."""
self.player.play()
def pause(self):
"""Pause the player."""
self.player.pause()
def stop(self):
"""Stop the player."""
self.player.stop()
def previous(self):
"""Play previous song."""
self.playlist.previous()
def next(self):
"""Play next song."""
self.playlist.next()
def mute(self):
"""Mute the player."""
self.player.setMuted(True)
def unmute(self):
"""Unmute the player."""
self.player.setMuted(False)
def setVolume(self, value):
"""Set player's volume to value."""
self.player.setVolume(value)
def add(self, fileNames):
"""Add fileNames to the playlist."""
for name in fileNames:
url = QUrl.fromLocalFile(QFileInfo(name).absoluteFilePath())
self.playlist.addMedia(QMediaContent(url))
self.musicOrder.append([name])
self.added(len(fileNames))
def added(self, added):
"""Saves music info in musicOrder."""
for name, index in zip(
self.musicOrder[self.playlist.mediaCount() - added:],
range(self.playlist.mediaCount() - added,
len(self.musicOrder))):
name = name[0]
artist = self.getArtist(name)[0]
title = self.getTitle(name)[0]
album = self.getAlbum(name)[0]
seconds = self.getDuration(name)
duration = QTime(0, seconds // 60, seconds % 60)
duration = duration.toString('mm:ss')
self.musicOrder[index].extend(
[artist, title, album, duration])
def remove(self, songIndexes):
"""Remove songIndexes from the playlist."""
for index in songIndexes:
self.songChanged = True
del self.musicOrder[index]
self.playlist.removeMedia(index)
self.songChanged = False
def savePlaylist(self, path):
"""Save playlist to path."""
if path.toString()[len(path.toString()) - 4:] != '.m3u':
path = QUrl('{}.m3u'.format(path.toString()))
self.playlist.save(path, 'm3u')
def loadPlaylist(self, path):
"""Load playlist form path."""
count = self.playlist.mediaCount()
self.playlist.load(path)
for index in range(count, self.playlist.mediaCount()):
self.musicOrder.append(
[self.playlist.media(index).canonicalUrl().path()])
self.added(self.playlist.mediaCount() - count)
def clearPlaylist(self):
"""Delete all songs in the playlist."""
self.playlist.clear()
self.musicOrder = []
def shuffle(self, value):
"""Shuffle playlist if value = True."""
self.shuffling = value
if self.repeatingSong:
return
if self.shuffling:
self.playlist.setPlaybackMode(QMediaPlaylist.Random)
elif self.repeatingPlaylist:
self.playlist.setPlaybackMode(QMediaPlaylist.Loop)
else:
self.playlist.setPlaybackMode(QMediaPlaylist.Sequential)
def repeatPlaylist(self, value):
"""Repeat playlist after the last song is finished if value = True."""
self.repeatingPlaylist = value
if self.repeatingSong or self.shuffling:
return
if self.repeatingPlaylist:
self.playlist.setPlaybackMode(QMediaPlaylist.Loop)
else:
self.playlist.setPlaybackMode(QMediaPlaylist.Sequential)
def repeatSong(self, value):
"""Repeat current song if value = True."""
self.repeatingSong = value
if self.repeatingSong:
self.playlist.setPlaybackMode(QMediaPlaylist.CurrentItemInLoop)
elif self.shuffling:
self.playlist.setPlaybackMode(QMediaPlaylist.Random)
elif self.repeatingPlaylist:
self.playlist.setPlaybackMode(QMediaPlaylist.Loop)
else:
self.playlist.setPlaybackMode(QMediaPlaylist.Sequential)
def sort(self, column, order):
"""Sort playlist by column in order."""
ordered = sorted(self.musicOrder, key=itemgetter(column + 1),
reverse=order)
self.clearPlaylist()
for song in ordered:
url = QUrl.fromLocalFile(QFileInfo(song[0]).absoluteFilePath())
self.playlist.addMedia(QMediaContent(url))
self.musicOrder = ordered
def findLyrics(self, index):
"""Returns lyrics for song at index."""
if self.musicOrder[index][2] == 'Unknown':
return 'Unknown song.'
searchSong = '{}track.search?q_track={}'.format(
self.lyricsApi, self.musicOrder[index][2].replace(' ', '%20'))
if self.musicOrder[index][1] != 'Unknown':
searchSong = '{}&q_artist={}'.format(
searchSong, self.musicOrder[index][1].replace(' ', '%20'))
searchSong = '{}&f_has_lyrics=1&apikey={}'.format(
searchSong, self.lyricsApiKey)
try:
requestSong = requests.get(searchSong)
except requests.ConnectionError:
return self.error
songJson = requestSong.json()
if requestSong.status_code != 200 or \
songJson['message']['header']['available'] == 0:
return self.error
songId = songJson[
'message']['body']['track_list'][0]["track"]["track_id"]
searchLyrics = '{}track.lyrics.get?track_id={}&apikey={}'.format(
self.lyricsApi, songId, self.lyricsApiKey)
try:
requestLyrics = requests.get(searchLyrics)
except requests.ConnectionError:
return self.error
if requestLyrics.status_code != 200 or \
songJson['message']['header']['available'] == 0:
return self.error
return requestLyrics.json()[
'message']['body']['lyrics']['lyrics_body'][:-58] # spam and bacon
def findInfo(self, index):
"""Returns info about artist and album for index if any."""
info = []
if self.musicOrder[index][1] != 'Unknown':
artist = self.artistInfo(self.musicOrder[index][1])
if artist != self.error:
info += artist
if self.musicOrder[index][1] != 'Unknown' and \
self.musicOrder[index][3] != 'Unknown':
album = self.albumInfo(self.musicOrder[index][1],
self.musicOrder[index][3])
if album != self.error:
info += album
if info:
return info
else:
return ['Unknown artist and song!']
def artistInfo(self, artist):
"""Returns info about artist if any."""
try:
response = requests.get(
('{}/?method=artist.getinfo&artist={}&api_key={}&'
'format=json&autocorrect=1').format(
self.lastFMapi, artist, self.lastFMapikey))
except Exception:
return self.error
if response.status_code != 200:
return self.error
artist = 'Artist: {}'.format(response.json()['artist']['name'])
bio = 'Bio: {}'.format(
response.json()['artist']['bio']['summary'].replace('.', '.\n'))
spam = bio.find('<a')
bio = bio[:spam]
return [artist, bio]
def albumInfo(self, artist, album):
"""Returns info about album if any."""
try:
response = requests.get(
('{}/?method=album.getinfo&artist={}&album={}&api_key={}&'
'format=json&autocorrect=1').format(
self.lastFMapi, artist, album, self.lastFMapikey))
except Exception:
return self.error
if response.status_code != 200 or \
'album' not in response.json().keys():
return self.error
album = 'Album: {}'.format(response.json()['album']['name'])
tracks = ['Tracks: ']
t = response.json()['album']['tracks']['track']
for track, index in zip(t, range(len(t))):
tracks.append('{}. {}'.format(index + 1, track['name']))
info = [album, '\n'.join(tracks)]
if 'wiki' in response.json()['album'].keys():
wiki = response.json()['album']['wiki']
if 'published' in wiki.keys():
info.append('Published: {}'.format(wiki['published']))
if 'summary' in wiki.keys():
summary = wiki['summary'].replace('.', '.\n')
spam = summary.find('<a')
info.append('Summary: {}'.format(summary[:spam]))
if 'Musical style' in wiki.keys():
info.append('Musical style: {}'.format(wiki['Musical style']))
return info
def login(self, username, password):
"""Creates lastFM network."""
self.username = username
self.password = pylast.md5(password)
try:
self.network = pylast.LastFMNetwork(api_key=self.lastFMapikey,
api_secret=self.lastFMsecret,
username=self.username,
password_hash=self.password)
except Exception:
self.username = None
self.password = None
self.network = None
return False
return True
def logout(self):
"""Destoys lastFM network and current user info."""
self.username = None
self.password = None
self.network = None
def loveTrack(self, index):
"""Love track at index in lastFM."""
if self.network is None:
return False
track = self.network.get_track(self.musicOrder[index][1],
self.musicOrder[index][2])
try:
track.love()
except Exception:
return False
return True
def unloveTrack(self, index):
"""Unlove track at index in lastFM."""
if self.network is None:
return False
track = self.network.get_track(self.musicOrder[index][1],
self.musicOrder[index][2])
try:
track.unlove()
except Exception:
return False
return True
def isMuted(self):
"""Returns True if player is muted."""
return self.player.isMuted()
def getArtist(self, song):
"""Returns the artist of song."""
if song[-4:] == '.mp3':
obj = EasyID3(song)
if 'artist' in obj.keys():
return obj['artist']
elif 'TAG' in mediainfo(song).keys():
obj = mediainfo(song)['TAG']
if 'artist' in obj.keys():
return [obj['artist']]
elif 'ARTIST' in obj.keys():
return [obj['ARTIST']]
else:
return ['Unknown']
else:
return ['Unknown']
def getTitle(self, song):
"""Returns the title of song."""
if song[-4:] == '.mp3':
obj = EasyID3(song)
if 'title' in obj.keys():
return obj['title']
elif 'TAG' in mediainfo(song).keys():
obj = mediainfo(song)['TAG']
if 'title' in obj.keys():
return [obj['title']]
elif 'TITLE' in obj.keys():
return [obj['TITLE']]
else:
return ['Unknown']
else:
return ['Unknown']
def getAlbum(self, song):
"""Returns the album of song."""
if song[-4:] == '.mp3':
obj = EasyID3(song)
if 'album' in obj.keys():
return obj['album']
elif 'TAG' in mediainfo(song).keys():
obj = mediainfo(song)['TAG']
if 'album' in obj.keys():
return [obj['album']]
elif 'ALBUM' in obj.keys():
return [obj['ALBUM']]
else:
return ['Unknown']
else:
return ['Unknown']
def getDuration(self, song):
"""Returns the duration of song."""
if song[-4:] == '.mp3':
return MP3(song).info.length
return int(float(mediainfo(song)['duration']))
class ApplicationWindow(QtWidgets.QMainWindow):
global wavFileName
global fig,chartFig
global duration, counterClick
global colorName, text_
global startAnnotation, endTimeToPlay
# >> QtMultimedia Signals
#----------------------
play = pyqtSignal()
pause = pyqtSignal()
stop = pyqtSignal()
def __init__(self):
global playerStarted
global wavFileName, fig, chartFig
global playerStarted, durationFlag, duration
global colorName, text_, counterClick
global startAnnotation, endTimeToPlay
QtWidgets.QMainWindow.__init__(self)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.main_widget = QtWidgets.QWidget(self)
playerStarted = False
#DEFINE PLAYER-PLAYLIST
#----------------------
self.source = QtCore.QUrl.fromLocalFile(os.path.abspath(wavFileName))
self.content = QMediaContent(self.source)
self.player = QMediaPlayer()
self.playlist = QMediaPlaylist(self)
self.playlist.addMedia(self.content)
self.player.setPlaylist(self.playlist)
# >> Define annotations and gantt chart
#----------------------
self.wave = Waveform()
fig = self.wave
self.chart = Chart()
chartFig = self.chart
# >> Define player buttons
#----------------------
playButton = QPushButton("Play")
pauseButton = QPushButton("Pause")
stopButton = QPushButton("Stop")
# >> Define layouts
#----------------------
waveLayout = QVBoxLayout()
waveLayout.addWidget(self.wave)
waveLayout.addWidget(self.chart)
line = QFrame()
line.setFrameShape(QFrame.VLine)
line.setSizePolicy(QSizePolicy.Minimum,QSizePolicy.Expanding)
waveLayout.addWidget(line)
#Buttons layout
buttonLayout = QVBoxLayout()
buttonLayout.addWidget(playButton)
buttonLayout.addWidget(pauseButton)
buttonLayout.addWidget(stopButton)
buttonLayout.setAlignment(Qt.AlignTop)
# >> Specify final layout align
#----------------------
layout = QHBoxLayout(self.main_widget)
layout.addLayout(waveLayout)
layout.addLayout(buttonLayout)
# >> Define buttons connections
#----------------------
playButton.clicked.connect(self.Play)
pauseButton.clicked.connect(self.Pause)
stopButton.clicked.connect(self.Stop)
self.main_widget.setFocus()
self.setCentralWidget(self.main_widget)
# PLAYER BUTTON FUNCTIONS
# >> Play audio (whole signal or segment)
#----------------------
def Play(self):
global playerStarted
global durationFlag
global duration, counterClick
global startTimeToPlay, endTimeToPlay, first
#GET CLICKS FROM WAVEFORM
#----------------------
#Initialize connection-position ONCE
if not playerStarted:
#10ms for changePosition -> Not Delaying
self.player.positionChanged.connect(self.checkPositionToStop)
self.player.setNotifyInterval(10)
if durationFlag==0:
playerStarted = True
startTimeToPlay = 0
self.start = startTimeToPlay
self.end = duration*1000 - 10
endTimeToPlay = self.end
counterClick = 3
elif durationFlag==1:
playerStarted = True
self.start = startTimeToPlay
self.end = duration*1000 - 10
endTimeToPlay = self.end
counterClick = 3
elif durationFlag==2:
playerStarted = True
self.start = startTimeToPlay
self.end = endTimeToPlay
self.player.setPosition(self.start)
playFlag = True
self.player.play()
# >> Pause audio playing
#----------------------
def Pause(self):
#Not begging from self.start
playerStarted = True
self.player.setPosition(self.time_)
self.player.pause()
# >> Stop audio playing
#----------------------
def Stop(self):
self.player.stop()
#Begin again segment
self.start = startTimeToPlay
self.player.setPosition(self.start)
# >> Check ms in audio to stop play
#----------------------
def checkPositionToStop(self):
self.time_ = self.player.position()
print self.time_
if self.time_ >= self.end:
self.Stop()
self.player.setPosition(self.start)
def fileQuit(self):
self.close()
def closeEvent(self, ce):
self.fileQuit()
class Game(QObject):
next_tetromino_updated = pyqtSignal(Tetromino)
field_updated = pyqtSignal(list)
score_updated = pyqtSignal(int)
level_updated = pyqtSignal(int)
lines_updated = pyqtSignal(int)
stamped_tetromino = pyqtSignal()
pre_clear = pyqtSignal(list)
game_window_action = pyqtSignal(GameWindowAction)
def __init__(self, height, width, main_window, start_level=0):
QObject.__init__(self)
self.tetris_music = str(Path(__file__).parent / "sounds" / "Tetris_theme.wav")
self.playlist = QMediaPlaylist()
self.playlist.addMedia(QMediaContent(QUrl.fromLocalFile(self.tetris_music)))
self.playlist.setPlaybackMode(QMediaPlaylist.Loop)
self.player = QMediaPlayer()
self.player.setPlaylist(self.playlist)
self.player.setVolume(50)
self.main_window = main_window
self.sound_manager = SoundManager(self)
# Connections
self.game_window_action.connect(self.sound_manager.on_game_window_action)
self.next_tetromino_updated.connect(self.main_window.on_next_tetromino_update)
self.field_updated.connect(self.main_window.on_field_update)
self.score_updated.connect(self.main_window.on_score_update)
self.level_updated.connect(self.main_window.on_level_update)
self.lines_updated.connect(self.main_window.on_lines_update)
self.lines_updated.connect(self.update_level)
self.stamped_tetromino.connect(self.check_complete_lines)
self.pre_clear.connect(self.main_window.pre_clear_animation)
# https://tetris.wiki/Scoring
self.line_score_base = [40, 100, 300, 1200]
# https://tetris.wiki/Tetris_(Game_Boy)
self.frames_per_second = 59.73
self.level_speed_frames = [
53,
49,
45,
41,
37,
33,
28,
22,
17,
11,
10,
9,
8,
7,
6,
6,
5,
5,
4,
4,
3,
]
self.on_hard_dropping = False
self.is_running = False
self.height = height
self.width = width
self.playing_cursor = (0, 0)
self.current_tetromino = None
# PROPERTY!
self._total_removed_lines = 0
self.soft_drops = 0
self.level = start_level
# PROPERTY!
self._score = 0
self.field = [[0] * self.width for i in range(self.height)]
self.initialise_field(self.field)
self.pause = False
self.move_timer = None
self.collision_detected = False
self.next_tetromino = Tetromino(choice(list(TetrominoType)))
self.build_next_tetromino()
def initialise_field(self, field):
# initialise/draw walls and ground
for h in range(self.height):
field[h][0] = -1
field[h][-1] = -1
for w in range(self.width):
field[-1][w] = -2
def update_field(self):
final_field = deepcopy(self.field)
self.draw_shadow_tetromino(final_field)
self.merge_tetromino_with_field(self.current_tetromino, final_field)
self.field_updated.emit(final_field)
def draw_shadow_tetromino(self, final_field):
shadow_h, shadow_w = self.playing_cursor
while self.is_possible((shadow_h, shadow_w), self.current_tetromino):
shadow_h += 1
shadow_h -= 1
shadow_cursor = (shadow_h, shadow_w)
self.merge_tetromino_with_field(self.current_tetromino, final_field, shadow_cursor)
def on_game_over(self):
self.sound_manager.on_game_window_action(GameWindowAction.GAME_OVER)
def handle_input(self, key):
# MOVE
if (key == QtCore.Qt.Key_Left or key == QtCore.Qt.Key_A) and not self.pause:
self.move(Action.LEFT)
# MOVE
elif (key == QtCore.Qt.Key_Right or key == QtCore.Qt.Key_D) and not self.pause:
self.move(Action.RIGHT)
# MOVE
elif (key == QtCore.Qt.Key_Down or key == QtCore.Qt.Key_S) and not self.pause:
self.move_timer.stop()
self.move(Action.DOWN)
self.move_timer.setInterval(self.calculate_move_speed())
self.move_timer.start()
self.soft_drops += 1
# ROTATION
elif key == QtCore.Qt.Key_K and not self.pause:
if self.current_tetromino.tetromio_type == TetrominoType.O_BRICK:
self.game_window_action.emit(GameWindowAction.NONSENSE_ROTATION)
elif self.rotate_clockwise_tetromino():
self.game_window_action.emit(GameWindowAction.ROTATION)
# ROTATION
elif key == QtCore.Qt.Key_J and not self.pause:
if self.current_tetromino.tetromio_type == TetrominoType.O_BRICK:
self.game_window_action.emit(GameWindowAction.NONSENSE_ROTATION)
else:
if self.rotate_counter_clockwise_tetromino():
self.game_window_action.emit(GameWindowAction.ROTATION)
# HARD DROP
elif key == QtCore.Qt.Key_Space and not self.pause:
self.game_window_action.emit(GameWindowAction.HARD_DROP)
self.move_timer.stop()
self.move(Action.DROP)
self.move_timer.setInterval(self.calculate_move_speed())
self.move_timer.start()
# PAUSE
elif key == QtCore.Qt.Key_P:
self.pause_game()
if key != QtCore.Qt.Key_P and not self.pause:
self.update_field()
def pause_game(self, play_sound=True):
self.pause = not self.pause
if self.pause:
if play_sound:
self.game_window_action.emit(GameWindowAction.PAUSE_ACTIVED)
self.move_timer.stop()
self.main_window.game_timer.stop()
self.main_window.write_pause()
self.player.pause()
else:
self.player.play()
if play_sound:
self.game_window_action.emit(GameWindowAction.PAUSE_INACTIVATED)
self.move_timer.start()
self.main_window.game_timer.start()
self.main_window.clear_pause_label()
def rotate_clockwise_tetromino(self):
return self._rotate(RotationType.CLOCKWISE)
def rotate_counter_clockwise_tetromino(self):
return self._rotate(RotationType.COUNTER_CLOCKWISE)
def _rotate(self, rotation_type):
rotated_tetromino = deepcopy(self.current_tetromino)
rotated_tetromino.rotate(rotation_type)
if self.is_possible(self.playing_cursor, rotated_tetromino):
self.current_tetromino = rotated_tetromino
return True
return False
def move(self, action=Action.DOWN):
h, w = self.playing_cursor
if action == Action.DOWN:
h += 1
elif action == Action.LEFT:
w -= 1
elif action == Action.RIGHT:
w += 1
elif action == Action.DROP:
self.on_hard_dropping = True
while self.move(Action.DOWN):
pass
# self.on_hard_dropping = False
return
new_pos = (h, w)
if self.is_possible(new_pos, self.current_tetromino):
self.playing_cursor = new_pos
if not self.on_hard_dropping:
self.update_field()
return True
else:
if action != Action.LEFT and action != Action.RIGHT:
self.collision_detected = True
return False
def calculate_move_speed(self):
level = min(self.level, len(self.level_speed_frames) - 1)
speed_frames = self.level_speed_frames[level]
return (speed_frames / self.frames_per_second) * 1000 # ms
def running(self):
if not self.move_timer:
self.move_timer = QTimer()
self.move_timer.timeout.connect(self.move)
self.move_timer.start(self.calculate_move_speed())
self.update_field()
# if first round, start in pause-mode
if self.main_window.rounds == 1:
self.pause_game()
if self.collision_detected:
self.stamp_tetromino()
# spawn next tetomino
self.collision_detected = self.build_next_tetromino()
self.is_running = not self.collision_detected
return self.is_running
def build_next_tetromino(self):
next_tetromino = self.next_tetromino
self.next_tetromino = Tetromino(choice(list(TetrominoType)))
if self.spawn(next_tetromino):
self.update_field()
self.next_tetromino_updated.emit(self.next_tetromino)
return False
else:
# draw collided tetromino in spawn (game over collision)
self.update_field()
return True
def spawn(self, tetromino, pos=None):
# https://tetris.fandom.com/wiki/Tetris_Guideline
# (last visit 2020-03-14)
self.current_tetromino = tetromino
tetromino_type = tetromino.tetromio_type
if pos:
self.playing_cursor = pos
else:
if tetromino_type == TetrominoType.I_BRICK:
self.playing_cursor = (0, 4)
elif tetromino_type == TetrominoType.J_BRICK:
self.playing_cursor = (1, 4)
elif tetromino_type == TetrominoType.L_BRICK:
self.playing_cursor = (1, 4)
elif tetromino_type == TetrominoType.O_BRICK:
self.playing_cursor = (1, 4)
elif tetromino_type == TetrominoType.S_BRICK:
self.playing_cursor = (1, 4)
elif tetromino_type == TetrominoType.T_BRICK:
self.playing_cursor = (1, 4)
elif tetromino_type == TetrominoType.Z_BRICK:
self.playing_cursor = (1, 4)
else:
raise "UNKNOWN TETROMINO"
return self.is_possible(self.playing_cursor, self.current_tetromino)
def is_possible(self, pos, tetromino):
future_cursor_h, future_cursor_w = pos
tetromino_h = len(tetromino.brick_matrix)
tetromino_w = len(tetromino.brick_matrix[0])
for h in range(tetromino_h):
for w in range(tetromino_w):
value = tetromino.brick_matrix[h][w]
if value != 0:
if (future_cursor_h + h) not in range(self.height) or (
future_cursor_w + w
) not in range(self.width):
return False
field_value = self.field[future_cursor_h + h][future_cursor_w + w]
if field_value != 0:
return False
return True
def stamp_tetromino(self):
if self.on_hard_dropping:
self.on_hard_dropping = False
else:
self.game_window_action.emit(GameWindowAction.STAMP)
self.merge_tetromino_with_field(self.current_tetromino, self.field)
self.stamped_tetromino.emit()
self.score += self.soft_drops
self.soft_drops = 0
def check_complete_lines(self):
complete_lines = []
for h in reversed(range(self.height - 1)):
completed_line = True
for w in range(1, self.width - 1):
if self.field[h][w] == 0:
completed_line = False
break
if completed_line:
complete_lines.append(h)
cnt_complete_lines = len(complete_lines)
if cnt_complete_lines > 0:
if cnt_complete_lines == 1:
self.game_window_action.emit(GameWindowAction.SINGLE_LINE_CLEAR)
elif cnt_complete_lines == 2:
self.game_window_action.emit(GameWindowAction.DOUBLE_LINE_CLEAR)
elif cnt_complete_lines == 3:
self.game_window_action.emit(GameWindowAction.TRIPLE_LINE_CLEAR)
else:
self.game_window_action.emit(GameWindowAction.TETRIS_LINE_CLEAR)
self.remove_complete_lines(complete_lines)
def remove_complete_lines(self, complete_lines):
self.update_field()
self.main_window.pre_clear_animation(complete_lines)
new_field = [[0] * self.width for i in range(self.height)]
self.initialise_field(new_field)
row_behind = 0
for h in reversed(range(self.height - 1)):
if h in complete_lines:
row_behind += 1
continue
for w in range(1, self.width - 1):
new_field[h + row_behind][w] = self.field[h][w]
self.field = new_field
calculated_score = self.line_score_base[len(complete_lines) - 1] * (
self.level + 1
)
self.score += calculated_score
self.total_removed_lines += len(complete_lines)
@property
def total_removed_lines(self):
return self._total_removed_lines
@total_removed_lines.setter
def total_removed_lines(self, value):
self._total_removed_lines = value
self.lines_updated.emit(self._total_removed_lines)
@property
def score(self):
return self._score
@score.setter
def score(self, value):
self._score = value
self.score_updated.emit(self._score)
def update_level(self):
old_level = self.level
self.level = self.total_removed_lines // 10
if old_level < self.level:
self.game_window_action.emit(GameWindowAction.LEVEL_UP)
self.level_updated.emit(self.level)
self.update_speed()
def update_speed(self):
self.move_timer.setInterval(self.calculate_move_speed())
def merge_tetromino_with_field(self, tetromino, field, shadowed_pos=None):
if shadowed_pos:
cursor_h, cursor_w = shadowed_pos
else:
cursor_h, cursor_w = self.playing_cursor
tetromino_h = len(tetromino.brick_matrix)
tetromino_w = len(tetromino.brick_matrix[0])
try:
for h in range(tetromino_h):
for w in range(tetromino_w):
if (cursor_h + h) in range(self.height) and (cursor_w + w) in range(
self.width
):
value = tetromino.brick_matrix[h][w]
if value != 0:
if shadowed_pos:
field[cursor_h + h][cursor_w + w] = -3
else:
field[cursor_h + h][cursor_w + w] = value
except Exception as e:
print(e)
class VideoPlayer(QWidget):
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoItem = QGraphicsVideoItem()
self.videoItem.setSize(QSizeF(640, 480))
scene = QGraphicsScene(self)
graphicsView = QGraphicsView(scene)
scene.addItem(self.videoItem)
rotateSlider = QSlider(Qt.Horizontal)
rotateSlider.setRange(-180, 180)
rotateSlider.setValue(0)
rotateSlider.valueChanged.connect(self.rotateVideo)
openButton = QPushButton("Open...")
openButton.clicked.connect(self.openFile)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(graphicsView)
layout.addWidget(rotateSlider)
layout.addLayout(controlLayout)
self.setLayout(layout)
self.mediaPlayer.setVideoOutput(self.videoItem)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
def sizeHint(self):
return QSize(800, 600)
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
QDir.homePath())
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def rotateVideo(self, angle):
x = self.videoItem.boundingRect().width() / 2.0
y = self.videoItem.boundingRect().height() / 2.0
self.videoItem.setTransform(
QTransform().translate(x, y).rotate(angle).translate(-x, -y))
class MyForm(QMainWindow):
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.lineEdit.textChanged.connect(self.aramaMetniDegistir)
self.ui.listWidget.itemClicked.connect(self.listedeKiElemanSecildi)
self.ui.comboBox.activated.connect(self.comboBoxTiklama)
self.ui.actionKategori_Ekle.triggered.connect(self.yeniKategoriEkle)
self.ui.actionKategori_Sil.triggered.connect(self.kategoriSil)
self.ui.actionKategori_Duzenle.triggered.connect(self.kategoriDuzenle)
self.ui.actionCoktanSecmeliSinav.triggered.connect(self.sinavCoktanSecmeli)
self.ui.actionHafizaOyunu.triggered.connect(self.hafizaOyunuAc)
self.ui.actionHafizaOyunu2.triggered.connect(self.hafizaOyunuAc2)
self.ui.actionKisaCevap.triggered.connect(self.kisacevapOyunuAc)
self.ui.actionYardim.triggered.connect(self.Yardim)
self.ui.actionHakkinda.triggered.connect(self.Hakkinda)
self.ui.actionKelime_Ekle.triggered.connect(self.yeniKelimeEkle)
self.ui.actionKelime_Sil.triggered.connect(self.kelimeSil)
self.ui.actionKelime_Duzenle.triggered.connect(self.kelimeDuzenle)
self.secilenKelime = Kelime()
self.secilenKategori = Kategori()
self.yeniKategori = Kategori()
self.silinecekKategori = Kategori()
self.kelimeListesi = []
self.kategoriListesi = []
self.seciliListe = []
self.listeleriHazirla()
self.listeyiHazirla()
self.comboListeHazirla()
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoWidget = QVideoWidget()
self.buton = KayitButonu(self)
self.buton.setIcon(QIcon('micro.png'))
self.buton.setIconSize(QSize(40, 40))
self.buton.setGeometry(0, 0, 50, 50)
self.buton.setStyleSheet('border-radius:60')
self.buton.setCursor(QCursor(Qt.PointingHandCursor))
self.buton.setFixedSize(self.buton.size())
self.buton.setEnabled(True)
self.buton.clicked.connect(self.butonTiklandi)
self.progress = QProgressBar(self, minimum=0, maximum=0, objectName="RedProgressBar")
self.progress.setGeometry(0, 0, 300, 25)
self.progress.setMaximum(5)
self.progress.setFormat('')
self.progress.setStyleSheet("#RedProgressBar::chunk {"
"background-color: #F44336;"
"}")
hBox = QHBoxLayout()
hBox.setContentsMargins(0, 0, 0, 0)
hBox.addWidget(self.buton)
hBox.setAlignment(Qt.AlignHCenter)
hBox2 = QHBoxLayout()
hBox2.setContentsMargins(0, 0, 0, 0)
hBox2.addWidget(self.progress)
hBox2.setAlignment(Qt.AlignHCenter)
hBox3 = QHBoxLayout()
hBox3.setContentsMargins(0, 2, 0, 2)
hBox3.setAlignment(Qt.AlignHCenter)
vBoxLayout = QVBoxLayout()
vBoxLayout.addLayout(hBox)
vBoxLayout.addLayout(hBox2)
vBoxLayout.addLayout(hBox3)
vBoxLayout.addWidget(self.videoWidget)
self.ui.layout.addLayout(vBoxLayout)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile("VIDEOLAR\MERHABA.mp4")))
self.progress.hide()
self.videoWidget.show()
self.mediaPlayer.play()
self.videoWidget.show()
self.show()
def recognize_speech_from_mic(self, recognizer, microphone):
if not isinstance(recognizer, sr.Recognizer):
raise TypeError("`recognizer` must be `Recognizer` instance")
if not isinstance(microphone, sr.Microphone):
print('HATA 2')
raise TypeError("`microphone` must be `Microphone` instance")
response = {"success": True, "error": None, "transcription": None}
try:
with microphone as source:
recognizer.adjust_for_ambient_noise(source)
audio = recognizer.listen(source, timeout=4)
except sr.WaitTimeoutError:
response["error"] = "Zamanında kelime söylemediniz."
# self.uyariLbl.setText(response["error"])
# self.uyariLbl.show()
self.buton.setIcon(QIcon('micro.png'))
except:
print("Bir şeyler ters gitti. Tekrar deneyin.")
# self.uyariLbl.show()
self.buton.setIcon(QIcon('micro.png'))
else:
try:
response["transcription"] = recognizer.recognize_google(audio, language='tr')
except sr.RequestError:
response["success"] = False
response["error"] = "API hatası! Arayüze ulaşılamadı."
# self.uyariLbl.setText(response["error"])
# self.uyariLbl.show()
except sr.UnknownValueError:
response["error"] = "Konuşmanız anlaşılamadı."
# self.uyariLbl.setText(response["error"])
# self.uyariLbl.show()
return response
def sesleAra(self):
# self.uyariLbl.hide()
recognizer = sr.Recognizer()
microphone = sr.Microphone()
self.guess = self.recognize_speech_from_mic(recognizer, microphone)
if not self.guess["transcription"] or not self.guess["success"]:
print("anlaşılamadı")
# self.uyariLbl.show()
elif self.guess["error"]:
print(self.guess["error"])
# self.uyariLbl.show()
else:
try:
yol = seslearamavb.yolDondur(self.guess["transcription"])
self.videoyuOynat(yol)
self.ui.listWidget.clear()
self.ui.lineEdit.setText(self.guess["transcription"])
except Exception as e:
self.ui.lineEdit.setText("Sözcük Bulunamadı")
self.buton.setIcon(QIcon('micro.png'))
self.buton.setEnabled(True)
def onCountChanged(self, value):
self.progress.setValue(value)
def onButtonClick(self):
self.calc = External()
self.calc.countChanged.connect(self.onCountChanged)
self.calc.start()
def butonTiklandi(self):
self.progress.show()
thread = threading.Thread(target=self.sesleAra)
thread.start()
self.onButtonClick()
def listeleriHazirla(self):
try:
kelimeListesiTupple = KelimeBLL.KelimeleriListele()
kategoriListesiTupple = KategoriBLL.KategorileriListele()
self.kelimeListesi = [item[0] for item in kelimeListesiTupple]
self.kategoriListesi = [item[0] for item in kategoriListesiTupple]
self.kategoriListesi.insert(0, "Kategori Seçin")
except Exception as exp:
print(exp)
def yeniKelimeEkle(self):
try:
self.yenikelimeEkle = YeniKelimeEkle()
self.yenikelimeEkle.show()
if self.yenikelimeEkle.close:
print("Deneme")
except Exception as e:
print(e)
donusDurumu=self.yenikelimeEkle.exec_()
if donusDurumu== 1:
QMessageBox.information(self, "Yeni Kelime", "Yeni Kelime Eklendi")
else:
QMessageBox.warning(self, "Yeni Kelime", "Yeni kelime eklenemedi.")
self.listeleriHazirla()
self.comboListeHazirla()
self.listeyiHazirla()
def kelimeSil(self):
try:
self.kelimeSil = SilinecekKelimeForm()
self.kelimeSil.show()
except Exception as e:
print(e)
donusDurumu = self.kelimeSil.exec_()
if donusDurumu == 1:
QMessageBox.information(self, "Kelime Sil", "Kelime Silindi")
else:
QMessageBox.warning(self, "Kelime Sil", "Kelime Silinemedi.")
self.listeleriHazirla()
self.comboListeHazirla()
self.listeyiHazirla()
def kelimeDuzenle(self):
print("Kelime Düzenle menü basıldı")
try:
self.KelimeDuzenle = DuzenlenecekKelimeForm()
print("Kelime Düzenle yaratıldı")
self.KelimeDuzenle.show()
if self.KelimeDuzenle.close:
print("Kelime Düzenle Kapatıldı")
except Exception as e:
print(e)
donusDurumu= self.KelimeDuzenle.exec_()
if donusDurumu== 1:
QMessageBox.information(self, "Kelime Düzenle", "Kelime Düzeltildi.")
else:
QMessageBox.warning(self, "Kelime Düzenle", "Kelime Düzenlenemedi.")
self.listeleriHazirla()
self.comboListeHazirla()
self.listeyiHazirla()
def kategoriDuzenle(self):
try:
self.kategoriDuzenle = KategoriDuzenle()
self.kategoriDuzenle.show()
if self.kategoriDuzenle.close:
print("Deneme")
except Exception as e:
print(e)
donusDurumu = self.kategoriDuzenle.exec_()
if donusDurumu == 1:
QMessageBox.information(self, "Kategori Düzenle", "Kategori Düzenlendi.")
else:
QMessageBox.warning(self, "Kategori Düzenle", "Kategori Düzenlenemedi.")
self.listeleriHazirla()
self.comboListeHazirla()
self.listeyiHazirla()
def yeniKategoriEkle(self):
try:
self.yeniKategoriEkle = YeniKategoriEkle()
self.yeniKategoriEkle.show()
if self.yeniKategoriEkle.close:
print("Yeni Kategori Sayfası kapatıldı.")
except Exception as e:
print(e)
donusDurumu = self.yeniKategoriEkle.exec_()
if donusDurumu == 1:
QMessageBox.information(self, "Yeni Kelime", "Yeni Kelime Eklendi")
else:
QMessageBox.warning(self, "Yeni Kategori", "Yeni Kategori Eklenemedi")
self.listeleriHazirla()
self.listeyiHazirla()
self.comboListeHazirla()
def kategoriSil(self):
try:
self.kategoriSil = KategoriSil()
self.kategoriSil.show()
donusDurumu = self.kategoriSil.exec_()
if donusDurumu == 1:
QMessageBox.information(self, "Kategori Sil", "Kategori ve ilişileri Silindi")
else:
QMessageBox.warning(self, "Kategori Sil", "Kategori ve/veya ilişkileri silinemedi.")
except Exception as e:
print(e)
self.listeleriHazirla()
self.comboListeHazirla()
self.listeyiHazirla()
def comboBoxTiklama(self):
print("tıklandı")
self.secilenKategori.kategori = self.ui.comboBox.itemText(self.ui.comboBox.currentIndex())
if (self.ui.comboBox.currentIndex() != 0): # düzeltilmesi gerekiyor bütün hepsinde çıkması lazım
try:
kelimeListesi = KategoriBLL.KategoriyeAitKelimeler(self.secilenKategori)
self.ui.listWidget.clear()
self.ui.listWidget.addItems(kelimeListesi)
except Exception as e:
print(e)
else:
self.listeleriHazirla()
self.listeyiHazirla()
def comboListeHazirla(self):
self.ui.comboBox.clear()
self.ui.comboBox.addItems(self.kategoriListesi)
def listeyiHazirla(self):
self.ui.listWidget.clear()
self.ui.listWidget.addItems(self.kelimeListesi)
def videoyuOynat(self, video):
##self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile("VIDEOLAR/RAHAT.mp4")))
self.progress.hide()
self.videoWidget.show()
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(video)))
self.mediaPlayer.play()
def listedeKiElemanSecildi(self):
self.secilenKelime.kelime = self.ui.listWidget.currentItem().text()
sonuc = KelimeBLL.KelimeVideoBul(self.secilenKelime)
print(sonuc)
self.videoyuOynat(sonuc)
def sinavCoktanSecmeli(self):
self.Form = QtWidgets.QWidget()
self.Form.ui = Sinav_coktan_secme()
self.Form.ui.show()
def aramaMetniDegistir(self):
self.ui.listWidget.clear()
self.seciliListe.clear()
aramaMetni = self.ui.lineEdit.text()
for v in self.kelimeListesi:
if v.startswith(Helper.KucukHarfleriBuyukYap(aramaMetni)):
self.seciliListe.append(v)
self.ui.listWidget.addItems(self.seciliListe)
def hafizaOyunuAc(self):
h = HafizaOyunu()
h.oyunuBaslat()
def hafizaOyunuAc2(self):
h = HafizaOyunu2()
h.oyunuBaslat()
def kisacevapOyunuAc(self):
KisaCevapFrom()
def Hakkinda(self):
self.hakkinda = Hakkinda()
self.hakkinda.show()
def Yardim(self):
webbrowser.open('https://github.com/munel/is_en')
class VideoPlayer(QWidget):
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
videoWidget = QVideoWidget()
openButton = QPushButton("Open...")
openButton.clicked.connect(self.openFile)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.errorLabel)
self.setLayout(layout)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
QDir.homePath())
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
self.singsTable.setItem(i, 2, item)
item = QTableWidgetItem(transSeconds(data["duration"] / 1000))
self.singsTable.setItem(i, 3, item)
@addToLoop
async def palyMusic(self, data):
url = await self.seivice.getMusicUrlInfo(data["id"])
if url:
player = self.parent.player
player.playMusic(QUrl(url))
def transSeconds(seconds):
m, s = divmod(seconds, 60)
h, m = divmod(m, 60)
return "%02d:%02d:%02d" % (h, m, s)
if __name__ == "__main__":
import sys
app = QApplication(sys.argv)
content = QMediaContent(
QUrl(
"http://m10.music.126.net/20190323193124/9f385ee03ede3f967a9c72152a911a8c/ymusic/46a6/061d/57b9/dca63fbd90a9bcba54084db8b1209593.mp3"
))
#content = QMediaContent(QUrl.fromLocalFile(r"F:\musicdowmload\处处吻__杨千嬅.MP3"))
play = QMediaPlayer()
play.setMedia(content)
play.play()
sys.exit(app.exec_())
class Player(QWidget):
fullScreenChanged = pyqtSignal(bool)
def __init__(self, playlist, parent=None):
super(Player, self).__init__(parent)
self.colorDialog = None
self.trackInfo = ""
self.statusInfo = ""
self.duration = 0
self.player = QMediaPlayer()
self.playlist = QMediaPlaylist()
self.player.setPlaylist(self.playlist)
self.player.durationChanged.connect(self.durationChanged)
self.player.positionChanged.connect(self.positionChanged)
self.player.metaDataChanged.connect(self.metaDataChanged)
self.playlist.currentIndexChanged.connect(self.playlistPositionChanged)
self.player.mediaStatusChanged.connect(self.statusChanged)
self.player.bufferStatusChanged.connect(self.bufferingProgress)
self.player.videoAvailableChanged.connect(self.videoAvailableChanged)
self.player.error.connect(self.displayErrorMessage)
self.videoWidget = VideoWidget()
self.player.setVideoOutput(self.videoWidget)
self.playlistModel = PlaylistModel()
self.playlistModel.setPlaylist(self.playlist)
self.playlistView = QListView()
self.playlistView.setModel(self.playlistModel)
self.playlistView.setCurrentIndex(
self.playlistModel.index(self.playlist.currentIndex(), 0))
self.playlistView.activated.connect(self.jump)
self.slider = QSlider(Qt.Horizontal)
self.slider.setRange(0, self.player.duration() / 1000)
self.labelDuration = QLabel()
self.slider.sliderMoved.connect(self.seek)
self.labelHistogram = QLabel()
self.labelHistogram.setText("Histogram:")
self.histogram = HistogramWidget()
histogramLayout = QHBoxLayout()
histogramLayout.addWidget(self.labelHistogram)
histogramLayout.addWidget(self.histogram, 1)
self.probe = QVideoProbe()
self.probe.videoFrameProbed.connect(self.histogram.processFrame)
self.probe.setSource(self.player)
openButton = QPushButton("Open", clicked=self.open)
controls = PlayerControls()
controls.setState(self.player.state())
controls.setVolume(self.player.volume())
controls.setMuted(controls.isMuted())
controls.play.connect(self.player.play)
controls.pause.connect(self.player.pause)
controls.stop.connect(self.player.stop)
controls.next.connect(self.playlist.next)
controls.previous.connect(self.previousClicked)
controls.changeVolume.connect(self.player.setVolume)
controls.changeMuting.connect(self.player.setMuted)
controls.changeRate.connect(self.player.setPlaybackRate)
controls.stop.connect(self.videoWidget.update)
self.player.stateChanged.connect(controls.setState)
self.player.volumeChanged.connect(controls.setVolume)
self.player.mutedChanged.connect(controls.setMuted)
self.fullScreenButton = QPushButton("FullScreen")
self.fullScreenButton.setCheckable(True)
self.colorButton = QPushButton("Color Options...")
self.colorButton.setEnabled(False)
self.colorButton.clicked.connect(self.showColorDialog)
displayLayout = QHBoxLayout()
displayLayout.addWidget(self.videoWidget, 2)
displayLayout.addWidget(self.playlistView)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addStretch(1)
controlLayout.addWidget(controls)
controlLayout.addStretch(1)
controlLayout.addWidget(self.fullScreenButton)
controlLayout.addWidget(self.colorButton)
layout = QVBoxLayout()
layout.addLayout(displayLayout)
hLayout = QHBoxLayout()
hLayout.addWidget(self.slider)
hLayout.addWidget(self.labelDuration)
layout.addLayout(hLayout)
layout.addLayout(controlLayout)
layout.addLayout(histogramLayout)
self.setLayout(layout)
if not self.player.isAvailable():
QMessageBox.warning(self, "Service not available",
"The QMediaPlayer object does not have a valid service.\n"
"Please check the media service plugins are installed.")
controls.setEnabled(False)
self.playlistView.setEnabled(False)
openButton.setEnabled(False)
self.colorButton.setEnabled(False)
self.fullScreenButton.setEnabled(False)
self.metaDataChanged()
self.addToPlaylist(playlist)
def open(self):
fileNames, _ = QFileDialog.getOpenFileNames(self, "Open Files")
self.addToPlaylist(fileNames)
def addToPlaylist(self, fileNames):
for name in fileNames:
fileInfo = QFileInfo(name)
if fileInfo.exists():
url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
if fileInfo.suffix().lower() == 'm3u':
self.playlist.load(url)
else:
self.playlist.addMedia(QMediaContent(url))
else:
url = QUrl(name)
if url.isValid():
self.playlist.addMedia(QMediaContent(url))
def durationChanged(self, duration):
duration /= 1000
self.duration = duration
self.slider.setMaximum(duration)
def positionChanged(self, progress):
progress /= 1000
if not self.slider.isSliderDown():
self.slider.setValue(progress)
self.updateDurationInfo(progress)
def metaDataChanged(self):
if self.player.isMetaDataAvailable():
self.setTrackInfo("%s - %s" % (
self.player.metaData(QMediaMetaData.AlbumArtist),
self.player.metaData(QMediaMetaData.Title)))
def previousClicked(self):
# Go to the previous track if we are within the first 5 seconds of
# playback. Otherwise, seek to the beginning.
if self.player.position() <= 5000:
self.playlist.previous()
else:
self.player.setPosition(0)
def jump(self, index):
if index.isValid():
self.playlist.setCurrentIndex(index.row())
self.player.play()
def playlistPositionChanged(self, position):
self.playlistView.setCurrentIndex(
self.playlistModel.index(position, 0))
def seek(self, seconds):
self.player.setPosition(seconds * 1000)
def statusChanged(self, status):
self.handleCursor(status)
if status == QMediaPlayer.LoadingMedia:
self.setStatusInfo("Loading...")
elif status == QMediaPlayer.StalledMedia:
self.setStatusInfo("Media Stalled")
elif status == QMediaPlayer.EndOfMedia:
QApplication.alert(self)
elif status == QMediaPlayer.InvalidMedia:
self.displayErrorMessage()
else:
self.setStatusInfo("")
def handleCursor(self, status):
if status in (QMediaPlayer.LoadingMedia, QMediaPlayer.BufferingMedia, QMediaPlayer.StalledMedia):
self.setCursor(Qt.BusyCursor)
else:
self.unsetCursor()
def bufferingProgress(self, progress):
self.setStatusInfo("Buffering %d%" % progress)
def videoAvailableChanged(self, available):
if available:
self.fullScreenButton.clicked.connect(
self.videoWidget.setFullScreen)
self.videoWidget.fullScreenChanged.connect(
self.fullScreenButton.setChecked)
if self.fullScreenButton.isChecked():
self.videoWidget.setFullScreen(True)
else:
self.fullScreenButton.clicked.disconnect(
self.videoWidget.setFullScreen)
self.videoWidget.fullScreenChanged.disconnect(
self.fullScreenButton.setChecked)
self.videoWidget.setFullScreen(False)
self.colorButton.setEnabled(available)
def setTrackInfo(self, info):
self.trackInfo = info
if self.statusInfo != "":
self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo))
else:
self.setWindowTitle(self.trackInfo)
def setStatusInfo(self, info):
self.statusInfo = info
if self.statusInfo != "":
self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo))
else:
self.setWindowTitle(self.trackInfo)
def displayErrorMessage(self):
self.setStatusInfo(self.player.errorString())
def updateDurationInfo(self, currentInfo):
duration = self.duration
if currentInfo or duration:
currentTime = QTime((currentInfo/3600)%60, (currentInfo/60)%60,
currentInfo%60, (currentInfo*1000)%1000)
totalTime = QTime((duration/3600)%60, (duration/60)%60,
duration%60, (duration*1000)%1000);
format = 'hh:mm:ss' if duration > 3600 else 'mm:ss'
tStr = currentTime.toString(format) + " / " + totalTime.toString(format)
else:
tStr = ""
self.labelDuration.setText(tStr)
def showColorDialog(self):
if self.colorDialog is None:
brightnessSlider = QSlider(Qt.Horizontal)
brightnessSlider.setRange(-100, 100)
brightnessSlider.setValue(self.videoWidget.brightness())
brightnessSlider.sliderMoved.connect(
self.videoWidget.setBrightness)
self.videoWidget.brightnessChanged.connect(
brightnessSlider.setValue)
contrastSlider = QSlider(Qt.Horizontal)
contrastSlider.setRange(-100, 100)
contrastSlider.setValue(self.videoWidget.contrast())
contrastSlider.sliderMoved.connect(self.videoWidget.setContrast)
self.videoWidget.contrastChanged.connect(contrastSlider.setValue)
hueSlider = QSlider(Qt.Horizontal)
hueSlider.setRange(-100, 100)
hueSlider.setValue(self.videoWidget.hue())
hueSlider.sliderMoved.connect(self.videoWidget.setHue)
self.videoWidget.hueChanged.connect(hueSlider.setValue)
saturationSlider = QSlider(Qt.Horizontal)
saturationSlider.setRange(-100, 100)
saturationSlider.setValue(self.videoWidget.saturation())
saturationSlider.sliderMoved.connect(
self.videoWidget.setSaturation)
self.videoWidget.saturationChanged.connect(
saturationSlider.setValue)
layout = QFormLayout()
layout.addRow("Brightness", brightnessSlider)
layout.addRow("Contrast", contrastSlider)
layout.addRow("Hue", hueSlider)
layout.addRow("Saturation", saturationSlider)
button = QPushButton("Close")
layout.addRow(button)
self.colorDialog = QDialog(self)
self.colorDialog.setWindowTitle("Color Options")
self.colorDialog.setLayout(layout)
button.clicked.connect(self.colorDialog.close)
self.colorDialog.show()
