def __init__(self, name): Device.__init__(self, name) self.ControlPanelClass = DskControlPanel self.file = ObservableVariable() self.file.changed.connect(self.file_changed) self.alpha = ObservableVariable(0) self.alpha.changed.connect(self.alpha_changed) # While input convert doesn't seem explicitly necessary, it seems to # give better performance. Not sure why. self.inputconvert = self.add_element('videoconvert') self.mixer = self.add_element('videomixer') self.outputconvert = self.add_element('videoconvert') self.add_input_video_port_on(self.inputconvert) self.inputconvert.link(self.mixer) self.mixer.link(self.outputconvert) self.add_output_video_port_on(self.outputconvert) self.mixer.get_static_pad('sink_0').set_property('zorder', 0) self.alpha.set_value(1.0)
def __init__(self, port, dimension=10, emulator=False): Device.__init__(self, "Cube", port) self.array = numpy.array([[\ [0]*dimension]*dimension]*dimension, dtype='bool') self.dimension = dimension self.emulator = emulator self.name = "Cube"
def __init__(self, diamondx, diamondy, specphi, speczoom, specfocus, yagzoom, yagfocus, cspadx, objName="madsen", pvBase=None, presetsfile=None): Device.__init__(self, objName, pvBase, presetsfile) self.diamondx = diamondx self.diamondy = diamondy self.specphi = specphi self.speczoom = speczoom self.specfocus = specfocus self.yagzoom = yagzoom self.yagfocus = yagfocus self.cspadx = cspadx self.motors = { "diamondx": diamondx, "diamondy": diamondy, "specphi": specphi, "speczoom": speczoom, "specfocus": specfocus, "speczoom": yagzoom, "specfocus": yagfocus, "cspadx": cspadx } pass
def __init__(self, hp=('', 0), mac='', root=None, name='', key=PK_KEY, password='', deviceid='', clientsessionid='', hp2=('', 0)): Device.__init__(self, hp, mac, root, name) ManTimerManager.__init__(self, root) IrManager.__init__(self, hp, mac, root, name) self.key = key self.fid = 0 if len(clientsessionid) == 0: self.clientSessionId = generatestring(32) else: self.clientSessionId = clientsessionid if root is None: self.password = password self.deviceId = deviceid self.localPort = hp2[1] self.localIp = hp2[0] else: self.password = root.attributes['password'].value self.deviceId = root.attributes['deviceId'].value self.localPort = root.attributes['localPort'].value self.localIp = root.attributes['localIp'].value
def __init__(self, name, major=None, minor=None, exists=None, format=None, parents=None, sysfsPath='', vendor="", model=""): Device.__init__(self, name, format=format, major=major, minor=minor, exists=True, parents=parents, sysfsPath=sysfsPath, vendor=vendor, model=model)
def __init__(self, width, height, fullscreen): print "glut::__init__()" Device.__init__(self) self.size = (width, height) self.fullscreen = fullscreen glutInit(sys.argv) glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH) if self.fullscreen: glutGameModeString("%dx%d:32@70" % self.size ) self.windowID = glutEnterGameMode() else: glutInitWindowSize(self.size[0], self.size[1]) glutInitWindowPosition(0,0) self.windowID = glutCreateWindow("") glutSetWindow(self.windowID) glutReshapeFunc(self.reSizeGLScene) glutMouseFunc(self.onMouse) glutMotionFunc(self.onMotion) glutPassiveMotionFunc(self.onMotion) glutKeyboardFunc(self.onKeyDown) glutKeyboardUpFunc(self.onKeyUp) glutSpecialFunc(self.onSpecialDown) glutSpecialUpFunc(self.onSpecialUp) self.graphicsDevice = OpenGLGraphics(self.size)
def __init__(self, width, height, fullscreen, mode=P2D): Device.__init__(self) self.mode = mode self.size = (width, height) pygame.init() pygame.key.set_mods(KMOD_NONE) pygame.mouse.set_visible(0) if mode == PygameDevice.P2D: flags = 0 if fullscreen: flags = flags | pygame.locals.FULLSCREEN | pygame.locals.SWSURFACE self.graphicsDevice = PygameGraphics(self.size, flags) elif mode == PygameDevice.OGL: from openglgraphics import OpenGLGraphics flags = pygame.locals.OPENGL | pygame.locals.DOUBLEBUF if fullscreen: flags = flags | pygame.locals.FULLSCREEN self.graphicsDevice = OpenGLGraphics(self.size, flags, pygame.display.set_mode(self.size, flags)) else: raise device.DeviceException("Invalid Graphics Mode Specified")
def __init__(self, id_): Device.__init__(self, id_) self.endpoint_for_router = None self.bits_sent_graph_tag = globals_.stats_manager.new_graph( title='Total Bits Sent by %s' % self.id_, ylabel='Total Bits' ) self.bit_rate_sent_graph_tag = globals_.stats_manager.new_graph( title='Rate of Data Sent by %s' % self.id_, ylabel='Rate (bits/sec)', is_rate=True ) self.bits_received_graph_tag = globals_.stats_manager.new_graph( title='Total Bits Received by %s' % self.id_, ylabel='Total Bits' ) self.bit_rate_received_graph_tag = globals_.stats_manager.new_graph( title='Rate of Data Received by %s' % self.id_, ylabel='Rate (bits/sec)', is_rate=True ) self.bits_sent = 0 self.bits_received = 0
def __init__(self, parent=None, node=None): if node is None: node = self.class_name.lower() Device.__init__(self, parent=parent, node=node) if parent is not None: parent.deviceservers.append(self) self.xmlrpc_naturalNaming = self.naturalNaming
def __init__(self, path, format=None, size=None, exists=None, parents=None): """ Create a FileDevice instance. Arguments: path -- full path to the file Keyword Arguments: format -- a DeviceFormat instance size -- the file size (units TBD) parents -- a list of required devices (Device instances) exists -- indicates whether this is an existing device """ Device.__init__(self, path, format=format, size=size, exists=exists, parents=parents)
def __init__(self, device, format=None, parents=None, exists=True, size=None, major=None, minor=None, sysfsPath='', serial=None, model="", vendor="", bus=""): """ Create a Disk instance. Arguments: device -- the device name (generally a device node's basename) Keyword Arguments: size -- the device's size (units/format TBD) major -- the device major minor -- the device minor sysfsPath -- sysfs device path format -- a DeviceFormat instance parents -- a list of required Device instances removable -- whether or not this is a removable device Disk always exist. """ Device.__init__(self, device, format=format, size=size, major=major, minor=minor, exists=exists, model=model, serial=serial, vendor=vendor,bus=bus, sysfsPath=sysfsPath, parents=parents)
def __init__(self, x, y, z, attx, atty, apx, objName="g2", pvBase=None, presetsfile=None): Device.__init__(self, objName, pvBase, presetsfile) self.x = x self.y = y self.z = z self.attx = attx self.atty = atty self.apx = apx #self.objName=objName #self.pvBase=pvBase self.motors = { "x": x, "y": y, "z": z, "attx": attx, "atty": atty, "apx": apx }
def __init__(self, name, pattern=0): Device.__init__(self, name) self.ControlPanelClass = VideoTestGenControlPanel self.pattern = ObservableVariable(pattern) self.pattern.changed.connect(self.change_pattern) self.src = Gst.ElementFactory.make('videotestsrc', None) self.bin.add(self.src) self.src.set_property('pattern', self.pattern.get_value()) self.convert = Gst.ElementFactory.make('videoconvert', None) self.bin.add(self.convert) self.text_overlay = Gst.ElementFactory.make('textoverlay', None) self.bin.add(self.text_overlay) self.text_overlay.set_property("text", self.name) self.text_overlay.set_property("shaded-background", True) self.caps_filter = Gst.ElementFactory.make('capsfilter', None) self.bin.add(self.caps_filter) caps = Gst.caps_from_string(Device.DEFAULT_VIDEO_CAPS) self.caps_filter.set_property('caps', caps) self.src.link(self.text_overlay) self.text_overlay.link(self.convert) self.convert.link(self.caps_filter) self.add_output_video_port_on(self.caps_filter, "src")
def __init__( self, diamondx=sxrmotors.user_mmn_02, diamondy=sxrmotors.user_mmn_01, specphi=sxrmotors.user_mmn_03, speczoom=sxrmotors.user_dumb_32, specfocus=sxrmotors.user_dumb_31, yagzoom=sxrmotors.user_dumb_29, yagfocus=sxrmotors.user_dumb_30, cspadx=sxrmotors.user_mmn_05, objName="madsen", presetsfile="/reg/neh/operator/sxropr/sxrpython_data/L729_presets.py" ): Device.__init__(self, objName, pvBase, presetsfile) self.diamondx = diamondx self.diamondy = diamondy self.specphi = specphi self.speczoom = speczoom self.specfocus = specfocus self.yagzoom = yagzoom self.yagfocus = yagfocus self.cspadx = cspadx self.motors = { "diamondx": diamondx, "diamondy": diamondy, "specphi": specphi, "speczoom": speczoom, "specfocus": specfocus, "speczoom": yagzoom, "specfocus": yagfocus, "cspadx": cspadx } pass
def __init__(self): Device.__init__(self) self.name = 'arm' self.params = self.robot_params[self.name] self.motor_rad_2_arm_m = self.params['chain_pitch'] * self.params[ 'chain_sprocket_teeth'] / self.params['gr_spur'] / (math.pi * 2) self.motor = Stepper('/dev/hello-motor-arm') self.status = { 'pos': 0.0, 'vel': 0.0, 'force': 0.0, 'motor': self.motor.status, 'timestamp_pc': 0 } # Default controller params self.stiffness = 1.0 self.i_feedforward = self.params['i_feedforward'] self.vel_r = self.translate_to_motor_rad( self.params['motion']['default']['vel_m']) self.accel_r = self.translate_to_motor_rad( self.params['motion']['default']['accel_m']) self.i_contact_neg = self.translate_force_to_motor_current( self.params['contact_thresh_N'][0]) self.i_contact_pos = self.translate_force_to_motor_current( self.params['contact_thresh_N'][1]) self.motor.set_motion_limits( self.translate_to_motor_rad(self.params['range_m'][0]), self.translate_to_motor_rad(self.params['range_m'][1]))
def __init__(self, hp=('', 0), mac='', root=None, timeout=DEFAULT_RESUBSCRIPTION_TIMEOUT, name='', sec1900=0, lsa_timeout=DEFAULT_RESUBSCRIPTION_STIMEOUT, **kw): Device.__init__(self, hp, mac, root, name) if root is None: self.subscribe_time = 0 self.resubscription_timeout = timeout self.last_subs_action_timeout = lsa_timeout self.sec1900 = int( ((datetime.now() - datetime(1900, 1, 1, 0, 0, 0, 0)).total_seconds() - (datetime.utcnow() - datetime.now()).total_seconds() - sec1900) * 1000) else: self.subscribe_time = int(root.attributes['sst'].value) self.sec1900 = int(root.attributes['sec1900'].value) self.resubscription_timeout = int(root.attributes['rtime'].value) self.last_subs_action_timeout = int(root.attributes['stime'].value) self.last_subs_action = 0 self.get_reversed_mac() self.rawtables = None self.tablever = None self.timer_off_after_on = None self.timezone = None
def __init__(self, name, format=None, size=None, dmUuid=None, target=None, exists=None, parents=None, sysfsPath=''): """ Create a DMDevice instance. Arguments: name -- the device name (generally a device node's basename) Keyword Arguments: target -- the device-mapper target type (string) size -- the device's size (units/format TBD) dmUuid -- the device's device-mapper UUID sysfsPath -- sysfs device path format -- a DeviceFormat instance parents -- a list of required Device instances exists -- indicates whether this is an existing device """ Device.__init__(self, name, format=format, size=size, exists=exists, parents=parents, sysfsPath=sysfsPath) self.target = target self.dmUuid = dmUuid
def __init__(self, name): Device.__init__(self, name) self.ControlPanelClass = AudioTestGenControlPanel self.freqs = ObservableVariable([1000, 1000]) self.freqs.changed.connect(self.change_freqs) caps = Gst.caps_from_string(self.SINGLE_CHANNEL_AUDIO_CAPS) self.src0 = Gst.ElementFactory.make('audiotestsrc', None) self.bin.add(self.src0) self.src0.set_property('is-live', True) self.src1 = Gst.ElementFactory.make('audiotestsrc', None) self.bin.add(self.src1) self.src1.set_property('is-live', True) self.interleave = Gst.ElementFactory.make('interleave', None) self.bin.add(self.interleave) self.src0.link_filtered(self.interleave, caps) self.src1.link_filtered(self.interleave, caps) self.add_output_audio_port_on(self.interleave, "src") self.change_freqs(self.freqs.get_value())
def __init__(self, identifier): Device.__init__(self, identifier) self.link = None self.flows = {} self.clock = None self.event_scheduler = None self.logger = None self.payload_packet_trackers = {}
def __init__(self, hp=('', 0), mac='', root=None, name=''): Device.__init__(self, hp, mac, root, name) self.state = '' self.states_map = {} self.states_nick_map = {} self.target = [] if root is not None: self.states_xml_device_node_parse( root, self.states_map, self.states_nick_map) self.target_xml_device_node_parse(root, self.target)
def __init__(self, house, xml): Device.__init__(self, house, xml) self.last_motion_time = None try: self.off_time = float(xml.find("timeout").text) except AttributeError: timeout = ET.SubElement(self.xml, "timeout") timeout.text = "60" self.off_time = 60.
def __init__(self, house, xml): Device.__init__(self, house, xml) self.last_open_time = None self.state = ("Closed", 0.0) try: self.off_time = float(xml.find("timeout").text) except AttributeError: timeout = ET.SubElement(self.xml, "timeout") timeout.text = "60" self.off_time = 60.0
def __init__(self): Device.__init__(self, 'jose') self.model_query = "SELECT id,parameters,model from calibration_models WHERE predicts = '%s' AND invalid = FALSE ORDER BY timestamp DESC LIMIT 1" self.state_query = "SELECT state from calibration_state WHERE process = '%s' AND model_id = %d ORDER BY timestamp DESC LIMIT 1" self.state_insert = "INSERT INTO calibration_state (process, model_id, state) VALUES ('%s', %d, '%s')" self.sensor_model_names = { 'co': 'carbon_monoxide__air_', 'no2': 'nitrogen_dioxide__air_', 'o3': 'ozone__air_' } self.config_dict = None
def __init__(self, outlet, port): # Lighting class inherits from Device class # Device class methods are accessed using self. Device.__init__(self, outlet) self.DATABASE = DATABASE # where does cotwo max value come from? self.cotwo_max = 4.6 # setup sensor server zmq context self.port = port self.context = zmq.Context() self.socket = self.context.socket(zmq.REQ)
def __init__(self, id_): Device.__init__(self, id_) # Map: host_id -> (LinkEndpoint, # estimated_cost_to_get_to_host_id_by_going_through_this_link_endpoint) self.routing_table = dict() self.provisional_routing_table = dict() # List of link endpoints whose links connect directly to hosts self.endpoints_to_hosts = [] # Map: router_id -> endpoint of a link that connects to that router self.endpoints_to_routers = dict()
def __init__(self, adb): self.address = adb[0] prop = self.get_props() Device.__init__( self, { YAMLKeyword.device_name: adb[1], YAMLKeyword.target_abis: prop['ro.product.cpu.abilist'].split(','), YAMLKeyword.target_socs: prop['ro.board.platform'], YAMLKeyword.models: prop['ro.product.model'], YAMLKeyword.address: adb[0], })
def __init__(self, name): Device.__init__(self, name) self.queue = Gst.ElementFactory.make("queue", None) self.queue.set_property("max-size-time", 1000000) self.bin.add(self.queue) self.sink = Gst.ElementFactory.make("alsasink", None) self.bin.add(self.sink) self.add_input_audio_port_on(self.queue) self.queue.link(self.sink)
def __init__(self, name): Device.__init__(self, name) self.queue = Gst.ElementFactory.make('queue', None) self.queue.set_property('max-size-time', 1000000) self.bin.add(self.queue) self.sink = Gst.ElementFactory.make('alsasink', None) self.bin.add(self.sink) self.add_input_audio_port_on(self.queue) self.queue.link(self.sink)
def __init__(self, name=None): Device.__init__(self) # Open the serial port self.port = serial.Serial() if name is None: # looks for USB serial device for port in list_ports.grep('USB Serial Port'): name, _, _ = port break # just the first one self.port.port = name
def __init__(self, identifier): """ Creates a Host instance with the specified port and the specified identifier. """ Device.__init__(self, identifier) self._port = None self._flows = {} self._most_recent = {} self._expected = {}
def __init__(self, parent=None, node='?p'): # Retrieve the dev identifier corresponding to node devpath. dev = self.__class__.from_devpath(node) devpath = self.__class__.from_dev(dev) if devpath == dev: devpath = node Device.__init__(self, parent=parent, node=devpath) self['initializing'] = False self.fd = None self.file = dev self['dev'] = dev self['isConnected'] = False print 'PhysicalDevice init with', dev, devpath
def __init__(self, hp=('', 0), mac='', root=None, name='', conf=''): Device.__init__(self, hp, name, root, name) ManTimerManager.__init__(self, root) IrManager.__init__(self, hp, mac, root, name) self.remote = None self.last_init = 0 self.fill_ir_list() if root is None: self.conffile = conf else: self.conffile = root.attributes['conffile'].value self.config = None self.offt = -1 self.init_device()
def __init__(self, hp=('', 0), mac='', root=None, name='', location='', deviceobj=None): Device.__init__(self, hp, mac, root, name) self.upnp_obj = deviceobj self.offt = -1 if root is None: self.upnp_location = location else: self.upnp_location = root.attributes['upnp_location'].value
def __init__(self, device_dict): Device.__init__(self, device_dict) self.username = device_dict[YAMLKeyword.username] if YAMLKeyword.device_types in device_dict.keys(): self.device_types = device_dict[YAMLKeyword.device_types] else: self.device_types = ["cpu"] try: sh.ssh('-q', '%s@%s' % (self.username, self.address), 'exit') except sh.ErrorReturnCode as e: six.print_('device connect failed, ' 'please check your authentication', file=sys.stderr) raise e
def __init__(self, device_id, private_key_file, name): Device.__init__(self, device_id, private_key_file, "position") self.name = name self.triggered = False self.i = 30*60 self.queue = Queue() self.file = open("location.txt", "r") for line in self.file: if line == self.name: self.queue.put(True) else : self.queue.put(False)
def __init__( self, x, y, th, th2, chi, phi, sx, sy, sz, dy, gam, objName="diff", pvBase=None, presetsfile="/reg/neh/operator/sxropr/sxrpython_data/diffpresets.py" ): Device.__init__(self, objName, pvBase, presetsfile) self.x = x self.y = y self.th = th self.th2 = th2 self.chi = chi self.phi = phi self.sx = sx self.sy = sy self.sz = sz self.dy = dy self.gam = gam self.objName = objName self.detCenOffset = None self.pvBase = pvBase self.reflectdet = None # externally defined, in sxrbeamline.py self.reflect = None # externally defined, in sxrbeamline.py self.motors = { "x": x, "y": y, "th": th, "th2": th2, "chi": chi, "phi": phi, "sx": sx, "sy": sy, "sz": sz, "dy": dy, "gam": gam }
def __init__(self, name): Device.__init__(self, name) self.ControlPanelClass = UstreamProviderControlPanel self.url_and_key = ObservableVariable([None, None]) self.url_and_key.changed.connect(self.change_url_and_key) self.video_input_queue = Gst.ElementFactory.make('queue', None) self.bin.add(self.video_input_queue) self.videoconvert = Gst.ElementFactory.make('videoconvert', None) self.bin.add(self.videoconvert) self.videoencoder = Gst.ElementFactory.make('x264enc', None) self.bin.add(self.videoencoder) self.videoencoder.set_property('bitrate', 4000) self.videoencoder.set_property('bframes', 0) self.videoparse = Gst.ElementFactory.make('h264parse', None) self.bin.add(self.videoparse) self.videoparse_queue = Gst.ElementFactory.make('queue', None) self.bin.add(self.videoparse_queue) self.flvmux = Gst.ElementFactory.make('flvmux', None) self.bin.add(self.flvmux) self.flvmux.set_property('streamable', True) self.flvmux_queue = Gst.ElementFactory.make('queue', None) self.bin.add(self.flvmux_queue) self.rtmpsink = Gst.ElementFactory.make('fakesink', None) self.bin.add(self.rtmpsink) # Link elements self.video_input_queue.link(self.videoconvert) self.videoconvert.link(self.videoencoder) self.videoencoder.link(self.videoparse) videoparse_caps = Gst.caps_from_string( 'video/x-h264,level=(string)4.1,profile=main') self.videoparse.link_filtered(self.videoparse_queue, videoparse_caps) self.videoparse_queue.link(self.flvmux) self.flvmux.link(self.flvmux_queue) self.flvmux_queue.link(self.rtmpsink) # Add ports self.add_input_video_port_on(self.video_input_queue, "sink")
def __init__(self, name): Device.__init__(self, name) self.ControlPanelClass = UstreamProviderControlPanel self.url_and_key = ObservableVariable([None, None]) self.url_and_key.changed.connect(self.change_url_and_key) self.video_input_queue = Gst.ElementFactory.make("queue", None) self.bin.add(self.video_input_queue) self.videoconvert = Gst.ElementFactory.make("videoconvert", None) self.bin.add(self.videoconvert) self.videoencoder = Gst.ElementFactory.make("x264enc", None) self.bin.add(self.videoencoder) self.videoencoder.set_property("bitrate", 4000) self.videoencoder.set_property("bframes", 0) self.videoparse = Gst.ElementFactory.make("h264parse", None) self.bin.add(self.videoparse) self.videoparse_queue = Gst.ElementFactory.make("queue", None) self.bin.add(self.videoparse_queue) self.flvmux = Gst.ElementFactory.make("flvmux", None) self.bin.add(self.flvmux) self.flvmux.set_property("streamable", True) self.flvmux_queue = Gst.ElementFactory.make("queue", None) self.bin.add(self.flvmux_queue) self.rtmpsink = Gst.ElementFactory.make("fakesink", None) self.bin.add(self.rtmpsink) # Link elements self.video_input_queue.link(self.videoconvert) self.videoconvert.link(self.videoencoder) self.videoencoder.link(self.videoparse) videoparse_caps = Gst.caps_from_string("video/x-h264,level=(string)4.1,profile=main") self.videoparse.link_filtered(self.videoparse_queue, videoparse_caps) self.videoparse_queue.link(self.flvmux) self.flvmux.link(self.flvmux_queue) self.flvmux_queue.link(self.rtmpsink) # Add ports self.add_input_video_port_on(self.video_input_queue, "sink")
def __init__(self, name): Device.__init__(self, name) self.src = Gst.ElementFactory.make('v4l2src', None) self.bin.add(self.src) self.convert = Gst.ElementFactory.make('videoconvert', None) self.bin.add(self.convert) self.caps_filter = Gst.ElementFactory.make('capsfilter', None) caps = Gst.caps_from_string(Device.DEFAULT_VIDEO_CAPS) self.caps_filter.set_property('caps', caps) self.bin.add(self.caps_filter) self.src.link(self.convert) self.convert.link(self.caps_filter) self.add_output_video_port_on(self.caps_filter, "src")
def __init__(self, device, format=None, parents=None, exists=True, size=None, major=None, minor=None, sysfsPath='', serial=None, model="", vendor="", bus=""): """ Create a Disk instance. Arguments: device -- the device name (generally a device node's basename) Keyword Arguments: size -- the device's size (units/format TBD) major -- the device major minor -- the device minor sysfsPath -- sysfs device path format -- a DeviceFormat instance parents -- a list of required Device instances removable -- whether or not this is a removable device Disk always exist. """ Device.__init__(self, device, format=format, size=size, major=major, minor=minor, exists=exists, model=model, serial=serial, vendor=vendor, bus=bus, sysfsPath=sysfsPath, parents=parents)
def __init__(self, hp, mac, root, name, **kw): Device.__init__(self, hp, mac, root, name) self.d433 = {} self.dir = {} self.sh = {} self.emit_ir_delay = 1 self.backupstate = 0 self.backuptimer = None if root is not None: if root.hasAttribute('emit_delay'): try: ed = float(root.attributes['emit_delay'].value) if ed > 0: self.emit_ir_delay = ed except: # noqa: E722 pass self.ir_xml_device_node_parse(root, self.d433, "d433") self.ir_xml_device_node_parse(root, self.dir, "dir") self.sh_xml_device_node_parse(root, self.sh, "sh")
def __init__(self, name): Device.__init__(self, name) #self.ControlPanelClass = DeckControlPanel self.file_uri = ObservableVariable() self.file_uri.changed.connect(self.file_uri_changed) self.default_video = self.add_element('videotestsrc') self.default_video.set_property('pattern', 2) self.video_selector = self.add_element('input-selector') self.default_video.link(self.video_selector) self.default_audio = self.add_element('audiotestsrc') self.default_audio.set_property('wave', 4) self.audio_selector = self.add_element('input-selector') caps = Gst.caps_from_string(self.DEFAULT_AUDIO_CAPS) self.default_audio.link_filtered(self.audio_selector, caps) self.add_output_video_port_on(self.video_selector, 'src', 'video_out') self.add_output_audio_port_on(self.audio_selector, 'src', 'audio_out')
def __init__(self, name, format=None, size=None, dmUuid=None, target=None, exists=None, parents=None, sysfsPath=""): """ Create a DMDevice instance. Arguments: name -- the device name (generally a device node's basename) Keyword Arguments: target -- the device-mapper target type (string) size -- the device's size (units/format TBD) dmUuid -- the device's device-mapper UUID sysfsPath -- sysfs device path format -- a DeviceFormat instance parents -- a list of required Device instances exists -- indicates whether this is an existing device """ Device.__init__(self, name, format=format, size=size, exists=exists, parents=parents, sysfsPath=sysfsPath) self.target = target self.dmUuid = dmUuid
def __init__(self, name, size, location): Device.__init__(self, name) self.ControlPanelClass = MonitorControlPanel self.size = ObservableVariable(size) self.size.changed.connect(self.change_size) self.location = ObservableVariable(location) self.location.changed.connect(self.change_location) self.convert = Gst.ElementFactory.make('videoconvert', None) self.bin.add(self.convert) self.scale = Gst.ElementFactory.make('videoscale', None) self.bin.add(self.scale) self.sink = Gst.ElementFactory.make('xvimagesink', None) self.bin.add(self.sink) caps = Gst.caps_from_string(Device.DEFAULT_VIDEO_CAPS) self.convert.link_filtered(self.scale, caps) self.scale.link(self.sink) self.add_input_video_port_on(self.convert)
def __init__(self, name, channel1, channel2, media_type): Device.__init__(self, name) if media_type == 'video': intersrc = 'intervideosrc' intersink = 'intervideosink' intercaps = self.DEFAULT_VIDEO_CAPS else: intersrc = 'interaudiosrc' intersink = 'interaudiosink' intercaps = self.DEFAULT_AUDIO_CAPS src = Gst.ElementFactory.make(intersrc, None) self.port_1 = channel1 src.set_property('channel', channel1) self.bin.add(src) sink = Gst.ElementFactory.make(intersink, None) self.port_2 = channel2 sink.set_property('channel', channel2) self.bin.add(sink) src.link_filtered(sink, Gst.caps_from_string(intercaps))
def __init__(self, algorithm, identifier): """ Creates a Router instance with the specified algorithm and the specified identifier. """ Device.__init__(self, identifier) # Checks that algorithm is a RoutingAlgorithm instance if not isinstance(algorithm, RoutingAlgorithm): raise TypeError, 'algorithm must be a RoutingAlgorithm instance' self._algorithm = algorithm self._ports = [] self._flows = {} self._changed = {} self._most_recent = {} self._next_update = 0 self._should_update = False
def __init__(self, name, addr): Device.__init__(self, name, addr) self.dbbuilder = GenericDBBuilder(addr, self.db) self.db.setRecordFormatter(LightDBRecordFormatter())
def __init__(self, name, addr): Device.__init__(self, name, addr) self.dbbuilder = ThermostatDBBuilder(addr, self.db)
def __init__(self, identifier): Device.__init__(self, identifier) self.routing_table = RoutingTable() self.links = [] self.logger = None
def __init__(self, name, addr, topOfDatabase): Device.__init__(self, name, addr) self.dbbuilder = ThermostatDBBuilder(addr, self.db, topOfDatabase)
def __init__(self, name, inputs): Device.__init__(self, name) self.ControlPanelClass = SwitcherControlPanel self.program_active_id = ObservableVariable(0) self.preview_active_id = ObservableVariable(0) self.opacity = ObservableVariable(1.0) # Create elements that exist for all instances of the switcher self.prog_mixer = Gst.ElementFactory.make('videomixer', None) self.bin.add(self.prog_mixer) self.prev_mixer = Gst.ElementFactory.make('videomixer', None) self.bin.add(self.prev_mixer) # Add outputs for static mixer pads self.add_output_video_port_on(self.prog_mixer, "src", "prog_out") self.add_output_video_port_on(self.prev_mixer, "src", "prev_out") for input_id in range(inputs): # Create tee and create input tee = Gst.ElementFactory.make('tee', None) self.bin.add(tee) name = "in" + str(input_id + 1) self.add_input_video_port_on(tee, name, name) #pad = Gst.GhostPad.new(name, tee.get_static_pad("sink")) #self.bin.add_pad(pad) # Create queues queue1 = Gst.ElementFactory.make('queue', None) self.bin.add(queue1) queue2 = Gst.ElementFactory.make('queue', None) self.bin.add(queue2) # Link tee to queues pad = tee.get_request_pad("src_%u") toPad = queue1.get_static_pad("sink") pad.link(toPad) pad = tee.get_request_pad("src_%u") toPad = queue2.get_static_pad("sink") pad.link(toPad) # Link queues to videomixers pad = queue1.get_static_pad("src") toPad = self.prog_mixer.get_request_pad("sink_%u") pad.link(toPad) pad = queue2.get_static_pad("src") toPad = self.prev_mixer.get_request_pad("sink_%u") pad.link(toPad) if inputs >= 2: self.set_bus_input("preview", 1) self.set_bus_input("program", 0) else: self.set_bus_input("preview", 0) self.set_bus_input("program", 0) self.add_action("take", self.take, "Swap program and preview or set program") self.add_action("preview", self.preview, "Set preview") self.add_action("fade", self.fade, "Set fade position")
def __init__(self): self._deviceHandle = llt.Llt(llt.INTF_TYPE_ETHERNET) Device.__init__(self)