← Back to branch summary

~tomasgroth/openlp/portable-path

« back to all changes in this revision

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

  • Committer: Tomas Groth
  • Date: 2019-04-30 19:02:42 UTC
  • mfrom: (2829.2.32 openlp)
  • Revision ID: tomasgroth@yahoo.dk-20190430190242-6zwjk8724tyux70m
trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
openlp/core/ui/media/mediacontroller.py
4
4
###############################################################################
5
5
# OpenLP - Open Source Lyrics Projection                                      #
6
6
# --------------------------------------------------------------------------- #
7
 
# Copyright (c) 2008-2018 OpenLP Developers                                   #
 
7
# Copyright (c) 2008-2019 OpenLP Developers                                   #
8
8
# --------------------------------------------------------------------------- #
9
9
# This program is free software; you can redistribute it and/or modify it     #
10
10
# under the terms of the GNU General Public License as published by the Free  #
23
23
The :mod:`~openlp.core.ui.media.mediacontroller` module contains a base class for media components and other widgets
24
24
related to playing media, such as sliders.
25
25
"""
26
 
import datetime
27
26
import logging
28
 
import os
29
 
 
30
 
from PyQt5 import QtCore, QtWidgets
31
 
 
 
27
 
 
28
try:
 
29
    from pymediainfo import MediaInfo
 
30
    pymediainfo_available = True
 
31
except ImportError:
 
32
    pymediainfo_available = False
 
33
 
 
34
from subprocess import check_output
 
35
from PyQt5 import QtCore
 
36
 
 
37
from openlp.core.state import State
32
38
from openlp.core.api.http import register_endpoint
33
 
from openlp.core.common import extension_loader
34
 
from openlp.core.common.i18n import UiStrings, translate
 
39
from openlp.core.common.i18n import translate
35
40
from openlp.core.common.mixins import LogMixin, RegistryProperties
36
41
from openlp.core.common.registry import Registry, RegistryBase
37
42
from openlp.core.common.settings import Settings
38
 
from openlp.core.lib import ItemCapabilities
 
43
from openlp.core.lib.serviceitem import ItemCapabilities
39
44
from openlp.core.lib.ui import critical_error_message_box
40
45
from openlp.core.ui import DisplayControllerType
41
 
from openlp.core.ui.icons import UiIcons
42
 
from openlp.core.ui.media import MediaState, MediaInfo, MediaType, get_media_players, set_media_players, \
43
 
    parse_optical_path
 
46
from openlp.core.ui.media import MediaState, ItemMediaInfo, MediaType, parse_optical_path
44
47
from openlp.core.ui.media.endpoint import media_endpoint
45
 
from openlp.core.ui.media.mediaplayer import MediaPlayer
46
 
from openlp.core.ui.media.vendor.mediainfoWrapper import MediaInfoWrapper
47
 
from openlp.core.widgets.toolbar import OpenLPToolbar
 
48
from openlp.core.ui.media.vlcplayer import VlcPlayer, get_vlc
 
49
 
48
50
 
49
51
log = logging.getLogger(__name__)
50
52
 
51
53
TICK_TIME = 200
52
54
 
53
55
 
54
 
class MediaSlider(QtWidgets.QSlider):
55
 
    """
56
 
    Allows the mouse events of a slider to be overridden and extra functionality added
57
 
    """
58
 
    def __init__(self, direction, manager, controller):
59
 
        """
60
 
        Constructor
61
 
        """
62
 
        super(MediaSlider, self).__init__(direction)
63
 
        self.manager = manager
64
 
        self.controller = controller
65
 
        self.no_matching_player = translate('MediaPlugin.MediaItem', 'File %s not supported using player %s')
66
 
 
67
 
    def mouseMoveEvent(self, event):
68
 
        """
69
 
        Override event to allow hover time to be displayed.
70
 
 
71
 
        :param event: The triggering event
72
 
        """
73
 
        time_value = QtWidgets.QStyle.sliderValueFromPosition(self.minimum(), self.maximum(), event.x(), self.width())
74
 
        self.setToolTip('%s' % datetime.timedelta(seconds=int(time_value / 1000)))
75
 
        QtWidgets.QSlider.mouseMoveEvent(self, event)
76
 
 
77
 
    def mousePressEvent(self, event):
78
 
        """
