Styjun

I'm new to PyQt and I'm trying to create a videoplayer that screenshots the current frame it retrieves. I implemented this method for grabbing the videoframes in order to take screenshots and added it to a videoplayer GUI. Here's how the GUI essentially looks like:

I created a trigger for the screenshot action in the VideoWindow class with the following code:

screenshotAction = QAction(QIcon('screenshot.png'), '&Screenshot', self)
screenshotAction.setShortcut('Ctrl+S')
screenshotAction.setStatusTip('Screenshot scenes')
screenshotAction.triggered.connect(self.screenshotCall)

I then took the implementation of the VideoFrameGrabber class and called it in the screenshot function:

def screenshotCall(self):
 #Call video frame grabber
 self.grabber = VideoFrameGrabber(self.videoWidget, self)
 self.mediaPlayer.setVideoOutput(self.grabber)
 self.grabber.frameAvailable.connect(self.process_frame)
 self.mediaPlayer.setVideoOutput(self.videoWidget)

Complete code:

# PyQt5 Video player
#!/usr/bin/env python

from PyQt5.QtCore import QDir, Qt, QUrl, pyqtSignal, QPoint, QRect, QObject
from PyQt5.QtMultimedia import QMediaContent, QMediaPlayer, QVideoFrame, QAbstractVideoSurface, QAbstractVideoBuffer, QVideoSurfaceFormat
from PyQt5.QtMultimediaWidgets import QVideoWidget
from PyQt5.QtWidgets import (QApplication, QFileDialog, QHBoxLayout, QLabel,
 QPushButton, QSizePolicy, QSlider, QStyle, QVBoxLayout, QWidget)
from PyQt5.QtWidgets import QMainWindow,QWidget, QPushButton, QAction
from PyQt5.QtGui import QIcon, QPainter, QImage
import sys
import os
import os.path as osp

