52427
pyqy5でwmv動画を再生させるときに、brightness,contrast,hue,saturationを変化させたいです。下は試しに書いてみたコードです。

```

    from PyQt5.QtCore import QDir, Qt, QUrl
    from PyQt5.QtMultimedia import QMediaContent, QMediaPlayer
    from PyQt5.QtMultimediaWidgets import QVideoWidget
    from PyQt5.QtWidgets import (QApplication, QFileDialog, QHBoxLayout, QLabel,
            QPushButton, QSizePolicy, QSlider, QStyle, QVBoxLayout, QWidget)
    
    
    class VideoPlayer(QWidget):
    
        def __init__(self, parent=None):
            super(VideoPlayer, self).__init__(parent)
    
            self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
    
            videoWidget = QVideoWidget()
    
            openButton = QPushButton("Open...")
            openButton.clicked.connect(self.openFile)
    
            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)
    
            controlLayout = QHBoxLayout()
            controlLayout.setContentsMargins(0, 0, 0, 0)
            controlLayout.addWidget(openButton)
            controlLayout.addWidget(self.playButton)
            controlLayout.addWidget(self.positionSlider)
    
            layout = QVBoxLayout()
            layout.addWidget(videoWidget)
            layout.addLayout(controlLayout)
            layout.addWidget(self.errorLabel)
    
            self.setLayout(layout)
    
            self.mediaPlayer.setVideoOutput(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)
    
            print(videoWidget.brightness())
            videoWidget.setBrightness(50)
            videoWidget.setContrast(100)
            videoWidget.setHue(100)
            videoWidget.setSaturation(100)
            print(videoWidget.brightness())
    
    
        def openFile(self):
            fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
                    QDir.homePath())
    
            if fileName != '':
                self.mediaPlayer.setMedia(
                        QMediaContent(QUrl.fromLocalFile(fileName)))
                self.playButton.setEnabled(True)
    
        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())
    
    
    if __name__ == '__main__':
    
        import sys
    
        app = QApplication(sys.argv)
    
        player = VideoPlayer()
        player.resize(320, 240)
        player.show()
    
        sys.exit(app.exec_())
    
```