79
 
        Mouse Press event no new functionality
80
 
 
81
 
        :param event: The triggering event
82
 
        """
83
 
        QtWidgets.QSlider.mousePressEvent(self, event)
84
 
 
85
 
    def mouseReleaseEvent(self, event):
86
 
        """
87
 
        Set the slider position when the mouse is clicked and released on the slider.
88
 
 
89
 
        :param event: The triggering event
90
 
        """
91
 
        self.setValue(QtWidgets.QStyle.sliderValueFromPosition(self.minimum(), self.maximum(), event.x(), self.width()))
92
 
        QtWidgets.QSlider.mouseReleaseEvent(self, event)
93
 
 
94
 
 
95
56
class MediaController(RegistryBase, LogMixin, RegistryProperties):
96
57
    """
97
58
    The implementation of the Media Controller. The Media Controller adds an own class for every Player.
110
71
        Constructor
111
72
        """
112
73
        super(MediaController, self).__init__(parent)
113
 
        self.media_players = {}
114
 
        self.display_controllers = {}
 
74
 
 
75
    def setup(self):
 
76
        self.vlc_player = None
115
77
        self.current_media_players = {}
116
78
        # Timer for video state
117
79
        self.live_timer = QtCore.QTimer()
134
96
        Registry().register_function('songs_hide', self.media_hide)
135
97
        Registry().register_function('songs_blank', self.media_blank)
136
98
        Registry().register_function('songs_unblank', self.media_unblank)
137
 
        Registry().register_function('mediaitem_media_rebuild', self._set_active_players)
138
99
        Registry().register_function('mediaitem_suffixes', self._generate_extensions_lists)
139
100
        register_endpoint(media_endpoint)
140
101
 
141
 
    def _set_active_players(self):
142
 
        """
143
 
        Set the active players and available media files
144
 
        """
145
 
        saved_players = get_media_players()[0]
146
 
        for player in list(self.media_players.keys()):
147
 
            self.media_players[player].is_active = player in saved_players
148
 
 
149
102
    def _generate_extensions_lists(self):
150
103
        """
151
104
        Set the active players and available media files
152
105
        """
153
106
        suffix_list = []
154
107
        self.audio_extensions_list = []
155
 
        for player in list(self.media_players.values()):
156
 
            if player.is_active:
157
 
                for item in player.audio_extensions_list:
158
 
                    if item not in self.audio_extensions_list:
159
 
                        self.audio_extensions_list.append(item)
160
 
                        suffix_list.append(item[2:])
 
108
        if self.vlc_player.is_active:
 
109
            for item in self.vlc_player.audio_extensions_list:
 
110
                if item not in self.audio_extensions_list:
 
111
                    self.audio_extensions_list.append(item)
 
112
                    suffix_list.append(item[2:])
161
113
        self.video_extensions_list = []
162
 
        for player in list(self.media_players.values()):
163
 
            if player.is_active:
164
 
                for item in player.video_extensions_list:
165
 
                    if item not in self.video_extensions_list:
166
 
                        self.video_extensions_list.append(item)
167
 
                        suffix_list.append(item[2:])
 
114
        if self.vlc_player.is_active:
 
115
            for item in self.vlc_player.video_extensions_list:
 
116
                if item not in self.video_extensions_list:
 
117
                    self.video_extensions_list.append(item)
 
118
                    suffix_list.append(item[2:])
168
119
        self.service_manager.supported_suffixes(suffix_list)
169
120
 
170
 
    def register_players(self, player):
171
 
        """
172
 
        Register each media Player (Webkit, Phonon, etc) and store
173
 
        for later use
174
 
 
175
 
        :param player: Individual player class which has been enabled
176
 
        """
177
 
        self.media_players[player.name] = player
178
 
 
179
121
    def bootstrap_initialise(self):
180
122
        """
181
123
        Check to see if we have any media Player's available.
