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