def constructPipeline(self): self.pipeline = gst.Pipeline() self.filesrc = gst.element_factory_make("gnlfilesource") # Set properties of filesrc element # Note: the gnlfilesource signal will be connected # in self.connect_signals() self.filesrc.set_property("uri", "file:///" + self.inFileLocation) self.filesrc.set_property("media-start", self.media_start_time*gst.SECOND) self.filesrc.set_property("media-duration", self.media_duration*gst.SECOND) self.audioconvert = gst.element_factory_make("audioconvert") self.encoder = gst.element_factory_make("lame", "mp3_encoder") self.filesink = gst.element_factory_make("filesink") self.filesink.set_property("location", self.outFileLocation) #Add elements to the pipeline self.pipeline.add(self.filesrc, self.audioconvert, self.encoder, self.filesink) # Link elements gst.element_link_many(self.audioconvert,self.encoder, self.filesink)
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 __init__(self, client): self.client = client pipeline = gst.element_factory_make("pipeline", "player") filesrc = gst.element_factory_make("filesrc", "player.filesrc") decodebin = gst.element_factory_make("decodebin", "player.decodebin") audioconvert = gst.element_factory_make("audioconvert", "player.audioconvert") try: sink = gst.element_factory_make("pulsesink", "player.pulsesink") except: sink = gst.element_factory_make("osxaudiosink", "player.osxaudiosink") decodebin.connect("new-decoded-pad", lambda bin, pad, islast, sink: pad.link(sink), audioconvert.get_pad("sink")) pipeline.add(filesrc, decodebin, audioconvert, sink) gst.element_link_many(filesrc, decodebin) gst.element_link_many(audioconvert, sink) bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message::eos", self.player_eos_cb) bus.connect("message::error", self.player_eos_cb) bus.connect("message::state-changed", self.player_state_changed_cb) self.pipeline = pipeline self.is_playable = False self.is_playing = False self.playback_tracker_id = 0
def _add_audiosink(self, audio_sink, buffer_position): '''Sets up the new audiosink and syncs it''' self.add(audio_sink) audio_sink.sync_state_with_parent() gst.element_link_many(self._elements[-1], audio_sink) if buffer_position is not None: # buffer position is the output from get_position. If set, we # seek to that position. # TODO: this actually seems to skip ahead a tiny bit. why? # Note! this is super important in paused mode too, because when # we switch the sinks around the new sink never goes into # the paused state because there's no buffer. This forces # a resync of the buffer, so things still work. seek_event = gst.event_new_seek(1.0, gst.FORMAT_DEFAULT, gst.SEEK_FLAG_FLUSH, gst.SEEK_TYPE_SET, buffer_position[0], gst.SEEK_TYPE_NONE, 0) self.send_event(seek_event) self.audio_sink = audio_sink
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 _addCommonAudioElements(self, audio_bin, output_stream): self.debug("Adding volume element") # add a volume element audio_bin.aconv = gst.element_factory_make("audioconvert", "internal-aconv") audio_bin.ares = gst.element_factory_make("audioresample", "internal-audioresample") # Fix audio jitter of up to 40ms audio_bin.arate = gst.element_factory_make("audiorate", "internal-audiorate") audio_bin.arate.props.tolerance = 40 * gst.MSECOND audio_bin.volume = gst.element_factory_make("volume", "internal-volume") audio_bin.add(audio_bin.volume, audio_bin.ares, audio_bin.aconv, audio_bin.arate) #if child_bin: # gst.element_link_many(audio_bin.aconv, audio_bin.ares, audio_bin.arate, audio_bin.child, audio_bin.volume) # audio_bin.child.sync_state_with_parent() #else: gst.element_link_many(audio_bin.aconv, audio_bin.ares, audio_bin.arate, audio_bin.volume) audio_bin.aconv.sync_state_with_parent() audio_bin.ares.sync_state_with_parent() audio_bin.arate.sync_state_with_parent() audio_bin.volume.sync_state_with_parent()
def _init_video_sink(self): self.bin = gst.Bin() videoscale = gst.element_factory_make('videoscale') self.bin.add(videoscale) pad = videoscale.get_pad('sink') ghostpad = gst.GhostPad('sink', pad) self.bin.add_pad(ghostpad) videoscale.set_property('method', 0) caps_string = 'video/x-raw-yuv, ' r = self.videowidget.get_allocation() if r.width > 500 and r.height > 500: # Sigh... xvimagesink on the XOs will scale the video to fit # but ximagesink in Xephyr does not. So we live with unscaled # video in Xephyr so that the XO can work right. w = 480 h = float(w) / float(float(r.width) / float(r.height)) caps_string += 'width=%d, height=%d' % (w, h) else: caps_string += 'width=480, height=360' caps = gst.Caps(caps_string) self.filter = gst.element_factory_make('capsfilter', 'filter') self.bin.add(self.filter) self.filter.set_property('caps', caps) conv = gst.element_factory_make('ffmpegcolorspace', 'conv') self.bin.add(conv) videosink = gst.element_factory_make('autovideosink') self.bin.add(videosink) gst.element_link_many(videoscale, self.filter, conv, videosink) self.player.set_property('video-sink', self.bin)
def constructPipeline(self): """ Build the GStreamer pipeline, add and link various GStreamer elements. """ self.pipeline = gst.Pipeline() self.fakesink = gst.element_factory_make("fakesink") filesrc = gst.element_factory_make("filesrc") filesrc.set_property("location", self.inFileLocation) autoaudiosink = gst.element_factory_make("autoaudiosink") self.decodebin = gst.element_factory_make("decodebin") self.audioconvert = gst.element_factory_make("audioconvert") self.encoder = gst.element_factory_make("lame", "mp3_encoder") self.filesink = gst.element_factory_make("filesink") self.filesink.set_property("location", self.outFileLocation) self.pipeline.add(filesrc, self.decodebin, self.audioconvert, self.encoder, self.fakesink) gst.element_link_many(filesrc, self.decodebin) gst.element_link_many(self.audioconvert, self.encoder, self.fakesink)
def extractAudio(self): """ Extract a piece of audio from the input audio. @see: self.run() which calls this method. """ if not self.seek_done: time.sleep(0.1) self.duration = (self.pipeline.query_duration( gst.FORMAT_TIME, None)[0]) self.duration = self.duration / gst.SECOND if self.start_time > self.duration: print( "\n start time specified" " is more than the total audio duration" " resetting the start time to 0 sec") self.start_time = 0.0 self.pipeline.seek_simple(gst.FORMAT_TIME, gst.SEEK_FLAG_FLUSH, self.start_time * gst.SECOND) self.pipeline.set_state(gst.STATE_PAUSED) self.seek_done = True self.pipeline.remove(self.fakesink) self.pipeline.add(self.filesink) gst.element_link_many(self.encoder, self.filesink) self.pipeline.set_state(gst.STATE_PLAYING) time.sleep(0.1) try: self.position = self.pipeline.query_position( gst.FORMAT_TIME, None)[0] self.position = self.position / gst.SECOND except gst.QueryError: # The pipeline has probably reached # the end of the audio, (and thus has 'reset' itself.) if self.duration is None: self.error_msg = ("\n Error cutting the audio file." " Unable to determine the audio duration.") self.pipeline.set_state(gst.STATE_NULL) self.is_playing = False if (self.position <= self.duration and self.position > (self.duration - 10)): # Position close to the end of file. # Do nothing to avoid a possible traceback. #The audio cutting should work pass else: self.error_msg = " Error cutting the audio file" self.pipeline.set_state(gst.STATE_NULL) self.is_playing = False if not self.end_time is None: if self.position >= self.end_time: self.pipeline.set_state(gst.STATE_NULL) self.is_playing = False if self.verbose_mode: print "\n Current play time: =", self.position
def on_realize(self, widget, data=None): # xid must be retrieved first in GUI-thread and before creating pipeline to prevent racing conditions self.movie_xid = self.movie_window.window.xid # The pipeline self.player = gst.Pipeline() # Create bus and connect several handlers 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.audio_composition = gst.element_factory_make( "gnlcomposition", "audio-composition") self.video_composition = gst.element_factory_make( "gnlcomposition", "video-composition") # Create sinks self.audiosink = gst.element_factory_make('autoaudiosink') self.videosink = gst.element_factory_make('autovideosink') # pipeline elements self.audioconvert = gst.element_factory_make('audioconvert') self.audioresample = gst.element_factory_make('audioresample') self.videoscale = gst.element_factory_make('videoscale') self.ffmpegcolorspace = gst.element_factory_make('ffmpegcolorspace') # Connect handler for 'pad-added' signal def on_pad_added(element, pad, sink_pad): caps = pad.get_caps() name = caps[0].get_name() if name == 'video/x-raw-rgb': if not sink_pad.is_linked(): # Only link once pad.link(sink_pad) elif 'audio/x-raw-float' or name == 'audio/x-raw-int': if not sink_pad.is_linked(): # Only link once pad.link(sink_pad) self.key_seek = KeySeekElement.KeySeekElement() self.audio_composition.connect('pad-added', on_pad_added, self.key_seek.get_pad('keyseek-sink')) self.video_composition.connect('pad-added', on_pad_added, self.key_seek.get_pad('secondary-sink')) # Add elements to pipeline self.player.add(self.audio_composition, self.audioconvert, self.audioresample, self.audiosink, self.video_composition, self.key_seek, self.ffmpegcolorspace, self.videoscale, self.videosink) self.key_seek.get_pad('secondary-src').link( self.ffmpegcolorspace.get_pad('sink')) gst.element_link_many(self.ffmpegcolorspace, self.videoscale, self.videosink) self.key_seek.get_pad('keyseek-src').link( self.audioconvert.get_pad('sink')) gst.element_link_many(self.audioconvert, self.audioresample, self.audiosink)
def setupFadeBin(self): """ Creates a GStreamer bin element and adds elements necessary for fade out effect implementation Also creates and adds ghost pads. @see: self.addFadingEffect() """ self.audioconvert = gst.element_factory_make("audioconvert") self.volume = gst.element_factory_make("volume") self.audioconvert2 = gst.element_factory_make("audioconvert") self.fadeBin = gst.element_factory_make("bin", "fadeBin") self.fadeBin.add(self.audioconvert, self.volume, self.audioconvert2) gst.element_link_many(self.audioconvert, self.volume, self.audioconvert2) #Create Ghost pads for fadeBin sinkPad = self.audioconvert.get_pad("sink") self.fadeBinSink = gst.GhostPad("sink", sinkPad) self.fadeBinSrc = gst.GhostPad("src", self.audioconvert2.get_pad("src")) self.fadeBin.add_pad(self.fadeBinSink) self.fadeBin.add_pad(self.fadeBinSrc)
def start(self, input_dir, output_file): ''' Process the input files and output the video file ''' self.normalize_images(input_dir) no_files = len(glob.glob(os.path.join(input_dir, '*.jpg'))) if self.verbose: logging.debug('Number of files to encode as video: %s', no_files) pipeline = gst.Pipeline("pipeline") source = self.get_element("multifilesrc") source_location = os.path.join(input_dir, "%04d.jpg") if self.verbose: logging.debug("Source location: %s", source_location) source.set_property('location', source_location) source.set_property('index', 1) source_caps = gst.Caps() source_caps.append('image/jpeg,framerate=(fraction)4/1') source.set_property('caps', source_caps) decoder = self.get_element("jpegdec") # Attempt to auto detect the chosen encoder/mux based on output_file encoder = None container = None for container_name in self.CONTAINER_ENCODER_MAPPING: if output_file.endswith('.%s' % container_name): enc_name = self.CONTAINER_ENCODER_MAPPING[container_name] enc_name_gst = self.ENCODER_MAPPING[enc_name] encoder = self.get_element(enc_name_gst) cont_name_gst = self.CONTAINER_MAPPING[container_name] container = self.get_element(cont_name_gst) # If auto detection fails, choose from the list of preferred codec/mux if encoder is None: encoder = self.get_element(self.get_encoder_name()) if container is None: container = self.get_element(self.get_container_name()) output = self.get_element("filesink") output.set_property('location', output_file) pipeline.add_many(source, decoder, encoder, container, output) gst.element_link_many(source, decoder, encoder, container, output) pipeline.set_state(gst.STATE_PLAYING) while True: if source.get_property('index') <= no_files: if self.verbose: logging.debug("Currently processing image number: %s", source.get_property('index')) time.sleep(1) else: break time.sleep(3) pipeline.set_state(gst.STATE_NULL)
def encode(self): import pygst pygst.require('0.10') import gst self.encoder = gst.Pipeline('encoder') decodebin = gst.element_factory_make('uridecodebin', 'uridecodebin') uri = yield self.song.get_uri() decodebin.set_property('uri', uri) decodebin.connect('pad-added', self.on_new_pad) audioconvert = gst.element_factory_make('audioconvert', 'audioconvert') lame = gst.element_factory_make('lamemp3enc', 'lame') lame.set_property('quality', 1) sink = gst.element_factory_make('appsink', 'appsink') sink.set_property('emit-signals', True) sink.connect('new-buffer', self.data_ready) self.encoder.add(decodebin, audioconvert, lame, sink) gst.element_link_many(audioconvert, lame, sink) self.encoder.set_state(gst.STATE_PAUSED) bus = self.encoder.get_bus() bus.add_signal_watch() bus.connect('message', self.on_message) result = yield self.done defer.returnValue(result)
def __init__(self, type): Encoder.__init__(self, type) print "dv" ffmux = gst.element_factory_make("ffmux_dv", "ffmux") self.add(ffmux) if type & INPUT_TYPE_AUDIO: audioconvert = gst.element_factory_make( "audioconvert", "audioconvert" ) self.add(audioconvert) queue_audio = gst.element_factory_make( "queue", "queue_audio_enc" ) self.add(queue_audio) gst.element_link_many( audioconvert, queue_audio, ffmux ) self.audio_pad.set_target(audioconvert.sink_pads().next()) if type & INPUT_TYPE_VIDEO: dvenc = gst.element_factory_make("ffenc_dvvideo", "dvenc") self.add(dvenc) queue_video = gst.element_factory_make( "queue", "queue_video_enc" ) self.add(queue_video) gst.element_link_many(dvenc, queue_video, ffmux) self.video_pad.set_target(dvenc.sink_pads().next()) self.source_pad.set_target(ffmux.src_pads().next())
def __init__ (self, p, uri, uri2, vol = 1.0): gst.Bin.__init__(self) self.uri2 = uri2 # bus = p.get_bus() # bus.add_signal_watch() # bus.connect("message", self.get_message) self.gnomevfssrc = gst.element_factory_make("gnomevfssrc") if checkURL(uri): self.gnomevfssrc.set_property("location", uri) else: self.gnomevfssrc.set_property("location", uri2) mad = gst.element_factory_make("mad") audioconvert = gst.element_factory_make("audioconvert") audioresample = gst.element_factory_make("audioresample") self.current_vol = vol self.target_vol = vol self.volume = gst.element_factory_make("volume") self.volume.set_property("volume", self.current_vol) self.add(self.gnomevfssrc, mad, audioconvert, audioresample, self.volume) gst.element_link_many(self.gnomevfssrc, mad, audioconvert, audioresample, self.volume) pad = self.volume.get_pad("src") ghostpad = gst.GhostPad("src", pad) self.add_pad(ghostpad)
def __init__(self): self.player = gst.element_factory_make("playbin", "player") fakesink = gst.element_factory_make('fakesink', "my-fakesink") self.player.set_property("video-sink", fakesink) bus = self.player.get_bus() bus.add_signal_watch() bus.connect('message', self.on_message) self.player = gst.Pipeline("player") source = gst.element_factory_make("filesrc", "file-source") self.player.add(source) demuxer = gst.element_factory_make("oggdemux", "demuxer") self.player.add(demuxer) demuxer.connect("pad-added", self.demuxer_callback) self.audio_decoder = gst.element_factory_make("vorbisdec", "vorbis-decoder") self.player.add(self.audio_decoder) audioconv = gst.element_factory_make("audioconvert", "converter") self.player.add(audioconv) audiosink = gst.element_factory_make("autoaudiosink", "audio-output") self.player.add(audiosink) gst.element_link_many(source, demuxer) gst.element_link_many(self.audio_decoder, audioconv, audiosink) bus = self.player.get_bus() bus.add_signal_watch() bus.connect("message", self.on_message)
def __init__(self, message_callback, sync_message_callback): self.player = gst.element_factory_make("playbin2", "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) timeoverlay = gst.element_factory_make("timeoverlay") colorspace = gst.element_factory_make('ffmpegcolorspace', 'color_pis') custom = CustomElement() autovideosink = gst.element_factory_make("autovideosink") my_bin = gst.Bin("my-bin") my_bin.add(timeoverlay, colorspace, custom, autovideosink) gst.element_link_many(timeoverlay, colorspace, custom, autovideosink) timeoverlay_video_sink_pad = timeoverlay.get_pad("video_sink") ghostpad_sink = gst.GhostPad("sink", timeoverlay_video_sink_pad) my_bin.add_pad(ghostpad_sink) # Because playbin2 is a pipeline, we set our bin as the video sink self.player.set_property("video-sink", my_bin) self.message_callback = message_callback self.sync_message_callback = sync_message_callback
def _makeBin(self, *args): b = gst.Bin() idt = gst.element_factory_make("identity", "single-segment") idt.props.single_segment = True idt.props.silent = True aconv = gst.element_factory_make("audioconvert", "aconv") ares = gst.element_factory_make("audioresample", "ares") arate = gst.element_factory_make("audiorate", "arate") b.add(idt, aconv, ares, arate) gst.element_link_many(idt, aconv, ares, arate) gsink = gst.GhostPad("sink", idt.get_pad("sink")) gsink.set_active(True) b.add_pad(gsink) # if we have an output stream specified, we add a capsfilter if len(self.output_streams): cfilter = gst.element_factory_make("capsfilter") cfilter.props.caps = self.output_streams[0].caps b.add(cfilter) arate.link(cfilter) gsrc = gst.GhostPad("src", cfilter.get_pad("src")) else: gsrc = gst.GhostPad("src", arate.get_pad("src")) gsrc.set_active(True) b.add_pad(gsrc) return b
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 _makeBin(self, *args): b = gst.Bin() idt = gst.element_factory_make("identity", "single-segment") idt.props.single_segment = True idt.props.silent = True csp = gst.element_factory_make("ffmpegcolorspace", "csp") vrate = gst.element_factory_make("videorate", "vrate") b.add(idt, csp, vrate) gst.element_link_many(idt, csp, vrate) gsink = gst.GhostPad("sink", idt.get_pad("sink")) gsink.set_active(True) b.add_pad(gsink) # if we have an output stream specified, we add a capsfilter vscale = SmartVideoScale() vscale.set_caps(self.output_streams[0].caps) b.add(vscale) vrate.link(vscale) self.debug("output_streams:%d", len(self.output_streams)) if len(self.output_streams) and self.output_streams[0].caps.is_fixed(): idt = gst.element_factory_make("capsfilter") idt.props.caps = self.output_streams[0].caps b.add(idt) vscale.link(idt) gsrc = gst.GhostPad("src", idt.get_pad("src")) else: gsrc = gst.GhostPad("src", vscale.get_pad("src")) gsrc.set_active(True) b.add_pad(gsrc) return b
def _makeBin(self, *args): b = gst.Bin() idt = gst.element_factory_make("identity", "single-segment") idt.props.single_segment = True aconv = gst.element_factory_make("audioconvert", "aconv") ares = gst.element_factory_make("audioresample", "ares") arate = gst.element_factory_make("audiorate", "arate") b.add(idt, aconv, ares, arate) gst.element_link_many(idt, aconv, ares, arate) gsink = gst.GhostPad("sink", idt.get_pad("sink")) gsink.set_active(True) b.add_pad(gsink) # if we have an output stream specified, we add a capsfilter if len(self.output_streams): cfilter = gst.element_factory_make("capsfilter") cfilter.props.caps = self.output_streams[0].caps b.add(cfilter) arate.link(cfilter) gsrc = gst.GhostPad("src", cfilter.get_pad("src")) else: gsrc = gst.GhostPad("src", arate.get_pad("src")) gsrc.set_active(True) b.add_pad(gsrc) return b
def add_videofile(self, filepath, alpha_value): src = gst.element_factory_make('filesrc') #src.set_property('location', '/home/hero/Videos/veejay/test.avi') #filepath = ('/home/hero/Videos/veejay/test.avi') src.props.location = args[0] decodebin = gst.element_factory_make('decodebin2') ffcol = gst.element_factory_make("ffmpegcolorspace") vscale = gst.element_factory_make('videoscale') alpha = gst.element_factory_make('alpha') alpha.props.alpha = alpha_value def pad_added(elem, pad, target): print "pad_added", pad, target if str(pad.get_caps()).startswith('video/'): elem.link(target) src.seek_simple(gst.FORMAT_TIME, gst.SEEK_FLAG_SEGMENT, 0) decodebin.connect('pad-added', pad_added, vscale) self.add(src, decodebin, ffcol, vscale, alpha) src.link(decodebin) gst.element_link_many(vscale, ffcol, alpha, self.mixer) return (src, alpha)
def __init__(self, player, pre_elems=[]): gst.Bin.__init__(self, name='mainbin-%s' % player._name) self.__player = player self._elements = pre_elems[:] self.pp = Postprocessing(player) self._elements.append(self.pp) self.tee = gst.element_factory_make("tee") self._elements.append(self.tee) #self.queue = gst.element_factory_make("queue") #self._elements.append(self.queue) self.add(*self._elements) gst.element_link_many(*self._elements) self.audio_sink = None self.__audio_sink_lock = threading.Lock() self.setup_audiosink() self.sinkpad = self._elements[0].get_static_pad("sink") self.add_pad(gst.GhostPad('sink', self.sinkpad)) self.sinkqueue = gst.element_factory_make("queue") self.sinkhandler = SinkHandler(player, 'playback_audio_sink') self.add(self.sinkhandler) self.add(self.sinkqueue) gst.element_link_many(self.tee, self.sinkqueue, self.sinkhandler)
def __init__(self): gobject.GObject.__init__(self) self.state = 0 self.player = gst.Pipeline("stream-player") self.filesrc = gst.element_factory_make("filesrc", "file-source") self.preroll_queue = gst.element_factory_make("queue", "preroll-queue") self.decoder = gst.element_factory_make("decodebin2", "decoder") self.decoder.connect("new-decoded-pad", self.onDynamicPad) self.convertor = gst.element_factory_make("audioconvert", "audioconvert") self.rgvolume = gst.element_factory_make("rgvolume", "rgvolume") self.audioresample = gst.element_factory_make("audioresample", "audioresample") self.queue = gst.element_factory_make("queue", "queue") self.volume = gst.element_factory_make("volume", "volume") self.sink = gst.element_factory_make("alsasink", "sink") self.player.add_many(self.filesrc, self.preroll_queue, self.decoder, self.convertor, self.rgvolume, self.audioresample, self.queue, self.volume, self.sink) gst.element_link_many(self.filesrc, self.preroll_queue, self.decoder) gst.element_link_many(self.convertor, self.rgvolume, self.audioresample, self.queue, self.volume) self.ghost_src_pad = gst.GhostPad("src", self.volume.get_pad("src"))
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 _set_audio_encoder(self): ''' Sets the audio encoder pipeline ''' audioenc_queue = gst.element_factory_make('queue', 'audioenc_queue') audioenc_convert = gst.element_factory_make('audioconvert', 'audioenc_convert') audioenc_level = gst.element_factory_make('level', 'audioenc_level') audioenc_level.set_property('interval', 20000000) audioenc_codec = gst.element_factory_make(self.recording_audio_codec, 'audioenc_codec') # create a VorbisTag element and merge tags from tag list audioenc_tags = gst.element_factory_make("vorbistag", "audioenc_tags") # set tag merge mode to GST_TAG_MERGE_REPLACE merge_mode = gst.TagMergeMode.__enum_values__[2] audioenc_tags.merge_tags(self.tags, merge_mode) audioenc_tags.set_tag_merge_mode(merge_mode) self.player.add(audioenc_queue, audioenc_convert, audioenc_level, audioenc_codec, audioenc_tags) gst.element_link_many(self.audio_tee, audioenc_queue, audioenc_convert, audioenc_level, audioenc_codec, audioenc_tags, self.mux)
def constructPipeline(self): if self.use_parse_launch: myPipelineString = ( "filesrc location=C:/AudioFiles/my_music.mp3 " "! decodebin ! audioconvert ! autoaudiosink") self.player = gst.parse_launch(myPipelineString) else: # Create the pipeline instance self.player = gst.Pipeline() # Define pipeline elements self.filesrc = gst.element_factory_make("filesrc") self.filesrc.set_property("location", "C:/AudioFiles/my_music.mp3") # Note: the decodebin signal is connected in self.connect_signals() self.decodebin = gst.element_factory_make("decodebin","decodebin") self.audioconvert = gst.element_factory_make("audioconvert", "audioconvert") self.audiosink = gst.element_factory_make("autoaudiosink", "a_a_sink") # Add elements to the pipeline self.player.add(self.filesrc, self.decodebin, self.audioconvert, self.audiosink) # Link elements in the pipeline. gst.element_link_many(self.filesrc, self.decodebin) gst.element_link_many(self.audioconvert, self.audiosink)
def __init__(self, sink): gst.Pipeline.__init__(self) try: self.playbin = gst.element_factory_make("playbin2") except gst.ElementNotFoundError: self.playbin = gst.element_factory_make("playbin") self.add(self.playbin) bin = gst.Bin("speed-bin") try: self.speedchanger = gst.element_factory_make("pitch") except gst.ElementNotFoundError: mygtk.show_error( _(u"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 = sink bin.add(self.audiosink) convert = gst.element_factory_make("audioconvert") bin.add(convert) gst.element_link_many(self.speedchanger, convert) gst.element_link_many(convert, self.audiosink) sink_pad = gst.GhostPad("sink", self.speedchanger.get_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 _restartSourceBin(self): self._successiveUnderruns += 1 if self._successiveUnderruns > 3: self._debugger.ddebug("Too many underruns.") sys.exit(1) gst.element_unlink_many(self._sourceBin, self._sinkBin) self._sourceBin.set_state(gst.STATE_NULL) self._sinkBin.set_state(gst.STATE_READY) self._pipeline.remove(self._sourceBin) self._sourceBin = None self._debug( "Attempting to recover from video loss: Stopping source pipeline and waiting 5s..." ) time.sleep(5) self._debug("Restarting source pipeline...") self._sourceBin = self._createSourceBin() self._pipeline.add(self._sourceBin) gst.element_link_many(self._sourceBin, self._sinkBin) self._sourceBin.set_state(gst.STATE_PLAYING) self._sinkBin.set_state(gst.STATE_PLAYING) self._pipeline.set_state(gst.STATE_PLAYING) self._startTimestamp = None self._debug("Restarted source pipeline") self._underrunTimeout.start() # stop the timeout from running again return False
def _set_video_encoder(self): videoenc_queue = gst.element_factory_make("queue", "videoenc_queue") videoenc_codec = gst.element_factory_make(self.recording_video_codec, "videoenc_codec") videoenc_codec.set_property("bitrate", self.recording_video_bitrate) self.player.add(videoenc_queue, videoenc_codec) gst.element_link_many(self.video_tee, videoenc_queue, videoenc_codec, self.mux)
def __init__(self): """ Used to play video received as a RTP Stream from the network """ self.pipeline = gst.Pipeline("mypipeline") udp=gst.element_factory_make("udpsrc", "udp-packet-receiver") self.pipeline.add(udp) self.pipeline.get_by_name("udp-packet-receiver").set_property("port", 5001) caps = gst.Caps("application/x-rtp, media=(string)audio, clock-rate=44100, width=16, height=16, encoding-name=(string)L16,encoding-params=(string)1, channels=(int)1, channel-position=(int)1, payload=(int)96") filter = gst.element_factory_make("capsfilter", "filter") filter.set_property("caps", caps) self.pipeline.add(filter) jitter=gst.element_factory_make("gstrtpjitterbuffer", "jitter") self.pipeline.add(jitter) self.pipeline.get_by_name("jitter").set_property("do-lost", "true") rtpaudiodepayloader=gst.element_factory_make("rtpL16depay", "rtpdeaudio") self.pipeline.add(rtpaudiodepayloader) conv = gst.element_factory_make("audioconvert", "converter") self.pipeline.add(conv) sink=gst.element_factory_make("alsasink", "Sink") self.pipeline.add(sink) self.pipeline.get_by_name("Sink").set_property("sync", "false") gst.element_link_many(udp, filter, jitter, rtpaudiodepayloader,conv, sink) self.pipeline.set_state(gst.STATE_PLAYING)
def _set_audio_encoder(self): """ Sets the audio encoder pipeline """ audioenc_queue = gst.element_factory_make("queue", "audioenc_queue") audioenc_convert = gst.element_factory_make("audioconvert", "audioenc_convert") audioenc_level = gst.element_factory_make("level", "audioenc_level") audioenc_level.set_property("interval", 20000000) audioenc_codec = gst.element_factory_make(self.recording_audio_codec, "audioenc_codec") # create a VorbisTag element and merge tags from tag list audioenc_tags = gst.element_factory_make("vorbistag", "audioenc_tags") # set tag merge mode to GST_TAG_MERGE_REPLACE merge_mode = gst.TagMergeMode.__enum_values__[2] audioenc_tags.merge_tags(self.tags, merge_mode) audioenc_tags.set_tag_merge_mode(merge_mode) self.player.add(audioenc_queue, audioenc_convert, audioenc_level, audioenc_codec, audioenc_tags) gst.element_link_many( self.audio_tee, audioenc_queue, audioenc_convert, audioenc_level, audioenc_codec, audioenc_tags, self.mux )
def convert(flacfile, mp3file): print "Converting %s... " % flacfile src = gst.element_factory_make("filesrc", "src") src.set_property("location", flacfile) src_pad = src.get_pad("src") flac = gst.element_factory_make("flacdec", "decoder") mp3 = gst.element_factory_make("lame", "encoder") mp3.set_property("bitrate", 192) mp3.set_property("quality", 2) sink = gst.element_factory_make("filesink", "sink") sink.set_property("location", mp3file) bin = gst.Pipeline() bin.add_many(src,flac,mp3,sink) gst.element_link_many(src,flac,mp3,sink) bin.connect("error", error_cb) bin.set_state(gst.STATE_PAUSED) res = bin.set_state(gst.STATE_PLAYING); while bin.iterate(): pass print "Done.\n"
def __init__(self): self.logger = logging.getLogger('tunes.player') self.logger.debug("Creating Player") self.pipeline = gst.Pipeline("pipeline") self.volume = 50 self.mf = None source = gst.element_factory_make("filesrc", "filesrc") decoder = gst.element_factory_make("decodebin", "decodebin") conv = gst.element_factory_make("audioconvert", "audioconvert") pitch = gst.element_factory_make("pitch", "pitch") volume = gst.element_factory_make("volume", "volume") resample = gst.element_factory_make("audioresample", "audioresample") sink = gst.element_factory_make("autoaudiosink", "autoaudiosink") self.pipeline.add(source, decoder, conv, volume, pitch, resample, sink) gst.element_link_many(source, decoder); gst.element_link_many(conv, pitch, volume, resample, sink) decoder.connect("new-decoded-pad", self.on_new_decoded_pad) self.pipeline.set_state(gst.STATE_PAUSED) self.bus = self.pipeline.get_bus() self.bus.add_signal_watch() self.bus.connect("message", self.on_message) self.logger.debug("Player created")
def _create_videobin(self): queue = gst.element_factory_make("queue", "videoqueue") queue.set_property("max-size-time", 5000000000) # 5 seconds queue.set_property("max-size-bytes", 33554432) # 32mb queue.connect("overrun", self._log_queue_overrun) scale = gst.element_factory_make("videoscale", "vbscale") scalecapsfilter = gst.element_factory_make("capsfilter", "scalecaps") scalecaps = gst.Caps('video/x-raw-yuv,width=160,height=120') scalecapsfilter.set_property("caps", scalecaps) colorspace = gst.element_factory_make("ffmpegcolorspace", "vbcolorspace") enc = gst.element_factory_make("theoraenc", "vbenc") enc.set_property("quality", 16) mux = gst.element_factory_make("oggmux", "vbmux") sink = gst.element_factory_make("filesink", "vbfile") sink.set_property("location", os.path.join(Instance.instancePath, "output.ogg")) self._videobin = gst.Bin("videobin") self._videobin.add(queue, scale, scalecapsfilter, colorspace, enc, mux, sink) queue.link(scale) scale.link_pads(None, scalecapsfilter, "sink") scalecapsfilter.link_pads("src", colorspace, None) gst.element_link_many(colorspace, enc, mux, sink) pad = queue.get_static_pad("sink") self._videobin.add_pad(gst.GhostPad("sink", pad))
def __init__(self): self.player = gst.Pipeline() self.playbin = gst.element_factory_make("playbin2", "player") # Disable the subtitle display if there is embeded subtitles # (for example, in mkv files) # # Flags activates some things # (1 << 0) : video # (1 << 1) : audio # (1 << 4) : software volume # # The default value is 0, 1, 2, 4. (1 << 2) display the subtitles # # For more details, see the doc # http://www.gstreamer.net/data/doc/gstreamer/head/gst-plugins-base-plugins/html/gst-plugins-base-plugins-playbin2.html#GstPlayFlags # http://www.gstreamer.net/data/doc/gstreamer/head/gst-plugins-base-plugins/html/gst-plugins-base-plugins-playbin2.html#GstPlayBin2--flags self.playbin.set_property("flags", (1 << 0)|(1 << 1)|(1 << 4)) self.playbin.set_property("current-audio", 0) self.player.add(self.playbin) self.logger = logging.Logger("VideoPlayer") self.logger.setLevel(defaultLoggingLevel) self.logger.addHandler(defaultLoggingHandler) #Audio audiobin = gst.Bin("audio-speed-bin") try: self.audiospeedchanger = gst.element_factory_make("pitch") self.canChangeSpeed = True except gst.ElementNotFoundError: self.logger.warn(_(u"You need to install the gstreamer soundtouch elements to " "use slowly play feature.")) self.canChangeSpeed = False #Try to use the pitch element only if it is available if self.canChangeSpeed and config.get("interface_use_speed_change"): audiobin.add(self.audiospeedchanger) self.audiosink = gst.element_factory_make("autoaudiosink") audiobin.add(self.audiosink) convert = gst.element_factory_make("audioconvert") audiobin.add(convert) gst.element_link_many(self.audiospeedchanger, convert, self.audiosink) sink_pad = gst.GhostPad("sink", self.audiospeedchanger.get_pad("sink")) audiobin.add_pad(sink_pad) self.playbin.set_property("audio-sink", audiobin) 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.time_format = gst.Format(gst.FORMAT_TIME) self.timeToSeek = -1 self.speed = 1.0 self.nextCallbackTime = -1
def __init__(self): """ This constructor builds the gstreamer pipeline that receives an RTP stream from the server and dumps it to my customized media player """ self.pipeline = gst.Pipeline("mypipeline") udp=gst.element_factory_make("udpsrc", "udp-packet-receiver") self.pipeline.add(udp) self.pipeline.get_by_name("udp-packet-receiver").set_property("port", 5001) caps = gst.Caps("application/x-rtp, media=(string)audio, clock-rate=44100, width=16, height=16, encoding-name=(string)L16,encoding-params=(string)1, channels=(int)1, channel-position=(int)1, payload=(int)96") filter = gst.element_factory_make("capsfilter", "filter") filter.set_property("caps", caps) self.pipeline.add(filter) jitter=gst.element_factory_make("gstrtpjitterbuffer", "jitter") self.pipeline.add(jitter) self.pipeline.get_by_name("jitter").set_property("do-lost", "true") rtpaudiodepayloader=gst.element_factory_make("rtpL16depay", "rtpdeaudio") self.pipeline.add(rtpaudiodepayloader) conv = gst.element_factory_make("audioconvert", "converter") self.pipeline.add(conv) sink= gst.element_factory_make("filesink", "file-sink") self.pipeline.add(sink) uri="./temp.mp3" self.pipeline.get_by_name("file-sink").set_property("location", uri) gst.element_link_many(udp, filter, jitter, rtpaudiodepayloader,conv, sink) self.pipeline.set_state(gst.STATE_PLAYING)
def get_preview_backend(config, num_audio_tracks): backend = gst.Bin("backend") #audio_volume = gst.element_factory_make("volume","volume") video_caps = gst.element_factory_make("capsfilter") video_caps.props.caps = config.get_video_caps("I420", dict(border=0)) mqueue = gst.element_factory_make("multiqueue") mqueue.props.max_size_time = 10 * gst.SECOND mqueue.props.max_size_bytes = 0 mqueue.props.max_size_buffers = 0 video_sink = gst.element_factory_make("autovideosink") audio_sel = gst.element_factory_make("input-selector") audio_sink = gst.element_factory_make("autoaudiosink") backend.add(video_caps, mqueue, video_sink, audio_sel, audio_sink) gst.element_link_many(video_caps, mqueue, video_sink) gst.element_link_many(audio_sel, mqueue, audio_sink) audio_caps = [] for i in range(num_audio_tracks): caps = gst.element_factory_make("capsfilter") audio_caps.append(caps) caps.props.caps = config.get_audio_caps() backend.add(caps) caps.link(audio_sel) backend.add_pad(gst.GhostPad("video_sink", video_caps.get_pad("sink"))) for i, sink in enumerate(audio_caps): backend.add_pad( gst.GhostPad("audio_sink%d" % (i, ), sink.get_pad("sink"))) return backend
def __init__(self): gobject.GObject.__init__(self) self._rate = 1 self.pipeline = gst.Pipeline('pipeline_main') self.audiosrc = gst.element_factory_make('filesrc', 'audio') self.decoder = gst.element_factory_make('decodebin', 'decoder') self.convert1 = gst.element_factory_make('audioconvert', 'convert1') self.resample1 = gst.element_factory_make('audioresample', 'resample1') self.volume1 = gst.element_factory_make('volume', 'volume') self.volume1.set_property('volume', 1) self.scaletempo = gst.element_factory_make('scaletempo', 'scaletempo') self.convert2 = gst.element_factory_make('audioconvert', 'convert2') self.resample2 = gst.element_factory_make('audioresample', 'resample2') self.sink = gst.element_factory_make('autoaudiosink', 'sink') self.decoder.connect('new-decoded-pad', self.on_new_decoded_pad) self.pipeline.add(self.audiosrc, self.decoder, self.convert1, self.volume1, self.resample1, self.scaletempo, self.convert2, self.resample2, self.sink) self.audiosrc.link(self.decoder) gst.element_link_many(self.convert1, self.resample1, self.volume1, self.scaletempo, self.convert2, self.resample2, self.sink) self.apad = self.convert1.get_pad('sink') bus = self.pipeline.get_bus() bus.add_signal_watch() bus.connect('message', self.on_message)
def get_preview_backend(config, num_audio_tracks): backend = gst.Bin("backend") #audio_volume = gst.element_factory_make("volume","volume") video_caps = gst.element_factory_make("capsfilter") video_caps.props.caps = config.get_video_caps("I420", dict(border=0)) mqueue = gst.element_factory_make("multiqueue") mqueue.props.max_size_time = 10 * gst.SECOND mqueue.props.max_size_bytes = 0 mqueue.props.max_size_buffers = 0 video_sink = gst.element_factory_make("autovideosink") audio_sel = gst.element_factory_make("input-selector") audio_sink = gst.element_factory_make("autoaudiosink") backend.add(video_caps, mqueue, video_sink, audio_sel, audio_sink) gst.element_link_many(video_caps, mqueue, video_sink) gst.element_link_many(audio_sel, mqueue, audio_sink) audio_caps = [] for i in range(num_audio_tracks): caps = gst.element_factory_make("capsfilter") audio_caps.append(caps) caps.props.caps = config.get_audio_caps() backend.add(caps) caps.link(audio_sel) backend.add_pad(gst.GhostPad("video_sink", video_caps.get_pad("sink"))) for i,sink in enumerate(audio_caps): backend.add_pad(gst.GhostPad("audio_sink%d" % (i,), sink.get_pad("sink"))) return backend
def restart_source_bin(self): self.successive_underruns += 1 if self.successive_underruns > 3: sys.stderr.write("Error: Video loss. Too many underruns.\n") sys.exit(1) gst.element_unlink_many(self.source_bin, self.sink_bin) self.source_bin.set_state(gst.STATE_NULL) self.sink_bin.set_state(gst.STATE_READY) self.pipeline.remove(self.source_bin) self.source_bin = None debug("Attempting to recover from video loss: " "Stopping source pipeline and waiting 5s...") time.sleep(5) debug("Restarting source pipeline...") self.source_bin = self.create_source_bin() self.pipeline.add(self.source_bin) gst.element_link_many(self.source_bin, self.sink_bin) self.source_bin.set_state(gst.STATE_PLAYING) self.pipeline.set_state(gst.STATE_PLAYING) debug("Restarted source pipeline") self.underrun_timeout.start() return False # stop the timeout from running again
def __init__(self, sink): gst.Pipeline.__init__(self) self.playbin = gst.element_factory_make("playbin") self.add(self.playbin) bin = gst.Bin("speed-bin") self.speedchanger = gst.element_factory_make("pitch") bin.add(self.speedchanger) self.audiosink = sink bin.add(self.audiosink) convert = gst.element_factory_make("audioconvert") bin.add(convert) gst.element_link_many(self.speedchanger, convert) gst.element_link_many(convert, self.audiosink) sink_pad = gst.GhostPad("sink", self.speedchanger.get_pad("sink")) bin.add_pad(sink_pad) self.playbin.set_property("audio-sink", bin) bus = self.get_bus() bus.add_signal_watch() bus.connect("message", self.on_message) self.eos = lambda: None self.on_eos_cb = None self.on_error_cb = None self.encoder = pipeline_encoders['wav']
def _makeBin(self, *args): b = gst.Bin() idt = gst.element_factory_make("identity", "single-segment") idt.props.single_segment = True csp = gst.element_factory_make("ffmpegcolorspace", "csp") vrate = gst.element_factory_make("videorate", "vrate") b.add(idt, csp, vrate) gst.element_link_many(idt, csp, vrate) gsink = gst.GhostPad("sink", idt.get_pad("sink")) gsink.set_active(True) b.add_pad(gsink) # if we have an output stream specified, we add a capsfilter vscale = SmartVideoScale() vscale.set_caps(self.output_streams[0].caps) b.add(vscale) vrate.link(vscale) self.debug("output_streams:%d", len(self.output_streams)) if len(self.output_streams) and self.output_streams[0].caps.is_fixed(): idt = gst.element_factory_make("capsfilter") idt.props.caps = self.output_streams[0].caps b.add(idt) vscale.link(idt) gsrc = gst.GhostPad("src", idt.get_pad("src")) else: gsrc = gst.GhostPad("src", vscale.get_pad("src")) gsrc.set_active(True) b.add_pad(gsrc) return b
def _setup_finish(self, elem, blocked, state): for sink in self.added_sinks: queue = self.queuedict[sink.name] pad = queue.get_static_pad("sink").get_peer() if pad: self.tee.release_request_pad(pad) try: self.remove(queue) queue.set_state(gst.STATE_NULL) except gst.RemoveError: pass try: self.remove(sink) sink.set_state(gst.STATE_NULL) except gst.RemoveError: pass self.added_sinks = [] for name, sink in self.sinks.iteritems(): self.add(sink) queue = gst.element_factory_make("queue") self.add(queue) self.queuedict[sink.name] = queue gst.element_link_many(self.tee, queue, sink) self.added_sinks.append(sink) self.set_state(state) if blocked: self.sinkpad.set_blocked_async(False, lambda *args: False, state)
def main(args): if len(args) != 3: print 'Usage: %s input output' % (args[0]) return -1 bin = gst.Pipeline('pipeline') filesrc = FileSource('filesource') assert filesrc filesrc.set_property('location', args[1]) filesink = gst.element_factory_make('filesink', 'sink') filesink.set_property('location', args[2]) bin.add(filesrc, filesink) gst.element_link_many(filesrc, filesink) bin.set_state(gst.STATE_PLAYING); mainloop = gobject.MainLoop() def bus_event(bus, message): t = message.type if t == gst.MESSAGE_EOS: mainloop.quit() elif t == gst.MESSAGE_ERROR: err, debug = message.parse_error() print "Error: %s" % err, debug mainloop.quit() return True bin.get_bus().add_watch(bus_event) mainloop.run() bin.set_state(gst.STATE_NULL)
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 __init__(self, uri, start, duration, fadein, fadeout, volume): gst.Bin.__init__(self) self.start = start self.duration = duration self.clip_volume = volume self.already_seeked = False self.fading = False self.gnomevfssrc = gst.element_factory_make("gnomevfssrc") self.gnomevfssrc.set_property("location", uri) self.wavparse = gst.element_factory_make("wavparse") self.audioconvert = gst.element_factory_make("audioconvert") self.audioresample = gst.element_factory_make("audioresample") self.audiopanorama = gst.element_factory_make("audiopanorama") self.volume = gst.element_factory_make("volume") self.controller = gst.Controller(self.volume, "volume") self.controller.set_interpolation_mode( "volume", gst.INTERPOLATE_LINEAR) self.controller.set("volume", 0, 0.0) self.controller.set("volume", start, 0.0) self.controller.set("volume", start + fadein, volume) self.controller.set("volume", start + duration - fadeout, volume) self.controller.set("volume", start + duration, 0.0) self.add(self.gnomevfssrc, self.wavparse, self.audioconvert, self.audioresample, self.audiopanorama, self.volume) gst.element_link_many(self.gnomevfssrc, self.wavparse) gst.element_link_many(self.audioconvert, self.audioresample, self.audiopanorama, self.volume) def on_pad(comp, pad): convpad = self.audioconvert.get_compatible_pad(pad, pad.get_caps()) pad.link(convpad) self.wavparse.connect("pad-added", on_pad) self.pad = self.volume.get_pad("src") self.ghostpad = gst.GhostPad("src", self.pad) self.add_pad(self.ghostpad)
def __init__(self): settings = Gtk.Settings.get_default() settings.set_property("gtk-application-prefer-dark-theme", True) self.builder = Gtk.Builder() self.builder.add_from_file("lightbox.xml") self.builder.connect_signals(self) self.devices = self.builder.get_object("devices") self.device_combo = self.builder.get_object("device_combo") self.formats = self.builder.get_object("formats") self.udev_client = GUdev.Client.new(['video4linux']) self.player = gst.Pipeline(name='player') self.source = gst.element_factory_make('v4l2src', 'source') self.filter = gst.element_factory_make("capsfilter", "filter") self.flipper = gst.element_factory_make("videoflip", "flipper") sink = gst.element_factory_make('xvimagesink', 'sink') self.player.add(self.source) self.player.add(self.filter) self.player.add(self.flipper) self.player.add(sink) gst.element_link_many(self.source, self.filter, self.flipper, sink) bus = self.player.get_bus() bus.add_signal_watch() bus.connect("message", self._on_message) bus.enable_sync_message_emission() bus.connect("sync-message::element", self._on_sync_message) self._pop_dev_timeout = 0
def constructVideoPipeline(self): """ Define and links elements to build the video portion of the main pipeline. @see: self.constructPipeline() """ # Autoconvert element for video processing self.autoconvert = gst.element_factory_make("autoconvert") self.videosink = gst.element_factory_make("autovideosink") # Set the capsfilter videocap = gst.Caps("video/x-raw-yuv") self.capsFilter = gst.element_factory_make("capsfilter") self.capsFilter.set_property("caps", videocap) # Converts the video from one colorspace to another self.colorSpace = gst.element_factory_make("ffmpegcolorspace") self.videobalance = gst.element_factory_make("videobalance") self.videobalance.set_property("brightness", 0.5) self.videobalance.set_property("contrast", 0.5) self.videobalance.set_property("saturation", 0.0) self.queue1 = gst.element_factory_make("queue") self.player.add(self.queue1, self.autoconvert, self.videobalance, self.capsFilter, self.colorSpace, self.videosink) gst.element_link_many(self.queue1, self.autoconvert, self.videobalance, self.capsFilter, self.colorSpace, self.videosink)
def main(args): print 'This example is not finished yet.' return if len(args) != 3: print 'Usage: %s input output' % (args[0]) return -1 bin = gst.Pipeline('pipeline') filesrc = FileSource('filesource') #filesrc = gst.Element('filesrc', 'src') assert filesrc filesrc.set_property('location', args[1]) filesink = gst.element_factory_make('filesink', 'sink') filesink.set_property('location', args[2]) bin.add_many(filesrc, filesink) gst.element_link_many(filesrc, filesink) bin.set_state(gst.STATE_PLAYING); while bin.iterate(): pass bin.set_state(gst.STATE_NULL)
def __init__(self, type): Encoder.__init__(self, type) self.oggmux = gst.element_factory_make("oggmux", "oggmux") self.add(self.oggmux) self.theoraenc = None self.vorbisenc = None if type & INPUT_TYPE_AUDIO: audioconvert = gst.element_factory_make("audioconvert", "audioconvert") self.add(audioconvert) self.vorbisenc = gst.element_factory_make("vorbisenc", "vorbisenc") self.add(self.vorbisenc) queue_audio = gst.element_factory_make("queue", "queue_audio_enc") self.add(queue_audio) gst.element_link_many(audioconvert, self.vorbisenc, queue_audio, self.oggmux) self.audio_pad.set_target(audioconvert.sink_pads().next()) if type & INPUT_TYPE_VIDEO: self.theoraenc = gst.element_factory_make("theoraenc", "theoraenc") self.add(self.theoraenc) queue_video = gst.element_factory_make("queue", "queue_video_enc") self.add(queue_video) gst.element_link_many(self.theoraenc, queue_video, self.oggmux) self.video_pad.set_target(self.theoraenc.sink_pads().next()) self.source_pad.set_target(self.oggmux.src_pads().next())
def convert(flacfile, mp3file): print "Converting %s... " % flacfile src = gst.element_factory_make("filesrc", "src") src.set_property("location", flacfile) src_pad = src.get_pad("src") flac = gst.element_factory_make("flacdec", "decoder") mp3 = gst.element_factory_make("lame", "encoder") mp3.set_property("bitrate", 192) mp3.set_property("quality", 2) sink = gst.element_factory_make("filesink", "sink") sink.set_property("location", mp3file) bin = gst.Pipeline() bin.add_many(src, flac, mp3, sink) gst.element_link_many(src, flac, mp3, sink) bin.connect("error", error_cb) bin.set_state(gst.STATE_PAUSED) res = bin.set_state(gst.STATE_PLAYING) while bin.iterate(): pass print "Done.\n"