182
124
        """
183
 
        controller_dir = os.path.join('core', 'ui', 'media')
184
 
        # Find all files that do not begin with '.' (lp:#1738047) and end with player.py
185
 
        glob_pattern = os.path.join(controller_dir, '[!.]*player.py')
186
 
        extension_loader(glob_pattern, ['mediaplayer.py'])
187
 
        player_classes = MediaPlayer.__subclasses__()
188
 
        for player_class in player_classes:
189
 
            self.register_players(player_class(self))
190
 
        if not self.media_players:
191
 
            return False
192
 
        saved_players, overridden_player = get_media_players()
193
 
        invalid_media_players = \
194
 
            [media_player for media_player in saved_players if media_player not in self.media_players or
195
 
                not self.media_players[media_player].check_available()]
196
 
        if invalid_media_players:
197
 
            for invalidPlayer in invalid_media_players:
198
 
                saved_players.remove(invalidPlayer)
199
 
            set_media_players(saved_players, overridden_player)
200
 
        self._set_active_players()
 
125
        self.setup()
 
126
        self.vlc_player = VlcPlayer(self)
 
127
        State().add_service("mediacontroller", 0)
 
128
        State().add_service("media_live", 0, requires="mediacontroller")
 
129
        if get_vlc() and pymediainfo_available:
 
130
            State().update_pre_conditions("mediacontroller", True)
 
131
            State().update_pre_conditions('media_live', True)
 
132
        else:
 
133
            State().missing_text("mediacontroller", translate('OpenLP.SlideController',
 
134
                                 "VLC or pymediainfo are missing, so you are unable to play any media"))
201
135
        self._generate_extensions_lists()
202
136
        return True
203
137
 
 
138
    def bootstrap_post_set_up(self):
 
139
        """
 
140
        Set up the controllers.
 
141
        :return:
 
142
        """
 
143
        try:
 
144
            self.setup_display(self.live_controller.display, False)
 
145
        except AttributeError:
 
146
            State().update_pre_conditions('media_live', False)
 
147
        self.setup_display(self.preview_controller.preview_display, True)
 
148
 
 
149
    def display_controllers(self, controller_type):
 
150
        """
 
151
        Decides which controller to use.
 
152
 
 
153
        :param controller_type: The controller type where a player will be placed
 
154
        """
 
155
        if controller_type == DisplayControllerType.Live:
 
156
            return self.live_controller
 
157
        else:
 
158
            return self.preview_controller
 
159
 
204
160
    def media_state_live(self):
205
161
        """
206
162
        Check if there is a running Live media Player and do updating stuff (e.g. update the UI)
207
163
        """
208
 
        display = self._define_display(self.display_controllers[DisplayControllerType.Live])
 
164
        display = self._define_display(self.display_controllers(DisplayControllerType.Live))
209
165
        if DisplayControllerType.Live in self.current_media_players:
210
166
            self.current_media_players[DisplayControllerType.Live].resize(display)
211
 
            self.current_media_players[DisplayControllerType.Live].update_ui(display)
212
 
            self.tick(self.display_controllers[DisplayControllerType.Live])
 
167
            self.current_media_players[DisplayControllerType.Live].update_ui(self.live_controller, display)
 
168
            self.tick(self.display_controllers(DisplayControllerType.Live))
213
169
            if self.current_media_players[DisplayControllerType.Live].get_live_state() is not MediaState.Playing:
214
170
                self.live_timer.stop()
215
171
        else:
216
172
            self.live_timer.stop()
217
 
            self.media_stop(self.display_controllers[DisplayControllerType.Live])
218
 
            if self.display_controllers[DisplayControllerType.Live].media_info.can_loop_playback:
219
 
                self.media_play(self.display_controllers[DisplayControllerType.Live], True)
 
173
            self.media_stop(self.display_controllers(DisplayControllerType.Live))
 
174
            if self.display_controllers(DisplayControllerType.Live).media_info.can_loop_playback:
 
175
                self.media_play(self.display_controllers(DisplayControllerType.Live), True)
220
176
 
221
177
    def media_state_preview(self):
222
178
        """
223
179
        Check if there is a running Preview media Player and do updating stuff (e.g. update the UI)
