multiloop compiling and old code mostly working

6 files changed, 138 insertions, 113 deletions

diff --git a/Edit/MainWindow.py b/Edit/MainWindow.py
index be92129..2d5e2d8 100644
--- a/Edit/MainWindow.py
+++ b/Edit/MainWindow.py
@@ -702,7 +702,7 @@ class MainWindow( SubActivity ):
         self.csnd.loopSetNumTicks( numticks )
 
         self.csnd.loopSetTick( self.page_onset[startPage] + startTick )
-        self.csnd.loopSetTempo(self._data['tempo'])
+        self.csnd.setTempo(self._data['tempo'])
         if (Config.DEBUG > 3): print "starting from tick", startTick, 'at tempo', self._data['tempo']
         self.csnd.loopStart()
 
@@ -865,7 +865,7 @@ class MainWindow( SubActivity ):
         img = min(7,int(8*(self._data["tempo"]-widget.lower)/(widget.upper-widget.lower)))+1# tempo 1-8
         #self.GUI["2tempoImage"].set_from_file( Config.IMAGE_ROOT+"tempo"+str(img)+".png" )
         if self.playing:
-            self.csnd.loopSetTempo(self._data['tempo'])
+            self.csnd.setTempo(self._data['tempo'])
 
     def handleToolClick( self, widget, mode ):
         if widget.get_active(): self.trackInterface.setInterfaceMode( mode )
@@ -1415,7 +1415,7 @@ class MainWindow( SubActivity ):
 
     def waitToSet(self):
         self.csnd.setMasterVolume(self._data['volume'])
-        self.csnd.loopSetTempo(self._data['tempo'])
+        self.csnd.setTempo(self._data['tempo'])
         self.initTrackVolume()
 
     def handleSave(self, widget):
diff --git a/Jam/JamMain.py b/Jam/JamMain.py
index 6645b97..1fe4c0f 100644
--- a/Jam/JamMain.py
+++ b/Jam/JamMain.py
@@ -34,7 +34,7 @@ class JamMain(SubActivity):
         for i in range(1,9):
             self.csnd.setTrackVolume( 100, i )
         self.csnd.setMasterVolume( self.volume )
-        self.csnd.loopSetTempo( self.tempo )
+        self.csnd.setTempo( self.tempo )
 
         #======================================================
         # GUI
diff --git a/Util/CSoundClient.py b/Util/CSoundClient.py
index 60fdd9a..2bab169 100644
--- a/Util/CSoundClient.py
+++ b/Util/CSoundClient.py
@@ -17,6 +17,11 @@ _note_template = array.array('f', [0] * 19 )
 def _new_note_array():
     return _note_template.__copy__()
 
+def _noteid(dbnote):
+    return (dbnote.page << 16) + dbnote.id
+
+_loop_default=0
+
 class _CSoundClientPlugin:
 
     #array index constants for csound
@@ -42,6 +47,8 @@ class _CSoundClientPlugin:
         self.on = False
         #self.masterVolume = 80.0
         self.periods_per_buffer = 2
+        global _loop_default
+        _loop_default = self.loopCreate()
 
     def __del__(self):
         self.connect(False)
@@ -49,28 +56,17 @@ class _CSoundClientPlugin:
 
     def setChannel(self, name, val):
         sc_setChannel(name, val)
-        #if self.on:
-            #sc_setChannel(name, val)
 
     def setMasterVolume(self, volume):
         sc_setChannel( 'masterVolume', volume)
-        #self.masterVolume = volume
-        #if self.on:
-            #sc_setMasterVolume(volume)
 
     def setTrackVolume( self, volume, trackId ):
         sc_setChannel( 'trackVolume' + str(trackId + 1), volume )
-        #self.trackVolume = volume
-        #sc_setTrackVolume(volume, trackId+1)
 
     def setTrackpadX( self, value ):
-        #trackpadX = value
-        #sc_setTrackpadX(trackpadX)
         sc_setChannel( 'trackpadX', value)
 
     def setTrackpadY( self, value ):
-        #trackpadY = value
-        #sc_setTrackpadY(trackpadY)
         sc_setChannel( 'trackpadY', value)
 
     def micRecording( self, table ):
@@ -123,37 +119,61 @@ class _CSoundClientPlugin:
     def inputMessage(self,msg):
         sc_inputMessage(msg)
 
