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

kivy/core/audio/audio_avplayer.py

@@ -0,0 +1,82 @@
+'''
+AudioAvplayer: implementation of Sound using pyobjus / AVFoundation.
+Works on iOS / OSX.
+'''
+
+__all__ = ('SoundAvplayer', )
+
+from kivy.core.audio import Sound, SoundLoader
+from pyobjus import autoclass, protocol
+from pyobjus.dylib_manager import load_framework, INCLUDE
+
+load_framework(INCLUDE.AVFoundation)
+AVAudioPlayer = autoclass("AVAudioPlayer")
+NSURL = autoclass("NSURL")
+NSString = autoclass("NSString")
+
+
+class SoundAvplayer(Sound):
+    @staticmethod
+    def extensions():
+        # taken from https://goo.gl/015kvU
+        return ("aac", "adts", "aif", "aiff", "aifc", "caf", "mp3", "mp4",
+                "m4a", "snd", "au", "sd2", "wav")
+
+    def __init__(self, **kwargs):
+        self._avplayer = None
+        super(SoundAvplayer, self).__init__(**kwargs)
+
+    def load(self):
+        self.unload()
+        fn = NSString.alloc().initWithUTF8String_(self.source)
+        url = NSURL.alloc().initFileURLWithPath_(fn)
+        self._avplayer = AVAudioPlayer.alloc().initWithContentsOfURL_error_(
+            url, None)
+
+    def unload(self):
+        self.stop()
+        self._avplayer = None
+
+    def play(self):
+        if not self._avplayer:
+            return
+        self._avplayer.delegate = self
+        self._avplayer.play()
+        super(SoundAvplayer, self).play()
+
+    def stop(self):
+        if not self._avplayer:
+            return
+        self._avplayer.delegate = None
+        self._avplayer.stop()
+        super(SoundAvplayer, self).stop()
+
+    def seek(self, position):
+        if not self._avplayer:
+            return
+        avplayer = self._avplayer
+        avplayer.stop()
+        avplayer.currentTime = float(position)
+        if self.state == 'play':
+            avplayer.play()
+
+    def get_pos(self):
+        if self._avplayer:
+            return self._avplayer.currentTime
+        return super(SoundAvplayer, self).get_pos()
+
+    def on_volume(self, instance, volume):
+        if self._avplayer:
+            self._avplayer.volume = float(volume)
+
+    def _get_length(self):
+        if self._avplayer:
+            return self._avplayer.duration
+        return super(SoundAvplayer, self)._get_length()
+
+    @protocol("AVAudioPlayerDelegate")
+    def audioPlayerDidFinishPlaying_successfully_(self, player, flag):
+        self.stop()
+
+
+SoundLoader.register(SoundAvplayer)

kivy/core/audio/audio_ffpyplayer.py