224
180
        """
225
 
        display = self._define_display(self.display_controllers[DisplayControllerType.Preview])
 
181
        display = self._define_display(self.display_controllers(DisplayControllerType.Preview))
226
182
        if DisplayControllerType.Preview in self.current_media_players:
227
183
            self.current_media_players[DisplayControllerType.Preview].resize(display)
228
 
            self.current_media_players[DisplayControllerType.Preview].update_ui(display)
229
 
            self.tick(self.display_controllers[DisplayControllerType.Preview])
 
184
            self.current_media_players[DisplayControllerType.Preview].update_ui(self.preview_controller, display)
 
185
            self.tick(self.display_controllers(DisplayControllerType.Preview))
230
186
            if self.current_media_players[DisplayControllerType.Preview].get_preview_state() is not MediaState.Playing:
231
187
                self.preview_timer.stop()
232
188
        else:
233
189
            self.preview_timer.stop()
234
 
            self.media_stop(self.display_controllers[DisplayControllerType.Preview])
235
 
            if self.display_controllers[DisplayControllerType.Preview].media_info.can_loop_playback:
236
 
                self.media_play(self.display_controllers[DisplayControllerType.Preview], True)
237
 
 
238
 
    def get_media_display_css(self):
239
 
        """
240
 
        Add css style sheets to htmlbuilder
241
 
        """
242
 
        css = ''
243
 
        for player in list(self.media_players.values()):
244
 
            if player.is_active:
245
 
                css += player.get_media_display_css()
246
 
        return css
247
 
 
248
 
    def get_media_display_javascript(self):
249
 
        """
250
 
        Add javascript functions to htmlbuilder
251
 
        """
252
 
        js = ''
253
 
        for player in list(self.media_players.values()):
254
 
            if player.is_active:
255
 
                js += player.get_media_display_javascript()
256
 
        return js
257
 
 
258
 
    def get_media_display_html(self):
259
 
        """
260
 
        Add html code to htmlbuilder
261
 
        """
262
 
        html = ''
263
 
        for player in list(self.media_players.values()):
264
 
            if player.is_active:
265
 
                html += player.get_media_display_html()
266
 
        return html
267
 
 
268
 
    def register_controller(self, controller):
269
 
        """
270
 
        Registers media controls where the players will be placed to run.
271
 
 
272
 
        :param controller: The controller where a player will be placed
273
 
        """
274
 
        self.display_controllers[controller.controller_type] = controller
275
 
        self.setup_generic_controls(controller)
276
 
 
277
 
    def setup_generic_controls(self, controller):
278
 
        """
279
 
        Set up controls on the control_panel for a given controller
280
 
 
281
 
        :param controller:  First element is the controller which should be used