-    def loopClear(self):
-        sc_loop_clear()
-    def loopDelete(self, dbnote):
-        sc_loop_delScoreEvent( (dbnote.page << 16) + dbnote.id)
-    def loopDelete1(self, page, id):
-        sc_loop_delScoreEvent( (page << 16) + id)
-    def loopStart(self):
-        sc_loop_playing(1)
-    def loopPause(self):
-        sc_loop_playing(0)
-    def loopSetTick(self,t):
-        sc_loop_setTick(t)
-    def loopGetTick(self):
-        return sc_loop_getTick()
-    def loopSetNumTicks(self,n):
-        sc_loop_setNumTicks(n)
-    def loopSetTickDuration(self,d):
-        sc_loop_setTickDuration(d)
-    def loopAdjustTick(self,d):
-        sc_loop_adjustTick(d)
-    def loopSetTempo(self,t):
+    def getTick( self ):
+        return sc_getTickf()
+
+    def adjustTick( self, amt ):
+        sc_adjustTick(amt)
+
+    def setTempo(self,t):
         if (Config.DEBUG > 3) : print 'INFO: loop tempo: %f -> %f' % (t, 60.0 / (Config.TICKS_PER_BEAT * t))
-        sc_loop_setTickDuration( 60.0 / (Config.TICKS_PER_BEAT * t))
+        sc_setTickDuration( 60.0 / (Config.TICKS_PER_BEAT * t))
+
+
+    def loopCreate(self):
+        return sc_loop_new()
+
+    def loopDestroy(self, loopId):
+        sc_loop_delete(loopId)
+
+    def loopClear(self):
+        global _loop_default
+        sc_loop_delete(_loop_default)
+        _loop_default = sc_loop_new()
+
+    # this is function deletes an Event from a loop
+    # TODO: rename this function
+    def loopDelete(self, dbnote, loopId=_loop_default):
+        sc_loop_delScoreEvent( loopId, _noteid(dbnote))
+
+    def loopDelete1(self, page, id, loopId=_loop_default):
+        sc_loop_delScoreEvent( loopId, (page << 16) + id)
+
+    def loopStart(self, loopId=_loop_default):
+        sc_loop_playing(loopId, 1)
+
+    def loopPause(self, loopId=_loop_default):
+        sc_loop_playing(loopId, 0)
+
+    def loopSetTick(self,t, loopId=_loop_default):
+        sc_loop_setTickf(loopId, t)
+
+    def loopGetTick(self, loopId=_loop_default):
+        return sc_loop_getTickf(loopId)
+
+    def loopSetNumTicks(self,n, loopId=_loop_default):
+        sc_loop_setNumTicks(loopId, n)
+
+    def loopSetTickDuration(self,d, loopId=_loop_default):
+        sc_loop_setTickDuration(loopId, d)
 
-    def loopDeactivate(self, note = None):
-        if note == None:
-            sc_loop_deactivate_all()
+    def loopDeactivate(self, note = 'all', loopId=_loop_default):
+        if note == 'all':
+            sc_loop_deactivate_all(loopId)
         else:
             if (Config.DEBUG > 0) : print 'ERROR: deactivating a single note is not implemented'
 
-    def loopUpdate(self, note, parameter, value,cmd):
+    def loopUpdate(self, note, parameter, value,cmd, loopId=_loop_default):
         page = note.page
         track = note.track
         id = note.id
@@ -166,7 +186,7 @@ class _CSoundClientPlugin:
                 instrument_id_offset = 100
         if (parameter == NoteDB.PARAMETER.ONSET):
             if (Config.DEBUG > 2): print 'INFO: updating onset', (page<<16)+id, value
-            sc_loop_updateEvent( (page<<16)+id, 1, value, cmd)
+            sc_loop_updateEvent( loopId, (page<<16)+id, 1, value, cmd)
         elif (parameter == NoteDB.PARAMETER.PITCH):
             if (Config.DEBUG > 2): print 'INFO: updating pitch', (page<<16)+id, value
             pitch = value
@@ -175,18 +195,18 @@ class _CSoundClientPlugin:
                 csoundInstId = instrument.csoundInstrumentId
                 csoundTable  = Config.INSTRUMENT_TABLE_OFFSET + instrument.instrumentId
                 if (Config.DEBUG > 2): print 'INFO: updating drum instrument (pitch)', (page<<16)+id, instrument.name, csoundInstId
-                sc_loop_updateEvent( (page<<16)+id, 0, (csoundInstId + instrument_id_offset) + note.track * 0.01, -1 )
-                sc_loop_updateEvent( (page<<16)+id, 7, csoundTable  , -1 )
+                sc_loop_updateEvent( loopId, (page<<16)+id, 0, (csoundInstId + instrument_id_offset) + note.track * 0.01, -1 )
+                sc_loop_updateEvent( loopId, (page<<16)+id, 7, csoundTable  , -1 )
                 pitch = 1
             else:
                 pitch = GenerationConstants.TRANSPOSE[ pitch - 24 ]
