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 checkTicket349():
result = messages.Result()
import pygst
pygst.require("0.10")
import gst
if get_gst_version(gst) < (0, 10, 4, 1):
major, minor, micro, nano = get_gst_version(gst)
m = messages.Error(
T_(N_("Version %d.%d.%d of the GStreamer library is too old.\n"), major, minor, micro), mid="ticket-349"
)
m.add(T_(N_("The '%s' component needs a newer version of '%s'.\n"), "looper", "gstreamer"))
m.add(T_(N_("Please upgrade '%s' to version %s or later."), "gstreamer", "0.10.5"))
result.add(m)
if get_pygst_version(gst) < (0, 10, 3, 1):
major, minor, micro, nano = get_pygst_version(gst)
m = messages.Error(
T_(N_("Version %d.%d.%d of the gst-python library is too old.\n"), major, minor, micro), mid="ticket-349"
)
m.add(T_(N_("The '%s' component needs a newer version of '%s'.\n"), "looper", "gst-python"))
m.add(T_(N_("Please upgrade '%s' to version %s or later."), "gst-python", "0.10.4"))
result.add(m)
result.succeed(None)
return defer.succeed(result)
def cal2(m=list()):
# m=islem_yapan(veri)
for i in m:
s = i + ".mp3"
import pygst
pygst.require("0.10")
import gst
player = gst.Pipeline("player")
source = gst.element_factory_make("filesrc", "file-source")
decoder = gst.element_factory_make(
"mad", "decoder"
) # mp3 formatı için decoder "mad", örneğin flac için "flacdec"...
conv = gst.element_factory_make("audioconvert", "converter")
sink = gst.element_factory_make(
"autoaudiosink", "audio-output"
) # autoaudiosink yerine sistemin kullandığı ses aygıtı, örneğin "alsasink", "alsa-output" yazılabilir
player.add(source, decoder, conv, sink)
gst.element_link_many(source, decoder, conv, sink)
player.get_by_name("file-source").set_property("location", s) # aynı dizinde değilse tam yol yazılmalı
player.set_state(gst.STATE_PLAYING)
time.sleep(0.35)
player.set_state(gst.STATE_NULL)
def import_gst0_10():
global gst_version, pygst_version
import pygst
pygst.require("0.10")
try:
#initializing gstreamer parses sys.argv
#which interferes with our own command line arguments
#so we temporarily replace them:
saved_args = sys.argv
sys.argv = sys.argv[:1]
#now do the import with stderr redirection
#to avoid gobject warnings:
oldfd = redirect_stderr()
import gst
gst_version = gst.gst_version
pygst_version = gst.pygst_version
gst.new_buffer = gst.Buffer
if not hasattr(gst, 'MESSAGE_STREAM_START'):
#a None value is better than nothing:
#(our code can assume it exists - just never matches)
gst.MESSAGE_STREAM_START = None
return gst
finally:
unredirect_stderr(oldfd)
sys.argv = saved_args
def _check_libs():
try:
import pygtk
pygtk.require('2.0')
import gtk
import gnome
import gnome.ui
gnome.ui.authentication_manager_init()
import gconf
import gobject
gobject.threads_init()
import gnomevfs
except ImportError:
print '%s needs pygtk and gnome-python >= 2.12!' % NAME
sys.exit(1)
try:
import pygst
pygst.require('0.10')
import gst
except ImportError:
print '%s needs python-gstreamer 0.10!' % NAME
sys.exit(1)
print ' using Gstreamer version: %s' % (
'.'.join([str(s) for s in gst.gst_version]))
def send_video(self, media, local_host, local_port, remote_host, remote_port):
# inspired from http://blog.abourget.net/2009/6/14/gstreamer-rtp-and-live-streaming/
# we send each stream on its own port pair
import gobject, pygst
pygst.require("0.10")
import gst
raise Exception("fixme: TODO send video on RTP/RTCP")
def __init__(self, usage, description, domain):
self.domain = domain
BaseOP.__init__(self, usage=usage, description=description)
if use_gst:
try:
import pygst
pygst.require('0.10')
import gstoption
self.add_option_group(gstoption.get_group())
except ImportError:
pass
def checkDependencies(self):
print ('Checking dependencies')
try:
import pygst
pygst.require('0.10')
import gst
except ImportError:
self.close('IMPORT_ERROR: Could not found the GStreamer Pythonbindings.\n'
'You can download the installers at:\n'
'http://www.gstreamer-winbuild.ylatuya.es')
else:
print ('GStreamer... OK')
try:
import pygtk
pygtk.require('2.0')
import gtk
import gtk.gdk
import gobject
except ImportError:
self.close('IMPORT_ERROR: Could not find the Gtk Python bindings.\n'
'You can download the installers at:\n'
'http://www.pygtk.org/\n'
'http://www.gtk.org/')
else:
print ('Gtk... OK')
try:
import gtk.glade
except ImportError:
self.close('IMPORT_ERROR: Could not find libglade in the system.\n'
'You can download the installers at:\n'
'http://sourceforge.net/projects/gladewin32/files/libglade-win32'
'/2.4.0/libglade-2.4.0-bin.zip/download')
else:
print ('libglade... OK')
try:
import goocanvas
except ImportError:
self.close('IMPORT_ERROR: Could not find the Goocanvas Python bindings.\n'
'You can download the intallers at:\n'
'http://ftp.gnome.org/pub/GNOME/binaries/win32/goocanvas/\n'
'http://sqlkit.argolinux.org/download/goocanvas.pyd')
else:
print ('goocanvas... OK')
try:
import zope.interface
except:
self.close('ERROR: Could not found Zope.Interface')
else:
print ('zope.interface... OK')
def __init__(self, config):
"""Initialize the speech components"""
global gst
global gobject
import gobject
import pygst
pygst.require('0.10')
import gst
sys.stdout = None
sys.stderr = None
self.config = config
self.active_plugin = None
self.plugins = []
for epoint in pkg_resources.iter_entry_points("mattd.plugins"):
log.info("Loading plugin %r" % epoint.name)
try:
self.plugins.append(epoint.load()(self))
except Exception as e:
log.warn("%r failed. %r" % (epoint.name, e))
log.info("Loaded %i plugins." % len(self.plugins))
one_second_in_nanoseconds = 1000000000
def dict2properties(d):
return " ".join([
"%s=%s" % (k, str(v)) for k, v in d.items()
])
vader_properties = {
'name': 'vader',
'auto-threshold': 'true',
'run-length': one_second_in_nanoseconds,
'pre-length': one_second_in_nanoseconds,
}
self.pipeline = gst.parse_launch(
'gconfaudiosrc ! audioconvert ! audioresample '
+ '! vader %s ' % dict2properties(vader_properties)
+ '! pocketsphinx name=asr ! fakesink')
asr = self.pipeline.get_by_name('asr')
asr.connect('partial_result', self.asr_partial_result)
asr.connect('result', self.asr_result)
asr.set_property('configured', True)
bus = self.pipeline.get_bus()
bus.add_signal_watch()
bus.connect('message::application', self.application_message)
self.pipeline.set_state(gst.STATE_PLAYING)
def __init__(self, options, tmp_dir):
self.options = options
self.tmp_dir = tmp_dir
self.frame_capture_padding = 0.5 * 1000000000
# Import python gstreamer libraries
global pygst, gst, gobject, threading, time
import pygst
pygst.require("0.10")
import gst
import gobject
import threading
import time
# Create gstreamer player object
self.player = gst.Pipeline("player")
# File source and universal decoder
filesrc = gst.element_factory_make("filesrc", "file-source")
decoder = gst.element_factory_make("decodebin", "decoder")
decoder.connect("new-decoded-pad", self.decoder_callback)
# PNG encoder, Multiple File sink and colorspace converter required by PNG encoder
colorspace = gst.element_factory_make("ffmpegcolorspace", "video-sink")
pngenc = gst.element_factory_make("pngenc", "png-encoder")
pngenc.set_property("snapshot", True)
multifilesink = gst.element_factory_make("multifilesink", "multi-file-sink")
multifilesink.set_property("location",
os.path.join(self.tmp_dir, "output-%05d.png"))
multifilesink.set_property("post-messages", True)
# Add elements to player pipeline
self.player.add(filesrc, decoder, colorspace, pngenc, multifilesink)
gst.element_link_many(filesrc, decoder)
gst.element_link_many(colorspace, pngenc, multifilesink)
bus = self.player.get_bus()
bus.add_signal_watch()
bus.connect("message", self.on_message)
# Initialize gobject MainLoop in a new thread
gobject.threads_init()
self.main_loop = gobject.MainLoop()
def main_loop_thread():
self.main_loop.run()
self.main_loop_thread = threading.Thread(target=main_loop_thread)
self.main_loop_thread.daemon = True
self.main_loop_thread.start()
def _deferred_imports():
# The GStreamer (or bulkio) modules may not be installed; defer imports
# until creation of a SoundSink to report the error only when it's relevant
try:
import pygst
pygst.require('0.10')
import gst
from bulkio.bulkioInterfaces import BULKIO__POA
def _deferred_imports():
pass
globals().update(locals())
except ImportError, e:
raise RuntimeError("Missing required package for sandbox audio: '%s'" % e)
def activate (self, totem_object):
"""Check for the availability of the flvdemux and souphttpsrc GStreamer plugins"""
bvw_name = totem_object.get_video_widget_backend_name ()
"""If the user's selected 1.5Mbps or greater as their connection speed, grab higher-quality videos
and drop the requirement for the flvdemux plugin."""
self.gconf_client = gconf.client_get_default ()
if bvw_name.find ("GStreamer") != -1:
try:
import pygst
pygst.require ("0.10")
import gst
registry = gst.registry_get_default ()
if registry.find_plugin ("soup") == None:
"""This means an error will be displayed when they try to play anything"""
self.gstreamer_plugins_present = False
except ImportError:
"""Do nothing; either it's using xine or python-gstreamer isn't installed"""
"""Continue loading the plugin as before"""
self.builder = self.load_interface ("youtube.ui", True, totem_object.get_main_window (), self)
self.totem = totem_object
self.search_entry = self.builder.get_object ("yt_search_entry")
self.search_entry.connect ("activate", self.on_search_entry_activated)
self.search_button = self.builder.get_object ("yt_search_button")
self.search_button.connect ("clicked", self.on_search_button_clicked)
self.progress_bar = self.builder.get_object ("yt_progress_bar")
self.notebook = self.builder.get_object ("yt_notebook")
self.notebook.connect ("switch-page", self.on_notebook_page_changed)
self.notebook_pages = ["search", "related"]
for page in self.notebook_pages:
self.setup_treeview (page)
self.current_treeview_name = "search"
self.vbox = self.builder.get_object ("yt_vbox")
self.vbox.show_all ()
totem_object.add_sidebar_page ("youtube", _("YouTube"), self.vbox)
"""Set up the service"""
self.service = gdata.service.GDataService (account_type = "HOSTED_OR_GOOGLE", server = "gdata.youtube.com")
def parse_arguments(args):
regex = re.compile("^gstreamer\|([0-9])+\.([0-9]+)\|(.+)\|(.+)\|([a-z]+)-(.*)[|]?")
requests = []
xid = None
gst_init = False
major = 0
minor = 0
for arg in args:
if arg[0:16] == "--transient-for=":
try:
xid = int(arg[16:])
except:
pass
continue
elif arg[0:2] == "--":
continue
match = regex.search(arg)
if not match:
continue
try:
r_major = int(match.group(1))
r_minor = int(match.group(2))
if not gst_init:
import pygst
pygst.require("%d.%d" % (r_major, r_minor))
import gst
gst_init = True
major = r_major
minor = r_minor
elif r_major != major or r_minor != minor:
return None
except ValueError:
continue
if match.group(5) == "decoder" or match.group(5) == "encoder":
try:
requests.append(Request(major, minor, match.group(3), match.group(4), match.group(5), caps=gst.Caps(match.group(6))))
except TypeError:
continue
elif match.group(5) == "urisource" or match.group(5) == "urisink" or match.group(5) == "element":
requests.append(Request(major, minor, match.group(3), match.group(4), match.group(5), feature=match.group(6)))
else:
continue
return (requests, xid)
def load_pygtk():
try:
import pygst
pygst.require('0.10')
import gst
except Exception:
import struct
is64bit = len(struct.pack(b'P', 0)) == 8
logging.info("Python arch: %d-bit" % (64 if is64bit else 32))
gstroot = os.environ.get('GSTREAMER_SDK_ROOT_X86_64', r'C:\gstreamer-sdk\0.10\x64') \
if is64bit \
else os.environ.get('GSTREAMER_SDK_ROOT_X86', r'C:\gstreamer-sdk\0.10\x86')
if not os.path.exists(gstroot):
error("GStreamer not found",
"GStreamer was not found. It can be downloaded from http://www.gstreamer.com/\r\n\r\n" +
"See README.Windows for more information.")
os.environ['PATH'] = gstroot + r'\bin;' + os.environ['PATH']
gstpypath = gstroot + r'\lib\python2.7\site-packages'
sys.path.insert(1, gstpypath)
os.environ['PYTHONPATH'] = gstpypath
try:
import pygst
pygst.require('0.10')
import gst
except Exception:
error("GStreamer Python bindings not found",
"The Python bindings for GStreamer could not be imported. Please re-run the GStreamer installer and ensure that \"GStreamer python bindings\" is selected for installation (it should be selected by default).\r\n\r\n" +
"GStreamer can be downloaded from http://www.gstreamer.com/\r\n\r\n" +
"See README.Windows for more information.")
else:
logging.info("GStreamer: %s" % gstroot)
else:
logging.info("GStreamer works out of the box")
try:
import pygtk
pygtk.require('2.0')
import gtk
except Exception:
error("GTK/PyGTK not found",
"PyGTK 2.x could not be imported. Please re-run the GStreamer installer and ensure that \"Gtk toolkit\" and \"Gtk python bindings\" are selected (they should be selected by default). Note that the PyGTK library from pygtk.org is NOT compatible with the GStreamer library from gstreamer.com.\r\n\r\n" +
"GStreamer can be downloaded from http://www.gstreamer.com/\r\n\r\n" +
"See README.Windows for more information.")
else:
logging.info("PyGTK works")
def _init_gst_version(gst_majorminor):
def tup2version(tup):
return '.'.join(map(str, tup))
if gst_majorminor not in GST_REQ:
raise SystemExit('ERROR: Invalid FLU_GST_VERSION: %r (expected '
'one of %r)' % (gst_majorminor, GST_REQ.keys()))
pygst_req = GST_REQ[gst_majorminor]['gst-python']
gst_req = GST_REQ[gst_majorminor]['gstreamer']
try:
import pygst
pygst.require(gst_majorminor)
import gst
except ImportError:
return False
except AssertionError:
return False
try:
gst_version = gst.get_gst_version()
pygst_version = gst.get_pygst_version()
except AttributeError:
# get_foo_version() added in 0.10.4, fall back
gst_version = gst.gst_version
pygst_version = gst.pygst_version
if gst_req[:2] != gst_version[:2]:
raise SystemExit(
'ERROR: Expected GStreamer %s, but got incompatible %s'
% (gst_majorminor, tup2version(gst_version[:2])))
if gst_version < gst_req:
raise SystemExit(
'ERROR: GStreamer %s too old; install %s or newer'
% (tup2version(gst_version), tup2version(gst_req)))
if pygst_version < pygst_req:
raise SystemExit(
'ERROR: gst-python %s too old; install %s or newer'
% (tup2version(pygst_version), tup2version(pygst_req)))
return True
def prepare(self):
super(Daemon, self).prepare()
# Late import pygst and gstreamer; they steals the `-h` switch
import pygst
pygst.require("0.10")
import gobject
gobject.threads_init()
from evafm.sources.rpcserver import RPCServer
from evafm.sources.source import Source
# Late searching of checkers in order to have logging properly setup
giblets.search.find_plugins_by_entry_point("evafm.sources.checkers")
self.source = Source(self.mgr)
self.source.activate()
self.source.connect_signals()
self.source.set_id(self.source_id)
self.rpc_server = RPCServer(self.mgr)
gobject.timeout_add_seconds(
self.detach_process and 2 or 0, self.source.setup_heart
)
self.loop = gobject.MainLoop()
def checkTicket348():
result = messages.Result()
import pygst
pygst.require('0.10')
import gst
(major, minor, nano) = gst.pygst_version
if (major, minor, nano) < (0, 10, 3):
m = messages.Warning(T_(
N_("Version %d.%d.%d of the gst-python library contains "
"a large memory leak.\n"),
major, minor, nano),
mid='ticket-348')
m.add(T_(N_("The Soundcard and Firewire sources may leak a lot of "
"memory as a result, and need to be restarted frequently.\n")))
m.add(T_(N_("Please upgrade '%s' to version %s or later."),
'gst-python', '0.10.3'))
result.add(m)
result.succeed(None)
return defer.succeed(result)
def do(self, args):
import pygst
pygst.require('0.10')
import gobject
gobject.threads_init()
import gst
from dadgst.task import level
runner = task.SyncRunner()
for path in filterFiles(self, args):
t = level.LevellerTask(path)
runner.run(t)
if t.done:
self.stdout.write('Successfully analyzed file %s.\n' %
path.encode('utf-8'))
mixes = t.get_track_mixes()
self.stdout.write('%d fragment(s)\n' % len(mixes))
for i, m in enumerate(mixes):
self.stdout.write('- fragment %d: %s - %s\n' % (
i, gst.TIME_ARGS(m.start), gst.TIME_ARGS(m.end)))
self.stdout.write(' - peak %02.3f dB (%03.3f %%)\n' % (
m.peak, common.decibelToRaw(m.peak) * 100.0))
self.stdout.write(' - rms %r dB\n' % m.rms)
self.stdout.write(' - peak rms %r dB\n' % m.rmsPeak)
self.stdout.write(' - 95 percentile rms %r dB\n' % m.rmsPercentile)
self.stdout.write(' - weighted rms %r dB\n' % m.rmsWeighted)
start = m.attack.get(m.rmsPeak - 9)
end = m.decay.get(m.rmsPeak - 9)
self.stdout.write(' - weighted from %s to %s\n' % (
gst.TIME_ARGS(start), gst.TIME_ARGS(end)))
else:
self.stderr.write('Could not level %s\n' %
path.encode('utf-8'))
t.clean()
def import_gst0_10():
log("import_gst0_10()")
global gst_version, pygst_version
import pygst
log("import_gst0_10() pygst=%s", pygst)
pygst.require("0.10")
#initializing gstreamer parses sys.argv
#which interferes with our own command line arguments
#so we temporarily hide it,
#also import with stderr redirection in place
#to avoid gobject warnings:
from xpra.os_util import HideStdErr, HideSysArgv
with HideStdErr():
with HideSysArgv():
import gst
gst_version = gst.gst_version
pygst_version = gst.pygst_version
gst.new_buffer = gst.Buffer
if not hasattr(gst, 'MESSAGE_STREAM_START'):
#a None value is better than nothing:
#(our code can assume it exists - just never matches)
gst.MESSAGE_STREAM_START = None
return gst
#!/usr/bin/env python
import pygst
pygst.require("1.0")
import gst
import gtk
import time
#python script to pipe youtube video through v4l2loopback
#gst-launch-0.10 uridecodebin name=dec uri=$(/usr/bin/youtube-dl -g -f 18 $VID) ! queue ! autoaudiosink dec. ! queue ! videoscale ! videorate ! videoconvert ! video/x-raw-yuv,width=$WIDTH,height=$HEIGHT,framerate=$FPS,format=\(fourcc\)YUY2 ! v4l2sink device=$DEV
class Pipeline(object):
def __init__(self):
self.pipeline = gst.Pipeline("pipe")
self.webcam = gst.element_factory_make("uridecodebin", "webcam")
self.webcam.set_property("name", "dec")
self.webcam.set_property("uri", "https://r7---sn-uxa0n-t8ge.googlevideo.com/videoplayback?upn=NfyzW9GP_rI&sparams=dur%2Cid%2Cinitcwndbps%2Cip%2Cipbits%2Citag%2Cmime%2Cmm%2Cms%2Cmv%2Cpl%2Cratebypass%2Crequiressl%2Csource%2Cupn%2Cexpire&mt=1423607359&mv=m&initcwndbps=1680000&itag=18&ms=au&mm=31&ipbits=0&fexp=907263%2C927622%2C934954%2C9405957%2C9406352%2C9406653%2C943917%2C947225%2C948124%2C951703%2C952302%2C952605%2C952612%2C952901%2C955301%2C957201%2C959701&id=o-AKTOF81wFSr82qnYzE4MeBw61iMriU75FOhA9tHvlJca&sver=3&ip=207.34.141.22&requiressl=yes&signature=1E2427505D722028BBC73A7A6433E59C63AD7E21.B9BF9D4F68425C001182903082E6D1B3A4140502&key=yt5&source=youtube&ratebypass=yes&dur=64.760&expire=1423629184&mime=video%2Fmp4&pl=17")
self.pipeline.add(self.webcam)
self.queue = gst.element_factory_make("queue", "queue")
self.pipeline.add(self.queue)
self.audio = gst.element_factory_make("autoaudiosink", "audio")
self.pipeline.add(self.audio)
self.dec = gst.element_get_name(self.webcam)
self.pipeline.add(self.dec)
self.que = gst.element_factory_make("queue", "que")
self.pipeline.add(self.que)
self.videoscale = gst.element_factory_make("videoscale", "videoscale")
self.pipeline.add(self.videoscale)
def setup_gstreamer(self):
import gobject
gobject.threads_init()
import pygst
pygst.require("0.10")
import gst
#####################################################################
# G-Streamer control/playback Object
#
# By Rob Williams (jolouis) for the FlipClock project
# Provides a simple GStreamer interface for playing back mp3s/audio
# using the native gstreamer app.
#
# loosely based on post on Nokia Maemo forums:
# http://wiki.forum.nokia.com/index.php/How_to_create_a_mp3_player_in_maemo
######################################################################
# Import python g-streamer bindings
import pygst
pygst.require('0.10') # uhh sure, why not...
# import gStreamer itself
import gst
# gobject, for setting up timeouts, etc
import gobject
class mediaPlayer(object):
# ## Method to initialize the gstreamer instance
def __init__(self, outputModule='mp3'):
# Extract any command line arguments. This needs to be done before GStreamer is
# imported, so that GStreamer doesn't hijack e.g. ``--help``.
mopidy_args = sys.argv[1:]
sys.argv[1:] = []
# Add ../ to the path so we can run Mopidy from a Git checkout without
# installing it on the system.
sys.path.insert(
0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../')))
import pygst
pygst.require('0.10')
import gst
from mopidy import config as config_lib, ext
from mopidy.models import Track, Artist, Album
from mopidy.utils import log, path, versioning
def main():
args = parse_args()
# TODO: support config files and overrides (shared from main?)
config_files = [b'/etc/mopidy/mopidy.conf',
b'$XDG_CONFIG_DIR/mopidy/mopidy.conf']
config_overrides = []
# TODO: decide if we want to avoid this boilerplate some how.
#!/usr/bin/env python
# Copyright (c) 2008 Carnegie Mellon University.
#
# You may modify and redistribute this file under the same terms as
# the CMU Sphinx system. See
# http://cmusphinx.sourceforge.net/html/LICENSE for more information.
import pygtk
pygtk.require('2.0')
import gtk
import gobject
import pygst
pygst.require('1.0')
gobject.threads_init()
import gst
class DemoApp(object):
"""GStreamer/PocketSphinx Demo Application"""
def __init__(self):
"""Initialize a DemoApp object"""
self.init_gui()
self.init_gst()
def init_gui(self):
"""Initialize the GUI components"""
self.window = gtk.Window()
self.window.connect("delete-event", gtk.main_quit)
self.window.set_default_size(400, 200)
#
# Important notes: you must take care of glib event + python. If you connect()
# directly an event to a python object method, the object will be ref, and will
# be never unref.
# To prevent memory leak, you must connect() to a func, and you might want to
# pass the referenced object with weakref()
#
import pygst
if not hasattr(pygst, '_gst_already_checked'):
found = False
for version in ('1.0', '0.10'):
try:
pygst.require(version)
found = True
break
except:
continue
if found:
pygst._gst_already_checked = True
else:
raise Exception('Unable to find a valid Gstreamer version to use')
import gst
from functools import partial
from os import path
from threading import Lock
def run(self):
print "Checking Python version >= 2.6:",
print ".".join(map(str, sys.version_info[:2]))
if sys.version_info < (2, 6):
raise SystemExit("%s requires at least Python 2.6. "
"(http://www.python.org)" % self.__NAME)
print "Checking for PyGTK >= 2.22:",
try:
import pygtk
pygtk.require("2.0")
import gtk
if gtk.pygtk_version < (2, 22) or gtk.gtk_version < (2, 22):
raise ImportError
except ImportError:
raise SystemExit("not found\n%s requires PyGTK 2.21. "
"(http://www.pygtk.org)" % self.__NAME)
else:
print "found"
print "Checking for gst-python >= 0.10.21:",
try:
import pygst
pygst.require("0.10")
import gst
if gst.pygst_version < (0, 10, 21):
raise ImportError
except ImportError:
have_pygst = False
print "not found"
else:
have_pygst = True
print "found"
print "Checking for Mutagen >= 1.19:",
try:
import mutagen
if mutagen.version < (1, 19):
raise ImportError
except ImportError:
raise SystemExit(
"not found\n%s requires Mutagen 1.19.\n"
"(http://code.google.com/p/mutagen/downloads/list)" %
self.__NAME)
else:
print "found"
print "Checking for PyGObject >= 2.21:",
try:
import gobject
if gobject.pygobject_version < (2, 21):
raise ImportError
except ImportError:
raise SystemExit(
"not found\n%s requires PyGObject 2.21.\n"
"(https://live.gnome.org/PyGObject)" %
self.__NAME)
else:
print "found"
print "Checking for Cython >= 0.15.1:",
try:
import Cython
if Cython.__version__ < "0.15.1":
raise ImportError
except ImportError:
raise SystemExit(
"not found\n%s requires Cython 0.15.1.\n"
"(http://http://www.cython.org/#download)" %
self.__NAME)
else:
print "found"
print "Checking for numpy >= 1.3:",
try:
import numpy.version
if numpy.version.version < "1.3":
raise ImportError
except ImportError:
raise SystemExit("not found\n%s requires python-numpy 1.3.\n" %
self.__NAME)
else:
print "found"
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# For support, questions, suggestions or any other inquiries, visit:
# http://wiki.github.com/Freeseer/freeseer/
import pygst
pygst.require("0.10") # required before import gst
from collections import defaultdict
from functools import partial
import gst
import os
import pytest
import re
import sys
from freeseer.framework.config import Config
from freeseer.framework.config.profile import ProfileManager
from freeseer.framework.plugin import IAudioInput
from freeseer.framework.plugin import PluginManager
from freeseer.framework.config import options
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
import blaconst
# FIXME: this module will get imported even if we won't finish the startup,
# e.g. blaplay is already running.
try:
import pygst
try:
pygst.require(blaconst.GST_REQUIRED_VERSION)
except pygst.RequiredVersionError:
raise ImportError
from gst import *
import gst.pbutils as pbutils
except ImportError:
class gst(object):
class ElementNotFoundError(Exception):
pass
@classmethod
def element_factory_find(cls, element):
return None
@classmethod
def element_factory_make(cls, element):
def main():
# The first time GStreamer is imported, it hijacks standard args like
# '--help'. To prevent this, we hide non-gst args and restore them later.
argv = sys.argv
sys.argv = [argv[0]]
sys.argv.extend(a for a in argv if a == '--help-gst' or a.startswith('--gst-'))
try:
import pygst
pygst.require('0.10')
import gst
except Exception:
import struct
is64bit = len(struct.pack(b'P', 0)) == 8
logging.info("Python arch: %d-bit" % (64 if is64bit else 32))
gstroot = os.environ.get('GSTREAMER_SDK_ROOT_X86_64', r'C:\gstreamer-sdk\0.10\x86_64') \
if is64bit \
else os.environ.get('GSTREAMER_SDK_ROOT_X86', r'C:\gstreamer-sdk\0.10\x86')
if not os.path.exists(gstroot):
error("GStreamer not found",
"GStreamer was not found. It can be downloaded from http://www.gstreamer.com/\r\n\r\n" +
"See README.Windows for more information.")
os.environ['PATH'] = gstroot + r'\bin;' + os.environ['PATH']
gstpypath = gstroot + r'\lib\python2.7\site-packages'
sys.path.insert(1, gstpypath)
os.environ['PYTHONPATH'] = gstpypath
try:
import pygst
pygst.require('0.10')
import gst
except Exception:
error("GStreamer Python bindings not found",
"The Python bindings for GStreamer could not be imported. Please re-run the GStreamer installer and ensure that \"GStreamer python bindings\" is selected for installation (it should be selected by default).\r\n\r\n" +
"GStreamer can be downloaded from http://www.gstreamer.com/\r\n\r\n" +
"See README.Windows for more information.")
else:
logging.info("GStreamer: %s" % gstroot)
else:
logging.info("GStreamer works out of the box")
finally:
sys.argv = argv
try:
import pygtk
pygtk.require('2.0')
import gtk
except Exception:
error("GTK/PyGTK not found",
"PyGTK 2.x could not be imported. Please re-run the GStreamer installer and ensure that \"Gtk toolkit\" and \"Gtk python bindings\" are selected (they should be selected by default). Note that the PyGTK library from pygtk.org is NOT compatible with the GStreamer library from gstreamer.com.\r\n\r\n" +
"GStreamer can be downloaded from http://www.gstreamer.com/\r\n\r\n" +
"See README.Windows for more information.")
else:
logging.info("PyGTK works")
try:
import mutagen
except Exception:
error("Mutagen not found",
"The Python module Mutagen could not be imported. It can be downloaded from http://code.google.com/p/mutagen\r\n\r\n" +
"See README.Windows for more information.")
else:
logging.info("Mutagen works")
try:
sys.argv[1:1] = ['--startgui', '--no-dbus', '--no-hal']
import exaile
exaile.main()
except Exception:
import traceback
traceback.print_exc()
raw_input()
#!/usr/bin/python
import gobject; gobject.threads_init()
import pygst; pygst.require("0.10")
import gst
from threading import Thread
class OSCController(Thread):
def __init__(self, port):
Thread.__init__(self)
import liblo
self.port = port
try:
self.server = liblo.Server(self.port)
except liblo.ServerError, err:
print str(err)
def add_method(self, path, type, method):
self.server.add_method(path, type, method)
def run(self):
while True:
self.server.recv(100)
class GSTSrcVideo(object):
def __init__(self, pipe=None, framerate='24/1', width=160, height=90, xpos=0, ypos=0):
self.framerate = framerate
self.width = width
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# For support, questions, suggestions or any other inquiries, visit:
# http://wiki.github.com/Freeseer/freeseer/
import pygst
pygst.require("0.10") # required before import gst
from collections import defaultdict
from functools import partial
import gst
import os
import pytest
import re
import sys
from freeseer.framework.config import Config
from freeseer.framework.config.profile import ProfileManager
from freeseer.framework.plugin import IAudioInput
from freeseer.framework.plugin import PluginManager
from freeseer.framework.config import options
#!/usr/bin/env python
# Copyright (c) 2008 Carnegie Mellon University.
#
# You may modify and redistribute this file under the same terms as
# the CMU Sphinx system. See
# http://cmusphinx.sourceforge.net/html/LICENSE for more information.
import pygtk
pygtk.require('2.0')
import gtk
import gobject
import pygst
pygst.require('1.0')
gobject.threads_init()
import gst
class DemoApp(object):
"""GStreamer/PocketSphinx Demo Application"""
def __init__(self):
"""Initialize a DemoApp object"""
self.init_gui()
self.init_gst()
def init_gui(self):
"""Initialize the GUI components"""
self.window = gtk.Window()
self.window.connect("delete-event", gtk.main_quit)
self.window.set_default_size(400,200)
self.window.set_border_width(10)
"""A wrapper for the GStreamer Python bindings that exposes a simple
music player.
"""
from __future__ import division, absolute_import, print_function
import sys
import time
import gobject
import thread
import os
import copy
import urllib
import pygst
pygst.require('0.10')
import gst # noqa
class GstPlayer(object):
"""A music player abstracting GStreamer's Playbin element.
Create a player object, then call run() to start a thread with a
runloop. Then call play_file to play music. Use player.playing
to check whether music is currently playing.
A basic play queue is also implemented (just a Python list,
player.queue, whose last element is next to play). To use it,
just call enqueue() and then play(). When a track finishes and
another is available on the queue, it is played automatically.
"""
#!/usr/bin/python
import pygst
pygst.require("0.10")
import gst
import sys
import time
# Audio delay code thanks to d53richar on Ubuntu Forums.
# http://ubuntuforums.org/showthread.php?t=1189559
class AudioDelay:
def __init__(self):
## ALSA
self.delay_pipeline = gst.Pipeline("mypipeline")
self.audiosrc = gst.element_factory_make("jackaudiosrc", "audio")
self.delay_pipeline.add(self.audiosrc)
## Queue
self.audioqueue = gst.element_factory_make("queue", "queue1")
self.audioqueue.set_property("max-size-time", 0)
self.audioqueue.set_property("max-size-buffers", 0)
self.audioqueue.set_property("max-size-bytes", 0)
self.audioqueue.set_property("leaky", "no")
self.delay_pipeline.add(self.audioqueue)
## Volume
self.volume = gst.element_factory_make("volume", "volume")
self.delay_pipeline.add(self.volume)
## Audio Output
An output plugin which routes sound to the device's available
speakers.
@author: Thanh Ha
'''
# python-lib
try: # Import using Python3 module name
import configparser
except ImportError:
import ConfigParser as configparser
# GStreamer
import pygst
pygst.require("0.10")
import gst
# PyQt
from PyQt4.QtCore import SIGNAL
# Freeseer
from freeseer.framework.plugin import IOutput
# .freeseer-plugin
import widget
class AudioFeedback(IOutput):
name = "Audio Feedback"
os = ["linux", "linux2", "win32", "cygwin", "darwin"]
