← Back to branch summary

~raoul-snyman/openlp/upgrade-jquery-2.4

« back to all changes in this revision

Viewing changes to openlp/core/ui/media/systemplayer.py

  • Committer: Raoul Snyman
  • Date: 2016-10-22 22:17:02 UTC
  • mfrom: (2643.2.13 2.4)
  • Revision ID: raoul@snyman.info-20161022221702-otmym1zvlnlg6v4t
HEAD

Show diffs side-by-side

added added

removed removed

Lines of Context:
openlp/core/ui/media/systemplayer.py
100
100
            ext = '*%s' % extension
101
101
            if ext not in mime_type_list:
102
102
                mime_type_list.append(ext)
103
 
        log.info('MediaPlugin: %s extensions: %s' % (mimetype, ' '.join(extensions)))
 
103
        log.info('MediaPlugin: %s extensions: %s', mimetype, ' '.join(extensions))
104
104
 
105
105
    def setup(self, display):
106
106
        """
160
160
        if start_time > 0:
161
161
            self.seek(display, controller.media_info.start_time * 1000)
162
162
        self.volume(display, controller.media_info.volume)
 
163
        display.media_player.blockSignals(True)
 
164
        try:
 
165
            display.media_player.durationChanged.disconnect()
 
166
        except TypeError:
 
167
            # We get a type error if there are no slots attached to this signal, so ignore it
 
168
            pass
 
169
        display.media_player.blockSignals(False)
163
170
        display.media_player.durationChanged.connect(functools.partial(self.set_duration, controller))
164
171
        self.state = MediaState.Playing
165
172
        display.video_widget.raise_()
178
185
        Stop the current media item
179
186
        """
180
187
        display.media_player.blockSignals(True)
181
 
        display.media_player.durationChanged.disconnect()
 
188
        try:
 
189
            display.media_player.durationChanged.disconnect()
 
190
        except TypeError:
 
191
            # We get a type error if there are no slots attached to this signal, so ignore it
 
192
            pass
182
193
        display.media_player.blockSignals(False)
183
194
        display.media_player.stop()
184
195
        self.set_visible(display, False)
216
227
 
217
228
    @staticmethod
218
229
    def set_duration(controller, duration):
 
230
        """
 
231
        Set the length of the seek slider
 
232
        """
219
233
        controller.media_info.length = int(duration / 1000)
220
234
        controller.seek_slider.setMaximum(controller.media_info.length * 1000)
221
235
 
261
275
        :return: True if file can be played otherwise False
262
276
        """
263
277
        thread = QtCore.QThread()
264
 
        check_media_player = CheckMedia(path)
265
 
        check_media_player.setVolume(0)
266
 
        check_media_player.moveToThread(thread)
267
 
        check_media_player.finished.connect(thread.quit)
268
 
        thread.started.connect(check_media_player.play)
 
278
        check_media_worker = CheckMediaWorker(path)
 
279
        check_media_worker.setVolume(0)
 
280
        check_media_worker.moveToThread(thread)
 
281
        check_media_worker.finished.connect(thread.quit)
 
282
        thread.started.connect(check_media_worker.play)
269
283
        thread.start()
270
284
        while thread.isRunning():
271
285
            self.application.processEvents()
272
 
        return check_media_player.result
273
 
 
274
 
 
275
 
class CheckMedia(QtMultimedia.QMediaPlayer):
 
286
        return check_media_worker.result
 
287
 
 
288
 
 
289
class CheckMediaWorker(QtMultimedia.QMediaPlayer):
276
290
    """
277
291
    Class used to check if a media file is playable
278
292
    """
279
293
    finished = QtCore.pyqtSignal()
280
294
 
281
295
    def __init__(self, path):
282
 
        super(CheckMedia, self).__init__(None, QtMultimedia.QMediaPlayer.VideoSurface)
 
296
        super(CheckMediaWorker, self).__init__(None, QtMultimedia.QMediaPlayer.VideoSurface)
283
297
        self.result = None
284
 
 
285
298
        self.error.connect(functools.partial(self.signals, 'error'))
286
299
        self.mediaStatusChanged.connect(functools.partial(self.signals, 'media'))
287
 
 
288
300
        self.setMedia(QtMultimedia.QMediaContent(QtCore.QUrl.fromLocalFile(path)))
289
301
 
290
302
    def signals(self, origin, status):
 
303
        """
 
304
        Exit the worker and stop the thread when either an error or a media change is encountered
 
305
        """
291
306
        if origin == 'media' and status == self.BufferedMedia:
292
307
            self.result = True
293
308
            self.stop()