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, 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, 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):
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, 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, 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, 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_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)
