mte90 PyQt/PySide Multimedia
Audio and video playback, camera capture, and media processing in PyQt/PySide.
Overview
Qt Multimedia provides classes for audio, video, and camera functionality:
- QMediaPlayer - Audio/video playback
- QVideoWidget - Video display
- QAudioOutput - Audio output management
- QCamera - Camera capture
- QMediaRecorder - Audio/video recording
Audio Playback
Basic Audio Player
from PyQt6.QtMultimedia import QMediaPlayer, QAudioOutput
from PyQt6.QtWidgets import QApplication, QPushButton, QVBoxLayout, QWidget, QSlider, QLabel
from PyQt6.QtCore import Qt, QUrl
import sys
class AudioPlayer(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("Audio Player")
self.player = QMediaPlayer()
self.audio_output = QAudioOutput()
self.player.setAudioOutput(self.audio_output)
# UI
self.play_btn = QPushButton("Play")
self.pause_btn = QPushButton("Pause")
self.stop_btn = QPushButton("Stop")
self.label = QLabel("No file loaded")
self.volume_slider = QSlider(Qt.Orientation.Horizontal)
self.volume_slider.setRange(0, 100)
self.volume_slider.setValue(50)
layout = QVBoxLayout()
layout.addWidget(self.label)
layout.addWidget(self.play_btn)
layout.addWidget(self.pause_btn)
layout.addWidget(self.stop_btn)
layout.addWidget(self.volume_slider)
self.setLayout(layout)
# Connections
self.play_btn.clicked.connect(self.player.play)
self.pause_btn.clicked.connect(self.player.pause)
self.stop_btn.clicked.connect(self.player.stop)
self.volume_slider.valueChanged.connect(
lambda v: self.audio_output.setVolume(v / 100)
)
self.player.positionChanged.connect(self.update_position)
def load_file(self, filepath):
self.player.setSource(QUrl.fromLocalFile(filepath))
self.label.setText(filepath.split('/')[-1])
def update_position(self, position):
# position in milliseconds
seconds = position // 1000
minutes = seconds // 60
seconds = seconds % 60
print(f"{minutes:02d}:{seconds:02d}")
if __name__ == "__main__":
app = QApplication(sys.argv)
window = AudioPlayer()
window.show()
sys.exit(app.exec())
Audio Playlist
from PyQt6.QtMultimedia import QMediaPlayer, QAudioOutput
from PyQt6.QtCore import QUrl, QModelIndex
from PyQt6.QtWidgets import QListView
class PlaylistPlayer:
def __init__(self, playlist_view: QListView):
self.player = QMediaPlayer()
self.audio_output = QAudioOutput()
self.player.setAudioOutput(self.audio_output)
self.playlist = [] # List of file paths
self.current_index = -1
def add_to_playlist(self, filepath):
self.playlist.append(filepath)
def play_index(self, index: int):
if 0 <= index < len(self.playlist):
self.current_index = index
self.player.setSource(QUrl.fromLocalFile(self.playlist[index]))
self.player.play()
def next(self):
if self.playlist:
self.current_index = (self.current_index + 1) % len(self.playlist)
self.play_index(self.current_index)
def previous(self):
if self.playlist:
self.current_index = (self.current_index - 1) % len(self.playlist)
self.play_index(self.current_index)
Video Playback
Video Player with Controls
from PyQt6.QtMultimedia import QMediaPlayer, QAudioOutput
from PyQt6.QtMultimediaWidgets import QVideoWidget
from PyQt6.QtWidgets import (
QApplication, QWidget, QVBoxLayout, QHBoxLayout,
QPushButton, QSlider, QLabel
)
from PyQt6.QtCore import Qt, QUrl, QTimer
from PyQt6.QtGui import QAction
import sys
class VideoPlayer(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("Video Player")
self.resize(800, 600)
# Media player
self.player = QMediaPlayer()
self.audio_output = QAudioOutput()
self.player.setAudioOutput(self.audio_output)
# Video widget
self.video_widget = QVideoWidget()
# Controls
self.play_btn = QPushButton("Play")
self.pause_btn = QPushButton("Pause")
self.stop_btn = QPushButton("Stop")
self.position_slider = QSlider(Qt.Orientation.Horizontal)
self.position_slider.setRange(0, 0)
self.time_label = QLabel("00:00 / 00:00")
self.volume_slider = QSlider(Qt.Orientation.Horizontal)
self.volume_slider.setRange(0, 100)
self.volume_slider.setValue(50)
# Layout
control_layout = QHBoxLayout()
control_layout.addWidget(self.play_btn)
control_layout.addWidget(self.pause_btn)
control_layout.addWidget(self.stop_btn)
control_layout.addWidget(self.position_slider)
control_layout.addWidget(self.time_label)
control_layout.addWidget(self.volume_slider)
main_layout = QVBoxLayout()
main_layout.addWidget(self.video_widget)
main_layout.addLayout(control_layout)
self.setLayout(main_layout)
# Connect
self.player.setVideoOutput(self.video_widget)
self.play_btn.clicked.connect(self.player.play)
self.pause_btn.clicked.connect(self.player.pause)
self.stop_btn.clicked.connect(self.stop)
self.player.positionChanged.connect(self.position_changed)
self.player.durationChanged.connect(self.duration_changed)
self.volume_slider.valueChanged.connect(
lambda v: self.audio_output.setVolume(v / 100)
)
def load_video(self, filepath):
self.player.setSource(QUrl.fromLocalFile(filepath))
def stop(self):
self.player.stop()
self.position_slider.setValue(0)
def position_changed(self, position):
self.position_slider.setValue(position)
self.update_time_label()
def duration_changed(self, duration):
self.position_slider.setRange(0, duration)
self.update_time_label()
def update_time_label(self):
pos = self.player.position() // 1000
dur = self.player.duration() // 1000
pos_m, pos_s = divmod(pos, 60)
dur_m, dur_s = divmod(dur, 60)
self.time_label.setText(
f"{pos_m:02d}:{pos_s:02d} / {dur_m:02d}:{dur_s:02d}"
)
def keyPressEvent(self, event):
if event.key() == Qt.Key.Key_Space:
if self.player.playbackState() == QMediaPlayer.PlaybackState.PlayingState:
self.player.pause()
else:
self.player.play()
elif event.key() == Qt.Key.Key_Left:
self.player.setPosition(max(0, self.player.position() - 5000))
elif event.key() == Qt.Key.Key_Right:
self.player.setPosition(
min(self.player.duration(), self.player.position() + 5000)
)
Fullscreen Video
class FullscreenVideoPlayer(VideoPlayer):
def __init__(self):
super().__init__()
self.is_fullscreen = False
self.video_widget.doubleClicked.connect(self.toggle_fullscreen)
def toggle_fullscreen(self):
if self.is_fullscreen:
self.showNormal()
else:
self.showFullScreen()
self.is_fullscreen = not self.is_fullscreen
Camera Capture
Display Camera Feed
from PyQt6.QtMultimedia import QCamera, QMediaDevices
from PyQt6.QtMultimediaWidgets import QVideoWidget
from PyQt6.QtWidgets import QApplication, QWidget, QVBoxLayout, QPushButton
from PyQt6.QtCore import Qt
import sys
class CameraViewer(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("Camera Viewer")
# Get available cameras
self.cameras = QMediaDevices.videoInputs()
if not self.cameras:
print("No cameras available")
return
# Create camera
self.camera = QCamera(self.cameras[0])
# Video widget
self.video_widget = QVideoWidget()
# Buttons
self.start_btn = QPushButton("Start")
self.stop_btn = QPushButton("Stop")
layout = QVBoxLayout()
layout.addWidget(self.video_widget)
layout.addWidget(self.start_btn)
layout.addWidget(self.stop_btn)
self.setLayout(layout)
# Connect camera to widget
self.camera.setVideoOutput(self.video_widget)
self.start_btn.clicked.connect(self.camera.start)
self.stop_btn.clicked.connect(self.camera.stop)
def closeEvent(self, event):
self.camera.stop()
super().closeEvent(event)
Capture Photo
from PyQt6.QtMultimedia import QCamera, QMediaCaptureSession, QImageCapture
from PyQt6.QtMultimediaWidgets import QVideoWidget
from PyQt6.QtWidgets import QWidget, QVBoxLayout, QPushButton, QLabel
from PyQt6.QtCore import QUrl
class CameraCapture(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("Camera Capture")
self.camera = QCamera()
self.capture_session = QMediaCaptureSession()
self.capture_session.setCamera(self.camera)
self.video_widget = QVideoWidget()
self.capture_session.setVideoOutput(self.video_widget)
# Image capture
self.image_capture = QImageCapture()
self.capture_session.setImageCapture(self.image_capture)
self.capture_btn = QPushButton("Capture Photo")
self.preview_label = QLabel()
layout = QVBoxLayout()
layout.addWidget(self.video_widget)
layout.addWidget(self.capture_btn)
layout.addWidget(self.preview_label)
self.setLayout(layout)
self.capture_btn.clicked.connect(self.capture_photo)
self.camera.start()
def capture_photo(self):
self.image_capture.captureToFile()
def handle_captured(self, id, filePath):
print(f"Photo saved to: {filePath}")
Record Video
from PyQt6.QtMultimedia import QCamera, QMediaCaptureSession, QMediaRecorder
from PyQt6.QtMultimediaWidgets import QVideoWidget
from PyQt6.QtWidgets import QWidget, QVBoxLayout, QPushButton, QLabel
class VideoRecorder(QWidget):
def __init__(self):
super().__init__()
self.camera = QCamera()
self.capture_session = QMediaCaptureSession()
self.capture_session.setCamera(self.camera)
self.video_widget = QVideoWidget()
self.capture_session.setVideoOutput(self.video_widget)
# Recorder
self.recorder = QMediaRecorder()
self.capture_session.setRecorder(self.recorder)
self.record_btn = QPushButton("Start Recording")
self.status_label = QLabel("Ready")
layout = QVBoxLayout()
layout.addWidget(self.video_widget)
layout.addWidget(self.record_btn)
layout.addWidget(self.status_label)
self.setLayout(layout)
self.record_btn.clicked.connect(self.toggle_recording)
self.recorder.recorderStateChanged.connect(self.update_status)
def toggle_recording(self):
if self.recorder.recorderState() == QMediaRecorder.RecorderState.RecordingState:
self.recorder.stop()
else:
self.recorder.setOutputLocation(QUrl.fromLocalFile("output.mp4"))
self.recorder.record()
def update_status(self, state):
states = {
QMediaRecorder.RecorderState.StoppedState: "Stopped",
QMediaRecorder.RecorderState.RecordingState: "Recording",
QMediaRecorder.RecorderState.PausedState: "Paused"
}
self.status_label.setText(states.get(state, "Unknown"))
Audio Recording
Microphone Input
from PyQt6.QtMultimedia import QMediaRecorder, QMediaCaptureSession, QAudioInput
from PyQt6.QtCore import QUrl, QStandardPaths
from PyQt6.QtWidgets import QWidget, QVBoxLayout, QPushButton, QLabel
import os
class AudioRecorder(QWidget):
def __init__(self):
super().__init__()
self.recorder = QMediaRecorder()
self.capture_session = QMediaCaptureSession()
self.audio_input = QAudioInput()
self.capture_session.setAudioInput(self.audio_input)
self.capture_session.setRecorder(self.recorder)
self.record_btn = QPushButton("Start Recording")
self.status_label = QLabel("Ready")
layout = QVBoxLayout()
layout.addWidget(self.record_btn)
layout.addWidget(self.status_label)
self.setLayout(layout)
self.record_btn.clicked.connect(self.toggle_recording)
self.recorder.recorderStateChanged.connect(self.update_status)
# Default output location
documents = QStandardPaths.writableLocation(
QStandardPaths.StandardLocation.MoviesLocation
)
self.output_path = os.path.join(documents, "recording.mp3")
def toggle_recording(self):
if self.recorder.recorderState() == QMediaRecorder.RecorderState.RecordingState:
self.recorder.stop()
else:
self.recorder.setOutputLocation(QUrl.fromLocalFile(self.output_path))
self.recorder.record()
def update_status(self, state):
if state == QMediaRecorder.RecorderState.RecordingState:
self.record_btn.setText("Stop Recording")
self.status_label.setText("Recording...")
else:
self.record_btn.setText("Start Recording")
self.status_label.setText("Ready")
GStreamer Backend
Install GStreamer (Linux)
# Ubuntu/Debian
sudo apt-get install libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev \
gstreamer1.0-plugins-good gstreamer1.0-plugins-bad gstreamer1.0-plugins-ugly
# For audio/video codecs
sudo apt-get install gstreamer1.0-libav
Install on Windows
PySide6 on Windows typically uses DirectShow or WMF backends. Install K-Lite Codec Pack for additional codec support.
Common Issues
No Audio/Video Output
# Check available codecs
from PyQt6.QtMultimedia import QMediaDevices
print("Audio outputs:", QMediaDevices.audioOutputs())
print("Video outputs:", QMediaDevices.videoOutputs())
# Check camera
print("Cameras:", QMediaDevices.videoInputs())
Format Not Supported
# Convert using QMediaEncoder with specific codec
from PyQt6.QtMultimedia import QMediaRecorder, QMediaFormat
recorder = QMediaRecorder()
recorder.setMediaFormat(QMediaFormat.MediaFormat.MPEG4)
recorder.setAudioCodec(QMediaFormat.AudioCodec.AAC)
recorder.setVideoCodec(QMediaFormat.VideoCodec.H264)
Best Practices
Audio/Video Capture
# ✅ GOOD: Check availability first
from PyQt6.QtMultimedia import QMediaDevices
if not QMediaDevices.audioInputs():
print("No microphone available")
return
# ✅ GOOD: Set output location before recording
recorder.setOutputLocation(QUrl.fromLocalFile(path))
recorder.record() # Start after setting location
Playback
# ✅ GOOD: Check player state
player.play()
# Wait for state change signal, don't assume immediate playback
# ✅ GOOD: Handle missing codecs
# Install K-Lite on Windows, gstreamer on Linux
Resource Management
# ✅ GOOD: Clean up resources
def closeEvent(self, event):
self.player.stop()
self.recorder.stop()
self.camera.stop()
super().closeEvent(event)
Do:
- Check device availability before use
- Set output location before recording
- Clean up on close
Don't:
- Record without checking available disk space
- Use unsupported formats
- Forget to stop capture sessions
References
- Qt Multimedia: https://doc.qt.io/qt-6/qtmultimedia-index.html
- PySide6 Multimedia: https://doc.qt.io/qt-6/multimedia.html
- GStreamer: https://gstreamer.freedesktop.org/
Video Playback (PySide6)
QMediaPlayer + QVideoWidget
from PySide6.QtMultimedia import QMediaPlayer
from PySide6.QtMultimediaWidgets import QVideoWidget
from PySide6.QtWidgets import (
QApplication, QWidget, QVBoxLayout, QHBoxLayout,
QPushButton, QSlider, QLabel, QMainWindow
)
from PySide6.QtCore import Qt, QUrl, QTimer
from PySide6.QtGui import QAction
import sys
class VideoPlayer(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("Video Player")
self.resize(800, 600)
# Media player
self.player = QMediaPlayer()
self.audio_output = QAudioOutput()
self.player.setAudioOutput(self.audio_output)
# Video widget
self.video_widget = QVideoWidget()
# Controls
self.play_btn = QPushButton("▶ Play")
self.pause_btn = QPushButton("❚❚ Pause")
self.stop_btn = QPushButton("■ Stop")
self.position_slider = QSlider(Qt.Orientation.Horizontal)
self.position_slider.setRange(0, 0)
self.time_label = QLabel("00:00 / 00:00")
self.volume_slider = QSlider(Qt.Orientation.Horizontal)
self.volume_slider.setRange(0, 100)
self.volume_slider.setValue(50)
# Toolbar layout
toolbar = QHBoxLayout()
toolbar.addWidget(self.play_btn)
toolbar.addWidget(self.pause_btn)
toolbar.addWidget(self.stop_btn)
toolbar.addWidget(self.position_slider)
toolbar.addWidget(self.time_label)
toolbar.addWidget(self.volume_slider)
toolbar.addStretch()
# Main layout
main_layout = QVBoxLayout()
main_layout.addWidget(self.video_widget)
main_layout.addLayout(toolbar)
self.setCentralWidget(QWidget())
self.centralLayout = self.centralWidget().layout()
self.centralLayout.addLayout(toolbar)
# Signal connections
self.player.setVideoOutput(self.video_widget)
self.play_btn.clicked.connect(self.player.play)
self.pause_btn.clicked.connect(self.player.pause)
self.stop_btn.clicked.connect(self.player.stop)
self.player.positionChanged.connect(self.position_changed)
self.player.durationChanged.connect(self.duration_changed)
self.volume_slider.valueChanged.connect(
lambda v: self.audio_output.setVolume(v / 100)
)
# Keyboard shortcuts
self.installEventFilter(self)
def load_video(self, filepath):
"""Load a video file."""
self.player.setSource(QUrl.fromLocalFile(filepath))
def position_changed(self, position):
"""Update position slider and time display."""
self.position_slider.setValue(position)
self.update_time_label()
def duration_changed(self, duration):
"""Update slider range and initial time display."""
self.position_slider.setRange(0, duration)
self.update_time_label()
def update_time_label(self):
"""Convert position/duration to MM:SS format."""
pos = self.player.position() // 1000
dur = self.player.duration() // 1000 if self.player.duration() > 0 else 0
pos_m, pos_s = divmod(pos, 60)
dur_m, dur_s = divmod(dur, 60)
self.time_label.setText(
f"{pos_m:02d}:{pos_s:02d} / {dur_m:02d}:{dur_s:02d}"
)
def keyPressEvent(self, event):
"""Handle keyboard shortcuts."""
if event.key() == Qt.Key.Key_Space:
if self.player.playbackState() == QMediaPlayer.PlaybackState.PlayingState:
self.player.pause()
else:
self.player.play()
elif event.key() == Qt.Key.Key_Left:
self.player.setPosition(max(0, self.player.position() - 5000))
elif event.key() == Qt.Key.Key_Right:
self.player.setPosition(
min(self.player.duration(), self.player.position() + 5000)
)
elif event.key() == Qt.Key.Key_k:
self.player.seek(5)
elif event.key() == Qt.Key.Key_j:
self.player.seek(-5)
if __name__ == "__main__":
app = QApplication(sys.argv)
# Set application properties
app.setApplicationName("Video Player")
app.setOrganizationName("MyOrg")
window = VideoPlayer()
window.show()
sys.exit(app.exec())
Controls Reference:
| Method | Description |
|---|---|
play() |
Start playback |
pause() |
Pause playback |
stop() |
Stop playback and reset position |
setPosition(pos) |
Set playback position (milliseconds) |
seek(seconds) |
Seek relative to current position |
playbackState() |
Returns current state (PlayingState, PausedState, StoppedState) |
position() |
Current playback position in milliseconds |
duration() |
Total duration in milliseconds |
Supported Formats:
- Audio/Video files:
.mp4,.avi,.mkv,.mov,.flv,.webm,.wmv - Audio files:
.mp3,.wav,.ogg,.flac,.aac - Real-time: Camera feed, network streams (RTSP, HTTP)
Note: Codec support varies by platform. On Linux, ensure GStreamer backends are installed.
Camera Access (PySide6)
QCamera + QMediaCaptureSession
from PySide6.QtMultimedia import QCamera, QMediaDevices, QMediaCaptureSession
from PySide6.QtMultimediaWidgets import QVideoWidget
from PySide6.QtWidgets import (
QApplication, QWidget, QVBoxLayout, QHBoxLayout,
QPushButton, QLabel, QComboBox, QDialogButtonBox
)
from PySide6.QtCore import Qt, QUrl
import sys
from typing import Optional
class CameraViewer(QWidget):
"""Camera viewer with live preview."""
def __init__(self):
super().__init__()
self.setWindowTitle("Camera Viewer")
self.setMinimumSize(640, 480)
# Available cameras
self.cameras = QMediaDevices.videoInputs()
if not self.cameras:
self.init_no_camera()
return
# Selected camera
self.camera = QCamera(self.cameras[0])
# Video widget for preview
self.video_widget = QVideoWidget()
# UI components
self.camera_label = QLabel("No cameras found")
self.camera_combo = QComboBox()
self.camera_combo.addItems([f"Camera {i}" for i in range(len(self.cameras))])
self.start_btn = QPushButton("Start")
self.stop_btn = QPushButton("Stop")
self.preview_label = QLabel("Ready")
# Layout
layout = QVBoxLayout()
# Camera selection
select_layout = QHBoxLayout()
select_layout.addWidget(QLabel("Camera:"))
select_layout.addWidget(self.camera_combo)
layout.addLayout(select_layout)
# Video preview
layout.addWidget(self.camera_label)
layout.addWidget(self.video_widget)
# Controls
control_layout = QHBoxLayout()
control_layout.addWidget(self.start_btn)
control_layout.addWidget(self.stop_btn)
layout.addLayout(control_layout)
# Status
layout.addWidget(self.preview_label)
layout.addStretch()
self.setLayout(layout)
# Setup camera
self.setup_camera()
# Connect signals
self.start_btn.clicked.connect(self.start_camera)
self.stop_btn.clicked.connect(self.stop_camera)
def init_no_camera(self):
"""Initialize UI when no camera is available."""
self.camera_label.setText("No camera detected")
self.preview_label.setText("No camera found")
self.camera_combo.hide()
def setup_camera(self):
"""Configure camera and connect to video output."""
camera_index = self.camera_combo.currentIndex()
camera = self.cameras[camera_index]
self.camera = QCamera(camera)
self.camera.setVideoOutput(self.video_widget)
def start_camera(self):
"""Start camera and enable preview."""
camera_index = self.camera_combo.currentIndex()
camera = self.cameras[camera_index]
self.camera = QCamera(camera)
self.camera.setVideoOutput(self.video_widget)
self.camera.start()
self.preview_label.setText("Camera active")
self.start_btn.setText("Restart")
self.stop_btn.setEnabled(True)
def stop_camera(self):
"""Stop camera and disable preview."""
self.camera.stop()
self.preview_label.setText("Camera stopped")
self.start_btn.setText("Start")
self.start_btn.setEnabled(False)
self.stop_btn.setEnabled(False)
def closeEvent(self, event):
"""Clean up camera resources."""
self.camera.stop()
super().closeEvent(event)
class CameraCapture(QWidget):
"""Camera with photo capture functionality."""
def __init__(self):
super().__init__()
self.setWindowTitle("Camera Capture")
self.setMinimumSize(640, 480)
self.camera = QCamera()
self.capture_session = QMediaCaptureSession()
self.image_capture = QImageCapture()
self.video_widget = QVideoWidget()
self.capture_session.setVideoOutput(self.video_widget)
self.capture_session.setCamera(self.camera)
self.capture_session.setImageCapture(self.image_capture)
# Image capture settings
self.image_capture.setCaptureMode(
QImageCapture.CaptureMode.Photo
)
self.image_capture.setResolution(
self.image_capture.resolutionHighest()
)
self.image_capture.setCompressionType(
QImageCapture.CompressionType.Jpeg
)
self.image_capture.setJpegQuality(85)
self.capture_btn = QPushButton("Capture Photo")
self.capture_btn.setEnabled(False)
self.status_label = QLabel("Ready")
# Layout
layout = QVBoxLayout()
layout.addWidget(self.video_widget)
layout.addWidget(self.capture_btn)
layout.addWidget(self.status_label)
self.setLayout(layout)
# Connect signals
self.capture_btn.clicked.connect(self.capture_photo)
self.camera.start()
def capture_photo(self):
"""Capture photo from camera."""
if self.camera.isRunning():
self.capture_session.setImageCapture(self.image_capture)
self.image_capture.triggerCapture(
self.image_capture.imageSize()
)
self.status_label.setText("Capturing...")
# Handle captured image
self.image_capture.imageReady.connect(self.on_image_ready)
else:
self.status_label.setText("Camera not running")
def on_image_ready(self, id: int, filePath: str):
"""Callback when image is captured."""
self.status_label.setText(f"Photo saved: {filePath}")
self.capture_btn.setEnabled(True)
# Display captured image
from PySide6.QtGui import QPixmap, QImage
pixmap = QPixmap(filePath)
self.video_widget.setPixmap(pixmap.scaled(
self.video_widget.size(),
Qt.AspectRatioMode.KeepAspectRatio,
Qt.TransformationMode.SmoothTransformation
))
if __name__ == "__main__":
app = QApplication(sys.argv)
window = CameraViewer()
window.show()
sys.exit(app.exec())
Camera Device Enumeration:
from PySide6.QtMultimedia import QMediaDevices
# Get all video input devices (cameras)
cameras = QMediaDevices.videoInputs()
print(f"Available cameras: {len(cameras)}")
for i, camera in enumerate(cameras):
print(f" Camera {i}: {camera}")
# Get all video output devices (displays)
video_outputs = QMediaDevices.videoOutputs()
# Get audio input devices (microphones)
audio_inputs = QMediaDevices.audioInputs()
# Get audio output devices (speakers)
audio_outputs = QMediaDevices.audioOutputs()
Photo Capture Options:
# Set capture mode
self.image_capture.setCaptureMode(
QImageCapture.CaptureMode.Photo
)
# Set resolution
self.image_capture.setResolution(
QImageCapture.Resolution.QVGA # or QualityBestResolution
)
# Set compression
self.image_capture.setCompressionType(
QImageCapture.CompressionType.Jpeg
)
self.image_capture.setJpegQuality(85)
# Set custom capture dimensions
self.image_capture.setCaptureSize(640, 480)
# Manual capture trigger
self.image_capture.triggerCapture(QSize(640, 480))
Media Recording
QMediaRecorder Setup
from PySide6.QtMultimedia import (
QMediaRecorder, QMediaCaptureSession, QCamera, QMediaDevices
)
from PySide6.QtMultimediaWidgets import QVideoWidget
from PySide6.QtWidgets import (
QApplication, QWidget, QVBoxLayout, QHBoxLayout,
QPushButton, QLabel, QFileDialog
)
from PySide6.QtCore import QUrl, QStandardPaths
from PySide6.QtGui import QDesktopServices
import os
import sys
class MediaRecorder(QWidget):
"""Complete media recording with audio/video support."""
def __init__(self):
super().__init__()
self.setWindowTitle("Media Recorder")
self.setMinimumSize(800, 600)
# Camera setup
self.camera = QCamera(QMediaDevices.videoInputs()[0])
self.capture_session = QMediaCaptureSession()
self.capture_session.setCamera(self.camera)
self.capture_session.setVideoOutput(self.video_widget)
# Video widget
self.video_widget = QVideoWidget()
# Recorder
self.recorder = QMediaRecorder()
self.capture_session.setRecorder(self.recorder)
# UI components
self.record_btn = QPushButton("Start Recording")
self.record_btn.setEnabled(False)
self.stop_btn = QPushButton("Stop Recording")
self.stop_btn.setEnabled(False)
self.status_label = QLabel("Ready")
self.progress_label = QLabel("")
self.recorder.recorderStateChanged.connect(self.update_status)
self.recorder.durationChanged.connect(self.duration_changed)
# Layout
layout = QVBoxLayout()
layout.addWidget(self.video_widget)
control_layout = QHBoxLayout()
control_layout.addWidget(self.record_btn)
control_layout.addWidget(self.stop_btn)
control_layout.addWidget(self.progress_label)
layout.addLayout(control_layout)
layout.addWidget(self.status_label)
layout.addStretch()
self.setLayout(layout)
# Setup recorder defaults
self.setup_recorder_defaults()
# Connect signals
self.record_btn.clicked.connect(self.toggle_recording)
self.stop_btn.clicked.connect(self.stop_recording)
def setup_recorder_defaults(self):
"""Configure default recording settings."""
# Default output location in Videos folder
documents = QStandardPaths.writableLocation(
QStandardPaths.StandardLocation.MoviesLocation
)
# Get video extension based on codec
self.output_format = "mp4"
self.output_path = os.path.join(documents, f"recording_{self._get_timestamp()}.{self.output_format}")
def _get_timestamp(self):
"""Generate timestamp string."""
from datetime import datetime
return datetime.now().strftime("%Y%m%d_%H%M%S")
def toggle_recording(self):
"""Toggle recording on/off."""
state = self.recorder.recorderState()
if state == QMediaRecorder.RecorderState.RecordingState:
self.recorder.stop()
else:
self.recorder.setOutputLocation(QUrl.fromLocalFile(self.output_path))
self.recorder.record()
def stop_recording(self):
"""Stop current recording."""
self.recorder.stop()
self.status_label.setText("Recording stopped")
self.record_btn.setEnabled(True)
self.record_btn.setText("Record Again")
self.stop_btn.setEnabled(False)
def update_status(self, state):
"""Update status based on recorder state."""
states = {
QMediaRecorder.RecorderState.StoppedState: "Ready to record",
QMediaRecorder.RecorderState.RecordingState: "Recording...",
QMediaRecorder.RecorderState.PausedState: "Paused",
QMediaRecorder.RecorderState.ErrorState: "Error occurred"
}
self.status_label.setText(states.get(state, "Unknown"))
def duration_changed(self, duration):
"""Update progress based on recording duration."""
if duration > 0:
seconds = duration // 1000
self.progress_label.setText(f"Recording: {seconds} seconds")
def closeEvent(self, event):
"""Clean up resources."""
self.recorder.stop()
self.camera.stop()
super().closeEvent(event)
if __name__ == "__main__":
app = QApplication(sys.argv)
window = MediaRecorder()
window.show()
sys.exit(app.exec())
Audio Recording Example
from PySide6.QtMultimedia import QMediaRecorder, QMediaCaptureSession
from PySide6.QtCore import QUrl, QStandardPaths, QMimeType
import os
import sys
from PySide6.QtWidgets import (
QApplication, QWidget, QVBoxLayout, QPushButton, QLabel, QFileDialog
)
class AudioRecorder(QWidget):
"""Audio recording from microphone."""
def __init__(self):
super().__init__()
self.setWindowTitle("Audio Recorder")
self.recorder = QMediaRecorder()
self.capture_session = QMediaCaptureSession()
# Audio input setup
audio_inputs = QStandardPaths.writableLocation(
QStandardPaths.StandardLocation.MoviesLocation
)
self.status_label = QLabel("Ready")
self.record_btn = QPushButton("Start Recording")
layout = QVBoxLayout()
layout.addWidget(self.record_btn)
layout.addWidget(self.status_label)
self.setLayout(layout)
self.record_btn.clicked.connect(self.toggle_recording)
self.recorder.recorderStateChanged.connect(self.update_status)
# Default output
self.output_path = os.path.join(
audio_inputs, "recording.wav"
)
def toggle_recording(self):
"""Toggle recording state."""
state = self.recorder.recorderState()
if state == QMediaRecorder.RecorderState.RecordingState:
self.recorder.stop()
self.status_label.setText("Recording stopped")
else:
self.recorder.setOutputLocation(QUrl.fromLocalFile(self.output_path))
self.recorder.setAudioFormat(
QMediaRecorder.AudioFormat.WAV,
44100,
2,
2,
-16,
-1
)
self.recorder.record()
self.status_label.setText("Recording...")
def update_status(self, state):
"""Update status label."""
if state == QMediaRecorder.RecorderState.RecordingState:
self.status_label.setText("Recording...")
self.record_btn.setText("Stop")
else:
self.status_label.setText("Recording saved")
self.record_btn.setText("Start Recording")
def save_recording(self):
"""Save recording to file dialog."""
file_path, _ = QFileDialog.getSaveFileName(
self, "Save Recording", self.output_path,
"Audio Files (*.wav *.mp3 *.ogg *.flac);;All Files (*)"
)
if file_path:
self.recorder.setOutputLocation(QUrl.fromLocalFile(file_path))
self.output_path = file_path
if __name__ == "__main__":
app = QApplication(sys.argv)
window = AudioRecorder()
window.show()
sys.exit(app.exec())
Video Recording Example
from PySide6.QtMultimedia import QMediaRecorder, QMediaCaptureSession
from PySide6.QtCore import QUrl, QStandardPaths
import os
import sys
from PySide6.QtWidgets import (
QApplication, QWidget, QVBoxLayout, QPushButton, QLabel
)
class VideoRecorder(QWidget):
"""Video recording with encoding options."""
def __init__(self):
super().__init__()
self.setWindowTitle("Video Recorder")
self.camera = QCamera(QStandardPaths.writableLocation(
QStandardPaths.StandardLocation.VideosLocation
) + "camera.mp4")
self.capture_session = QMediaCaptureSession()
self.capture_session.setCamera(self.camera)
self.recorder = QMediaRecorder()
self.capture_session.setRecorder(self.recorder)
self.status_label = QLabel("Ready")
self.record_btn = QPushButton("Start Recording")
layout = QVBoxLayout()
layout.addWidget(self.record_btn)
layout.addWidget(self.status_label)
self.setLayout(layout)
self.record_btn.clicked.connect(self.toggle_recording)
self.recorder.recorderStateChanged.connect(self.update_status)
def toggle_recording(self):
"""Start/stop video recording."""
state = self.recorder.recorderState()
if state == QMediaRecorder.RecorderState.RecordingState:
self.recorder.stop()
else:
self.recorder.setMediaFormat(self._get_video_format())
self.recorder.setVideoCodec(self.recorder.videoFormat().videoCodec())
self.recorder.setAudioCodec(self.recorder.audioFormat().audioCodec())
self.recorder.setOutputLocation(QUrl.fromLocalFile("video.mp4"))
self.recorder.record()
def _get_video_format(self):
"""Get H.264 video format."""
return QMediaFormat(
QMediaFormat.MediaFormat.MPEG4,
self.camera.videoResolution(),
QMediaFormat.VelocityLevel.Normal,
2000000, # 2 Mbps bitrate
QMediaFormat.ResolutionSelector.Variable
)
def update_status(self, state):
"""Update status."""
if state == QMediaRecorder.RecorderState.RecordingState:
self.status_label.setText("Recording video...")
else:
self.status_label.setText("Recording complete")
def save_recording(self):
"""Open save dialog."""
file_path, _ = QFileDialog.getSaveFileName(
self, "Save Video", "recording.mp4",
"Video Files (*.mp4 *.avi *.mkv);;All Files (*)"
)
if file_path:
self.recorder.setOutputLocation(QUrl.fromLocalFile(file_path))
if __name__ == "__main__":
app = QApplication(sys.argv)
window = VideoRecorder()
window.show()
sys.exit(app.exec())
Encoding Settings
from PySide6.QtMultimedia import QMediaFormat, QMediaRecorder
# Configure video format
video_format = QMediaFormat()
video_format.
…(truncated)