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, 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, 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, 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):
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 = 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, 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")