282
 
        """
283
 
        controller.media_info = MediaInfo()
284
 
        # Build a Media ToolBar
285
 
        controller.mediabar = OpenLPToolbar(controller)
286
 
        controller.mediabar.add_toolbar_action('playbackPlay', text='media_playback_play',
287
 
                                               icon=UiIcons().play,
288
 
                                               tooltip=translate('OpenLP.SlideController', 'Start playing media.'),
289
 
                                               triggers=controller.send_to_plugins)
290
 
        controller.mediabar.add_toolbar_action('playbackPause', text='media_playback_pause',
291
 
                                               icon=UiIcons().pause,
292
 
                                               tooltip=translate('OpenLP.SlideController', 'Pause playing media.'),
293
 
                                               triggers=controller.send_to_plugins)
294
 
        controller.mediabar.add_toolbar_action('playbackStop', text='media_playback_stop',
295
 
                                               icon=UiIcons().stop,
296
 
                                               tooltip=translate('OpenLP.SlideController', 'Stop playing media.'),
297
 
                                               triggers=controller.send_to_plugins)
298
 
        controller.mediabar.add_toolbar_action('playbackLoop', text='media_playback_loop',
299
 
                                               icon=UiIcons().repeat, checked=False,
300
 
                                               tooltip=translate('OpenLP.SlideController', 'Loop playing media.'),
301
 
                                               triggers=controller.send_to_plugins)
302
 
        controller.position_label = QtWidgets.QLabel()
303
 
        controller.position_label.setText(' 00:00 / 00:00')
304
 
        controller.position_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
305
 
        controller.position_label.setToolTip(translate('OpenLP.SlideController', 'Video timer.'))
306
 
        controller.position_label.setMinimumSize(90, 0)
307
 
        controller.position_label.setObjectName('position_label')
308
 
        controller.mediabar.add_toolbar_widget(controller.position_label)
309
 
        # Build the seek_slider.
310
 
        controller.seek_slider = MediaSlider(QtCore.Qt.Horizontal, self, controller)
311
 
        controller.seek_slider.setMaximum(1000)
312
 
        controller.seek_slider.setTracking(True)
313
 
        controller.seek_slider.setMouseTracking(True)
314
 
        controller.seek_slider.setToolTip(translate('OpenLP.SlideController', 'Video position.'))
315
 
        controller.seek_slider.setGeometry(QtCore.QRect(90, 260, 221, 24))
316
 
        controller.seek_slider.setObjectName('seek_slider')
317
 
        controller.mediabar.add_toolbar_widget(controller.seek_slider)
318
 
        # Build the volume_slider.
319
 
        controller.volume_slider = QtWidgets.QSlider(QtCore.Qt.Horizontal)
320
 
        controller.volume_slider.setTickInterval(10)
321
 
        controller.volume_slider.setTickPosition(QtWidgets.QSlider.TicksAbove)
322
 
        controller.volume_slider.setMinimum(0)
323
 
        controller.volume_slider.setMaximum(100)
324
 
        controller.volume_slider.setTracking(True)
325
 
        controller.volume_slider.setToolTip(translate('OpenLP.SlideController', 'Audio Volume.'))
326
 
        controller.volume_slider.setValue(controller.media_info.volume)
327
 
        controller.volume_slider.setGeometry(QtCore.QRect(90, 160, 221, 24))
328
 
        controller.volume_slider.setObjectName('volume_slider')
329
 
        controller.mediabar.add_toolbar_widget(controller.volume_slider)
330
 
        controller.controller_layout.addWidget(controller.mediabar)
331
 
        controller.mediabar.setVisible(False)
332
 
        if not controller.is_live:
333
 
            controller.volume_slider.setEnabled(False)
334
 
        # Signals
335
 
        controller.seek_slider.valueChanged.connect(controller.send_to_plugins)
336
 
        controller.volume_slider.valueChanged.connect(controller.send_to_plugins)
 
190
            self.media_stop(self.display_controllers(DisplayControllerType.Preview))
 
191
            if self.display_controllers(DisplayControllerType.Preview).media_info.can_loop_playback:
 
192
                self.media_play(self.display_controllers(DisplayControllerType.Preview), True)
337
193
 
338
194
    def setup_display(self, display, preview):
339
195
        """
342
198
        :param display:  Display on which the output is to be played
343
199
        :param preview: Whether the display is a main or preview display
344
200
        """
345
 
        # clean up possible running old media files
346
 
        self.finalise()
347
 
        # update player status
348
 
        self._set_active_players()
 
201
        display.media_info = ItemMediaInfo()
349
202
        display.has_audio = True
350
 
        if display.is_live and preview:
351
 
            return
 
203
        # if display.is_live and preview:
 
204
        #     return
352
205
        if preview:
353
206
            display.has_audio = False
354
 
        for player in list(self.media_players.values()):
355
 
            if player.is_active:
356
 
                player.setup(display)
 
207
        self.vlc_player.setup(display, preview)
357
208
 
358
209
    def set_controls_visible(self, controller, value):
359
210
        """
364
215
        """
365
216
        # Generic controls
366
217
        controller.mediabar.setVisible(value)
367
 
        if controller.is_live and controller.display:
368
 
            if self.current_media_players and value:
369
 
                if self.current_media_players[controller.controller_type] != self.media_players['webkit']:
370
 
                    controller.display.set_transparency(False)
 
218
        # if controller.is_live and controller.display:
 
219
        #    if self.current_media_players and value:
 
220
        #       controller.display.set_transparency(False)
371
221
 
372
222
    @staticmethod
373
223
    def resize(display, player):
379
229
        """
380
230
        player.resize(display)
381
231
 
382
 
    def video(self, source, service_item, hidden=False, video_behind_text=False):
 
232
    def load_video(self, source, service_item, hidden=False, video_behind_text=False):
383
233
        """
384
234
        Loads and starts a video to run with the option of sound
385
235
 
388
238
        :param hidden: The player which is doing the playing
389
239
        :param video_behind_text: Is the video to be played behind text.
390
240
        """
391
 
        is_valid = False
392
 
        controller = self.display_controllers[source]
 