@@ -0,0 +1,185 @@
+'''
+FFmpeg based audio player
+=========================
+
+To use, you need to install ffpyplayer and have a compiled ffmpeg shared
+library.
+
+    https://github.com/matham/ffpyplayer
+
+The docs there describe how to set this up. But briefly, first you need to
+compile ffmpeg using the shared flags while disabling the static flags (you'll
+probably have to set the fPIC flag, e.g. CFLAGS=-fPIC). Here's some
+instructions: https://trac.ffmpeg.org/wiki/CompilationGuide. For Windows, you
+can download compiled GPL binaries from http://ffmpeg.zeranoe.com/builds/.
+Similarly, you should download SDL.
+
+Now, you should a ffmpeg and sdl directory. In each, you should have a include,
+bin, and lib directory, where e.g. for Windows, lib contains the .dll.a files,
+while bin contains the actual dlls. The include directory holds the headers.
+The bin directory is only needed if the shared libraries are not already on
+the path. In the environment define FFMPEG_ROOT and SDL_ROOT, each pointing to
+the ffmpeg, and SDL directories, respectively. (If you're using SDL2,
+the include directory will contain a directory called SDL2, which then holds
+the headers).
+
+Once defined, download the ffpyplayer git and run
+
+    python setup.py build_ext --inplace
+
+Finally, before running you need to ensure that ffpyplayer is in python's path.
+
+..Note::
+
+    When kivy exits by closing the window while the audio is playing,
+    it appears that the __del__method of SoundFFPy
+    is not called. Because of this the SoundFFPy object is not
+    properly deleted when kivy exits. The consequence is that because
+    MediaPlayer creates internal threads which do not have their daemon
+    flag set, when the main threads exists it'll hang and wait for the other
+    MediaPlayer threads to exit. But since __del__ is not called to delete the
+    MediaPlayer object, those threads will remain alive hanging kivy. What this
+    means is that you have to be sure to delete the MediaPlayer object before
+    kivy exits by setting it to None.
+'''
+
+__all__ = ('SoundFFPy', )
+
+try:
+    import ffpyplayer
+    from ffpyplayer.player import MediaPlayer
+    from ffpyplayer.tools import set_log_callback, get_log_callback, formats_in
+except:
+    raise
+
+
+from kivy.clock import Clock
+from kivy.logger import Logger
+from kivy.core.audio import Sound, SoundLoader
+from kivy.weakmethod import WeakMethod
+import time
+
+try:
+    Logger.info(
+        'SoundFFPy: Using ffpyplayer {}'.format(ffpyplayer.__version__))
+except:
+    Logger.info('SoundFFPy: Using ffpyplayer {}'.format(ffpyplayer.version))
+
+
+logger_func = {'quiet': Logger.critical, 'panic': Logger.critical,
+               'fatal': Logger.critical, 'error': Logger.error,
+               'warning': Logger.warning, 'info': Logger.info,
+               'verbose': Logger.debug, 'debug': Logger.debug}
+
+
+def _log_callback(message, level):
+    message = message.strip()
+    if message:
+        logger_func[level]('ffpyplayer: {}'.format(message))
+
+
+class SoundFFPy(Sound):
+
+    @staticmethod
+    def extensions():
+        return formats_in
+
+    def __init__(self, **kwargs):
+        self._ffplayer = None
+        self.quitted = False
+        self._log_callback_set = False
+        self._state = ''
+        self.state = 'stop'
+
+        if not get_log_callback():
+            set_log_callback(_log_callback)
+            self._log_callback_set = True
+
+        super(SoundFFPy, self).__init__(**kwargs)
+
+    def __del__(self):
+        self.unload()
+        if self._log_callback_set:
+            set_log_callback(None)
+
+    def _player_callback(self, selector, value):
+        if self._ffplayer is None:
+            return
+        if selector == 'quit':
+            def close(*args):
+                self.quitted = True
+                self.unload()
+            Clock.schedule_once(close, 0)
+        elif selector == 'eof':
+            Clock.schedule_once(self._do_eos, 0)
+
+    def load(self):
+        self.unload()
+        ff_opts = {'vn': True, 'sn': True}  # only audio
+        self._ffplayer = MediaPlayer(self.source,
+                                     callback=self._player_callback,
+                                     loglevel='info', ff_opts=ff_opts)
+        player = self._ffplayer
+        player.set_volume(self.volume)
+        player.toggle_pause()
+        self._state = 'paused'
+        # wait until loaded or failed, shouldn't take long, but just to make
+        # sure metadata is available.
+        s = time.perf_counter()
+        while (player.get_metadata()['duration'] is None and
+               not self.quitted and time.perf_counter() - s < 10.):
+            time.sleep(0.005)
+
+    def unload(self):
+        if self._ffplayer:
+            self._ffplayer = None
+        self._state = ''
+        self.state = 'stop'
+        self.quitted = False
+
+    def play(self):
+        if self._state == 'playing':
+            super(SoundFFPy, self).play()
+            return
+        if not self._ffplayer:
+            self.load()
+        self._ffplayer.toggle_pause()
+        self._state = 'playing'
+        self.state = 'play'
+        super(SoundFFPy, self).play()
+        self.seek(0)
+
+    def stop(self):
+        if self._ffplayer and self._state == 'playing':
+            self._ffplayer.toggle_pause()
+            self._state = 'paused'
+            self.state = 'stop'
+        super(SoundFFPy, self).stop()
+
+    def seek(self, position):
+        if self._ffplayer is None:
+            return
+        self._ffplayer.seek(position, relative=False)
+
+    def get_pos(self):
+        if self._ffplayer is not None:
+            return self._ffplayer.get_pts()
+        return 0
+
+    def on_volume(self, instance, volume):
+        if self._ffplayer is not None:
+            self._ffplayer.set_volume(volume)
+
+    def _get_length(self):
+        if self._ffplayer is None:
+            return super(SoundFFPy, self)._get_length()
+        return self._ffplayer.get_metadata()['duration']
+
+    def _do_eos(self, *args):
+        if not self.loop:
+            self.stop()
+        else:
+            self.seek(0.)
+
+
+SoundLoader.register(SoundFFPy)