class VideoFrameGrabber(QAbstractVideoSurface):
 frameAvailable = pyqtSignal(QImage)

 def __init__(self, widget: QWidget, parent: QObject):
 super().__init__(parent)

 self.widget = widget
 def supportedPixelFormats(self, handleType):
 return [QVideoFrame.Format_ARGB32, QVideoFrame.Format_ARGB32_Premultiplied,
 QVideoFrame.Format_RGB32, QVideoFrame.Format_RGB24, QVideoFrame.Format_RGB565,
 QVideoFrame.Format_RGB555, QVideoFrame.Format_ARGB8565_Premultiplied,
 QVideoFrame.Format_BGRA32, QVideoFrame.Format_BGRA32_Premultiplied, QVideoFrame.Format_BGR32,
 QVideoFrame.Format_BGR24, QVideoFrame.Format_BGR565, QVideoFrame.Format_BGR555,
 QVideoFrame.Format_BGRA5658_Premultiplied, QVideoFrame.Format_AYUV444,
 QVideoFrame.Format_AYUV444_Premultiplied, QVideoFrame.Format_YUV444,
 QVideoFrame.Format_YUV420P, QVideoFrame.Format_YV12, QVideoFrame.Format_UYVY,
 QVideoFrame.Format_YUYV, QVideoFrame.Format_NV12, QVideoFrame.Format_NV21,
 QVideoFrame.Format_IMC1, QVideoFrame.Format_IMC2, QVideoFrame.Format_IMC3,
 QVideoFrame.Format_IMC4, QVideoFrame.Format_Y8, QVideoFrame.Format_Y16,
 QVideoFrame.Format_Jpeg, QVideoFrame.Format_CameraRaw, QVideoFrame.Format_AdobeDng]

 def isFormatSupported(self, format):
 imageFormat = QVideoFrame.imageFormatFromPixelFormat(format.pixelFormat())
 size = format.frameSize()

 return imageFormat != QImage.Format_Invalid and not size.isEmpty() and 
 format.handleType() == QAbstractVideoBuffer.NoHandle

 def start(self, format: QVideoSurfaceFormat):
 imageFormat = QVideoFrame.imageFormatFromPixelFormat(format.pixelFormat())
 size = format.frameSize()

 if imageFormat != QImage.Format_Invalid and not size.isEmpty():
 self.imageFormat = imageFormat
 self.imageSize = size
 self.sourceRect = format.viewport()

 super().start(format)

 self.widget.updateGeometry()
 self.updateVideoRect()

 return True
 else:
 return False

 def stop(self):
 self.currentFrame = QVideoFrame()
 self.targetRect = QRect()

 super().stop()

 self.widget.update()

 def present(self, frame):
 if frame.isValid():
 cloneFrame = QVideoFrame(frame)
 cloneFrame.map(QAbstractVideoBuffer.ReadOnly)
 image = QImage(cloneFrame.bits(), cloneFrame.width(), cloneFrame.height(),
 QVideoFrame.imageFormatFromPixelFormat(cloneFrame.pixelFormat()))
 self.frameAvailable.emit(image) # this is very important
 cloneFrame.unmap()

 if self.surfaceFormat().pixelFormat() != frame.pixelFormat() or 
 self.surfaceFormat().frameSize() != frame.size():
 self.setError(QAbstractVideoSurface.IncorrectFormatError)
 self.stop()

 return False
 else:
 self.currentFrame = frame
 self.widget.repaint(self.targetRect)

 return True

 def updateVideoRect(self):
 size = self.surfaceFormat().sizeHint()
 size.scale(self.widget.size().boundedTo(size), Qt.KeepAspectRatio)

 self.targetRect = QRect(QPoint(0, 0), size)
 self.targetRect.moveCenter(self.widget.rect().center())

 def paint(self, painter):
 if self.currentFrame.map(QAbstractVideoBuffer.ReadOnly):
 oldTransform = self.painter.transform()

 if self.surfaceFormat().scanLineDirection() == QVideoSurfaceFormat.BottomToTop:
 self.painter.scale(1, -1)
 self.painter.translate(0, -self.widget.height())

 image = QImage(self.currentFrame.bits(), self.currentFrame.width(), self.currentFrame.height(),
 self.currentFrame.bytesPerLine(), self.imageFormat)

 self.painter.drawImage(self.targetRect, image, self.sourceRect)

 self.painter.setTransform(oldTransform)

 self.currentFrame.unmap()

