def __init__(self, app, remote): self.tuner_chidx = 0 # Current channel, index into config.TV_CHANNELS self.app_mode = 'tv' self.fc = FreevoChannels() self.current_vg = None self.xawtv_prog = app self.remote_prog = remote
def __init__(self, standalone=False): """ init the upsoon plugin """ logger.log( 9, 'upsoon.PluginInterface.__init__()') plugin.DaemonPlugin.__init__(self) plugin.register(self, 'upsoon') self.standalone = standalone self.lock = thread.allocate_lock() self.running = True self.timer = Timer(self.timer_handler).start(15) self.event = EventHandler(self.event_handler) #self.event.register(('VIDEO_START', 'VIDEO_END')) self.event.register() self.recordclient = RecordClient() self.fc = FreevoChannels() self.rdev = config.RADIO_DEVICE self.next_program = None self.announced = False self.seconds_before_announce = config.TV_UPSOON_ANNOUNCE self.seconds_before_start = config.TV_UPSOON_BEFORE_START self.pending_lockfile = config.FREEVO_CACHEDIR + '/record.soon' self.tv_lockfile = None # lockfile of recordserver self.stopped = None # flag that tells upsoon what stopped if os.path.exists(self.pending_lockfile): os.remove(self.pending_lockfile) logger.debug('%r lockfile removed', self.pending_lockfile)
def __init__(self): """ init the upsoon plugin """ _debug_('__init__(self)', 2) plugin.DaemonPlugin.__init__(self) self.lock = thread.allocate_lock() self.poll_interval = 1500 #15 secs self.poll_menu_only = 0 self.event_listener = 1 plugin.register(self, 'upsoon') server_string = 'http://%s:%s/' % (config.RECORDSERVER_IP, config.RECORDSERVER_PORT) _debug_('%s' % server_string) self.server = xmlrpclib.Server(server_string, allow_none=1) _debug_('%s' % self.server) self.serverup = None self.next_program = self.findNextProgram() _debug_('%s' % (self.next_program)) self.fc = FreevoChannels() self.seconds_before_announce = 120 self.seconds_before_start = 60 self.pending_lockfile = config.FREEVO_CACHEDIR + '/record.soon' self.tv_lockfile = None # lockfile of recordserver self.stopped = False # flag that tells upsoon stopped the tv, not the user
def __init__(self): self.ivtv_init = False self.fc = FreevoChannels() self.curr_channel = None self.embed = None self.stack = []
def __init__(self, standalone=False): """ init the upsoon plugin """ _debug_('upsoon.PluginInterface.__init__()', 2) plugin.DaemonPlugin.__init__(self) plugin.register(self, 'upsoon') self.standalone = standalone self.lock = thread.allocate_lock() self.running = True self.timer = Timer(self.timer_handler).start(15) self.event = EventHandler(self.event_handler) #self.event.register(('VIDEO_START', 'VIDEO_END')) self.event.register() self.recordclient = RecordClient() self.fc = FreevoChannels() self.rdev = config.RADIO_DEVICE self.next_program = None self.seconds_before_announce = 120 self.seconds_before_start = 60 self.pending_lockfile = config.FREEVO_CACHEDIR + '/record.soon' self.tv_lockfile = None # lockfile of recordserver self.stopped = None # flag that tells upsoon what stopped
def __init__(self, xine): """ TunerControl constructor """ self.xine = xine self.ivtv_init = False self.fc = FreevoChannels() self.curr_channel = None self.embed = None self.stack = []
def run(self): while 1: if DEBUG: print('Record_Thread::run: mode=%s' % self.mode) if self.mode == 'idle': self.mode_flag.wait() self.mode_flag.clear() elif self.mode == 'record': rc.post_event(Event('RECORD_START', arg=self.prog)) if DEBUG: print 'Record_Thread::run: started recording' fc = FreevoChannels() if DEBUG: print 'CHAN: %s' % fc.getChannel() (v_norm, v_input, v_clist, v_dev) = config.TV_SETTINGS.split() v = tv.ivtv.IVTV(v_dev) v.init_settings() vg = fc.getVideoGroup(self.prog.tunerid, False) if DEBUG: print 'Setting Input to %s' % vg.input_num v.setinput(vg.input_num) if DEBUG: print 'Setting Channel to %s' % self.prog.tunerid fc.chanSet(str(self.prog.tunerid), False) if DEBUG: v.print_settings() now = time.time() stop = now + self.prog.rec_duration time.sleep(2) v_in = open(v_dev, 'r') v_out = open(self.prog.filename, 'w') while time.time() < stop: buf = v_in.read(CHUNKSIZE) v_out.write(buf) if self.mode == 'stop': break v_in.close() v_out.close() v.close() v = None self.mode = 'idle' rc.post_event(Event('RECORD_STOP', arg=self.prog)) if DEBUG: print('Record_Thread::run: finished recording') else: self.mode = 'idle' time.sleep(0.5)
def run(self): while 1: if DEBUG: print('Record_Thread::run: mode=%s' % self.mode) if self.mode == 'idle': self.mode_flag.wait() self.mode_flag.clear() elif self.mode == 'record': rc.post_event(Event('RECORD_START', arg=self.prog)) if DEBUG: print('Record_Thread::run: cmd=%s' % self.command) fc = FreevoChannels() if DEBUG: print 'CHAN: %s' % fc.getChannel() (v_norm, v_input, v_clist, v_dev) = config.TV_SETTINGS.split() v = tv.ivtv.IVTV(v_dev) v.init_settings() self.vg = fc.getVideoGroup(self.prog.tunerid, False) if DEBUG: print 'Using video device %s' % self.vg.vdev if DEBUG: print 'Setting Input to %s' % self.vg.input_num v.setinput(self.vg.input_num) if DEBUG: print 'Setting Channel to %s' % self.prog.tunerid fc.chanSet(str(self.prog.tunerid), False) if DEBUG: v.print_settings() self.app = RecordApp(self.command) while self.mode == 'record' and self.app.isAlive(): self.autokill -= 0.5 time.sleep(0.5) if self.autokill <= 0: if DEBUG: print 'autokill timeout, stopping recording' self.mode = 'stop' if self.app.isAlive(): # might not want to do this is PDC is valid, programme may be delayed if DEBUG: print('Record_Thread::run: past wait!!') rc.post_event( Event(OS_EVENT_KILL, (self.app.child.pid, 15))) self.app.kill() rc.post_event(Event('RECORD_STOP', arg=self.prog)) if DEBUG: print('Record_Thread::run: finished recording') self.mode = 'idle' else: self.mode = 'idle' time.sleep(0.5)
def __init__(self, manager): """ Initialise the recording thread passing in the DVBStreamerControl object to use to control instances of dvbstreamer. """ threading.Thread.__init__(self) self.fc = FreevoChannels() self.manager = manager self.mode = 'idle' self.mode_flag = threading.Event() self.prog = None self.app = None
def __init__(self): # Disable this plugin if not loaded by record_server. if string.find(sys.argv[0], 'recordserver') == -1: return if DEBUG: print 'ACTIVATING GENERIC RECORD PLUGIN' self.fc = FreevoChannels() self.thread = Record_Thread() self.thread.setDaemon(1) self.thread.mode = 'idle' self.thread.start()
def __init__(self, manager, path, size): self.name = 'vlc' self.app_mode = 'tv' self.app = None self.adapter_in_use = -1 self.fc = FreevoChannels() self.path = path self.size = size self.buffer = ring_buffer.RingBuffer(size, path) self.last_channel = None self.subtitles = False self.paused = False self.stop_time = 0 self.state = STATE_IDLE self.manager = manager self.udp_receiver = UDPReceiver(self.buffer, WAIT_FOR_DATA_TIMEOUT) self.slave_server = SlaveServer(self.buffer, self) self.fill = 0 self.cur_audio = None self.cur_sub = None self.cur_audiodev = None self.lastchan = None self.timer = kaa.Timer(self.__update_data_from_vlc) self.timer_start = kaa.OneShotTimer( self.__update_data_from_vlc) self.timer_disablebuffering = kaa.OneShotTimer( self.disable_buffering) if hasattr(config, 'LIVE_PAUSE_BUFFER_TIMEOUT'): self. buffering_timeout=config.LIVE_PAUSE_BUFFER_TIMEOUT else: # Disable after 5min if not LIVE_PAUSE_BUFFERING_TIMEOUT self.buffering_timeout= 5 * 60 # Create the command used to start vlc. # NOTE: We add the slave server MRL twice so that we can toggle between # them, this allows use to effectively reset vlc rendering pipeline and # make it possible to seek quickly. self.command = [ '--prio=%s' % config.MPLAYER_NICE ] + \ config.VLC_COMMAND.split(' ') + \ [ '--intf', 'rc' ] + \ ['--no-interact','--rc-fake-tty'] + \ [ '--sub-filter' ,'marq' ] + \ [ '--marq-marquee' ,'Playing' ] + \ [ '--marq-position','4'] + \ [ '--fullscreen', self.slave_server.get_vlc_mrl(), self.slave_server.get_vlc_mrl()] if not rc.PYLIRC and '--no-lirc' in self.command: self.command.remove('--no-lirc') self.udp_receiver.start() self.slave_server.start()
def __init__(self): # Disable this plugin if not loaded by record_server. if string.find(sys.argv[0], 'recordserver') == -1: return if DEBUG: print 'ACTIVATING VBI2SRT RECORD PLUGIN' self.vg = None self.fc = FreevoChannels() self.tuner_chidx = 0 # Current channel, index into config.TV_CHANNELS self.thread = Record_Thread() self.thread.setDaemon(1) self.thread.mode = 'idle' self.thread.start()
def run(self): _debug_('Record_Thread.run()', 2) while 1: _debug_('mode=%s' % self.mode) if self.mode == 'idle': self.mode_flag.wait() self.mode_flag.clear() elif self.mode == 'record': rc.post_event(Event('RECORD_START', arg=self.prog)) fc = FreevoChannels() _debug_('channel %s' % fc.getChannel()) self.vg = fc.getVideoGroup(self.prog.tunerid, False) v = tv.ivtv.IVTV(self.vg.vdev) v.init_settings() _debug_('Using video device=%r' % self.vg.vdev) _debug_('Setting Channel to %r' % self.prog.tunerid) fc.chanSet(str(self.prog.tunerid), False) _debug_('command %r' % self.command) self.app = RecordApp(self.command) _debug_('app child pid: %s' % self.app.child.pid) while self.mode == 'record' and self.app.isAlive(): self.autokill -= 0.5 time.sleep(0.5) if self.autokill <= 0: _debug_('autokill timeout, stopping recording') self.mode = 'stop' if self.app.isAlive(): # might not want to do this is PDC is valid, programme may be delayed _debug_('past wait!!') rc.post_event( Event(OS_EVENT_KILL, (self.app.child.pid, 15))) self.app.kill() rc.post_event(Event('RECORD_STOP', arg=self.prog)) _debug_('finished recording') self.mode = 'idle' else: self.mode = 'idle' time.sleep(0.5)
def __init__(self, type): self.name = 'xine' self.app_mode = 'tv' self.xine_type = type self.app = None self.fc = FreevoChannels() self.command = [ '--prio=%s' % config.MPLAYER_NICE ] + \ config.XINE_COMMAND.split(' ') + \ [ '--stdctl', '-V', config.XINE_VO_DEV, '-A', config.XINE_AO_DEV ] + \ config.XINE_ARGS_DEF.split(' ')
def __init__(self, manager): """ Initialise the recorder passing in the DVBStreamerControl object to use to control instances of dvbstreamer. """ # Disable this plugin if not loaded by record_server. if sys.argv[0].find('recordserver') == -1: return self.fc = FreevoChannels() self.thread = Record_Thread(manager) self.thread.setDaemon(1) self.thread.mode = 'idle' self.thread.start()
def play(self, arg=None, menuw=None): """ Start watching TV """ logger.log(9, 'play(arg=%r, menuw=%r)', arg, menuw) # watching TV should only be possible from the guide if not self.context == 'guide': rc.post_event(MENU_SELECT) return now = time.time() if menuw: menuw.delete_submenu() # Check if the selected program is >7 min in the future if self.prog.start > now + (7 * 60): if menuw: menuw.show() # this program is in the future if self.scheduled: msgtext = _( 'Do you want to remove the Program from the record schedule?' ) confirmbtn = _('Remove') else: msgtext = _( 'This Program is in the future. Do you want to record it?') confirmbtn = _('Record') dialog.show_confirmation(msgtext, lambda: self.toggle_rec(menuw=menuw), proceed_text=confirmbtn) return else: # check if the device is free fc = FreevoChannels() # for that we need the name of the lock file suffix = fc.getVideoGroup(self.prog.channel_id, True, CHANNEL_ID).vdev suffix = suffix.split('/')[-1] tvlockfile = config.FREEVO_CACHEDIR + '/record.' + suffix if os.path.exists(tvlockfile): if menuw: menuw.show() # XXX: In the future add the options to watch what we are # recording or cancel it and watch TV. msgtext = _('Sorry, you cannot watch TV while recording. ') msgtext += _('If this is not true then remove ') msgtext += tvlockfile + '.' dialog.show_alert(msgtext) else: # everything is ok, we can start watching! self.parent.hide() self.parent.player('tv', self.prog.channel_id)
def writeTvtimeXML(self): tvtimexml = os.path.join(os.environ['HOME'], '.tvtime', 'tvtime.xml') configcmd = os.path.join(os.path.dirname(config.TVTIME_CMD), "tvtime-configure") #cf_norm, cf_input, cf_clist, cf_device = config.TV_SETTINGS.split() fc = FreevoChannels() vg = fc.getVideoGroup(config.TV_CHANNELS[0][2], True) cf_norm = vg.tuner_norm cf_input = vg.input_num cf_device = vg.vdev s_norm = cf_norm.upper() daoptions = '' if os.path.isfile(tvtimexml): daoptions = ' -F ' + tvtimexml if self.xmltv_supported: daoptions += ' -d %s -n %s -t %s' % (cf_device, s_norm, config.XMLTV_FILE) else: daoptions += ' -d %s -n %s' % (cf_device, s_norm) if hasattr(config, "TV_TVTIME_SETUP_OPTS") and config.TV_TVTIME_SETUP_OPTS: daoptions += ' %s' % config.TV_TVTIME_SETUP_OPTS os.system(configcmd+daoptions)
def __init__(self, start_time, player, menuw): Item.__init__(self) self.n_items, hours_per_page = skin.items_per_page(('tv', self)) stop_time = start_time + hours_per_page * 60 * 60 msgtext = _('Preparing the program guide') guide = epg_xmltv.get_guide(PopupBox(text=msgtext)) channels = guide.GetPrograms(start=start_time + 1, stop=stop_time - 1) if not channels: AlertBox(text=_('TV Guide is corrupt!')).show() return selected = None for chan in channels: if chan.programs: selected = chan.programs[0] break self.col_time = 30 # each col represents 30 minutes self.n_cols = (stop_time - start_time) / 60 / self.col_time self.player = player self.type = 'tv' self.menuw = menuw self.visible = True self.select_time = start_time self.last_update = 0 self.lastinput_value = None self.lastinput_time = None self.update_schedules(force=True) self.fc = FreevoChannels() self.rebuild(start_time, stop_time, guide.chan_list[0].id, selected) self.event_context = 'tvmenu' menuw.pushmenu(self)
def __init__(self, type, version, manager, path, size): self.name = 'xine' self.app_mode = 'tv' self.xine_type = type self.version = version self.app = None self.adapter_in_use = -1 self.fc = FreevoChannels() self.path = path self.size = size self.buffer = ring_buffer.RingBuffer(size, path) self.last_channel = None self.subtitles = False self.paused = False self.stop_time = 0 self.state = STATE_IDLE self.manager = manager self.udp_receiver = UDPReceiver(self.buffer, WAIT_FOR_DATA_TIMEOUT) self.slave_server = SlaveServer(self.buffer, self) # Create the command used to start xine. # NOTE: We add the slave server MRL twice so that we can toggle between # them, this allows use to effectively reset Xine rendering pipeline and # make it possible to seek quickly. self.command = [ '--prio=%s' % config.MPLAYER_NICE ] + \ config.XINE_COMMAND.split(' ') + \ [ '--stdctl', '-V', config.XINE_VO_DEV, '-A', config.XINE_AO_DEV ] + \ config.XINE_ARGS_DEF.split(' ') + \ [self.slave_server.get_xine_mrl(), self.slave_server.get_xine_mrl()] if not rc.PYLIRC and '--no-lirc' in self.command: self.command.remove('--no-lirc') self.udp_receiver.start() self.slave_server.start()
def run(self): logger.log(9, 'Record_Thread.run()') while 1: logger.debug('Record_Thread::run: mode=%s', self.mode) if self.mode == 'idle': self.mode_flag.wait() self.mode_flag.clear() elif self.mode == 'record': try: logger.info('Record_Thread::run: started recording') fc = FreevoChannels() logger.debug('Channel: %s', fc.getChannel()) vg = fc.getVideoGroup(self.prog.tunerid, False) logger.debug('Opening device %r', vg.vdev) v = tv.ivtv.IVTV(vg.vdev) v.init_settings() logger.debug('Setting input to %r', vg.input_type) v.setinputbyname(vg.input_type) cur_std = v.getstd() try: new_std = V4L2.NORMS.get(vg.tuner_norm) if cur_std != new_std: logger.debug('Setting standard to %s', new_std) v.setstd(new_std) except: logger.error( "Videogroup norm value '%s' not from NORMS: %s", vg.tuner_norm, V4L2.NORMS.keys()) logger.debug('Setting channel to %r', self.prog.tunerid) fc.chanSet(str(self.prog.tunerid), False) # Setting the input sound level on the PVR card channel = self.prog.tunerid try: # lookup the channel name in TV_CHANNELS for pos in range(len(config.TV_CHANNELS)): entry = config.TV_CHANNELS[pos] if str(channel) == str(entry[2]): channel_index = pos break except ValueError: pass logger.debug( 'SetAudioByChannel: Channel: %r TV_CHANNEL pos(%d)', channel, channel_index) try: ivtv_avol = vg.avol except AttributeError: ivtv_avol = 0 if ivtv_avol <= 0: logger.debug( 'SetAudioByChannel: The tv_video group for %r doesn\'t set the volume', channel) else: # Is there a specific volume level in TV_CHANNELS_VOLUME avol_percent = 100 try: # lookup the channel name in TV_CHANNELS for pos in range(len(config.TV_CHANNELS_VOLUME)): if config.TV_CHANNELS_VOLUME[pos][ 0] == config.TV_CHANNELS[ channel_index][0]: avol_percent = config.TV_CHANNELS_VOLUME[ pos][1] break except: pass try: avol_percent = int(avol_percent) except ValueError: avol_percent = 100 avol = int(ivtv_avol * avol_percent / 100) if avol > 65535: avol = 65535 if avol < 0: avol = 0 logger.debug( 'SetAudioByChannel: Current PVR Sound level is : %s', v.getctrl(0x00980905)) logger.debug( 'SetAudioByChannel: Set the PVR Sound Level to : %s (%s * %s)', avol, ivtv_avol, avol_percent) v.setctrl(0x00980905, avol) logger.debug( 'SetAudioByChannel: New PVR Sound level is : %s', v.getctrl(0x00980905)) if vg.cmd != None: logger.debug("Running command %r", vg.cmd) retcode = os.system(vg.cmd) logger.debug("exit code: %g", retcode) now = time.time() stop = now + self.prog.rec_duration rc.post_event(Event('RECORD_START', arg=self.prog)) time.sleep(2) v_in = open(vg.vdev, 'r') v_out = open(self.prog.filename, 'w') logger.debug('Recording from %r to %r in %s byte chunks', vg.vdev, self.prog.filename, CHUNKSIZE) while time.time() < stop: buf = v_in.read(CHUNKSIZE) v_out.write(buf) if self.mode == 'stop': logger.info('Recording stopped') break v_in.close() v_out.close() v.close() v = None self.mode = 'idle' rc.post_event(Event('RECORD_STOP', arg=self.prog)) logger.info('Record_Thread::run: finished recording') except Exception, why: logger.critical('%s', why) return else: self.mode = 'idle' time.sleep(0.5)
def __init__(self): self.event_context = 'tv' self.fc = FreevoChannels() self.current_vg = None self.optionD_supported = False self.xmltv_supported = False
def __init__(self): self.tuner_chidx = 0 # Current channel, index into config.TV_CHANNELS self.app_mode = 'tv' self.fc = FreevoChannels() self.current_vg = None
def __init__(self, player): self.name = 'livepause' self.event_context = 'tv' self.fc = FreevoChannels() self.backend = backend.get_backend() self.backend.set_mode(player.mode) self.last_channel = None self.stop_time = 0 self.data_started_timer = kaa.OneShotTimer(self.__buffering_data_timedout) self.disable_buffering_timer = kaa.OneShotTimer(self.__disable_buffering_timeout) self.state = State.IDLE self.player = player self.changing_channel = False self.subtitles = None self.subtitle_index = -1 self.audio_langs = None self.audio_lang_index = -1 self.recording = False self.state_dialog = None # Setup Event Maps self.event_maps = {} self.event_maps[State.IDLE] = { 'READER_OVERTAKEN' : self.__idle_reader_overtaken, } self.event_maps[State.TUNING] = { 'DATA_STARTED' : self.__tuning_data_started, 'DATA_TIMEDOUT': self.__tuning_data_timedout, 'PLAY_END' : self.__handle_stop, 'USER_END' : self.__handle_stop, 'STOP' : self.__handle_stop } self.event_maps[State.BUFFERING] = { 'DATA_ACQUIRED': self.__buffering_data_acquired, 'DATA_TIMEDOUT': self.__buffering_data_timedout, 'PLAY_END' : self.__handle_stop, 'USER_END' : self.__handle_stop, 'STOP' : self.__handle_stop } self.event_maps[State.PLAYING] = { 'PLAY' : self.__playing_play_pause, 'PAUSE' : self.__playing_play_pause, 'PLAY_END' : self.__handle_stop, 'USER_END' : self.__handle_stop, 'STOP' : self.__handle_stop, 'TV_CHANNEL_UP' : self.__playing_tv_channel_up, 'TV_CHANNEL_DOWN' : self.__playing_tv_channel_down, 'TV_CHANNEL_NUMBER' : self.__playing_tv_channel_number, 'TV_START_RECORDING' : self.__playing_tv_record, 'SAVE_STARTED' : self.__playing_tv_record_start, 'SAVE_FINISHED' : self.__playing_tv_record_stop, 'BUTTON' : self.__playing_button_pressed, 'TOGGLE_OSD' : self.__playing_display_info, 'SEEK' : self.__playing_seek, 'SECONDS_LEFT' : self.__playing_seconds_left, 'READER_OVERTAKEN' : self.__playing_reader_overtaken, 'DATA_ACQUIRED' : None, 'DATA_TIMEDOUT' : None, 'VIDEO_NEXT_FILLMODE' : None, 'VIDEO_NEXT_AUDIOMODE': None, 'VIDEO_NEXT_AUDIOLANG': None, #self.__playing_toggle_audo_lang, 'VIDEO_NEXT_SUBTITLE' : self.__playing_toggle_subtitles, } self.current_event_map = self.event_maps[self.state]
def run(self): _debug_('Record_Thread.run()', 2) while 1: _debug_('Record_Thread::run: mode=%s' % self.mode) if self.mode == 'idle': self.mode_flag.wait() self.mode_flag.clear() elif self.mode == 'record': try: _debug_('Record_Thread::run: started recording', DINFO) fc = FreevoChannels() _debug_('Channel: %s' % (fc.getChannel())) vg = fc.getVideoGroup(self.prog.tunerid, False) _debug_('Opening device %r' % (vg.vdev)) v = tv.ivtv.IVTV(vg.vdev) v.init_settings() _debug_('Setting input to %r' % (vg.input_type)) v.setinputbyname(vg.input_type) cur_std = v.getstd() try: new_std = V4L2.NORMS.get(vg.tuner_norm) if cur_std != new_std: _debug_('Setting standard to %s' % (new_std)) v.setstd(new_std) except: _debug_("Videogroup norm value '%s' not from NORMS: %s" % \ (vg.tuner_norm, V4L2.NORMS.keys()), DERROR) _debug_('Setting channel to %r' % self.prog.tunerid) fc.chanSet(str(self.prog.tunerid), False) if vg.cmd != None: _debug_("Running command %r" % vg.cmd) retcode = os.system(vg.cmd) _debug_("exit code: %g" % retcode) now = time.time() stop = now + self.prog.rec_duration rc.post_event(Event('RECORD_START', arg=self.prog)) time.sleep(2) v_in = open(vg.vdev, 'r') v_out = open(self.prog.filename, 'w') _debug_('Recording from %r to %r in %s byte chunks' % (vg.vdev, self.prog.filename, CHUNKSIZE)) while time.time() < stop: buf = v_in.read(CHUNKSIZE) v_out.write(buf) if self.mode == 'stop': _debug_('Recording stopped', DINFO) break v_in.close() v_out.close() v.close() v = None self.mode = 'idle' rc.post_event(Event('RECORD_STOP', arg=self.prog)) _debug_('Record_Thread::run: finished recording', DINFO) except Exception, why: _debug_('%s' % (why), DCRITICAL) return else: self.mode = 'idle' time.sleep(0.5)
kaa.main.run() elif function == 'findnextprogram': def handler(result): print 'findnextprogram=%r' % (result, ) print result.__dict__ raise SystemExit server.findNextProgram(handler) kaa.main.run() elif function == 'isplayerrunning': def handler(result): print 'isplayerrunning=%r' % (result, ) raise SystemExit server.isPlayerRunning(handler) kaa.main.run() else: fc = FreevoChannels() vg = fc.getVideoGroup('K10', False) print 'vg=%s' % vg print 'dir(%s)' % dir(vg) for it in dir(vg): print ' %s:%s' % (it, eval('vg.' + it)) vdev = vg.vdev print 'vdev=%s' % vdev