kivy/core/audio/audio_gstplayer.py

@@ -0,0 +1,101 @@
+'''
+Audio Gstplayer
+===============
+
+.. versionadded:: 1.8.0
+
+Implementation of a VideoBase with Kivy :class:`~kivy.lib.gstplayer.GstPlayer`
+This player is the preferred player, using Gstreamer 1.0, working on both
+Python 2 and 3.
+'''
+
+from kivy.lib.gstplayer import GstPlayer, get_gst_version
+from kivy.core.audio import Sound, SoundLoader
+from kivy.logger import Logger
+from kivy.compat import PY2
+from kivy.clock import Clock
+from os.path import realpath
+
+if PY2:
+    from urllib import pathname2url
+else:
+    from urllib.request import pathname2url
+
+Logger.info('AudioGstplayer: Using Gstreamer {}'.format(
+    '.'.join(map(str, get_gst_version()))))
+
+
+def _on_gstplayer_message(mtype, message):
+    if mtype == 'error':
+        Logger.error('AudioGstplayer: {}'.format(message))
+    elif mtype == 'warning':
+        Logger.warning('AudioGstplayer: {}'.format(message))
+    elif mtype == 'info':
+        Logger.info('AudioGstplayer: {}'.format(message))
+
+
+class SoundGstplayer(Sound):
+
+    @staticmethod
+    def extensions():
+        return ('wav', 'ogg', 'mp3', 'm4a', 'flac', 'mp4')
+
+    def __init__(self, **kwargs):
+        self.player = None
+        super(SoundGstplayer, self).__init__(**kwargs)
+
+    def _on_gst_eos_sync(self):
+        Clock.schedule_once(self._on_gst_eos, 0)
+
+    def _on_gst_eos(self, *dt):
+        if self.loop:
+            self.player.stop()
+            self.player.play()
+        else:
+            self.stop()
+
+    def load(self):
+        self.unload()
+        uri = self._get_uri()
+        self.player = GstPlayer(uri, None, self._on_gst_eos_sync,
+                                _on_gstplayer_message)
+        self.player.load()
+
+    def play(self):
+        # we need to set the volume everytime, it seems that stopping + playing
+        # the sound reset the volume.
+        self.player.set_volume(self.volume)
+        self.player.play()
+        super(SoundGstplayer, self).play()
+
+    def stop(self):
+        self.player.stop()
+        super(SoundGstplayer, self).stop()
+
+    def unload(self):
+        if self.player:
+            self.player.unload()
+            self.player = None
+
+    def seek(self, position):
+        self.player.seek(position / self.length)
+
+    def get_pos(self):
+        return self.player.get_position()
+
+    def _get_length(self):
+        return self.player.get_duration()
+
+    def on_volume(self, instance, volume):
+        self.player.set_volume(volume)
+
+    def _get_uri(self):
+        uri = self.source
+        if not uri:
+            return
+        if '://' not in uri:
+            uri = 'file:' + pathname2url(realpath(uri))
+        return uri
+
+
+SoundLoader.register(SoundGstplayer)

kivy/core/audio/audio_pygame.py

