implementing player buffering

Author: s-n-g

pyradio/edit.py

@@ -12,6 +12,7 @@
 except:
     from urlparse import urlparse
 from .simple_curses_widgets import SimpleCursesLineEdit, SimpleCursesCheckBox, SimpleCursesHorizontalPushButtons, DisabledWidget
+from .player import PlayerCache
 from .log import Log
 
 import locale
@@ -1230,6 +1231,139 @@ def keypress(self, char):
         return self._get_result(ret)
 
 
+class PyRadioBuffering(object):
+
+    _text = 'Buffer size in seconds: '
+    _help_text = ' Help '
+    _note_text = ' Note '
+    _max_lines = 12
+    _cache_data  = None
+    _step = 1
+    _big_step = 5
+    _limit = 60
+
+    def __init__(self,
+                 parent,
+                 config,
+                 player,
+                 global_functions=None):
+        self._parent = parent
+        self._cnf = config
+        self._player = player
+        self._global_functions = global_functions
+        if self._global_functions is None:
+            self._global_functions = {}
+        self.recording = lambda: self._player.recording
+        self._title = ' ' + self._player.PLAYER_NAME + ' Buffering '
+        if self._player.PLAYER_NAME == 'mplayer':
+            self._text = 'Buffer size in KBytes: '
+            self._step = 500
+            self._big_step = 1000
+            self._limit = 100000
+        self._cache_data = PlayerCache(
+                player.PLAYER_NAME,
+                self._cnf.data_dir,
+                lambda: self._player.recording
+                )
+        if self._cnf.buffering_data:
+            self._delay = self._cache_data.delay
+        else:
+            self._delay = 0
+
+    def save(self):
+        self._cache_data._save()
+
+    def show(self, parent=None):
+        if parent:
+            self._parent = parent
+        y, x = self._parent.getmaxyx()
+        new_y = int((y - self._max_lines) / 2) + 1
+        new_x = int((x - len(self._text) - 9 - 4) / 2)
+        self.MaxX = len(self._text) + 9 + 4
+        self._win = None
+        if y < self._max_lines + 2 or x < self.MaxX + 2:
+            self._win = curses.newwin(3, 20, int((y-2)/2), int((x - 20) / 2))
+            self._win.bkgdset(' ', curses.color_pair(3))
+            self._win.erase()
+            self._win.box()
+            self._win.addstr(1, 2, 'Window too small', curses.color_pair(10))
+        else:
+
+            self._win = curses.newwin(self._max_lines, self.MaxX, new_y, new_x)
+            self._win.bkgdset(' ', curses.color_pair(3))
+            self._win.erase()
+            self._win.box()
+
+            # show title
+            x = int((self.MaxX - len(self._title)) / 2)
+            self._win.addstr(0, x, self._title, curses.color_pair(11))
+
+            # show content
+            self._win.addstr(2, 4, self._text, curses.color_pair(10))
+            self._win.addstr('{}'.format(self._delay), curses.color_pair(11))
+
+            # show help
+            try:
+                self._win.addstr(4, 2, '─' * (self.MaxX - 4), curses.color_pair(3))
+            except:
+                self._win.addstr(4, 2, '─'.encode('utf-8') * (self.maxX - 6), curses.color_pair(3))
+            self._win.addstr(4, int((self.MaxX - len(self._help_text))/2), self._help_text, curses.color_pair(3))
+            self._win.addstr(5, 2, 'j k UP DOWN', curses.color_pair(11))
+            self._win.addstr(6, 2, 'PgUp PgDown', curses.color_pair(11))
+            self._win.addstr('     Adjust value', curses.color_pair(10))
+            self._win.addstr(7, 2, 'r', curses.color_pair(11))
+            self._win.addstr('               Load saved value', curses.color_pair(10))
+            self._win.addstr(8, 2, 'z', curses.color_pair(11))
+            self._win.addstr('               No buffering', curses.color_pair(10))
+            self._win.addstr(9, 2, 'ENTER s', curses.color_pair(11))
+            self._win.addstr('         Accept value', curses.color_pair(10))
+            self._win.addstr(10, 2, 'Esc q h RIGHT', curses.color_pair(11))
+            self._win.addstr('   Cancel operation', curses.color_pair(10))
+        self._win.refresh()
+
+    def keypress(self, char):
+        """ Returns:
+                -1: Cancel  - []
+                 0: go on   - []
+                 1: Ok      = [buffering parameters]
+        """
+        if char in self._global_functions.keys():
+            self._global_functions[char]()
+
+        elif char in (curses.KEY_ENTER, ord('\n'), ord('\r'), ord('s')):
+            self._cache_data.delay = self._delay
+            return 1, self._cache_data.cache
+
+        elif char in (curses.KEY_EXIT, 27, ord('q'), ord('h'), curses.KEY_LEFT):
+            return -1, []
+
+        elif char in (ord('j'), curses.KEY_UP,
+                      ord('k'), curses.KEY_DOWN,
+                      curses.KEY_NPAGE, curses.KEY_PPAGE,
+                      ord('z'), ord('r')
+                      ):
+            if char == ord('r'):
+                self._delay = self._cache_data.delay
+            elif char in (ord('k'), curses.KEY_UP):
+                self._delay += self._step
+            elif char in (ord('j'), curses.KEY_DOWN):
+                self._delay -= self._step
+            elif char == curses.KEY_NPAGE:
+                self._delay -= self._big_step
+            elif char == curses.KEY_PPAGE:
+                self._delay += self._big_step
+            elif char == ord('z'):
+                self._delay = 0
+
+            if self._delay < 0:
+                self._delay = 0
+            elif self._delay > self._limit:
+                self._delay = self._limit
+            self._win.addstr(2, len(self._text) + 4, '{:<7}'.format(self._delay), curses.color_pair(11))
+            self._win.refresh()
+        return 0, []
+
+
 class PyRadioConnectionType(object):
 
     _title = ' Connection Type '

