tutorial yaml and more plugin code migration and stubs

Author: flipcoder

textbeat/def/style.yaml

@@ -0,0 +1 @@
+# playstyle variables like vibrato speed and depth

textbeat/player.py

@@ -66,7 +66,7 @@ def __init__(self):
         self.stoprow = -1
         self.cmdmode = 'n' # n normal c command s sequence
         self.schedule = Schedule(self)
-        self.rack = []
+        self.host = []
         self.tracks = []
         self.shell = False
         self.remote = False
@@ -143,25 +143,26 @@ def init(self):
     def refresh_devices(self):
         # determine output device support and load external programs
         # try:
-        from .support import supports, support_init
+        from .support import supports, SUPPORT_PLUGINS
         # except:
         #     import textbeat.support as support
         for dev in self.devices:
             if not supports(dev):
                 if dev!='auto':
                     out('Device not supported by system: ' + dev)
                 else:
-                    out('Loading instrument presets requires Carla.')
+                    out('Loading instrument presets requires a compatible host module.')
                 assert False
             try:
-                support_init[dev](self.rack)
+                # support_enable[dev](self.rack)
+                SUPPORT_PLUGINS[dev].enable(self.host)
             except KeyError:
                 # no init needed, silent
                 pass
         self.auto = 'auto' in self.devices
 
-    def set_rack(self, plugins):
-        self.rack = plugins
+    def set_host(self, plugins):
+        self.host = plugins
         self.refresh_devices()
 
     # def remove_flags(self, f):
@@ -421,7 +422,7 @@ def run(self):
                                     elif var=='R':
                                         if not 'auto' in self.devices:
                                             self.devices = ['auto'] + self.devices
-                                        self.set_rack(val.split(','))
+                                        self.set_host(val.split(','))
                                     elif var=='V': self.version = val
                                     elif var=='D':
                                         self.devices = val.split(',')

textbeat/plugins/carla.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python
+import textbeat.instrument as instrument
+from textbeat.instrument import Instrument
+from shutilwhich import which
+
+ERROR = False
+if which('carla'):
+    ERROR = True
+
+class Carla(Instrument):
+    NAME = 'carla'
+    def __init__(self, args):
+        Instrument.__init__(self, Carla.NAME)
+        self.initialized = False
+        self.enabled = False
+        self.soundfonts = []
+        self.proc = None
+        self.args = args
+        self.gen_inited = False
+    def enabled(self):
+        return self.initialized
+    def enable(self, rack):
+        if not self.proc:
+            fn = self.args['SONGNAME']
+            if not fn:
+                fn = 'default'
+            if rack:
+                self.self.temp_proj = tempfile.mkstemp('.carxp',fn)
+                os.close(self.temp_proj[0])
+                self.temp_proj = self.temp_proj[1]
+                os.unlink(self.temp_proj)
+                base_proj = os.path.join(os.path.join(os.path.dirname(os.path.abspath(__file__)),'presets','default.carxp'))
+                shutil.copy2(base_proj, self.temp_proj)
+
+                # add instruments to temp proj file
+                filebuf = ''
+                with open(self.temp_proj,'r') as f:
+                    filebuf = f.read()
+                instrumentxml = ''
+                i = 0
+                for instrument in rack:
+                    fnparts = instrument.split('.')
+                    name = fnparts[0]
+                    try:
+                        ext = fnparts[1].upper()
+                    except IndexError:
+                        ext = 'LV2'
+                    instrumentxml += '<!--'+name+'-->\n'+\
+                        '<Plugin><Info>\n'+\
+                        '<Type>'+ext+'</Type>\n'+\
+                        '<Name>'+name+'</Name>\n'+\
+                        '<URI>x</URI>'+\
+                        '</Info>\n'+\
+                        '<Data>\n'+\
+                            '<ControlChannel>N</ControlChannel>\n'+\
+                            '<Active>Yes</Active>\n'+\
+                            '<Options>'+hex(i)+'</Options>\n'+\
+                        '</Data>'+\
+                        '</Plugin>\n\n'
+                    i += 1
+                filebuf = filebuf.replace('</EngineSettings>', '</EngineSettings>'+instrumentxml)
+                with open(self.temp_proj,'w') as f:
+                    f.write(filebuf)
+                
+                self.proj = self.temp_proj
+                self.gen_inited = True
+            else:
+                self.proj = fn.split('.')[0]+'.carxp'
+        if os.path.exists(proj):
+            log(proj)
+            self.proc = subprocess.Popen(['carla',proj], stdout=subprocess.PIPE, stderr=subprocess.PIPE) # '--nogui', 
+        elif not rack:
+            log('To load a Carla project headless, create a \'%s\' file.' % proj)
+
+        self.initialized = True
+    def supported(self):
+        return not ERROR
+    def support(self):
+        return ['auto','carla']
+    def stop(self):
+        if self.gen_inited and self.proj:
+            try:
+                os.remove(carla_proj[1])
+            except OSError:
+                pass
+            except FileNotFoundError:
+                pass
+
+        if self.self.temp_proj:
+            os.unlink(self.temp_proj)
+        if self.self.proc:
+            self.proc.kill()
+
+# instrument.export(FluidSynth)
+export = Carla
+

