def __init__(self, inuri, outuri, vformat, vquality, aquality, fformat): gobject.GObject.__init__(self) self._infile = inuri self._outfile = outuri self._vformat = vformat if self._vformat == "THEORA": self._vquality = ocv_constants.THEORA_QUALITY_MAPPING[vquality] elif self._vformat == "SCHRO": self._vquality = ocv_constants.SCHRO_QUALITY_MAPPING[vquality] elif self._vformat == "VP8": self._vquality = ocv_constants.VP8_QUALITY_MAPPING[vquality] else: # We should never get here self._vquality = 0 self._aquality = ocv_constants.VORBIS_QUALITY_MAPPING[aquality] self._fformat = fformat self._pipeline = gst.Pipeline() #self._filesrc = gst.element_factory_make("filesrc") #self._filesrc.set_property("location", self._infile) self._filesrc = gst.element_make_from_uri(gst.URI_SRC, inuri) self._decodebin = gst.element_factory_make("decodebin") self._decodebin.connect("new-decoded-pad", self._on_new_pad) if fformat == "OGG": self._mux = gst.element_factory_make("oggmux") for key in ocv_constants.OGGMUX_OPTS: self._mux.set_property(key, ocv_constants.OGGMUX_OPTS[key]) else: self._mux = gst.element_factory_make("matroskamux") for key in ocv_constants.MATROSKAMUX_OPTS: self._mux.set_property(key, ocv_constants.MATROSKAMUX_OPTS[key]) self._progreport = gst.element_factory_make("progressreport") #self._filesink = gst.element_factory_make("filesink") #self._filesink.set_property("location", outfile) self._filesink = gst.element_make_from_uri(gst.URI_SINK, outuri) self._pipeline.add(self._filesrc, self._decodebin, self._mux, self._progreport, self._filesink) # Link up what we've got so far self._filesrc.link(self._decodebin) self._mux.link(self._progreport) self._progreport.link(self._filesink) # Connect up callbacks self.bus = self._pipeline.get_bus() self.bus.add_signal_watch() self.bus.connect("message::eos",self._on_end_of_stream) self.bus.connect("message::state-changed", self._on_state_changed)
def do_setup_pipeline(self): self.src = gst.element_make_from_uri(gst.URI_SRC, self.fromuri) self.remuxbin = RemuxBin(self.start_time, self.stop_time) self.sink = gst.element_make_from_uri(gst.URI_SINK, self.touri) self.resolution = UNKNOWN if gobject.signal_lookup('allow-overwrite', self.sink.__class__): self.sink.connect('allow-overwrite', lambda *x: True) self.add(self.src, self.remuxbin, self.sink) self.src.link(self.remuxbin) self.remuxbin.link(self.sink)
def start_track(self, track): (pending, state, timeout) = self.pipeline.get_state() logging.debug ("Start track %s", track.uri) if self.src: self.pipeline.remove(self.src) if self.pipeline.get_by_name("decodebin2") != None: self.pipeline.remove(self.decodebin) self.src = None for key in self.sources.keys(): if self.dogvibes.sources[key].uri_matches(track.uri): self.src = self.dogvibes.sources[key].get_src() self.dogvibes.sources[key].set_track(track) self.pipeline.add(self.src) self.src.link(self.tee) # Try decode bin if there where no match within the sources if self.src == None: logging.debug ("Decodebin is taking care of this uri") self.src = gst.element_make_from_uri(gst.URI_SRC, track.uri, "source") if self.src == None: logging.error("No suitable gstreamer element found for given uri") return False self.decodebin = gst.element_factory_make("decodebin2", "decodebin2") self.decodebin.connect('new-decoded-pad', self.pad_added) self.pipeline.add(self.src) self.pipeline.add(self.decodebin) self.src.link(self.decodebin) self.set_state(gst.STATE_PLAYING) return True
def __init__(self, caps=None, uri=None, stream=None, *args, **kwargs): gst.Bin.__init__(self, *args, **kwargs) if not caps: caps = gst.caps_new_any() self.caps = caps self.stream = stream self.typefind = gst.element_factory_make("typefind", "internal-typefind") self.add(self.typefind) self.uri = uri if self.uri and gst.uri_is_valid(self.uri): self.urisrc = gst.element_make_from_uri(gst.URI_SRC, uri, "urisrc") self.log("created urisrc %s / %r" % (self.urisrc.get_name(), self.urisrc)) self.add(self.urisrc) self.urisrc.link(self.typefind) else: self._sinkpad = gst.GhostPad("sink", self.typefind.get_pad("sink")) self._sinkpad.set_active(True) self.add_pad(self._sinkpad) self.typefind.connect("have_type", self._typefindHaveTypeCb) self._srcpad = None self._dynamics = [] self._validelements = [] #added elements self._factories = self._getSortedFactoryList()
def play_only_if_null(self, track): (pending, state, timeout) = self.pipeline.get_state() if state != gst.STATE_NULL: self.set_state(gst.STATE_PLAYING) if self.src: self.pipeline.remove(self.src) if self.pipeline.get_by_name("decodebin2") != None: self.pipeline.remove(self.decodebin) self.src = None for source in self.sources: if source.uri_matches(track.uri): self.src = source.get_src() source.set_track(track) self.pipeline.add(self.src) self.src.link(self.tee) # Try decode bin if there where no match within the sources if self.src == None: logging.debug ("Decodebin is taking care of this uri") self.src = gst.element_make_from_uri(gst.URI_SRC, track.uri, "source") self.decodebin = gst.element_factory_make("decodebin2", "decodebin2") self.decodebin.connect('new-decoded-pad', self.pad_added) self.pipeline.add(self.src) self.pipeline.add(self.decodebin) self.src.link(self.decodebin) self.set_state(gst.STATE_PLAYING)
def _setup_pipeline(self, fpath): fpathnz = fpath.replace(' ', '_') gst.debug('_setup_pipeline: %r' % (fpath,)) self.ppl = gst.Pipeline('D-%s' % fpathnz) src = gst.element_make_from_uri(gst.URI_SRC, fpath, 'src-%s' % fpathnz) if not src: gst.warning('No element to access: %r' % fpath) self._finish(AnalysisError('No element to access the URI.')) return False dbin = gst.element_factory_make('decodebin2', 'dbin') self._connect(dbin, 'new-decoded-pad', self._cb_new_decoded_pad) self._connect(dbin, 'no-more-pads', self._cb_no_more_pads) self._connect(dbin, 'unknown-type', self._cb_unknown_type) tfind = dbin.get_by_name('typefind') self._connect(tfind, 'have-type', self._cb_have_type) self._connect(tfind.get_pad('src'), 'notify::caps', self._cb_notify_caps_tfind) self.ppl.add(src, dbin) src.link(dbin) gst.debug('pipeline created') self.bus = self.ppl.get_bus() self._connect(self.bus, 'message', self._cb_bus_message) self.bus.add_signal_watch() return True
def register_elements(): register_element(M3uDecoder) register_element(PlsDecoder) register_element(XspfDecoder) register_element(AsxDecoder) register_element(UriListElement) # Only register icy if gst install can't handle it on it's own. if not gst.element_make_from_uri(gst.URI_SRC, 'icy://'): register_element(IcySrc)
def __init__(self): super(IcySrc, self).__init__() self._httpsrc = gst.element_make_from_uri(gst.URI_SRC, 'http://') try: self._httpsrc.set_property('iradio-mode', True) except TypeError: pass self.add(self._httpsrc) self._srcpad = gst.GhostPad('src', self._httpsrc.get_pad('src')) self.add_pad(self._srcpad)
def _createSource(self): source = gst.element_make_from_uri(gst.URI_SRC, self.current_uri, "src-%s" % self.current_uri) if not source: self.warning("This is not a media file: %s", self.current_uri) self.error = _("No available source handler.") self.error_detail = _("You do not have a GStreamer source element to handle protocol '%s'") % gst.uri_get_protocol(self.current_uri) return None # increment source blocksize to 128kbytes, this should speed up # push-mode scenarios (like pictures). if hasattr(source.props, 'blocksize'): source.props.blocksize = 131072 return source
def __init__(self, uri, gst_type): self.__uri = uri self.__gst_type = gst_type self.__taglist = {} # Pipeline di gstreamer self.pipe = gst.Pipeline("pipe") # File sorgente filesource = gst.element_make_from_uri(gst.URI_SRC, self.__uri) # Decodebin2 con l'evento decoder = gst.element_factory_make("decodebin2", "decoder") decoder.connect("new-decoded-pad", self.on_pad) # Aggiunge i primi due alla pipeline e li collega self.pipe.add(filesource, decoder) gst.element_link_many(filesource, decoder) # Audioconverter self.converter = gst.element_factory_make("audioconvert", "converter") # Formato grezzo caps = gst.Caps("audio/x-raw-int") capsfilter = gst.element_factory_make("capsfilter", "filter") capsfilter.set_property("caps", caps) # Encoder wav encoder = gst.element_factory_make("wavenc", "wavencoder") # File risultato dest = gst.element_factory_make("filesink", "file-dest") dest.set_property("location", XACHOME + "/tempfile.wav") # Aggiunge e collega gli ultimi self.pipe.add(self.converter, capsfilter, encoder, dest) gst.element_link_many(self.converter, capsfilter, encoder, dest) self.bus = self.pipe.get_bus() self.bus.add_signal_watch() self.bus.connect("message", self.on_message) self.pipe.set_state(gst.STATE_PLAYING) self.mainloop = gobject.MainLoop() self.mainloop.run()
def _setup_pipeline(uri, proxy_config=None): src = gst.element_make_from_uri(gst.URI_SRC, uri) if not src: raise exceptions.ScannerError("GStreamer can not open: %s" % uri) typefind = gst.element_factory_make("typefind") decodebin = gst.element_factory_make("decodebin2") pipeline = gst.element_factory_make("pipeline") pipeline.add_many(src, typefind, decodebin) gst.element_link_many(src, typefind, decodebin) if proxy_config: utils.setup_proxy(src, proxy_config) typefind.connect("have-type", _have_type, decodebin) decodebin.connect("pad-added", _pad_added, pipeline) return pipeline
def CopyAndGenerateWaveform(self, uri): """ Copies the audio file to the new file location and reads the levels at the same time. """ urisrc = gst.element_make_from_uri(gst.URI_SRC, uri) if not urisrc: # This means that here is no gstreamer src element on the system that can handle this URI type. return False pipe = ( """tee name=mytee mytee. ! queue ! filesink name=sink """ + """mytee. ! queue ! decodebin ! audioconvert ! level name=level_element message=true ! fakesink""" ) self.loadingPipeline = gst.parse_launch(pipe) tee = self.loadingPipeline.get_by_name("mytee") filesink = self.loadingPipeline.get_by_name("sink") level = self.loadingPipeline.get_by_name("level_element") self.loadingPipeline.add(urisrc) urisrc.link(tee) filesink.set_property("location", self.GetAbsFile()) level.set_property("interval", int(self.LEVEL_INTERVAL * gst.SECOND)) self.bus = self.loadingPipeline.get_bus() self.bus.add_signal_watch() self.bus.connect("message::element", self.bus_message) self.bus.connect("message::tag", self.bus_message_tags) self.bus.connect("message::state-changed", self.bus_message_statechange) self.bus.connect("message::eos", self.bus_eos) self.bus.connect("message::error", self.bus_error) self.levels_list = LevelsList.LevelsList() self.isLoading = True self.emit("loading") self.loadingPipeline.set_state(gst.STATE_PLAYING) return True
def __init__(self, path, filter_caps, *args, **kwargs): gst.Bin.__init__(self, *args, **kwargs) uri = 'file://%s' % path if uri and gst.uri_is_valid(uri): urisrc = gst.element_make_from_uri(gst.URI_SRC, uri, "urisrc") self.add(urisrc) jpegdec = gst.element_factory_make('jpegdec','pic-jpegdec') self.add(jpegdec) queue = gst.element_factory_make('queue', "pic-queue") self.add(queue) csp = gst.element_factory_make('ffmpegcolorspace', 'pic-colorspace') self.add(csp) videoscale = gst.element_factory_make('videoscale', 'pic-scale') videoscale.set_property("add-borders", False) self.add(videoscale) freeze = gst.element_factory_make('imagefreeze', 'pic-freeze') self.add(freeze) capsfilter = gst.element_factory_make("capsfilter", "pic-capsfilter") caps = gst.Caps(filter_caps) capsfilter.set_property("caps", caps) self.add(capsfilter) # link elements gst.element_link_many( urisrc, jpegdec, videoscale, queue, csp, capsfilter, freeze ) self.add_pad(gst.GhostPad('src', freeze.get_pad('src')))
def _setup_pipeline(uri, proxy_config=None): src = gst.element_make_from_uri(gst.URI_SRC, uri) if not src: raise exceptions.ScannerError('GStreamer can not open: %s' % uri) typefind = gst.element_factory_make('typefind') decodebin = gst.element_factory_make('decodebin2') pipeline = gst.element_factory_make('pipeline') for e in (src, typefind, decodebin): pipeline.add(e) gst.element_link_many(src, typefind, decodebin) if proxy_config: utils.setup_proxy(src, proxy_config) typefind.connect('have-type', _have_type, decodebin) decodebin.connect('pad-added', _pad_added, pipeline) return pipeline
def search(self, db, entry, is_playing, on_search_completed, *args): # only search if we're not already playing this entry if is_playing: print "not checking for embedded cover art in playing entry" on_search_completed(self, entry, None, *args) return # only search local files uri = entry.get_string(RB.RhythmDBPropType.LOCATION) if uri.startswith("file://") is False: print "not checking for embedded cover art in non-local entry %s" % uri on_search_completed(self, entry, None, *args) return self.entry = entry self.args = args self.callback = on_search_completed self.args = args self.got_pixbuf = False # set up pipeline and bus callbacks self.pipeline = gst.Pipeline() bus = self.pipeline.get_bus() bus.add_signal_watch() bus.connect("message::tag", self._tag_cb) bus.connect("message::state-changed", self._state_changed_cb) bus.connect("message::error", self._error_cb) # create elements self.src = gst.element_make_from_uri(gst.URI_SRC, uri) self.decodebin = gst.element_factory_make("decodebin2") self.sink = gst.element_factory_make("fakesink") self.decodebin.connect('new-decoded-pad', self._decoded_pad_cb) self.pipeline.add(self.src, self.decodebin, self.sink) self.src.link(self.decodebin) self.sinkpad = self.sink.get_pad('sink') self.pipeline.set_state(gst.STATE_PAUSED)
def play_only_if_null(self, track): (pending, state, timeout) = self.pipeline.get_state() if state != gst.STATE_NULL: self.pipeline.set_state(gst.STATE_PLAYING) return if self.src: self.pipeline.remove(self.src) if self.spotify_in_use == False: print "removed a decodebin" self.pipeline.remove(self.decodebin) if track.uri[0:7] == "spotify": print "It was a spotify uri" self.src = self.spotify # FIXME ugly self.dogvibes.sources[0].set_track(track) self.pipeline.add(self.src) self.src.link(self.tee) self.spotify_in_use = True elif track.uri == "lastfm": print "It was a lastfm uri" self.src = self.lastfm self.dogvibes.sources[1].set_track(track) self.decodebin = gst.element_factory_make("decodebin2", "decodebin2") self.decodebin.connect('new-decoded-pad', self.pad_added) self.pipeline.add(self.src) self.pipeline.add(self.decodebin) self.src.link(self.decodebin) self.spotify_in_use = False else: print "Decodebin is taking care of this uri" self.src = gst.element_make_from_uri(gst.URI_SRC, track.uri, "source") self.decodebin = gst.element_factory_make("decodebin2", "decodebin2") self.decodebin.connect('new-decoded-pad', self.pad_added) self.pipeline.add(self.src) self.pipeline.add(self.decodebin) self.src.link(self.decodebin) self.spotify_in_use = False self.pipeline.set_state(gst.STATE_PLAYING)
def search (self, db, entry, is_playing, on_search_completed, *args): # only search if we're not already playing this entry if is_playing: print "not checking for embedded cover art in playing entry" on_search_completed (self, entry, None, *args) return # only search local files uri = db.entry_get(entry, rhythmdb.PROP_LOCATION) if uri.startswith("file://") is False: print "not checking for embedded cover art in non-local entry %s" % uri on_search_completed (self, entry, None, *args) return self.entry = entry self.args = args self.callback = on_search_completed self.args = args self.got_pixbuf = False # set up pipeline and bus callbacks self.pipeline = gst.Pipeline() bus = self.pipeline.get_bus() bus.add_signal_watch() bus.connect("message::tag", self._tag_cb) bus.connect("message::state-changed", self._state_changed_cb) bus.connect("message::error", self._error_cb) # create elements self.src = gst.element_make_from_uri(gst.URI_SRC, uri) self.decodebin = gst.element_factory_make("decodebin2") self.sink = gst.element_factory_make("fakesink") self.decodebin.connect('new-decoded-pad', self._decoded_pad_cb) self.pipeline.add(self.src, self.decodebin, self.sink) self.src.link(self.decodebin) self.sinkpad = self.sink.get_pad('sink') self.pipeline.set_state(gst.STATE_PAUSED)
def CopyAndGenerateWaveform(self, uri): """ Copies the audio file to the new file location and reads the levels at the same time. """ urisrc = gst.element_make_from_uri(gst.URI_SRC, uri) if not urisrc: #This means that here is no gstreamer src element on the system that can handle this URI type. return False pipe = """tee name=mytee mytee. ! queue ! filesink name=sink """ +\ """mytee. ! queue ! decodebin ! audioconvert ! level name=level_element message=true ! fakesink""" self.loadingPipeline = gst.parse_launch(pipe) tee = self.loadingPipeline.get_by_name("mytee") filesink = self.loadingPipeline.get_by_name("sink") level = self.loadingPipeline.get_by_name("level_element") self.loadingPipeline.add(urisrc) urisrc.link(tee) filesink.set_property("location", self.GetAbsFile()) level.set_property("interval", int(self.LEVEL_INTERVAL * gst.SECOND)) self.bus = self.loadingPipeline.get_bus() self.bus.add_signal_watch() self.bus.connect("message::element", self.bus_message) self.bus.connect("message::tag", self.bus_message_tags) self.bus.connect("message::state-changed", self.bus_message_statechange) self.bus.connect("message::eos", self.bus_eos) self.bus.connect("message::error", self.bus_error) self.levels_list = LevelsList.LevelsList() self.isLoading = True self.emit("loading") self.loadingPipeline.set_state(gst.STATE_PLAYING) return True
def __init__(self, uri, filename, audiosink): self.pipeline = gst.Pipeline() # create stream reader and automatic MP3 transcoder/decoder self.stream = gst.element_make_from_uri(gst.URI_SRC, uri) self.filter = autotranscoder() self.pipeline.add(self.stream, self.filter) # create audio and/or file sinks self.audiosink = audiosink or gst.element_factory_make('fakesink') if filename: self.filesink = gst.element_factory_make('filesink') self.filesink.set_property('location', filename) else: self.filesink = gst.element_factory_make('fakesink') self.pipeline.add(self.audiosink, self.filesink) # assemble pipeline self.stream.link(self.filter) self.filter.link_pads('audiosrc', self.audiosink, None) self.filter.link_pads('filesrc', self.filesink, None)
def createPipeline(self): # uri source uri = self.arguments["uri"] if not gst.uri_is_valid(uri): self.validateStep("is-valid-uri-format", False) return None self.validateStep("is-valid-uri-format") src = gst.element_make_from_uri(gst.URI_SRC, uri, "uri-src") typefind = gst.element_factory_make("typefind") fakesink = gst.element_factory_make("fakesink") p = gst.Pipeline() p.add(src, typefind, fakesink) gst.element_link_many(src,typefind,fakesink) # connect signals typefind.connect("have-type", self._typefindHaveTypeCb) return p
def createPipeline(self): self._src = gst.element_make_from_uri(gst.URI_SRC, self.arguments.get("uri")) try: self._dbin = gst.element_factory_make("decodebin2") except: self._dbin = gst.element_factory_make("decodebin") self._typefind = self._dbin.get_by_name("typefind") p = gst.Pipeline() p.add(self._src, self._dbin) self._src.link(self._dbin) self._streams = [] self._mimetype = None self._typefind.connect("have-type", self._haveTypeCb) self._dbin.connect("unknown-type", self._unknownTypeCb) self._dbin.connect("new-decoded-pad", self._newDecodedPadCb) self._dbin.connect("no-more-pads", self._noMorePadsCb) return p
def _makeDefaultBin(self): """ Return a bin that decodes all the available streams. This is generally used to get an overview of the source media before splitting it in separate streams. """ bin = gst.Bin("%s" % self.name) src = gst.element_make_from_uri(gst.URI_SRC, self.uri) try: dbin = gst.element_factory_make("decodebin2") except: dbin = gst.element_factory_make("decodebin") bin.add(src, dbin) src.link_pads_full("src", dbin, "sink", gst.PAD_LINK_CHECK_NOTHING) dbin.connect("new-decoded-pad", self._binNewDecodedPadCb, bin) dbin.connect("removed-decoded-pad", self._binRemovedDecodedPadCb, bin) bin.decodebin = dbin return bin
def _makeDefaultBin(self): """ Return a bin that decodes all the available streams. This is generally used to get an overview of the source media before splitting it in separate streams. """ bin = gst.Bin("%s" % self.name) src = gst.element_make_from_uri(gst.URI_SRC, self.uri) try: dbin = gst.element_factory_make("decodebin2") except: dbin = gst.element_factory_make("decodebin") bin.add(src, dbin) src.link(dbin) dbin.connect("new-decoded-pad", self._binNewDecodedPadCb, bin) dbin.connect("removed-decoded-pad", self._binRemovedDecodedPadCb, bin) bin.decodebin = dbin return bin
def __init__(self, caps=None, uri=None, stream=None, *args, **kwargs): gst.Bin.__init__(self, *args, **kwargs) if not caps: caps = gst.caps_new_any() self.caps = caps self.stream = stream self.typefind = gst.element_factory_make("typefind", "internal-typefind") self.add(self.typefind) self.uri = uri if self.uri and gst.uri_is_valid(self.uri): self.urisrc = gst.element_make_from_uri(gst.URI_SRC, uri, "urisrc") self.log("created urisrc %s / %r" % (self.urisrc.get_name(), self.urisrc)) self.add(self.urisrc) # Set the blocksize to 512kbytes, this will only matter for push-based sources if hasattr(self.urisrc.props, "blocksize"): self.urisrc.props.blocksize = 524288 self.urisrc.link_pads_full("src", self.typefind, "sink", gst.PAD_LINK_CHECK_NOTHING) else: self._sinkpad = gst.GhostPad("sink", self.typefind.get_pad("sink")) self._sinkpad.set_active(True) self.add_pad(self._sinkpad) self.typefind.connect("have_type", self._typefindHaveTypeCb) self._srcpad = None self._dynamics = [] self._validelements = [] # added elements self.debug("stream:%r" % self.stream) self.pending_newsegment = None self.eventProbeId = None
def __init__(self, uri): self.__uri = uri self.pipe = gst.Pipeline("pipe") #filesource = gst.element_factory_make("filesrc", "filesource") #filesource.set_property("location", self.__location) filesource = gst.element_make_from_uri(gst.URI_SRC, self.__uri) fakesink = gst.element_factory_make("fakesink", "sink") typefind = gst.element_factory_make("typefind", "typefinder") typefind.connect("have_type", self.on_find_type) self.pipe.add(filesource, typefind, fakesink) gst.element_link_many(filesource, typefind, fakesink) self.bus = self.pipe.get_bus() self.bus.add_signal_watch() self.bus.connect("message", self.on_message) self.pipe.set_state(gst.STATE_PLAYING)
def __init__(self, caps=None, uri=None, stream=None, *args, **kwargs): gst.Bin.__init__(self, *args, **kwargs) if not caps: caps = gst.caps_new_any() self.caps = caps self.stream = stream self.typefind = gst.element_factory_make("typefind", "internal-typefind") self.add(self.typefind) self.uri = uri if self.uri and gst.uri_is_valid(self.uri): self.urisrc = gst.element_make_from_uri(gst.URI_SRC, uri, "urisrc") self.log("created urisrc %s / %r" % (self.urisrc.get_name(), self.urisrc)) self.add(self.urisrc) # Set the blocksize to 512kbytes, this will only matter for push-based sources if hasattr(self.urisrc.props, "blocksize"): self.urisrc.props.blocksize = 524288 self.urisrc.link_pads_full("src", self.typefind, "sink", gst.PAD_LINK_CHECK_NOTHING) else: self._sinkpad = gst.GhostPad("sink", self.typefind.get_pad("sink")) self._sinkpad.set_active(True) self.add_pad(self._sinkpad) self.typefind.connect("have_type", self._typefindHaveTypeCb) self._srcpad = None self._dynamics = [] self._validelements = [] #added elements self.debug("stream:%r" % self.stream) self.pending_newsegment = None self.eventProbeId = None
def register(): # Only register icy if gst install can't handle it on it's own. if not gst.element_make_from_uri(gst.URI_SRC, 'icy://'): gobject.type_register(IcySrc) gst.element_register( IcySrc, IcySrc.__name__.lower(), gst.RANK_MARGINAL)
def _makeBin(self, input_stream=None): return gst.element_make_from_uri(gst.URI_SINK, self.uri)
def _makeBin(self, input_stream=None): sink_element = gst.element_make_from_uri(gst.URI_SINK, self.uri) sink_element.set_property("async", False) return sink_element