Kivy-examples 2.3.1.dev0__py3-none-any.whl

kivy/uix/videoplayer.py

@@ -0,0 +1,697 @@
+'''
+Video player
+============
+
+.. versionadded:: 1.2.0
+
+The video player widget can be used to play video and let the user control the
+play/pausing, volume and position. The widget cannot be customized much because
+of the complex assembly of numerous base widgets.
+
+.. image:: images/videoplayer.jpg
+    :align: center
+
+Annotations
+-----------
+
+If you want to display text at a specific time and for a certain duration,
+consider annotations. An annotation file has a ".jsa" extension. The player
+will automatically load the associated annotation file if it exists.
+
+An annotation file is JSON-based, providing a list of label dictionary items.
+The key and value must match one of the :class:`VideoPlayerAnnotation` items.
+For example, here is a short version of a jsa file that you can find in
+`examples/widgets/cityCC0.jsa`::
+
+
+    [
+        {"start": 0, "duration": 2,
+        "text": "This is an example of annotation"},
+        {"start": 2, "duration": 2,
+        "bgcolor": [0.5, 0.2, 0.4, 0.5],
+        "text": "You can change the background color"}
+    ]
+
+For our cityCC0.mpg example, the result will be:
+
+.. image:: images/videoplayer-annotation.jpg
+    :align: center
+
+If you want to experiment with annotation files, test with::
+
+    python -m kivy.uix.videoplayer examples/widgets/cityCC0.mpg
+
+Fullscreen
+----------
+
+The video player can play the video in fullscreen, if
+:attr:`VideoPlayer.allow_fullscreen` is activated by a double-tap on
+the video. By default, if the video is smaller than the Window, it will be not
+stretched.
+
+You can allow stretching by passing custom options to a
+:class:`VideoPlayer` instance::
+
+    player = VideoPlayer(source='myvideo.avi', state='play',
+        options={'fit_mode': 'contain'})
+
+End-of-stream behavior
+----------------------
+
+You can specify what happens when the video has finished playing by passing an
+`eos` (end of stream) directive to the underlying
+:class:`~kivy.core.video.VideoBase` class. `eos` can be one of 'stop', 'pause'
+or 'loop' and defaults to 'stop'. For example, in order to loop the video::
+
+    player = VideoPlayer(source='myvideo.avi', state='play',
+        options={'eos': 'loop'})
+
+.. note::
+
+    The `eos` property of the VideoBase class is a string specifying the
+    end-of-stream behavior. This property differs from the `eos`
+    properties of the :class:`VideoPlayer` and
+    :class:`~kivy.uix.video.Video` classes, whose `eos`
+    property is simply a boolean indicating that the end of the file has
+    been reached.
+
+'''
+
+__all__ = ('VideoPlayer', 'VideoPlayerAnnotation')
+
+from json import load
+from os.path import exists
+from kivy.properties import ObjectProperty, StringProperty, BooleanProperty, \
+    NumericProperty, DictProperty, OptionProperty
+from kivy.animation import Animation
+from kivy.uix.gridlayout import GridLayout
+from kivy.uix.floatlayout import FloatLayout
+from kivy.uix.progressbar import ProgressBar
+from kivy.uix.label import Label
+from kivy.uix.video import Video
+from kivy.uix.video import Image
+from kivy.factory import Factory
+from kivy.logger import Logger
+from kivy.clock import Clock
+
+
+class VideoPlayerVolume(Image):
+    video = ObjectProperty(None)
+
+    def on_touch_down(self, touch):
+        if not self.collide_point(*touch.pos):
+            return False
+        touch.grab(self)
+        # save the current volume and delta to it
+        touch.ud[self.uid] = [self.video.volume, 0]
+        return True
+
+    def on_touch_move(self, touch):
+        if touch.grab_current is not self:
+            return
+        # calculate delta
+        dy = abs(touch.y - touch.oy)
+        if dy > 10:
+            dy = min(dy - 10, 100)
+            touch.ud[self.uid][1] = dy
+            self.video.volume = dy / 100.
+        return True
+
+    def on_touch_up(self, touch):
+        if touch.grab_current is not self:
+            return
+        touch.ungrab(self)
+        dy = abs(touch.y - touch.oy)
+        if dy < 10:
+            if self.video.volume > 0:
+                self.video.volume = 0
+            else:
+                self.video.volume = 1.
+
+
+class VideoPlayerPlayPause(Image):
+    video = ObjectProperty(None)
+
+    def on_touch_down(self, touch):
+        '''.. versionchanged:: 1.4.0'''
+        if self.collide_point(*touch.pos):
+            if self.video.state == 'play':
+                self.video.state = 'pause'
+            else:
+                self.video.state = 'play'
+            return True
+
+
+class VideoPlayerStop(Image):
+    video = ObjectProperty(None)
+
+    def on_touch_down(self, touch):
+        if self.collide_point(*touch.pos):
+            self.video.state = 'stop'
+            self.video.position = 0
+            return True
+
+
+class VideoPlayerProgressBar(ProgressBar):
+    video = ObjectProperty(None)
+    seek = NumericProperty(None, allownone=True)
+    alpha = NumericProperty(1.)
+
+    def __init__(self, **kwargs):
+        super(VideoPlayerProgressBar, self).__init__(**kwargs)
+        self.bubble = Factory.Bubble(size=(50, 44))
+        self.bubble_label = Factory.Label(text='0:00')
+        self.bubble.add_widget(self.bubble_label)
+        self.add_widget(self.bubble)
+
+        update = self._update_bubble
+        fbind = self.fbind
+        fbind('pos', update)
+        fbind('size', update)
+        fbind('seek', update)
+
+    def on_video(self, instance, value):
+        self.video.bind(position=self._update_bubble,
+                        state=self._showhide_bubble)
+
+    def on_touch_down(self, touch):
+        if not self.collide_point(*touch.pos):
+            return
+        self._show_bubble()
+        touch.grab(self)
+        self._update_seek(touch.x)
+        return True
+
+    def on_touch_move(self, touch):
+        if touch.grab_current is not self:
+            return
+        self._update_seek(touch.x)
+        return True
+
+    def on_touch_up(self, touch):
+        if touch.grab_current is not self:
+            return
+        touch.ungrab(self)
+        if self.seek:
+            self.video.seek(self.seek)
+        self.seek = None
+        self._hide_bubble()
+        return True
+
+    def _update_seek(self, x):
+        if self.width == 0:
+            return
+        x = max(self.x, min(self.right, x)) - self.x
+        self.seek = x / float(self.width)
+
+    def _show_bubble(self):
+        self.alpha = 1
+        Animation.stop_all(self, 'alpha')
+
+    def _hide_bubble(self):
+        self.alpha = 1.
+        Animation(alpha=0, d=4, t='in_out_expo').start(self)
+
+    def on_alpha(self, instance, value):
+        self.bubble.background_color = (1, 1, 1, value)
+        self.bubble_label.color = (1, 1, 1, value)
+
+    def _update_bubble(self, *l):
+        seek = self.seek
+        if self.seek is None:
+            if self.video.duration == 0:
+                seek = 0
+            else:
+                seek = self.video.position / self.video.duration
+        # convert to minutes:seconds
+        d = self.video.duration * seek
+        minutes = int(d / 60)
+        seconds = int(d - (minutes * 60))
+        # fix bubble label & position
+        self.bubble_label.text = '%d:%02d' % (minutes, seconds)
+        self.bubble.center_x = self.x + seek * self.width
+        self.bubble.y = self.top
+
+    def _showhide_bubble(self, instance, value):
+        if value == 'play':
+            self._hide_bubble()
+        else:
+            self._show_bubble()
+
+
+class VideoPlayerPreview(FloatLayout):
+    source = ObjectProperty(None)
+    video = ObjectProperty(None)
+    click_done = BooleanProperty(False)
+
+    def on_touch_down(self, touch):
+        if self.collide_point(*touch.pos) and not self.click_done:
+            self.click_done = True
+            self.video.state = 'play'
+        return True
+
+
+class VideoPlayerAnnotation(Label):
+    '''Annotation class used for creating annotation labels.
+
+    Additional keys are available:
+
+    * bgcolor: [r, g, b, a] - background color of the text box
+    * bgsource: 'filename' - background image used for the background text box
+    * border: (n, e, s, w) - border used for the background image
+
+    '''
+    start = NumericProperty(0)
+    '''Start time of the annotation.
+
+    :attr:`start` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 0.
+    '''
+
+    duration = NumericProperty(1)
+    '''Duration of the annotation.
+
+    :attr:`duration` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 1.
+    '''
+
+    annotation = DictProperty({})
+
+    def on_annotation(self, instance, ann):
+        for key, value in ann.items():
+            setattr(self, key, value)
+
+
+class VideoPlayer(GridLayout):
+    '''VideoPlayer class. See module documentation for more information.
+    '''
+
+    source = StringProperty('')
+    '''Source of the video to read.
+
+    :attr:`source` is a :class:`~kivy.properties.StringProperty` and
+    defaults to ''.
+
+    .. versionchanged:: 1.4.0
+    '''
+
+    thumbnail = StringProperty('')
+    '''Thumbnail of the video to show. If None, VideoPlayer will try to find
+    the thumbnail from the :attr:`source` + '.png'.
+
+    :attr:`thumbnail` a :class:`~kivy.properties.StringProperty` and defaults
+    to ''.
+
+    .. versionchanged:: 1.4.0
+    '''
+
+    duration = NumericProperty(-1)
+    '''Duration of the video. The duration defaults to -1 and is set to the
+    real duration when the video is loaded.
+
+    :attr:`duration` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to -1.
+    '''
+
+    position = NumericProperty(0)
+    '''Position of the video between 0 and :attr:`duration`. The position
+    defaults to -1 and is set to the real position when the video is loaded.
+
+    :attr:`position` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to -1.
+    '''
+
+    volume = NumericProperty(1.0)
+    '''Volume of the video in the range 0-1. 1 means full volume and 0 means
+    mute.
+
+    :attr:`volume` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 1.
+    '''
+
+    state = OptionProperty('stop', options=('play', 'pause', 'stop'))
+    '''String, indicates whether to play, pause, or stop the video::
+
+        # start playing the video at creation
+        video = VideoPlayer(source='movie.mkv', state='play')
+
+        # create the video, and start later
+        video = VideoPlayer(source='movie.mkv')
+        # and later
+        video.state = 'play'
+
+    :attr:`state` is an :class:`~kivy.properties.OptionProperty` and defaults
+    to 'stop'.
+    '''
+
+    play = BooleanProperty(False, deprecated=True)
+    '''
+    .. deprecated:: 1.4.0
+        Use :attr:`state` instead.
+
+    Boolean, indicates whether the video is playing or not. You can start/stop
+    the video by setting this property::
+
+        # start playing the video at creation
+        video = VideoPlayer(source='movie.mkv', play=True)
+
+        # create the video, and start later
+        video = VideoPlayer(source='movie.mkv')
+        # and later
+        video.play = True
+
+    :attr:`play` is a :class:`~kivy.properties.BooleanProperty` and defaults
+    to False.
+    '''
+
+    image_overlay_play = StringProperty(
+        'atlas://data/images/defaulttheme/player-play-overlay')
+    '''Image filename used to show a "play" overlay when the video has not yet
+    started.
+
+    :attr:`image_overlay_play` is a
+    :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/player-play-overlay'.
+
+    '''
+
+    image_loading = StringProperty('data/images/image-loading.zip')
+    '''Image filename used when the video is loading.
+
+    :attr:`image_loading` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'data/images/image-loading.zip'.
+    '''
+
+    image_play = StringProperty(
+        'atlas://data/images/defaulttheme/media-playback-start')
+    '''Image filename used for the "Play" button.
+
+    :attr:`image_play` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/media-playback-start'.
+    '''
+
+    image_stop = StringProperty(
+        'atlas://data/images/defaulttheme/media-playback-stop')
+    '''Image filename used for the "Stop" button.
+
+    :attr:`image_stop` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/media-playback-stop'.
+    '''
+
+    image_pause = StringProperty(
+        'atlas://data/images/defaulttheme/media-playback-pause')
+    '''Image filename used for the "Pause" button.
+
+    :attr:`image_pause` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/media-playback-pause'.
+    '''
+
+    image_volumehigh = StringProperty(
+        'atlas://data/images/defaulttheme/audio-volume-high')
+    '''Image filename used for the volume icon when the volume is high.
+
+    :attr:`image_volumehigh` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/audio-volume-high'.
+    '''
+
+    image_volumemedium = StringProperty(
+        'atlas://data/images/defaulttheme/audio-volume-medium')
+    '''Image filename used for the volume icon when the volume is medium.
+
+    :attr:`image_volumemedium` is a :class:`~kivy.properties.StringProperty`
+    and defaults to 'atlas://data/images/defaulttheme/audio-volume-medium'.
+    '''
+
+    image_volumelow = StringProperty(
+        'atlas://data/images/defaulttheme/audio-volume-low')
+    '''Image filename used for the volume icon when the volume is low.
+
+    :attr:`image_volumelow` is a :class:`~kivy.properties.StringProperty`
+    and defaults to 'atlas://data/images/defaulttheme/audio-volume-low'.
+    '''
+
+    image_volumemuted = StringProperty(
+        'atlas://data/images/defaulttheme/audio-volume-muted')
+    '''Image filename used for the volume icon when the volume is muted.
+
+    :attr:`image_volumemuted` is a :class:`~kivy.properties.StringProperty`
+    and defaults to 'atlas://data/images/defaulttheme/audio-volume-muted'.
+    '''
+
+    annotations = StringProperty('')
+    '''If set, it will be used for reading annotations box.
+
+    :attr:`annotations` is a :class:`~kivy.properties.StringProperty`
+    and defaults to ''.
+    '''
+
+    fullscreen = BooleanProperty(False)
+    '''Switch to fullscreen view. This should be used with care. When
+    activated, the widget will remove itself from its parent, remove all
+    children from the window and will add itself to it. When fullscreen is
+    unset, all the previous children are restored and the widget is restored to
+    its previous parent.
+
+    .. warning::
+
+        The re-add operation doesn't care about the index position of its
+        children within the parent.
+
+    :attr:`fullscreen` is a :class:`~kivy.properties.BooleanProperty`
+    and defaults to False.
+    '''
+
+    allow_fullscreen = BooleanProperty(True)
+    '''By default, you can double-tap on the video to make it fullscreen. Set
+    this property to False to prevent this behavior.
+
+    :attr:`allow_fullscreen` is a :class:`~kivy.properties.BooleanProperty`
+    defaults to True.
+    '''
+
+    options = DictProperty({})
+    '''Optional parameters can be passed to a :class:`~kivy.uix.video.Video`
+    instance with this property.
+
+    :attr:`options` a :class:`~kivy.properties.DictProperty` and
+    defaults to {}.
+    '''
+
+    # internals
+    container = ObjectProperty(None)
+
+    _video_load_ev = None
+
+    def __init__(self, **kwargs):
+        self._video = None
+        self._image = None
+        self._annotations = ''
+        self._annotations_labels = []
+        super(VideoPlayer, self).__init__(**kwargs)
+        update_thumbnail = self._update_thumbnail
+        update_annotations = self._update_annotations
+        fbind = self.fbind
+        fbind('thumbnail', update_thumbnail)
+        fbind('annotations', update_annotations)
+
+        if self.source:
+            self._trigger_video_load()
+
+    def _trigger_video_load(self, *largs):
+        ev = self._video_load_ev
+        if ev is None:
+            ev = self._video_load_ev = Clock.schedule_once(self._do_video_load,
+                                                           -1)
+        ev()
+
+    def _try_load_default_thumbnail(self, *largs):
+        if not self.thumbnail:
+            filename = self.source.rsplit('.', 1)
+            thumbnail = filename[0] + '.png'
+            if exists(thumbnail):
+                self._load_thumbnail(thumbnail)
+
+    def _try_load_default_annotations(self, *largs):
+        if not self.annotations:
+            filename = self.source.rsplit('.', 1)
+            annotations = filename[0] + '.jsa'
+            if exists(annotations):
+                self._load_annotations(annotations)
+
+    def on_source(self, instance, value):
+        # By default, VideoPlayer should look for thumbnail and annotations
+        # with the same filename (except extension) of the source (video) file.
+        Clock.schedule_once(self._try_load_default_thumbnail, -1)
+        Clock.schedule_once(self._try_load_default_annotations, -1)
+        if self._video is not None:
+            self._video.unload()
+            self._video = None
+        if value:
+            self._trigger_video_load()
+
+    def _update_thumbnail(self, *largs):
+        self._load_thumbnail(self.thumbnail)
+
+    def _update_annotations(self, *largs):
+        self._load_annotations(self.annotations)
+
+    def on_image_overlay_play(self, instance, value):
+        self._image.image_overlay_play = value
+
+    def on_image_loading(self, instance, value):
+        self._image.image_loading = value
+
+    def _load_thumbnail(self, thumbnail):
+        if not self.container:
+            return
+        self.container.clear_widgets()
+        if thumbnail:
+            self._image = VideoPlayerPreview(source=thumbnail, video=self)
+            self.container.add_widget(self._image)
+
+    def _load_annotations(self, annotations):
+        if not self.container:
+            return
+        self._annotations_labels = []
+        if annotations:
+            with open(annotations, 'r') as fd:
+                self._annotations = load(fd)
+            if self._annotations:
+                for ann in self._annotations:
+                    self._annotations_labels.append(
+                        VideoPlayerAnnotation(annotation=ann))
+
+    def on_state(self, instance, value):
+        if self._video is not None:
+            self._video.state = value
+
+    def _set_state(self, instance, value):
+        self.state = value
+
+    def _do_video_load(self, *largs):
+        self._video = Video(source=self.source, state=self.state,
+                            volume=self.volume, pos_hint={'x': 0, 'y': 0},
+                            **self.options)
+        self._video.bind(texture=self._play_started,
+                         duration=self.setter('duration'),
+                         position=self.setter('position'),
+                         volume=self.setter('volume'),
+                         state=self._set_state)
+
+    def on_play(self, instance, value):
+        value = 'play' if value else 'stop'
+        return self.on_state(instance, value)
+
+    def on_volume(self, instance, value):
+        if not self._video:
+            return
+        self._video.volume = value
+
+    def on_position(self, instance, value):
+        labels = self._annotations_labels
+        if not labels:
+            return
+        for label in labels:
+            start = label.start
+            duration = label.duration
+            if start > value or (start + duration) < value:
+                if label.parent:
+                    label.parent.remove_widget(label)
+            elif label.parent is None:
+                self.container.add_widget(label)
+
+    def seek(self, percent, precise=True):
+        '''Change the position to a percentage (strictly, a proportion)
+           of duration.
+
+        :Parameters:
+            `percent`: float or int
+                Position to seek as a proportion of total duration, must
+                be between 0-1.
+            `precise`: bool, defaults to True
+                Precise seeking is slower, but seeks to exact requested
+                percent.
+
+        .. warning::
+            Calling seek() before the video is loaded has no effect.
+
+        .. versionadded:: 1.2.0
+
+        .. versionchanged:: 1.10.1
+            The `precise` keyword argument has been added.
+        '''
+        if not self._video:
+            return
+        self._video.seek(percent, precise=precise)
+
+    def _play_started(self, instance, value):
+        self.container.clear_widgets()
+        self.container.add_widget(self._video)
+
+    def on_touch_down(self, touch):
+        if not self.collide_point(*touch.pos):
+            return False
+        if touch.is_double_tap and self.allow_fullscreen:
+            self.fullscreen = not self.fullscreen
+            return True
+        return super(VideoPlayer, self).on_touch_down(touch)
+
+    def on_fullscreen(self, instance, value):
+        window = self.get_parent_window()
+        if not window:
+            Logger.warning('VideoPlayer: Cannot switch to fullscreen, '
+                           'window not found.')
+            if value:
+                self.fullscreen = False
+            return
+        if not self.parent:
+            Logger.warning('VideoPlayer: Cannot switch to fullscreen, '
+                           'no parent.')
+            if value:
+                self.fullscreen = False
+            return
+
+        if value:
+            self._fullscreen_state = state = {
+                'parent': self.parent,
+                'pos': self.pos,
+                'size': self.size,
+                'pos_hint': self.pos_hint,
+                'size_hint': self.size_hint,
+                'window_children': window.children[:]}
+
+            # remove all window children
+            for child in window.children[:]:
+                window.remove_widget(child)
+
+            # put the video in fullscreen
+            if state['parent'] is not window:
+                state['parent'].remove_widget(self)
+            window.add_widget(self)
+
+            # ensure the video widget is in 0, 0, and the size will be
+            # readjusted
+            self.pos = (0, 0)
+            self.size = (100, 100)
+            self.pos_hint = {}
+            self.size_hint = (1, 1)
+        else:
+            state = self._fullscreen_state
+            window.remove_widget(self)
+            for child in state['window_children']:
+                window.add_widget(child)
+            self.pos_hint = state['pos_hint']
+            self.size_hint = state['size_hint']
+            self.pos = state['pos']
+            self.size = state['size']
+            if state['parent'] is not window:
+                state['parent'].add_widget(self)
+
+
+if __name__ == '__main__':
+    import sys
+    from kivy.base import runTouchApp
+    player = VideoPlayer(source=sys.argv[1])
+    runTouchApp(player)
+    if player:
+        player.state = 'stop'