241
        is_valid = True
 
242
        controller = self.display_controllers(source)
393
243
        # stop running videos
394
244
        self.media_reset(controller)
395
 
        controller.media_info = MediaInfo()
 
245
        controller.media_info = ItemMediaInfo()
396
246
        controller.media_info.volume = controller.volume_slider.value()
397
247
        controller.media_info.is_background = video_behind_text
398
248
        # background will always loop video.
399
249
        controller.media_info.can_loop_playback = video_behind_text
400
 
        controller.media_info.file_info = QtCore.QFileInfo(service_item.get_frame_path())
 
250
        if service_item.is_capable(ItemCapabilities.HasBackgroundAudio):
 
251
            controller.media_info.file_info = service_item.background_audio
 
252
        else:
 
253
            controller.media_info.file_info = [service_item.get_frame_path()]
401
254
        display = self._define_display(controller)
402
255
        if controller.is_live:
403
256
            # if this is an optical device use special handling
410
263
            else:
411
264
                log.debug('video is not optical and live')
412
265
                controller.media_info.length = service_item.media_length
413
 
                is_valid = self._check_file_type(controller, display, service_item)
414
 
            display.override['theme'] = ''
415
 
            display.override['video'] = True
 
266
                is_valid = self._check_file_type(controller, display)
 
267
            # display.override['theme'] = ''
 
268
            # display.override['video'] = True
416
269
            if controller.media_info.is_background:
417
270
                # ignore start/end time
418
271
                controller.media_info.start_time = 0
430
283
            else:
431
284
                log.debug('video is not optical and preview')
432
285
                controller.media_info.length = service_item.media_length
433
 
                is_valid = self._check_file_type(controller, display, service_item)
 
286
                is_valid = self._check_file_type(controller, display)
434
287
        if not is_valid:
435
288
            # Media could not be loaded correctly
436
289
            critical_error_message_box(translate('MediaPlugin.MediaItem', 'Unsupported File'),
437
290
                                       translate('MediaPlugin.MediaItem', 'Unsupported File'))
438
291
            return False
439
 
        log.debug('video mediatype: ' + str(controller.media_info.media_type))
 
292
        log.debug('video media type: ' + str(controller.media_info.media_type))
440
293
        # dont care about actual theme, set a black background
441
 
        if controller.is_live and not controller.media_info.is_background:
442
 
            display.frame.evaluateJavaScript('show_video("setBackBoard", null, null,"visible");')
 
294
        # if controller.is_live and not controller.media_info.is_background:
 
295
        #    display.frame.runJavaScript('show_video("setBackBoard", null, null,"visible");')
443
296
        # now start playing - Preview is autoplay!
444
297
        autoplay = False
445
298
        # Preview requested
461
314
        return True
462
315
 
463
316
    @staticmethod
464
 
    def media_length(service_item):
 
317
    def media_length(media_path):
465
318
        """
466
319
        Uses Media Info to obtain the media length
467
320
 
468
 
        :param service_item: The ServiceItem containing the details to be played.
 
321
        :param media_path: The file path to be checked..
469
322
        """
470
 
        media_info = MediaInfo()
471
 
        media_info.volume = 0
472
 
        media_info.file_info = QtCore.QFileInfo(service_item.get_frame_path())
473
 
        media_data = MediaInfoWrapper.parse(service_item.get_frame_path())
 
323
        if MediaInfo.can_parse():
 
324
            media_data = MediaInfo.parse(media_path)
 
325
        else:
 
326
            xml = check_output(['mediainfo', '-f', '--Output=XML', '--Inform=OLDXML', media_path])
 
327
            if not xml.startswith(b'<?xml'):
 
328
                xml = check_output(['mediainfo', '-f', '--Output=XML', media_path])
 
329
            media_data = MediaInfo(xml.decode("utf-8"))
474
330
        # duration returns in milli seconds
475
 
        service_item.set_media_length(media_data.tracks[0].duration)
476
 
        return True
 
331
        return media_data.tracks[0].duration
477
332
 
478
333
    def media_setup_optical(self, filename, title, audio_track, subtitle_track, start, end, display, controller):
