Player Example¶
Media Player demonstrates a simple multimedia player that can play audio and or video files using various codecs.
# Copyright (C) 2025 The Qt Company Ltd.
# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
"""PySide6 Multimedia player example"""
import sys
from argparse import ArgumentParser, RawTextHelpFormatter
from PySide6.QtWidgets import QApplication
from PySide6.QtCore import qVersion, QCoreApplication, QDir, QUrl
from player import Player
if __name__ == "__main__":
app = QApplication(sys.argv)
QCoreApplication.setApplicationName("Player Example")
QCoreApplication.setOrganizationName("QtProject")
QCoreApplication.setApplicationVersion(qVersion())
argument_parser = ArgumentParser(description=QCoreApplication.applicationName(),
formatter_class=RawTextHelpFormatter)
argument_parser.add_argument("file", help="File", nargs='?', type=str)
options = argument_parser.parse_args()
player = Player()
if options.file:
player.openUrl(QUrl.fromUserInput(options.file, QDir.currentPath(),
QUrl.UserInputResolutionOption.AssumeLocalFile))
player.show()
sys.exit(QCoreApplication.exec())
# Copyright (C) 2025 The Qt Company Ltd.
# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
from math import log10, sqrt
from PySide6.QtMultimedia import QAudioBuffer
from PySide6.QtWidgets import (QApplication, QHBoxLayout, QLabel, QSizePolicy, QToolButton,
QVBoxLayout, QWidget)
from PySide6.QtGui import QBrush, QPainter, QPalette
from PySide6.QtCore import QObject, QRectF, QThread, QTimer, qFuzzyCompare, Qt, Signal, Slot
# Constants used by AudioLevelMeter and MeterChannel
WIDGET_WIDTH = 34
MAX_CHANNELS = 8
PEAK_COLOR = "#1F9B5D"
RMS_COLOR = "#28C878"
RMS_WINDOW = 400 # ms
PEAK_LABEL_HOLD_TIME = 2000 # ms
DECAY_EASE_IN_TIME = 160 # ms
UPDATE_INTERVAL = 16 # ms, Assuming 60 Hz refresh rate.
DB_DECAY_PER_SECOND = 20.0
DB_DECAY_PER_UPDATE = DB_DECAY_PER_SECOND / (1000 / UPDATE_INTERVAL)
DB_MAX = 0.0
DB_MIN = -60.0
def amplitudeToDb(f):
"""Converts a float sample value to dB and clamps it between DB_MIN and DB_MAX."""
if f <= 0:
return DB_MIN
v = 20.0 * log10(f)
if v < DB_MIN:
return DB_MIN
if v > DB_MAX:
return DB_MAX
return v
# A struct used by BufferAnalyzer to emit its results back to AudioLevelMeter
class BufferValues:
"""A struct used by BufferAnalyzer to emit its results back to AudioLevelMeter."""
def __init__(self, nChannels):
self.peaks = [0.0] * nChannels
self.squares = [0.0] * nChannels
class BufferAnalyzer(QObject):
"""A worker class analyzing incoming buffers on a separate worker thread."""
valuesReady = Signal(BufferValues)
def __init__(self, parent=None):
super().__init__(parent)
self.m_stopRequested = False
def requestStop(self):
self.m_stopRequested = True
@Slot(QAudioBuffer, int)
def analyzeBuffer(self, buffer, maxChannelsToAnalyze):
"""Analyzes an audio buffer and emits its peak and sumOfSquares values.
Skips remaining frames if self.m_stopRequested is set to true."""
if QThread.currentThread().isInterruptionRequested():
return # Interrupted by ~AudioLevelMeter, skipping remaining buffers in signal queue
self.m_stopRequested = False
channelCount = buffer.format().channelCount()
channelsToAnalyze = min(channelCount, maxChannelsToAnalyze)
values = BufferValues(channelsToAnalyze)
bufferData = buffer.constData()
bufferSize = len(bufferData)
bytesPerSample = buffer.format().bytesPerSample()
for i in range(0, bufferSize, bytesPerSample * channelCount):
if self.m_stopRequested:
framesSkipped = (bufferSize - i) / channelCount
print("BufferAnalyzer::analyzeBuffer skipped", framesSkipped, "out of",
buffer.frameCount(), "frames")
# Emit incomplete values also when stop is requested to get some audio level readout
# even if frames are being skipped for every buffer. Displayed levels will be
# inaccurate.
break
for channelIndex in range(0, channelsToAnalyze):
offset = i + bytesPerSample * channelIndex
sample = buffer.format().normalizedSampleValue(bufferData[offset:])
values.peaks[channelIndex] = max(values.peaks[channelIndex], abs(sample))
values.squares[channelIndex] += sample * sample
self.valuesReady.emit(values)
class MeterChannel(QWidget):
"""A custom QWidget representing an audio channel in the audio level meter. It serves
both as a model for the channels's peak and RMS values and as a view using the overridden
paintEvent()."""
def __init__(self, parent):
super().__init__(parent)
self.m_peakDecayRate = 0.0
self.m_rmsDecayRate = 0.0
self.m_peak = DB_MIN
self.m_rms = DB_MIN
self.m_sumOfSquares = 0.0
self.m_sumOfSquaresQueue = []
self.m_peakBrush = QBrush(PEAK_COLOR)
self.m_rmsBrush = QBrush(RMS_COLOR)
def normalize(self, dB):
"""# Normalizes a dB value for visualization."""
return (dB - DB_MIN) / (DB_MAX - DB_MIN)
def clearRmsData(self):
"""Clears the data used to calculate RMS values."""
self.m_sumOfSquares = 0.0
self.m_sumOfSquaresQueue = []
def decayPeak(self):
"""Decays self.m_peak value by DB_DECAY_PER_UPDATE with ease-in animation based
on DECAY_EASE_IN_TIME."""
peak = self.m_peak
if qFuzzyCompare(peak, DB_MIN):
return
cubicEaseInFactor = self.m_peakDecayRate * self.m_peakDecayRate * self.m_peakDecayRate
self.m_peak = max(DB_MIN, peak - DB_DECAY_PER_UPDATE * cubicEaseInFactor)
if self.m_peakDecayRate < 1:
self.m_peakDecayRate += float(UPDATE_INTERVAL) / float(DECAY_EASE_IN_TIME)
if self.m_peakDecayRate > 1.0:
self.m_peakDecayRate = 1.0
def decayRms(self):
"""Decays self.m_rms value by DB_DECAY_PER_UPDATE with ease-in animation based on
DECAY_EASE_IN_TIME."""
rms = self.m_rms
if qFuzzyCompare(rms, DB_MIN):
return
cubicEaseInFactor = self.m_rmsDecayRate * self.m_rmsDecayRate * self.m_rmsDecayRate
self.m_rms = max(DB_MIN, rms - DB_DECAY_PER_UPDATE * cubicEaseInFactor)
if self.m_rmsDecayRate < 1:
self.m_rmsDecayRate += float(UPDATE_INTERVAL) / float(DECAY_EASE_IN_TIME)
if self.m_rmsDecayRate > 1.0:
self.m_rmsDecayRate = 1.0
def updatePeak(self, sampleValue):
"""Updates self.m_peak and resets self.m_peakDecayRate if sampleValue > self.m_peak."""
dB = amplitudeToDb(sampleValue)
if dB > self.m_peak:
self.m_peakDecayRate = 0
self.m_peak = dB
def updateRms(self, sumOfSquaresForOneBuffer, duration, frameCount):
"""Calculates current RMS. Resets self.m_rmsDecayRate and updates self.m_rms
if current RMS > self.m_rms."""
# Add the new sumOfSquares to the queue and update the total
self.m_sumOfSquaresQueue.append(sumOfSquaresForOneBuffer)
self.m_sumOfSquares += sumOfSquaresForOneBuffer
# Remove the oldest sumOfSquares to stay within the RMS window
if len(self.m_sumOfSquaresQueue) * duration > RMS_WINDOW:
self.m_sumOfSquares -= self.m_sumOfSquaresQueue[0]
del self.m_sumOfSquaresQueue[0]
# Fix negative values caused by floating point precision errors
if self.m_sumOfSquares < 0:
self.m_sumOfSquares = 0
# Calculate the new RMS value
if self.m_sumOfSquares > 0 and self.m_sumOfSquaresQueue:
newRms = sqrt(self.m_sumOfSquares / (frameCount * len(self.m_sumOfSquaresQueue)))
dB = amplitudeToDb(newRms)
if dB > self.m_rms:
self.m_rmsDecayRate = 0
self.m_rms = dB
def paintEvent(self, event):
"""Paints the level bar of the meter channel based on the decayed peak and rms values."""
if qFuzzyCompare(self.m_peak, DB_MIN) and qFuzzyCompare(self.m_rms, DB_MIN):
return # Nothing to paint
peakLevel = self.normalize(self.m_peak)
rmsLevel = self.normalize(self.m_rms)
with QPainter(self) as painter:
rect = QRectF(0, self.height(), self.width(), -peakLevel * self.height())
painter.fillRect(rect, self.m_peakBrush) # Paint the peak level
rect.setHeight(-rmsLevel * self.height())
painter.fillRect(rect, self.m_rmsBrush) # Paint the RMS level
class AudioLevelMeter(QWidget):
"""The audio level meter´s parent widget class. It acts as a controller
for the MeterChannel widgets and the BufferAnalyzer worker."""
newBuffer = Signal(QAudioBuffer, int)
def __init__(self, parent=None):
super().__init__(parent)
self.m_isOn = True
self.m_isActive = False
self.m_channels = []
self.m_channelCount = 0
self.m_bufferDurationMs = 0
self.m_frameCount = 0
self.m_highestPeak = 0.0
self.m_updateTimer = QTimer()
self.m_deactivationTimer = QTimer()
self.m_peakLabelHoldTimer = QTimer()
self.m_peakLabel = None
self.m_onOffButton = None
self.m_bufferAnalyzer = None
self.m_analyzerThread = QThread()
# Layout and background color
self.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Preferred)
self.setMinimumWidth(WIDGET_WIDTH)
currentPalette = self.palette()
currentPalette.setColor(QPalette.ColorRole.Window,
currentPalette.color(QPalette.ColorRole.Base))
self.setPalette(currentPalette)
self.setAutoFillBackground(True)
mainLayout = QVBoxLayout(self)
mainLayout.setSpacing(2)
mainLayout.setContentsMargins(0, 0, 0, 0)
# Meter channels
meterChannelLayout = QHBoxLayout()
meterChannelLayout.setContentsMargins(2, 2, 2, 2)
meterChannelLayout.setSpacing(2)
for i in range(0, MAX_CHANNELS):
channel = MeterChannel(self)
meterChannelLayout.addWidget(channel)
self.m_channels.append(channel)
mainLayout.addLayout(meterChannelLayout)
# Peak label
self.m_peakLabel = QLabel("-", self)
self.m_peakLabel.setAlignment(Qt.AlignmentFlag.AlignCenter)
font = QApplication.font()
font.setPointSize(10)
self.m_peakLabel.setFont(font)
mainLayout.addWidget(self.m_peakLabel)
mainLayout.setStretch(0, 1)
# On/off button
self.m_onOffButton = QToolButton(self)
mainLayout.addWidget(self.m_onOffButton)
self.m_onOffButton.setMaximumWidth(WIDGET_WIDTH)
self.m_onOffButton.setText("On")
self.m_onOffButton.setCheckable(True)
self.m_onOffButton.setChecked(True)
self.m_onOffButton.clicked.connect(self.toggleOnOff)
# Timer triggering update of the audio level bars
self.m_updateTimer.timeout.connect(self.updateBars)
# Timer postponing deactivation of update timer to allow meters to fade to 0
self.m_deactivationTimer.timeout.connect(self.m_updateTimer.stop)
self.m_deactivationTimer.setSingleShot(True)
# Timer resetting the peak label
self.m_peakLabelHoldTimer.timeout.connect(self.resetPeakLabel)
self.m_peakLabelHoldTimer.setSingleShot(True)
# Buffer analyzer and worker thread that analyzes incoming buffers
self.m_bufferAnalyzer = BufferAnalyzer()
self.m_bufferAnalyzer.moveToThread(self.m_analyzerThread)
self.m_analyzerThread.finished.connect(self.m_bufferAnalyzer.deleteLater)
self.newBuffer.connect(self.m_bufferAnalyzer.analyzeBuffer)
self.m_bufferAnalyzer.valuesReady.connect(self.updateValues)
self.m_analyzerThread.start()
def closeRequest(self):
self.m_analyzerThread.requestInterruption()
self.m_bufferAnalyzer.requestStop()
self.m_analyzerThread.quit()
self.m_analyzerThread.wait()
@Slot(QAudioBuffer)
def onAudioBufferReceived(self, buffer):
"""Receives a buffer from QAudioBufferOutput and triggers BufferAnalyzer to analyze it."""
if not self.m_isOn or not buffer.isValid() or not buffer.format().isValid():
return
if not self.m_isActive:
self.activate()
# Update internal values to match the current audio stream
self.updateChannelCount(buffer.format().channelCount())
self.m_frameCount = buffer.frameCount()
self.m_bufferDurationMs = buffer.duration() / 1000
# Stop any ongoing analysis, skipping remaining frames
self.m_bufferAnalyzer.requestStop()
self.newBuffer.emit(buffer, self.m_channelCount)
@Slot(BufferValues)
def updateValues(self, values):
"""Updates peak/RMS values and peak label."""
if not self.m_isActive:
return # Discard incoming values from BufferAnalyzer
bufferPeak = 0.0
for i in range(0, len(values.peaks)):
bufferPeak = max(bufferPeak, values.peaks[i])
self.m_channels[i].updatePeak(values.peaks[i])
self.m_channels[i].updateRms(values.squares[i], self.m_bufferDurationMs,
self.m_frameCount)
self.updatePeakLabel(bufferPeak)
def updatePeakLabel(self, peak):
"""Updates peak label and restarts self.m_peakLabelHoldTimer
if peak >= self.m_highestPeak."""
if peak < self.m_highestPeak:
return
self.m_peakLabelHoldTimer.start(PEAK_LABEL_HOLD_TIME)
if qFuzzyCompare(peak, self.m_highestPeak):
return
self.m_highestPeak = peak
dB = amplitudeToDb(self.m_highestPeak)
self.m_peakLabel.setText(f"{int(dB)}")
@Slot()
def resetPeakLabel(self):
"""Resets peak label. Called when self.m_labelHoldTimer timeouts."""
self.m_highestPeak = 0.0
self.m_peakLabel.setText(f"{DB_MIN}" if self.m_isOn else "")
def clearAllRmsData(self):
"""Clears internal data used to calculate RMS values."""
for channel in self.m_channels.copy():
channel.clearRmsData()
@Slot()
def activate(self):
"""Starts the update timer that updates the meter bar."""
self.m_isActive = True
self.m_deactivationTimer.stop()
self.m_updateTimer.start(UPDATE_INTERVAL)
@Slot()
def deactivate(self):
"""Start the deactiviation timer that eventually stops the update timer."""
self.m_isActive = False
self.clearAllRmsData()
# Calculate the time it takes to decay fram max to min dB
interval = (DB_MAX - DB_MIN) / (DB_DECAY_PER_SECOND / 1000) + DECAY_EASE_IN_TIME
self.m_deactivationTimer.start(interval)
@Slot()
def updateBars(self):
"""Decays internal peak and RMS values and triggers repainting of meter bars."""
for i in range(0, self.m_channelCount):
channel = self.m_channels[i]
channel.decayPeak()
channel.decayRms()
channel.update() # Trigger paint event
@Slot()
def toggleOnOff(self):
"""Toggles between on (activated) and off (deactivated) state."""
self.m_isOn = not self.m_isOn
if not self.m_isOn:
self.deactivate()
else:
self.activate()
self.m_onOffButton.setText("On" if self.m_isOn else "Off")
def updateChannelCount(self, channelCount):
"""Updates the number of visible MeterChannel widgets."""
if (channelCount == self.m_channelCount
or (channelCount > MAX_CHANNELS and MAX_CHANNELS == self.m_channelCount)):
return
self.m_channelCount = min(channelCount, MAX_CHANNELS)
for i in range(0, MAX_CHANNELS):
self.m_channels[i].setVisible(i < self.m_channelCount)
# Copyright (C) 2025 The Qt Company Ltd.
# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
from functools import cache
from PySide6.QtMultimedia import (QAudioBufferOutput, QAudioDevice, QAudioOutput, QMediaDevices,
QMediaFormat, QMediaMetaData, QMediaPlayer)
from PySide6.QtWidgets import (QApplication, QComboBox, QDialog, QFileDialog, QGridLayout,
QHBoxLayout, QLabel, QLineEdit, QMessageBox, QPushButton,
QSizePolicy, QSlider, QVBoxLayout, QWidget)
from PySide6.QtGui import QCursor, QPixmap
from PySide6.QtCore import QDir, QLocale, QStandardPaths, QTime, Qt, Signal, Slot
from audiolevelmeter import AudioLevelMeter
from playercontrols import PlayerControls
from videowidget import VideoWidget
MP4 = 'video/mp4'
@cache
def getSupportedMimeTypes():
result = []
for f in QMediaFormat().supportedFileFormats(QMediaFormat.ConversionMode.Decode):
mime_type = QMediaFormat(f).mimeType()
result.append(mime_type.name())
if MP4 not in result:
result.append(MP4) # Should always be there when using FFMPEG
return result
class Player(QWidget):
fullScreenChanged = Signal(bool)
def __init__(self, parent=None):
super().__init__(parent)
self.m_statusInfo = ""
self.m_mediaDevices = QMediaDevices()
self.m_player = QMediaPlayer(self)
self.m_audioOutput = QAudioOutput(self)
self.m_player.setAudioOutput(self.m_audioOutput)
self.m_player.durationChanged.connect(self.durationChanged)
self.m_player.positionChanged.connect(self.positionChanged)
self.m_player.metaDataChanged.connect(self.metaDataChanged)
self.m_player.mediaStatusChanged.connect(self.statusChanged)
self.m_player.bufferProgressChanged.connect(self.bufferingProgress)
self.m_player.hasVideoChanged.connect(self.videoAvailableChanged)
self.m_player.errorChanged.connect(self.displayErrorMessage)
self.m_player.tracksChanged.connect(self.tracksChanged)
self.m_videoWidget = VideoWidget(self)
available_geometry = self.screen().availableGeometry()
self.m_videoWidget.setMinimumSize(available_geometry.width() / 2,
available_geometry.height() / 3)
self.m_player.setVideoOutput(self.m_videoWidget)
# audio level meter
self.m_audioBufferOutput = QAudioBufferOutput(self)
self.m_player.setAudioBufferOutput(self.m_audioBufferOutput)
self.m_audioLevelMeter = AudioLevelMeter(self)
self.m_audioBufferOutput.audioBufferReceived.connect(self.m_audioLevelMeter.onAudioBufferReceived) # noqa: E501
self.m_player.playingChanged.connect(self.m_audioLevelMeter.deactivate)
# player layout
layout = QVBoxLayout(self)
# display
displayLayout = QHBoxLayout()
displayLayout.addWidget(self.m_videoWidget, 2)
displayLayout.addWidget(self.m_audioLevelMeter, 3)
layout.addLayout(displayLayout)
# duration slider and label
hLayout = QHBoxLayout()
self.m_slider = QSlider(Qt.Orientation.Horizontal, self)
self.m_slider.setRange(0, self.m_player.duration())
self.m_slider.sliderMoved.connect(self.seek)
hLayout.addWidget(self.m_slider)
self.m_labelDuration = QLabel()
self.m_labelDuration.setSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Fixed)
hLayout.addWidget(self.m_labelDuration)
layout.addLayout(hLayout)
# controls
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
openButton = QPushButton("Open", self)
openButton.clicked.connect(self.open)
controlLayout.addWidget(openButton)
controlLayout.addStretch(1)
controls = PlayerControls()
controls.setState(self.m_player.playbackState())
controls.setVolume(self.m_audioOutput.volume())
controls.setMuted(controls.isMuted())
controls.play.connect(self.m_player.play)
controls.pause.connect(self.m_player.pause)
controls.stop.connect(self.m_player.stop)
controls.previous.connect(self.previousClicked)
controls.changeVolume.connect(self.m_audioOutput.setVolume)
controls.changeMuting.connect(self.m_audioOutput.setMuted)
controls.changeRate.connect(self.m_player.setPlaybackRate)
controls.stop.connect(self.m_videoWidget.update)
self.m_player.playbackStateChanged.connect(controls.setState)
self.m_audioOutput.volumeChanged.connect(controls.setVolume)
self.m_audioOutput.mutedChanged.connect(controls.setMuted)
controlLayout.addWidget(controls)
controlLayout.addStretch(1)
self.m_fullScreenButton = QPushButton("FullScreen", self)
self.m_fullScreenButton.setCheckable(True)
controlLayout.addWidget(self.m_fullScreenButton)
self.m_pitchCompensationButton = QPushButton("Pitch compensation", self)
self.m_pitchCompensationButton.setCheckable(True)
av = self.m_player.pitchCompensationAvailability()
toolTip = ""
if av == QMediaPlayer.PitchCompensationAvailability.AlwaysOn:
self.m_pitchCompensationButton.setEnabled(False)
self.m_pitchCompensationButton.setChecked(True)
toolTip = "Pitch compensation always enabled on self backend"
elif av == QMediaPlayer.PitchCompensationAvailability.Unavailable:
self.m_pitchCompensationButton.setEnabled(False)
self.m_pitchCompensationButton.setChecked(False)
toolTip = "Pitch compensation unavailable on self backend"
elif av == QMediaPlayer.PitchCompensationAvailability.Available:
self.m_pitchCompensationButton.setEnabled(True)
self.m_pitchCompensationButton.setChecked(self.m_player.pitchCompensation())
self.m_pitchCompensationButton.setToolTip(toolTip)
controlLayout.addWidget(self.m_pitchCompensationButton)
self.m_player.pitchCompensationChanged.connect(self._updatePitchCompensation)
self.m_pitchCompensationButton.setChecked(self.m_player.pitchCompensation())
self.m_pitchCompensationButton.toggled.connect(self.m_player.setPitchCompensation)
self.m_audioOutputCombo = QComboBox(self)
controlLayout.addWidget(self.m_audioOutputCombo)
self.updateAudioDevices()
self.m_audioOutputCombo.activated.connect(self.audioOutputChanged)
self.m_mediaDevices.audioOutputsChanged.connect(self.updateAudioDevices)
layout.addLayout(controlLayout)
# tracks
tracksLayout = QGridLayout()
self.m_audioTracks = QComboBox(self)
self.m_audioTracks.activated.connect(self.selectAudioStream)
tracksLayout.addWidget(QLabel("Audio Tracks:"), 0, 0)
tracksLayout.addWidget(self.m_audioTracks, 0, 1)
self.m_videoTracks = QComboBox(self)
self.m_videoTracks.activated.connect(self.selectVideoStream)
tracksLayout.addWidget(QLabel("Video Tracks:"), 1, 0)
tracksLayout.addWidget(self.m_videoTracks, 1, 1)
self.m_subtitleTracks = QComboBox(self)
self.m_subtitleTracks.activated.connect(self.selectSubtitleStream)
tracksLayout.addWidget(QLabel("Subtitle Tracks:"), 2, 0)
tracksLayout.addWidget(self.m_subtitleTracks, 2, 1)
layout.addLayout(tracksLayout)
# metadata
metaDataLabel = QLabel("Metadata for file:")
layout.addWidget(metaDataLabel)
metaDataLayout = QGridLayout()
metaDataCount = QMediaMetaData.NumMetaData
self.m_metaDataLabels = [None] * metaDataCount
self.m_metaDataFields = [None] * metaDataCount
key = QMediaMetaData.Key.Title.value
for i in range(0, round((metaDataCount + 2) / 3)):
for j in range(0, 6, 2):
labelText = QMediaMetaData.metaDataKeyToString(QMediaMetaData.Key(key))
self.m_metaDataLabels[key] = QLabel(labelText)
if (key == QMediaMetaData.Key.ThumbnailImage
or key == QMediaMetaData.Key.CoverArtImage):
self.m_metaDataFields[key] = QLabel()
else:
lineEdit = QLineEdit()
lineEdit.setReadOnly(True)
self.m_metaDataFields[key] = lineEdit
self.m_metaDataLabels[key].setDisabled(True)
self.m_metaDataFields[key].setDisabled(True)
metaDataLayout.addWidget(self.m_metaDataLabels[key], i, j)
metaDataLayout.addWidget(self.m_metaDataFields[key], i, j + 1)
key += 1
if key == QMediaMetaData.NumMetaData:
break
layout.addLayout(metaDataLayout)
if not self.isPlayerAvailable():
QMessageBox.warning(self, "Service not available",
"The QMediaPlayer object does not have a valid service.\n"
"Please check the media service plugins are installed.")
controls.setEnabled(False)
openButton.setEnabled(False)
self.m_fullScreenButton.setEnabled(False)
self.metaDataChanged()
def closeEvent(self, event):
self.m_audioLevelMeter.closeRequest()
event.accept()
@Slot()
def _updatePitchCompensation(self):
self.m_pitchCompensationButton.setChecked(self.m_player.pitchCompensation())
def isPlayerAvailable(self):
return self.m_player.isAvailable()
@Slot()
def open(self):
fileDialog = QFileDialog(self)
fileDialog.setAcceptMode(QFileDialog.AcceptMode.AcceptOpen)
fileDialog.setWindowTitle("Open Files")
fileDialog.setMimeTypeFilters(getSupportedMimeTypes())
fileDialog.selectMimeTypeFilter(MP4)
movieDirs = QStandardPaths.standardLocations(QStandardPaths.StandardLocation.MoviesLocation)
fileDialog.setDirectory(movieDirs[0] if movieDirs else QDir.homePath())
if fileDialog.exec() == QDialog.DialogCode.Accepted:
self.openUrl(fileDialog.selectedUrls()[0])
def openUrl(self, url):
self.m_player.setSource(url)
@Slot("qlonglong")
def durationChanged(self, duration):
self.m_duration = duration / 1000
self.m_slider.setMaximum(duration)
@Slot("qlonglong")
def positionChanged(self, progress):
if not self.m_slider.isSliderDown():
self.m_slider.setValue(progress)
self.updateDurationInfo(progress / 1000)
@Slot()
def metaDataChanged(self):
metaData = self.m_player.metaData()
artist = metaData.value(QMediaMetaData.Key.AlbumArtist)
title = metaData.value(QMediaMetaData.Key.Title)
trackInfo = QApplication.applicationName()
if artist and title:
trackInfo = f"{artist} - {title}"
elif artist:
trackInfo = artist
elif title:
trackInfo = title
self.setTrackInfo(trackInfo)
for i in range(0, QMediaMetaData.NumMetaData):
field = self.m_metaDataFields[i]
if isinstance(field, QLineEdit):
field.clear()
elif isinstance(field, QLabel):
field.clear()
self.m_metaDataFields[i].setDisabled(True)
self.m_metaDataLabels[i].setDisabled(True)
for key in metaData.keys():
i = key.value
field = self.m_metaDataFields[i]
if key == QMediaMetaData.Key.CoverArtImage or key == QMediaMetaData.Key.ThumbnailImage:
if isinstance(field, QLabel):
field.setPixmap(QPixmap.fromImage(metaData.value(key)))
elif isinstance(field, QLineEdit):
field.setText(metaData.stringValue(key))
self.m_metaDataFields[i].setDisabled(False)
self.m_metaDataLabels[i].setDisabled(False)
tracks = self.m_player.videoTracks()
currentVideoTrack = self.m_player.activeVideoTrack()
if currentVideoTrack >= 0 and currentVideoTrack < len(tracks):
track = tracks[currentVideoTrack]
trackKeys = track.keys()
for key in trackKeys:
i = key.value
field = self.m_metaDataFields[i]
if isinstance(field, QLineEdit):
stringValue = track.stringValue(key)
field.setText(stringValue)
self.m_metaDataFields[i].setDisabled(True)
self.m_metaDataLabels[i].setDisabled(True)
def trackName(self, metaData, index):
name = ""
title = metaData.stringValue(QMediaMetaData.Key.Title)
lang = metaData.value(QMediaMetaData.Key.Language)
if not title:
if lang == QLocale.Language.AnyLanguage:
name = f"Track {index + 1}"
else:
name = QLocale.languageToString(lang)
else:
if lang == QLocale.Language.AnyLanguage:
name = title
else:
langName = QLocale.languageToString(lang)
name = f"{title} - [{langName}]"
return name
@Slot()
def tracksChanged(self):
self.m_audioTracks.clear()
self.m_videoTracks.clear()
self.m_subtitleTracks.clear()
audioTracks = self.m_player.audioTracks()
self.m_audioTracks.addItem("No audio", -1)
for i in range(0, len(audioTracks)):
self.m_audioTracks.addItem(self.trackName(audioTracks[i], i), i)
self.m_audioTracks.setCurrentIndex(self.m_player.activeAudioTrack() + 1)
videoTracks = self.m_player.videoTracks()
self.m_videoTracks.addItem("No video", -1)
for i in range(0, len(videoTracks)):
self.m_videoTracks.addItem(self.trackName(videoTracks[i], i), i)
self.m_videoTracks.setCurrentIndex(self.m_player.activeVideoTrack() + 1)
self.m_subtitleTracks.addItem("No subtitles", -1)
subtitleTracks = self.m_player.subtitleTracks()
for i in range(0, len(subtitleTracks)):
self.m_subtitleTracks.addItem(self.trackName(subtitleTracks[i], i), i)
self.m_subtitleTracks.setCurrentIndex(self.m_player.activeSubtitleTrack() + 1)
@Slot()
def previousClicked(self):
self.m_player.setPosition(0)
@Slot(int)
def seek(self, mseconds):
self.m_player.setPosition(mseconds)
@Slot(QMediaPlayer.MediaStatus)
def statusChanged(self, status):
self.handleCursor(status)
# handle status message
if (status == QMediaPlayer.MediaStatus.NoMedia
or status == QMediaPlayer.MediaStatus.LoadedMedia):
self.setStatusInfo("")
elif status == QMediaPlayer.MediaStatus.LoadingMedia:
self.setStatusInfo("Loading...")
elif (status == QMediaPlayer.MediaStatus.BufferingMedia
or status == QMediaPlayer.MediaStatus.BufferedMedia):
progress = round(self.m_player.bufferProgress() * 100.0)
self.setStatusInfo(f"Buffering {progress}%")
elif status == QMediaPlayer.MediaStatus.StalledMedia:
progress = round(self.m_player.bufferProgress() * 100.0)
self.setStatusInfo(f"Stalled {progress}%")
elif status == QMediaPlayer.MediaStatus.EndOfMedia:
QApplication.alert(self)
elif status == QMediaPlayer.MediaStatus.InvalidMedia:
self.displayErrorMessage()
def handleCursor(self, status):
if (status == QMediaPlayer.MediaStatus.LoadingMedia
or status == QMediaPlayer.MediaStatus.BufferingMedia
or status == QMediaPlayer.MediaStatus.StalledMedia):
self.setCursor(QCursor(Qt.CursorShape.BusyCursor))
else:
self.unsetCursor()
@Slot("float")
def bufferingProgress(self, progressV):
progress = round(progressV * 100.0)
if self.m_player.mediaStatus() == QMediaPlayer.MediaStatus.StalledMedia:
self.setStatusInfo(f"Stalled {progress}%")
else:
self.setStatusInfo(f"Buffering {progress}%")
@Slot(bool)
def videoAvailableChanged(self, available):
if not available:
self.m_fullScreenButton.clicked.disconnect(self.m_videoWidget.switchToFullScreen)
self.m_videoWidget.fullScreenChanged.disconnect(self.m_fullScreenButton.setChecked)
self.m_videoWidget.setFullScreen(False)
else:
self.m_fullScreenButton.clicked.connect(self.m_videoWidget.switchToFullScreen)
self.m_videoWidget.fullScreenChanged.connect(self.m_fullScreenButton.setChecked)
if self.m_fullScreenButton.isChecked():
self.m_videoWidget.setFullScreen(True)
@Slot()
def selectAudioStream(self):
stream = self.m_audioTracks.currentData()
self.m_player.setActiveAudioTrack(stream)
@Slot()
def selectVideoStream(self):
stream = self.m_videoTracks.currentData()
self.m_player.setActiveVideoTrack(stream)
@Slot()
def selectSubtitleStream(self):
stream = self.m_subtitleTracks.currentData()
self.m_player.setActiveSubtitleTrack(stream)
def setTrackInfo(self, info):
self.m_trackInfo = info
title = self.m_trackInfo
if self.m_statusInfo:
title += f" | {self.m_statusInfo}"
self.setWindowTitle(title)
def setStatusInfo(self, info):
self.m_statusInfo = info
title = self.m_trackInfo
if self.m_statusInfo:
title += f" | {self.m_statusInfo}"
self.setWindowTitle(title)
@Slot()
def displayErrorMessage(self):
if self.m_player.error() != QMediaPlayer.Error.NoError:
self.setStatusInfo(self.m_player.errorString())
def updateDurationInfo(self, currentInfo):
tStr = ""
if currentInfo or self.m_duration:
currentTime = QTime((currentInfo / 3600) % 60, (currentInfo / 60) % 60,
currentInfo % 60, (currentInfo * 1000) % 1000)
totalTime = QTime((self.m_duration / 3600) % 60, (self.m_duration / 60) % 60,
self.m_duration % 60, (self.m_duration * 1000) % 1000)
format = "hh:mm:ss" if self.m_duration > 3600 else "mm:ss"
tStr = currentTime.toString(format) + " / " + totalTime.toString(format)
self.m_labelDuration.setText(tStr)
@Slot()
def updateAudioDevices(self):
self.m_audioOutputCombo.clear()
self.m_audioOutputCombo.addItem("Default", QAudioDevice())
for deviceInfo in QMediaDevices.audioOutputs():
self.m_audioOutputCombo.addItem(deviceInfo.description(), deviceInfo)
@Slot(int)
def audioOutputChanged(self, index):
device = self.m_audioOutputCombo.itemData(index)
self.m_player.audioOutput().setDevice(device)
# Copyright (C) 2025 The Qt Company Ltd.
# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
from PySide6.QtMultimedia import QMediaPlayer, QtAudio
from PySide6.QtWidgets import (QComboBox, QHBoxLayout, QSizePolicy, QSlider, QStyle,
QToolButton, QWidget)
from PySide6.QtGui import QPalette
from PySide6.QtCore import qFuzzyCompare, Qt, Signal, Slot
class PlayerControls(QWidget):
play = Signal()
pause = Signal()
stop = Signal()
previous = Signal()
changeVolume = Signal(float)
changeMuting = Signal(bool)
changeRate = Signal(float)
def __init__(self, parent=None):
super().__init__(parent)
style = self.style()
self.m_playerState = QMediaPlayer.PlaybackState.StoppedState
self.m_playerMuted = False
self.m_playButton = QToolButton(self)
self.m_playButton.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_MediaPlay))
self.m_playButton.setToolTip("Play")
self.m_playButton.clicked.connect(self.playClicked)
self.m_pauseButton = QToolButton(self)
self.m_pauseButton.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_MediaPause))
self.m_pauseButton.setToolTip("Pause")
self.m_pauseButton.clicked.connect(self.pauseClicked)
self.m_stopButton = QToolButton(self)
self.m_stopButton.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_MediaStop))
self.m_stopButton.setToolTip("Stop")
self.m_stopButton.clicked.connect(self.stop)
self.m_previousButton = QToolButton(self)
self.m_previousButton.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_MediaSkipBackward)) # noqa: E501
self.m_previousButton.setToolTip("Rewind")
self.m_previousButton.clicked.connect(self.previous)
self.m_muteButton = QToolButton(self)
self.m_muteButton.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_MediaVolume))
self.m_muteButton.setToolTip("Mute")
self.m_muteButton.clicked.connect(self.muteClicked)
self.m_volumeSlider = QSlider(Qt.Orientation.Horizontal, self)
self.m_volumeSlider.setRange(0, 100)
sp = self.m_volumeSlider.sizePolicy()
sp.setHorizontalPolicy(QSizePolicy.Policy.MinimumExpanding)
self.m_volumeSlider.setSizePolicy(sp)
self.m_volumeSlider.valueChanged.connect(self.onVolumeSliderValueChanged)
self.m_rateBox = QComboBox(self)
self.m_rateBox.setToolTip("Rate")
self.m_rateBox.addItem("0.5x", 0.5)
self.m_rateBox.addItem("1.0x", 1.0)
self.m_rateBox.addItem("2.0x", 2.0)
self.m_rateBox.setCurrentIndex(1)
self.m_rateBox.activated.connect(self.updateRate)
self._doSetState(QMediaPlayer.PlaybackState.StoppedState, True)
layout = QHBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.m_stopButton)
layout.addWidget(self.m_previousButton)
layout.addWidget(self.m_pauseButton)
layout.addWidget(self.m_playButton)
layout.addWidget(self.m_muteButton)
layout.addWidget(self.m_volumeSlider)
layout.addWidget(self.m_rateBox)
def state(self):
return self.m_playerState
@Slot(QMediaPlayer.PlaybackState)
def setState(self, state):
self._doSetState(state, False)
def _doSetState(self, state, force):
if state != self.m_playerState or force:
self.m_playerState = state
baseColor = self.palette().color(QPalette.ColorRole.Base)
inactiveStyleSheet = f"background-color: {baseColor.name()}"
defaultStyleSheet = ""
if state == QMediaPlayer.PlaybackState.StoppedState:
self.m_stopButton.setStyleSheet(inactiveStyleSheet)
self.m_playButton.setStyleSheet(defaultStyleSheet)
self.m_pauseButton.setStyleSheet(defaultStyleSheet)
elif state == QMediaPlayer.PlaybackState.PlayingState:
self.m_stopButton.setStyleSheet(defaultStyleSheet)
self.m_playButton.setStyleSheet(inactiveStyleSheet)
self.m_pauseButton.setStyleSheet(defaultStyleSheet)
elif state == QMediaPlayer.PlaybackState.PausedState:
self.m_stopButton.setStyleSheet(defaultStyleSheet)
self.m_playButton.setStyleSheet(defaultStyleSheet)
self.m_pauseButton.setStyleSheet(inactiveStyleSheet)
def volume(self):
linearVolume = QtAudio.convertVolume(self.m_volumeSlider.value() / 100.0,
QtAudio.VolumeScale.LogarithmicVolumeScale,
QtAudio.VolumeScale.LinearVolumeScale)
return linearVolume
@Slot("float")
def setVolume(self, volume):
logarithmicVolume = QtAudio.convertVolume(volume, QtAudio.VolumeScale.LinearVolumeScale,
QtAudio.VolumeScale.LogarithmicVolumeScale)
self.m_volumeSlider.setValue(round(logarithmicVolume * 100.0))
def isMuted(self):
return self.m_playerMuted
@Slot(bool)
def setMuted(self, muted):
if muted != self.m_playerMuted:
self.m_playerMuted = muted
sp = (QStyle.StandardPixmap.SP_MediaVolumeMuted
if muted else QStyle.StandardPixmap.SP_MediaVolume)
self.m_muteButton.setIcon(self.style().standardIcon(sp))
@Slot()
def playClicked(self):
self.play.emit()
@Slot()
def pauseClicked(self):
self.pause.emit()
@Slot()
def muteClicked(self):
self.changeMuting.emit(not self.m_playerMuted)
def playbackRate(self):
return self.m_rateBox.itemData(self.m_rateBox.currentIndex())
def setPlaybackRate(self, rate):
for i in range(0, self.m_rateBox.count()):
if qFuzzyCompare(rate, self.m_rateBox.itemData(i)):
self.m_rateBox.setCurrentIndex(i)
return
self.m_rateBox.addItem(f"{rate}x", rate)
self.m_rateBox.setCurrentIndex(self.m_rateBox.count() - 1)
@Slot()
def updateRate(self):
self.changeRate.emit(self.playbackRate())
@Slot()
def onVolumeSliderValueChanged(self):
self.changeVolume.emit(self.volume())
# Copyright (C) 2025 The Qt Company Ltd.
# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
from PySide6.QtMultimediaWidgets import QVideoWidget
from PySide6.QtWidgets import QSizePolicy
from PySide6.QtGui import QPalette
from PySide6.QtCore import Qt, QOperatingSystemVersion, Slot
class VideoWidget(QVideoWidget):
def __init__(self, parent=None):
super().__init__(parent)
self.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Ignored)
p = self.palette()
p.setColor(QPalette.ColorRole.Window, Qt.GlobalColor.black)
self.setPalette(p)
if QOperatingSystemVersion.currentType() != QOperatingSystemVersion.OSType.Android:
self.setAttribute(Qt.WidgetAttribute.WA_OpaquePaintEvent)
def keyPressEvent(self, event):
key = event.key()
if (key == Qt.Key.Key_Escape or key == Qt.Key.Key_Back) and self.isFullScreen():
self.setFullScreen(False)
event.accept()
elif key == Qt.Key.Key_Enter and event.modifiers() & Qt.Key.Key_Alt:
self.setFullScreen(not self.isFullScreen())
event.accept()
else:
super().keyPressEvent(event)
@Slot()
def switchToFullScreen(self):
self.setFullScreen(True)
def mouseDoubleClickEvent(self, event):
self.setFullScreen(not self.isFullScreen())
event.accept()
def mousePressEvent(self, event):
super().mousePressEvent(event)