pyradio/player.py

@@ -3492,26 +3492,26 @@ class PlayerCache(object):
 
     _data = {
             'mpv': [
-                '--cache-secs=30',
+                '--cache-secs=20',
                 '--cache=yes',
                 '--cache-on-disk=yes',
                 '--demuxer-cache-wait=yes',
                 '--demuxer-readahead-secs=29',
                 ],
             'mplayer': [
-                '-cache=1024',
+                '-cache=2000',
                 '-cache-min=80'
                 ],
             'vlc': [
                  '--network-caching',
-                 '10000'
+                 '20'
                  ]
             }
 
     def __init__(self, player_name, data_dir, recording):
         self._player_name = player_name
         self._data_file = os.path.join(data_dir, 'buffers')
-        self_recording = recording
+        self._recording = recording
         self._read()
 
     def __del__(self):
@@ -3521,7 +3521,11 @@ def __del__(self):
     def cache(self):
         if self._player_name == 'mpv':
             self._on_disk()
-        return self._data[self._player_name]
+        if self._player_name != 'vlc':
+            return self._data[self._player_name]
+        out = self._data['vlc']
+        out[1] = str(int(out[1]) * 1000)
+        return out
 
     @property
     def delay(self):
@@ -3538,8 +3542,6 @@ def delay(self, a_delay):
             x = int(a_delay)
         except ValueError:
             return
-        if self._player_name == 'vlc':
-            x *= 1000
 
         if self._player_name == 'vlc':
             self._data['vlc'][1] = str(x)
@@ -3582,11 +3584,11 @@ def _save(self):
             self._dirty = False
 
     def _on_disk(self):
-        if self._recording():
+        if self._recording() > 0:
             self._data['mpv'][2] = '--cache-on-disk=no'
             return
         try:
-            vitr = psutil.virtual_memory()
+            virt = psutil.virtual_memory()
         except:
             self._data['mpv'][2] = '--cache-on-disk=no'
             return

pyradio/radio.py

@@ -35,7 +35,7 @@
 from .window_stack import Window_Stack
 from .config_window import *
 from .log import Log
-from .edit import PyRadioSearch, PyRadioEditor, PyRadioRenameFile, PyRadioConnectionType, PyRadioServerWindow
+from .edit import PyRadioSearch, PyRadioEditor, PyRadioRenameFile, PyRadioConnectionType, PyRadioServerWindow, PyRadioBuffering
 from .themes import *
 from .cjkwrap import cjklen, cjkcenter, cjkslices
 from . import player
@@ -391,6 +391,8 @@ class PyRadio(object):
     _remote_control_window = None
     _group_selection_window = None
 
+    _buffering_win = None           # Cache editing window
+
     def ll(self, msg):
         logger.error('DE ==========')
         logger.error('DE ===> {}'.format(msg))
@@ -580,6 +582,7 @@ def __init__(self, pyradio_config,
             self.ws.GROUP_HELP_MODE: self._show_group_help,
             self.ws.RECORD_WINDOW_MODE: self._show_recording_toggle_window,
             self.ws.WIN_VLC_NO_RECORD_MODE: self._show_win_no_record,
+            self.ws.BUFFER_SET_MODE: self._show_buffer_set,
         }
 
         ''' list of help functions '''