479
334
        """
492
347
        # stop running videos
493
348
        self.media_reset(controller)
494
349
        # Setup media info
495
 
        controller.media_info = MediaInfo()
 
350
        controller.media_info = ItemMediaInfo()
496
351
        controller.media_info.file_info = QtCore.QFileInfo(filename)
497
352
        if audio_track == -1 and subtitle_track == -1:
498
353
            controller.media_info.media_type = MediaType.CD
507
362
        # When called from mediaitem display is None
508
363
        if display is None:
509
364
            display = controller.preview_display
510
 
        # Find vlc player
511
 
        used_players = get_media_players()[0]
512
 
        vlc_player = None
513
 
        for title in used_players:
514
 
            player = self.media_players[title]
515
 
            if player.name == 'vlc':
516
 
                vlc_player = player
517
 
        if vlc_player is None:
518
 
            critical_error_message_box(translate('MediaPlugin.MediaItem', 'VLC player required'),
519
 
                                       translate('MediaPlugin.MediaItem',
520
 
                                                 'VLC player required for playback of optical devices'))
521
 
            return False
522
 
        vlc_player.load(display)
523
 
        self.resize(display, vlc_player)
524
 
        self.current_media_players[controller.controller_type] = vlc_player
 
365
        self.vlc_player.load(display, filename)
 
366
        self.resize(display, self.vlc_player)
 
367
        self.current_media_players[controller.controller_type] = self.vlc_player
525
368
        if audio_track == -1 and subtitle_track == -1:
526
369
            controller.media_info.media_type = MediaType.CD
527
370
        else:
528
371
            controller.media_info.media_type = MediaType.DVD
529
372
        return True
530
373
 
531
 
    @staticmethod
532
 
    def _get_used_players(service_item):
533
 
        """
534
 
        Find the player for a given service item
535
 
 
536
 
        :param service_item: where the information is about the media and required player
537
 
        :return: player description
538
 
        """
539
 
        used_players = get_media_players()[0]
540
 
        # If no player, we can't play
541
 
        if not used_players:
542
 
            return False
543
 
        default_player = [used_players[0]]
544
 
        if service_item.processor and service_item.processor != UiStrings().Automatic:
545
 
            # check to see if the player is usable else use the default one.
546
 
            if service_item.processor.lower() not in used_players:
547
 
                used_players = default_player
548
 
            else:
549
 
                used_players = [service_item.processor.lower()]
550
 
        return used_players
551
 
 
552
 
    def _check_file_type(self, controller, display, service_item):
 
374
    def _check_file_type(self, controller, display):
553
375
        """
554
376
        Select the correct media Player type from the prioritized Player list
555
377
 
556
378
        :param controller: First element is the controller which should be used
557
379
        :param display: Which display to use
558
 
        :param service_item: The ServiceItem containing the details to be played.
559
380
        """
560
 
        used_players = self._get_used_players(service_item)
561
 
        if controller.media_info.file_info.isFile():
562
 
            suffix = '*.%s' % controller.media_info.file_info.suffix().lower()
563
 
            for title in used_players:
564
 
                if not title:
565
 
                    continue
566
 
                player = self.media_players[title]
567
 
                if suffix in player.video_extensions_list:
 
381
        for file in controller.media_info.file_info:
 
382
            if file.is_file:
 
383
                suffix = '*%s' % file.suffix.lower()
 
384
                file = str(file)
 
385
                if suffix in self.vlc_player.video_extensions_list:
568
386
                    if not controller.media_info.is_background or controller.media_info.is_background and \
569
 
                            player.can_background:
570
 
                        self.resize(display, player)
571
 
                        if player.load(display):
572
 
                            self.current_media_players[controller.controller_type] = player
 
387
                            self.vlc_player.can_background:
 
388
                        self.resize(display, self.vlc_player)
 
389
                        if self.vlc_player.load(display, file):
 
390
                            self.current_media_players[controller.controller_type] = self.vlc_player
573
391
                            controller.media_info.media_type = MediaType.Video
574
392
                            return True
575
 
                if suffix in player.audio_extensions_list:
576
 
                    if player.load(display):
577
 
                        self.current_media_players[controller.controller_type] = player
 
393
                if suffix in self.vlc_player.audio_extensions_list:
 
394
                    if self.vlc_player.load(display, file):
 
395
                        self.current_media_players[controller.controller_type] = self.vlc_player
578
396
                        controller.media_info.media_type = MediaType.Audio
579
397
                        return True
580
 
        else:
581
 
            for title in used_players:
582
 
                player = self.media_players[title]
583
 
                if player.can_folder:
584
 
                    self.resize(display, player)
585
 
                    if player.load(display):
586
 
                        self.current_media_players[controller.controller_type] = player
 
398
            else:
 
399
                file = str(file)
 
400
                if self.vlc_player.can_folder:
 
401
                    self.resize(display, self.vlc_player)
 
402
                    if self.vlc_player.load(display, file):
 
403
                        self.current_media_players[controller.controller_type] = self.vlc_player
587
404
                        controller.media_info.media_type = MediaType.Video
588
405
                        return True
589
 
        # no valid player found
590
406
        return False
591
407
 
592
408
    def media_play_msg(self, msg, status=True):
601
417
    def on_media_play(self):
602
418
        """