-            sc_loop_updateEvent( (page<<16)+id, 3, pitch, cmd)
+            sc_loop_updateEvent( loopId, (page<<16)+id, 3, pitch, cmd)
         elif (parameter == NoteDB.PARAMETER.AMPLITUDE):
             if (Config.DEBUG > 2): print 'INFO: updating amp', (page<<16)+id, value
-            sc_loop_updateEvent( (page<<16)+id, 5, value, cmd)
+            sc_loop_updateEvent( loopId, (page<<16)+id, 5, value, cmd)
         elif (parameter == NoteDB.PARAMETER.DURATION):
             if (Config.DEBUG > 2): print 'INFO: updating duration', (page<<16)+id, value
-            sc_loop_updateEvent( (page<<16)+id, self.DURATION, value, cmd)
+            sc_loop_updateEvent( loopId, (page<<16)+id, self.DURATION, value, cmd)
         elif (parameter == NoteDB.PARAMETER.INSTRUMENT):
             pitch = note.cs.pitch
             instrument = Config.INSTRUMENTSID[value]
@@ -198,31 +218,32 @@ class _CSoundClientPlugin:
             loopEnd = instrument.loopEnd
             crossDur = instrument.crossDur
             if (Config.DEBUG > 2): print 'INFO: updating instrument', (page<<16)+id, instrument.name, csoundInstId
-            sc_loop_updateEvent( (page<<16)+id, 0, (csoundInstId + (track+1) + instrument_id_offset) + note.track * 0.01, cmd )
-            sc_loop_updateEvent( (page<<16)+id, 7, csoundTable, -1 )
-            sc_loop_updateEvent( (page<<16)+id, 12, loopStart, -1 )
-            sc_loop_updateEvent( (page<<16)+id, 13, loopEnd, -1 )
-            sc_loop_updateEvent( (page<<16)+id, 14, crossDur , -1 )
+            sc_loop_updateEvent( loopId, (page<<16)+id, 0, (csoundInstId + (track+1) + instrument_id_offset) + note.track * 0.01, cmd )
+            sc_loop_updateEvent( loopId, (page<<16)+id, 7, csoundTable, -1 )
+            sc_loop_updateEvent( loopId, (page<<16)+id, 12, loopStart, -1 )
+            sc_loop_updateEvent( loopId, (page<<16)+id, 13, loopEnd, -1 )
+            sc_loop_updateEvent( loopId, (page<<16)+id, 14, crossDur , -1 )
         elif (parameter == NoteDB.PARAMETER.PAN):
-            sc_loop_updateEvent( (page<<16)+id, self.PAN, value, cmd)
+            sc_loop_updateEvent( loopId, (page<<16)+id, self.PAN, value, cmd)
         elif (parameter == NoteDB.PARAMETER.REVERB):
-            sc_loop_updateEvent( (page<<16)+id, self.REVERBSEND, value, cmd)
+            sc_loop_updateEvent( loopId, (page<<16)+id, self.REVERBSEND, value, cmd)
         elif (parameter == NoteDB.PARAMETER.ATTACK):
-            sc_loop_updateEvent( (page<<16)+id, self.ATTACK, value, cmd)
+            sc_loop_updateEvent( loopId, (page<<16)+id, self.ATTACK, value, cmd)
         elif (parameter == NoteDB.PARAMETER.DECAY):
-            sc_loop_updateEvent( (page<<16)+id, self.DECAY, value, cmd)
+            sc_loop_updateEvent( loopId, (page<<16)+id, self.DECAY, value, cmd)
         elif (parameter == NoteDB.PARAMETER.FILTERTYPE):
-            sc_loop_updateEvent( (page<<16)+id, self.FILTERTYPE, value, cmd)
+            sc_loop_updateEvent( loopId, (page<<16)+id, self.FILTERTYPE, value, cmd)
         elif (parameter == NoteDB.PARAMETER.FILTERCUTOFF):
-            sc_loop_updateEvent( (page<<16)+id, self.FILTERCUTOFF, value, cmd)
+            sc_loop_updateEvent( loopId, (page<<16)+id, self.FILTERCUTOFF, value, cmd)
         elif (parameter == NoteDB.PARAMETER.INSTRUMENT2):
