def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
#Connection du decodeur et lecteur
self.mediaPlayer = QMediaPlayer()
self.mediaPlayer.setVideoOutput(self.ui.ecranWidget)
#chargement du media
mediaContent = QMediaContent(QUrl.fromLocalFile("big_buck_bunny.avi"))
self.mediaPlayer.setMedia(mediaContent)
#connect push boutons
self.ui.pbLecture.clicked.connect(self.lectureClicked)
self.ui.pbPause.clicked.connect(self.pauseClicked)
self.ui.pbStop.clicked.connect(self.stopClicked)
self.ui.dialVolume.valueChanged.connect(self.volControl)
self.ui.nivoVolume.setText(str(self.ui.dialVolume.value()))
self.ui.nivoVolume.setText('{}%'.format(str(self.ui.dialVolume.value())))
self.mediaPlayer.durationChanged.connect(self.affTemp)
self.mediaPlayer.positionChanged.connect(self.avanceTemp)
self.ui.barreLect.valueChanged.connect(self.avanceSlider)
self.ui.pbPlus.clicked.connect(self.pbPlusCtrl)
self.ui.pbMoins.clicked.connect(self.pbMoinsCtrl)
self.ui.listWidget.itemDoubleClicked.connect(self.mediaSelected)
self.ui.pbSuivant.clicked.connect(self.suivantBouton)
self.ui.pbPrecedent.clicked.connect(self.precedentBouton)
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.pBLecture.clicked.connect(self.lecture)
self.ui.pBPause.clicked.connect(self.pause)
self.ui.pBStop.clicked.connect(self.stop)
self.ui.pBPrecedent.clicked.connect(self.precedent)
self.ui.pBSuivant.clicked.connect(self.suivant)
self.ui.pBAjout.clicked.connect(self.ajoutListe)
self.ui.pBSupp.clicked.connect(self.suppListe)
self.ui.listWidget.itemDoubleClicked.connect(self.mediaSelected)
self.ui.dBVolume.valueChanged.connect(self.volume)
self.ui.dBVolume.setRange(0, 100)
self.ui.suiviVol.setText(f'{str(self.ui.dBVolume.value())} %')
self.ui.sTpsCourant.valueChanged.connect(self.avanceSlider)
self.mediaPlayer = QMediaPlayer()
self.mediaPlayer.setVideoOutput(self.ui.Lecteur)
self.mediaPlayer.durationChanged.connect(self.duree)
self.mediaPlayer.positionChanged.connect(self.avancee)
def __init__(self):
QMainWindow.__init__(self)
Ui_MainWindow.__init__(self)
self.setupUi(self)
self.videoWidget = QVideoWidget()
self.mediaPlayer = QMediaPlayer()
self.mediaPlaylist = QMediaPlaylist()
# Add the video file path
self.mediaPlaylist.addMedia(QUrl.fromLocalFile(os.path.abspath("./sample_data/sampleVideo.mp4")))
# Set the video to played in a loop once it ends.
self.mediaPlaylist.setPlaybackMode(QMediaPlaylist.CurrentItemInLoop)
# Set the QMediaPlaylist for the QMediaPlayer.
self.mediaPlayer.setPlaylist(self.mediaPlaylist)
# Add the QVideoWidget in the GridLayout.
self.playerLayout.addWidget(self.videoWidget)
# Set the video output from the QMediaPlayer to the QVideoWidget.
self.mediaPlayer.setVideoOutput(self.videoWidget)
# Set the QPushButtons to play, pause and stop the video in the QVideoWidget.
self.playButton.clicked.connect(self.play_video)
self.pauseButton.clicked.connect(self.pause_video)
self.stopButton.clicked.connect(self.stop_video)
# Set the total range for the QSlider.
self.mediaPlayer.durationChanged.connect(self.change_duration)
# Set the current value for the QSlider.
self.mediaPlayer.positionChanged.connect(self.change_position)
# Set the video position in QMediaPlayer based on the QSlider position.
self.horizontalSlider.sliderMoved.connect(self.video_position)
def __init__(self, sys_argv):
super().__init__(sys_argv)
# Show main window
self.view = QMainWindow()
self.centralWidget = QWidget(self.view)
self.gridLayout = QGridLayout(self.centralWidget)
self.gridLayout.setContentsMargins(0, 0, 0, 0)
self.gridLayout.setSpacing(0)
self.video_item = QVideoWidget()
self.gridLayout.addWidget(self.video_item)
self.view.setCentralWidget(self.centralWidget)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.grabber = VideoFrameGrabber(self.video_item, self)
self.mediaPlayer.setVideoOutput(self.grabber)
self.grabber.frameAvailable.connect(self.process_frame)
self.mediaPlayer.durationChanged.connect(self.update_duration)
self.mediaPlayer.positionChanged.connect(self.update_slider_position)
local = QUrl.fromLocalFile('D:\\SampleData\\albamonSample.mp4')
media = QMediaContent(local)
self.mediaPlayer.setMedia(media)
self.mediaPlayer.play()
self.view.show()
def __init__(self):
super().__init__()
self.width = 75
self.height = self.width
self.x = 0
self.y = 0
self.board_tile_width = 0
self.board_tile_height = self.board_tile_width
self.sides = 6
self.dice_initialized = False
self.draw_dice = False
self.dice_amount = 0
self.audio_player = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.audio_player.setMedia(
QUrl.fromLocalFile(
definitions.ROOT_DIR +
"/Trivial_Purfuit/resources/audio/dice_roll.mp3"))
self.audio_player.setVolume(50)
self.image_path = definitions.ROOT_DIR + "/Trivial_Purfuit/src/die/"
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(
self
) #permet de charger tous les composants graphiques coder dans un autre fichier
# partir du fichier .py (au lieu du .ui) permet d'accéder à la complétion cad la liste des fonctions, widgets...
self.ui.pbLect.clicked.connect(self.lectClicked)
self.ui.pbPause.clicked.connect(self.pauseClicked)
self.ui.pbStop.clicked.connect(self.stopClicked)
self.ui.pbPreced.clicked.connect(self.precedClicked)
self.ui.pbSuiv.clicked.connect(self.suivClicked)
# self.ui.pbAjout.clicked.connect(self.ajoutClicked)
self.ui.pbAjout.clicked.connect(self.ajoutClicked2)
self.ui.pbSuppr.clicked.connect(self.supprClicked)
self.ui.dlVolume.valueChanged.connect(self.volumeChange)
self.mediaPlayer = QMediaPlayer()
self.mediaPlayer.setVideoOutput(self.ui.videoScreen)
self.mediaPlayer.durationChanged.connect(self.mediaDurationChanged)
self.mediaPlayer.positionChanged.connect(self.mediaPositionChanged)
self.ui.slTimeBarre.valueChanged.connect(self.timeBarreChanged)
self.ui.listFilm.itemDoubleClicked.connect(
self.filmSelectDC) #film démmarre si double clique sur son titre
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow(
) # on veut utiliser qu'il y a dans le fichier généré
self.ui.setupUi(
self) # on charge tous les composants graphiques qui sont dedans
self.mediaPlayer = QMediaPlayer()
self.mediaPlayer.setVideoOutput(self.ui.videoWidget)
self.ui.dial.setValue(50) # pour avoir le son à 50% de base
self.mediaPlayer.setVolume(self.ui.dial.value())
self.ui.volume.setText(f"{self.ui.dial.value()}%")
self.ui.pbLecture.clicked.connect(self.lectureClicked)
self.ui.pbPause.clicked.connect(self.pauseClicked)
self.ui.pbStop.clicked.connect(self.stopClicked)
self.ui.dial.valueChanged.connect(self.displayVolume)
self.mediaPlayer.durationChanged.connect(self.mediaDurationChanged)
self.mediaPlayer.positionChanged.connect(self.mediaPositionChanged)
self.ui.sTempsCourant.valueChanged.connect(self.sliderPositionChanged)
self.ui.pbAjouter.clicked.connect(self.ajouterMedia2)
self.ui.pbSupprimer.clicked.connect(self.supprMedia)
self.ui.listeLecture.itemDoubleClicked.connect(self.mediaSelected2)
self.ui.pbPrec.clicked.connect(self.precClicked)
self.ui.pbSuiv.clicked.connect(self.suivClicked)
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.PLAY_Button.clicked.connect(self.PLAY)
self.ui.PAUSE_Button.clicked.connect(self.PAUSE)
self.ui.STOP_Button.clicked.connect(self.STOP)
self.ui.PREV_Button.clicked.connect(self.PREV)
self.ui.NEXT_Button.clicked.connect(self.NEXT)
self.ui.next_file_button.clicked.connect(self.nextFile)
self.ui.del_file_button.clicked.connect(self.delFile)
self.ui.dial_volumen.setMinimum(0)
self.ui.dial_volumen.setMaximum(100)
self.ui.dial_volumen.setValue(3)
self.ui.volumen_level.setText(str(self.ui.dial_volumen.value()) + '%')
self.ui.sliderTime.setMinimum(0)
self.ui.sliderTime.setMaximum(3600)
self.ui.sliderTime.setValue(0)
self.ui.timePlayed.setText(str(self.ui.sliderTime.value()) + 's')
self.mediaPlayer = QMediaPlayer()
self.mediaPlayer.setVideoOutput(self.ui.wVideo)
#mediaContent = QMediaContent(QUrl.fromLocalFile('big_buck_bunny.avi'))
#self.mediaPlayer.setMedia(mediaContent)
#Dialog
self.ui.dial_volumen.valueChanged.connect(self.changeVolDial)
self.mediaPlayer.positionChanged.connect(self.updateTime)
self.ui.sliderTime.valueChanged.connect(self.changeTime)
self.ui.file_list.itemDoubleClicked.connect(self.loadfile)
def init_video(self):
self.old_bpm = 1.0
self.video_widget = VideoWidget(self,
self.show_video_preview,
self.screen)
self.media_player = QMediaPlayer(self.central)
self.media_player.setVideoOutput(self.video_widget)
self.playlist = QMediaPlaylist(self.media_player)
dir_path = os.path.dirname(os.path.realpath(__file__))
file_location = dir_path + "/resources/video_long.mp4"
self.video_file = QUrl.fromLocalFile(file_location)
self.playlist.addMedia(self.video_file)
self.playlist.setPlaybackMode(QMediaPlaylist.Loop)
self.playlist.setCurrentIndex(0)
self.media_player.setPlaylist(self.playlist)
self.media_player.mediaStatusChanged.connect(self.handle_media_state_changed)
self.media_player.play()
self.change_playback_rate(self.video_loop_bpm)
if not self.show_video_preview:
self.video_widget.hide()
def __init__(self, ui_file, parent=None):
#reference to our music player
self.music_player = QMediaPlayer()
self.music_player.setVolume(100)
#call parent QObject constructor
super(MainWindow, self).__init__(parent)
#load the UI file into Python
ui_file = QFile(ui_file)
ui_file.open(QFile.ReadOnly)
loader = QUiLoader()
self.window = loader.load(ui_file)
ui_file.close()
volume_slider = self.window.findChild(QSlider, 'volume_slider')
volume_slider.valueChanged.connect(self.volumeChanged)
open_action = self.window.findChild(QAction, 'action_open')
open_action.triggered.connect(self.open_action_triggered)
quit_action = self.window.findChild(QAction, 'action_quit')
quit_action.triggered.connect(self.quit_action_triggered)
play_button = self.window.findChild(QPushButton, 'play_button')
play_button.clicked.connect(self.play_button_clicked)
pause_button = self.window.findChild(QPushButton, 'pause_button')
pause_button.clicked.connect(self.pause_button_clicked)
#show window to user
self.window.show()
def __init__(self, parent=None):
super(Player, self).__init__(parent)
self.duration = 0
self.volume = 50
self.player = QMediaPlayer()
self.playlist = Playlist(self)
self.videoWidget = VideoWidget()
self.next_url = QUrl()
self.context_menu = QMenu(self)
self.display_splitter = QSplitter(Qt.Horizontal)
self.repeat_control = RepeatControl(parent=self)
self.repeat_control.get_player_position = self.player.position
self.repeat_control.set_position_to_player = self.player.setPosition
self.player.positionChanged.connect(self.repeat_control.set_pos)
self.setAcceptDrops(True)
std_icon = self.style().standardIcon
self.play_button = create_flat_button(std_icon(QStyle.SP_MediaPlay))
self.stopButton = create_flat_button(std_icon(QStyle.SP_MediaStop), '')
self.backwardButton = create_flat_button(
std_icon(QStyle.SP_MediaSkipBackward), '')
self.forwardButton = create_flat_button(
std_icon(QStyle.SP_MediaSkipForward), '')
self.order_list = self.repeat_control.menu()
self.order_list.setFixedWidth(115)
self.playback_rate_menu = QComboBox()
self.playback_rate_menu.addItems(
('0.5x', '0.75x', '0.9x', '1.0x', '1.1x', '1.25x', '1.5x'))
self.playback_rate_menu.setCurrentText('1.0x')
self.muteButton = create_flat_button(
std_icon(QStyle.SP_MediaVolume if not self.player.isMuted() else
QStyle.SP_MediaVolumeMuted))
self.volumeBar = QSlider(Qt.Horizontal)
self.volumeBar.setRange(0, 100)
self.volumeBar.setValue(self.volume)
self.labelVolume = QLabel(str(self.volume))
self.labelVolume.setMinimumWidth(24)
self.statusInfoLabel = QLabel()
self.seekBar = QSlider(Qt.Horizontal)
self.seekBar.setRange(0, self.player.duration() / 1000)
self.labelTotalTime = QLabel('00:00')
self.labelCurrentTime = QLabel('00:00')
self.create_layout()
self.create_connections()
self.player.setVideoOutput(self.videoWidget)
self.videoWidget.show()
def __init__(self, ui_file, parent=None):
#reference to our music player
self.music_player = QMediaPlayer()
self.music_player.setVolume(100)
self.music_player.positionChanged.connect(self.position_changed)
self.music_player.durationChanged.connect(self.duration_changed)
#call parent QObject constructor
super(MainWindow, self).__init__(parent)
#load the UI file into Python
ui_file = QFile(ui_file)
ui_file.open(QFile.ReadOnly)
loader = QUiLoader()
self.window = loader.load(ui_file)
#always remember to close files
ui_file.close()
#add event listeners
open_action = self.window.findChild(QAction, 'action_open')
open_action.triggered.connect(self.open_action_triggered)
quit_action = self.window.findChild(QAction, 'action_quit')
quit_action.triggered.connect(self.quit_action_triggered)
play_button = self.window.findChild(QPushButton, 'play_button')
play_button.clicked.connect(self.play_button_clicked)
pause_button = self.window.findChild(QPushButton, 'pause_button')
pause_button.clicked.connect(self.pause_button_clicked)
toggle_forward = self.window.findChild(QPushButton, 'toggle_forward')
toggle_forward.clicked.connect(self.toggle_forward_function)
self.progress_bar = self.window.findChild(QSlider, 'progress_bar')
self.progress_bar.sliderMoved.connect(self.set_position)
# toggle_back = self.window.findChild(QPushButton, 'toggle_back')
# toggle_back.clicked.connect(self.toggle_back_function)
self.song_library = self.window.findChild(QListWidget, 'song_library')
#self.song_library.addItem(1, "videogame.mp3")
self.volume_slider = self.window.findChild(QSlider, 'volume_slider')
self.volume_slider.valueChanged.connect(self.volume_control)
self.volume_slider.setMinimum(1)
self.volume_slider.setMaximum(90)
self.volume_slider.setValue(25)
self.volume_slider.setTickInterval(10)
self.volume_slider.setTickPosition(QSlider.TicksBelow)
#show window to user
self.window.show()
def __init__(self, media, parent):
super(VideoMediaView_, self).__init__(media, parent)
self.widget = QVideoWidget(parent)
self.player = QMediaPlayer()
self.playlist = QMediaPlaylist()
self.player.setPlaylist(self.playlist)
self.player.setVideoOutput(self.widget)
self.widget.setGeometry(media['geometry'])
self.set_default_widget_prop()
self.widget.setDisabled(True)
def adjust_player_volume_by_decibel(self, player: QMediaPlayer,
decibel: Number) -> Number:
original_volume = player.volume()
target_volume = round(
add_decibel_to_linear_volume(original_volume, decibel))
player.setVolume(target_volume)
# Return clamped volume difference, so increasing linear volume 100 by n > 1 db
# returns 0
return player.volume() - original_volume
class VideoPlayer(QtWidgets.QWidget):
def __init__(self, url: str):
super(VideoPlayer, self).__init__()
self.player = QMediaPlayer()
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
self.playlist = QMediaPlaylist(self.player)
self.playlist.addMedia(QUrl(url))
self.video_widget = QVideoWidget()
self.player.setVideoOutput(self.video_widget)
self.playlist.setCurrentIndex(0)
self.player.setPlaylist(self.playlist)
self.layout = QtWidgets.QVBoxLayout()
self.layout.addWidget(self.video_widget)
self.setLayout(self.layout)
self.player.play()
QApplication.restoreOverrideCursor()
def mousePressEvent(self, event):
if self.player.state() == QMediaPlayer.PausedState:
self.player. play()
else:
self.player.pause()
class MainWindow(QObject):
#class constructor
def __init__(self, ui_file, parent=None):
#reference to our music player
self.music_player = QMediaPlayer()
self.music_player.setVolume(100)
#call parent QObject constructor
super(MainWindow, self).__init__(parent)
#load the UI file into Python
ui_file = QFile(ui_file)
ui_file.open(QFile.ReadOnly)
loader = QUiLoader()
self.window = loader.load(ui_file)
ui_file.close()
volume_slider = self.window.findChild(QSlider, 'volume_slider')
volume_slider.valueChanged.connect(self.volumeChanged)
open_action = self.window.findChild(QAction, 'action_open')
open_action.triggered.connect(self.open_action_triggered)
quit_action = self.window.findChild(QAction, 'action_quit')
quit_action.triggered.connect(self.quit_action_triggered)
play_button = self.window.findChild(QPushButton, 'play_button')
play_button.clicked.connect(self.play_button_clicked)
pause_button = self.window.findChild(QPushButton, 'pause_button')
pause_button.clicked.connect(self.pause_button_clicked)
#show window to user
self.window.show()
def open_action_triggered(self):
file_name = QFileDialog.getOpenFileName(self.window)
self.music_player.setMedia(QUrl.fromLocalFile(file_name[0]))
def pause_button_clicked(self):
self.music_player.pause()
def quit_action_triggered(self):
self.window.close()
def play_button_clicked(self):
self.music_player.play()
def volumeChanged(self):
volume = self.window.findChild(QSlider, 'volume_slider').value()
self.music_player.setVolume(volume)
def __init__(self,
titles: List[Title] = [],
widgetToPlay: QVideoWidget = None):
QObject.__init__(self)
self.__titles = titles
self.__playlist = QMediaPlaylist(self)
self.__player = QMediaPlayer(self)
self.__videoWidget = widgetToPlay
self.__player.setVideoOutput(self.__videoWidget)
self.titlesListChanged.connect(self.resetPlayList)
def _openVideo(self):
logger.debug("entering _openVideo")
self.player = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoOutput = DummyVideoSurface(self.player)
#self.videoOutput = QVideoWidget()
#self.videoOutput.show()
self.player.setVideoOutput(self.videoOutput)
#self.player.setMuted(True)
self.player.durationChanged.connect(self.newDuration)
self.player.currentMediaChanged.connect(self.currentMediaChanged)
self.player.setMedia(QUrl.fromLocalFile(self.filename))
logger.debug("leaving _openVideo; videoAv=%s audioAv=%s", self.player.isVideoAvailable(), self.player.isAudioAvailable())
class MainWindow(QMainWindow):
def __init__(self, parent=None):
super().__init__(parent)
self.resize(600, 400)
self.media_player = QMediaPlayer(self, QMediaPlayer.VideoSurface)
self.video_widget = QVideoWidget(self)
self.setCentralWidget(self.video_widget)
def showEvent(self, event) -> None:
if sys.platform in ['linux', 'darwin']:
media_content = QMediaContent(
QUrl.fromLocalFile(
QFileInfo(
'./../example_data/sample.mp4').absoluteFilePath()))
else:
media_content = QMediaContent(
QUrl.fromLocalFile(
QFileInfo(
'./../example_data/pusheen.gif').absoluteFilePath()))
self.media_player.setMedia(media_content)
self.media_player.setVideoOutput(self.video_widget)
self.video_widget.show()
self.video_widget.update()
self.media_player.setPosition(0)
self.media_player.play()
def __init__(self, soundfile, parent):
self.soundfile = soundfile
self.isplaying = False
self.time = 0 # current audio position in frames
self.audio = QMediaPlayer()
self.is_loaded = False
self.volume = 100
self.isplaying = False
self.max_bits = 32768
# File Loading is Asynchronous, so we need to be creative here, doesn't need to be duration but it works
self.audio.durationChanged.connect(self.on_durationChanged)
# self.decoder.finished.connect(self.decode_finished_signal)
self.audio.setMedia(QUrl.fromLocalFile(soundfile))
# self.decoder.setSourceFilename(soundfile) # strangely inconsistent file-handling
# It will hang here forever if we don't process the events.
while not self.is_loaded:
QCoreApplication.processEvents()
time.sleep(0.1)
self.isvalid = True
self.pydubfile = None
if AudioSegment:
if which("ffmpeg") is not None:
AudioSegment.converter = which("ffmpeg")
elif which("avconv") is not None:
AudioSegment.converter = which("avconv")
else:
if platform.system() == "Windows":
AudioSegment.converter = os.path.join(
get_main_dir(), "ffmpeg.exe")
# AudioSegment.converter = os.path.dirname(os.path.realpath(__file__)) + "\\ffmpeg.exe"
else:
# TODO: Check if we have ffmpeg or avconv installed
AudioSegment.converter = "ffmpeg"
try:
if AudioSegment:
print(self.soundfile)
self.pydubfile = AudioSegment.from_file(
self.soundfile,
format=os.path.splitext(self.soundfile)[1][1:])
else:
self.wave_reference = wave.open(self.soundfile)
self.isvalid = True
except:
traceback.print_exc()
self.wave_reference = None
self.isvalid = False
def setPlayer(self):
self.playerWidget = QGraphicsVideoItem()
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
self.view.resize(1280, 730)
self.scene.addItem(self.playerWidget)
self.stack.addWidget(self.view)
self.player = QMediaPlayer(self, QMediaPlayer.VideoSurface)
self.player.setVideoOutput(self.playerWidget)
self.view.installEventFilter(self)
self.view.show()
self.srtTextItemDict = {0: QGraphicsTextItem(), 1: QGraphicsTextItem(), 2: QGraphicsTextItem(), 3: QGraphicsTextItem(), 4: QGraphicsTextItem()}
for _, srtTextItem in self.srtTextItemDict.items():
self.scene.addItem(srtTextItem)
def __init__(self, soundfile, parent):
self.soundfile = soundfile
self.isplaying = False
self.time = 0 # current audio position in frames
self.audio = QMediaPlayer()
self.decoder = QAudioDecoder()
self.is_loaded = False
self.volume = 100
self.isplaying = False
self.decoded_audio = {}
self.only_samples = []
self.decoding_is_finished = False
self.max_bits = 32768
self.signed = False
# File Loading is Asynchronous, so we need to be creative here, doesn't need to be duration but it works
self.audio.durationChanged.connect(self.on_durationChanged)
self.decoder.finished.connect(self.decode_finished_signal)
self.audio.setMedia(QUrl.fromLocalFile(soundfile))
self.decoder.setSourceFilename(soundfile) # strangely inconsistent file-handling
# It will hang here forever if we don't process the events.
while not self.is_loaded:
QCoreApplication.processEvents()
time.sleep(0.1)
self.decode_audio()
self.np_data = np.array(self.only_samples)
if not self.signed: # don't ask me why this fixes 8 bit samples...
self.np_data = self.np_data - self.max_bits / 2
print(len(self.only_samples))
print(self.max_bits)
self.isvalid = True
def __init__(self, player_name, b_width, b_height, x_offset, y_offset):
"""
Construct a PlayerToken instance for a player based on name Provided by Board and an empty cake piece Dictionary
"""
super().__init__()
self.width = 35
self.height = self.width
self.cake_width = 13
self.cake_height = self.cake_width
self.board_tile_width = b_width
self.board_tile_height = b_height
self.x = self.board_tile_width * 5 - (self.width * x_offset)
self.y = self.board_tile_width * 5 - (self.height * y_offset)
self.x_offset = x_offset
self.y_offset = y_offset
self.moves_left = 0
self.name = player_name
self.is_current_player = False
self.question_categories = [
definitions.question_type1, definitions.question_type2,
definitions.question_type3, definitions.question_type4
]
self.cake_list = {
self.question_categories[0]: False,
self.question_categories[1]: False,
self.question_categories[2]: False,
self.question_categories[3]: False
}
self.turn_status = False
self.player_initialized = False
self.draw_token = False
self.location = [4, 4]
self.direction_to_move = ""
self.done_moving = False
self.resize(b_width, b_height)
self.audio_player = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.audio_player.setMedia(
QUrl.fromLocalFile(
definitions.ROOT_DIR +
"/Trivial_Purfuit/resources/audio/player_move.mp3"))
def test2():
url = QUrl.fromLocalFile("D:/test/2.mp4")
content = QMediaContent(url)
player = QMediaPlayer()
vw = QVideoWidget()
vw.show()
player.play()
player.setVideoOutput(vw)
player.setMedia(content)
def __init__(self, soundfile, parent):
self.soundfile = soundfile
self.isplaying = False
self.time = 0 # current audio position in frames
self.audio = QMediaPlayer()
self.is_loaded = False
self.volume = 100
self.isplaying = False
self.max_bits = 32768
# File Loading is Asynchronous, so we need to be creative here, doesn't need to be duration but it works
self.audio.durationChanged.connect(self.on_durationChanged)
# self.decoder.finished.connect(self.decode_finished_signal)
self.audio.setMedia(QUrl.fromLocalFile(soundfile))
# self.decoder.setSourceFilename(soundfile) # strangely inconsistent file-handling
# It will hang here forever if we don't process the events.
self.audio_file = audioread.audio_open(self.soundfile)
self.audio_data = []
for buf in self.audio_file:
self.audio_data.extend(
struct.unpack("<{}H".format(int(len(list(buf)) / 2)), buf))
print(self.audio_data)
print(len(self.audio_data))
print(len(self.audio_data) / self.audio_file.samplerate)
print(self.audio_file.duration)
print(self.audio_file.channels)
print("DATAEND")
while not self.is_loaded:
QCoreApplication.processEvents()
time.sleep(0.1)
self.isvalid = True
self.pydubfile = None
if AudioSegment:
if which("ffmpeg") is not None:
AudioSegment.converter = which("ffmpeg")
elif which("avconv") is not None:
AudioSegment.converter = which("avconv")
else:
if platform.system() == "Windows":
AudioSegment.converter = os.path.join(
get_main_dir(), "ffmpeg.exe")
# AudioSegment.converter = os.path.dirname(os.path.realpath(__file__)) + "\\ffmpeg.exe"
else:
# TODO: Check if we have ffmpeg or avconv installed
AudioSegment.converter = "ffmpeg"
self.isvalid = True
def __init__(self):
QMainWindow.__init__(self)
self.setFixedSize(400, 100)
self.setWindowTitle("PyPRad")
# Icon made by https://www.flaticon.com/authors/freepik
self.setWindowIcon(QIcon("icon.png"))
self.setWindowIconText("PyPRad")
self.current_stream = "https://kathy.torontocast.com:3060/stream" # Add a Stream URL. Default URL
# Setup Media Player
self.player = QMediaPlayer(self, QMediaPlayer.StreamPlayback)
self.player.setMedia(QUrl(self.current_stream))
# Connect Button
connect_btn = QPushButton("Connect To Stream")
connect_btn.setFixedWidth(150)
connect_btn.clicked.connect(self.connectStream)
# Play Button
self.play = QPushButton()
self.play.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.play.setFixedWidth(100)
self.play.clicked.connect(self.playStream)
# Volume Slider
slider = QSlider(Qt.Horizontal)
slider.setRange(0, 100)
slider.setFixedWidth(100)
slider.setValue(100)
slider.valueChanged.connect(self.setVolume)
# Horizontal Layout
hbox_layout = QHBoxLayout()
hbox_layout.setContentsMargins(0, 0, 0, 0)
hbox_layout.addWidget(connect_btn)
hbox_layout.addWidget(self.play)
hbox_layout.addWidget(slider)
widget = QWidget()
widget.setLayout(hbox_layout)
self.player.stateChanged.connect(self.mediaStateChanged)
self.setCentralWidget(widget)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.settings_model = SettingsModel()
self.manager_model = manager_model.Model(
self.settings_model.get("DatabasePath"))
self.queue_manager = queue_manager.QueueManager(self.manager_model)
self.player_object = QMediaPlayer()
self.player_object.setPlaylist(self.queue_manager)
self.queue_manager.player_object = self.player_object
self.main_window = MainWindow(self.settings_model, self.manager_model,
self.queue_manager)
self.queue_manager.player_widget = self.main_window.playerWidget
self.main_window.playerWidget.queue_manager = self.queue_manager
self.queue_manager.queue_widget = self.main_window.queueWidget
self.main_window.queueWidget.queue_manager = self.queue_manager
self.queue_manager.setup_signals()
self.main_window.show()
def __init__(self, ui_file, parent=None):
#reference to our music player
self.music_player = QMediaPlayer()
volume = self.music_player.setVolume(100)
#call parent QObject constructor
super(MainWindow, self).__init__(parent)
#load the UI file into Python
ui_file = QFile(ui_file)
ui_file.open(QFile.ReadOnly)
loader = QUiLoader()
self.window = loader.load(ui_file)
#always remember to close files
ui_file.close()
#add event listeners
open_action = self.window.findChild(QAction, 'action_open')
open_action.triggered.connect(self.open_action_triggered)
quit_action = self.window.findChild(QAction, 'action_quit')
quit_action.triggered.connect(self.quit_action_triggered)
play_button = self.window.findChild(QPushButton, 'play_button')
play_button.clicked.connect(self.play_button_clicked)
pause_button = self.window.findChild(QPushButton, 'pause_button')
pause_button.clicked.connect(self.pause_button_clicked)
v_up = self.window.findChild(QPushButton, 'v_up')
v_up.clicked.connect(self.v_up_clicked)
v_down = self.window.findChild(QPushButton, 'v_down')
v_down.clicked.connect(self.v_down_clicked)
#skip_prev = self.window.findChild(QPushButton, 'skip_prev')
#skip_prev.clicked.connect(self.skip_prev_clicked)
#skip_next = self.window.findChild(QPushButton, 'skip_next')
#skip_next.clicked.connect(self.skip_next_clicked)
#show window to user
self.window.show()
def __init__(self, soundfile, parent):
self.soundfile = soundfile
self.isplaying = False
self.time = 0 # current audio position in frames
self.audio = QMediaPlayer()
self.decoder = QAudioDecoder()
self.is_loaded = False
self.volume = 100
self.isplaying = False
self.decoded_audio = {}
self.only_samples = []
self.decoding_is_finished = False
self.max_bits = 32768
self.signed = False
# File Loading is Asynchronous, so we need to be creative here, doesn't need to be duration but it works
self.audio.durationChanged.connect(self.on_durationChanged)
self.decoder.finished.connect(self.decode_finished_signal)
self.audio.setMedia(QUrl.fromLocalFile(soundfile))
self.decoder.setSourceFilename(
soundfile) # strangely inconsistent file-handling
self.top_level_widget = None
for widget in QtWidgets.QApplication.topLevelWidgets():
if "lip_sync_frame" in dir(widget):
self.top_level_widget = widget
self.top_level_widget.lip_sync_frame.status_progress.show()
self.top_level_widget.lip_sync_frame.status_progress.reset()
self.top_level_widget.lip_sync_frame.status_progress.setMinimum(0)
self.top_level_widget.lip_sync_frame.status_progress.setMaximum(0)
# It will hang here forever if we don't process the events.
while not self.is_loaded:
QCoreApplication.processEvents()
time.sleep(0.01)
self.top_level_widget.lip_sync_frame.status_progress.setMaximum(
self.decoder.duration())
self.decode_audio(
self.top_level_widget.lip_sync_frame.status_bar_progress)
self.top_level_widget.lip_sync_frame.status_progress.hide()
self.np_data = np.array(self.only_samples)
if not self.signed: # don't ask me why this fixes 8 bit samples...
self.np_data = self.np_data - self.max_bits / 2
print(len(self.only_samples))
print(self.max_bits)
self.isvalid = True
def _set_sound_source(alias):
solution = 2
if solution == 0:
# qrc, MediaPlayer()
sound = QMediaPlayer()
sound.setMedia(QUrl('qrc:/' + alias))
elif solution == 1:
# absoluteFilePath(), MediaPlayer()
path = QFileInfo('sounds/' + alias + '.wav').absoluteFilePath()
sound = QMediaPlayer()
sound.setMedia(QUrl(path))
elif solution == 2:
# qrc, QSound()
sound = QSound('qrc:/' + alias)
return sound
def __init__(self, url):
# type: (str) -> None
self.__url = url # Only used for debugging
# Tell the app not to quit while this sound is loading, since it is plausible that a user is using sounds
# without using a frame or any timers:
TheApp.add_tracked(self)
self.__player = QMediaPlayer(TheApp, flags=QMediaPlayer.LowLatency)
self.__player.setAudioRole(QAudio.GameRole)
self.__player.mediaStatusChanged.connect(self.__on_status_changed)
self.__player.error.connect(self.__on_status_changed)
req = request(url)
content = QMediaContent(req)
self.__player.setMedia(content)
self.__sound_loaded = False
self.__play_requested = False
def open(self):
fileDialog = QFileDialog(self)
supportedMimeTypes = QMediaPlayer.supportedMimeTypes()
if not supportedMimeTypes:
supportedMimeTypes.append("video/x-msvideo") # AVI
fileDialog.setMimeTypeFilters(supportedMimeTypes)
moviesLocation = QStandardPaths.writableLocation(QStandardPaths.MoviesLocation)
fileDialog.setDirectory(moviesLocation)
if fileDialog.exec_() == QDialog.Accepted:
self.playlist.addMedia(fileDialog.selectedUrls()[0])
self.player.play()
class SoundPlayer:
def __init__(self, soundfile, parent):
self.soundfile = soundfile
self.isplaying = False
self.time = 0 # current audio position in frames
self.audio = QMediaPlayer()
self.decoder = QAudioDecoder()
self.is_loaded = False
self.volume = 100
self.isplaying = False
self.decoded_audio = {}
self.only_samples = []
self.decoding_is_finished = False
self.max_bits = 32768
# File Loading is Asynchronous, so we need to be creative here, doesn't need to be duration but it works
self.audio.durationChanged.connect(self.on_durationChanged)
#self.decoder.finished.connect(self.decode_finished_signal)
self.audio.setMedia(QUrl.fromLocalFile(soundfile))
#self.decoder.setSourceFilename(soundfile) # strangely inconsistent file-handling
# It will hang here forever if we don't process the events.
while not self.is_loaded:
QCoreApplication.processEvents()
time.sleep(0.1)
#self.decode_audio()
#self.np_data = np.array(self.only_samples)
#self.np_data = np.abs(self.np_data / self.max_bits)
# A simple normalisation, with this the samples should all be between 0 and 1
# for i in self.decoded_audio.items():
# self.only_samples.extend(i[1][0])
# t = []
# for i in self.only_samples:
# if i != []:
# t.append(i + -(min(self.only_samples)))
#
# t2 = []
# for i in t:
# t2.append(i / max(t))
# self.only_samples = t2
#print(len(self.only_samples))
#print(self.max_bits)
self.isvalid = True
self.pydubfile = None
if AudioSegment:
if which("ffmpeg") is not None:
AudioSegment.converter = which("ffmpeg")
elif which("avconv") is not None:
AudioSegment.converter = which("avconv")
else:
if platform.system() == "Windows":
AudioSegment.converter = os.path.join(get_main_dir(), "ffmpeg.exe")
#AudioSegment.converter = os.path.dirname(os.path.realpath(__file__)) + "\\ffmpeg.exe"
else:
# TODO: Check if we have ffmpeg or avconv installed
AudioSegment.converter = "ffmpeg"
try:
if AudioSegment:
print(self.soundfile)
self.pydubfile = AudioSegment.from_file(self.soundfile, format=os.path.splitext(self.soundfile)[1][1:])
else:
self.wave_reference = wave.open(self.soundfile)
self.isvalid = True
except:
traceback.print_exc()
self.wave_reference = None
self.isvalid = False
#self.audio.play()
def audioformat_to_datatype(self, audioformat):
num_bits = audioformat.sampleSize()
signed = audioformat.sampleType()
self.max_bits = 2 ** int(num_bits)
if signed == QAudioFormat.SampleType.UnSignedInt:
return "uint" + str(num_bits) + "_t"
elif signed == QAudioFormat.SampleType.SignedInt:
self.max_bits = int(self.max_bits / 2)
return "int" + str(num_bits) + "_t"
def decode_audio(self):
self.decoder.start()
while not self.decoding_is_finished:
QCoreApplication.processEvents()
if self.decoder.bufferAvailable():
tempdata = self.decoder.read()
# We use the Pointer Address to get a cffi Pointer to the data (hopefully)
cast_data = self.audioformat_to_datatype(tempdata.format())
possible_data = ffi.cast("{1}[{0}]".format(tempdata.sampleCount(), cast_data), int(tempdata.constData()))
current_sample_data = []
for i in possible_data:
current_sample_data.append(int(ffi.cast(cast_data, i)))
#x = int(ffi.cast("int16_t", possible_data[0]))
self.only_samples.extend(current_sample_data)
self.decoded_audio[self.decoder.position()] = [current_sample_data, len(possible_data), tempdata.byteCount(), tempdata.format()]
def decode_finished_signal(self):
self.decoding_is_finished = True
def on_durationChanged(self, duration):
print("Changed!")
print(duration)
self.is_loaded = True
def get_audio_buffer(self, bufferdata):
print(bufferdata)
def IsValid(self):
return self.isvalid
def Duration(self):
return self.audio.duration() / 1000.0
def GetRMSAmplitude(self, time, sampleDur):
if AudioSegment:
return self.pydubfile[time*1000.0:(time+sampleDur)*1000.0].rms
else:
startframe = int(round(time * self.wave_reference.getframerate()))
samplelen = int(round(sampleDur * self.wave_reference.getframerate()))
self.wave_reference.setpos(startframe)
frame = self.wave_reference.readframes(samplelen)
width = self.wave_reference.getsampwidth()
return audioop.rms(frame, width)
def is_playing(self):
if self.audio.state() == QMediaPlayer.PlayingState:
return True
else:
return False
def set_cur_time(self, newtime):
self.time = newtime * 1000.0
self.audio.setPosition(self.time)
def stop(self):
self.isplaying = False
self.audio.stop()
def current_time(self):
self.time = self.audio.position() / 1000.0
return self.time
def set_volume(self, newvolume):
self.volume = newvolume
self.audio.setVolume(self.volume)
def play(self, arg):
self.isplaying = True # TODO: We should be able to replace isplaying with queries to self.audio.state()
self.audio.play()
def play_segment(self, start, length):
print("Playing Segment")
if not self.isplaying: # otherwise this get's kinda echo-y
self.isplaying = True
self.audio.setPosition(start * 1000.0)
self.audio.play()
thread.start_new_thread(self._wait_for_segment_end, (start, length))
def _wait_for_segment_end(self, newstart, newlength):
start = newstart * 1000.0
length = newlength * 1000.0
end = start + length
print(start)
print(length)
print(end)
while self.audio.position() < end:
QCoreApplication.processEvents()
print(self.audio.position())
time.sleep(0.001)
self.audio.stop()
self.isplaying = False
def __init__(self, soundfile, parent):
self.soundfile = soundfile
self.isplaying = False
self.time = 0 # current audio position in frames
self.audio = QMediaPlayer()
self.decoder = QAudioDecoder()
self.is_loaded = False
self.volume = 100
self.isplaying = False
self.decoded_audio = {}
self.only_samples = []
self.decoding_is_finished = False
self.max_bits = 32768
# File Loading is Asynchronous, so we need to be creative here, doesn't need to be duration but it works
self.audio.durationChanged.connect(self.on_durationChanged)
#self.decoder.finished.connect(self.decode_finished_signal)
self.audio.setMedia(QUrl.fromLocalFile(soundfile))
#self.decoder.setSourceFilename(soundfile) # strangely inconsistent file-handling
# It will hang here forever if we don't process the events.
while not self.is_loaded:
QCoreApplication.processEvents()
time.sleep(0.1)
#self.decode_audio()
#self.np_data = np.array(self.only_samples)
#self.np_data = np.abs(self.np_data / self.max_bits)
# A simple normalisation, with this the samples should all be between 0 and 1
# for i in self.decoded_audio.items():
# self.only_samples.extend(i[1][0])
# t = []
# for i in self.only_samples:
# if i != []:
# t.append(i + -(min(self.only_samples)))
#
# t2 = []
# for i in t:
# t2.append(i / max(t))
# self.only_samples = t2
#print(len(self.only_samples))
#print(self.max_bits)
self.isvalid = True
self.pydubfile = None
if AudioSegment:
if which("ffmpeg") is not None:
AudioSegment.converter = which("ffmpeg")
elif which("avconv") is not None:
AudioSegment.converter = which("avconv")
else:
if platform.system() == "Windows":
AudioSegment.converter = os.path.join(get_main_dir(), "ffmpeg.exe")
#AudioSegment.converter = os.path.dirname(os.path.realpath(__file__)) + "\\ffmpeg.exe"
else:
# TODO: Check if we have ffmpeg or avconv installed
AudioSegment.converter = "ffmpeg"
try:
if AudioSegment:
print(self.soundfile)
self.pydubfile = AudioSegment.from_file(self.soundfile, format=os.path.splitext(self.soundfile)[1][1:])
else:
self.wave_reference = wave.open(self.soundfile)
self.isvalid = True
except:
traceback.print_exc()
self.wave_reference = None
self.isvalid = False
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.playlist = QMediaPlaylist()
self.player = QMediaPlayer()
toolBar = QToolBar()
self.addToolBar(toolBar)
fileMenu = self.menuBar().addMenu("&File")
openAction = QAction(QIcon.fromTheme("document-open"),
"&Open...", self, shortcut=QKeySequence.Open,
triggered=self.open)
fileMenu.addAction(openAction)
exitAction = QAction(QIcon.fromTheme("application-exit"), "E&xit",
self, shortcut="Ctrl+Q", triggered=self.close)
fileMenu.addAction(exitAction)
playMenu = self.menuBar().addMenu("&Play")
playIcon = self.style().standardIcon(QStyle.SP_MediaPlay)
self.playAction = toolBar.addAction(playIcon, "Play")
self.playAction.triggered.connect(self.player.play)
playMenu.addAction(self.playAction)
previousIcon = self.style().standardIcon(QStyle.SP_MediaSkipBackward)
self.previousAction = toolBar.addAction(previousIcon, "Previous")
self.previousAction.triggered.connect(self.previousClicked)
playMenu.addAction(self.previousAction)
pauseIcon = self.style().standardIcon(QStyle.SP_MediaPause)
self.pauseAction = toolBar.addAction(pauseIcon, "Pause")
self.pauseAction.triggered.connect(self.player.pause)
playMenu.addAction(self.pauseAction)
nextIcon = self.style().standardIcon(QStyle.SP_MediaSkipForward)
self.nextAction = toolBar.addAction(nextIcon, "Next")
self.nextAction.triggered.connect(self.playlist.next)
playMenu.addAction(self.nextAction)
stopIcon = self.style().standardIcon(QStyle.SP_MediaStop)
self.stopAction = toolBar.addAction(stopIcon, "Stop")
self.stopAction.triggered.connect(self.player.stop)
playMenu.addAction(self.stopAction)
self.volumeSlider = QSlider()
self.volumeSlider.setOrientation(Qt.Horizontal)
self.volumeSlider.setMinimum(0)
self.volumeSlider.setMaximum(100)
self.volumeSlider.setFixedWidth(app.desktop().availableGeometry(self).width() / 10)
self.volumeSlider.setValue(self.player.volume())
self.volumeSlider.setTickInterval(10)
self.volumeSlider.setTickPosition(QSlider.TicksBelow)
self.volumeSlider.setToolTip("Volume")
self.volumeSlider.valueChanged.connect(self.player.setVolume)
toolBar.addWidget(self.volumeSlider)
aboutMenu = self.menuBar().addMenu("&About")
aboutQtAct = QAction("About &Qt", self, triggered=qApp.aboutQt)
aboutMenu.addAction(aboutQtAct)
self.videoWidget = QVideoWidget()
self.setCentralWidget(self.videoWidget)
self.player.setPlaylist(self.playlist)
self.player.stateChanged.connect(self.updateButtons)
self.player.setVideoOutput(self.videoWidget)
self.updateButtons(self.player.state())
def open(self):
fileDialog = QFileDialog(self)
supportedMimeTypes = QMediaPlayer.supportedMimeTypes()
if not supportedMimeTypes:
supportedMimeTypes.append("video/x-msvideo") # AVI
fileDialog.setMimeTypeFilters(supportedMimeTypes)
moviesLocation = QStandardPaths.writableLocation(QStandardPaths.MoviesLocation)
fileDialog.setDirectory(moviesLocation)
if fileDialog.exec_() == QDialog.Accepted:
self.playlist.addMedia(fileDialog.selectedUrls()[0])
self.player.play()
def previousClicked(self):
# Go to 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:
player.setPosition(0)
def updateButtons(self, state):
mediaCount = self.playlist.mediaCount()
self.playAction.setEnabled(mediaCount > 0
and state != QMediaPlayer.PlayingState)
self.pauseAction.setEnabled(state == QMediaPlayer.PlayingState)
self.stopAction.setEnabled(state != QMediaPlayer.StoppedState)
self.previousAction.setEnabled(self.player.position() > 0)
self.nextAction.setEnabled(mediaCount > 1)
def __init__(self):
super(MainWindow, self).__init__()
self.playlist = QMediaPlaylist()
self.player = QMediaPlayer()
toolBar = QToolBar()
self.addToolBar(toolBar)
fileMenu = self.menuBar().addMenu("&File")
openAction = QAction(QIcon.fromTheme("document-open"),
"&Open...", self, shortcut=QKeySequence.Open,
triggered=self.open)
fileMenu.addAction(openAction)
exitAction = QAction(QIcon.fromTheme("application-exit"), "E&xit",
self, shortcut="Ctrl+Q", triggered=self.close)
fileMenu.addAction(exitAction)
playMenu = self.menuBar().addMenu("&Play")
playIcon = self.style().standardIcon(QStyle.SP_MediaPlay)
self.playAction = toolBar.addAction(playIcon, "Play")
self.playAction.triggered.connect(self.player.play)
playMenu.addAction(self.playAction)
previousIcon = self.style().standardIcon(QStyle.SP_MediaSkipBackward)
self.previousAction = toolBar.addAction(previousIcon, "Previous")
self.previousAction.triggered.connect(self.previousClicked)
playMenu.addAction(self.previousAction)
pauseIcon = self.style().standardIcon(QStyle.SP_MediaPause)
self.pauseAction = toolBar.addAction(pauseIcon, "Pause")
self.pauseAction.triggered.connect(self.player.pause)
playMenu.addAction(self.pauseAction)
nextIcon = self.style().standardIcon(QStyle.SP_MediaSkipForward)
self.nextAction = toolBar.addAction(nextIcon, "Next")
self.nextAction.triggered.connect(self.playlist.next)
playMenu.addAction(self.nextAction)
stopIcon = self.style().standardIcon(QStyle.SP_MediaStop)
self.stopAction = toolBar.addAction(stopIcon, "Stop")
self.stopAction.triggered.connect(self.player.stop)
playMenu.addAction(self.stopAction)
self.volumeSlider = QSlider()
self.volumeSlider.setOrientation(Qt.Horizontal)
self.volumeSlider.setMinimum(0)
self.volumeSlider.setMaximum(100)
self.volumeSlider.setFixedWidth(app.desktop().availableGeometry(self).width() / 10)
self.volumeSlider.setValue(self.player.volume())
self.volumeSlider.setTickInterval(10)
self.volumeSlider.setTickPosition(QSlider.TicksBelow)
self.volumeSlider.setToolTip("Volume")
self.volumeSlider.valueChanged.connect(self.player.setVolume)
toolBar.addWidget(self.volumeSlider)
aboutMenu = self.menuBar().addMenu("&About")
aboutQtAct = QAction("About &Qt", self, triggered=qApp.aboutQt)
aboutMenu.addAction(aboutQtAct)
self.videoWidget = QVideoWidget()
self.setCentralWidget(self.videoWidget)
self.player.setPlaylist(self.playlist)
self.player.stateChanged.connect(self.updateButtons)
self.player.setVideoOutput(self.videoWidget)
self.updateButtons(self.player.state())
class SoundPlayer:
def __init__(self, soundfile, parent):
self.soundfile = soundfile
self.isplaying = False
self.time = 0 # current audio position in frames
self.audio = QMediaPlayer()
self.decoder = QAudioDecoder()
self.is_loaded = False
self.volume = 100
self.isplaying = False
self.decoded_audio = {}
self.only_samples = []
self.decoding_is_finished = False
self.max_bits = 32768
self.signed = False
# File Loading is Asynchronous, so we need to be creative here, doesn't need to be duration but it works
self.audio.durationChanged.connect(self.on_durationChanged)
self.decoder.finished.connect(self.decode_finished_signal)
self.audio.setMedia(QUrl.fromLocalFile(soundfile))
self.decoder.setSourceFilename(soundfile) # strangely inconsistent file-handling
# It will hang here forever if we don't process the events.
while not self.is_loaded:
QCoreApplication.processEvents()
time.sleep(0.1)
self.decode_audio()
self.np_data = np.array(self.only_samples)
if not self.signed: # don't ask me why this fixes 8 bit samples...
self.np_data = self.np_data - self.max_bits / 2
print(len(self.only_samples))
print(self.max_bits)
self.isvalid = True
def audioformat_to_datatype(self, audioformat):
num_bits = audioformat.sampleSize()
signed = audioformat.sampleType()
self.max_bits = 2 ** int(num_bits)
if signed == QAudioFormat.SampleType.UnSignedInt:
self.signed = False
return "uint" + str(num_bits) + "_t"
elif signed == QAudioFormat.SampleType.SignedInt:
self.signed = True
self.max_bits = int(self.max_bits / 2)
return "int" + str(num_bits) + "_t"
def decode_audio(self):
self.decoder.start()
while not self.decoding_is_finished:
QCoreApplication.processEvents()
if self.decoder.bufferAvailable():
tempdata = self.decoder.read()
# We use the Pointer Address to get a cffi Pointer to the data (hopefully)
cast_data = self.audioformat_to_datatype(tempdata.format())
possible_data = ffi.cast("{1}[{0}]".format(tempdata.sampleCount(), cast_data), int(tempdata.constData()))
self.only_samples.extend(possible_data)
self.decoded_audio[self.decoder.position()] = [possible_data, len(possible_data), tempdata.byteCount(), tempdata.format()]
def decode_finished_signal(self):
self.decoding_is_finished = True
def on_durationChanged(self, duration):
print("Changed!")
print(duration)
self.is_loaded = True
def get_audio_buffer(self, bufferdata):
print(bufferdata)
def IsValid(self):
return self.isvalid
def Duration(self):
return self.audio.duration() / 1000.0
def GetRMSAmplitude(self, time, sampleDur):
# time_start = time * (len(self.only_samples)/self.Duration())
# time_end = (time + sampleDur) * (len(self.only_samples)/self.Duration())
# samples = self.only_samples[int(time_start):int(time_end)]
time_start = time * (len(self.np_data) / self.Duration())
time_end = (time + sampleDur) * (len(self.np_data) / self.Duration())
samples = self.np_data[int(time_start):int(time_end)]
if len(samples):
return np.sqrt(np.mean(samples ** 2))
else:
return 1
def is_playing(self):
if self.audio.state() == QMediaPlayer.PlayingState:
return True
else:
return False
def set_cur_time(self, newtime):
self.time = newtime * 1000.0
self.audio.setPosition(self.time)
def stop(self):
self.isplaying = False
self.audio.stop()
def current_time(self):
self.time = self.audio.position() / 1000.0
return self.time
def set_volume(self, newvolume):
self.volume = newvolume
self.audio.setVolume(self.volume)
def play(self, arg):
self.isplaying = True # TODO: We should be able to replace isplaying with queries to self.audio.state()
self.audio.play()
def play_segment(self, start, length):
print("Playing Segment")
if not self.is_playing(): # otherwise this get's kinda echo-y
self.isplaying = True
self.audio.setPosition(start * 1000.0)
self.audio.play()
thread.start_new_thread(self._wait_for_segment_end, (start, length))
def _wait_for_segment_end(self, newstart, newlength):
start = newstart * 1000.0
length = newlength * 1000.0
end = start + length
print(start)
print(length)
print(end)
while self.audio.position() < end:
if not self.isplaying:
return 0
QCoreApplication.processEvents()
print(self.audio.position())
time.sleep(0.001)
self.audio.stop()
self.isplaying = False
