def _create_pipeline(self, source, target, start, end):
'''
Creates a pipeline in the form:
gnlcomposition
-----------------
| gnlfilesource | --> audioconvert --> lame --> filesink
-----------------
'''
self.pipeline = gst.Pipeline('slicer')
comp = gst.element_factory_make('gnlcomposition', 'mycomposition')
comp.connect('pad-added', self._on_pad)
self.convert = gst.element_factory_make('audioconvert', 'convert')
self.pipeline.add(self.convert)
mp3_encoder = gst.element_factory_make('lame', 'mp3-encoder')
self.pipeline.add(mp3_encoder)
self.convert.link(mp3_encoder)
out = gst.element_factory_make('filesink', 'out')
out.set_property('location', target)
self.pipeline.add(out)
mp3_encoder.link(out)
audio1 = gst.element_factory_make('gnlfilesource', 'audio1')
audio1.set_property('location', source)
audio1.set_property('start', long(start) * gst.SECOND)
audio1.set_property('duration', long(end-start) * gst.SECOND)
self.pipeline.add(comp)
comp.add(audio1)
def _gst_init(self):
# self._videosink will receive the buffers so we can upload them to GPU
if PY2:
self._videosink = gst.element_factory_make('appsink', 'videosink')
self._videosink.set_property('caps', gst.Caps(_VIDEO_CAPS))
else:
self._videosink = gst.ElementFactory.make('appsink', 'videosink')
self._videosink.set_property('caps',
gst.caps_from_string(_VIDEO_CAPS))
self._videosink.set_property('async', True)
self._videosink.set_property('drop', True)
self._videosink.set_property('qos', True)
self._videosink.set_property('emit-signals', True)
self._videosink.connect('new-' + BUF_SAMPLE, partial(
_gst_new_buffer, ref(self)))
# playbin, takes care of all, loading, playing, etc.
# XXX playbin2 have some issue when playing some video or streaming :/
#self._playbin = gst.element_factory_make('playbin2', 'playbin')
if PY2:
self._playbin = gst.element_factory_make('playbin', 'playbin')
else:
self._playbin = gst.ElementFactory.make('playbin', 'playbin')
self._playbin.set_property('video-sink', self._videosink)
# gstreamer bus, to attach and listen to gst messages
self._bus = self._playbin.get_bus()
self._bus.add_signal_watch()
self._bus.connect('message', _on_gst_message)
self._bus.connect('message::eos', partial(
_on_gst_eos, ref(self)))
def do_request_new_pad(self, template, name=None):
self.debug("template:%r, name:%r" % (template, name))
if name == None:
name = "sink_%u" % self.pad_count
if name in self.inputs.keys():
return None
csp = gst.element_factory_make("ffmpegcolorspace", "csp-%d" % self.pad_count)
capsfilter = gst.element_factory_make("capsfilter", "capsfilter-%d" % self.pad_count)
# configure the capsfilter caps
if self.alpha_helper.alpha_count != 0:
capsfilter.props.caps = gst.Caps('video/x-raw-yuv,format=(fourcc)AYUV')
else:
capsfilter.props.caps = gst.Caps('video/x-raw-yuv')
self.add(csp, capsfilter)
csp.link_pads_full("src", capsfilter, "sink", gst.PAD_LINK_CHECK_NOTHING)
csp.sync_state_with_parent()
capsfilter.sync_state_with_parent()
videomixerpad = self.videomixer.get_request_pad("sink_%d" % self.pad_count)
capsfilter.get_pad("src").link_full(videomixerpad, gst.PAD_LINK_CHECK_NOTHING)
pad = gst.GhostPad(name, csp.get_pad("sink"))
pad.set_active(True)
self.add_pad(pad)
self.inputs[name] = (pad, csp, capsfilter, videomixerpad)
self.pad_count += 1
return pad
def __init__(self, location, caps):
gst.Bin.__init__(self)
# Create elements
src = gst.element_factory_make('filesrc')
dec = gst.element_factory_make('decodebin')
conv = gst.element_factory_make('audioconvert')
rsmpl = gst.element_factory_make('audioresample')
ident = gst.element_factory_make('identity')
# Set 'location' property on filesrc
src.set_property('location', location)
# Connect handler for 'new-decoded-pad' signal
dec.connect('new-decoded-pad', self.__on_new_decoded_pad)
# Add elements to bin
self.add(src, dec, conv, rsmpl, ident)
# Link *some* elements
# This is completed in self.__on_new_decoded_pad()
src.link(dec)
conv.link(rsmpl)
rsmpl.link(ident, caps)
# Reference used in self.__on_new_decoded_pad()
self.__apad = conv.get_pad('sink')
# Add ghost pad
self.add_pad(gst.GhostPad('src', ident.get_pad('src')))
def __init__(
self, uris, data_callback, error_callback=None, scan_timeout=1000):
self.data = {}
self.uris = iter(uris)
self.data_callback = data_callback
self.error_callback = error_callback
self.scan_timeout = scan_timeout
self.loop = gobject.MainLoop()
self.timeout_id = None
self.fakesink = gst.element_factory_make('fakesink')
self.fakesink.set_property('signal-handoffs', True)
self.fakesink.connect('handoff', self.process_handoff)
self.uribin = gst.element_factory_make('uridecodebin')
self.uribin.set_property(
'caps', gst.Caps(b'audio/x-raw-int; audio/x-raw-float'))
self.uribin.connect('pad-added', self.process_new_pad)
self.pipe = gst.element_factory_make('pipeline')
self.pipe.add(self.uribin)
self.pipe.add(self.fakesink)
bus = self.pipe.get_bus()
bus.add_signal_watch()
bus.connect('message::application', self.process_application)
bus.connect('message::tag', self.process_tags)
bus.connect('message::error', self.process_error)
def __init__(self):
self.player = gst.element_factory_make("playbin2", "player")
fakesink = gst.element_factory_make("fakesink", "fakesink")
self.player.set_property("video-sink", fakesink)
bus = self.player.get_bus()
bus.add_signal_watch()
bus.connect("message", self.on_message)
def __init__(self, location):
gst.Bin.__init__(self)
self.set_name('ogg_bin')
vorbisenc = gst.element_factory_make(
"vorbisenc", "vorbisenc")
oggmux = gst.element_factory_make(
"oggmux", "oggmux")
filesink = gst.element_factory_make(
"filesink", "filesinkogg")
self.add(vorbisenc)
self.add(oggmux)
self.add(filesink)
vorbisenc.link(oggmux)
oggmux.link(filesink)
filesink.set_property(
'location', location)
pad = vorbisenc.get_static_pad("sink")
self.add_pad(gst.GhostPad("sink", pad))
def __init__(self):
# Create GUI objects
self.window = gtk.Window()
self.vbox = gtk.VBox()
self.da = gtk.DrawingArea()
self.bb = gtk.HButtonBox()
self.da.set_size_request(300, 150)
self.playButton = gtk.Button(stock="gtk - media - play")
self.playButton.connect("clicked", self.OnPlay)
self.stopButton = gtk.Button(stock="gtk - media - stop")
self.stopButton.connect("clicked", self.OnStop)
self.quitButton = gtk.Button(stock="gtk - quit")
self.quitButton.connect("clicked", self.OnQuit)
self.vbox.pack_start(self.da)
self.bb.add(self.playButton)
self.bb.add(self.stopButton)
self.bb.add(self.quitButton)
self.vbox.pack_start(self.bb)
self.window.add(self.vbox)
# Create GStreamer pipeline
self.pipeline = gst.Pipeline("mypipeline")
# Set up our video test source
self.videotestsrc = gst.element_factory_make("videotestsrc", "video")
# Add it to the pipeline
self.pipeline.add(self.videotestsrc)
# Now we need somewhere to send the video
self.sink = gst.element_factory_make("xvimagesink", "sink")
# Add it to the pipeline
self.pipeline.add(self.sink)
# Link the video source to the sink - xv
self.videotestsrc.link(self.sink)
self.window.show_all()
def __init__(self):
_base.ExailePlayer.__init__(self)
self._current_stream = 1
self._timer_id = 0
# have to fix the caps because gst cant deal with having them change.
# TODO: make this a preference and/or autodetect optimal based on the
# output device - if its a 48000hz-native chip we dont want to send it
# 44100hz audio all the time.
# Or better yet, fix gst to handle changing caps :D
self.caps = gst.Caps(
"audio/x-raw-int, "
"endianness=(int)1234, "
"signed=(boolean)true, "
"width=(int)16, "
"depth=(int)16, "
"rate=(int)44100, "
"channels=(int)2")
self.pipe = gst.Pipeline()
self.adder = gst.element_factory_make("adder")
self.audio_queue = gst.element_factory_make("queue")
self.streams = [None, None]
self._load_queue_values()
self._setup_pipeline()
self.setup_bus()
def __init__(self, filename, threshold=-9.0):
gst.Pipeline.__init__(self)
self._filename = filename
self._thresholddB = threshold
self._threshold = math.pow(10, self._thresholddB / 10.0)
self._source = sources.AudioSource(filename)
self._source.connect('done', self._done_cb)
self._level = gst.element_factory_make("level")
self._fakesink = gst.element_factory_make("fakesink")
self.add(self._source, self._level, self._fakesink)
self._source.connect("pad-added", self._sourcePadAddedCb)
self._level.link(self._fakesink)
# temporary values for each timepoint
self._rmsdB = {} # hash of channel, rmsdB value
self._peakdB = 0.0 # highest value over all channels for this time
# results over the whole file
self._meansquaresums = [] # list of time -> mean square sum value
self._peaksdB = [] # list of time -> peak value
self._lasttime = 0
# will be set when done
self.mixin = 0
self.mixout = 0
self.length = 0
self.rms = 0.0
self.rmsdB = 0.0
def __init__(self, name, audiosrc, partial_cb, final_cb, lm_path=None, dict_path=None):
""" Sets up the gstreamer pipeline and registers callbacks.
Partial and full callbacks must take arguments (name, uttid, text)
"""
#rospy.Subscriber("chatter", String, callback)
self.name = name
self.partial_cb = partial_cb
self.final_cb = final_cb
self.pipe = gst.Pipeline()
conv = gst.element_factory_make("audioconvert", "audioconv")
res = gst.element_factory_make("audioresample", "audioresamp")
# Vader controls when sphinx listens for spoken text
vader = gst.element_factory_make("vader", "vad")
vader.set_property("auto-threshold", True)
asr = gst.element_factory_make("pocketsphinx", "asr")
asr.connect('partial_result', self.asr_partial_result)
asr.connect('result', self.asr_result)
if lm_path and dict_path:
asr.set_property('lm', lm_path)
asr.set_property('dict', dict_path)
asr.set_property('configured', True)
# we don't do anything with the actual audio data after transcription,
# but you could e.g. write the audio to a file here instead.
sink = gst.element_factory_make("fakesink", "fs")
self.pipe.add(audiosrc, conv, res, vader, asr, sink)
gst.element_link_many(audiosrc, conv, res, vader, asr, sink)
self.pipe.set_state(gst.STATE_PLAYING)
def on_audio_decoded(element, pad, bin, muxer):
name = pad.get_caps()[0].get_name()
element_name = element.get_name()[:8]
sink = None
# only one audio will be muxed
created = bin.get_by_name("sbs-audio-convert")
pending = False if created else True
if name.startswith("audio/x-raw") and pending:
# db%. audioconvert ! queue ! faac bitrate = 12800 ! queue ! mux.
convert = gst.element_factory_make("audioconvert", "sbs-audio-convert")
q1 = gst.element_factory_make("queue", "sbs-audio-queue1")
f = gst.element_factory_make("faac", "sbs-audio-encoder")
f.set_property("bitrate", 128000)
q2 = gst.element_factory_make("queue", "sbs-audio-queue2")
# link
bin.add(convert)
bin.add(q1)
bin.add(f)
bin.add(q2)
convert.link(q1)
q1.link(f)
f.link(q2)
q2.link(muxer)
# keep activating
convert.set_state(gst.STATE_PLAYING)
q1.set_state(gst.STATE_PLAYING)
f.set_state(gst.STATE_PLAYING)
q2.set_state(gst.STATE_PLAYING)
pad.link(convert.get_pad("sink"))
return sink
def __init__(self):
self.pipeline = gst.Pipeline()
self.player = gst.element_factory_make("playbin", "player")
self.vis = gst.element_factory_make("goom", "vis")
self.videosink = gst.element_factory_make("tee", 'vidtee')
self.audiosink = gst.element_factory_make("autoaudiosink", 'audiosink')
self.aqueue = gst.element_factory_make("queue", 'aqueue')
self.bqueue = gst.element_factory_make("queue", 'bqueue')
self.avidsink = gst.element_factory_make('autovideosink', 'avidsink')
self.bvidsink = gst.element_factory_make('autovideosink', 'bvidsink')
self.acolorspace = gst.element_factory_make("ffmpegcolorspace","acolor")
self.bcolorspace = gst.element_factory_make("ffmpegcolorspace","bcolor")
#self.pipeline.add(self.acolorspace, self.bcolorspace, self.player, self.vis, self.videosink, self.audiosink, self.aqueue, self.bqueue, self.avidsink, self.bvidsink)
self.pipeline.add(self.videosink, self.aqueue, self.bqueue, self.acolorspace, self.bcolorspace, self.avidsink, self.bvidsink)
self.videosink.link(self.aqueue)
self.videosink.link(self.bqueue)
gst.element_link_many(self.aqueue, self.acolorspace, self.avidsink)
gst.element_link_many(self.bqueue, self.bcolorspace, self.bvidsink)
self.player.set_property("vis-plugin", self.vis)
#self.player.set_property("video-sink", self.pipeline)
self.player.set_property("audio-sink", self.audiosink)
self.bus = self.player.get_bus()
#self.bus.add_signal_watch()
#self.bus.enable_sync_message_emission()
#self.bus.connect("message", self.on_message)
print self.player
def __init__(self, config, plugman, window_id=None, audio_feedback=None, cli=False):
self.config = config
self.plugman = plugman
self.window_id = window_id
self.audio_feedback_event = audio_feedback
self.cli = cli
self.record_audio = False
self.record_video = False
self.current_state = Multimedia.NULL
# Initialize Player
self.player = gst.Pipeline('player')
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)
# Initialize Entry Points
self.audio_tee = gst.element_factory_make('tee', 'audio_tee')
self.video_tee = gst.element_factory_make('tee', 'video_tee')
self.player.add(self.audio_tee)
self.player.add(self.video_tee)
log.debug("Gstreamer initialized.")
def createPipeline(self, w):
"""Given a window, creates a pipeline and connects it to the window"""
# code will make the ximagesink output in the specified window
def set_xid(window):
gtk.gdk.threads_enter()
sink.set_xwindow_id(window.window.xid)
sink.expose()
gtk.gdk.threads_leave()
# this code receives the messages from the pipeline. if we
# need to set X11 id, then we call set_xid
def bus_handler(unused_bus, message):
if message.type == gst.MESSAGE_ELEMENT:
if message.structure.get_name() == 'prepare-xwindow-id':
set_xid(w)
return gst.BUS_PASS
# create our pipeline, and connect our bus_handler
self.pipeline = gst.Pipeline()
bus = self.pipeline.get_bus()
bus.set_sync_handler(bus_handler)
sink = gst.element_factory_make("ximagesink", "sink")
sink.set_property("force-aspect-ratio", True)
sink.set_property("handle-expose", True)
scale = gst.element_factory_make("videoscale", "scale")
cspace = gst.element_factory_make("ffmpegcolorspace", "cspace")
# our pipeline looks like this: ... ! cspace ! scale ! sink
self.pipeline.add(cspace, scale, sink)
scale.link(sink)
cspace.link(scale)
return (self.pipeline, cspace)
def __init__(self):
gst.Bin.__init__(self)
self.set_name('mp2_bin')
queue = gst.element_factory_make('queue', "queue")
queue.set_property("max-size-buffers", 0)
queue.set_property("max-size-bytes", 0)
queue.set_property("max-size-time", 0)
audioconvert = gst.element_factory_make('audioconvert', "audioconvert")
ffenc_mp2 = gst.element_factory_make('ffenc_mp2', 'ffenc_mp2')
self.add(queue)
self.add(audioconvert)
self.add(ffenc_mp2)
queue.link(audioconvert)
audioconvert.link(ffenc_mp2)
self.add_pad(gst.GhostPad("sink",
queue.get_static_pad("sink")))
self.add_pad(gst.GhostPad("src",
ffenc_mp2.get_static_pad("src")))
def __init__(self):
gst.Bin.__init__(self)
self.width = 320
self.height = 240
self.x_position = 0
self.y_position = 0
self.enabled = True
self.position = 0
self.videomixer = gst.element_factory_make("videomixer", "videomixer")
self.add(self.videomixer)
self.caps = self.make_caps(self.width, self.height)
self.csp = gst.element_factory_make("ffmpegcolorspace", "pip_csp")
self.add(self.csp)
self.A_capsfilter = []
self.B_capsfilter = []
self.A_pads = []
self.B_pads = []
self.videomixer.link(self.csp)
src_pad = gst.GhostPad("src", self.csp.src_pads().next())
self.add_pad(src_pad)
self.A_number = 0
self.B_number = 0
self.a_active = 0
self._set_active_a(self.a_active)
self.b_active = 0
self._set_active_b(self.b_active)
def __init__(self):
gst.Bin.__init__(self)
self.set_name("Audio_Bin")
autoaudiosrc = gst.element_factory_make('autoaudiosrc', "autoaudiosrc")
audiorate = gst.element_factory_make('audiorate', "audiorate")
capaaudio = gst.Caps(
"audio/x-raw-int,rate=16000,channels=2,depth=16")
filtroaudio = gst.element_factory_make("capsfilter", "filtroaudio")
filtroaudio.set_property("caps", capaaudio)
audioconvert = gst.element_factory_make('audioconvert', "audioconvert")
self.add(autoaudiosrc)
self.add(audiorate)
self.add(filtroaudio)
self.add(audioconvert)
autoaudiosrc.link(audiorate)
audiorate.link(filtroaudio)
filtroaudio.link(audioconvert)
self.add_pad(gst.GhostPad(
"src", audioconvert.get_static_pad("src")))
def __init__(self):
gst.Bin.__init__(self)
self.set_name('Vorbis_bin')
queue = gst.element_factory_make('queue', "queue")
queue.set_property("max-size-buffers", 0)
queue.set_property("max-size-bytes", 0)
queue.set_property("max-size-time", 0)
audioconvert = gst.element_factory_make('audioconvert', "audioconvert")
vorbisenc = gst.element_factory_make('vorbisenc', 'vorbisenc')
self.add(queue)
self.add(audioconvert)
self.add(vorbisenc)
queue.link(audioconvert)
audioconvert.link(vorbisenc)
self.add_pad(gst.GhostPad("sink",
queue.get_static_pad("sink")))
self.add_pad(gst.GhostPad("src",
vorbisenc.get_static_pad("src")))
def gstreamer_player(self):
playbin = gst.element_factory_make("playbin2", "player")
if FC().is_eq_enable:
self.audiobin = gst.Bin('audiobin')
audiosink = gst.element_factory_make('autoaudiosink', 'audiosink')
self.audiobin.add(audiosink)
self.audiobin.add_pad(gst.GhostPad('sink', audiosink.get_pad('sink')))
playbin.set_property('audio-sink', self.audiobin)
self.equalizer = gst.element_factory_make('equalizer-10bands', 'equalizer')
self.audiobin.add(self.equalizer)
self.audiobin.get_pad('sink').set_target(self.equalizer.get_pad('sink'))
self.equalizer.link(audiosink)
bus = playbin.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)
logging.debug("LOCAL gstreamer")
return playbin
def __init__(self, position=0, duration=2 * gst.SECOND, fadefromblack=True):
gst.Bin.__init__(self)
self.incsp = gst.element_factory_make("ffmpegcolorspace", "incsp")
self.outcsp = gst.element_factory_make("ffmpegcolorspace", "outcsp")
self.alpha = gst.element_factory_make("alpha", "alpha")
self.vmix = gst.element_factory_make("videomixer", "videomix")
self.vmix.set_property("background", 1)
self.add(self.incsp, self.alpha, self.vmix, self.outcsp)
gst.element_link_many(self.incsp, self.alpha, self.vmix, self.outcsp)
self._sinkpad = gst.GhostPad("sink", self.incsp.get_pad("sink"))
self._sinkpad.set_active(True)
self._srcpad = gst.GhostPad("src", self.outcsp.get_pad("src"))
self._srcpad.set_active(True)
self.add_pad(self._sinkpad)
self.add_pad(self._srcpad)
self.startposition = position
self.duration = duration
self.fadefromblack = fadefromblack
self.alphacontrol = gst.Controller(self.alpha, "alpha")
self.alphacontrol.set_interpolation_mode("alpha", gst.INTERPOLATE_LINEAR)
self._resetControllerValues()
def make_source(self):
bin = gst.Bin()
if CAMERA:
source = gst.element_factory_make("v4l2src")
source.set_property("device", CAMERA)
bin.add(source)
else:
source = gst.element_factory_make("videotestsrc")
source.set_property("is-live", 1)
bin.add(source)
overlay = gst.element_factory_make("timeoverlay")
overlay.set_property("font-desc", "Sans 32")
bin.add(overlay)
source.link(overlay)
source=overlay
filter = gst.element_factory_make("capsfilter")
filter.set_property("caps", gst.Caps("video/x-raw-yuv , width=[300,500] , height=[200,500], framerate=[20/1,30/1]"))
bin.add(filter)
source.link(filter)
videoscale = gst.element_factory_make("videoscale")
bin.add(videoscale)
filter.link(videoscale)
bin.add_pad(gst.GhostPad("src", videoscale.get_pad("src")))
return bin
def __init__(self):
QMainWindow.__init__(self)
self.initUI()
# Must not be initialized until after layout is set
self.gstWindowId = None
engine_config = 'gstreamer'
if engine_config == 'gstreamer':
self.source = gst.element_factory_make("v4l2src", "vsource")
self.source.set_property("device", "/dev/video0")
print 'FD', self.source.get_property("device-fd")
#self.fd = open('/dev/video0', 'rw')
#self.source.set_property("uri", 'fd://%s' % self.fd.fileno())
self.setupGst()
elif engine_config == 'gstreamer-testsrc':
self.source = gst.element_factory_make("videotestsrc", "video-source")
self.setupGst()
else:
raise Exception('Unknown engine %s' % (engine_config,))
if self.gstWindowId:
print "Starting gstreamer pipeline"
self.player.set_state(gst.STATE_PLAYING)
def __probe(self):
"""Probes the device to figure out which v4l source to use"""
# first v4l
v = gst.Pipeline()
vsrc = gst.element_factory_make("v4lsrc")
vsrc.props.device = self._device
fsink = gst.element_factory_make("fakesink")
v.add(vsrc, fsink)
vsrc.link(fsink)
if v.set_state(gst.STATE_PAUSED) != gst.STATE_CHANGE_FAILURE:
self.__isv4l2 = False
self.__probed = True
v.set_state(gst.STATE_NULL)
return
v.set_state(gst.STATE_NULL)
v = gst.Pipeline()
vsrc = gst.element_factory_make("v4l2src")
vsrc.props.device = self._device
fsink = gst.element_factory_make("fakesink")
v.add(vsrc, fsink)
# let's still make sure that it's a v4l2 device :)
if v.set_state(gst.STATE_PAUSED) != gst.STATE_CHANGE_FAILURE:
self.__isv4l2 = True
self.__probed = True
v.set_state(gst.STATE_NULL)
return
v.set_state(gst.STATE_NULL)
self.warning("Could not probe %s", self._device)
def get_videoinput_bin(self):
"""
Return the video input object in gstreamer bin format.
"""
bin = gst.Bin() # Do not pass a name so that we can load this input more than once.
videosrc = None
if sys.platform.startswith("linux"):
videosrc = gst.element_factory_make("v4l2src", "videosrc")
videosrc.set_property("device", self.device)
elif sys.platform in ["win32", "cygwin"]:
videosrc = gst.element_factory_make("dshowvideosrc", "videosrc")
videosrc.set_property("device-name", self.device)
bin.add(videosrc)
colorspace = gst.element_factory_make("ffmpegcolorspace", "colorspace")
bin.add(colorspace)
videosrc.link(colorspace)
# Setup ghost pad
pad = colorspace.get_pad("src")
ghostpad = gst.GhostPad("videosrc", pad)
bin.add_pad(ghostpad)
return bin
def decoder_pad_added(self, decoder, pad):
caps_string = pad.get_caps().to_string()
if caps_string.startswith('video'):
pad.link(self.video_input_queue.get_pad('sink'))
if caps_string.startswith('video/x-h264'):
#h264parse = gst.element_factory_make('h264parse', 'h264parse')
#h264parse.set_property('output-format', 1)
#self.transcoder.add(h264parse)
#gst.element_link_many(self.video_input_queue, h264parse, self.video_output_queue, self.muxer)
gst.element_link_many(self.video_input_queue, self.video_output_queue, self.muxer)
#h264parse.set_state(gst.STATE_PLAYING)
else:
video_encoder = gst.element_factory_make('ffenc_mpeg4', 'video-encoder')
video_encoder.set_property('bitrate', (2048*1000))
self.transcoder.add(video_encoder)
gst.element_link_many(self.video_input_queue, video_encoder, self.video_output_queue, self.muxer)
video_encoder.set_state(gst.STATE_PLAYING)
elif caps_string.startswith('audio'):
pad.link(self.audio_input_queue.get_pad('sink'))
if caps_string.startswith('audio/x-ac3'):
ac3parse = gst.element_factory_make('ac3parse', 'ac3parse')
self.transcoder.add(ac3parse)
gst.element_link_many(self.audio_input_queue, ac3parse, self.audio_output_queue, self.muxer)
ac3parse.set_state(gst.STATE_PLAYING)
elif caps_string.startswith('audio/mpeg'):
gst.element_link_many(self.audio_input_queue, self.audio_output_queue, self.muxer)
else:
audioconvert = gst.element_factory_make('audioconvert', 'audioconvert')
audio_encoder = gst.element_factory_make('ffenc_mp2', 'audio-encoder')
self.transcoder.add(audioconvert, audio_encoder)
gst.element_link_many(self.audio_input_queue, audioconvert, audio_encoder, self.audio_output_queue, self.muxer)
audioconvert.set_state(gst.STATE_PLAYING)
audio_encoder.set_state(gst.STATE_PLAYING)
def demux_pad_added(self, element, pad, bool):
'''Add fake sink to get demux info'''
caps = pad.get_caps()
structure = caps[0]
stream_type = structure.get_name()
if stream_type.startswith('video'):
self.have_video = True
colorspace = gst.element_factory_make('ffmpegcolorspace')
self.pipeline.add(colorspace)
colorspace.set_state(gst.STATE_PLAYING)
pad.link(colorspace.get_pad('sink'))
self.video = gst.element_factory_make('fakesink')
self.video.props.signal_handoffs = True
self.pipeline.add(self.video)
self.video.set_state(gst.STATE_PLAYING)
colorspace.link(self.video)
self.video_cb = self.video.connect('handoff',
self.get_video_info_cb)
elif stream_type.startswith('audio'):
self.have_audio = True
self.audio = gst.element_factory_make('fakesink')
self.audio.props.signal_handoffs = True
self.pipeline.add(self.audio)
self.audio.set_state(gst.STATE_PLAYING)
pad.link(self.audio.get_pad('sink'))
self.audio_cb = self.audio.connect('handoff',
self.get_audio_info_cb)
def link_audio_sink(self, pad):
"Link the audio sink to the pad"
print >>sys.stderr, "LINKING AUDIO SINK"
if not self.adder:
audiosink = gst.element_factory_make("alsasink")
audiosink.set_property("buffer-time", 50000)
self.pipeline.add(audiosink)
try:
self.adder = gst.element_factory_make("liveadder")
except gst.ElementNotFoundError:
audiosink.set_state(gst.STATE_PLAYING)
pad.link(audiosink.get_pad("sink"))
return
self.pipeline.add(self.adder)
audiosink.set_state(gst.STATE_PLAYING)
self.adder.link(audiosink)
self.adder.set_state(gst.STATE_PLAYING)
convert1 = gst.element_factory_make("audioconvert")
self.pipeline.add(convert1)
resample = gst.element_factory_make("audioresample")
self.pipeline.add(resample)
convert2 = gst.element_factory_make("audioconvert")
self.pipeline.add(convert2)
convert1.link(resample)
resample.link(convert2)
convert2.link(self.adder)
pad.link(convert1.get_pad("sink"))
convert2.set_state(gst.STATE_PLAYING)
resample.set_state(gst.STATE_PLAYING)
convert1.set_state(gst.STATE_PLAYING)
def __init__(self):
gst.Pipeline.__init__(self)
self.set_name('jamedia_video_pipeline')
convert = gst.element_factory_make('ffmpegcolorspace', 'convert')
rate = gst.element_factory_make('videorate', 'rate')
pantalla = gst.element_factory_make('xvimagesink', "pantalla")
pantalla.set_property("force-aspect-ratio", True)
try: # FIXME: xo no posee esta propiedad
rate.set_property('max-rate', 30)
except:
pass
self.add(convert)
self.add(rate)
self.add(pantalla)
convert.link(rate)
rate.link(pantalla)
self.ghost_pad = gst.GhostPad("sink", convert.get_static_pad("sink"))
self.ghost_pad.set_target(convert.get_static_pad("sink"))
self.add_pad(self.ghost_pad)
def __init__(self, uri, process = None, hopsize = 512,
caps = None):
if uri.startswith('/'):
from urllib import quote
uri = 'file://'+quote(uri)
src = gst.element_factory_make('uridecodebin')
src.set_property('uri', uri)
src.connect('pad-added', self.source_pad_added_cb)
conv = gst.element_factory_make('audioconvert')
self.conv = conv
rsmpl = gst.element_factory_make('audioresample')
capsfilter = gst.element_factory_make('capsfilter')
if caps:
capsfilter.set_property('caps', gst.caps_from_string(caps))
sink = AubioSink("AubioSink", process = process)
sink.set_property('hopsize', hopsize) # * calcsize('f'))
self.pipeline = gst.Pipeline()
self.bus = self.pipeline.get_bus()
self.bus.add_signal_watch()
self.bus.connect('message', self.on_eos)
self.apad = conv.get_pad('sink')
self.pipeline.add(src, conv, rsmpl, capsfilter, sink)
gst.element_link_many(conv, rsmpl, capsfilter, sink)
self.mainloop = gobject.MainLoop()
self.pipeline.set_state(gst.STATE_PLAYING)
def _set_video_source(self):
video_src = gst.element_factory_make(self.video_source, 'video_src')
if (self.video_source_type.startswith('usb')):
# not sure about device format on windows. for now lets just use the default
if os.name == 'posix': # only set device for linux systems.
video_src.set_property('device', self.video_device)
video_rate = gst.element_factory_make('videorate', 'video_rate')
video_rate_cap = gst.element_factory_make('capsfilter',
'video_rate_cap')
video_rate_cap.set_property('caps',
gst.caps_from_string('video/x-raw-rgb, framerate=10/1'))
video_scale = gst.element_factory_make('videoscale', 'video_scale')
video_scale_cap = gst.element_factory_make('capsfilter',
'video_scale_cap')
video_cspace = gst.element_factory_make('ffmpegcolorspace',
'video_cspace')
self.video_tee = gst.element_factory_make('tee', 'video_tee')
if self.recording_width != '0':
self.core.logger.log.debug('Recording will be scaled to %sx%s'
% (self.recording_width, self.recording_height))
video_scale_cap.set_property('caps',
gst.caps_from_string('video/x-raw-rgb, width=%s, height=%s'
% (self.recording_width, self.recording_height)))
self.player.add(video_src,
video_rate,
video_rate_cap,
video_scale,
video_scale_cap,
video_cspace,
self.video_tee)
if ( self.icecast ):
# Add a "tee" component so that the icecast components can be built at the end
self.src_tee = gst.element_factory_make('tee', 'src_tee')
self.player.add( self.src_tee )
video_src.link( self.src_tee )
if (self.video_source_type == 'firewire'):
self.dv1394q1 = gst.element_factory_make('queue', 'dv1394q1')
self.dv1394q2 = gst.element_factory_make('queue', 'dv1394q2')
self.dv1394dvdemux = gst.element_factory_make('dvdemux',
'dv1394dvdemux')
self.dv1394dvdec = gst.element_factory_make('dvdec', 'dv1394dvdec')
self.player.add(self.dv1394q1,
self.dv1394q2,
self.dv1394dvdemux,
self.dv1394dvdec)
if ( self.icecast ):
# The "src_tee" was added so link from it
self.src_tee.link(self.dv1394dvdemux)
else:
video_src.link(self.dv1394dvdemux)
self.dv1394dvdemux.connect('pad-added', self._dvdemux_padded)
gst.element_link_many(self.dv1394q1, self.dv1394dvdec, video_rate)
else:
if ( self.icecast ):
# The "src_tee" was added so link from it
self.src_tee.link(video_rate)
else:
video_src.link(video_rate)
gst.element_link_many(video_rate,
video_rate_cap,
video_scale,
video_scale_cap,
video_cspace,
self.video_tee)
if __name__ == "__main__":
import sys
import gobject
gobject.threads_init()
if len(sys.argv) != 4:
print "Usage: %s <ip_address> <user> <pass>" % sys.argv[0]
sys.exit(-1)
pipeline = gst.Pipeline("pipe")
gobject.type_register(KaicongAudioSource)
gst.element_register(KaicongAudioSource, 'kaicongaudiosrc',
gst.RANK_MARGINAL)
src = gst.element_factory_make("kaicongaudiosrc", "audiosrc")
src.set_property("ip", sys.argv[1])
src.set_property("user", sys.argv[2])
src.set_property("pwd", sys.argv[3])
src.set_property("on", True)
conv = gst.element_factory_make("audioconvert", "audioconv")
amp = gst.element_factory_make("audioamplify", "audioamp")
amp.set_property("amplification", 20)
res = gst.element_factory_make("audioresample", "audioresamp")
sink = gst.element_factory_make("autoaudiosink", "audiosink")
pipeline.add(src, conv, amp, res, sink)
gst.element_link_many(src, conv, amp, res, sink)
pipeline.set_state(gst.STATE_PLAYING)
main_loop = gobject.MainLoop()
def get_output_bin(self, audio=True, video=True, metadata=None):
bin = gst.Bin()
if metadata is not None:
self.set_metadata(metadata)
# Muxer
muxer = gst.element_factory_make("flvmux", "muxer")
# Setup metadata
# set tag merge mode to GST_TAG_MERGE_REPLACE
merge_mode = gst.TagMergeMode.__enum_values__[2]
if metadata is not None:
# Only set tag if metadata is set
muxer.merge_tags(self.tags, merge_mode)
muxer.set_tag_merge_mode(merge_mode)
bin.add(muxer)
# RTMP sink
rtmpsink = gst.element_factory_make('rtmpsink', 'rtmpsink')
rtmpsink.set_property('location', self.config.url)
bin.add(rtmpsink)
#
# Setup Audio Pipeline if Audio Recording is Enabled
#
if audio:
audioqueue = gst.element_factory_make("queue", "audioqueue")
bin.add(audioqueue)
audioconvert = gst.element_factory_make("audioconvert",
"audioconvert")
bin.add(audioconvert)
audiolevel = gst.element_factory_make('level', 'audiolevel')
audiolevel.set_property('interval', 20000000)
bin.add(audiolevel)
audiocodec = gst.element_factory_make(self.config.audio_codec,
"audiocodec")
if 'quality' in audiocodec.get_property_names():
audiocodec.set_property("quality", self.config.audio_quality)
else:
log.debug(
"WARNING: Missing property: 'quality' on audiocodec; available: "
+ ','.join(audiocodec.get_property_names()))
bin.add(audiocodec)
# Setup ghost pads
audiopad = audioqueue.get_pad("sink")
audio_ghostpad = gst.GhostPad("audiosink", audiopad)
bin.add_pad(audio_ghostpad)
# Link Elements
audioqueue.link(audioconvert)
audioconvert.link(audiolevel)
audiolevel.link(audiocodec)
audiocodec.link(muxer)
#
# Setup Video Pipeline
#
if video:
videoqueue = gst.element_factory_make("queue", "videoqueue")
bin.add(videoqueue)
videocodec = gst.element_factory_make("x264enc", "videocodec")
videocodec.set_property("bitrate", self.config.video_bitrate)
if self.config.video_tune != 'none':
videocodec.set_property('tune', self.config.video_tune)
bin.add(videocodec)
# Setup ghost pads
videopad = videoqueue.get_pad("sink")
video_ghostpad = gst.GhostPad("videosink", videopad)
bin.add_pad(video_ghostpad)
# Link Elements
videoqueue.link(videocodec)
videocodec.link(muxer)
#
# Link muxer to rtmpsink
#
muxer.link(rtmpsink)
if self.config.streaming_destination == STREAMING_DESTINATION_VALUES[
1] and self.config.use_justin_api == 'yes':
self.justin_api.set_channel_status(self.get_talk_status(metadata),
self.get_description(metadata))
return bin
def _set_icecast_streaming(self):
'''
Sets up the icecast stream pipeline.
'''
icecast = gst.element_factory_make('shout2send', 'icecast')
icecast.set_property('ip', self.icecast_ip)
icecast.set_property('port', self.icecast_port)
icecast.set_property('password', self.icecast_password)
icecast.set_property('mount', self.icecast_mount)
# Need to add "ffmpegcolorspace" to the player again, after "src_tee"
icecast_colorspace = gst.element_factory_make('ffmpegcolorspace', 'icecast_colorspace')
icecast_queue = gst.element_factory_make('queue', 'icecast_queue')
icecast_scale = gst.element_factory_make('videoscale', 'icecast_scale')
icecast_scale_cap = gst.element_factory_make('capsfilter', 'icecast_scale_cap')
#icecast_gst_caps = gst.Caps('video/x-raw-yuv,width=320,height=240')
#icecast_scale_cap.set_property('caps', icecast_gst_caps)
#icecast_video_codec = gst.element_factory_make(self.icecast_video_codec, 'icecast_video_codec')
#icecast_video_codec.set_property('quality',16)
icecast_gst_caps = gst.Caps('video/x-raw-yuv,width=' + str(self.icecast_width) + ',height=' + str(self.icecast_height))
icecast_scale_cap.set_property('caps', icecast_gst_caps)
icecast_video_codec = gst.element_factory_make(self.icecast_video_codec, 'icecast_video_codec')
icecast_video_codec.set_property('bitrate',self.icecast_vidbitrate)
icecast_muxer = gst.element_factory_make(self.icecast_muxer, 'icecast_muxer')
icecast_audio_src = gst.element_factory_make(self.icecast_audio_src,'icecast_audio_src')
icecast_queue2 = gst.element_factory_make('queue','icecast_queue2')
icecast_audioconvert = gst.element_factory_make('audioconvert','icecast_audioconvert')
icecast_audio_codec = gst.element_factory_make(self.icecast_audio_codec,'icecast_audio_codec')
icecast_audio_codec.set_property('quality',0.2)
icecast_queue3 = gst.element_factory_make('queue','icecast_queue3')
icecast_queue4 = gst.element_factory_make('queue','icecast_queue4')
self.player.add(icecast,
icecast_queue,
icecast_queue2,
icecast_queue3,
icecast_queue4,
icecast_colorspace,
icecast_video_codec,
icecast_muxer,
icecast_audio_src,
icecast_audioconvert,
icecast_audio_codec,
icecast_scale,
icecast_scale_cap)
gst.element_link_many(self.src_tee,
icecast_queue,
icecast_colorspace,
icecast_scale,
icecast_scale_cap,
icecast_video_codec,
icecast_muxer)
gst.element_link_many(icecast_audio_src,
icecast_queue2,
icecast_audioconvert,
icecast_audio_codec,
icecast_queue3,
icecast_muxer,
icecast_queue4,
icecast)
def _set_audio_feedback(self):
afqueue = gst.element_factory_make('queue', 'afqueue')
afsink = gst.element_factory_make('autoaudiosink', 'afsink')
self.player.add(afqueue, afsink)
gst.element_link_many(self.audio_tee, afqueue, afsink)
def _set_audio_source(self):
audio_src = gst.element_factory_make(self.audio_source, 'audio_src')
self.audio_tee = gst.element_factory_make('tee', 'audio_tee')
self.player.add(audio_src, self.audio_tee)
audio_src.link(self.audio_tee)
def _set_video_feedback(self):
vpqueue = gst.element_factory_make('queue', 'vpqueue')
vpsink = gst.element_factory_make('autovideosink', 'vpsink')
self.player.add(vpqueue, vpsink)
gst.element_link_many(self.video_tee, vpqueue, vpsink)
import time
import sys
def on_message(self, bus, message):
pass
def on_about_to_finish(playbin):
playbin.set_property(
'uri',
'file:///home/leon/Workspaces/py-icecream/samples/gapless/ogg/07. Beethoven.ogg'
)
playbin = gst.element_factory_make('playbin2')
fakesink = gst.element_factory_make('fakesink')
playbin.set_property('video-sink', fakesink)
playbin.set_property(
'uri',
'file:///home/leon/Workspaces/py-icecream/samples/gapless/ogg/06. Beethoven.ogg'
)
bus = playbin.get_bus()
bus.add_signal_watch()
bus.connect("message", on_message)
playbin.connect('about-to-finish', on_about_to_finish)
for i in playbin.elements():
self.offset = value
else:
logger.error("No property %s" % key.name)
gst.element_register(SliceBuffer, 'slicebuffer')
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
mainloop = gobject.MainLoop()
files = [a for a in sys.argv[1:] if not '=' in a]
params = [a for a in sys.argv[1:] if '=' in a]
if files:
player = gst.element_factory_make('playbin')
player.props.uri = 'file://' + files[0]
bin = gst.Bin()
elements = [
gst.element_factory_make('ffmpegcolorspace'),
gst.element_factory_make('videoscale'),
gst.element_factory_make('slicebuffer', 'slicer'),
gst.element_factory_make('capsfilter', 'capsfilter'),
gst.element_factory_make('ffmpegcolorspace'),
gst.element_factory_make('xvimagesink'),
]
bin.add(*elements)
gst.element_link_many(*elements)
bin.add_pad(
gst.GhostPad(
#create the logger
logger = logging.getLogger('Pilot Client log') #__name__
logging.info('\n\nPilot client has just connected...\n')
#add log handler so it can have max of 32mb file
handler = logging.handlers.RotatingFileHandler('AudioStreamerLogging.log',
maxBytes=2 ^ 15,
backupCount=0)
logger.addHandler(handler)
# create the pipeline and add client [ filesrc ! tcpclientsink ]
pipeline = gst.Pipeline("client")
#player = gst.element_factory_make("playbin", "player")
src = gst.element_factory_make("filesrc", "source")
logger.debug('Debug msg: %s' % src + ' created')
files = []
poppedfiles = []
path = os.path.join("/opt/crat/core/home/sounds/PILOTS/")
def getFiles(path):
if os.path.isdir(path) == False:
print "\nThe required folder %s" % path + " doesn't exist\n" + "Please extract all PILOTS songs or contact the admin\n"
exit(-1)
#make it even more randomly :D
random.seed()
for f in sorted(os.listdir(path), key=lambda k: random.random()):
f = os.path.join(path, f)
def __init__( self, filename, timeout=3000, max_interleave=1.0 ):
self.is_video = False
self.is_audio = False
self.finished = False
self._success = False
self._nomorepads = False
self._timeoutid = 0
self._timeout = timeout
self._max_interleave = max_interleave
if not os.path.isfile(filename):
self.debug("File '%s' does not exist, finished" % filename)
self.finished = True
return
# the initial elements of the pipeline
self.src = gst.element_factory_make("filesrc")
self.src.set_property("location", filename)
self.src.set_property("blocksize", 1000000)
self.dbin = gst.element_factory_make("decodebin")
self.add(self.src, self.dbin)
self.src.link(self.dbin)
self.typefind = self.dbin.get_by_name("typefind")
def _timed_out_or_eos(self):
if (not self.is_audio and not self.is_video) or \
(self.is_audio and not self.audiocaps) or \
(self.is_video and not self.videocaps):
self._finished(False)
else:
self._finished(True)
def _finished(self, success=False):
self.debug("success:%d" % success)
self._success = success
self.bus.remove_signal_watch()
if self._timeoutid:
gobject.source_remove(self._timeoutid)
self._timeoutid = 0
gobject.idle_add(self._stop)
return False
def _stop(self):
self.debug("success:%d" % self._success)
self.finished = True
self.set_state(gst.STATE_READY)
self.debug("about to emit signal")
self.emit('discovered', self._success)
def discover(self):
"""Find the information on the given file asynchronously"""
self.debug("starting discovery")
if self.finished:
self.emit('discovered', False)
return
self.bus = self.get_bus()
self.bus.add_signal_watch()
self.bus.connect("message", self._bus_message_cb)
# 3s timeout
self._timeoutid = gobject.timeout_add(self._timeout, self._timed_out_or_eos)
self.info("setting to PLAY")
if not self.set_state(gst.STATE_PLAYING):
self._finished()
def fetchDevices(mid, factories, parameter):
"""
Fetches the available devices on the system according to the specified
factories. If the first factory succeeds the other are ignored.
The result is either:
- succesful, with a list of tuples with guid and device-name
- succesful, with an error
- failed
@param mid: the id to set on the message.
@param factories: The gstreamer elements to check
@type factories: L{str}
@param parameter: The parameter that specifies the device
@type parameter: str
@rtype: L{twisted.internet.defer.Deferred} of
L{flumotion.common.messages.Result}
"""
result = messages.Result()
factory = factories.pop()
try:
element = gst.element_factory_make(factory)
except gst.ElementNotFoundError:
element = None
if not element:
log.debug("device-check", "Could not instantiate the %s factory.",
factory)
if not factories:
log.debug("device-check", "No more factories were specified.")
m = messages.Error(T_(
N_("GStreamer error, %s factory could not be found.\n"
"Maybe the plugin is not properly installed.")),
mid=mid)
result.add(m)
return defer.succeed(result)
else:
return fetchDevices(mid, factories, parameter)
element.probe_property_name(parameter)
values = element.probe_get_values_name(parameter)
pipeline_str = "%s name=source %s" % (factory, parameter)
pipeline_str += "=%s ! fakesink"
devices = []
for value in values:
pipeline = gst.parse_launch(pipeline_str % value)
pipeline.set_state(gst.STATE_READY)
source = pipeline.get_by_name("source")
name = source.get_property("device-name")
log.debug("device-check", "New device found: %s with values=%s", name,
value)
devices.append((name, value))
pipeline.set_state(gst.STATE_NULL)
if devices:
result.succeed(devices)
return defer.succeed(result)
else:
log.debug("device-check", "No devices were found using %s factory.",
factory)
if factories:
return fetchDevices(mid, factories, parameter)
else:
m = messages.Error(T_(N_("No devices were found for %s."),
factory),
mid=mid)
result.add(m)
return defer.succeed(result)
def create_decodebin():
try:
return gst.element_factory_make("decodebin2")
except:
return gst.element_factory_make("decodebin")
def execute(self, **kwargs):
"""Speak the provided text through the computer's speakers.
Keyword arguments:
text -- the text to speak
"""
if "text" not in kwargs:
return ''
phrase = str(kwargs["text"])
names = {"callie": "6.5", "lawrence": "8.5"}
name = "callie"
#TODO find a better way of implementing TTS
ttsfd, ttsfile = tempfile.mkstemp(".wav")
outfile, outname = tempfile.mkstemp(".wav")
try:
tts = sp.Popen(
['/opt/swift/bin/swift', '-o', ttsfile, '-n', name, phrase],
stdout=sp.PIPE,
stderr=sp.PIPE)
# cmd = ('/opt/swift/bin/swift "' + phrase + '" -o ' + ttsname + ' && sox -V1 ' +
# tmp + ' -t wav ' + tmp2 + ' trim 8 ;')
# p = sp.Popen(cmd, stdout=sp.PIPE, stderr=sp.PIPE, shell=True)
# out, err = p.communicate()
# if len(err) > 0:
# return err
out, err = tts.communicate()
if not err:
sox = sp.Popen([
'sox', '-V1', ttsfile, '-t', 'wav', outname, 'trim',
names[name]
],
stdout=sp.PIPE,
stderr=sp.PIPE)
out, err = sox.communicate()
player = gst.element_factory_make("playbin2", "player")
bus = player.get_bus()
bus.add_signal_watch()
mainloop = gobject.MainLoop()
def quit(bus, message):
mainloop.quit()
bus.connect("message::eos", quit)
bus.connect("message::error", quit)
player.set_property("uri", 'file://' + outname)
player.set_state(gst.STATE_PLAYING)
try:
mainloop.run()
finally:
player.set_state(gst.STATE_NULL)
finally:
try:
os.remove(ttsfile)
except OSError as err:
print e
try:
os.remove(outname)
except IOError as err:
print err
def _makeGnlObject(self):
effect = gst.element_factory_make(
'gnloperation', "gnloperation: " +
self.factory.__class__.__name__ + str(TrackEffect.numobjs))
TrackEffect.numobjs += 1
return effect
self.pipe.set_state(gst.STATE_PLAYING)
def asr_partial_result(self, asr, text, uttid):
""" This function is called when pocketsphinx gets a partial
transcription of spoken audio.
"""
self.partial_cb(self.name, uttid, text)
def asr_result(self, asr, text, uttid):
""" This function is called when pocketsphinx gets a
full result (spoken command with a pause)
"""
self.final_cb(self.name, uttid, text)
if __name__ == "__main__":
import threading
import gobject
gobject.threads_init()
def print_cb(name, uttid, text):
print "(%s) %s: %s" % (uttid, name, text)
src = gst.element_factory_make("autoaudiosrc") # Grab a random source
parser = SpeechParser("parser", src, print_cb, print_cb)
# This loops the program until Ctrl+C is pressed
g_loop = threading.Thread(target=gobject.MainLoop().run)
g_loop.daemon = False
g_loop.start()
def build_pipeline(self):
self.player = gst.element_factory_make("playbin", "player")
self.bus = self.player.get_bus()
self.player.set_state(gst.STATE_READY)
def play(self):
self.emit("preplay")
self.player = gst.Pipeline("player")
self.queue_video = gst.element_factory_make("queue", "queue_video")
self.player.add(self.queue_video)
self.input_type = 0
# Source selection
self.source_pads = {}
self.audio_pads = {}
self.pip_pads = {}
self.output_bins = {}
type = 0
source_number = 0
pip_number = 0
self.pip = PictureInPicture()
self.player.add(self.pip)
for row in self.sources.get_store():
(name, source) = row
element = source.create()
self.player.add(element)
if element.does_audio():
if not self.input_type & MEDIA_AUDIO:
# The pipeline has audio sources, and this is the first
# audio source we add
if self.audio_source is None:
self.emit("error", "You need to select an audio source")
self.emit("stopped")
return
self.input_type |= MEDIA_AUDIO
self.input_selector = gst.element_factory_make(
"input-selector", "audio-selector"
)
self.player.add(self.input_selector)
audiobin = audioinputbin.AudioInputBin(source)
self.player.add(audiobin)
element.audio_pad.link(audiobin.get_static_pad("sink"))
self.audio_pads[name] = \
self.input_selector.get_request_pad("sink%d")
audiobin.src_pad.link(self.audio_pads[name])
if element.does_video():
self.input_type |= MEDIA_VIDEO
self.source_pads[name] = source_number
source_number = source_number + 1
# Thumbnail preview
tee = gst.element_factory_make("tee", None)
self.player.add(tee)
element.video_pad.link(tee.sink_pads().next())
thumbnail_queue = gst.element_factory_make("queue", None)
self.player.add(thumbnail_queue)
self.thumbnails[name] = Preview(self)
self.player.add(self.thumbnails[name])
thumbnail_err = gst.element_link_many(
tee, thumbnail_queue, self.thumbnails[name]
)
if thumbnail_err == False:
self.emit("error", "Error conecting thumbnail preview.")
# Picture in Picture
self.pip_pads[name] = pip_number
pip_number = pip_number + 1
main_queue = gst.element_factory_make("queue", None)
self.player.add(main_queue)
pip_queue = gst.element_factory_make("queue", None)
self.player.add(pip_queue)
tee.link(main_queue)
tee.link(pip_queue)
main_queue.src_pads().next().link(self.pip.get_request_pad_A())
pip_queue.src_pads().next().link(self.pip.get_request_pad_B())
if name == self.video_source:
type |= element.get_type()
if name == self.audio_source:
type |= element.get_type()
self.watermark = gst.element_factory_make(
"cairoimageoverlay", "cairoimageoverlay"
)
self.player.add(self.watermark)
self.colorspace = gst.element_factory_make(
"ffmpegcolorspace", "colorspace-imageoverlay-videobalance"
)
self.player.add(self.colorspace)
self.videobalance = gst.element_factory_make(
"videobalance", "videobalance"
)
self.player.add(self.videobalance)
if self.videobalance_contrast:
self.videobalance.set_property(
"contrast", self.videobalance_contrast
)
if self.videobalance_brightness:
self.videobalance.set_property(
"brightness", self.videobalance_brightness
)
if self.videobalance_hue:
self.videobalance.set_property(
"hue", self.videobalance_hue
)
if self.videobalance_saturation:
self.videobalance.set_property(
"saturation", self.videobalance_saturation
)
gst.element_link_many(
self.pip, self.watermark, self.colorspace, self.videobalance,
self.queue_video
)
self._switch_source()
self._switch_pip()
if self.pip_position:
self.pip.set_property("position", self.pip_position)
self.effect[MEDIA_VIDEO] = effect.video_effect.VideoEffect(
self.effect_name[MEDIA_VIDEO]
)
self.player.add(self.effect[MEDIA_VIDEO])
self.overlay = gst.element_factory_make("textoverlay", "overlay")
self.overlay.set_property("font-desc", self.overlay_font)
self.overlay.set_property("halign", self.halign)
self.overlay.set_property("valign", self.valign)
self.player.add(self.overlay)
gst.element_link_many(
self.queue_video, self.effect[MEDIA_VIDEO], self.overlay
)
self.preview_tee = multeequeue.MulTeeQueue()
self.player.add(self.preview_tee)
self.overlay.link(self.preview_tee)
if self.input_type & MEDIA_AUDIO:
self.convert = gst.element_factory_make("audioconvert", "convert")
self.player.add(self.convert)
self.effect[MEDIA_AUDIO] = effect.audio_effect.AudioEffect(
self.effect_name[MEDIA_AUDIO]
)
self.player.add(self.effect[MEDIA_AUDIO])
self.audio_tee = gst.element_factory_make("tee", "audio_tee")
self.player.add(self.audio_tee)
self.volume = volume.Volume()
self.player.add(self.volume)
gst.element_link_many(
self.input_selector, self.volume,
self.effect[MEDIA_AUDIO], self.convert, self.audio_tee
)
self.input_selector.set_property(
"active-pad", self.audio_pads[self.audio_source]
)
added_encoders = {}
pip_width = 0
pip_height = 0
for row in self.outputs.get_store():
(name, output) = row
output_bin = outputbin.OutputBin(output)
self.output_bins[name] = output_bin
self.player.add(output_bin)
encoder_name = output.get_config()["parent"]
encoder_item = self.encoders.get_item(encoder_name)
if encoder_item is None:
self.emit("error", "Please, add an encoder.")
break
if added_encoders.has_key(encoder_name):
tee = added_encoders[encoder_name]
tee.link(output_bin)
else:
tee = gst.element_factory_make("tee", None)
self.player.add(tee)
converter_item = encoder_item.parent
converter = converter_item.create()
if converter_item.config["width"] > pip_width:
pip_width = converter_item.config["width"]
if converter_item.config["height"] > pip_height:
pip_height = converter_item.config["height"]
self.player.add(converter)
encoder = encoder_item.factory.create(type)
if encoder.vorbisenc:
self.metadata = metadata.Metadata(encoder.vorbisenc)
self.metadata.set_tags(self.taglist)
encoder.config(encoder_item.config)
self.player.add(encoder)
added_encoders[encoder_name] = tee
self.preview_tee.get_src_pad().link(
converter.sink_pads().next()
)
gst.element_link_many(
converter, encoder, tee, output_bin
)
if self.input_type & MEDIA_AUDIO:
audio_queue = gst.element_factory_make("queue", None)
self.player.add(audio_queue)
gst.element_link_many(self.audio_tee, audio_queue, encoder)
self.preview = Preview(self)
self.player.add(self.preview)
self.preview_tee.get_src_pad().link(self.preview.sink_pads().next())
if pip_width == 0:
pip_width = 320
pip_height = 240
self.pip.set_property("width", int(pip_width))
self.pip.set_property("height", int(pip_height))
self.video_width = int(pip_width)
self.video_height = int(pip_height)
self._set_watermark(self.video_width, self.video_height)
self.overlay.set_property("text", self.overlay_text)
if self.volume_value is not None:
self.volume.set_property("volume", self.volume_value)
self.emit("pipeline-ready")
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)
cr = self.player.set_state(gst.STATE_PLAYING)
if cr == gst.STATE_CHANGE_SUCCESS:
self.emit("playing")
elif cr == gst.STATE_CHANGE_ASYNC:
self.pending_state = gst.STATE_PLAYING
def build_elements(self):
self.player = gst.Pipeline()
self.filesrc = gst.element_factory_make("gnomevfssrc", "filesrc")
self.typefinder = gst.element_factory_make("typefind", "typefinder")
self.typefinder.connect("have-type", self.__cb_typefound)
self.player.add(self.filesrc, self.typefinder)
gst.element_link_many(self.filesrc, self.typefinder)
bus = self.player.get_bus()
bus.add_signal_watch()
bus.connect('message', self.on_message)
self.mp3audiosink = gst.element_factory_make("dspmp3sink")
self.mp3audioqueue = gst.element_factory_make("queue")
self.mp3audiobin = gst.Bin('mp3bin')
self.mp3audiobin.add(self.mp3audioqueue, self.mp3audiosink)
self.videosink = gst.element_factory_make("xvimagesink", 'videosink')
self.hantrovideodec = gst.element_factory_make("hantro4100dec")
self.hantrovideoqueue = gst.element_factory_make("queue")
self.hantrovideobin = gst.Bin('hantrobin')
self.hantrovideobin.add(self.hantrovideoqueue, self.hantrovideodec)
self.mpegvideodec = gst.element_factory_make("ffdec_mpegvideo")
self.mpegvideoqueue = gst.element_factory_make("queue")
self.mpegvideobin = gst.Bin('mpegbin')
self.mpegvideobin.add(self.mpegvideoqueue, self.mpegvideodec)
self.aacaudiosink = gst.element_factory_make("dspaacsink")
self.aacaudioqueue = gst.element_factory_make("queue")
self.aacaudiobin = gst.Bin('aacbin')
self.aacaudiobin.add(self.aacaudioqueue, self.aacaudiosink)
gst.element_link_many(self.hantrovideoqueue, self.hantrovideodec)
gst.element_link_many(self.mp3audioqueue, self.mp3audiosink)
gst.element_link_many(self.mpegvideoqueue, self.mpegvideodec)
gst.element_link_many(self.aacaudioqueue, self.aacaudiosink)
self.hantrovideobin.add_pad(
gst.GhostPad('sink', self.hantrovideoqueue.get_pad('sink')))
self.hantrovideobin.add_pad(
gst.GhostPad('src', self.hantrovideodec.get_pad('src')))
self.mp3audiobin.add_pad(
gst.GhostPad('sink', self.mp3audioqueue.get_pad('sink')))
self.mpegvideobin.add_pad(
gst.GhostPad('sink', self.mpegvideoqueue.get_pad('sink')))
self.mpegvideobin.add_pad(
gst.GhostPad('src', self.mpegvideodec.get_pad('src')))
self.aacaudiobin.add_pad(
gst.GhostPad('sink', self.aacaudioqueue.get_pad('sink')))
def _makeGnlObject(self):
source = gst.element_factory_make(
'gnlsource', "gnlsource: " + self.factory.__class__.__name__ +
str(SourceTrackObject.numobjs))
SourceTrackObject.numobjs += 1
return source
def extractAudioTrackFile (device, track_number, filename, extra = None):
sink = gst.element_factory_make ("filesink")
sink.set_property ("location", filename)
return extractAudioTrack (device, track_number, sink, extra)
def __cb_typefound(self, element, prob, caps):
if str(caps).find("audio/mpeg") is not -1:
if self.mp3audiobin.get_parent() is None:
self.player.add(self.mp3audiobin)
gst.element_link_many(self.typefinder, self.mp3audiobin)
self.mp3audiobin.set_state(gst.STATE_PLAYING)
else:
self.mp3audiobin.set_state(gst.STATE_READY)
self.mp3audiobin.set_state(gst.STATE_PLAYING)
elif str(caps).find("application/x-id3") is not -1:
if self.mp3audiobin.get_parent() is None:
# id3lib = gst.element_factory_make("id3demux")
# self.player.add(id3lib)
self.player.add(self.mp3audiobin)
gst.element_link_many(self.typefinder, id3lib)
self.player.add(self.mp3audiobin)
id3lib.connect('pad-added', self.on_pad_added_mp3)
else:
self.mp3audiobin.set_state(gst.STATE_READY)
self.mp3audiobin.set_state(gst.STATE_PLAYING)
elif str(caps).find("video/x-msvideo") is not -1:
# Create elements
if self.hantrovideobin.get_parent() is None:
demux = gst.element_factory_make("avidemux")
self.player.add(demux)
# Link source and demux elements
gst.element_link_many(self.typefinder, demux)
# Connect handler for 'pad-added' signal
demux.connect('pad-added', self.on_pad_added)
self.player.add(self.hantrovideobin, self.videosink)
gst.element_link_many(self.hantrovideobin, self.videosink)
demux.set_state(gst.STATE_PLAYING)
elif str(caps).find("video/mpeg") is not -1:
# Create elements
if self.mpegvideobin.get_parent() is None:
demux = gst.element_factory_make("mpegdemux")
self.player.add(demux)
# Link source and demux elements
gst.element_link_many(self.typefinder, demux)
# Connect handler for 'pad-added' signal
demux.connect('pad-added', self.on_pad_added)
self.player.add(self.mpegvideobin, self.videosink)
gst.element_link_many(self.mpegvideobin, self.videosink)
demux.set_state(gst.STATE_PLAYING)
elif caps == "adts_mpeg_stream" or caps == "audio/x-ac3" or \
caps == "audio/x-dts":
if self.aacaudiobin.get_parent() is None:
self.player.add(self.aacaudiobin)
gst.element_link_many(self.typefinder, self.aacaudiobin)
self.aacaudiobin.set_state(gst.STATE_PLAYING)
else:
self.aacaudiobin.set_state(gst.STATE_READY)
self.aacaudiobin.set_state(gst.STATE_PLAYING)
elif caps == "video/quicktime":
pass
else:
log.error("format not support %s", str(caps))
self.player.set_state(gst.STATE_NULL)
self.__av_uri = None
def __init__(self, filename):
self.debug = True
self.last_ocr = ''
self.words = ''
self.frame = 0
self.seek_sec = 30
# self.gocr_cmd = ['gocr', '-', '-d', '0', '-a', '95']
self.ocr_cmd = ['tesseract', '/tmp/image.pnm', '/tmp/text']
self.base_name = os.path.splitext(filename)[0]
if self.debug: print(self.base_name)
pipeline = gst.Pipeline("mypipeline")
self.pipeline = pipeline
# source: file
filesrc = gst.element_factory_make("filesrc", "audio")
self.filesrc = filesrc
self.filesrc.set_property("location", filename)
pipeline.add(filesrc)
# decoder
decode = gst.element_factory_make("decodebin", "decode")
decode.connect("new-decoded-pad", self.OnDynamicPad)
pipeline.add(decode)
filesrc.link(decode)
ffmpegcolorspace = gst.element_factory_make("ffmpegcolorspace",
"ffmpegcolorspace")
pipeline.add(ffmpegcolorspace)
self.ffmpegcolorspace = ffmpegcolorspace
pnmenc = gst.element_factory_make("pnmenc", "pnmenc")
pnmenc.set_property('ascii', True)
pipeline.add(pnmenc)
self.pnmenc = pnmenc
ffmpegcolorspace.link(pnmenc)
sink = gst.element_factory_make("fakesink", "sink")
sink.set_property('signal-handoffs', True)
sink.connect('handoff', one_frame, self)
pipeline.add(sink)
pnmenc.link(sink)
# keep refernce to pipleline so it doesn't get destroyed
self.pipeline = pipeline
self.time_format = gst.Format(gst.FORMAT_TIME)
if self.debug:
# print the pipeline
elements = list(pipeline.elements())
elements.reverse()
print("pipeline elements:", end=' ')
for e in elements:
print(e.get_factory().get_name(), end=' ')
print()
bus = pipeline.get_bus()
bus.add_signal_watch()
bus.connect("message", self.on_message)
pipeline.set_state(gst.STATE_PLAYING)
def get_output_bin(self, audio=True, video=True, metadata=None):
bin = gst.Bin()
if metadata is not None:
self.set_metadata(metadata)
# Muxer
muxer = gst.element_factory_make("oggmux", "muxer")
bin.add(muxer)
icecast = gst.element_factory_make("shout2send", "icecast")
icecast.set_property("ip", self.config.ip)
icecast.set_property("port", self.config.port)
icecast.set_property("password", self.config.password)
icecast.set_property("mount", self.config.mount)
bin.add(icecast)
#
# Setup Audio Pipeline
#
if audio:
audioqueue = gst.element_factory_make("queue", "audioqueue")
bin.add(audioqueue)
audioconvert = gst.element_factory_make("audioconvert",
"audioconvert")
bin.add(audioconvert)
audiocodec = gst.element_factory_make("vorbisenc", "audiocodec")
audiocodec.set_property("quality", self.config.audio_quality)
bin.add(audiocodec)
# Setup metadata
vorbistag = gst.element_factory_make("vorbistag", "vorbistag")
# set tag merge mode to GST_TAG_MERGE_REPLACE
merge_mode = gst.TagMergeMode.__enum_values__[2]
if metadata is not None:
# Only set tag if metadata is set
vorbistag.merge_tags(self.tags, merge_mode)
vorbistag.set_tag_merge_mode(merge_mode)
bin.add(vorbistag)
# Setup ghost pads
audiopad = audioqueue.get_pad("sink")
audio_ghostpad = gst.GhostPad("audiosink", audiopad)
bin.add_pad(audio_ghostpad)
# Link elements
audioqueue.link(audioconvert)
audioconvert.link(audiocodec)
audiocodec.link(vorbistag)
vorbistag.link(muxer)
#
# Setup Video Pipeline
#
if video:
videoqueue = gst.element_factory_make("queue", "videoqueue")
bin.add(videoqueue)
videocodec = gst.element_factory_make("theoraenc", "videocodec")
videocodec.set_property("bitrate", self.config.video_bitrate)
bin.add(videocodec)
videopad = videoqueue.get_pad("sink")
video_ghostpad = gst.GhostPad("videosink", videopad)
bin.add_pad(video_ghostpad)
videoqueue.link(videocodec)
videocodec.link(muxer)
#
# Link muxer to icecast
#
muxer.link(icecast)
return bin
def __init__(self, filename=None, bands=4096):
gst.Pipeline.__init__(self)
# filesrc
self.filesrc = gst.element_factory_make("filesrc")
self.add(self.filesrc)
# decodebin
decodebin = gst.element_factory_make("decodebin")
decodebin.connect("new-decoded-pad", self.on_decoded_pad)
self.add(decodebin)
self.filesrc.link(decodebin)
# audioconvert
self.convert = gst.element_factory_make("audioconvert")
self.add(self.convert)
# scaletempo
scaletempo = gst.element_factory_make("scaletempo")
self.add(scaletempo)
self.convert.link(scaletempo)
# spectrum
self.spectrum = gst.element_factory_make("spectrum", "spectrum")
self.add(self.spectrum)
scaletempo.link(self.spectrum)
# insert equalizer
a = gst.element_factory_make("audiorate")
self.add(a)
self.spectrum.link(a)
r = gst.element_factory_make("audioresample")
self.add(r)
a.link(r)
c = gst.element_factory_make("audioconvert")
self.add(c)
r.link(c)
fft = gst.element_factory_make("fft")
self.add(fft)
c.link(fft)
self.eq = gst.element_factory_make("spectrum_equalizer")
self.add(self.eq)
fft.link(self.eq)
ifft = gst.element_factory_make("ifft")
self.add(ifft)
self.eq.link(ifft)
c = gst.element_factory_make("audioconvert")
self.add(c)
ifft.link(c)
# sink
sink = gst.element_factory_make("gconfaudiosink")
self.add(sink)
c.link(sink)
# set properties
self.set_bands(bands)
if not filename == None: self.set_file(filename)
bus = self.get_bus()
bus.add_signal_watch()
def __init__(self, enableVideo=False):
self.player = gst.element_factory_make("playbin2", "player")
fakesink = gst.element_factory_make("fakesink", "fakesink")
if not enableVideo:
print('No Video')
self.player.set_property("video-sink", fakesink)
DEST_HOST = '127.0.0.1'
AUDIO_SRC = 'audiotestsrc'
AUDIO_ENC = 'alawenc'
AUDIO_PAY = 'rtppcmapay'
RTP_SEND_PORT = 5002
RTCP_SEND_PORT = 5003
RTCP_RECV_PORT = 5007
# the pipeline to hold everything
pipeline = gst.Pipeline('rtp_server')
# the pipeline to hold everything
audiosrc = gst.element_factory_make(AUDIO_SRC, 'audiosrc')
audioconv = gst.element_factory_make('audioconvert', 'audioconv')
audiores = gst.element_factory_make('audioresample', 'audiores')
# the pipeline to hold everything
audioenc = gst.element_factory_make(AUDIO_ENC, 'audioenc')
audiopay = gst.element_factory_make(AUDIO_PAY, 'audiopay')
# add capture and payloading to the pipeline and link
pipeline.add(audiosrc, audioconv, audiores, audioenc, audiopay)
res = gst.element_link_many(audiosrc, audioconv, audiores, audioenc, audiopay)
# the rtpbin element
rtpbin = gst.element_factory_make('gstrtpbin', 'rtpbin')
def makeAudioBin(self):
alsa = gst.element_factory_make("alsasink")
alsa.set_property("device", "hw:%d,%d" % (self._card, self._device))
return alsa
if t == gst.MESSAGE_EOS:
print("End-of-stream")
loop.quit()
elif t == gst.MESSAGE_ERROR:
err, debug = message.parse_error()
print("Error: %s: %s" % (err, debug))
loop.quit()
return True
if len(sys.argv) != 2:
print "Usage: %s <URI>" % sys.argv[0]
sys.exit(1)
dest = sys.argv[1]
src = gst.element_factory_make("videotestsrc")
# src = gst.element_factory_make("v4l2src")
src_caps = gst.caps_from_string("video/x-raw-yuv,width=704,height=480")
rate = gst.element_factory_make("videorate")
rate_caps = gst.caps_from_string("video/x-raw-yuv,framerate=30000/1001")
overlay = gst.element_factory_make("timeoverlay")
overlay.set_property('shaded-background', True)
overlay.set_property('halignment', 'right')
# overlay.set_property('valignment', 'bottom')
encoder = gst.element_factory_make("x264enc")
encoder.set_property('bitrate', 256)
encoder.set_property('byte-stream', True)
mycname = "".join((pwd.getpwuid(os.getuid())[0],
"-" ,
str(os.getpid()),
"@",
socket.gethostname()))
gladefile = os.path.join(os.path.dirname(__file__),"rural.glade")
RUNNING_STATUS = False
def make_video_sink(pipeline, xid, name, async=True):
"Make a bin with a video sink in it, that will be displayed on xid."
bin = gst.Bin("videosink_%d" % xid)
sink = gst.element_factory_make("xvimagesink", name)
sink.set_property("sync", async)
sink.set_property("async", async)
bin.add(sink)
colorspace = gst.element_factory_make("ffmpegcolorspace")
bin.add(colorspace)
videoscale = gst.element_factory_make("videoscale")
bin.add(videoscale)
videoscale.link(colorspace)
colorspace.link(sink)
bin.add_pad(gst.GhostPad("sink", videoscale.get_pad("sink")))
sink.set_data("xid", xid)
return bin
class FsUIPipeline:
"Object to wrap the GstPipeline"
