Python PyQt5.QtMultimedia.QMediaContent() Examples

def load_soundtrack_playlist():
    """
    Loads the play list of the soundtracks and replaces the file name with the full path.

    A playlist is a list where each entry is a list of two strings: file path, title
    """
    global soundtrack_playlist

    # create playlist
    soundtrack_playlist = QtMultimedia.QMediaPlaylist()
    soundtrack_playlist.setPlaybackMode(QtMultimedia.QMediaPlaylist.Loop)

    # read information file
    data = utils.read_as_yaml(constants.SOUNDTRACK_INFO_FILE)

    # add the soundtrack folder to each file name
    for entry in data:
        file = constants.extend(constants.SOUNDTRACK_FOLDER, entry[0])
        url = qt.local_url(file)
        media = QtMultimedia.QMediaContent(url)
        soundtrack_playlist.addMedia(media) 

def play_song(self, song: str):
        """Play a song given its file url in the local filesystem."""
        self.player.playlist().clear()
        self.controls.duration_label.setText('Loading...')
        url = QtCore.QUrl.fromLocalFile(song)

        if self.check_advert_intermission():
            self.player.playlist().addMedia(QtMultimedia.QMediaContent(url))
        else:
            self.player.playlist().insertMedia(
                self.player.playlist().nextIndex(),
                QtMultimedia.QMediaContent(url)
            )

            if self.player.playlist().mediaCount() == 1:
                self.controls.toggle_play()
            else:
                self.controls._next_song()
        self.controls.duration_label.setText('0')
        self.controls.play_pause_button.setIcon(QtGui.QIcon(imgButtons.Pause.str)) 

def play(self):
        try:
            media = self.musics[self.currentIndex]
        except:
            logger.error("unknow error. musics info: {0}".format(self.musics))
            return

        if type(media) == str:
            if 'http' in media or 'file' in media:
                content = QMediaContent(QUrl(media))
            else:
                content = QMediaContent(QUrl.fromLocalFile(media))

            self.musics = self.musics[:self.currentIndex] + [content] + self.musics[self.currentIndex+1:]
            media = content

        self.parent.setMedia(media)
        self.parent.playMusic()

        self.tabMusicEvent() 

def setCurrentIndex(self, index):
        try:
            media = self.musics[index]
        except:
            logger.error("unknow error. musics info: {0}".format(self.musics))
            return

        if type(media) == str:
            if 'http' in media or 'file' in media:
                content = QMediaContent(QUrl(media))
            else:
                content = QMediaContent(QUrl.fromLocalFile(media))

            self.musics = self.musics[:index] + [content] + self.musics[index+1:]
            self.parent.setMedia(content)
        else:
            self.parent.setMedia(media)

        self.parent.playMusic()
        self.tabMusicEvent()

        self.currentIndex = index 

def _open_file(self):
        """Opens an audio file and adds it to the playlist."""
        song = QtWidgets.QFileDialog.getOpenFileName(self, "Open Song", "", "Sound Files (*.mp3)")

        if song[0]:
            url = QtCore.QUrl.fromLocalFile(song[0])

            if not self.player.playlist().mediaCount():
                self.player.playlist().addMedia(QtMultimedia.QMediaContent(url))
                self.toggle_play()
            else:
                self.player.playlist().addMedia(QtMultimedia.QMediaContent(url)) 

def play_pronunciation(self):
        if not self.pronunciation_mp3 or not multimedia_available:
            return

        media_content = QtMultimedia.QMediaContent(
            QtCore.QUrl(self.pronunciation_mp3))

        player = QtMultimedia.QMediaPlayer(self)
        player.setMedia(media_content)
        player.play() 

def disable_advert_controls(self, media: QtMultimedia.QMediaContent):
        """Disable player controls while an ad is playing."""
        if self.advert_in_progress:
            self.now_playing_widget.audio_visualiser.green_flames()
            self.controls.setEnabled(False)
            self.advert_in_progress = False
        else:
            self.now_playing_widget.audio_visualiser.red_flames()
            self.controls.setEnabled(True) 

def _media_changed(self, media: QtMultimedia.QMediaContent):
        """Update 'Now playing' label when a new song is selected."""
        filename = media.canonicalUrl().fileName()
        song_name = '.'.join(filename.split('.')[:-1])
        self.now_playing_label.setText(song_name) 

def on_file_selected(self, item):
        fn = item.text()
        url = qtc.QUrl.fromLocalFile(self.video_dir.filePath(fn))
        content = qtmm.QMediaContent(url)
        self.player.setMedia(content)
        self.player.play()

    #######################
    # Recording callbacks #
    ####################### 