@@ -0,0 +1,127 @@
+'''
+AudioPygame: implementation of Sound with Pygame
+
+.. warning::
+
+    Pygame has been deprecated and will be removed in the release after Kivy
+    1.11.0.
+'''
+
+__all__ = ('SoundPygame', )
+
+from kivy.clock import Clock
+from kivy.utils import platform, deprecated
+from kivy.core.audio import Sound, SoundLoader
+
+_platform = platform
+try:
+    if _platform == 'android':
+        try:
+            import android.mixer as mixer
+        except ImportError:
+            # old python-for-android version
+            import android_mixer as mixer
+    else:
+        from pygame import mixer
+except:
+    raise
+
+# init pygame sound
+mixer.pre_init(44100, -16, 2, 1024)
+mixer.init()
+mixer.set_num_channels(32)
+
+
+class SoundPygame(Sound):
+
+    # XXX we don't set __slots__ here, to automatically add
+    # a dictionary. We need that to be able to use weakref for
+    # SoundPygame object. Otherwise, it failed with:
+    # TypeError: cannot create weak reference to 'SoundPygame' object
+    # We use our clock in play() method.
+    # __slots__ = ('_data', '_channel')
+    _check_play_ev = None
+
+    @staticmethod
+    def extensions():
+        if _platform == 'android':
+            return ('wav', 'ogg', 'mp3', 'm4a')
+        return ('wav', 'ogg')
+
+    @deprecated(
+        msg='Pygame has been deprecated and will be removed after 1.11.0')
+    def __init__(self, **kwargs):
+        self._data = None
+        self._channel = None
+        super(SoundPygame, self).__init__(**kwargs)
+
+    def _check_play(self, dt):
+        if self._channel is None:
+            return False
+        if self._channel.get_busy():
+            return
+        if self.loop:
+            def do_loop(dt):
+                self.play()
+            Clock.schedule_once(do_loop)
+        else:
+            self.stop()
+        return False
+
+    def play(self):
+        if not self._data:
+            return
+        self._data.set_volume(self.volume)
+        self._channel = self._data.play()
+        self.start_time = Clock.time()
+        # schedule event to check if the sound is still playing or not
+        self._check_play_ev = Clock.schedule_interval(self._check_play, 0.1)
+        super(SoundPygame, self).play()
+
+    def stop(self):
+        if not self._data:
+            return
+        self._data.stop()
+        # ensure we don't have anymore the callback
+        if self._check_play_ev is not None:
+            self._check_play_ev.cancel()
+            self._check_play_ev = None
+        self._channel = None
+        super(SoundPygame, self).stop()
+
+    def load(self):
+        self.unload()
+        if self.source is None:
+            return
+        self._data = mixer.Sound(self.source)
+
+    def unload(self):
+        self.stop()
+        self._data = None
+
+    def seek(self, position):
+        if not self._data:
+            return
+        if _platform == 'android' and self._channel:
+            self._channel.seek(position)
+
+    def get_pos(self):
+        if self._data is not None and self._channel:
+            if _platform == 'android':
+                return self._channel.get_pos()
+            return Clock.time() - self.start_time
+        return 0
+
+    def on_volume(self, instance, volume):
+        if self._data is not None:
+            self._data.set_volume(volume)
+
+    def _get_length(self):
+        if _platform == 'android' and self._channel:
+            return self._channel.get_length()
+        if self._data is not None:
+            return self._data.get_length()
+        return super(SoundPygame, self)._get_length()
+
+
+SoundLoader.register(SoundPygame)

kivy/core/camera/__init__.py