-            sc_loop_updateEvent( (page<<16)+id, self.INSTRUMENT2, value, cmd)
+            sc_loop_updateEvent( loopId, (page<<16)+id, self.INSTRUMENT2, value, cmd)
         else:
             if (Config.DEBUG > 0): print 'ERROR: loopUpdate(): unsupported parameter change'
 
-    def loopPlay(self, dbnote, active, storage=_new_note_array() ):
+    def loopPlay(self, dbnote, active, storage=_new_note_array(),
+            loopId=_loop_default ):
         qid = (dbnote.page << 16) + dbnote.id
-        sc_loop_addScoreEvent( qid, 1, active, 'i',
+        sc_loop_addScoreEvent( loopId, qid, 1, active, 'i',
                 self.csnote_to_array( dbnote.cs, storage))
 
     def play(self, csnote, secs_per_tick, storage=_new_note_array()):
diff --git a/Util/Clooper/aclient.cpp b/Util/Clooper/aclient.cpp
index b17e848..1146c3b 100644
--- a/Util/Clooper/aclient.cpp
+++ b/Util/Clooper/aclient.cpp
@@ -342,6 +342,10 @@ struct Music
     }
     ~Music()
     {
+        for (eventMap_t::iterator i = loop.begin(); i != loop.end(); ++i)
+        {
+            delete i->second;
+        }
         csoundDestroyMutex(mutex);
     }
 
@@ -896,7 +900,17 @@ DECL(sc_scoreEvent) //(char type, farray param)
     assert(!"not reached");
     return NULL;
 }
-DECL(sc_setChannel) //(float v)
+DECL (sc_inputMessage) //(const char *msg)
+{
+    char * msg;
+    if (!PyArg_ParseTuple(args, "s", &msg ))
+    {
+        return NULL;
+    }
+    g_tt->inputMessage(msg);
+    RetNone;
+}
+DECL(sc_setChannel) //(string name, float value)
 {
     const char * str;
     float v;
@@ -916,6 +930,38 @@ DECL(sc_getTickf) // () -> float
     }
     return Py_BuildValue("f", g_tt->getTickf());
 }
+DECL(sc_adjustTick) // (MYFLT ntick)
+{
+    float spt;
+    if (!PyArg_ParseTuple(args, "f", &spt ))
+    {
+        return NULL;
+    }
+    g_tt->adjustTick(spt);
+    RetNone;
+}
+DECL(sc_setTickDuration) // (MYFLT secs_per_tick)
+{
+    float spt;
+    if (!PyArg_ParseTuple(args, "f", &spt ))
+    {
+        return NULL;
+    }
+    g_tt->setTickDuration(spt);
+    RetNone;
+}
+DECL(sc_loop_new) // () -> int
+{
+    if (!PyArg_ParseTuple(args, "" )) return NULL;
+    return Py_BuildValue("i", g_music->alloc());
+}
+DECL(sc_loop_delete) // (int loopIdx)
+{
+    int loopIdx;
+    if (!PyArg_ParseTuple(args, "i", &loopIdx )) return NULL;
+    g_music->destroy(loopIdx);
+    RetNone;
+}
 DECL(sc_loop_getTickf) // (int loopIdx) -> float
 {
     int idx;
@@ -941,27 +987,7 @@ DECL(sc_loop_setTickf) // (int loopIdx, float pos)
     g_music->setTickf(loopIdx, pos);
     RetNone;
 }
-DECL(sc_loop_setTickDuration) // (MYFLT secs_per_tick)
-{
-    float spt;
-    if (!PyArg_ParseTuple(args, "f", &spt ))
-    {
-        return NULL;
-    }
-    g_tt->setTickDuration(spt);
-    RetNone;
-}
-DECL(sc_adjustTick) // (MYFLT ntick)
-{
-    float spt;
-    if (!PyArg_ParseTuple(args, "f", &spt ))
-    {
-        return NULL;
-    }
-    g_tt->adjustTick(spt);
-    RetNone;
-}
-DECL(sc_loop_addScoreEvent) // (int id, int duration_in_ticks, char type, farray param)
+DECL(sc_loop_addScoreEvent) // (int loopIdx, int id, int duration_in_ticks, char type, farray param)
 {
     int loopIdx, qid, inticks, active;
     char ev_type;
@@ -992,7 +1018,7 @@ DECL(sc_loop_addScoreEvent) // (int id, int duration_in_ticks, char type, farray
     assert(!"not reached");
     return NULL;
 }
-DECL(sc_loop_delScoreEvent) // (int id)
+DECL(sc_loop_delScoreEvent) // (int loopIdx, int id)
 {
     int loopIdx, id;
     if (!PyArg_ParseTuple(args, "ii", &loopIdx, &id ))
@@ -1002,7 +1028,7 @@ DECL(sc_loop_delScoreEvent) // (int id)
     g_music->delEvent(loopIdx, id);
     RetNone;
 }