@@ -914,6 +917,7 @@ def setup(self, stdscr):
             self.player.params = self._cnf.params[self.player.PLAYER_NAME][:]
             self.player.buffering_change_function = self._show_recording_status_in_header
             self.player.buffering_lock = self._buffering_lock
+            self._cnf.buffering_data = []
             if self._request_recording:
                 if not (platform.startswith('win') and \
                         self.player.PLAYER_NAME == 'vlc'):
@@ -2263,6 +2267,9 @@ def stopPlayer(self,
             # with self._buffering_lock:
             #     self._show_recording_status_in_header()
 
+    def _show_buffer_set(self):
+        pass
+
     def _show_player_is_stopped(self, from_update_thread=False):
         if from_update_thread:
             msg_id = 2
@@ -3408,6 +3415,7 @@ def _show_extra_commands_help(self):
                  self.ws.previous_operation_mode == self.ws.NORMAL_MODE):
             txt = '''\\      |Open previous playlist.
                      ]      |Open first opened playlist.
+                     b      |Set player |b|uffering.
                      l      |Toggle |Open last playlist|.
                      m      |Cahnge |m|edia player.
                      n      |Create a |n|ew playlist.
@@ -6993,6 +7001,22 @@ def keypress(self, char):
                                 mode_to_set=self.ws.NORMAL_MODE,
                                 callback_function=self.refreshBody)
 
+            elif char == ord('b'):
+                self._update_status_bar_right(status_suffix='')
+                if self.ws.operation_mode == self.ws.NORMAL_MODE:
+                    self._buffering_win = PyRadioBuffering(
+                            parent=self.outerBodyWin,
+                            config=self._cnf,
+                            player=self.player,
+                            global_functions=self._global_functions
+                            )
+                    self.ws.operation_mode = self.ws.BUFFER_SET_MODE
+                    self._buffering_win.show()
+                else:
+                    self._backslash_pressed = False
+                    self._print_not_applicable()
+                    return
+
             else:
                 ''' ESC or invalid char pressed - leave \ mode '''
                 self._update_status_bar_right(status_suffix='')
@@ -7158,6 +7182,7 @@ def keypress(self, char):
                 self.player.params = self._cnf.params[self.player.PLAYER_NAME][:]
                 self.player.buffering_change_function = self._show_recording_status_in_header
                 self.player.buffering_lock = self._buffering_lock
+                self._cnf.buffering_data = []
                 if not (self.player.PLAYER_NAME == 'vlc' and \
                         platform.startswith('win')):
                     self.player.recording = to_record
@@ -7279,6 +7304,21 @@ def keypress(self, char):
                 self.ws.close_window()
                 self.refreshBody()
 
+        elif self.ws.operation_mode == self.ws.BUFFER_SET_MODE:
+            ret, buf = self._buffering_win.keypress(char)
+            if ret == 0:
+                return
+            elif ret == 1:
+                self._cnf.buffering_data = buf[:]
+                if logger.isEnabledFor(logging.DEBUG):
+                    logger.debug('buffering data = {}'.format(buf))
+                self._buffering_win.save()
+                self._buffering_win = None
+            elif ret == -1:
+                self._buffering_win = None
+            self.ws.close_window()
+            self.refreshBody()
+
         elif self.ws.operation_mode == self.ws.CONFIG_MODE and \
                 char not in self._chars_to_bypass:
             if char in (ord('r'), ord('d')):

pyradio/window_stack.py

@@ -59,6 +59,7 @@ class Window_Stack_Constants(object):
     SCHEDULE_PLAYER_STOP_MODE = 75
     REMOVE_GROUP_MODE = 76
     RECORD_WINDOW_MODE = 77
+    BUFFER_SET_MODE = 78
     MAIN_HELP_MODE = 100
     MAIN_HELP_MODE_PAGE_2 = 101
     MAIN_HELP_MODE_PAGE_3 = 102
@@ -283,7 +284,8 @@ class Window_Stack_Constants(object):
         GROUP_SEARCH_MODE: 'GROUP_SEARCH_MODE',
         GROUP_HELP_MODE: 'GROUP_HELP_MODE',
         RECORD_WINDOW_MODE: 'RECORD_WINDOW_MODE',
-        WIN_VLC_NO_RECORD_MODE: 'WIN_VLC_NO_RECORD_MODE' ,
+        WIN_VLC_NO_RECORD_MODE: 'WIN_VLC_NO_RECORD_MODE',
+        BUFFER_SET_MODE: 'BUFFER_SET_MODE',
     }
 
     ''' When PASSIVE_WINDOWS target is one of them,