@@ -0,0 +1,151 @@
+'''
+Camera
+======
+
+Core class for acquiring the camera and converting its input into a
+:class:`~kivy.graphics.texture.Texture`.
+
+.. versionchanged:: 1.10.0
+    The pygst and videocapture providers have been removed.
+
+.. versionchanged:: 1.8.0
+    There is now 2 distinct Gstreamer implementation: one using Gi/Gst
+    working for both Python 2+3 with Gstreamer 1.0, and one using PyGST
+    working only for Python 2 + Gstreamer 0.10.
+'''
+
+__all__ = ('CameraBase', 'Camera')
+
+
+from kivy.utils import platform
+from kivy.event import EventDispatcher
+from kivy.logger import Logger
+from kivy.core import core_select_lib
+
+
+class CameraBase(EventDispatcher):
+    '''Abstract Camera Widget class.
+
+    Concrete camera classes must implement initialization and
+    frame capturing to a buffer that can be uploaded to the gpu.
+
+    :Parameters:
+        `index`: int
+            Source index of the camera.
+        `size`: tuple (int, int)
+            Size at which the image is drawn. If no size is specified,
+            it defaults to the resolution of the camera image.
+        `resolution`: tuple (int, int)
+            Resolution to try to request from the camera.
+            Used in the gstreamer pipeline by forcing the appsink caps
+            to this resolution. If the camera doesn't support the resolution,
+            a negotiation error might be thrown.
+
+    :Events:
+        `on_load`
+            Fired when the camera is loaded and the texture has become
+            available.
+        `on_texture`
+            Fired each time the camera texture is updated.
+    '''
+
+    __events__ = ('on_load', 'on_texture')
+
+    def __init__(self, **kwargs):
+        kwargs.setdefault('stopped', False)
+        kwargs.setdefault('resolution', (640, 480))
+        kwargs.setdefault('index', 0)
+
+        self.stopped = kwargs.get('stopped')
+        self._resolution = kwargs.get('resolution')
+        self._index = kwargs.get('index')
+        self._buffer = None
+        self._format = 'rgb'
+        self._texture = None
+        self.capture_device = None
+        kwargs.setdefault('size', self._resolution)
+
+        super(CameraBase, self).__init__()
+
+        self.init_camera()
+
+        if not self.stopped:
+            self.start()
+
+    def _set_resolution(self, res):
+        self._resolution = res
+        self.init_camera()
+
+    def _get_resolution(self):
+        return self._resolution
+
+    resolution = property(lambda self: self._get_resolution(),
+                          lambda self, x: self._set_resolution(x),
+                          doc='Resolution of camera capture (width, height)')
+
+    def _set_index(self, x):
+        if x == self._index:
+            return
+        self._index = x
+        self.init_camera()
+
+    def _get_index(self):
+        return self._x
+
+    index = property(lambda self: self._get_index(),
+                     lambda self, x: self._set_index(x),
+                     doc='Source index of the camera')
+
+    def _get_texture(self):
+        return self._texture
+    texture = property(lambda self: self._get_texture(),
+                       doc='Return the camera texture with the latest capture')
+
+    def init_camera(self):
+        '''Initialize the camera (internal)'''
+        pass
+
+    def start(self):
+        '''Start the camera acquire'''
+        self.stopped = False
+
+    def stop(self):
+        '''Release the camera'''
+        self.stopped = True
+
+    def _update(self, dt):
+        '''Update the camera (internal)'''
+        pass
+
+    def _copy_to_gpu(self):
+        '''Copy the buffer into the texture.'''
+        if self._texture is None:
+            Logger.debug('Camera: copy_to_gpu() failed, _texture is None !')
+            return
+        self._texture.blit_buffer(self._buffer, colorfmt=self._format)
+        self._buffer = None
+        self.dispatch('on_texture')
+
+    def on_texture(self):
+        pass
+
+    def on_load(self):
+        pass
+
+
+# Load the appropriate providers
+providers = ()
+
+if platform in ['macosx', 'ios']:
+    providers += (('avfoundation', 'camera_avfoundation',
+                   'CameraAVFoundation'), )
+elif platform == 'android':
+    providers += (('android', 'camera_android', 'CameraAndroid'), )
+else:
+    providers += (('picamera', 'camera_picamera', 'CameraPiCamera'), )
+    providers += (('gi', 'camera_gi', 'CameraGi'), )
+
+providers += (('opencv', 'camera_opencv', 'CameraOpenCV'), )
+
+
+Camera = core_select_lib('camera', (providers))