ffpyplayer+Qt，制作一个视频播放器
项目地址
FFmpegMediaPlayer
按照
QMediaPlayer的方法重写一个ffpyplayer
python
# coding:utf-8
import logging
from typing import Union
from PySide6.QtCore import QTimer, QUrl, Signal, QObject
from PySide6.QtGui import QImage
from PySide6.QtMultimedia import QMediaPlayer
from PySide6.QtWidgets import QWidget
from ffpyplayer.pic import Image
from ffpyplayer.player import MediaPlayer
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger('FFmpegMediaPlayer')
class FFmpegMediaPlayer(QObject):
"""
ffmpeg media player
"""
sourceChanged = Signal(QUrl)
mediaStatusChanged = Signal(QMediaPlayer.MediaStatus)
positionChanged = Signal(int)
durationChanged = Signal(int)
metaDataChanged = Signal(dict)
playbackStateChanged = Signal(QMediaPlayer.PlaybackState)
playingChanged = Signal(bool)
errorChanged = Signal(QMediaPlayer.Error)
def __init__(self, parent=None):
super().__init__(parent)
self.__source: QUrl = QUrl()
self.__playerWidget: QWidget = None
self.__mediaStatus: QMediaPlayer.MediaStatus = QMediaPlayer.MediaStatus.NoMedia
self.__position: int = 0
self.__duration: int = 0
self.__metaData: dict = {}
self.__error: QMediaPlayer.Error = QMediaPlayer.Error.NoError
self.__errorString: str = ''
self.timer = QTimer(self)
self.player: MediaPlayer = None
self.timer.timeout.connect(self._update_frame)
def setSource(self, source: Union[str, QUrl]):
if isinstance(source, QUrl):
source = source.toString()
if self.player:
self.player.close_player()
self.timer.stop()
self.player = None
logger.debug(f'set source: {source}')
self.player = MediaPlayer(
source,
ff_opts={
'paused': True,
'autoexit': True,
'vn': False,
'sn': False,
'aud': 'sdl'
},
loglevel='debug',
callback=self.__callback
)
self.__source = QUrl(source)
self.sourceChanged.emit(self.__source)
def source(self) -> QUrl:
return self.__source
def fps(self) -> float:
fps = self.metadata()["frame_rate"][0] / self.metadata()["frame_rate"][1]
return fps
def close(self):
self.player.close_player()
logger.debug('player closed')
def play(self):
self.player.set_pause(False)
self.timer.start()
self.playingChanged.emit(True)
self.playbackStateChanged.emit(QMediaPlayer.PlaybackState.PlayingState)
logger.debug('player playing')
def pause(self):
self.player.set_pause(True)
self.timer.stop()
self.playingChanged.emit(False)
self.playbackStateChanged.emit(QMediaPlayer.PlaybackState.PausedState)
logger.debug('player paused')
def stop(self):
self.player.set_pause(True)
self.timer.stop()
self.playingChanged.emit(False)
self.playbackStateChanged.emit(QMediaPlayer.PlaybackState.StoppedState)
logger.debug('player stopped')
def toggle(self):
logger.debug('toggle player')
self.player.toggle_pause()
if self.isPaused():
self.timer.stop()
self.playingChanged.emit(False)
self.playbackStateChanged.emit(QMediaPlayer.PlaybackState.PausedState)
logger.debug('player paused')
else:
self.timer.start()
self.playingChanged.emit(True)
self.playbackStateChanged.emit(QMediaPlayer.PlaybackState.PlayingState)
logger.debug('player playing')
def isPlaying(self) -> bool:
return not self.player.get_pause()
def isPaused(self) -> bool:
return self.player.get_pause()
def setPosition(self, position: int):
if self.player is None:
return
logger.debug(f'set position: {position}')
self.player.seek(position, relative=False)
def position(self) -> int:
return self.player.get_pts()
def duration(self) -> int:
return int(self.metadata().get('duration', 0))
def __setPosition(self, position: Union[float, int]):
if self.player is None:
return
position = int(position)
if self.__position == position:
return
self.__position = position
self.positionChanged.emit(position)
def metaData(self) -> dict:
meta = self.player.get_metadata()
if meta != self.__metaData:
self.__metaData = meta
self.metaDataChanged.emit(meta)
return meta
def setVolume(self, volume: int):
if self.player is None:
return
logger.debug(f'set volume: {volume}')
self.player.set_volume(volume / 100)
def volume(self) -> int:
return int(self.player.get_volume() * 100)
def setMuted(self, muted: bool):
if self.player is None:
return
logger.debug(f'set muted: {muted}')
self.player.set_mute(muted)
def isMuted(self) -> bool:
return self.player.get_mute()
def setOutputPixFormat(self, pix_fmt: str):
self.player.set_output_pix_fmt(pix_fmt)
def outputPixFormat(self) -> str:
return self.player.get_output_pix_fmt()
def metadata(self) -> dict:
return self.player.get_metadata()
def __setMediaStatus(self, status: QMediaPlayer.MediaStatus):
if status == self.__mediaStatus:
return
logger.debug(f'set media status: {status}')
self.__mediaStatus = status
self.mediaStatusChanged.emit(status)
def mediaStatus(self) -> QMediaPlayer.MediaStatus:
return self.__mediaStatus
def _update_frame(self):
frame, val = self.player.get_frame()
if frame is None:
self.__setMediaStatus(QMediaPlayer.MediaStatus.LoadingMedia)
if val == 'eof':
# 结束状态处理
self.__setMediaStatus(QMediaPlayer.MediaStatus.EndOfMedia)
self.stop()
return
if not frame:
return
self.__setMediaStatus(QMediaPlayer.MediaStatus.LoadedMedia)
img: Image
tm: int
img, tm = frame
interval = round(1000 / self.fps())
if self.timer.interval() != interval:
logger.debug(f'set timer interval: {interval}')
self.timer.setInterval(interval)
w, h = img.get_size()
self.__setPosition(tm)
if self.__duration != self.duration():
self.durationChanged.emit(self.duration())
self.metaData()
qimage = QImage(img.to_bytearray(True)[0], w, h, QImage.Format.Format_RGB888)
self.__playerWidget.setImage(qimage)
def setVideoOutput(self, widget: QWidget):
self.__playerWidget = widget
logger.debug(f'set video output: {widget}')
if not hasattr(widget, 'setImage'):
logger.error('视频输出小部件必须有 `setImage` 方法')
raise ValueError('视频输出小部件必须有 `setImage` 方法')
def errorString(self) -> str:
return self.__errorString
def __setError(self, error: QMediaPlayer.Error):
if self.__error == error:
return
self.__error = error
self.errorChanged.emit(error)
def error(self) -> QMediaPlayer.Error:
return self.__error
def __callback(self, *args, **kwargs):
tp, status = args[0].split(':')
if tp == 'read':
if status == 'error':
self.__errorString = '资源读取错误'
self.__setMediaStatus(QMediaPlayer.MediaStatus.InvalidMedia)
self.__setError(QMediaPlayer.Error.ResourceError)
self.stop()
self.close()
elif status == 'exit':
self.__errorString = '播放结束'
self.__setMediaStatus(QMediaPlayer.MediaStatus.EndOfMedia)
self.stop()
self.close()
elif tp == 'audio':
if status == 'error':
self.__errorString = '音频播放错误'
self.__setError(QMediaPlayer.Error.ResourceError)
self.stop()
self.close()
elif status == 'exit':
self.__errorString = '音频播放结束'
self.stop()
self.close()
elif tp == 'video':
if status == 'error':
self.__errorString = '视频播放错误'
self.__setError(QMediaPlayer.Error.ResourceError)
self.stop()
self.close()
elif status == 'exit':
self.__errorString = '视频播放结束'
self.stop()
self.close()VideoWidget
python
# coding:utf-8
from typing import Union
from PySide6.QtCore import QRect, Qt, Signal, Property
from PySide6.QtGui import QImage, QPainter, QPixmap, QColor, QPainterPath, QKeyEvent
from PySide6.QtWidgets import QWidget
class VideoWidget(QWidget):
"""
视频播放控件, 该控件只能作为子页面使用, 不能单独使用
"""
imageChanged = Signal(QImage)
fullScreenChanged = Signal(bool)
_topLeftRadius = 0
_topRightRadius = 0
_bottomLeftRadius = 0
_bottomRightRadius = 0
def __init__(self, parent=None):
super().__init__(parent)
self._transparent = False
self._backgroundColor = Qt.GlobalColor.black
self.image = QImage()
self.backgroundImage = QImage()
self.setBorderRadius(5, 5, 5, 5)
self.setMouseTracking(True)
def setPixmap(self, pixmap: QPixmap):
""" 设置显示的图像 """
self.setImage(pixmap)
def pixmap(self) -> QPixmap:
""" 获取显示的图像 """
return QPixmap.fromImage(self.image)
def setImage(self, image: Union[QPixmap, QImage] = None):
""" 设置显示的图像 """
self.image = image or QImage()
if isinstance(image, QPixmap):
self.image = image.toImage()
self.imageChanged.emit(self.image)
self.update()
def setBackgroundImage(self, image: Union[str, QPixmap, QImage] = None):
""" 设置背景图像 """
self.backgroundImage = image or QImage()
if isinstance(image, QPixmap):
self.backgroundImage = image.toImage()
self.update()
elif isinstance(image, str):
self.backgroundImage.load(image)
self.update()
def backgroundImage(self) -> QImage:
""" 获取背景图像 """
return self.backgroundImage
def isNull(self):
return self.image.isNull()
def setTransparent(self, transparent: bool):
""" 设置是否透明 """
self._transparent = transparent
self.update()
def isTransparent(self) -> bool:
""" 获取是否透明 """
return self._transparent
def setBackgroundColor(self, color: QColor):
""" 设置背景颜色 """
self._backgroundColor = color
self.update()
def backgroundColor(self) -> QColor:
""" 获取背景颜色 """
return self._backgroundColor
def setBorderRadius(self, topLeft: int, topRight: int, bottomLeft: int, bottomRight: int):
""" set the border radius of image """
self._topLeftRadius = topLeft
self._topRightRadius = topRight
self._bottomLeftRadius = bottomLeft
self._bottomRightRadius = bottomRight
self.update()
@Property(int)
def topLeftRadius(self):
return self._topLeftRadius
@topLeftRadius.setter
def topLeftRadius(self, radius: int):
self.setBorderRadius(radius, self.topRightRadius, self.bottomLeftRadius, self.bottomRightRadius)
@Property(int)
def topRightRadius(self):
return self._topRightRadius
@topRightRadius.setter
def topRightRadius(self, radius: int):
self.setBorderRadius(self.topLeftRadius, radius, self.bottomLeftRadius, self.bottomRightRadius)
@Property(int)
def bottomLeftRadius(self):
return self._bottomLeftRadius
@bottomLeftRadius.setter
def bottomLeftRadius(self, radius: int):
self.setBorderRadius(self.topLeftRadius, self.topRightRadius, radius, self.bottomRightRadius)
@Property(int)
def bottomRightRadius(self):
return self._bottomRightRadius
@bottomRightRadius.setter
def bottomRightRadius(self, radius: int):
self.setBorderRadius(
self.topLeftRadius,
self.topRightRadius,
self.bottomLeftRadius,
radius
)
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHints(QPainter.RenderHint.Antialiasing)
painter.setRenderHint(QPainter.RenderHint.LosslessImageRendering)
path = QPainterPath()
w, h = self.width(), self.height()
# top line
path.moveTo(self.topLeftRadius, 0)
path.lineTo(w - self.topRightRadius, 0)
# top right arc
d = self.topRightRadius * 2
path.arcTo(w - d, 0, d, d, 90, -90)
# right line
path.lineTo(w, h - self.bottomRightRadius)
# bottom right arc
d = self.bottomRightRadius * 2
path.arcTo(w - d, h - d, d, d, 0, -90)
# bottom line
path.lineTo(self.bottomLeftRadius, h)
# bottom left arc
d = self.bottomLeftRadius * 2
path.arcTo(0, h - d, d, d, -90, -90)
# left line
path.lineTo(0, self.topLeftRadius)
# top left arc
d = self.topLeftRadius * 2
path.arcTo(0, 0, d, d, -180, -90)
# 裁剪路径
painter.setPen(Qt.PenStyle.NoPen)
painter.setClipPath(path)
if not self._transparent:
painter.fillRect(self.rect(), self._backgroundColor) # 填充颜色
if not self.backgroundImage.isNull():
painter.drawImage(self.rect(), self.backgroundImage) # 填充背景图片
if self.isNull():
return
# draw image
image = self.image
# 保持宽高比居中显示
image_ratio = image.width() / image.height()
widget_ratio = self.width() / self.height()
# 计算适配后的显示区域
if widget_ratio > image_ratio:
target_width = self.height() * image_ratio
target_rect = QRect(
(self.width() - target_width) // 2, 0,
target_width, self.height()
)
else:
target_height = self.width() / image_ratio
target_rect = QRect(
0, (self.height() - target_height) // 2,
self.width(), target_height
)
painter.drawImage(target_rect, image)
def fullScreen(self):
""" 全屏显示 """
self.setWindowFlags(Qt.WindowType.Window)
self.showFullScreen()
self.fullScreenChanged.emit(True)
def normalScreen(self):
""" 退出全屏显示 """
self.setWindowFlags(Qt.WindowType.SubWindow)
self.showNormal()
self.fullScreenChanged.emit(False)
def toggleFullScreen(self):
""" 切换全屏显示 """
if self.isFullScreen():
self.normalScreen()
else:
self.fullScreen()
self.setBorderRadius(0, 0, 0, 0)
def setFullScreen(self, fullScreen: bool):
""" 设置全屏显示 """
if fullScreen:
self.fullScreen()
else:
self.normalScreen()
def keyPressEvent(self, event: QKeyEvent):
""" 键盘按下事件 """
if event.key() == Qt.Key.Key_Escape:
self.toggleFullScreen()