-DECL(sc_loop_updateEvent) // (int id)
+DECL(sc_loop_updateEvent) // (int loopIdx, int id, int paramIdx, float paramVal, int activate_cmd))
 {
     int loopIdx, eventId;
     int idx;
@@ -1019,35 +1045,13 @@ DECL(sc_loop_deactivate_all) // (int id)
     g_music->deactivateAll(loopIdx);
     RetNone;
 }
-DECL(sc_loop_new)
-{
-    if (!PyArg_ParseTuple(args, "" )) return NULL;
-    return Py_BuildValue("i", g_music->alloc());
-}
-DECL(sc_loop_delete)
-{
-    int loopIdx;
-    if (!PyArg_ParseTuple(args, "i", &loopIdx )) return NULL;
-    g_music->destroy(loopIdx);
-    RetNone;
-}
-DECL(sc_loop_playing) // (int tf)
+DECL(sc_loop_playing) // (int loopIdx, int tf)
 {
     int loopIdx, tf;
-    if (!PyArg_ParseTuple(args, "i", &loopIdx, &tf )) return NULL;
+    if (!PyArg_ParseTuple(args, "ii", &loopIdx, &tf )) return NULL;
     g_music->playing(loopIdx, tf);
     RetNone;
 }
-DECL (sc_inputMessage) //(const char *msg)
-{
-    char * msg;
-    if (!PyArg_ParseTuple(args, "s", &msg ))
-    {
-        return NULL;
-    }
-    g_tt->inputMessage(msg);
-    RetNone;
-}
 
 #define MDECL(s) {""#s, s, METH_VARARGS, "documentation of "#s"... nothing!"}
 static PyMethodDef SpamMethods[] = {
@@ -1062,13 +1066,13 @@ static PyMethodDef SpamMethods[] = {
 
     MDECL(sc_getTickf),
     MDECL(sc_adjustTick),
+    MDECL(sc_setTickDuration),
 
     MDECL(sc_loop_new),
     MDECL(sc_loop_delete),
     MDECL(sc_loop_getTickf),
     MDECL(sc_loop_setTickf),
     MDECL(sc_loop_setNumTicks),
-    MDECL(sc_loop_setTickDuration),
     MDECL(sc_loop_delScoreEvent),
     MDECL(sc_loop_addScoreEvent),
     MDECL(sc_loop_updateEvent),
diff --git a/Util/Clooper/aclient.so b/Util/Clooper/aclient.so
index 97c9cbb..996e9e3 100755
--- a/Util/Clooper/aclient.so
+++ b/Util/Clooper/aclient.so
diff --git a/miniTamTam/miniTamTamMain.py b/miniTamTam/miniTamTamMain.py
index f8e3232..ac134d6 100644
--- a/miniTamTam/miniTamTamMain.py
+++ b/miniTamTam/miniTamTamMain.py
@@ -70,7 +70,7 @@ class miniTamTamMain(SubActivity):
         self.drumFillin = Fillin( self.beat, self.tempo, self.rythmInstrument, self.reverb, self.drumVolume )
         self.sequencer= MiniSequencer(self.recordStateButton, self.recordOverSensitivity)
         self.loop = Loop(self.beat, sqrt( self.instVolume*0.01 ))
-        self.csnd.loopSetTempo(self.tempo)
+        self.csnd.setTempo(self.tempo)
         self.noteList = []
         time.sleep(0.001) # why?
         self.trackpad = Trackpad( self )
@@ -503,7 +503,7 @@ class miniTamTamMain(SubActivity):
         self.tempo = val
         self.beatDuration = 60.0/self.tempo
         self.ticksPerSecond = Config.TICKS_PER_BEAT*self.tempo/60.0
-        self.csnd.loopSetTempo(self.tempo)
+        self.csnd.setTempo(self.tempo)
         self.sequencer.tempo = self.tempo
         self.drumFillin.setTempo(self.tempo)
 
@@ -831,7 +831,7 @@ class miniTamTamMain(SubActivity):
             correct += ticksPerLoop
         #print "correct:: %f ticks, %f ticks in, %f expected, %f err, correct %f" % (curTick, curTicksIn, ticksIn, err, correct)
         if abs(err) > 0.25:
-            self.csnd.loopAdjustTick(-err)
+            self.csnd.adjustTick(-err)
 
 
 if __name__ == "__main__":