def run(self) :
self.show_all()
self.xid = self.movie_window.get_property('window').get_xid()
self.player.set_state(Gst.State.NULL)
if self.startcam == "Start":
if self.flipcam == True:
self.player = Gst.parse_launch("v4l2src device=\"/dev/video1\" ! image/jpeg,width=640,height=480,framerate=30/1 ! jpegdec ! aspectratiocrop aspect-ratio=16/9 ! videoflip method=horizontal-flip ! autovideosink")
else:
self.player = Gst.parse_launch("v4l2src device=\"/dev/video1\" ! image/jpeg,width=640,height=480,framerate=30/1 ! jpegdec ! aspectratiocrop aspect-ratio=16/9 ! autovideosink")
# Set up the gstreamer pipeline
# self.player = Gst.parse_launch("v4l2src ! autovideosink")
# self.player = Gst.parse_launch("v4l2src device=\"/dev/video1\" ! autovideosink")
# self.player = Gst.parse_launch("v4l2src device=\"/dev/video1\" ! video/x-raw-yuv,width=320,height=240,framerate=30/1 ! autovideosink")
# self.player = Gst.parse_launch("v4l2src device=\"/dev/video1\" ! video/x-raw-yuv,width=320,height=240,framerate=30/1 ! textoverlay font-desc=\"Sans 20\" text=\"Microsoft LifeCam NX-3000\" valign=top halign=left shaded-background=true ! timeoverlay halign=right valign=bottom font-desc=\"Sans 20\" ! clockoverlay halign=left valign=bottom text=\"\" time-format=\"%d.%m.%Y %H:%M:%S \" font-desc=\"Sans 20\" ! autovideosink")
# self.player = Gst.parse_launch("v4l2src device=\"/dev/video1\" ! image/jpeg,width=640,height=480,framerate=30/1 ! jpegdec ! autovideosink")
# self.player = Gst.parse_launch("v4l2src device=\"/dev/video1\" ! image/jpeg,width=640,height=480,framerate=30/1 ! jpegdec ! aspectratiocrop aspect-ratio=16/9 ! textoverlay valignment=bottom xpad=450 ypad=25 color=4278255360 font-desc=\"Sans 20\" text=\"Microsoft LifeCam NX-3000\" shaded-background=true ! timeoverlay halignment=right color=4278255360 font-desc=\"Sans 20\" ! clockoverlay color=4278255360 text=\"\" time-format=\"%d.%m.%Y %H:%M:%S \" font-desc=\"Sans 20\" ! autovideosink")
# self.player = Gst.parse_launch("v4l2src device=\"/dev/video1\" ! image/jpeg,width=640,height=480,framerate=30/1 ! jpegdec ! aspectratiocrop aspect-ratio=16/9 ! videoflip method=horizontal-flip ! autovideosink")
self.startcam ="Stop"
else:
self.player = Gst.parse_launch("videotestsrc ! video/x-raw,width=640,height=480,framerate=30/1 ! aspectratiocrop aspect-ratio=16/9 ! autovideosink")
# self.player = Gst.parse_launch("videotestsrc ! autovideosink")
self.startcam = "Start"
bus = self.player.get_bus()
bus.add_signal_watch()
bus.enable_sync_message_emission()
bus.connect("message", self.on_message)
bus.connect("sync-message::element", self.on_sync_message)
self.player.set_state(Gst.State.PLAYING)
def __init__(self, pipeline_string='videotestsrc pattern=18 ! tee name=t ! queue ! autovideosink t. ! queue ! videoconvert ! videorate ! video/x-raw,width=(int)320,height=(int)240,format=(string)RGB16,framerate=(fraction)30/1 ! appsink name=sink'):
self.data = None# this will contain the data passed between
self.source_id = None
self.lock = Lock()
self.isWhite = True
self.isStream = True
self.timestamp = 0
self.pipeline = Gst.parse_launch(pipeline_string)
self.appsink = self.pipeline.get_by_name('sink')
assert self.appsink, 'appsink element named \'sink\' not found'
self.appsink.connect('new-sample', self.on_new_buffer)
self.appsink.set_property('emit-signals', True)
self.pipeline.set_state(Gst.State.PLAYING)
# OUTPUT pipeline
self.pipeline_out = Gst.parse_launch('appsrc name=source ! videoconvert ! autovideosink')
self.appsrc = self.pipeline_out.get_by_name('source')
assert self.appsrc, 'appsrc element named \'source\' not found'
self.appsrc.set_property('caps', Gst.Caps.from_string('video/x-raw,format=(string)RGB16,width=(int)320,height=(int)240,framerate=(fraction)30/1'))
self.appsrc.connect('need-data', self.on_need_data)
self.appsrc.connect('enough-data', self.on_enough_data)
self.pipeline_out.set_state(Gst.State.PLAYING)
GObject.timeout_add_seconds(2, self._switch_data_type)
def makeReference(self, video):
'''
Make the reference videos.
:param string video: Path to the selected video.
'''
VTLOG.info('Making reference...')
self.pipeline = Gst.parse_launch('filesrc name=source ! decodebin ! videorate ! video/x-raw,framerate=%s/1 ! filesink name=sink1' % self.framerate)
source = self.pipeline.get_by_name('source')
sink1 = self.pipeline.get_by_name('sink1')
self.files['original'].append(video)
source.props.location = video
location = self.path + '_ref_original.yuv'
self.files['original'].append(location)
sink1.props.location = location
self.__play()
self.pipeline = Gst.parse_launch('filesrc name=source ! decodebin ! videorate ! video/x-raw,framerate=%s/1 ! %s bitrate=%s ! tee name=t ! queue %s ! filesink name=sink2 t. ! queue ! decodebin ! filesink name=sink3' % (
self.framerate,
supported_codecs[self.codec]['encoder'],
supported_codecs[self.codec]['bitrate_from_kbps'](self.bitrate),
supported_codecs[self.codec]['add']
))
source = self.pipeline.get_by_name('source')
sink2 = self.pipeline.get_by_name('sink2')
sink3 = self.pipeline.get_by_name('sink3')
source.props.location = video
location = self.path + '_ref.' + self.codec
self.files['coded'].append(location)
sink2.props.location = location
location = self.path + '_ref.yuv'
self.files['coded'].append(location)
sink3.props.location = location
self.__play()
VTLOG.info('Reference made')
def _convert_to_mp3(self, src, dst):
"""
Convert file to mp3
@param src as Gio.File
@param dst as Gio.File
@return Gst.Pipeline
"""
try:
# We need to escape \ in path
src_path = src.get_path().replace("\\", "\\\\\\")
dst_path = dst.get_path().replace("\\", "\\\\\\")
if self._normalize:
pipeline = Gst.parse_launch(
'filesrc location="%s" ! decodebin\
! audioconvert\
! rgvolume pre-amp=6.0 headroom=10.0\
! rglimiter ! audioconvert\
! lamemp3enc ! id3v2mux\
! filesink location="%s"'
% (src_path, dst_path))
else:
pipeline = Gst.parse_launch(
'filesrc location="%s" ! decodebin\
! audioconvert ! lamemp3enc ! id3v2mux\
! filesink location="%s"'
% (src_path, dst_path))
pipeline.set_state(Gst.State.PLAYING)
return pipeline
except Exception as e:
print("MtpSync::_convert_to_mp3(): %s" % e)
return None
def _has_espeak_module():
try:
Gst.parse_launch('espeak')
except GError:
logging.error('The speech plugin is not installed in the system.')
return False
return True
def __init__(self, ip_address, partners_quality):
# Create GStreamer pipeline
self.pipeline = Gst.Pipeline()
partners_quality = partners_quality.rstrip()
if partners_quality.lower() == "h":
self.pipeline = Gst.parse_launch("rtpbin name=rtpbin v4l2src ! videoscale ! videoconvert ! video/x-raw,format=UYVY,width=640,height=480,framerate=30/1 ! videoscale ! videoconvert ! avenc_mpeg4 bitrate=1000000 ! tee name=t ! rtpmp4vpay ! rtpbin.send_rtp_sink_0 t. ! queue ! xvimagesink rtpbin.send_rtp_src_0 ! udpsink name=udpsink_video port=5002 host=" + ip_address + " rtpbin.send_rtcp_src_0 ! udpsink port=5003 host=" + ip_address + " sync=false async=false udpsrc port=5007 ! rtpbin.recv_rtcp_sink_0")
print "You've sent High Quality data"
else:
self.pipeline = Gst.parse_launch("rtpbin name=rtpbin v4l2src ! videoscale ! videoconvert ! video/x-raw,format=UYVY,width=640,height=480,framerate=30/1 ! videoscale ! videoconvert ! avenc_mpeg4 bitrate=150000 ! tee name=t ! rtpmp4vpay ! rtpbin.send_rtp_sink_0 t. ! queue ! xvimagesink rtpbin.send_rtp_src_0 ! udpsink name=udpsink_video port=5002 host=" + ip_address + " rtpbin.send_rtcp_src_0 ! udpsink port=5003 host=" + ip_address + " sync=false async=false udpsrc port=5007 ! rtpbin.recv_rtcp_sink_0")
print "You've sent Low Quality data"
def _check(self, song):
old_threshold = Gst.debug_get_default_threshold()
Gst.debug_set_default_threshold(Gst.DebugLevel.NONE)
pipeline = Gst.parse_launch(
"uridecodebin uri=%s ! fakesink" % song("~uri"))
bus = pipeline.get_bus()
pipeline.set_state(Gst.State.PLAYING)
try:
while 1:
message = bus.timed_pop(Gst.SECOND * 10)
if not message or message.type == Gst.MessageType.ERROR:
if message:
debug = message.parse_error()[0].message
else:
debug = "timed out"
# only print a warning for platforms where we control
# the shipped dependencies.
if sys.platform == "darwin" or os.name == "nt":
print_w("GStreamer: Decoding %r failed (%s)" %
(song("~format"), debug))
break
if message.type == Gst.MessageType.EOS:
break
finally:
pipeline.set_state(Gst.State.NULL)
Gst.debug_set_default_threshold(old_threshold)
def _create_waveform(self, song, points):
# Close any existing pipeline to avoid leaks
self._clean_pipeline()
if not song.is_file:
return
command_template = """
uridecodebin name=uridec
! audioconvert
! level name=audiolevel interval={} post-messages=true
! fakesink sync=false"""
interval = int(song("~#length") * 1E9 / points)
print_d("Computing data for each %.3f seconds" % (interval / 1E9))
command = command_template.format(interval)
pipeline = Gst.parse_launch(command)
pipeline.get_by_name("uridec").set_property("uri", song("~uri"))
bus = pipeline.get_bus()
self._bus_id = bus.connect("message", self._on_bus_message)
bus.add_signal_watch()
pipeline.set_state(Gst.State.PLAYING)
self._pipeline = pipeline
self._new_rms_vals = []
def __updatePipeline(self):
"""Creates / updates the GStreamer pipeline according to the currently set state."""
print "Updating Pipeline, isReady: {}, isRunning: {}, isRecording: {} ".format(self.isReady, self.isRunning, self.isRecording)
if self.pl:
self.pl.set_state(Gst.State.NULL)
self.pl = []
pipeString = ""
if self.isRecording:
# pipeString = self.source + \
# " ! tee name=t t. ! queue ! videoconvert ! x264enc ! mp4mux ! filesink location=outvid01 async=0 t. ! queue ! autovideosink"
pipeString = "videotestsrc ! tee name=t t. ! queue ! videoconvert ! x264enc ! mp4mux ! filesink location=outvid01 async=0 t. ! queue ! autovideosink"
else:
pipeString = self.source + " ! autovideosink"
print "\tPipeline String: " + pipeString
self.pl = Gst.parse_launch(pipeString)
# intercept sync messages so we can set in which window to draw in
bus = self.pl.get_bus()
bus.add_signal_watch()
bus.enable_sync_message_emission()
bus.connect("message::eos", self.__onEos)
bus.connect("message::error", self.__onError)
bus.connect("sync-message::element", self.__onSyncMessage)
if self.isRunning:
self.pl.set_state(Gst.State.PLAYING)
else:
self.pl.set_state(Gst.State.NULL)
print "\tWinID: " + str(self.targetWin.winId())
def __init__(self, options={}):
base.Base.__init__(self, options)
Gst.Bin.__init__(self)
aux = pipestr.replace("gc-hauppauge-preview", "sink-" + self.options['name'])
#bin = Gst.parse_bin_from_description(aux, True)
bin = Gst.parse_launch("( {} )".format(aux))
self.add(bin)
sink = self.get_by_name("gc-hauppauge-device-src")
sink.set_property("device", self.options["locprevideo"])
sink = self.get_by_name("gc-hauppauge-file-src")
sink.set_property("location", self.options["location"])
sink = self.get_by_name("gc-hauppauge-audio-src")
sink.set_property("location", self.options["locpreaudio"])
if self.options["player"] == False:
self.mute = True
element = self.get_by_name("gc-hauppauge-volume")
element.set_property("mute", True)
else:
self.mute = False
sink = self.get_by_name("gc-hauppauge-sink")
sink.set_property('location', path.join(self.options['path'], self.options['file']))
if self.options["vumeter"] == False:
level = self.get_by_name("gc-hauppauge-level")
level.set_property("message", False)
def _check(self, song):
old_threshold = Gst.debug_get_default_threshold()
Gst.debug_set_default_threshold(Gst.DebugLevel.NONE)
pipeline = Gst.parse_launch(
"uridecodebin uri=%s ! fakesink" % song("~uri"))
bus = pipeline.get_bus()
pipeline.set_state(Gst.State.PLAYING)
error = None
try:
while 1:
message = bus.timed_pop(Gst.SECOND * 40)
if not message or message.type == Gst.MessageType.ERROR:
if message:
error = message.parse_error()[0].message
else:
error = "timed out"
break
if message.type == Gst.MessageType.EOS:
break
finally:
pipeline.set_state(Gst.State.NULL)
Gst.debug_set_default_threshold(old_threshold)
return error
def mk_pipe(self):
# self.pipeline = Gst.parse_launch( "uridecodebin name=decode ! audioconvert ! level name=wavelevel ! fakesink name=faked" )
# self.pipeline = Gst.parse_launch( "filesrc name=filesrc ! qtdemux ! audioconvert ! level name=wavelevel ! fakesink")
self.pipeline = Gst.parse_launch(
"filesrc name=filesrc ! decodebin ! audioconvert ! level name=wavelevel ! fakesink"
)
# if self.uri.startswith('/'):
# self.uri = "file://" + self.uri
# decode = self.pipeline.get_by_name("decode")
# decode.set_property( 'uri', self.uri )
filesrc = self.pipeline.get_by_name("filesrc")
filesrc.set_property("location", self.location)
wavelevel = self.pipeline.get_by_name("wavelevel")
wavelevel.set_property("interval", int(self.interval * Gst.SECOND))
wavelevel.set_property("post-messages", True)
bus = self.pipeline.get_bus()
bus.add_signal_watch()
bus.connect("message", self._messageCb)
return
def on_connect(self, sock, *args):
'''Asynchronous connection listener. Starts a handler for each connection.'''
if self.source_pipeline:
return False
conn, addr = sock.accept()
print("Connection from", addr)
self.source_pipeline = Gst.parse_launch("""
fdsrc name=a fd=%u !
matroskademux name=demux
demux. !
video/x-raw,width=800,height=450,format=I420,framerate=25/1 !
queue !
textoverlay halignment=left valignment=top ypad=25 text=intervideosink !
timeoverlay halignment=left valignment=top ypad=25 xpad=400 !
intervideosink channel=video
demux. !
audio/x-raw,format=S16LE,channels=2,layout=interleaved,rate=48000,channel-mask=(bitmask)0x3 !
queue !
interaudiosink channel=audio
""" % conn.fileno())
self.source_pipeline.bus.add_signal_watch()
self.source_pipeline.bus.connect("message::eos", self.on_disconnect)
self.source_pipeline.set_state(Gst.State.PLAYING)
self.conn = conn
return True
def _setupPipeline(self):
"""Creates the pipeline.
It has the form "playbin ! thumbnailsink" where thumbnailsink
is a Bin made out of "videorate ! capsfilter ! gdkpixbufsink"
"""
# TODO: don't hardcode framerate
self.pipeline = Gst.parse_launch(
"uridecodebin uri={uri} name=decode ! "
"videoconvert ! "
"videorate ! "
"videoscale method=lanczos ! "
"capsfilter caps=video/x-raw,format=(string)RGBA,height=(int){height},"
"pixel-aspect-ratio=(fraction)1/1,framerate=2/1 ! "
"gdkpixbufsink name=gdkpixbufsink".format(uri=self.uri, height=self.thumb_height))
# get the gdkpixbufsink and the sinkpad
self.gdkpixbufsink = self.pipeline.get_by_name("gdkpixbufsink")
decode = self.pipeline.get_by_name("decode")
decode.connect("autoplug-select", self._autoplug_select_cb)
self.__preroll_timeout_id = GLib.timeout_add_seconds(MAX_BRINGING_TO_PAUSED_DURATION,
self.__preroll_timed_out_cb)
self.pipeline.get_bus().add_signal_watch()
self.pipeline.get_bus().connect("message", self.__bus_message_cb)
self.pipeline.set_state(Gst.State.PAUSED)
def __init__(self):
Gtk.Window.__init__(self)
self.image = None
GLib.timeout_add(50, self.save_image)
self.connect("delete-event", self.on_quit)
# Status
self.status = Gst.State.NULL
# Video Area
self.video_area = Gtk.DrawingArea()
# Disable Double Buffered
self.video_area.set_double_buffered(False)
# playbin
self.player = Gst.parse_launch("tcpclientsrc host=" + sys.argv[1] +" port=5000 ! gdpdepay ! rtph264depay ! avdec_h264 ! videoconvert ! xvimagesink name=xv")
bus = self.player.get_bus()
bus.add_signal_watch()
bus.enable_sync_message_emission()
bus.connect("message", self.on_message)
bus.connect("sync-message::element", self.on_sync_message)
# DnD
dnd_list = Gtk.TargetEntry.new("text/uri-list", 0, 0)
# pack
vbox = Gtk.Box.new(Gtk.Orientation.VERTICAL, 0)
vbox.pack_start(self.video_area, True, True, 0)
self.add(vbox)
self.resize(640, 480)
self.show_all()
self.player.set_state(Gst.State.PLAYING)
def _launchPipeline(self):
self.debug(
'Now generating waveforms for: %s', path_from_uri(self._uri))
self.pipeline = Gst.parse_launch("uridecodebin name=decode uri=" +
self._uri + " ! waveformbin name=wave"
" ! fakesink qos=false name=faked")
# This line is necessary so we can instantiate GstTranscoder's
# GstCpuThrottlingClock below.
Gst.ElementFactory.make("uritranscodebin", None)
clock = GObject.new(GObject.type_from_name("GstCpuThrottlingClock"))
clock.props.cpu_usage = self._max_cpu_usage
self.pipeline.use_clock(clock)
faked = self.pipeline.get_by_name("faked")
faked.props.sync = True
self._wavebin = self.pipeline.get_by_name("wave")
asset = self.ges_elem.get_parent().get_asset()
self._wavebin.props.uri = asset.get_id()
self._wavebin.props.duration = asset.get_duration()
decode = self.pipeline.get_by_name("decode")
decode.connect("autoplug-select", self._autoplug_select_cb)
bus = self.pipeline.get_bus()
bus.add_signal_watch()
asset = self.ges_elem.get_parent().get_asset()
self.n_samples = asset.get_duration() / SAMPLE_DURATION
bus.connect("message", self._busMessageCb)
def __init__(self):
QtCore.QObject.__init__(self)
self._supported_extensions = []
for plugin, extensions in self.PLUGINS.items():
print("Testing plugin \"" + plugin + "\" ..."),
if Gst.Registry.find_plugin(Gst.Registry.get(), plugin) is not None:
print("supported.")
self._supported_extensions.extend(extensions)
else:
print("NOT supported.")
self.uri = None
self._status = State.STOPPED
self.bin = Gst.ElementFactory.make('playbin', None)
self.bin.set_property('video-sink', None)
try:
device = Gst.parse_launch(self.SINK)
except GObject.GError:
pass
else:
self.bin.set_property('audio-sink', device)
bus = self.bin.get_bus()
bus.add_signal_watch()
bus.connect('message::eos', self._message_eos)
bus.connect('message::error', self._message_error)
bus.connect('message::async-done', self._message_async_done)
self.time_fmt = Gst.Format(Gst.Format.TIME)
self.seek_pending = False
def GStreamerSink(pipeline_desc):
"""Returns a list of unlinked gstreamer elements ending with an audio sink
and a textual description of the pipeline.
`pipeline_desc` can be gst-launch syntax for multiple elements
with or without an audiosink.
In case of an error, raises PlayerError
"""
pipe = None
if pipeline_desc:
try:
pipe = [Gst.parse_launch(e) for e in pipeline_desc.split('!')]
except GLib.GError as e:
message = e.message.decode("utf-8")
raise PlayerError(_("Invalid GStreamer output pipeline"), message)
if pipe:
# In case the last element is linkable with a fakesink
# it is not an audiosink, so we append the default one
fake = Gst.ElementFactory.make('fakesink', None)
if link_many([pipe[-1], fake]):
unlink_many([pipe[-1], fake])
default_elm, default_desc = find_audio_sink()
pipe += [default_elm]
pipeline_desc += " ! " + default_desc
else:
elm, pipeline_desc = find_audio_sink()
pipe = [elm]
return pipe, pipeline_desc
def _create_pipeline(self):
"""
Create a GstPipeline that contains our encoding, etc
"""
if self.current_filename == "":
location = self._generate_location()
else:
location = self.current_filename
encoder = self._select_encoder()
sink_str = self._select_sink()
save_str = ("appsrc name={} is-live=true format=3 "
"! {} "
"! queue leaky=downstream "
"! videoconvert "
"! {} "
"! {} name={} location={}").format(self.src_name,
self.caps.to_string(),
encoder.module,
sink_str,
self.sink_name,
location)
log.info("Using pipeline to save: '{}'".format(save_str))
self.pipeline = Gst.parse_launch(save_str)
self.src = self.pipeline.get_by_name(self.src_name)
self.src.set_property("caps", self.caps)
self.src.set_property("do-timestamp", True)
self.pipeline.set_name(self.pipeline_name)
def __init__(self, options={}):
base.Base.__init__(self, options)
Gst.Bin.__init__(self)
aux = (pipestr.replace('gc-v4l2-preview', 'sink-' + self.options['name'])
.replace('gc-v4l2-enc', self.options['videoencoder'])
.replace('gc-v4l2-mux', self.options['muxer']))
if self.options['videofilter']:
aux = aux.replace('gc-videofilter', self.options['videofilter'])
else:
aux = aux.replace('gc-videofilter !', '')
if 'image/jpeg' in self.options['caps']:
aux = aux.replace('gc-v4l2-dec', 'jpegdec max-errors=-1 ! queue !')
else:
aux = aux.replace('gc-v4l2-dec', '')
#bin = Gst.parse_bin_from_description(aux, True)
bin = Gst.parse_launch("( {} )".format(aux))
self.add(bin)
self.set_option_in_pipeline('location', 'gc-v4l2-src', 'device')
self.set_value_in_pipeline(path.join(self.options['path'], self.options['file']), 'gc-v4l2-sink', 'location')
self.set_option_in_pipeline('caps', 'gc-v4l2-filter', 'caps', None)
def copyThumbPic(self, fsink, buffer, pad, user_data=None):
if not self._thumb_exposure_open:
return
self._thumb_exposure_open = False
loader = Gtk.Gdk.pixbuf_loader_new_with_mime_type("image/jpeg")
loader.write(buffer)
loader.close()
self.thumbBuf = loader.get_pixbuf()
self.model.still_ready(self.thumbBuf)
self._thumb_element('thumb_tee').unlink(self._thumb_element('thumb_queue'))
oggFilepath = os.path.join(Instance.instancePath, "output.ogg") #ogv
wavFilepath = os.path.join(Instance.instancePath, "output.wav")
muxFilepath = os.path.join(Instance.instancePath, "mux.ogg") #ogv
muxline = Gst.parse_launch('filesrc location=' + str(oggFilepath) + ' name=muxVideoFilesrc ! oggdemux name=muxOggdemux ! theoraparse ! oggmux name=muxOggmux ! filesink location=' + str(muxFilepath) + ' name=muxFilesink filesrc location=' + str(wavFilepath) + ' name=muxAudioFilesrc ! wavparse name=muxWavparse ! audioconvert name=muxAudioconvert ! vorbisenc name=muxVorbisenc ! muxOggmux.')
taglist = self._get_tags(constants.TYPE_VIDEO)
vorbis_enc = muxline.get_by_name('muxVorbisenc')
vorbis_enc.merge_tags(taglist, Gst.TAG_MERGE_REPLACE_ALL)
muxBus = muxline.get_bus()
muxBus.add_signal_watch()
self._video_transcode_handler = muxBus.connect('message', self._onMuxedVideoMessageCb, muxline)
self._mux_pipes.append(muxline)
#add a listener here to monitor % of transcoding...
self._transcode_id = GObject.timeout_add(200, self._transcodeUpdateCb, muxline)
muxline.set_state(Gst.STATE_PLAYING)
def test_create_thumbnail_bin(self):
"""Checks our `waveformbin` element is usable."""
pipeline = Gst.parse_launch("uridecodebin name=decode uri=file:///some/thing"
" waveformbin name=wavebin ! fakesink qos=false name=faked")
self.assertTrue(pipeline)
wavebin = pipeline.get_by_name("wavebin")
self.assertTrue(wavebin)
def async_process_file(self, filename, end_callback):
self.end_callback = end_callback
at = self.ensure_new_type('sound_segment', title=_("Sound segment"))
at.setMetaData(config.data.namespace_prefix['dc'], "description", _("Sound segmentation with a threshold of %(threshold)d dB - channel: %(channel)s") % self.__dict__)
# Build pipeline
self.pipeline = Gst.parse_launch('uridecodebin name=decoder ! audioconvert ! audiopanorama method=1 panorama=%d ! audioconvert ! cutter threshold-dB=%s run-length=%d ! progressreport silent=true update-freq=1 name=report ! fakesink' % (self.channel_mapping[self.channel], str(self.threshold), self.min_silence_duration * Gst.MSECOND))
self.decoder = self.pipeline.get_by_name('decoder')
self.report = self.pipeline.get_by_name('report')
bus = self.pipeline.get_bus()
# Enabling sync_message_emission will in fact force the
# self.progress call from a thread other than the main thread,
# which surprisingly works better ATM.
bus.enable_sync_message_emission()
bus.connect('sync-message', self.on_bus_message)
bus.connect('message', self.on_bus_message)
if config.data.os == 'win32':
self.decoder.props.uri = 'file:///' + os.path.abspath(str(filename))
else:
self.decoder.props.uri = 'file://' + os.path.abspath(str(filename))
self.progress(.1, _("Starting silence detection"))
self.pipeline.set_state(Gst.State.PLAYING)
return self.package
def _video_eos(self):
self._pipeline.set_state(Gst.STATE_NULL)
self._pipeline.get_by_name("tee").unlink(self._videobin)
self._pipeline.remove(self._videobin)
self._pipeline.remove(self._audiobin)
self.model.shutter_sound()
if len(self._thumb_pipes) > 0:
thumbline = self._thumb_pipes[-1]
thumbline.get_by_name('thumb_fakesink').disconnect(self._thumb_handoff_handler)
ogg_path = os.path.join(Instance.instancePath, "output.ogg") #ogv
if not os.path.exists(ogg_path) or os.path.getsize(ogg_path) <= 0:
# FIXME: inform model of failure?
return
line = 'filesrc location=' + ogg_path + ' name=thumbFilesrc ! oggdemux name=thumbOggdemux ! theoradec name=thumbTheoradec ! tee name=thumb_tee ! queue name=thumb_queue ! ffmpegcolorspace name=thumbFfmpegcolorspace ! jpegenc name=thumbJPegenc ! fakesink name=thumb_fakesink'
thumbline = Gst.parse_launch(line)
thumb_queue = thumbline.get_by_name('thumb_queue')
thumb_queue.set_property("leaky", True)
thumb_queue.set_property("max-size-buffers", 1)
thumb_tee = thumbline.get_by_name('thumb_tee')
thumb_fakesink = thumbline.get_by_name('thumb_fakesink')
self._thumb_handoff_handler = thumb_fakesink.connect("handoff", self.copyThumbPic)
thumb_fakesink.set_property("signal-handoffs", True)
self._thumb_pipes.append(thumbline)
self._thumb_exposure_open = True
thumbline.set_state(Gst.STATE_PLAYING)
def init_camera(self):
# TODO: This doesn't work when camera resolution is resized at runtime.
# There must be some other way to release the camera?
if self._pipeline:
self._pipeline = None
video_src = self._video_src
if video_src == 'v4l2src':
video_src += ' device=/dev/video%d' % self._index
elif video_src == 'dc1394src':
video_src += ' camera-number=%d' % self._index
if Gst.version() < (1, 0, 0, 0):
caps = ('video/x-raw-rgb,red_mask=(int)0xff0000,'
'green_mask=(int)0x00ff00,blue_mask=(int)0x0000ff')
pl = ('{} ! decodebin name=decoder ! ffmpegcolorspace ! '
'appsink name=camerasink emit-signals=True caps={}')
else:
caps = 'video/x-raw,format=RGB'
pl = '{} ! decodebin name=decoder ! videoconvert ! appsink ' + \
'name=camerasink emit-signals=True caps={}'
self._pipeline = Gst.parse_launch(pl.format(video_src, caps))
self._camerasink = self._pipeline.get_by_name('camerasink')
self._camerasink.connect('new-sample', self._gst_new_sample)
self._decodebin = self._pipeline.get_by_name('decoder')
if self._camerasink and not self.stopped:
self.start()
def __init__(self, sink):
Gst.Pipeline.__init__(self)
self.playbin = Gst.ElementFactory.make("playbin")
self.add(self.playbin)
bin = Gst.Bin()
self.speedchanger = Gst.ElementFactory.make("pitch")
if self.speedchanger is None:
myGtk.show_error(_("You need to install the Gstreamer soundtouch elements for "
"play it slowly to. They are part of Gstreamer-plugins-bad. Consult the "
"README if you need more information.")).run()
raise SystemExit()
bin.add(self.speedchanger)
self.audiosink = Gst.parse_launch(sink)
#self.audiosink = Gst.ElementFactory.make(sink, "sink")
bin.add(self.audiosink)
convert = Gst.ElementFactory.make("audioconvert")
bin.add(convert)
self.speedchanger.link(convert)
convert.link(self.audiosink)
sink_pad = Gst.GhostPad.new("sink", self.speedchanger.get_static_pad("sink"))
bin.add_pad(sink_pad)
self.playbin.set_property("audio-sink", bin)
#bus = self.playbin.get_bus()
#bus.add_signal_watch()
#bus.connect("message", self.on_message)
self.eos = lambda: None
def convert(inFile, outFile, quality):
if not os.path.exists(inFile):
raise Exception('File does not exist: "', fileName, '"')
player = Gst.parse_launch(
"filesrc name=src ! flacparse ! flacdec ! audioconvert ! "
"lamemp3enc name=enc ! id3v2mux "
"! filesink name=sink"
)
bus = player.get_bus()
src = player.get_by_name("src")
src.set_property("location", inFile)
sink = player.get_by_name("sink")
sink.set_property("location", outFile)
enc = player.get_by_name("enc")
enc.set_property("quality", quality)
player.set_state(Gst.State.PLAYING)
while True:
message = bus.pop()
if not message:
continue
t = message.type
if t == Gst.MessageType.EOS:
break
elif t == Gst.MessageType.ERROR:
err, debug = message.parse_error()
print "Error: %s" % err, debug
break
player.set_state(Gst.State.NULL)
def __initVideo(self):
self.pipeline = Gst.parse_launch(
'filesrc name=video1 filesrc name=video2 filesrc name=video3 \
videomixer name=mix ! xvimagesink \
video1. \
! queue ! videoparse framerate=%s/1 name=parser1 \
! textoverlay font-desc="Sans 24" text="Original" \
valignment=top halignment=left shaded-background=true \
! videoscale \
! mix.sink_1 \
video2. \
! queue ! videoparse framerate=%s/1 name=parser2 \
! textoverlay font-desc="Sans 24" text="Coded" \
valignment=top halignment=left shaded-background=true \
! videoscale \
! mix.sink_2 \
video3. \
! queue ! videoparse framerate=%s/1 name=parser3 \
! textoverlay font-desc="Sans 24" text="Received" \
valignment=top halignment=left shaded-background=true \
! videoscale \
! mix.sink_3' % (
self.main.conf['framerate'],
self.main.conf['framerate'],
self.main.conf['framerate']
))
bus = self.pipeline.get_bus()
bus.add_signal_watch()
bus.enable_sync_message_emission()
bus.connect('message', self.onMessage)
bus.connect('sync-message::element', self.onSyncMessage)
def __init__(self, loop=None):
self.default_volume = 10
self.raw_buffers = []
self.fft_magnitudes = [0.0] * BINS
self.fft_frequency_bands = [i * (SAMPLING_FREQUENCY / BINS / 2)
for i in range(BINS)]
self.fft_samples_taken = 0
self.loop = loop
self.in_range = False
self.pipeline = Gst.parse_launch('''autoaudiosrc name=recordersrc
! queue
! level message=true name=recorderlevel
! audioconvert
! audio/x-raw,channels=1, rate=(int)44100
! audioresample
! spectrum interval=100000000 bands = %(bands)s
! wavenc
! appsink name=recordersink emit-signals=true''' %
{'bands': BINS})
self.sink = self.pipeline.get_by_name('recordersink')
self.sink.connect('new-sample', self.nextbuffer)
self.recordersource = self.pipeline.get_by_name('recordersrc')
self.bus = self.pipeline.get_bus()
self.bus.add_signal_watch()
self.bus.connect('message', self.bus_message_handler)
self.volume = 0
self.volumecontrol(self.volume)
def __init__(self, options={}):
base.Base.__init__(self, options)
Gst.Bin.__init__(self)
gcvideosink = get_videosink(videosink=self.options['videosink'], name='sink-'+self.options['name'])
gcaudiosink = get_audiosink(audiosink=self.options['audiosink'], name='sink-audio-'+self.options['name'])
aux = (pipestr.replace('gc-vsink', gcvideosink)
.replace('gc-asink', gcaudiosink))
if self.options["caps-preview"]:
aux = aux.replace("caps-preview !","videoscale ! videorate ! "+self.options["caps-preview"]+" !")
else:
aux = aux.replace("caps-preview !","")
#bin = Gst.parse_bin_from_description(aux, False)
bin = Gst.parse_launch("( {} )".format(aux))
self.add(bin)
sink = self.get_by_name("gc-firewireavi-sink")
sink.set_property('location', path.join(self.options['path'], self.options['file']))
if self.options["vumeter"] == False:
level = self.get_by_name("gc-firewireavi-level")
level.set_property("message", False)
if self.options["player"] == False:
self.mute = True
element = self.get_by_name("gc-firewireavi-volume")
element.set_property("mute", True)
else:
self.mute = False
def build_pipeline(self):
sink = 'autovideosink'
if config.data.player['vout'] == 'x11':
sink = 'ximagesink'
elif config.data.player['vout'] == 'xvideo':
sink = 'xvimagesink'
elif config.data.player['vout'] == 'gtk':
sink = 'gtksink'
elif config.data.player['vout'] == 'd3d':
sink = 'd3dvideosink'
elif config.data.player['vout'] == 'gl':
sink = 'glimagesinkelement'
elif config.data.player['vout'].startswith('raw:'):
# "Raw" element definition - will be passed to Gst.parse_launch
sink = config.data.player['vout'][4:]
self.player = Gst.ElementFactory.make("playbin", "player")
self.video_sink = Gst.Bin()
# TextOverlay does not seem to be present in win32 installer. Do without it.
try:
self.captioner = Gst.ElementFactory.make('textoverlay',
'captioner')
# FIXME: move to config.data
self.captioner.props.font_desc = 'Sans 24'
except:
self.captioner = None
self.imageoverlay = None
if config.data.player['svg'] and svgelement:
try:
self.imageoverlay = Gst.ElementFactory.make(
svgelement, 'overlay')
self.imageoverlay.props.fit_to_frame = True
except:
logger.error("Gstreamer SVG overlay element is not available",
exc_info=True)
self.imagesink = Gst.parse_launch(f"{sink} name=sink")
try:
self.imagesink.set_property('force-aspect-ratio', True)
except TypeError:
logger.warning("Cannot set force-aspect-ratio on video sink")
self.real_imagesink = self.imagesink
elements = []
elements.append(Gst.ElementFactory.make('videoconvert', None))
elements.append(Gst.ElementFactory.make('videoscale', None))
if self.imageoverlay is not None:
# FIXME: Issue: rsvgoverlay.fit_to_frame expects that the
# dimensions of the input buffers match the aspect ratio
# of the original video, which is currently not the case.
elements.append(Gst.ElementFactory.make('queue', None))
elements.append(self.imageoverlay)
if self.captioner is not None:
elements.append(self.captioner)
# Add a queue before display
elements.append(Gst.ElementFactory.make('queue', None))
if sink == 'glimagesinkelement':
upload = Gst.ElementFactory.make('glupload', None)
csp = Gst.ElementFactory.make('glcolorconvert', None)
elements.extend((upload, csp, self.imagesink))
else:
csp = Gst.ElementFactory.make('videoconvert', None)
elements.extend((csp, self.imagesink))
for el in elements:
self.video_sink.add(el)
if len(elements) >= 2:
for src, dst in zip(elements, elements[1:]):
src.link(dst)
self.log("using " + sink)
# Note: it is crucial to make ghostpad an attribute, so that
# it is not garbage-collected at the end of the build_pipeline
# method.
self._video_ghostpad = Gst.GhostPad.new(
'sink', elements[0].get_static_pad('video_sink')
or elements[0].get_static_pad('sink'))
# Idem for elements
self._video_elements = elements
logger.debug("Using video sink pipeline %s", self._video_elements)
self.video_sink.add_pad(self._video_ghostpad)
self.player.props.video_sink = self.video_sink
self.player.props.force_aspect_ratio = True
self.audio_sink = Gst.parse_launch(
'scaletempo name=scaletempo ! audioconvert ! audioresample ! autoaudiosink'
)
self.audio_sink.add_pad(
Gst.GhostPad.new(
'sink',
self.audio_sink.get_child_by_name('scaletempo').get_static_pad(
'sink')))
self.player.props.audio_sink = self.audio_sink
bus = self.player.get_bus()
bus.enable_sync_message_emission()
bus.connect('sync-message::element', self.on_sync_message)
bus.add_signal_watch()
bus.connect('message::error', self.on_bus_message_error)
bus.connect('message::warning', self.on_bus_message_warning)
def __init__(self, serial, width, height, framerate, cam_name,
camera_info_url):
""" Constructor.
Creates the sink pipeline and the source pipeline.
:param serial: Serial number of the camera to use.
:param width: Width of the video format, e.g. 640, 1920 etc,
:param height: Height of the video format, e.g. 480, 1080
:param framerate: Numerator of the frame rate, e.g. 15, 30, 60 etc
:param color: If True, color is used, else gray scale
:param liveview: If True an own live window is opened.
"""
Gst.init([])
self.height = height
self.width = width
self.sample = None
self.samplelocked = False
self.newsample = False
self.pid = -1
self.camera_name = cam_name
self.camera_info_url = camera_info_url
self.randshm = random_str(8)
self.__remove_tmp_file()
pixelformat = "BGRx"
color = True
liveview = False
if not color:
pixelformat = "GRAY8"
if liveview:
p = 'tcambin serial="%s" name=source ! video/x-raw,format=%s,width=%d,height=%d,framerate=%d/1' % (
serial,
pixelformat,
width,
height,
framerate,
)
p += ' ! tee name=t'
p += ' t. ! queue ! videoconvert ! video/x-raw,format=RGB ,width=%d,height=%d,framerate=%d/1! shmsink socket-path=/tmp/tiscamera_%s' % (
width, height, framerate, self.randshm)
p += ' t. ! queue ! videoconvert ! ximagesink'
else:
p = 'tcambin serial="%s" name=source ! video/x-raw,format=%s,width=%d,height=%d,framerate=%d/1' % (
serial,
pixelformat,
width,
height,
framerate,
)
p += ' ! videoconvert ! video/x-raw,format=RGB ,width=%d,height=%d,framerate=%d/1! shmsink socket-path=/tmp/tiscamera_%s' % (
width, height, framerate, self.randshm)
# print(p)
try:
self.pipeline = Gst.parse_launch(p)
except GLib.Error as error:
raise RuntimeError("Error creating pipeline: {0}".format(error))
self.pipeline.set_state(Gst.State.READY)
if self.pipeline.get_state(
10 * Gst.SECOND)[0] != Gst.StateChangeReturn.SUCCESS:
raise RuntimeError("Failed to start video stream.")
# Query a pointer to our source, so we can set properties.
self.source = self.pipeline.get_by_name("source")
# Create gscam_config variable with content
gscam = 'shmsrc socket-path=/tmp/tiscamera_%s ! video/x-raw-rgb, width=%d,height=%d,framerate=%d/1' % (
self.randshm,
width,
height,
framerate,
)
gscam += ',bpp=24,depth=24,blue_mask=16711680, green_mask=65280, red_mask=255 ! ffmpegcolorspace'
os.environ["GSCAM_CONFIG"] = gscam
def init_audio(self):
self.unlink_gst()
if(self.enable):
self.chain = []
rs = int(SignalGen.sample_rates[self.sample_rate])
self.rate = float(rs)
self.interval = 1.0 / self.rate
if 0:
self.player = gst.Pipeline("mypipeline")
self.source = self.make_and_chain("appsrc", "appsrc")
if not self.source:
print("ERROR: Could not create '{0}' element".format('appsrc'))
sys.exit(1)
self.source.set_property("is-live", True)
else:
# inject the real rate
self.pipeline = self.PIPELINE_SIMPLE.format(rs)
# parse it
self.pipeline = Gst.parse_launch(self.pipeline)
self.appsrc = self.pipeline.get_by_name("appsrc")
self.appsrc.connect('need-data', self.need_data)
if 0:
caps = gst.Caps(
'audio/x-raw-int,'
'endianness=(int)1234,'
'channels=(int)2,'
'width=(int)32,'
'depth=(int)32,'
'signed=(boolean)true,'
'rate=(int)%s' % rs)
# this must be done for each buffer
# self.source.set_property('caps', caps)
self.source.connect('need-data', self.need_data)
self.source.connect('enough-data', self.enough_data)
self.source.set_property('format', 'time')
self.source.set_property('do-timestamp', True)
self.sink = self.make_and_chain("autoaudiosink")
self.player.add(*self.chain)
gst.element_link_many(*self.chain)
# print initial negotiated caps (in NULL state)
print("In NULL state:")
if 0:
print(self.sink)
print_pad_capabilities(self.sink, "sink")
if 0:
self.bus = self.player.get_bus()
else:
self.bus = self.pipeline.get_bus()
self.bus.add_signal_watch()
self.bus.enable_sync_message_emission()
self.bus.connect('message', self.on_message)
if 0:
self.player.set_state(gst.STATE_PLAYING)
else:
ret = self.pipeline.set_state(Gst.State.PLAYING)
if ret == Gst.StateChangeReturn.FAILURE:
print("ERROR: Unable to set the pipeline to the playing state")
sys.exit(1)
# print the current capabilities of the sink
print("init_audio: set state to PLAYING")
if 0:
print_pad_capabilities(self.sink, "sink")
print('enabled the output player')
else:
if 0:
if self.player:
self.player.set_state(Gst.State.NULL)
else:
if self.pipeline:
self.pipeline.set_state(Gst.State.PAUSED)
def _rtsp_start_pipeline(self):
self._pipeline = Gst.parse_launch(self._command)
bus = self._pipeline.get_bus()
bus.add_signal_watch()
bus.connect("message", self._rtsp_on_message, None)
self._pipeline.set_state(Gst.State.PLAYING)
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument("socket", help="shmsrc socket")
args = parser.parse_args(argv[1:])
cache_root = (os.environ.get("XDG_CACHE_HOME", None)
or os.environ.get("HOME") + '/.cache')
default_file = '%s/stbt/camera-video-cache/black.mp4' % cache_root
if not os.path.exists(default_file):
utils.mkdir_p(os.path.dirname(default_file))
gst_utils.frames_to_video(
default_file,
[(bytearray([0, 0, 0]) * 1280 * 720, 5 * Gst.SECOND)],
'video/x-raw,format=BGR,width=1280,height=720', 'mp4')
default_uri = "file://" + default_file
frame_bytes = 1280 * 720 * 3
next_video = [default_uri]
def about_to_finish(playbin):
playbin.set_property('uri', next_video[0])
next_video[0] = default_uri
playbin.set_state(Gst.State.PLAYING)
if USE_SHMSRC:
pipeline_desc = (
"""\
playbin name=pb audio-sink=fakesink uri=%s flags=0x00000791 \
video-sink="videoconvert \
! video/x-raw,width=1280,height=720,format=RGB ! identity ! \
shmsink wait-for-connection=true shm-size=%i max-lateness=-1 \
qos=false socket-path=%s blocksize=%i sync=true \
buffer-time=100000000" """ %
(default_uri, frame_bytes * 1000, args.socket, frame_bytes))
else:
pipeline_desc = (
"""playbin name=pb audio-sink=fakesink uri=%s flags=0x00000791 \
video-sink="videoconvert ! timeoverlay ! xvimagesink sync=true" """
% default_uri)
playbin = Gst.parse_launch(pipeline_desc)
playbin.connect("about-to-finish", about_to_finish)
runner = gst_utils.PipelineRunner(playbin)
gst_thread = threading.Thread(target=runner.run)
gst_thread.daemon = True
gst_thread.start()
playbin.get_state(0)
def set_uri(uri):
print "=== Setting URI to", uri
if uri == 'stop':
next_video[0] = default_uri
else:
next_video[0] = uri
playbin.seek(1.0, Gst.Format.TIME,
Gst.SeekFlags.FLUSH | Gst.SeekFlags.KEY_UNIT,
Gst.SeekType.END, 0, Gst.SeekType.NONE, 0)
while True:
uri = sys.stdin.readline()
if uri == '':
break
elif len(uri.strip()) > 0:
set_uri(uri.strip())
def do_create_element(self, url):
logging.info("Video pipeline to be used: {0}".format(self.videoPipeline))
return Gst.parse_launch(self.videoPipeline)
def __init__(self, pipeline):
Gst.init(None)
self._pipeline = Gst.parse_launch(pipeline)
self.running = False
import os, sys
import gi
gi.require_version('Gst', '1.0')
from gi.repository import Gst
frame_format = 'RGBA'
Gst.init()
pipeline = Gst.parse_launch(f'''
filesrc location=media/in.mp4 num-buffers=200 !
decodebin !
fakesink name=s
''')
def on_frame_probe(pad, info):
buf = info.get_buffer()
print(f'[{buf.pts / Gst.SECOND:6.2f}]')
return Gst.PadProbeReturn.OK
pipeline.get_by_name('s').get_static_pad('sink').add_probe(
Gst.PadProbeType.BUFFER, on_frame_probe)
pipeline.set_state(Gst.State.PLAYING)
try:
while True:
msg = pipeline.get_bus().timed_pop_filtered(
Gst.SECOND, Gst.MessageType.EOS | Gst.MessageType.ERROR)
if msg:
def get_pipeline(self):
description = 'rtspsrc name=rtspsrc ! rtph264depay ! h264parse ! matroskamux ! filesink location=file.mkv'
self.pipeline = Gst.parse_launch(description)
rtsp_src = self.pipeline.get_by_name("rtspsrc")
rtsp_src.set_property('location', self.url)
def construct_pipeline(configuration):
"""
Launch the gstreamer pipeline according to the choosen configuration (from configuration file).
Bass lift adjustment is made with the low 3 bands of the standard 10 band equalizer which is
not really the way to do it properly. But it is simple and fairly intuitive to use.
Also note that there are a total of 3 volume controls per channel to aid when playing
around, they should probably just be removed.
"""
# Alsa device selection
# The primary entry is used for 'left', 'right', 'mono' and 'stereo_40' (anything but 'stereo')
# Default Alsa device if left empty, use 'device=hw:X' to select a specific device instead
primary = ''
# The secondary entry is the second output alsa device used when running in 'stereo'.
# Modify to use the correct second soundcard.
secondary = 'device=hw:X'
# Input Alsa device is always the primary from above.
input = (
f'alsasrc {primary} ! audioconvert ! audio/x-raw,format=F32LE,channels=2 ! '
f'queue ! ')
if configuration in (Configuration.LEFT, Configuration.RIGHT):
# pick which of the two input channels to play (src_0 or src_1) if part of a stereo setup
channel = f'deinterleave name=d d.src_{configuration.value} ! tee name=tee_0 '
paths = [configuration.value]
alsa_devices = [primary]
channel_masks = [0x01]
interleave_index = [0]
elif configuration == Configuration.MONO:
# stereo signal mixed to mono
channel = 'audioconvert ! audio/x-raw,channels=1 ! deinterleave name=d d.src_0 ! tee name=tee_0 '
paths = [Configuration.LEFT.value]
alsa_devices = [primary]
channel_masks = [0x01]
interleave_index = [0]
else:
# 'stereo' or 'stereo_40'. 'stereo' uses two soundcards
# and 'stereo_40' two outputs on a 5.1 soundcard.
channel = 'deinterleave name=d d.src_0 ! tee name=tee_0 d.src_1 ! tee name=tee_1 '
paths = [Configuration.LEFT.value, Configuration.RIGHT.value]
if configuration == Configuration.STEREO:
alsa_devices = [primary, secondary]
channel_masks = [0x01, 0x01]
interleave_index = [0, 1]
else:
alsa_devices = [primary, primary]
channel_masks = [0x01, 0x10]
interleave_index = [0, 4]
launch = input + channel
for path in range(len(paths)):
interleave_element = 0
if not path or (configuration == Configuration.STEREO):
if path and (configuration == Configuration.STEREO):
interleave_element = 1
output = (f'interleave name=i{interleave_element} ! '
f'audioconvert ! audioresample ! queue ! '
f'volume name=master_vol{path} volume=0.01 ! '
f'alsasink name=alsasink{path} {alsa_devices[path]} '
f'sync=true buffer-time=1000 ')
launch += output
low_ch_mask = channel_masks[path]
high_ch_mask = low_ch_mask * 2
low_interleave_channel = interleave_index[path]
high_interleave_channel = low_interleave_channel + 1
low = (
f'tee_{path}.src_0 ! queue ! '
f'equalizer-10bands name=equalizer{path} band0=0.0 band1=6.0 band2=0.0 ! '
f'audiocheblimit name=low_xover{path} poles=8 mode=low-pass cutoff=2000.0 ! '
f'volume name=low_vol{path} volume=1.0 ! audioconvert ! '
f'"audio/x-raw,channels=1,channel-mask=(bitmask){low_ch_mask:#x}" ! '
f'i{interleave_element}.sink_{low_interleave_channel} ')
high = (
f'tee_{path}.src_1 ! queue ! '
f'audiocheblimit name=high_xover{path} poles=8 mode=high-pass cutoff=2000.0 ! '
f'volume name=high_vol{path} volume=1.0 ! audioconvert ! '
f'"audio/x-raw,channels=1,channel-mask=(bitmask){high_ch_mask:#x}" ! '
f'i{interleave_element}.sink_{high_interleave_channel} ')
launch += low + high
# The printed launch line can be used directly with the gst-launch tool for testing on the command line
# print(launch)
# Python bindings refuses to run with caps in double quotes (!?)
pipeline = Gst.parse_launch(launch.replace('"', ''))
pipeline.set_state(Gst.State.PLAYING)
return pipeline
class_indexes *
image_indexes,
iou_threshold=0.7)
bboxes = flat_locs[nms_mask].cpu()
probs = flat_probs[nms_mask].cpu()
class_indexes = class_indexes[nms_mask].cpu()
if bboxes.size(0) > 0:
print(bboxes, class_indexes, probs)
Gst.init()
pipeline = Gst.parse_launch(f'''
filesrc location=media/in.mp4 num-buffers=256 !
decodebin !
nvvideoconvert !
video/x-raw,format={frame_format} !
fakesink name=s
''')
pipeline.get_by_name('s').get_static_pad('sink').add_probe(
Gst.PadProbeType.BUFFER, on_frame_probe)
pipeline.set_state(Gst.State.PLAYING)
try:
while True:
msg = pipeline.get_bus().timed_pop_filtered(
Gst.SECOND, Gst.MessageType.EOS | Gst.MessageType.ERROR)
if msg:
text = msg.get_structure().to_string() if msg.get_structure(
queue max-size-buffers=2 leaky=downstream ! \
%s name=%s" % (SINK_NAME, GST_VIEW_NAME)
# a gstreamer sink that is a gtk drawing area
# this is the camera preview display.
gDrawAreaSink = Gtk.DrawingArea()
gDrawAreaSink.set_double_buffered(True)
gDrawAreaSink.name = GST_VIEW_NAME
# build GStreamer launch string
source2tee = "%s ! tee name=t" % cam_src_str
tee2view = "t. ! %s" % view_launch_str
tee2app = "t. ! %s" % app_launch_str
launch = "%s %s %s" % (source2tee, tee2view, tee2app)
gstPipeline = Gst.parse_launch(launch)
gGstAppSink = gstPipeline.get_by_name(GST_APP_NAME)
# build GUI
window = Gtk.Window()
window.connect("delete-event", window_closed, gstPipeline)
window.set_default_size(640, 480)
window.set_title("py_stream_infer")
box = Gtk.Box()
box.set_spacing(5)
box.set_orientation(Gtk.Orientation.VERTICAL)
window.add(box)
box.pack_start(gDrawAreaSink, True, True, 0)
def run_pipeline(
user_function,
src_frame_rate: int = None,
src_height: int = None,
src_width: int = None,
binning_level: int = 1,
use_leaky_queue: bool = True,
image_sink_bin: str = "ximagesink sync=false",
image_src_bin: str = "pyspinsrc",
):
if binning_level is not None and binning_level != 1:
image_src_bin += f" h-binning={binning_level} v-binning={binning_level}"
image_src_caps = "video/x-raw,format=RGB"
if src_frame_rate is not None:
image_src_caps += f",framerate={int(src_frame_rate)}/1"
if src_height is not None:
image_src_caps += f",height={src_height}"
if src_width is not None:
image_src_caps += f",width={src_width}"
appsink_element = "appsink name=appsink emit-signals=true max-buffers=1 drop=true"
appsink_caps = "video/x-raw,format=RGB"
image_queue = "queue"
if use_leaky_queue:
image_queue += " max-size-buffers=1 leaky=downstream"
appsrc_element = (
"appsrc name=appsrc is-live=true emit-signals=true format=3 block=true"
)
image_src_pipeline = f" {image_src_bin} ! {image_src_caps} ! {image_queue} ! videoconvert ! {appsink_caps} ! {appsink_element}"
print("Image src pipeline:\n", image_src_pipeline)
image_src_pipeline = Gst.parse_launch(image_src_pipeline)
appsink = image_src_pipeline.get_by_name("appsink")
# start image source pipeling and block until playing
image_src_pipeline.set_state(Gst.State.PLAYING)
state_change_info = image_src_pipeline.get_state(Gst.CLOCK_TIME_NONE)
print(
f"Image src pipeline state change to running successful? : {state_change_info[0] == Gst.StateChangeReturn.SUCCESS}"
)
image_sink_pipeline = f"{appsrc_element} ! {str(appsink.sinkpad.get_current_caps())} ! videoconvert ! {image_sink_bin}"
print("Image sink pipeline:\n", image_sink_pipeline)
image_sink_pipeline = Gst.parse_launch(image_sink_pipeline)
appsrc = image_sink_pipeline.get_by_name("appsrc")
appsink.connect(
"new-sample",
partial(on_new_sample, appsrc=appsrc, user_function=user_function),
)
loop = GObject.MainLoop()
src_bus = image_src_pipeline.get_bus()
src_bus.add_signal_watch()
src_bus.connect("message", on_bus_message, loop)
sink_bus = image_sink_pipeline.get_bus()
image_sink_pipeline.set_state(Gst.State.PLAYING)
try:
loop.run()
except:
pass
image_src_pipeline.set_state(Gst.State.NULL)
image_sink_pipeline.send_event(Gst.Event.new_eos())
print("Waiting for the EOS message on the bus")
sink_bus.timed_pop_filtered(Gst.CLOCK_TIME_NONE, Gst.MessageType.EOS)
print("Stopping pipeline")
image_sink_pipeline.set_state(Gst.State.NULL)
while GLib.MainContext.default().iteration(False):
pass
def __init__(self):
self.pipe = Gst.parse_launch(PIPELINE_DESC)
self.pipe.set_state(Gst.State.PLAYING)
def run_pipeline(user_function,
src_size,
appsink_size,
mirror=False,
h264=False,
jpeg=False,
videosrc='/dev/video0'):
PIPELINE = 'v4l2src device=%s ! {src_caps} ! {leaky_q} '%videosrc
if h264:
SRC_CAPS = 'video/x-h264,width={width},height={height},framerate=30/1'
elif jpeg:
SRC_CAPS = 'image/jpeg,width={width},height={height},framerate=30/1'
else:
SRC_CAPS = 'video/x-raw,width={width},height={height},framerate=30/1'
APPSRC_PIPELINE = 'appsrc name=appsrc ! {appsrc_caps} '
if detectCoralDevBoard():
print("***\nNOTE: On a Coral devboard use bodypix_gl_imx.py instead for much faster performance.\n***")
scale_caps = None
PIPELINE += """
! decodebin ! glupload ! glvideoflip video-direction={direction} ! {leaky_q}
! glfilterbin filter=glbox name=glbox ! {sink_caps} ! {sink_element}
"""
APPSRC_PIPELINE += """
! {leaky_q} ! videoconvert n-threads=4
! rsvgoverlay name=overlay ! waylandsink
"""
else: # raspberry pi or linux
scale = min(appsink_size[0] / src_size[0], appsink_size[1] / src_size[1])
scale = tuple(int(x * scale) for x in src_size)
scale_caps = 'video/x-raw,width={width},height={height}'.format(width=scale[0], height=scale[1])
PIPELINE += """
! decodebin ! videoflip video-direction={direction} ! videoconvert
! videoscale ! {scale_caps} ! videobox name=box autocrop=true
! {sink_caps} ! {leaky_q} ! {sink_element} """
APPSRC_PIPELINE += """ ! {leaky_q} ! videoconvert
! rsvgoverlay name=overlay ! videoconvert ! autovideosink"""
SINK_ELEMENT = 'appsink name=appsink sync=false emit-signals=true max-buffers=1 drop=true'
DL_CAPS = 'video/x-raw,format=BGRA,width={width},height={height}'
SINK_CAPS = 'video/x-raw,format=RGB,width={width},height={height}'
APPSRC_CAPS = 'video/x-raw,format=RGB,width={width},height={height},framerate=30/1'
LEAKY_Q = 'queue max-size-buffers=1 leaky=downstream'
direction = 'horiz' if mirror else 'identity'
src_caps = SRC_CAPS.format(width=src_size[0], height=src_size[1])
sink_caps = SINK_CAPS.format(width=appsink_size[0], height=appsink_size[1])
dl_caps = DL_CAPS.format(width=appsink_size[0], height=appsink_size[1])
pipeline = PIPELINE.format(leaky_q=LEAKY_Q, src_caps=src_caps, dl_caps=dl_caps,
sink_caps=sink_caps, sink_element=SINK_ELEMENT,
scale_caps=scale_caps, direction=direction)
print('Gstreamer pipeline: ', pipeline)
pipeline = Gst.parse_launch(pipeline)
appsink = pipeline.get_by_name('appsink')
appsrc_caps = APPSRC_CAPS.format(width=appsink_size[0], height=appsink_size[1])
appsrc_pipeline = APPSRC_PIPELINE.format(leaky_q=LEAKY_Q,
appsrc_caps=appsrc_caps,
src_caps=src_caps)
print('Gstreamer appsrc pipeline: ', appsrc_pipeline)
appsrc_pipeline = Gst.parse_launch(appsrc_pipeline)
appsrc = appsrc_pipeline.get_by_name('appsrc')
overlay = appsrc_pipeline.get_by_name('overlay')
appsink.connect('new-sample', partial(on_new_sample,
appsrc=appsrc, overlay=overlay,
screen_size=src_size, appsink_size=appsink_size,
user_function=user_function))
loop = GObject.MainLoop()
# Set up a pipeline bus watch to catch errors.
bus = pipeline.get_bus()
bus.add_signal_watch()
bus.connect('message', on_bus_message, loop)
# Run pipeline.
pipeline.set_state(Gst.State.PLAYING)
appsrc_pipeline.set_state(Gst.State.PLAYING)
try:
loop.run()
except:
pass
# Clean up.
pipeline.set_state(Gst.State.NULL)
appsrc_pipeline.set_state(Gst.State.NULL)
while GLib.MainContext.default().iteration(False):
pass
pipeline.set_state(Gst.State.NULL)
sys.exit()
else:
pass
return True
def set_callbacks(pipeline):
gvawatermark = pipeline.get_by_name("gvawatermark")
pad = gvawatermark.get_static_pad("src")
pad.add_probe(Gst.PadProbeType.BUFFER, pad_probe_callback)
bus = pipeline.get_bus()
bus.add_signal_watch()
bus.connect("message", bus_call, pipeline)
if __name__ == '__main__':
Gst.init(sys.argv)
gst_launch_string = create_launch_string()
print(gst_launch_string)
pipeline = Gst.parse_launch(gst_launch_string)
set_callbacks(pipeline)
pipeline.set_state(Gst.State.PLAYING)
glib_mainloop()
print("Exiting")
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
# GStreamer SDK Tutorials in Python
#
# basic-tutorial-1
#
"""
basic-tutorial-1: Hello world!
http://docs.gstreamer.com/display/GstSDK/Basic+tutorial+2%3A+GStreamer+concepts
"""
from gi.repository import Gst
Gst.init(None)
# Build the pipeline
pipeline = Gst.parse_launch(
"playbin uri=http://docs.gstreamer.com/media/sintel_trailer-480p.webm")
# Start playing
pipeline.set_state(Gst.State.PLAYING)
# Wait until error or EOS
bus = pipeline.get_bus()
msg = bus.timed_pop_filtered(Gst.CLOCK_TIME_NONE,
Gst.MessageType.ERROR | Gst.MessageType.EOS)
# Free resources
pipeline.set_state(Gst.State.NULL)
#!/usr/bin/env python
# Shows how two pipelines can be connected, using proxysink/proxysrc.
# It will output a test audio sound.
# Python equivalent of example at https://gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-plugins-bad-plugins/html/gst-plugins-bad-plugins-proxysrc.html
import gi
gi.require_version('Gst', '1.0')
from gi.repository import GObject, Gst
import os
Gst.init(None)
mainloop = GObject.MainLoop()
pipe1 = Gst.parse_launch("audiotestsrc is-live=1 ! proxysink name=psink")
psink = pipe1.get_by_name('psink')
pipe2 = Gst.parse_launch("proxysrc name=psrc ! autoaudiosink")
psrc = pipe2.get_by_name('psrc')
psrc.set_property('proxysink', psink)
clock = Gst.SystemClock.obtain()
pipe1.use_clock(clock)
pipe2.use_clock(clock)
clock.unref()
pipe1.set_base_time(0)
pipe2.set_base_time(0)
pipe1.set_state(Gst.State.PLAYING)
pipe2.set_state(Gst.State.PLAYING)
def run_pipeline(pipeline,
layout,
loop,
render_overlay,
display,
handle_sigint=True,
signals=None):
# Create pipeline
pipeline = describe(pipeline)
print(pipeline)
pipeline = Gst.parse_launch(pipeline)
# Set up a pipeline bus watch to catch errors.
bus = pipeline.get_bus()
bus.add_signal_watch()
bus.connect('message', on_bus_message, pipeline, loop)
if display is not Display.NONE:
# Needed to commit the wayland sub-surface.
def on_gl_draw(sink, widget):
widget.queue_draw()
# Needed to account for window chrome etc.
def on_widget_configure(widget, event, glsink):
allocation = widget.get_allocation()
glsink.set_render_rectangle(allocation.x, allocation.y,
allocation.width, allocation.height)
return False
window = Gtk.Window(Gtk.WindowType.TOPLEVEL)
window.set_title(WINDOW_TITLE)
window.set_default_size(layout.render_size.width,
layout.render_size.height)
if display is Display.FULLSCREEN:
window.fullscreen()
drawing_area = Gtk.DrawingArea()
window.add(drawing_area)
drawing_area.realize()
glsink = pipeline.get_by_name('glsink')
glsink.connect('drawn', on_gl_draw, drawing_area)
# Wayland window handle.
wl_handle = glsink.get_wayland_window_handle(drawing_area)
glsink.set_window_handle(wl_handle)
# Wayland display context wrapped as a GStreamer context.
wl_display = glsink.get_default_wayland_display_context()
glsink.set_context(wl_display)
drawing_area.connect('configure-event', on_widget_configure, glsink)
window.connect('delete-event', Gtk.main_quit)
window.show_all()
# The appsink pipeline branch must use the same GL display as the screen
# rendering so they get the same GL context. This isn't automatically handled
# by GStreamer as we're the ones setting an external display handle.
def on_bus_message_sync(bus, message, glsink):
if message.type == Gst.MessageType.NEED_CONTEXT:
_, context_type = message.parse_context_type()
if context_type == GstGL.GL_DISPLAY_CONTEXT_TYPE:
sinkelement = glsink.get_by_interface(
GstVideo.VideoOverlay)
gl_context = sinkelement.get_property('context')
if gl_context:
display_context = Gst.Context.new(
GstGL.GL_DISPLAY_CONTEXT_TYPE, True)
GstGL.context_set_gl_display(display_context,
gl_context.get_display())
message.src.set_context(display_context)
return Gst.BusSyncReply.PASS
bus.set_sync_handler(on_bus_message_sync, glsink)
with Worker(save_frame) as images, Commands() as get_command:
signals = {
'appsink': {
'new-sample':
functools.partial(on_new_sample,
render_overlay=functools.partial(
render_overlay, layout=layout),
layout=layout,
images=images,
get_command=get_command),
'eos':
on_sink_eos
},
**(signals or {})
}
for name, signals in signals.items():
component = pipeline.get_by_name(name)
if component:
for signal_name, signal_handler in signals.items():
component.connect(signal_name, signal_handler, pipeline)
# Handle signals.
if handle_sigint:
GLib.unix_signal_add(GLib.PRIORITY_DEFAULT, signal.SIGINT,
Gtk.main_quit)
# Run pipeline.
pipeline.set_state(Gst.State.PLAYING)
try:
Gtk.main()
except KeyboardInterrupt:
pass
finally:
pipeline.set_state(Gst.State.NULL)
# Process all pending MainContext operations.
while GLib.MainContext.default().iteration(False):
pass
def __init__(self, media_file, result_file, options, mainloop, media_info):
self.analyze_returncode = None
self.options = options
self.media_info = media_info
self._samplerate = int(self.media_info.get("sample_rate", 0))
self._media_duration = float(self.media_info["duration"])
self.mainloop = mainloop
self._media_file = media_file
self._result_filename = result_file
self._result_file = open(result_file, "w")
self._bands_count = 1024
self.last_freq = 0
self._first_tick_timestamp = -1
self._first_tick_timestamp_saved = -1
self._magnitude_position = -1
self._max_magnitude = 0
self._last_freq_count = 0
self.qrcode_count = 0
self.qrcode_with_beep_count = 0
self._tick_count = 0
spectrum_interval_ms = 3
self.spectrum_interval_ns = spectrum_interval_ms * Gst.MSECOND
framerate = self.media_info.get("avg_frame_rate")
if framerate is not None:
# assume audio ticks are at least 1 video frame long
self.framerate = Fraction(self.media_info["avg_frame_rate"])
frame_dur_ms = float(1000 / self.framerate)
else:
# assume 60 fps
frame_dur_ms = 1000 / 60
if options.expected_beep_duration:
self.ticks_count_threshold = int(options.expected_beep_duration / spectrum_interval_ms)
else:
self.ticks_count_threshold = int(frame_dur_ms / spectrum_interval_ms)
# FIXME: fdk adds 2048 samples of priming samples (silence) which adds 42ms of latency
# aacenc adds 1024 samples (21ms)
# https://github.com/mstorsjo/fdk-aac/issues/24
# apple encoder adds 2112 samples
# https://developer.apple.com/library/content/technotes/tn2258/_index.html
# we will assume 2112 which gives a perfect result for our real samples
self._encoder_latency = (
1000000000 * 2112 / self._samplerate
if self.media_info.get("a_codec") == "aac"
else 0
)
# spectrum works on averaging over a 3ms interval, which adds latency
self._encoder_latency += self.spectrum_interval_ns
self._start_time = 0
self._end_time = 0
self._json_length = 70
self._threshold_db = self.options.audio_threshold
self._min_freq = 200
self._audio_duration = 0
self._video_duration = 0
self._audio_fakesink_pad = None
self._video_fakesink_pad = None
self._id_prob_audio_sink = None
self._id_prob_video_sink = None
self.size = 0
self._uri_media_file = self._media_file
if '://' not in self._uri_media_file:
self._uri_media_file = Gst.filename_to_uri(self._media_file)
self.pipeline_str = self.get_pipeline(self._uri_media_file)
self.pipeline = Gst.parse_launch(self.pipeline_str)
elif mtype == Gst.MessageType.ERROR:
err, debug = message.parse_error()
print(err, debug)
elif mtype == Gst.MessageType.WARNING:
err, debug = message.parse_warning()
print(err, debug)
return True
command = "videotestsrc num-buffers=50 ! gtksink"
# Gst.Pipeline https://lazka.github.io/pgi-docs/Gst-1.0/classes/Pipeline.html
# https://lazka.github.io/pgi-docs/Gst-1.0/functions.html#Gst.parse_launch
pipeline = Gst.parse_launch(command)
# https://lazka.github.io/pgi-docs/Gst-1.0/classes/Bus.html
bus = pipeline.get_bus()
# allow bus to emit messages to main thread
bus.add_signal_watch()
# Add handler to specific signal
# https://lazka.github.io/pgi-docs/GObject-2.0/classes/Object.html#GObject.Object.connect
bus.connect("message", on_message, None)
# Start pipeline
pipeline.set_state(Gst.State.PLAYING)
# Init GObject loop to handle Gstreamer Bus Events
from gettext import gettext as _
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gio
from gi.repository import Gtk
from gi.repository import Gdk
from gi.repository import GObject
_HAS_GST = True
try:
gi.require_version('Gst', '1.0')
from gi.repository import Gst
Gst.init(None)
Gst.parse_launch('espeak')
except:
logging.error('Gst or the espeak plugin is not installed in the system.')
_HAS_GST = False
from sugar3 import power
DEFAULT_PITCH = 0
DEFAULT_RATE = 0
_SAVE_TIMEOUT = 500
# This voice names are use dto allow the translation of the voice names.
# If espeak add new voices, we need update this list.
def __init__(self):
Loggable.__init__(self)
self.video_effects = []
self.audio_effects = []
self.gl_effects = []
self._effects = {}
useless_words = [
"Video", "Audio", "audio", "effect",
_("Video"),
_("Audio"),
_("Audio").lower(),
_("effect")
]
uselessRe = re.compile(" |".join(useless_words))
registry = Gst.Registry.get()
factories = registry.get_feature_list(Gst.ElementFactory)
longnames = set()
duplicate_longnames = set()
for factory in factories:
longname = factory.get_longname()
if longname in longnames:
duplicate_longnames.add(longname)
else:
longnames.add(longname)
for factory in factories:
klass = factory.get_klass()
name = factory.get_name()
if ("Effect" not in klass
or any(black in name for black in BLACKLISTED_PLUGINS)):
continue
media_type = None
if "Audio" in klass:
self.audio_effects.append(factory)
media_type = AUDIO_EFFECT
elif "Video" in klass:
self.video_effects.append(factory)
media_type = VIDEO_EFFECT
if not media_type:
HIDDEN_EFFECTS.append(name)
continue
longname = factory.get_longname()
if longname in duplicate_longnames:
# Workaround https://bugzilla.gnome.org/show_bug.cgi?id=760566
# Add name which identifies the element and is unique.
longname = "%s %s" % (longname, name)
human_name = uselessRe.sub("", longname).title()
effect = EffectInfo(name,
media_type,
categories=self._getEffectCategories(name),
human_name=human_name,
description=factory.get_description())
self._effects[name] = effect
gl_element_factories = registry.get_feature_list_by_plugin("opengl")
self.gl_effects = [
element_factory.get_name()
for element_factory in gl_element_factories
]
if self.gl_effects:
# Checking whether the GL effects can be used
# by setting a pipeline with "gleffects" to PAUSED.
pipeline = Gst.parse_launch(
"videotestsrc ! glupload ! gleffects ! fakesink")
bus = pipeline.get_bus()
bus.add_signal_watch()
bus.connect("message", self._gl_pipeline_message_cb, pipeline)
res = pipeline.set_state(Gst.State.PAUSED)
assert res == Gst.StateChangeReturn.ASYNC
#https://gist.github.com/velovix/8cbb9bb7fe86a08fb5aa7909b2950259
from threading import Thread
import gi
gi.require_version("Gst", "1.0")
from gi.repository import Gst, GLib
import time
Gst.init()
main_loop = GLib.MainLoop()
thread = Thread(target=main_loop.run)
thread.start()
cmd = """gst-launch-1.0.exe souphttpsrc is-live=true location="$(youtube-dl --format "best[ext=mp4][protocol=https]" --get-url https://www.youtube.com/watch?v=jQhUhlU1KL8)" ! qtdemux name=demuxer demuxer. ! queue ! decodebin ! autovideosink demuxer.audio_0 ! queue ! decodebin ! audioconvert ! audioresample ! autoaudiosink"""
t = """https://r2---sn-m4vox-ua8s.googlevideo.com/videoplayback?expire=1611531280&ei=sK8NYIG-BZPh1wL3opfQBg&ip=5.102.225.128&id=o-ABHwT7CcK7dWK0ygNJRUJk-NBqL2dsACBwj9OAwQfOmU&itag=22&source=youtube&requiressl=yes&mh=eV&mm=31%2C29&mn=sn-m4vox-ua8s%2Csn-4g5edne7&ms=au%2Crdu&mv=m&mvi=2&pl=20&initcwndbps=508750&vprv=1&mime=video%2Fmp4&ns=zrEFQGojWySkqMq0ToXK22IF&ratebypass=yes&dur=140.387&lmt=1572989225009924&mt=1611509324&fvip=2&beids=9466587&c=WEB&txp=5532432&n=kvStZPM0GzfNsSu&sparams=expire%2Cei%2Cip%2Cid%2Citag%2Csource%2Crequiressl%2Cvprv%2Cmime%2Cns%2Cratebypass%2Cdur%2Clmt&sig=AOq0QJ8wRQIhAPHyHkhW0ZGMDZPQfTg90iB0kgnzstXg4mAJBZw8jNxAAiBSU9Ne8818omKNEVDIrRpu5VjjEUeCe3YHNVJcM_eEeQ%3D%3D&lsparams=mh%2Cmm%2Cmn%2Cms%2Cmv%2Cmvi%2Cpl%2Cinitcwndbps&lsig=AG3C_xAwRQIhAOzDzS-zDzSBNdyCP19IWUg3-kbN0fTpeVYeZ09K4RQ6AiBBozHzQ3zcafBn5Xp6GrTlUPN0aYJDMF2NDlDOV_IhfA%3D%3D"""
#pipeline = Gst.parse_launch("videotestsrc ! decodebin ! videoconvert ! autovideosink")
pipeline = Gst.parse_launch(
f'souphttpsrc is-live=true location="{t}" ! qtdemux name=demuxer demuxer. ! queue ! decodebin ! autovideosink demuxer.audio_0 ! queue ! decodebin ! audioconvert ! audioresample ! autoaudiosink'
)
pipeline.set_state(Gst.State.PLAYING)
try:
while True:
time.sleep(0.1)
except KeyboardInterrupt:
pass
pipeline.set_state(Gst.State.NULL)
main_loop.quit()
def push_to_pipeline(self):
try:
r = requests.post(url="http://127.0.0.1:4001/create/%s" %
self.stream_name,
timeout=1)
content = r.content
print(content)
res = json.loads(content.decode("utf-8"))
rtp_port = res["rtp_port"]
print("assigned rtp port %s" % rtp_port)
except requests.exceptions.RequestException:
print(
"Error vinculando rtp con con webrtc - Revisar modulo rtmp-to-webrtc"
)
return
if rtp_port is None:
self.running = False
print("Error intentando obtener un puerto rtp")
return
launch_string = 'appsrc name=source is-live=true format=GST_FORMAT_TIME ' \
' caps=video/x-raw,format=BGR,width=%s,height=%s,framerate=%s/1 ' \
'! videoconvert ! video/x-raw,format=I420 ' \
'! x264enc speed-preset=ultrafast tune=zerolatency byte-stream=true ' \
'! h264parse ! rtph264pay config-interval=-1 pt=96 ! udpsink host=127.0.0.1 port=%s sync=false' % (
self.w, self.h, self.fps, rtp_port)
pipeline = Gst.parse_launch(launch_string)
appsrc = pipeline.get_child_by_name('source')
pipeline.set_state(Gst.State.PLAYING)
while self.running:
try:
ret, frame = self.cap.read()
if not ret or frame is None:
time.sleep(0.5)
continue
frame = cv2.resize(
frame, (self.w, self.h),
interpolation=cv2.INTER_AREA) # resized frame
cv2.putText(frame, 'HELLO WORLD', (100, 100),
cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
#cv2.imshow("TEST", frame)
data = frame.tostring()
buf = Gst.Buffer.new_allocate(None, len(data), None)
buf.fill(0, data)
buf.duration = self.duration
timestamp = self.number_frames * self.duration
buf.pts = buf.dts = int(timestamp)
buf.offset = timestamp
self.number_frames += 1
retval = appsrc.emit('push-buffer', buf)
if retval != Gst.FlowReturn.OK:
print(retval)
k = cv2.waitKey(33)
if k == 27: # Esc key to stop
break
time.sleep(1 / self.fps)
except Exception:
break
pipeline.set_state(Gst.State.NULL)
def run_example(self):
"""Init pipeline and run example.
:return: None
"""
print("Run: NNStreamer example for multimodel implementation.")
# main loop
self.loop = GObject.MainLoop()
pipeline_string = self.pipeline_initializer()
print(pipeline_string)
# init pipeline
self.pipeline = Gst.parse_launch(pipeline_string)
# bus and message callback
bus = self.pipeline.get_bus()
bus.add_signal_watch()
bus.connect('message', self.on_bus_message)
if self.OPTION_FM or self.OPTION_EM:
res_face = self.pipeline.get_by_name('res_face')
res_face.connect('new-data', self.new_callback_face)
if self.OPTION_OD:
tensor_sink = self.pipeline.get_by_name('res_object')
tensor_sink.connect('new-data', self.new_callback_object)
if self.OPTION_EM:
posesink_0 = self.pipeline.get_by_name('posesink_0')
posesink_0.connect('new-data', self.new_data_pose_cb)
posesink_1 = self.pipeline.get_by_name('posesink_1')
posesink_1.connect('new-data', self.new_data_pose_cb)
posesink_2 = self.pipeline.get_by_name('posesink_2')
posesink_2.connect('new-data', self.new_data_pose_cb)
if self.OPTION_XV or self.OPTION_RTMP:
tensor_res = self.pipeline.get_by_name('tensor_res')
tensor_res.connect('draw', self.draw_overlay_cb)
tensor_res.connect('caps-changed', self.prepare_overlay_cb)
# start pipeline
self.pipeline.set_state(Gst.State.PLAYING)
self.running = True
if self.OPTION_XV:
self.set_window_title('output_local',
'NNStreamer Multi Model TFLite Example')
# run main loop
# Don't use this then you're trying to use this code with gui
self.loop.run()
# quit when received eos or error message
# run this when you're going to quit stream
self.running = False
self.pipeline.set_state(Gst.State.NULL)
bus.remove_signal_watch()
def run_pipeline(user_function,
src_size=(X_PIXEL, Y_PIXEL),
appsink_size=(639, 480)):
PIPELINE = 'v4l2src device=/dev/video1 ! {src_caps} ! {leaky_q} '
if detectCoralDevBoard():
SRC_CAPS = 'video/x-raw,format=YUY2,width={width},height={height},framerate={frame_rate}/1'
PIPELINE += """ ! glupload ! tee name=t
t. ! {leaky_q} ! glfilterbin filter=glcolorscale
! {dl_caps} ! videoconvert ! {sink_caps} ! {sink_element}
t. ! {leaky_q} ! glfilterbin filter=glcolorscale
! rsvgoverlay name=overlay ! waylandsink
"""
else:
SRC_CAPS = 'video/x-raw,width={width},height={height},framerate={frame_rate}/1'
PIPELINE += """ ! tee name=t
t. ! {leaky_q} ! videoconvert ! videoscale ! {sink_caps} ! {sink_element}
t. ! {leaky_q} ! videoconvert
! rsvgoverlay name=overlay ! videoconvert ! ximagesink
"""
SINK_ELEMENT = 'appsink name=appsink sync=false emit-signals=true max-buffers=1 drop=true'
DL_CAPS = 'video/x-raw,format=RGBA,width={width},height={height}'
SINK_CAPS = 'video/x-raw,format=RGB,width={width},height={height}'
LEAKY_Q = 'queue max-size-buffers=1 leaky=downstream'
src_caps = SRC_CAPS.format(width=src_size[0],
height=src_size[1],
frame_rate=FRAME_RATE)
dl_caps = DL_CAPS.format(width=appsink_size[0], height=appsink_size[1])
sink_caps = SINK_CAPS.format(width=appsink_size[0], height=appsink_size[1])
pipeline = PIPELINE.format(leaky_q=LEAKY_Q,
src_caps=src_caps,
dl_caps=dl_caps,
sink_caps=sink_caps,
sink_element=SINK_ELEMENT)
print("Preparing streamer pipeline")
print("Camera resolution", src_size[0], src_size[1], "Frame rate",
FRAME_RATE)
print(pipeline)
pipeline = Gst.parse_launch(pipeline)
overlay = pipeline.get_by_name('overlay')
appsink = pipeline.get_by_name('appsink')
appsink.connect(
'new-sample',
partial(on_new_sample,
overlay=overlay,
screen_size=src_size,
appsink_size=appsink_size,
user_function=user_function))
loop = GObject.MainLoop()
# Set up a pipeline bus watch to catch errors.
bus = pipeline.get_bus()
bus.add_signal_watch()
bus.connect('message', on_bus_message, loop)
# Run pipeline.
pipeline.set_state(Gst.State.PLAYING)
try:
loop.run()
except:
pass
# Clean up.
pipeline.set_state(Gst.State.NULL)
while GLib.MainContext.default().iteration(False):
pass
def _setup(self):
self.video_pipe = Gst.parse_launch(self.command)
self.closed = True
def do_create_element(self, url):
return Gst.parse_launch(self.launch_string)
This demo shows how, by splitting into pipelines, each soure can be seeked independently.
And if one fails (e.g. file not found), the other continues.
'''
import gi
gi.require_version('Gst', '1.0')
from gi.repository import GObject, Gst
import os
from time import sleep
from threading import Thread
Gst.init(None)
mainloop = GObject.MainLoop()
# We make the two pipelines
pipe1 = Gst.parse_launch("playbin uri=\"file://" + os.environ['SRC'] + "\"")
pipe2 = Gst.parse_launch("playbin uri=\"file://" + os.environ['SRC2'] + "\"")
# The third pipeline is more complex as it has to accept the other two, and mix.
pipe3 = Gst.parse_launch(
"intervideosrc name=video_src_1 ! videomix. " +
"interaudiosrc name=audio_src_1 ! autoaudiosink "
"intervideosrc name=video_src_2 ! videomix. " +
"interaudiosrc name=audio_src_2 ! autoaudiosink " +
"compositor name=videomix sink_1::xpos=800 sink_1::ypos=800 ! autovideosink "
)
# Because 'playbin' is a bin rather than element, the bit we want within it is 'playsink':
pipe1_playsink = pipe1.get_by_name('playsink')
pipe2_playsink = pipe2.get_by_name('playsink')