textbeat/plugins/csound.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+import textbeat.instrument as instrument
+from textbeat.instrument import Instrument
+from shutilwhich import which
+import subprocess
+
+ERROR = False
+if not which('csound'):
+    ERROR = True
+
+class CSound(Instrument):
+    NAME = 'csound'
+    def __init__(self, args):
+        Instrument.__init__(self, CSound.NAME)
+        self.initialized = False
+        self.proc = None
+        self.csound = None
+    def enable(self):
+        if not initialized:
+            self.proc = subprocess.Popen(['csound', '-odac', '--port='+str(CSOUND_PORT)], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            self.csound = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            self.initialized = True
+    def enabled(self):
+        return self.initialized
+    def supported(self):
+        return not ERROR
+    def support(self):
+        return ['csound']
+    def send(self, s):
+        assert self.initialized
+        return csound.sendto(s,('localhost',CSOUND_PORT))
+    # def note_on(self, t, n, v):
+    #     self.fs.noteon(t, n, v)
+    # def note_off(self, t, n, v):
+    #     self.fs.noteoff(t, v)
+    #     pass
+    def stop(self):
+        self.proc.kill()
+        pass
+
+export = CSound
+

textbeat/plugins/espeak.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python
+from textbeat.defs import *
+import textbeat.instrument as instrument
+from textbeat.instrument import Instrument
+from shutilwhich import which
+import subprocess
+
+ERROR = False
+if not which('espeak'):
+    ERROR = True
+
+# Currently not used, caches text to speech stuff in a way compatible with jack
+# current super slow, need to write stabilizer first
+class BackgroundProcess(object):
+    def __init__(self, con):
+        self.con = con
+        self.words = {}
+        self.processes = []
+    def cache(self,word):
+        try:
+            tmp = self.words[word]
+        except:
+            tmp = tempfile.NamedTemporaryFile()
+            p = subprocess.Popen(['espeak', '\"'+pipes.quote(word)+'\"','--stdout'], stdout=tmp)
+            p.wait()
+            self.words[tmp.name] = tmp
+        return tmp
+    def run(self):
+        devnull = open(os.devnull, 'w')
+        while True:
+            msg = self.con.recv()
+            # log(msg)
+            if msg[0]==BGCMD.SAY:
+                tmp = self.cache(msg[1])
+                # super slow, better option needed
+                self.processes.append(subprocess.Popen(['mpv','-ao','jack',tmp.name],stdout=devnull,stderr=devnull))
+            elif msg[0]==BGCMD.CACHE:
+                self.cache(msg[1])
+            elif msg[0]==BGCMD.QUIT:
+                break
+            elif msg[0]==BGCMD.CLEAR:
+                self.words.clear()
+            else:
+                log('BAD COMMAND: ' + msg[0])
+            self.processses = list(filter(lambda p: p.poll()==None, self.processes))
+        self.con.close()
+        for tmp in self.words:
+            tmp.close()
+        for proc in self.processes:
+            proc.wait()
+
+def bgproc_run(con):
+    self.proc = BackgroundProcess(con)
+    self.proc.run()
+
+class ESpeak(Instrument):
+    NAME = 'espeak'
+    def __init__(self, args):
+        Instrument.__init__(self, ESpeak.NAME)
+        self.initialized = False
+        self.proc = None
+        self.espeak = None
+    def enable(self):
+        if not initialized:
+            self.pipe, child = Pipe()
+            self.proc = Process(target=bgproc_run, args=(child,))
+            self.proc.start()
+
+            self.initialized = True
+    def enabled(self):
+        return self.initialized
+    def supported(self):
+        return not ERROR
+    def support(self):
+        return ['espeak']
+    # def note_on(self, t, n, v):
+    #     self.fs.noteon(t, n, v)
+    # def note_off(self, t, n, v):
+    #     self.fs.noteoff(t, v)
+    #     pass
+    def stop(self):
+        if self.proc:
+            self.pipe.send((BGCMD.QUIT,))
+            self.proc.join()
+
+        # self.proc.kill()
+        pass
+
+export = ESpeak
+

textbeat/plugins/fluidsynth.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+import textbeat.instrument as instrument
+from textbeat.instrument import Instrument
+from shutilwhich import which
+
+ERROR = False
+if which('fluidsynth'):
+    try:
+        import fluidsynth # https://github.com/flipcoder/pyfluidsynth
+    except:
+        ERROR = True
+else:
+    ERROR = True
+
+class FluidSynth(Instrument):
+    NAME = 'fluidsynth'
+    def __init__(self, args):
+        Instrument.__init__(self, FluidSynth.NAME)
+        self.initialized = False
+        self.enabled = False
+        self.soundfonts = []
+    def init(self):
+        self.initialized = True
+    def inited(self):
+        return self.initialized
+    def enabled(self):
+        return self.enabled
+    def enable(self):
+        self.fs = fluidsynth.Synth()
+        self.enabled = True
+    def soundfont(self, fn, track, bank, preset):
+        sfid = self.fs.sfload(fn)
+        self.fs.program_select(track, sfid, bank, preset)
+        return sfid
+    def supported(self):
+        return not ERROR
+    def support(self):
+        return ['fluidsynth','soundfonts']
+    def note_on(self, t, n, v):
+        self.fs.noteon(t, n, v)
+    def note_off(self, t, n, v):
+        self.fs.noteoff(t, v)
+        pass
+    def stop(self):
+        pass
+
+# instrument.export(FluidSynth)
+export = FluidSynth
+

textbeat/plugins/sonicpi.py

@@ -10,13 +10,13 @@
 
 class SonicPi(Instrument):
     NAME = 'sonicpi'
-    def __init__(self):
+    def __init__(self, args):
         Instrument.__init__(self, SonicPi.NAME)
         self.initalized = False
-    def init(self):
+    def enable(self):
         self.initalized = True
-    def inited(self):
-        return self.initalized
+    def enabled(self):
+        return self.initialized
     def supported(self):
         return not ERROR
     def support(self):

textbeat/plugins/supercollider.py

@@ -14,13 +14,13 @@
 
 class SuperCollider(Instrument):
     NAME = 'supercollider'
-    def __init__(self):
+    def __init__(self, args):
         Instrument.__init__(self, SuperCollider.NAME)
         self.initalized = False
-    def init(self):
+    def enable(self):
         self.initalized = True
-    def inited(self):
-        return self.initalized
+    def enabled(self):
+        return self.enabled
     def supported(self):
         return not ERROR
     def support(self):