class VideoWindow(QMainWindow):

 def __init__(self, parent=None):
 super(VideoWindow, self).__init__(parent)
 self.setWindowTitle("PyQt Video Player Widget") 

 self.counter = 0
 self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
 self.videoWidget = QVideoWidget()
 self.videoFrame = QVideoFrame()
 self.playButton = QPushButton()
 self.playButton.setEnabled(False)
 self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
 self.playButton.clicked.connect(self.play)

 self.positionSlider = QSlider(Qt.Horizontal)
 self.positionSlider.setRange(0, 0)
 self.positionSlider.sliderMoved.connect(self.setPosition)

 self.errorLabel = QLabel()
 self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
 QSizePolicy.Maximum)
 # Create new action
 openAction = QAction(QIcon('open.png'), '&Open', self) 
 openAction.setShortcut('Ctrl+O')
 openAction.setStatusTip('Open video')
 openAction.triggered.connect(self.openFile)

 # Create exit action
 exitAction = QAction(QIcon('quit.png'), '&Exit', self) 
 exitAction.setShortcut('Ctrl+Q')
 exitAction.setStatusTip('Exit application')
 exitAction.triggered.connect(self.exitCall)

 screenshotAction = QAction(QIcon('screenshot.png'), '&Screenshot', self)
 screenshotAction.setShortcut('Ctrl+S')
 screenshotAction.setStatusTip('Screenshot scenes')
 screenshotAction.triggered.connect(self.screenshotCall)

 # Create menu bar and add action
 menuBar = self.menuBar()
 fileMenu = menuBar.addMenu('&File')
 #fileMenu.addAction(newAction)
 fileMenu.addAction(openAction)
 fileMenu.addAction(screenshotAction)
 fileMenu.addAction(exitAction)


 # Create a widget for window contents
 wid = QWidget(self)
 self.setCentralWidget(wid)

 # Create layouts to place inside widget
 controlLayout = QHBoxLayout()
 controlLayout.setContentsMargins(0, 0, 0, 0)
 controlLayout.addWidget(self.playButton)
 controlLayout.addWidget(self.positionSlider)

 layout = QVBoxLayout()
 layout.addWidget(self.videoWidget)
 layout.addLayout(controlLayout)
 layout.addWidget(self.errorLabel)

 # Set widget to contain window contents
 wid.setLayout(layout)


 self.mediaPlayer.setVideoOutput(self.videoWidget)
 self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
 self.mediaPlayer.positionChanged.connect(self.positionChanged)
 self.mediaPlayer.durationChanged.connect(self.durationChanged)
 self.mediaPlayer.error.connect(self.handleError)

 def openFile(self):
 fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
 QDir.homePath())
 self.path = osp.dirname(str(fileName))
 if fileName != '':
 self.mediaPlayer.setMedia(
 QMediaContent(QUrl.fromLocalFile(fileName)))
 self.playButton.setEnabled(True)

 def exitCall(self):
 sys.exit(app.exec_())

 def screenshotCall(self):
 #Call video frame grabber
 self.grabber = VideoFrameGrabber(self.videoWidget, self)
 self.mediaPlayer.setVideoOutput(self.grabber)
 self.mediaPlayer.pause()
 self.grabber.frameAvailable.connect(self.process_frame)
 self.errorLabel.setText("Taking a screenshot of image "+str(self.counter)+" ....")
 self.mediaPlayer.play()
 self.mediaPlayer.setVideoOutput(self.videoWidget)

 def play(self):
 if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
 self.mediaPlayer.pause()
 else:
 self.mediaPlayer.play()

 def mediaStateChanged(self, state):
 if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
 self.playButton.setIcon(
 self.style().standardIcon(QStyle.SP_MediaPause))
 else:
 self.playButton.setIcon(
 self.style().standardIcon(QStyle.SP_MediaPlay))

 def positionChanged(self, position):
 self.positionSlider.setValue(position)

 def durationChanged(self, duration):
 self.positionSlider.setRange(0, duration)

 def setPosition(self, position):
 self.mediaPlayer.setPosition(position)

 def handleError(self):
 self.playButton.setEnabled(False)
 self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())

 def process_frame(self, image):
 # Save image here
 filename = "screenshot" + str(self.counter).zfill(6)
 self.path = 'C:/Desktop/temp'
 image.save(self.path+'/.png'.format(str(filename)))
 self.counter = self.counter+1

if __name__ == '__main__':
 app = QApplication(sys.argv)
 player = VideoWindow()
 player.resize(720, 480)
 player.show()
 sys.exit(app.exec_())

However, whenever I try taking a screenshot, the video display turns black. Based from the audio, the video is still playing, but the current display remains black all throughout the duration of the video from the moment the screenshot is taken. This happens for both when the player is paused and while it is still playing. I think it's because of the line self.mediaPlayer.setVideoOutput(self.grabber), since it overwrites the current display on the screen with the grabber.

I've tried calling the videoWidget back and set it as the video output after the frame was grabbed, but it seems to overwrite the grabber and does not produce any screenshots at all.

Is there a way for me to simultaneously take screenshots and still display the video on the GUI?

solved this by calling the pause function every time the video plays, and then playing the part of the video where it was paused when the play button is pressed.

here's the code:

def screenshotCall(self):
 #Call video frame grabber
 self.grabber = VideoFrameGrabber(self.videoWidget, self)
 self.mediaPlayer.setVideoOutput(self.grabber)
 self.grabber.frameAvailable.connect(self.process_frame)
 self.errorLabel.setText("Taking a screenshot of image "+str(self.counter)+" ....")
 self.mediaPlayer.pause()

def play(self):
 if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
 self.mediaPlayer.pause()
 else:
 self.mediaPlayer.play()
 self.mediaPlayer.setVideoOutput(self.videoWidget)