これを実行することで、  
[![画像](https://i.stack.imgur.com/wheSl.png)](https://i.stack.imgur.com/wheSl.png)  
の様なGUIが作成されます。ここで、再際される動画のbrightness,contrast,hue,saturationが変化したものが再生されるつもりでしたが、実行しても通常のままの動画が再生されました。また、このコードを描くときに参考にしたコードがしたのコードで(長いですが、そのまま載せます。申し訳ありません。)、そちらでは上記4つの変化を施すことが可能でした。私のコードをどのように直せばよいのでしょうか。

```

    from PyQt5.QtCore import (pyqtSignal, pyqtSlot, Q_ARG, QAbstractItemModel,
            QFileInfo, qFuzzyCompare, QMetaObject, QModelIndex, QObject, Qt,
            QThread, QTime, QUrl)
    from PyQt5.QtGui import QColor, qGray, QImage, QPainter, QPalette
    from PyQt5.QtMultimedia import (QAbstractVideoBuffer, QMediaContent,
            QMediaMetaData, QMediaPlayer, QMediaPlaylist, QVideoFrame, QVideoProbe)
    from PyQt5.QtMultimediaWidgets import QVideoWidget
    from PyQt5.QtWidgets import (QApplication, QComboBox, QDialog, QFileDialog,
            QFormLayout, QHBoxLayout, QLabel, QListView, QMessageBox, QPushButton,
            QSizePolicy, QSlider, QStyle, QToolButton, QVBoxLayout, QWidget)
    
    
    class VideoWidget(QVideoWidget):
    
        def __init__(self, parent=None):
            super(VideoWidget, self).__init__(parent)
    
            self.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
    
            p = self.palette()
            p.setColor(QPalette.Window, Qt.black)
            self.setPalette(p)
    
            self.setAttribute(Qt.WA_OpaquePaintEvent)
    
        def keyPressEvent(self, event):
            if event.key() == Qt.Key_Escape and self.isFullScreen():
                self.setFullScreen(False)
                event.accept()
            elif event.key() == Qt.Key_Enter and event.modifiers() & Qt.Key_Alt:
                self.setFullScreen(not self.isFullScreen())
                event.accept()
            else:
                super(VideoWidget, self).keyPressEvent(event)
    
        def mouseDoubleClickEvent(self, event):
            self.setFullScreen(not self.isFullScreen())
            event.accept()
    
    
    class PlaylistModel(QAbstractItemModel):
    
        Title, ColumnCount = range(2)
    
        def __init__(self, parent=None):
            super(PlaylistModel, self).__init__(parent)
    
            self.m_playlist = None
    
        def rowCount(self, parent=QModelIndex()):
            return self.m_playlist.mediaCount() if self.m_playlist is not None and not parent.isValid() else 0
    
        def columnCount(self, parent=QModelIndex()):
            return self.ColumnCount if not parent.isValid() else 0
    
        def index(self, row, column, parent=QModelIndex()):
            return self.createIndex(row, column) if self.m_playlist is not None and not parent.isValid() and row >= 0 and row < self.m_playlist.mediaCount() and column >= 0 and column < self.ColumnCount else QModelIndex()
    
        def parent(self, child):
            return QModelIndex()
    
        def data(self, index, role=Qt.DisplayRole):
            if index.isValid() and role == Qt.DisplayRole:
                if index.column() == self.Title:
                    location = self.m_playlist.media(index.row()).canonicalUrl()
                    return QFileInfo(location.path()).fileName()
    
                return self.m_data[index]
    
            return None
    
        def playlist(self):
            return self.m_playlist
    
        def setPlaylist(self, playlist):
            if self.m_playlist is not None:
                self.m_playlist.mediaAboutToBeInserted.disconnect(
                        self.beginInsertItems)
                self.m_playlist.mediaInserted.disconnect(self.endInsertItems)
                self.m_playlist.mediaAboutToBeRemoved.disconnect(
                        self.beginRemoveItems)
                self.m_playlist.mediaRemoved.disconnect(self.endRemoveItems)
                self.m_playlist.mediaChanged.disconnect(self.changeItems)
    
            self.beginResetModel()
            self.m_playlist = playlist
    
            if self.m_playlist is not None:
                self.m_playlist.mediaAboutToBeInserted.connect(
                        self.beginInsertItems)
                self.m_playlist.mediaInserted.connect(self.endInsertItems)
                self.m_playlist.mediaAboutToBeRemoved.connect(
                        self.beginRemoveItems)
                self.m_playlist.mediaRemoved.connect(self.endRemoveItems)
                self.m_playlist.mediaChanged.connect(self.changeItems)
    
            self.endResetModel()
    
        def beginInsertItems(self, start, end):
            self.beginInsertRows(QModelIndex(), start, end)
    
        def endInsertItems(self):
            self.endInsertRows()
    
        def beginRemoveItems(self, start, end):
            self.beginRemoveRows(QModelIndex(), start, end)
    
        def endRemoveItems(self):
            self.endRemoveRows()
    
        def changeItems(self, start, end):
            self.dataChanged.emit(self.index(start, 0),
                    self.index(end, self.ColumnCount))
    
    
    class PlayerControls(QWidget):
    
        play = pyqtSignal()
        pause = pyqtSignal()
        stop = pyqtSignal()
        next = pyqtSignal()
        previous = pyqtSignal()
        changeVolume = pyqtSignal(int)
        changeMuting = pyqtSignal(bool)
        changeRate = pyqtSignal(float)
    
        def __init__(self, parent=None):
            super(PlayerControls, self).__init__(parent)
    
            self.playerState = QMediaPlayer.StoppedState
            self.playerMuted = False
    
            self.playButton = QToolButton(clicked=self.playClicked)
            self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
    
            self.stopButton = QToolButton(clicked=self.stop)
            self.stopButton.setIcon(self.style().standardIcon(QStyle.SP_MediaStop))
            self.stopButton.setEnabled(False)
    
            self.nextButton = QToolButton(clicked=self.next)
            self.nextButton.setIcon(
                    self.style().standardIcon(QStyle.SP_MediaSkipForward))
    
            self.previousButton = QToolButton(clicked=self.previous)
            self.previousButton.setIcon(
                    self.style().standardIcon(QStyle.SP_MediaSkipBackward))
    
            self.muteButton = QToolButton(clicked=self.muteClicked)
            self.muteButton.setIcon(
                    self.style().standardIcon(QStyle.SP_MediaVolume))
    
            self.volumeSlider = QSlider(Qt.Horizontal,
                    sliderMoved=self.changeVolume)
            self.volumeSlider.setRange(0, 100)
    
            self.rateBox = QComboBox(activated=self.updateRate)
            self.rateBox.addItem("0.5x", 0.5)
            self.rateBox.addItem("1.0x", 1.0)
            self.rateBox.addItem("2.0x", 2.0)
            self.rateBox.setCurrentIndex(1)
    
            layout = QHBoxLayout()
            layout.setContentsMargins(0, 0, 0, 0)
            layout.addWidget(self.stopButton)
            layout.addWidget(self.previousButton)
            layout.addWidget(self.playButton)
            layout.addWidget(self.nextButton)
            layout.addWidget(self.muteButton)
            layout.addWidget(self.volumeSlider)
            layout.addWidget(self.rateBox)
            self.setLayout(layout)
    
        def state(self):
            return self.playerState
    
        def setState(self,state):
            if state != self.playerState:
                self.playerState = state
    
                if state == QMediaPlayer.StoppedState:
                    self.stopButton.setEnabled(False)
                    self.playButton.setIcon(
                            self.style().standardIcon(QStyle.SP_MediaPlay))
                elif state == QMediaPlayer.PlayingState:
                    self.stopButton.setEnabled(True)
                    self.playButton.setIcon(
                            self.style().standardIcon(QStyle.SP_MediaPause))
                elif state == QMediaPlayer.PausedState:
                    self.stopButton.setEnabled(True)
                    self.playButton.setIcon(
                            self.style().standardIcon(QStyle.SP_MediaPlay))
    
        def volume(self):
            return self.volumeSlider.value()
    
        def setVolume(self, volume):
            self.volumeSlider.setValue(volume)
    
        def isMuted(self):
            return self.playerMuted
    
        def setMuted(self, muted):
            if muted != self.playerMuted:
                self.playerMuted = muted
    
                self.muteButton.setIcon(
                        self.style().standardIcon(
                                QStyle.SP_MediaVolumeMuted if muted else QStyle.SP_MediaVolume))
    
        def playClicked(self):
            if self.playerState in (QMediaPlayer.StoppedState, QMediaPlayer.PausedState):
                self.play.emit()
            elif self.playerState == QMediaPlayer.PlayingState:
                self.pause.emit()
    
        def muteClicked(self):
            self.changeMuting.emit(not self.playerMuted)
    
        def playbackRate(self):
            return self.rateBox.itemData(self.rateBox.currentIndex())
    
        def setPlaybackRate(self, rate):
            for i in range(self.rateBox.count()):
                if qFuzzyCompare(rate, self.rateBox.itemData(i)):
                    self.rateBox.setCurrentIndex(i)
                    return
    
            self.rateBox.addItem("%dx" % rate, rate)
            self.rateBox.setCurrentIndex(self.rateBox.count() - 1)
    
        def updateRate(self):
            self.changeRate.emit(self.playbackRate())
    
    
    class FrameProcessor(QObject):
    
        histogramReady = pyqtSignal(list)
    
        @pyqtSlot(QVideoFrame, int)
        def processFrame(self, frame, levels):
            histogram = [0.0] * levels
    
            if levels and frame.map(QAbstractVideoBuffer.ReadOnly):
                pixelFormat = frame.pixelFormat()
    
                if pixelFormat == QVideoFrame.Format_YUV420P or pixelFormat == QVideoFrame.Format_NV12:
                    # Process YUV data.
                    bits = frame.bits()
                    for idx in range(frame.height() * frame.width()):
                        histogram[(bits[idx] * levels) >> 8] += 1.0
                else:
                    imageFormat = QVideoFrame.imageFormatFromPixelFormat(pixelFormat)
                    if imageFormat != QImage.Format_Invalid:
                        # Process RGB data.
                        image = QImage(frame.bits(), frame.width(), frame.height(), imageFormat)
    
                        for y in range(image.height()):
                            for x in range(image.width()):
                                pixel = image.pixel(x, y)
                                histogram[(qGray(pixel) * levels) >> 8] += 1.0
    
                # Find the maximum value.
                maxValue = 0.0
                for value in histogram:
                    if value > maxValue:
                        maxValue = value
    
                # Normalise the values between 0 and 1.
                if maxValue > 0.0:
                    for i in range(len(histogram)):
                        histogram[i] /= maxValue
    
                frame.unmap()
    
            self.histogramReady.emit(histogram)
    
    
    class HistogramWidget(QWidget):
    
        def __init__(self, parent=None):
            super(HistogramWidget, self).__init__(parent)
    
            self.m_levels = 128
            self.m_isBusy = False
            self.m_histogram = []
            self.m_processor = FrameProcessor()
            self.m_processorThread = QThread()
    
            self.m_processor.moveToThread(self.m_processorThread)
            self.m_processor.histogramReady.connect(self.setHistogram)
    
        def __del__(self):
            self.m_processorThread.quit()
            self.m_processorThread.wait(10000)
    
        def setLevels(self, levels):
            self.m_levels = levels
    
        def processFrame(self, frame):
            if self.m_isBusy:
                return
    
            self.m_isBusy = True
            QMetaObject.invokeMethod(self.m_processor, 'processFrame',
                    Qt.QueuedConnection, Q_ARG(QVideoFrame, frame),
                    Q_ARG(int, self.m_levels))
    
        @pyqtSlot(list)
        def setHistogram(self, histogram):
            self.m_isBusy = False
            self.m_histogram = list(histogram)
            self.update()
    
        def paintEvent(self, event):
            painter = QPainter(self)
    
            if len(self.m_histogram) == 0:
                painter.fillRect(0, 0, self.width(), self.height(),
                        QColor.fromRgb(0, 0, 0))
                return
    
            barWidth = self.width() / float(len(self.m_histogram))
    
            for i, value in enumerate(self.m_histogram):
                h = value * self.height()
                # Draw the level.
                painter.fillRect(barWidth * i, self.height() - h,
                        barWidth * (i + 1), self.height(), Qt.red)
                # Clear the rest of the control.
                painter.fillRect(barWidth * i, 0, barWidth * (i + 1),
                        self.height() - h, Qt.black)
    
    
    class Player(QWidget):
    
        fullScreenChanged = pyqtSignal(bool)
    
        def __init__(self, playlist, parent=None):
            super(Player, self).__init__(parent)
    
            self.colorDialog = None
            self.trackInfo = ""
            self.statusInfo = ""
            self.duration = 0
    
            self.player = QMediaPlayer()
            self.playlist = QMediaPlaylist()
            self.player.setPlaylist(self.playlist)
    
            self.player.durationChanged.connect(self.durationChanged)
            self.player.positionChanged.connect(self.positionChanged)
            self.player.metaDataChanged.connect(self.metaDataChanged)
            self.playlist.currentIndexChanged.connect(self.playlistPositionChanged)
            self.player.mediaStatusChanged.connect(self.statusChanged)
            self.player.bufferStatusChanged.connect(self.bufferingProgress)
            self.player.videoAvailableChanged.connect(self.videoAvailableChanged)
            self.player.error.connect(self.displayErrorMessage)
    
            self.videoWidget = VideoWidget()
            self.player.setVideoOutput(self.videoWidget)
    
            self.playlistModel = PlaylistModel()
            self.playlistModel.setPlaylist(self.playlist)
    
            self.playlistView = QListView()
            self.playlistView.setModel(self.playlistModel)
            self.playlistView.setCurrentIndex(
                    self.playlistModel.index(self.playlist.currentIndex(), 0))
    
            self.playlistView.activated.connect(self.jump)
    
            self.slider = QSlider(Qt.Horizontal)
            self.slider.setRange(0, self.player.duration() / 1000)
    
            self.labelDuration = QLabel()
            self.slider.sliderMoved.connect(self.seek)
    
            self.labelHistogram = QLabel()
            self.labelHistogram.setText("Histogram:")
            self.histogram = HistogramWidget()
            histogramLayout = QHBoxLayout()
            histogramLayout.addWidget(self.labelHistogram)
            histogramLayout.addWidget(self.histogram, 1)
    
            self.probe = QVideoProbe()
            self.probe.videoFrameProbed.connect(self.histogram.processFrame)
            self.probe.setSource(self.player)
    
            openButton = QPushButton("Open", clicked=self.open)
    
            controls = PlayerControls()
            controls.setState(self.player.state())
            controls.setVolume(self.player.volume())
            controls.setMuted(controls.isMuted())
    
            controls.play.connect(self.player.play)
            controls.pause.connect(self.player.pause)
            controls.stop.connect(self.player.stop)
            controls.next.connect(self.playlist.next)
            controls.previous.connect(self.previousClicked)
            controls.changeVolume.connect(self.player.setVolume)
            controls.changeMuting.connect(self.player.setMuted)
            controls.changeRate.connect(self.player.setPlaybackRate)
            controls.stop.connect(self.videoWidget.update)
    
            self.player.stateChanged.connect(controls.setState)
            self.player.volumeChanged.connect(controls.setVolume)
            self.player.mutedChanged.connect(controls.setMuted)
    
            self.fullScreenButton = QPushButton("FullScreen")
            self.fullScreenButton.setCheckable(True)
    
            self.colorButton = QPushButton("Color Options...")
            self.colorButton.setEnabled(False)
            self.colorButton.clicked.connect(self.showColorDialog)
    
            displayLayout = QHBoxLayout()
            displayLayout.addWidget(self.videoWidget, 2)
            displayLayout.addWidget(self.playlistView)
    
            controlLayout = QHBoxLayout()
            controlLayout.setContentsMargins(0, 0, 0, 0)
            controlLayout.addWidget(openButton)
            controlLayout.addStretch(1)
            controlLayout.addWidget(controls)
            controlLayout.addStretch(1)
            controlLayout.addWidget(self.fullScreenButton)
            controlLayout.addWidget(self.colorButton)
    
            layout = QVBoxLayout()
            layout.addLayout(displayLayout)
            hLayout = QHBoxLayout()
            hLayout.addWidget(self.slider)
            hLayout.addWidget(self.labelDuration)
            layout.addLayout(hLayout)
            layout.addLayout(controlLayout)
            layout.addLayout(histogramLayout)
    
            self.setLayout(layout)
    
            if not self.player.isAvailable():
                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)
                self.playlistView.setEnabled(False)
                openButton.setEnabled(False)
                self.colorButton.setEnabled(False)
                self.fullScreenButton.setEnabled(False)
    
            self.metaDataChanged()
    
            self.addToPlaylist(playlist)
    
        def open(self):
            fileNames, _ = QFileDialog.getOpenFileNames(self, "Open Files")
            self.addToPlaylist(fileNames)
    
        def addToPlaylist(self, fileNames):
            for name in fileNames:
                fileInfo = QFileInfo(name)
                if fileInfo.exists():
                    url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
                    if fileInfo.suffix().lower() == 'm3u':
                        self.playlist.load(url)
                    else:
                        self.playlist.addMedia(QMediaContent(url))
                else:
                    url = QUrl(name)
                    if url.isValid():
                        self.playlist.addMedia(QMediaContent(url))
    
        def durationChanged(self, duration):
            duration /= 1000
    
            self.duration = duration
            self.slider.setMaximum(duration)
    
        def positionChanged(self, progress):
            progress /= 1000
    
            if not self.slider.isSliderDown():
                self.slider.setValue(progress)
    
            self.updateDurationInfo(progress)
    
        def metaDataChanged(self):
            if self.player.isMetaDataAvailable():
                self.setTrackInfo("%s - %s" % (
                        self.player.metaData(QMediaMetaData.AlbumArtist),
                        self.player.metaData(QMediaMetaData.Title)))
    
        def previousClicked(self):
            # Go to the previous track if we are within the first 5 seconds of
            # playback.  Otherwise, seek to the beginning.
            if self.player.position() <= 5000:
                self.playlist.previous()
            else:
                self.player.setPosition(0)
    
        def jump(self, index):
            if index.isValid():
                self.playlist.setCurrentIndex(index.row())
                self.player.play()
    
        def playlistPositionChanged(self, position):
            self.playlistView.setCurrentIndex(
                    self.playlistModel.index(position, 0))
    
        def seek(self, seconds):
            self.player.setPosition(seconds * 1000)
    
        def statusChanged(self, status):
            self.handleCursor(status)
    
            if status == QMediaPlayer.LoadingMedia:
                self.setStatusInfo("Loading...")
            elif status == QMediaPlayer.StalledMedia:
                self.setStatusInfo("Media Stalled")
            elif status == QMediaPlayer.EndOfMedia:
                QApplication.alert(self)
            elif status == QMediaPlayer.InvalidMedia:
                self.displayErrorMessage()
            else:
                self.setStatusInfo("")
    
        def handleCursor(self, status):
            if status in (QMediaPlayer.LoadingMedia, QMediaPlayer.BufferingMedia, QMediaPlayer.StalledMedia):
                self.setCursor(Qt.BusyCursor)
            else:
                self.unsetCursor()
    
        def bufferingProgress(self, progress):
            self.setStatusInfo("Buffering %d%" % progress)
    
        def videoAvailableChanged(self, available):
            if available:
                self.fullScreenButton.clicked.connect(
                        self.videoWidget.setFullScreen)
                self.videoWidget.fullScreenChanged.connect(
                        self.fullScreenButton.setChecked)
    
                if self.fullScreenButton.isChecked():
                    self.videoWidget.setFullScreen(True)
            else:
                self.fullScreenButton.clicked.disconnect(
                        self.videoWidget.setFullScreen)
                self.videoWidget.fullScreenChanged.disconnect(
                        self.fullScreenButton.setChecked)
    
                self.videoWidget.setFullScreen(False)
    
            self.colorButton.setEnabled(available)
    
        def setTrackInfo(self, info):
            self.trackInfo = info
    
            if self.statusInfo != "":
                self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo))
            else:
                self.setWindowTitle(self.trackInfo)
    
        def setStatusInfo(self, info):
            self.statusInfo = info
    
            if self.statusInfo != "":
                self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo))
            else:
                self.setWindowTitle(self.trackInfo)
    
        def displayErrorMessage(self):
            self.setStatusInfo(self.player.errorString())
    
        def updateDurationInfo(self, currentInfo):
            duration = self.duration
            if currentInfo or duration:
                currentTime = QTime((currentInfo/3600)%60, (currentInfo/60)%60,
                        currentInfo%60, (currentInfo*1000)%1000)
                totalTime = QTime((duration/3600)%60, (duration/60)%60,
                        duration%60, (duration*1000)%1000);
    
                format = 'hh:mm:ss' if duration > 3600 else 'mm:ss'
                tStr = currentTime.toString(format) + " / " + totalTime.toString(format)
            else:
                tStr = ""
    
            self.labelDuration.setText(tStr)
    
        def showColorDialog(self):
            if self.colorDialog is None:
                brightnessSlider = QSlider(Qt.Horizontal)
                brightnessSlider.setRange(-100, 100)
                brightnessSlider.setValue(self.videoWidget.brightness())
                brightnessSlider.sliderMoved.connect(
                        self.videoWidget.setBrightness)
                self.videoWidget.brightnessChanged.connect(
                        brightnessSlider.setValue)
    
                contrastSlider = QSlider(Qt.Horizontal)
                contrastSlider.setRange(-100, 100)
                contrastSlider.setValue(self.videoWidget.contrast())
                contrastSlider.sliderMoved.connect(self.videoWidget.setContrast)
                self.videoWidget.contrastChanged.connect(contrastSlider.setValue)
    
                hueSlider = QSlider(Qt.Horizontal)
                hueSlider.setRange(-100, 100)
                hueSlider.setValue(self.videoWidget.hue())
                hueSlider.sliderMoved.connect(self.videoWidget.setHue)
                self.videoWidget.hueChanged.connect(hueSlider.setValue)
    
                saturationSlider = QSlider(Qt.Horizontal)
                saturationSlider.setRange(-100, 100)
                saturationSlider.setValue(self.videoWidget.saturation())
                saturationSlider.sliderMoved.connect(
                        self.videoWidget.setSaturation)
                self.videoWidget.saturationChanged.connect(
                        saturationSlider.setValue)
    
                layout = QFormLayout()
                layout.addRow("Brightness", brightnessSlider)
                layout.addRow("Contrast", contrastSlider)
                layout.addRow("Hue", hueSlider)
                layout.addRow("Saturation", saturationSlider)
    
                button = QPushButton("Close")
                layout.addRow(button)
    
                self.colorDialog = QDialog(self)
                self.colorDialog.setWindowTitle("Color Options")
                self.colorDialog.setLayout(layout)
    
                button.clicked.connect(self.colorDialog.close)
    
            self.colorDialog.show()
    
    
    if __name__ == '__main__':
    
        import sys
    
        app = QApplication(sys.argv)
    
        player = Player(sys.argv[1:])
        player.show()
    
        sys.exit(app.exec_())
    
```
CC BY-SA 4.0
2019-01-22T21:42:23.513
52219
2019-01-30T11:18:05.090
26529
question
python3 pyqt5
pyqt5でwmvファイルの動画を再生するときにbrightnessなどを変化させたい
いまいち原理がよく分かりませんが、見よう見まねで書いた下のコードでとりあえず希望道理の動作はしました。Sliderを介して変数を変更すると何故か動きました。

```

    from PyQt5.QtCore import QDir, Qt, QUrl
    from PyQt5.QtMultimedia import QMediaContent, QMediaPlayer
    from PyQt5.QtMultimediaWidgets import QVideoWidget
    from PyQt5.QtWidgets import (QApplication, QFileDialog, QHBoxLayout, QLabel,
            QPushButton, QSizePolicy, QSlider, QStyle, QVBoxLayout, QGridLayout, QWidget)
    
    
    class VideoPlayer(QWidget):
    
        def __init__(self, parent=None):
            super(VideoPlayer, self).__init__(parent)
    
            self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
    
            self.videoWidget = QVideoWidget()
            self.videoWidget.setFixedSize(640,480)
    
            openButton = QPushButton("Open...")
            openButton.clicked.connect(self.openFile)
    
            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)
    
            controlLayout = QHBoxLayout()
            controlLayout.setContentsMargins(0, 0, 0, 0)
            controlLayout.addWidget(openButton)
            controlLayout.addWidget(self.playButton)
            controlLayout.addWidget(self.positionSlider)
    
            lbl1=QLabel("brightness")
            lbl2=QLabel("contrast")
            lbl3=QLabel("hue")
            lbl4=QLabel("saturation")
    
            self.sld1=QSlider(Qt.Horizontal)
            self.sld1.valueChanged[int].connect(self.changeValue1)
            self.sld1.setRange(-100,100)
            self.sld1.setValue(self.videoWidget.brightness())
    
            self.sld2=QSlider(Qt.Horizontal)
            self.sld2.valueChanged[int].connect(self.changeValue2)
            self.sld2.setRange(-100,100)
            self.sld2.setValue(self.videoWidget.contrast())
    
            self.sld3=QSlider(Qt.Horizontal)
            self.sld3.valueChanged[int].connect(self.changeValue3)
            self.sld3.setRange(-100,100)
            self.sld3.setValue(self.videoWidget.hue())
    
            self.sld4=QSlider(Qt.Horizontal)
            self.sld4.valueChanged[int].connect(self.changeValue4)
            self.sld4.setRange(-100,100)
            self.sld4.setValue(self.videoWidget.saturation())
    
            sldLayout=QGridLayout()
            sldLayout.addWidget(lbl1,0,0)
            sldLayout.addWidget(self.sld1,0,1)
            sldLayout.addWidget(lbl2,1,0)
            sldLayout.addWidget(self.sld2,1,1)
            sldLayout.addWidget(lbl3,2,0)
            sldLayout.addWidget(self.sld3,2,1)
            sldLayout.addWidget(lbl4,3,0)  
            sldLayout.addWidget(self.sld4,3,1) 
    
            layout = QVBoxLayout()
            layout.addWidget(self.videoWidget)
            layout.addLayout(controlLayout)
            layout.addLayout(sldLayout)
            layout.addWidget(self.errorLabel)
    
            self.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)
            """
            print(videoWidget.brightness())
            videoWidget.setBrightness(50)
            videoWidget.setContrast(100)
            videoWidget.setHue(100)
            videoWidget.setSaturation(100)
            print(videoWidget.brightness())
            """
    
        def changeValue1(self,value):
            self.videoWidget.setBrightness(value)
    
        def changeValue2(self,value):
            self.videoWidget.setContrast(value)
    
        def changeValue3(self,value):
            self.videoWidget.setHue(value)
    
        def changeValue4(self,value):
            self.videoWidget.setSaturation(value)
    
        def openFile(self):
            fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
                    QDir.homePath())
    
            if fileName != '':
                self.mediaPlayer.setMedia(
                        QMediaContent(QUrl.fromLocalFile(fileName)))
                self.playButton.setEnabled(True)
    
        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())
    
    
    if __name__ == '__main__':
    
        import sys
    
        app = QApplication(sys.argv)
    
        player = VideoPlayer()
        player.resize(320, 240)
        player.show()
    
        sys.exit(app.exec_())
    
```
CC BY-SA 4.0
2019-01-30T11:18:05.090
52427
2019-01-30T11:18:05.090
26529
52219
answer