603
419
        Responds to the request to play a loaded video from the web.
604
 
 
605
 
        :param msg: First element is the controller which should be used
606
420
        """
607
421
        self.media_play(Registry().get('live_controller'), False)
608
422
 
616
430
        controller.seek_slider.blockSignals(True)
617
431
        controller.volume_slider.blockSignals(True)
618
432
        display = self._define_display(controller)
619
 
        if not self.current_media_players[controller.controller_type].play(display):
 
433
        if not self.current_media_players[controller.controller_type].play(controller, display):
620
434
            controller.seek_slider.blockSignals(False)
621
435
            controller.volume_slider.blockSignals(False)
622
436
            return False
625
439
        else:
626
440
            self.media_volume(controller, controller.media_info.volume)
627
441
        if first_time:
628
 
            if not controller.media_info.is_background:
629
 
                display.frame.evaluateJavaScript('show_blank("desktop");')
 
442
            # if not controller.media_info.is_background:
 
443
            #    display.frame.runJavaScript('show_blank("desktop");')
630
444
            self.current_media_players[controller.controller_type].set_visible(display, True)
631
445
            controller.mediabar.actions['playbackPlay'].setVisible(False)
632
446
            controller.mediabar.actions['playbackPause'].setVisible(True)
683
497
    def on_media_pause(self):
684
498
        """
685
499
        Responds to the request to pause a loaded video from the web.
686
 
 
687
 
        :param msg: First element is the controller which should be used
688
500
        """
689
501
        self.media_pause(Registry().get('live_controller'))
690
502
 
731
543
    def on_media_stop(self):
732
544
        """
733
545
        Responds to the request to stop a loaded video from the web.
734
 
 
735
 
        :param msg: First element is the controller which should be used
736
546
        """
737
547
        self.media_stop(Registry().get('live_controller'))
738
548
 
745
555
        """
746
556
        display = self._define_display(controller)
747
557
        if controller.controller_type in self.current_media_players:
748
 
            if not looping_background:
749
 
                display.frame.evaluateJavaScript('show_blank("black");')
 
558
            # if not looping_background:
 
559
            #    display.frame.runJavaScript('show_blank("black");')
750
560
            self.current_media_players[controller.controller_type].stop(display)
751
561
            self.current_media_players[controller.controller_type].set_visible(display, False)
752
562
            controller.seek_slider.setSliderPosition(0)
817
627
            display.override = {}
818
628
            self.current_media_players[controller.controller_type].reset(display)
819
629
            self.current_media_players[controller.controller_type].set_visible(display, False)
820
 
            display.frame.evaluateJavaScript('show_video("setBackBoard", null, null, "hidden");')
 
630
            # display.frame.runJavaScript('show_video("setBackBoard", null, null, "hidden");')
821
631
            del self.current_media_players[controller.controller_type]
822
632
 
823
633
    def media_hide(self, msg):
880
690
        """
881
691
        self.live_timer.stop()
882
692
        self.preview_timer.stop()
883
 
        for controller in self.display_controllers:
884
 
            self.media_reset(self.display_controllers[controller])
 
693
        self.media_reset(self.display_controllers(DisplayControllerType.Live))
 
694
        self.media_reset(self.display_controllers(DisplayControllerType.Preview))
885
695
 
886
696
    @staticmethod
887
697
    def _define_display(controller):