def set_file(self, url):
        self.label.setText(url.fileName())
        if url.scheme() == '':
            url.setScheme('file')
        content = qtmm.QMediaContent(url)
        #self.player.setMedia(content)
        # Looping
        # must retain a reference to the playlist
        # hence self.playlist
        self.playlist = qtmm.QMediaPlaylist()
        self.playlist.addMedia(content)
        self.playlist.setCurrentIndex(1)
        self.player.setPlaylist(self.playlist)
        self.loop_cb.setChecked(False) 

def addMedia(self, media_file):
        media_content = QMediaContent(QUrl.fromLocalFile(media_file))
        self._playlist.addMedia(media_content)

    # クリックでポーズ・再生の切り替え 

def setMediaUrl(self, url):
        if url.startswith('http'):
            _url = QUrl(url)
        else:
            _url = QUrl.fromLocalFile(url)

        gPlayer.setMedia(QMediaContent(_url))
        self.playToggle(self._isPlaying) 

def saveCookies(self):
        with open(self.musicsCookiesFolder, 'wb') as f:
            for row, data in enumerate(self.musics):
                if type(data) == QMediaContent:
                    url = data.canonicalUrl().toString()
                    self.musics[row] = url

            pickle.dump(self.musics, f)

        with open(self.mediaListCookiesFolder, 'wb') as f:
            pickle.dump(self.mediaList, f) 

def addMedias(self, url, data):
        # url为QMediaContent, data包含这个歌曲的信息。{name, author, url, music_id}
        self.parent.setMedia(url)
        self.musics.append(url)
        self.currentIndex = len(self.musics) - 1
        self.mediaList[url.canonicalUrl().toString()] = data
        self.parent.playMusic()
        
        # window
        self.playWidgets.parent.systemTray.setToolTip('{0}-{1}'.format(data['name'], data['author'])) 

def setMusic(self, url, data):
        """设置当前的音乐，可以直接用网络链接。"""
        if url:
            if 'http' in url or 'file' in url:
                self.playList.addMedias(QMediaContent(QUrl(url)), data)
            else:
                self.playList.addMedias(QMediaContent(QUrl.fromLocalFile(url)), data)
            return True
        return False 

def set_source(self, audio_path):
        url = QUrl.fromLocalFile(audio_path)
        media = QMediaContent(url)
        self.setNotifyInterval(35)
        self.setMedia(media) 

def playFile(self, videoPath, islocal=False, klv_folder=None):
        ''' Play file from path
        @param videoPath: Video file path
        @param islocal: Check if video is local,created using multiplexor or is MISB
        @param klv_folder: klv folder if video is created using multiplexor
        '''
        self.islocal = islocal
        self.klv_folder = klv_folder
        try:
            # Remove All Data
            self.RemoveAllData()
            self.clearMetadata()
            QApplication.processEvents()

            # Create Group
            root = QgsProject.instance().layerTreeRoot()
            node_group = QgsLayerTreeGroup(videoPath)
            #If you have a loaded project, insert the group
            #on top of it.
            root.insertChildNode(0, node_group)

            self.fileName = videoPath
            self.playlist = QMediaPlaylist()

            self.isStreaming = False
            if "://" in self.fileName:
                self.isStreaming = True

            if self.isStreaming:
                # show video from splitter (port +1)
                oldPort = videoPath.split(":")[2]
                newPort = str(int(oldPort) + 10)                
                proto = videoPath.split(":")[0]
                url = QUrl(proto + "://127.0.0.1:" + newPort)
            else:
                url = QUrl.fromLocalFile(videoPath)
            qgsu.showUserAndLogMessage("", "Added: " + str(url), onlyLog=True)

            self.playlist.addMedia(QMediaContent(url))
            self.player.setPlaylist(self.playlist)

            self.setWindowTitle(QCoreApplication.translate(
                "QgsFmvPlayer", 'Playing : ') + os.path.basename(videoPath))

            CreateVideoLayers(hasElevationModel(), videoPath)

            self.HasFileAudio = True
            if not self.HasAudio(videoPath):
                self.actionAudio.setEnabled(False)
                self.actionSave_Audio.setEnabled(False)
                self.HasFileAudio = False

            self.playClicked(True)

        except Exception as e:
            qgsu.showUserAndLogMessage(QCoreApplication.translate(
                "QgsFmvPlayer", 'Open Video File : '), str(e), level=QGis.Warning)