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
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
