<CsoundSynthesizer> <CsOptions> -odac -m0 </CsOptions> <CsInstruments> ksmps = 16 nchnls = 2 0dbfs = 1 ;============================================================================; ;============================================================================; ;============================================================================; ; KARLHEINZ STOCKHAUSEN: STUDIE

II (1954) ; ;============================================================================; ;============================================================================; ; GENERIERT IN CSOUND VON JOACHIM HEINTZ ; ; VERSION 1, NOVEMBER 2009 ; ;============================================================================; ;============================================================================; ;============================================================================; ;Dies ist keine Transkription der "Studie II" Stockhausens, wie man sie nach ; ;der Partitur leicht anfertigen kann. Es ist eine Generierung smtlicher ; ;musikalischer Ereignisse in Echtzeit und aus zwei Grundlagen: ; ;1) der Folge 3 - 5 - 1 - 4 - 2, und ; ;2) einer Reihe von Entscheidungen und "Methoden" (also beschreibbaren Regeln, ;Verfahren) auf verschiedenen Ebenen, die dazu fhren, dass aus der ursprng-; ;lichen Zahlenfolge zunchst ausgedehnte Reihenfolgen oder Zahlenquadrate ; ;entstehen, dann eine Vorordnung der Tonhhen, Dauern und Lautstrken, und ; ;schlielich die Ableitung der einzelnen musikalischen Ereignisse in den fnf; ;Teilen. ; ; ; ;Wenn etwas einer beschreibbaren Regel folgt, ist es auch programmierbar. ; ;Die Nachprogrammierung des Kompositionsprozesses selbst zeigt aber auch, wie; ;vielfltig und phantasievoll die Verfahren waren, die Stockhausen hier ange-; ;wandt hat, und wie sehr die musikalische Intuition immer wieder den Aus; ;schlag gegeben hat bei der Frage, ob eine Verfahrensweise so weiterlaufen ; ;soll wie bisher oder gendert werden soll. Dieses bestndige Hinhren auf ; ;das, was entsteht, und die Bereitschaft, darauf zu reagieren mit den eigenen; ;Methoden und Verfahrensweisen: das lsst sich heute noch von diesem Stck ; ;lernen. ; ; ;Diese Arbeit wre nicht mglich gewesen ohne die umfassende Analyse von ; ;Heinz Silberhorn (Die Reihentechnik in Stockhausens Studie II, Rohrdorfer ; ;Musikverlag 1980). Es bleiben nur wenige Leerstellen; vor allem die Frage ; ;nach den Hllkurven. Ich bin davon berzeugt, dass mindestens die Hllkurven; ;fr die Teile 1 bis 4 seriell ableitbar sind. Bei den Teilen 2 und 4 sind ; ;die Fnferreihen schon sichtbar (s.u.). Ich hoffe, die Ableitungen lassen ; ;sich finden und in sptere Versionen einarbeiten. ; ; ; ;In dieser ersten Version habe ich nicht gekennzeichnet, wo Stockhausens ; ;(meist kleine) Abweichungen von den Reihenablufen bernommen werden und wo ; ;nicht. Das soll in spteren Versionen geschehen, und dem Benutzer die Wahl ; ;gelassen werden. Auch sonst habe ich noch viele Ideen fr die nchste Ver- ; ;sion. ber Korrekturen, Anregungen und Kritik (an jh at joachimheintz.de) ; ;freue ich mich und werde versuchen, sie einzuarbeiten. ; ; ; ; joachim heintz, 15.11.09 ; ; (fr QuteCsound: Courier 18, Tab 70);

;============================================================================; ;============================================================================; ; INHALTSVERZEICHNIS ; ;============================================================================; ; I. OPCODE-DEFINITIONEN ; ; A. ALLGEMEINE FUNKTIONEN ; ; B. SPEZIELLERE METHODEN FR STOCKHAUSENS STUDIE II (SS2_...) ; ; 1. ZUR GENERIERUNG DER REIHEN ; ; 2. ZU DEN GRUNDTABELLEN ; ; 3. ERZEUGUNG VON TABELLEN EINES PARAMETERS FR EINEN TEIL ; ; 4. SPEZIELLE VERFAHREN IN EINIGEN TEILEN ; ; 5. GENERIERUNG DER STARTZEITEN ; ; 6. LAUTSTRKEN UND HLLKURVEN ; ; 7. AUSLSEN DER EREIGNISSE ; ; II. GENERIERUNG DER STRUKTUREN UND KLNGE ; ; A. DIE REIHEN UND DIE ZAHLENQUADRATE ; ; B. GRUNDTABELLEN FR FREQUENZEN, DAUERN, INTENSITTEN ; ; C. DIE EREIGNISSE IN DEN EINZELNEN TEILEN ; ; 1. TEIL 1 ; ; 2. TEIL 2 ; ; 3. TEIL 3 ; ; 4. TEIL 4 ; ; 5. TEIL 5 ; ; 6. CODA ; ; 7. BERECHNUNG DER GESAMTDAUER UND AUDIO-OUTPUT ; ; 8. UNTERINSTRUMENT ZUR ERZEUGUNG EINER KLANGMISCHUNG ; ;============================================================================; ;============================================================================; ;============================================================================; ;============================================================================; ;============================================================================; ; I. OPCODE-DEFINITIONEN ; ;============================================================================; ;============================================================================; ;============================================================================; ;============================================================================; ;============================================================================; ; A. ALLGEMEINE FUNKTIONEN ; ;============================================================================; ;============================================================================; opcode TabCopyGroupIn_i, 0, iiiii ;setzt eine gruppe von werten von einer tabelle (array, liste) in eine andere. a rgumente: ;basistabelle, erster index zu lesen, wie viele indices zu lesen, zieltabelle, e rster index zu schreiben isrc, istrtindx, ihowmany, idest, istrtwrite xin ireadindx = istrtindx loop: ival tab_i ireadindx, isrc tabw_i ival, istrtwrite, idest istrtwrite = istrtwrite + 1 loop_lt ireadindx, 1, istrtindx+ihowmany, loop

endop opcode TabMkPartCp_i, i, iiio ;kopiert ihowmany werte beginnend bei index istrtindx in der basistabelle isrc z u einer neuen tabelle (beginnend bei index istrtwrite mit 0 als default) und gib t dessen bezeichnung icop zurck isrc, istrtindx, ihowmany, istrtwrite xin icop ftgen 0, 0, -(ihowmany + istrtwrite), -2, 0 ireadindx = istrtindx loop: ival tab_i ireadindx, isrc tabw_i ival, istrtwrite, icop istrtwrite = istrtwrite + 1 loop_lt ireadindx, 1, istrtindx+ihowmany, loop xout icop endop opcode TabMkCp_i, i, i ;schafft eine neue tabelle icop als kopie von isrc und gibt ihre bezeichnung zurc k isrc xin isrclen = ftlen(isrc) icop ftgen 0, 0, -isrclen, -2, 0 tableicopy icop, isrc xout icop endop opcode TabMultRecurs_i, i, iii ;setzt istart auf index 0 der neu geschaffenen tabelle ift. multipliziert die fo lgenden werte rekursiv mit imult bis isize erreicht ist, und gibt ift zurck isize, istart, imult xin ift ftgen 0, 0, -isize, -2, 0 indx = 0 loop: ival = istart * (imult ^ indx) tabw_i ival, indx, ift loop_lt indx, 1, isize, loop xout ift endop opcode TabMkNewByHop_i, i, ii ;macht eine neue tabelle indem es im abstand ihop durch ift hoppelt. gibt iftres zurck ift, ihop xin ihowmany = ftlen(ift) iftres ftgen 0, 0, -ihowmany, -2, 0 indx = 0 loop: iread = indx * ihop iread = (iread >= ihowmany ? iread % ihowmany : iread) ival tab_i iread, ift tabw_i ival, indx, iftres loop_lt indx, 1, ihowmany, loop xout iftres endop opcode TabMkTbFrmGrpMx_i, i, ii ;erzeugt eine neue tabelle die die maxima von gruppen von indices in iftsrc enthl t, die durch iftgrp angegeben werden, und gibt dessen bezeichnung iftout zurck iftsrc, iftgrp xin

iftout indxiftgrp indxabs = loop1: indxels = igrplen tab_i icomval tab_i loop2: ival icomval = indxabs =

ftgen = 0

0, 0, -ftlen(iftgrp), -2, 0 0 0 indxiftgrp, iftgrp indxabs, iftsrc; erster wert jeder gruppe als vergleich

indxabs, iftsrc (ival > icomval ? ival : icomval) indxabs + 1 loop_lt indxels, 1, igrplen, loop2 tabw_i icomval, indxiftgrp, iftout loop_lt indxiftgrp, 1, ftlen(iftgrp), loop1 xout iftout

tab_i

endop opcode TabRvrs_i, i, i ;gibt eine kopie von iftin in rcklufiger ordnung als iftout zurck iftin xin iftlen = ftlen(iftin) iftout ftgen 0, 0, -iftlen, -2, 0 tableicopy iftout, iftin indx = 0 loop: iread tab_i indx, iftin tabw_i iread, iftlen-indx-1, iftout loop_lt indx, 1, iftlen, loop xout iftout endop opcode TabValIn, i, ii ;untersucht ob irgendein wert in der tabelle itable gleich ivalsuch ist ;gibt als ergebnisindex -1 raus wenn nicht, sonst den index in dem der identisch e wert steht ivalsuch, itable xin ilen = ftlen(itable) indx init 0 loop: ival tab_i indx, itable iresult = (ival == ivalsuch ? indx : -1) indx = indx + 1 if iresult == -1 && indx < ilen igoto loop xout iresult endop opcode TableAppend2_i, i, iii ;hngt ift2 und ift3 an ift1 und gibt die resultierende tabelle ift zurck ift1, ift2, ift3 xin ilen1 = ftlen(ift1) ilen2 = ftlen(ift2) ilen3 = ftlen(ift3) ilen = ilen1+ilen2+ilen3 ift ftgen 0, 0, -ilen, -2, 0 indxread = 0 indxwrite = 0 loop1: ival tab_i indxread, ift1 tabw_i ival, indxwrite, ift indxwrite = indxwrite + 1

indxread loop2: ival indxwrite indxread loop3: ival indxwrite endop

loop_lt indxread, 1, ilen1, loop1 = 0 tab_i indxread, ift2 tabw_i ival, indxwrite, ift = indxwrite + 1 loop_lt indxread, 1, ilen2, loop2 = 0 tab_i indxread, ift3 tabw_i ival, indxwrite, ift = indxwrite + 1 loop_lt indxread, 1, ilen3, loop3 xout ift

opcode TableDumpSimp, 0, iio ;druckt den inhalt einer tabelle in einfacher weise ifn, iprec, ippr xin; tabelle, nachkommastellen, parameter pro zeile (maximum = 32, default = 10) ippr = (ippr == 0 ? 10 : ippr) iend = ftlen(ifn) indx = 0 Sformat sprintf "%%.%d f\t", iprec Sdump = "" loop: ival tab_i indx, ifn Snew sprintf Sformat, ival Sdump strcat Sdump, Snew indx = indx + 1 imod = indx % ippr if imod == 0 then puts Sdump, 1 Sdump = "" endif if indx < iend igoto loop puts Sdump, 1 endop opcode TableDumpSimpS, 0, iiSo ;druckt den inhalt einer tabelle in einfacher weise, mit einer zustzlichen zeiche nkette als 'einleitung' ifn, iprec, String, ippr xin; tabelle, nachkommastellen, zeichenkette, parame ter pro zeile (maximum = 32, default = 10) ippr = (ippr == 0 ? 10 : ippr) iend = ftlen(ifn) indx = 0 puts String, 1 Sformat sprintf "%%.%d f\t", iprec Sdump = "" loop: ival tab_i indx, ifn Snew sprintf Sformat, ival Sdump strcat Sdump, Snew indx = indx + 1 imod = indx % ippr if imod == 0 then puts Sdump, 1 Sdump = "" endif

if indx < iend igoto loop puts Sdump, 1 endop opcode ShowLED_a, 0, Sakkk ;zeigt ein audiosignal in einem outvalue-kanal, in dB oder reinen amplituden ;Soutchan: string als name des outvalue-kanals ;asig: audio signal das angezeigt werden soll ;kdispfreq: erneuerungsfrequenz der anzeige (Hz) ;idb: 1 = in dB anzeigen, 0 = in reinen amplitudes anzei (beides im bereich 0-1) ;idbrange: wenn idb=1: wie viele dB-schritte werden angezeigt (zb wenn idbrange= 36 sieht man nichts von einem signal unterhalb von -36 dB) Soutchan, asig, ktrig, kdb, kdbrange xin kdispval max_k asig, ktrig, 1 if kdb != 0 then kdb = dbfsamp(kdispval) kval = (kdbrange + kdb) / kdbrange else kval = kdispval endif if ktrig == 1 then outvalue Soutchan, kval endif endop opcode ShowOver_a, 0, Sakk ;zeigt wenn asig grer als 1 war und bleibt khold sekunden auf dieser anzeige ;Soutchan: string als name des outvalue-kanals ;kdispfreq: erneuerungsfrequenz der anzeige (Hz) Soutchan, asig, ktrig, khold xin kon init 0 ktim times kstart init 0 kend init 0 khold = (khold < .01 ? .01 : khold); avoiding too short hold times kmax max_k asig, ktrig, 1 if kon == 0 && kmax > 1 && ktrig == 1 then kstart = ktim kend = kstart + khold outvalue Soutchan, kmax kon = 1 endif if kon == 1 && ktim > kend && ktrig == 1 then outvalue Soutchan, 0 kon = 0 endif endop

;============================================================================; ;============================================================================; ; B. SPEZIELLERE METHODEN FR STOCKHAUSENS STUDIE II (SS2_...) ; ;============================================================================; ;============================================================================; ;============================================================================; ; 1. ZUR GENERIERUNG DER REIHEN ;

;============================================================================; opcode SS2_TP1Val, i, iiii ;errechnet einen neuen wert aus ival und dem transpositionsintervall interv, im rahmen von iminval und imaxval ival, interv, iminval, imaxval xin ivalneu = ival + interv ires = (ivalneu > imaxval ? ivalneu - imaxval : (ivalne u < iminval ? ivalneu + imaxval : ivalneu)) xout ires endop opcode SS2_Transp, i, iiii ;transponiert die "intervallfolge" einer reihe auf einen bestimmten anfangswert ift, iminval, imaxval, itransval xin; reihe, tiefster und hchster wert, und wert auf den transponiert werden soll ifttrans TabMkCp_i ift iftlen = ftlen(ift) indx = 0 loop: ival tab_i indx, ift indxnext = (indx + 1 < iftlen ? indx + 1 : (indx + 1) - ift len) ivalnext tab_i indxnext, ift interv = ivalnext - ival ires SS2_TP1Val itransval, interv, iminval, imaxval tabw_i itransval, indx, ifttrans itransval = ires loop_lt indx, 1, iftlen, loop xout ifttrans endop opcode SS2_Transp_R, i, i ;transponiert eine reihe indem es ihre einzelwerte im abstand ihop als anfang ei ner neuen zeile nimmt (bei ihop = 1 beginnen die zeilen der reihe 3-5-1-4-2 mit genau diesen zahlen; bei ihop = 2 beginnen die zeilen mit 3-1-2-5-4, usw), und s chreibt alles hintereinander ift xin; eine reihe mit fnf werten ires ftgen 0, 0, -(ftlen(ift) ^ 2), -2, 0 indx = 0 loop: itransval tab_i indx, ift iftres SS2_Transp ift, 1, 5, itransval TabCopyGroupIn_i iftres, 0, ftlen(ift), ires, indx * 5 loop_lt indx, 1, ftlen(ift), loop xout ires endop opcode SS2_Hop1, i, iii ;macht die zeilenanfnge fr R2-R5 aus den zeilen von R1 mit bestimmten hoppelgren ift, istart, ihop xin idest ftgen 0, 0, -5, -2, 0 TabCopyGroupIn_i ift, istart, 5, idest, 0 ifttransvals TabMkNewByHop_i idest, ihop ftfree idest, 0 xout ifttransvals endop opcode SS2_Hop2, i, ii ;analysiert den abstand in der sich die elemente von ifn2 in ifn1 befinden und g

ibt diese abstnde als neue tabelle zurck ifn1, ifn2 xin iftreslen = ftlen(ifn2) - 1 ifnabst ftgen 0, 0, -iftreslen, -2, 0 indx = 0 loop: ival1 tab_i indx, ifn2; nchster wert in ifn2 indx1 TabValIn ival1, ifn1; an welchem index steht dieser wert in ifn1 ival2 tab_i indx+1, ifn2; nchster wert in ifn2 indx2 TabValIn ival2, ifn1; an welchem index steht dieser wert in ifn1 iabst = indx2 - indx1 iabst = (iabst < 0 ? iabst + 5 : iabst) tabw_i iabst, indx, ifnabst loop_lt indx, 1, iftreslen, loop xout ifnabst endop opcode SS2_Hop3, i, iii ;nimmt eine reihe, eine abstandsreihe und das startelement und macht daraus eine neue fnferreihe ifn, ifnabst, istartval xin ilen = ftlen(ifn) iftres ftgen 0, 0, -ilen, -2, 0 tabw_i istartval, 0, iftres; istartval ist das erste re sultat indx = 0 ival = istartval; mit istartval beginnen indxifn TabValIn ival, ifn; wo ist es in ifn loop: iabst tab_i indx, ifnabst; ersten abstand nehmen indxnext = indxifn + iabst; index bei dem der nchste wert is t: im allgemeinen ... indxnext = (indxnext >= ilen ? indxnext % ilen : indxnext); ... und in wirklichkeit ival tab_i indxnext, ifn; diesen wert nehmen tabw_i ival, indx+1, iftres; in iftres schreiben indxifn = indxnext; dort weitermachen wo man aufgehrt hat loop_lt indx, 1, ilen-1, loop; 4 mal wiederholen xout iftres endop opcode SS2_HopAbst, i, i ;gibt die abstnde der elemente der zeilen 2-5 zu denen der zeile 1 in einem zahle nquadrat heraus iftquadr xin ifterste TabMkPartCp_i iftquadr, 0, 5; erste zeile iftzeil ftgen 0, 0, -5, -2, 0 iftres ftgen 0, 0, -16, -2, 0 indx = 5 iwrite = 0 loop: TabCopyGroupIn_i iftquadr, indx, 5, iftzeil, 0; zeilen 2-5 im ve rlauf des loops iftabst SS2_Hop2 ifterste, iftzeil TabCopyGroupIn_i iftabst, 0, 4, iftres, iwrite iwrite = iwrite + 4 loop_lt indx, 5, ftlen(iftquadr), loop xout iftres

endop opcode SS2_Hop, i, iiii ;macht ein neues zahlenquadrat aus einem anderen, der angabe einer zeile in ihm, der hoppelgre und der abstandsliste. gibt die bezeichnung des neuen quadrats zurck ift, istart, ihop, iftabst xin; erstes zahlenquadrat, reihenbeginn, hoppelgre, abs tandsliste iftkopf ftgen 0, 0, -5, -2, 0 TabCopyGroupIn_i ift, istart, 5, iftkopf, 0; zeile aus ift als k opfzeile des neuen quadrats ifttransvals SS2_Hop1 ift, istart, ihop; zeilenanfnge fr das quadrat aus der kopfzeile iftres ftgen 0, 0, -25, -2, 0; ergebnisliste TabCopyGroupIn_i iftkopf, 0, 5, iftres, 0; mit iftkopf als erste m element indx = 1 loop: istartval tab_i indx, ifttransvals; anfang der neuen zeile iabstzeil TabMkPartCp_i iftabst, (indx - 1) * 4, 4; zeile aus der abstands liste iftneuzeil SS2_Hop3 iftkopf, iabstzeil, istartval; ganze neue zeile TabCopyGroupIn_i iftneuzeil, 0, 5, iftres, indx * 5 loop_lt indx, 1, 5,loop xout iftres endop opcode SS2_Umk, i, i ;kehrt eine reihe quasi intervallmig um (1->5, 2->4, 4->2, 5->1) iftreihe xin iftumkehr TabMkCp_i iftreihe indx = 0 loop: ival tab_i indx, iftreihe tabw_i 6 - ival, indx, iftumkehr loop_lt indx, 1, ftlen(iftreihe), loop xout iftumkehr endop

;============================================================================; ; 2. ZU DEN GRUNDTABELLEN ; ;============================================================================; opcode SS2_IndxAusGSS, i, iii ;gibt den index fr eine tabelle aus den ;zB fr 1-1-1 ist der index=0, fr 2-1-1 igrup, ispalt, istel xin igrupval = (igrup ispstval = ispalt * indx = igrupval xout indx endop drei werten Gruppe, Spalte, Stelle ist der index=25, usw. 1) * 5 (istel - 1) + ispstval

opcode SS2_FreqsAusGTSS, iiiii, iiiii ;gibt aus den angaben fr Gruppe-Transposition-Spalte-Stelle die 5 frequenzen des tongemischs ifreqtab, igrup, itrans, ispalt, istel xin igrup = igrup + itrans - 1 indx SS2_IndxAusGSS igrup, ispalt, istel

ifreq1 ifreq2 ifreq3 ifreq4 ifreq5 endop

tab_i tab_i tab_i tab_i tab_i xout

indx, ifreqtab indx + ispalt, ifreqtab indx + (2*ispalt), ifreqtab indx + (3*ispalt), ifreqtab indx + (4*ispalt), ifreqtab ifreq1, ifreq2, ifreq3, ifreq4, ifreq5

opcode SS2_ValsAusGTSS, i, iiiii ;gibt aus den angaben fr Gruppe-Transposition-Spalte-Stelle die intensitt oder dau er ivaltab, igrup, itrans, ispalt, istel xin igrup = igrup + itrans - 1 indx SS2_IndxAusGSS igrup, ispalt, istel ival tab_i indx, ivaltab xout ival endop opcode SS2_MkGlob_dB_Tab, i, ii ;fllt eine tabelle mit werten von istart bis imin mit schritten von -1, und rckwrts , wenn imin erreicht istart, imin xin ilen = (abs(imin-istart) * 2) + 1 iftres ftgen 0, 0, -ilen, -2, 0 indx = 0 incr = 0 loop: ival = istart + incr tabw_i ival, indx, iftres if (indx < (ilen/2 - 1)) then incr = incr - 1 else incr = incr + 1 endif loop_lt indx, 1, ilen, loop xout iftres endop

;============================================================================; ; 3. ERZEUGUNG VON TABELLEN EINES PARAMETERS FR EINEN TEIL ; ;============================================================================; opcode SS2_MkParamTab_Meth1, i, iiiiiiiii ;die erste methode, um eine tabelle mit parametern fr einen teil zu bekommen: ein fester wert fr die transposition, gruppe und spalte bewegen sich wie iftcount, b ei den stellen ein wert fr jede note. ;wenn eine frequenztabelle erzeugt wird, hat sie 5 werte fr jeden ton; bei dauern oder intensitten ist es nur einer ;iftbas = frequenz-, dauern- oder lautstrkentabelle als grundvorrat ;iftcount = ftable der angibt wie oft ein bestimmter typ sich wiederholt ;iftgrup = ftable mit angabe der (untransponierten) gruppen ;itrans = transpositions"intervall" ;iftspalt = ftable mit angabe der spalten ;iftstel1-3 sind die ftables mit angaben ber die stellen (wechseln bei jedem ton, die anderen bleiben bei einem typ gleich) ;ifreqjn = 0=dauern- oder lautstrkentabelle, 1=freqtabelle iftbas, iftcount, iftgrup, itrans, iftspalt, iftstel1, iftstel2, iftstel3, ifreq jn xin

iftstel TableAppend2_i iftstel1, iftstel2, iftstel3 if ifreqjn == 0 then iftout ftgen 0, 0, -ftlen(iftstel), -2, 0; tabelle fr dauern o der dbs else iftout ftgen 0, 0, -(ftlen(iftstel) * 5), -2, 0; tabelle fr fr equenzen endif indxcount = 0 indxtonabs = 0 seq: icount tab_i indxcount, iftcount igrup tab_i indxcount, iftgrup ispalt tab_i indxcount, iftspalt indxton = 0 ton: istel tab_i indxtonabs, iftstel if ifreqjn == 0 then ival SS2_ValsAusGTSS iftbas, igrup, itrans, ispalt, istel tabw_i ival, indxtonabs, iftout else ifq1, ifq2, ifq3, ifq4, ifq5 SS2_FreqsAusGTSS iftbas, igrup, itrans, ispalt, i stel tabw_i ifq1, indxtonabs * 5, iftout tabw_i ifq2, indxtonabs * 5 + 1, iftout tabw_i ifq3, indxtonabs * 5 + 2, iftout tabw_i ifq4, indxtonabs * 5 + 3, iftout tabw_i ifq5, indxtonabs * 5 + 4, iftout endif indxtonabs = indxtonabs + 1 loop_lt indxton, 1, icount, ton loop_lt indxcount, 1, ftlen(iftcount), seq xout iftout endop opcode SS2_MkParamTab_Meth2, i, iiiiiiii ;;die zweite methode eine tabelle mit parametern fr einen teil zu bekommen: ;1. die gruppe wechselt von ton zu ton (es werden dieselben reihen benutzt wie z ur bestimmung der stellen) ;2. die transposition wechselt mit einem wert pro sequenz ;sonst alles wie bei methode 1 iftbas, iftcount, ifttrans, iftspalt, iftstel1, iftstel2, iftstel3, ifreqjn xin iftstel TableAppend2_i iftstel1, iftstel2, iftstel3 if ifreqjn == 0 then iftout ftgen 0, 0, -ftlen(iftstel), -2, 0; tabelle fr dauern o der dbs else iftout ftgen 0, 0, -(ftlen(iftstel) * 5), -2, 0; tabelle fr fr equenzen endif indxcount = 0 indxtonabs = 0 seq: icount tab_i indxcount, iftcount ispalt tab_i indxcount, iftspalt itrans tab_i indxcount, ifttrans indxton = 0 ton: istel tab_i indxtonabs, iftstel igrup = istel

if ifreqjn == 0 then ival SS2_ValsAusGTSS tabw_i else ifq1, ifq2, ifq3, ifq4, stel tabw_i tabw_i tabw_i tabw_i tabw_i endif indxtonabs = loop_lt loop_lt xout endop

iftbas, igrup, itrans, ispalt, istel ival, indxtonabs, iftout ifq5 SS2_FreqsAusGTSS iftbas, igrup, itrans, ispalt, i ifq1, ifq2, ifq3, ifq4, ifq5, indxtonabs indxtonabs indxtonabs indxtonabs indxtonabs * * * * * 5, iftout 5 + 1, iftout 5 + 2, iftout 5 + 3, iftout 5 + 4, iftout

indxtonabs + 1 indxton, 1, icount, ton indxcount, 1, ftlen(iftcount), seq iftout

;============================================================================; ; 4. SPEZIELLE VERFAHREN IN EINIGEN TEILEN ; ;============================================================================; opcode SS2_Freqtab_5, i, iiiiiiiii ;;alles wie teil 3 und 4 aber in bestimmten sequenzen wird als gruppe eine 2 ges etzt (sonst bleibt das verfahren wie es war). diese sequenzen werden hier durch die beiden fnferreihen irpl5a und irpl5b angegeben. die erste zahl der reihe beze ichnet eine position in der ersten seqenzgruppe (zwischen 1 und 5), die zweite i n der zweiten, und so weiter, fr jede der beiden reihen. ;bei der allerletzten sequenz (gruppe 5, sequenz 5) wird die spalte auf 3 gesetz t ift_Freqs, iftcount, ifttrans, iftspalt, iftstel1, iftstel2, iftstel3, iftrpl1, iftrpl2 xin iftstel TableAppend2_i iftstel1, iftstel2, iftstel3 iftfreqs ftgen 0, 0, -(ftlen(iftstel) * 5), -2, 0 indxseqgrp = 0 indxtonabs = 0 seqgrp: indxseq = 0 irplseq1 tab_i indxseqgrp, iftrpl1 irplseq2 tab_i indxseqgrp, iftrpl2 seq: indxcount = (indxseqgrp * 5) + indxseq icount tab_i indxcount, iftcount if indxseqgrp == 4 && indxseq == 4 then; beim letzten mal ispalt = 3; spalte auf 3 setzen else ispalt tab_i indxcount, iftspalt endif itrans tab_i indxcount, ifttrans indxton = 0 ton: istel tab_i indxtonabs, iftstel if indxseq+1 == irplseq1 || indxseq+1 == irplseq2 then; wenn zu ndernde sequenz igrup = 2; gruppe auf 2 setzen else igrup = istel; sonst gruppe gleich stelle endif ifq1, ifq2, ifq3, ifq4, ifq5 SS2_FreqsAusGTSS ift_Freqs, igrup, itrans, ispalt , istel

indxtonabs

tabw_i ifq1, indxtonabs tabw_i ifq2, indxtonabs tabw_i ifq3, indxtonabs tabw_i ifq4, indxtonabs tabw_i ifq5, indxtonabs = indxtonabs + 1 loop_lt indxton, 1, icount, ton loop_lt indxseq, 1, 5, seq loop_lt indxseqgrp, 1, 5, seqgrp xout iftfreqs;enthlt

* * * * *

5, iftfreqs 5 + 1, iftfreqs 5 + 2, iftfreqs 5 + 3, iftfreqs 5 + 4, iftfreqs

alle freqs dieses teils, quasi in

fnferpacks endop opcode SS2_durs2, i, iii iftdur, iftcount, iftenv xin; ursprngliche dauerntabelle, tabelle mit anzahl der elemente pro sequenz, tabelle mit der hllkurve fr je eine sequenz (1-5, siehe den opcode SS2_dbs_2) iftout ftgen 0, 0, -ftlen(iftdur), -2, 0 indxseq = 0 indxnotabs = 0 seq: indxnote = 0 iduraccum = 0 indxabsseq = indxnotabs; absoluter index in iftdur am beginn einer sequenz icount tab_i indxseq, iftcount ienv tab_i indxseq, iftenv note: if ienv == 1 || ienv == 2 then; gemeinsamer beginn: erste dauer normal, alle and eren summieren sich idurnorm tab_i indxnotabs, iftdur; dauer aus der normalen tabel le idur = idurnorm + iduraccum; reale dauer = summe der vo rherigen dauern dieser sequenz plus idurnorm iduraccum = idur; das ist der nchste wert fr die angesammelten dauern tabw_i idur, indxnotabs, iftout; dauer in iftout schrei ben else; gemeinsames ende: letzte dauer normal, alle anderen summieren sich rckwrts indxback = indxabsseq + icount - indxnote - 1; zhlt rckwrts idurnorm tab_i indxback, iftdur; dauer aus der normalen tabelle idur = idurnorm + iduraccum; reale dauer = summe der vo rherigen dauern dieser sequenz plus idurnorm iduraccum = idur; das ist der nchste wert fr die angesammelten dauern tabw_i idur, indxback, iftout; dauer in iftout schreibe n endif indxnotabs = indxnotabs + 1 loop_lt indxnote, 1, icount, note loop_lt indxseq, 1, ftlen(iftcount), seq xout iftout endop opcode SS2_durs4, i, iii iftdur, iftcount, iftenv xin; ursprngliche dauerntabelle, tabelle mit anzahl der elemente pro sequenz, tabelle mit der hllkurve fr je eine sequenz (1-5, siehe den opcode SS2_dbs_4) iftout ftgen 0, 0, -ftlen(iftdur), -2, 0 indxseq = 0

indxnotabs = 0 seq: indxnote = 0 iduraccum = 0 indxabsseq = indxnotabs; absoluter index in iftdur am beginn einer sequenz icount tab_i indxseq, iftcount ienv tab_i indxseq, iftenv note: if ienv == 1 || ienv == 2 || ienv == 5 then; gemeinsamer beginn: erste dauer nor mal, alle anderen summieren sich idurnorm tab_i indxnotabs, iftdur; dauer aus der normalen tabel le idur = idurnorm + iduraccum; reale dauer = summe der vo rherigen dauern dieser sequenz plus idurnorm iduraccum = idur; das ist der nchste wert fr die angesammelten dauern tabw_i idur, indxnotabs, iftout; dauer in iftout schrei ben else; gemeinsames ende: letzte dauer normal, alle anderen summieren sich rckwrts indxback = indxabsseq + icount - indxnote - 1; zhlt rckwrts idurnorm tab_i indxback, iftdur; dauer aus der normalen tabelle idur = idurnorm + iduraccum; reale dauer = summe der vo rherigen dauern dieser sequenz plus idurnorm iduraccum = idur; das ist der nchste wert fr die angesammelten dauern tabw_i idur, indxback, iftout; dauer in iftout schreibe n endif indxnotabs = indxnotabs + 1 loop_lt indxnote, 1, icount, note loop_lt indxseq, 1, ftlen(iftcount), seq xout iftout endop opcode SS2_durs5, i, iiii ;ndert die dauern, die bei den akkorden autreten, nach dem blichen prinzip (gemein samer anfang: erste dauer bleibt, andere dauern addieren sich; gemeinsames ende: letzte dauer bleibt, andere dauern addieren sich rckwrts) iftdur, ifttyps, iftcount, iftenv xin; ursprngliche dauerntabelle, tabelle mit de n in teil 5 vorkommenden typen (1-3), tabelle mit anzahl der elemente pro sequen z, tabelle mit der hllkurve fr je eine sequenz (1-6, siehe bei instr 1) iftout ftgen 0, 0, -ftlen(iftdur), -2, 0 indxseq = 0 indxnotabs = 0 indxenv = 0 seq: indxnote = 0 iduraccum = 0 indxabsseq = indxnotabs; absoluter index in iftdur am beginn einer sequenz icount tab_i indxseq, iftcount ityp tab_i indxseq, ifttyps note: if ityp == 2 then; wenn akkord: ienv tab_i indxenv, iftenv if ienv == 1 || ienv == 2 || ienv == 5 then; gemeinsamer beginn: erste dauer no rmal, alle anderen summieren sich idurnorm tab_i indxnotabs, iftdur; dauer aus der normalen tabel le

idur = idurnorm + iduraccum; reale dauer = summe der vo rherigen dauern dieser sequenz plus idurnorm iduraccum = idur; das ist der nchste wert fr die angesammelten dauern tabw_i idur, indxnotabs, iftout; dauer in iftout schrei ben else; gemeinsames ende: letzte dauer normal, alle anderen summieren sich rckwrts indxback = indxabsseq + icount - indxnote - 1; zhlt rckwrts idurnorm tab_i indxback, iftdur; dauer aus der normalen tabelle idur = idurnorm + iduraccum; reale dauer = summe der vo rherigen dauern dieser sequenz plus idurnorm iduraccum = idur; das ist der nchste wert fr die angesammelten dauern tabw_i idur, indxback, iftout; dauer in iftout schreibe n endif else; sonst dauer aus der normalen tabelle in iftout schreiben idur tab_i indxnotabs, iftdur tabw_i idur, indxnotabs, iftout endif indxnotabs = indxnotabs + 1 loop_lt indxnote, 1, icount, note indxenv = (ityp == 2 ? indxenv+1 : indxenv); indxenv rauf wenn wer t in gebrauch war loop_lt indxseq, 1, ftlen(iftcount), seq xout iftout endop ;============================================================================; ; 5. GENERIERUNG DER STARTZEITEN ; ;============================================================================; opcode SS2_Starts_part, i, iiiiiiiii ;hat als ersten index istartabs (den absoluten startpunkt in cm), dann die 24 we iteren startpunkte der sequenzen ;als index 25 (also 26.wert) wird der startpunkt des nchsten teils weitergegeben ift_Durs, iftcount, iftgrup, itrans, iftspalt, iftstel1, iftstel2, iftstel3, ist artabs xin iftstel TableAppend2_i iftstel1, iftstel2, iftstel3 iftstarts ftgen 0, 0, -(ftlen(iftcount)+1), -2, istartabs indxcount = 0 indxtonabs = 0 seq: icount tab_i indxcount, iftcount igrup tab_i indxcount, iftgrup ispalt tab_i indxcount, iftspalt indxton = 0 idurabs = 0 ton: istel tab_i indxtonabs, iftstel idur SS2_ValsAusGTSS ift_Durs, igrup, itrans, ispalt, istel indxtonabs = indxtonabs + 1 idurabs = idurabs + idur; dauer einer 1-5 ton gruppe in cm loop_lt indxton, 1, icount, ton istartabs = istartabs + idurabs tabw_i istartabs, indxcount+1, iftstarts loop_lt indxcount, 1, ftlen(iftcount), seq xout iftstarts endop

opcode SS2_Starts_3, i, iiiiiiiii ;hat als ersten index istartabs (den absoluten startpunkt in cm), dann die 74 we iteren startpunkte der tne ;als index 75 (also 76.wert) wird der startpunkt des nchsten teils weitergegeben ift_Durs, iftcount, iftgrup, itrans, iftspalt, iftstel1, iftstel2, iftstel3, ist artabs xin iftstel TableAppend2_i iftstel1, iftstel2, iftstel3 iftstarts ftgen 0, 0, -(ftlen(iftstel)+1), -2, istartabs indxcount = 0 indxtonabs = 0 seq: icount tab_i indxcount, iftcount igrup tab_i indxcount, iftgrup ispalt tab_i indxcount, iftspalt indxton = 0 ton: istel tab_i indxtonabs, iftstel idur SS2_ValsAusGTSS ift_Durs, igrup, itrans, ispalt, istel istartabs = istartabs + idur tabw_i istartabs, indxtonabs+1, iftstarts indxtonabs = indxtonabs + 1 loop_lt indxton, 1, icount, ton loop_lt indxcount, 1, ftlen(iftcount), seq xout iftstarts endop opcode SS2_Starts_5, i, iiiiii ;gibt die startzeiten. indx 75 (position 76) gibt den anfang der coda iftstarts5a, iftcount, ifttyps, iftdurs, iftenvtyp2, istartabs xin; vorufige star ts, tne pro sequenz, sequenztypen (1-3), dauern, hllkurventypen bei akkorden (typ= 2) (1-6), start dieses teils (cm) iftout ftgen 0, 0, -(ftlen(iftstarts5a) + 1), -2, istartabs iftmxgrpdrs TabMkTbFrmGrpMx_i iftdurs, iftcount; tabelle mit den maximalen d auern je einer sequenz indxseq = 0 indxtonabs = 0 indxenv = 0;leseindex in iftenvtyp2 (hat so viele positionen wie e s typ2-sequenzen gibt) seq: icount tab_i indxseq, iftcount indxton = 0 ityp tab_i indxseq, ifttyps istartseq = istartabs; absolute startzeit fr diese sequenz idurshift = 0 imaxdur tab_i indxseq, iftmxgrpdrs ton: istartdiff3 tab_i indxtonabs, iftstarts5a istartabs = istartabs + istartdiff3; startzeit wenn alles di rekt aus iftstarts5a (typ=3) if ityp == 1 && indxton < icount-1 then; typ1: aneinanderhngen der tne fr eine sequ enz idur1 tab_i indxtonabs, iftdurs idurshift = idurshift + idur1 istart1 = istartseq + idurshift tabw_i istart1, indxtonabs+1, iftout; wert fr den nchsten ton nach der dauer dieses tons elseif ityp == 2 then; typ2: akkorde ienv tab_i indxenv, iftenvtyp2; huelllkurve holen if (ienv == 1 || ienv == 2 || ienv == 5) && (indxton < icount-1) then; fuer gem

einsame starts istart2 = istartseq else; sonst startpunkt als differenz zur maximaldauer der sequenz idur2 tab_i indxtonabs, iftdurs istart2 = istartseq + (imaxdur - idur2) endif tabw_i istart2, indxtonabs, iftout; wert fr diesen ton aus dieser berechnung tabw_i istartabs, indxtonabs+1, iftout; wert fr den nchst en ton aus normaler tabelle else; typ=3: isolierte ereignisse, oder letzter ton einer sequenz vom typ=1 tabw_i istartabs, indxtonabs+1, iftout endif indxtonabs = indxtonabs + 1 loop_lt indxton, 1, icount, ton indxenv = (ityp == 2 ? indxenv+1 : indxenv); indxenv rauf wenn wer t in gebrauch war loop_lt indxseq, 1, ftlen(iftcount), seq xout iftout endop ;============================================================================; ; 6. LAUTSTRKEN UND HLLKURVEN ; ;============================================================================; opcode SS2_dbs_1, ii, iiiii ;nimmt an, dass die hllkurven in teil 1 folgenden regeln folgen: ;a) crescendi werden grundstzlich isoliert ausgefhrt, beginnen also bei -40 dB ;b) diminuendi werden dann isoliert ausgefhrt (enden also bei -40 dB) wenn sie ; - entweder durch ein crescendo abgelst werden ; - oder der nchste ton lauter ist (sonst wrde bei einer verbindung ein cresc ens tehen) ; - oder der aktuelle ton der letzte einer sequenz ist ;c) sonst haben diminuendi als endwert den startwert der folgenden note iftdb, iftenv, indxnotabs, indxnote, icount xin idb tab_i indxnotabs, iftdb ienv tab_i indxnotabs, iftenv if indxnote != icount-1 then; idbnext und ienvnext berechnen wenn es relevant is t idbnext tab_i indxnotabs+1, iftdb ienvnext tab_i indxnotabs+1, iftenv else ; anderfalls idiotenwerte nehmen idbnext = 0 ienvnext = 1 endif if ienv == 1 then; isoliertes crescendo (bei -40 db beginnend) idb1 = -40 idb2 = idb elseif indxnote == icount-1 || ienvnext == 1 || idbnext > idb then; isoliertes d iminuendo (bis -40 db fallend) idb1 = idb idb2 = -40 else ;wenn dim gefolgt von anderem dim und nicht letzter ton: dim geht auf start wert des nchsten dims idb1 = idb idb2 = idbnext endif xout idb1, idb2 endop

opcode SS2_dbs_2, ii, iiii idb, ienv, imaxdur, idur xin; db wert fr diesen ton, hllkurventyp (1-5), dauer des lngsten tons dieser sequenz, dauer dieses tons ;;mgliche hllkurventypen (ienv) ; 1 = gemeinsamer beginn, diminuendo, abbruch der krzeren tne hher als -40 dB wegen gemeinsamem "fluchtpunkt" ; 2 = gemeinsamer beginn, crescendo der einzeltne ; 3 = gemeinsames ende, diminuendo der einzeltne ; 4 = gemeinsames ende, crescendo, anfang der krzeren tne hher als -40 dB wegen gem einsamem "fluchtpunkt" ; 5 = gemeinsames ende, crescendo der einzeltne if ienv == 2 || ienv == 5 then; einfaches cresc ber die dauer des tons idb1 = -40 idb2 = idb elseif ienv == 3 then; einfaches dim idb1 = idb idb2 = -40 elseif ienv == 1 then; dim aber krzere tne gehen nicht bis -40 dB idb1 = idb irel = idur / imaxdur idbdiff = idb1 + 35; wieviele db zwischen dem maximum und -35 als endpunkt (da in der partitur nur raum von entsprechend 5 db zwischen -30 und -40 ) idb2 = idb1 - (irel * idbdiff) idb2 = (idb2 <= -35 ? -40 : idb2); auf wirkliches minim um setzen wenn ntig elseif ienv == 4 then; cresc aber anfang mehr oder weniger hher als -40 db idb2 = idb irel = idur / imaxdur idbdiff = idb2 + 35; wieviele db zwischen dem maximum und -35 als anfangspunkt (s.o. zur skalierung) idb1 = idb2 - (irel * idbdiff) idb1 = (idb1 <= -35 ? -40 : idb1); auf wirkliches mimin um setzen wenn ntig endif xout idb1, idb2 endop opcode SS2_dbtab_3, i, iiiiiii ;das verfahren ist dasselbe wie bei den frequenzen (s.o. opcode SS2_Freqtabs_3), nur dass hier nur ein wert pro note erzeugt wird ift_Intens, iftcount, ifttrans, iftspalt, iftstel1, iftstel2, iftstel3 xin iftstel TableAppend2_i iftstel1, iftstel2, iftstel3 iftdbs ftgen 0, 0, -ftlen(iftstel), -2, 0 indxcount = 0 indxtonabs = 0 seq: icount tab_i indxcount, iftcount ispalt tab_i indxcount, iftspalt itrans tab_i indxcount, ifttrans indxton = 0 ton: istel tab_i indxtonabs, iftstel igrup = istel idb SS2_ValsAusGTSS ift_Intens, igrup, itrans, ispalt, istel tabw_i idb, indxtonabs, iftdbs indxtonabs = indxtonabs + 1 loop_lt indxton, 1, icount, ton loop_lt indxcount, 1, ftlen(iftcount), seq

xout endop

iftdbs

opcode SS2_dbtab_4, i, iiiiiiiii ;nur die krzeste note einer sequenz bekommt ihre gewohnte dauer aus der intensitts -tabelle; die anderen ziehen den wert ihrer stellenposition von dieser db-zahl a b und setzen das ergebnis fr die nachfolgenden der seq als neuen bezugswert ift_Intens, iftcount, iftgrup, itrans, iftspalt, iftstel1, iftstel2, iftstel3, i ftenv xin iftstel TableAppend2_i iftstel1, iftstel2, iftstel3 iftdbs ftgen 0, 0, -ftlen(iftstel), -2, 0 indxcount = 0 indxtonabs = 0 seq: icount tab_i indxcount, iftcount ispalt tab_i indxcount, iftspalt igrup tab_i indxcount, iftgrup ienv tab_i indxcount, iftenv indxton = 0 idbref = 0; db-bezugswert (wird berschrieben) indxabsseq = indxtonabs; absoluter index in iftstel am beginn einer sequenz ton: if ienv == 1 || ienv == 2 || ienv == 5 then; gemeinsamer beginn: istel tab_i indxtonabs, iftstel; normale zhlung der stelle if indxton == 0 then; beim ersten mal idb SS2_ValsAusGTSS ift_Intens, igrup, itrans, ispalt, istel; db-wer t aus der tabelle holen idbref = idb; und als referenz setzen else; alle anderen idb = idbref - istel; ziehen ihre stelle als db ab idbref = idb; und setzen das als neue referenz endif tabw_i idb, indxtonabs, iftdbs; und schreiben ihn in if tdbs else; gemeinsames ende: indxback = indxabsseq + icount - indxton - 1; rckwrtigen zhler einsetzen istel tab_i indxback, iftstel; erst letzter ton einer sequen z, dann vorletzter etc if indxton == 0 then; beim ersten mal idb SS2_ValsAusGTSS ift_Intens, igrup, itrans, ispalt, istel; db-wer t aus der tabelle holen idbref = idb; und als referenz setzen else; alle anderen idb = idbref - istel; ziehen ihre stelle als db ab idbref = idb; und setzen das als neue referenz endif tabw_i idb, indxback, iftdbs; und schreiben ihn von hin ten nach vorn in die positionen dieser sequenz endif indxtonabs = indxtonabs + 1 loop_lt indxton, 1, icount, ton loop_lt indxcount, 1, ftlen(iftcount), seq xout iftdbs endop opcode SS2_dbtab_5b, i, ii ;korrigiert die werte in iftdbs_5a, die iftkorr angibt iftdbs_5a, iftkorr xin

iftout indxkorr loop: iwhich ikorrval

TabMkCp_i =

iftdbs_5a 0

tab_i indxkorr, iftkorr tab_i indxkorr+1, iftkorr tabw_i ikorrval, iwhich, iftout loop_lt indxkorr, 2, ftlen(iftkorr), loop xout iftout

endop opcode SS2_dbs_4, ii, iiii idb, ienv, imaxdur, idur xin; db wert fr diesen ton, hllkurventyp (1-5), dauer des lngsten tons dieser sequenz, dauer dieses tons ;;mgliche hllkurventypen (ienv) ; 1 = gemeinsamer beginn, diminuendo, abbruch der krzeren tne hher als -40 dB wegen gemeinsamem "fluchtpunkt" ; 2 = gemeinsamer beginn, crescendo der einzeltne ; 3 = gemeinsames ende, diminuendo der einzeltne ; 4 = gemeinsames ende, crescendo, anfang der krzeren tne hher als -40 dB wegen gem einsamem "fluchtpunkt" ; 5 = gemeinsamer beginn, diminuendo der einzeltne if ienv == 2 then; einfaches cresc ber die dauer des tons idb1 = -40 idb2 = idb elseif ienv == 3 || ienv == 5 then; einfaches dim idb1 = idb idb2 = -40 elseif ienv == 1 then; dim aber krzere tne gehen nicht bis -40 dB idb1 = idb irel = idur / imaxdur idbdiff = idb1 + 35; wieviele db zwischen dem maximum und -35 als endpunkt (da in der partitur nur raum von entsprechend 5 db zwischen -30 und -40 ) idb2 = idb1 - (irel * idbdiff) idb2 = (idb2 <= -35 ? -40 : idb2); auf wirkliches minim um setzen wenn ntig elseif ienv == 4 then; cresc aber anfang mehr oder weniger hher als -40 db idb2 = idb irel = idur / imaxdur idbdiff = idb2 + 35; wieviele db zwischen dem maximum und -35 als anfangspunkt (s.o. zur skalierung) idb1 = idb2 - (irel * idbdiff) idb1 = (idb1 <= -35 ? -40 : idb1); auf wirkliches mimin um setzen wenn ntig endif xout idb1, idb2 endop opcode SS2_dbs_5, i, iiiiii iftdb, iftcount, ifttyp, iftenv1, iftenv2, iftdur xin; tabelle mit db maxima fr e inen ton, tabelle mit anzahl der tne fr eine sequenz, notentypus (1-3), hllkurven b ei typ 1 (1-2), hllkurven bei typ 2 (1-6), dauern ;output ist hier eine tabelle nach dem schema db1, db2, db1, db2, ... (zwei wert en pro ton) iftout ftgen 0, 0, -(ftlen(iftdb) * 2), -2, 0 iftmxgrpdrs TabMkTbFrmGrpMx_i iftdur, iftcount; tabelle mit den maximalen da uern je einer sequenz indxnotabs = 0 indxseq = 0 indxenv1 = 0; leseindex in hllkurven fr typ 1 (eine pro note)

indxenv2 nz) seq: indxnot = icrescalign es vorigen dims icount imaxdur tab_i ityp note: idb idur

= 0 = anfngt tab_i tab_i tab_i tab_i

0; leseindex in hllkurven fr typ 2 (eine pro seque

0; ob ein cresc bei typ1 nicht bei dem endwert d indxseq, iftcount indxseq, iftmxgrpdrs indxseq, ifttyp indxnotabs, iftdb indxnotabs, iftdur

if ityp == 3 then; ISOLIERTE EINZELTNE idb1 = idb idb2 = -40 tabw_i idb1, indxnotabs * 2, iftout tabw_i idb2, (indxnotabs * 2) + 1, iftout elseif ityp == 2 then; AKKORDE ienv2 tab_i indxenv2, iftenv2; hllkurventyp holen if ienv2 == 2 || ienv2 == 6 then; einfaches cresc ber die dauer des tons idb1 = -40 idb2 = idb elseif ienv2 == 3 || ienv2 == 5 then; einfaches dim idb1 = idb idb2 = -40 elseif ienv2 == 1 then; dim aber krzere tne gehen nicht bis -40 dB idb1 = idb irel = idur / imaxdur idbdiff = idb1 + 35; wieviele db zwischen dem maximum und -35 als endpunkt (da in der partitur nur raum von entsprechend 5 db zwischen -30 und -40 ) idb2 = idb1 - (irel * idbdiff) idb2 = (idb2 <= -35 ? -40 : idb2); auf wirkliches minim um setzen wenn ntig elseif ienv2 == 4 then; cresc aber anfang mehr oder weniger hher als -40 db idb2 = idb irel = idur / imaxdur idbdiff = idb2 + 35; wieviele db zwischen dem maximum und -35 als anfangspunkt (s.o. zur skalierung) idb1 = idb2 - (irel * idbdiff) idb1 = (idb1 <= -35 ? -40 : idb1); auf wirkliches mimin um setzen wenn ntig endif tabw_i idb1, indxnotabs * 2, iftout tabw_i idb2, (indxnotabs * 2) + 1, iftout elseif ityp == 1 then; ANEINANDERKLEBENDE TNE ienv1 tab_i indxenv1, iftenv1 if ienv1 == 1 then; crescendo if icrescalign == 0 then; wenn kein anschluss an vorigen ton idb1 = -40; isoliert ausfhren (von -40 db beginnend) idb2 = idb else; if linked (icrescalign == 1) idbprev tab_i (indxnotabs * 2) - 1, iftout; voriges db2 aus tabelle h olen idb1 = idbprev idb2 = idb icrescalign = 0; info ber anschluss lschen

endif elseif ienv1 == 2 then; diminuendo if (indxnot != icount - 1) then; nchsten db wert und nchste hllkurve holen wenn n icht letzte note einer sequenz idbnext tab_i indxnotabs + 1, iftdb; nchster db-wert aus der tabelle ienvnext tab_i indxenv1 + 1, iftenv1; nchster wert fr hllkurve (cr esc oder dim) else ;sonst idiotenwert nehmen idbnext = 0 ienvnext = 2 endif if (indxnot == icount - 1) || (ienvnext == 2 && idbnext > idb) || (ienvnext == 1 && idbnext < idb) || (ienvnext == 1 && idb < -21) then; wenn (1) letzter ton der sequenz, oder (2) folgendes dim und dessen db-wert grer als dieser db-wert, od er (3) folgendes cresc und dessen db-wert kleiner als dieser db-wert, oder (4) f olgendes cresc und gegenwrtiger db-wert ist -22 oder kleiner: dim bis -40 db idb1 = idb idb2 = -40 else; if ienvnext == 1 then; wenn cresc anschliet auf -25 db zurck (zwei stellen: 3.3 und 4.4) idb1 = idb idb2 = -25 icrescalign = 1; zeichen fr den folgenden ton setzen else ; sonst geht dim auf startwert des nchsten tons zurck idb1 = idb idb2 = idbnext icrescalign = 1; zeichen fr den folgenden ton setzen endif endif endif tabw_i idb1, indxnotabs * 2, iftout tabw_i idb2, (indxnotabs * 2) + 1, iftout endif indxnotabs = indxnotabs + 1 indxenv1 = (ityp == 1 ? indxenv1+1 : indxenv1); indices fr i ftenv1 und iftenv 2 ... loop_lt indxnot, 1, icount, note indxenv2 = (ityp == 2 ? indxenv2+1 : indxenv2); ... weiters chalten wenn einer dran war loop_lt indxseq, 1, ftlen(iftcount), seq xout endop ;============================================================================; ; 7. AUSLSEN DER EREIGNISSE ; ;============================================================================; opcode SS2_TrigEvents_1, 0, iiiiiiii ;lst die events fr teil 1 aus und druckt sie aus wenn iprintjn=1 iftstarts, iftcounts, iftfreqs, iftdurs, iftdb, iftenv, isubinstr, iprintjn xin indxseq = 0 indxnotabs = 0 seq: indxnote = 0 idurshift tab_i indxseq, iftstarts icount tab_i indxseq, iftcounts iftout

istartseq note: ifq1 ifq2 ifq3 ifq4 ifq5 idur idb1, idb2

tab_i

indxseq, iftstarts

tab_i indxnotabs * 5, iftfreqs tab_i indxnotabs * 5 + 1, iftfreqs tab_i indxnotabs * 5 + 2, iftfreqs tab_i indxnotabs * 5 + 3, iftfreqs tab_i indxnotabs * 5 + 4, iftfreqs tab_i indxnotabs, iftdurs SS2_dbs_1 iftdb, iftenv, indxnotabs, indxnote, icount event_i "i", isubinstr, idurshift/76.2, idur/76.2, ifq1, ifq2, i fq3, ifq4, ifq5, idb1, idb2 if iprintjn == 1 then prints "%d.%d.%d.%d%t%t%.2f%t%t%.3f%t%t%.2f%t%t%.3f%t%t %.2f%t%t%.2f%t%t%.0f%t%.0f%n", 1, int(indxseq/5) + 1, (indxseq%5) + 1, indxnote + 1, idurshift, idurshift/76.2, idur, idur/76.2, ifq1, ifq5, idb1, idb2 endif idurshift = idurshift + idur indxnotabs = indxnotabs + 1 loop_lt indxnote, 1, icount, note loop_lt indxseq, 1, ftlen(iftcounts), seq endop opcode SS2_TrigEvents_2, 0, iiiiiiii ;lst die events fr teil 2 aus und druckt sie aus wenn iprintjn=1 iftstarts, iftcounts, iftfreqs, iftdurs, iftdb, iftenv, isubinstr, iprintjn xin iftmxgrpdrs TabMkTbFrmGrpMx_i iftdurs, iftcounts; tabelle mit den maximalen dauern je einer sequenz indxseq = 0 indxnotabs = 0 seq: indxnote = 0 icount tab_i indxseq, iftcounts istartseq tab_i indxseq, iftstarts ienv tab_i indxseq, iftenv imaxdur tab_i indxseq, iftmxgrpdrs note: ifq1 tab_i indxnotabs * 5, iftfreqs ifq2 tab_i indxnotabs * 5 + 1, iftfreqs ifq3 tab_i indxnotabs * 5 + 2, iftfreqs ifq4 tab_i indxnotabs * 5 + 3, iftfreqs ifq5 tab_i indxnotabs * 5 + 4, iftfreqs idur tab_i indxnotabs, iftdurs idb tab_i indxnotabs, iftdb idb1, idb2 SS2_dbs_2 idb, ienv, imaxdur, idur if ienv == 1 || ienv == 2 then; bei gemeinsamem anfang istart = istartseq else; sonst startpunkt als differenz zur maximaldauer der sequenz istart = istartseq + (imaxdur - idur) endif event_i "i", isubinstr, istart/76.2, idur/76.2, ifq1, ifq2, ifq3 , ifq4, ifq5, idb1, idb2 if iprintjn == 1 then prints "%d.%d.%d.%d%t%t%.2f%t%t%.3f%t%t%.2f%t%t%.3f%t%t %.2f%t%t%.2f%t%t%.0f%t%.0f%n", 2, int(indxseq/5) + 1, (indxseq%5) + 1, indxnote + 1, istart, istart/76.2, idur, idur/76.2, ifq1, ifq5, idb1, idb2 endif indxnotabs = indxnotabs + 1 loop_lt indxnote, 1, icount, note loop_lt indxseq, 1, ftlen(iftcounts), seq endop

opcode SS2_TrigEvents_3, 0, iiiiiii ;lst die events fr teil 3 aus und druckt sie aus wenn iprintjn=1 iftstarts, iftcounts, iftfreqs, iftdurs, iftdb, isubinstr, iprintjn xin indxseq = 0 indxnotabs = 0 seq: ;doppelter loop hier eigentlich nur wegen dem printout; sonst luft alles "no te gegen note" indxnote = 0 icount tab_i indxseq, iftcounts note: ifq1 tab_i indxnotabs * 5, iftfreqs ifq2 tab_i indxnotabs * 5 + 1, iftfreqs ifq3 tab_i indxnotabs * 5 + 2, iftfreqs ifq4 tab_i indxnotabs * 5 + 3, iftfreqs ifq5 tab_i indxnotabs * 5 + 4, iftfreqs idur tab_i indxnotabs, iftdurs idb1 tab_i indxnotabs, iftdb idb2 = -40 istart tab_i indxnotabs, iftstarts event_i "i", isubinstr, istart/76.2, idur/76.2, ifq1, ifq2, ifq3 , ifq4, ifq5, idb1, idb2 if iprintjn == 1 then prints "%d.%d.%d.%d%t%t%.2f%t%t%.3f%t%t%.2f%t%t%.3f%t%t %.2f%t%t%.2f%t%t%.0f%t%.0f%n", 3, int(indxseq/5) + 1, (indxseq%5) + 1, indxnote + 1, istart, istart/76.2, idur, idur/76.2, ifq1, ifq5, idb1, idb2 endif indxnotabs = indxnotabs + 1 loop_lt indxnote, 1, icount, note loop_lt indxseq, 1, ftlen(iftcounts), seq endop opcode SS2_TrigEvents_4, 0, iiiiiiii ;lst die events fr teil 4 aus und druckt sie aus wenn iprintjn=1 iftstarts, iftcounts, iftfreqs, iftdurs, iftdb, iftenv, isubinstr, iprintjn xin iftmxgrpdrs TabMkTbFrmGrpMx_i iftdurs, iftcounts; tabelle mit den maximalen dauern je einer sequenz indxseq = 0 indxnotabs = 0 seq: indxnote = 0 icount tab_i indxseq, iftcounts istartseq tab_i indxseq, iftstarts ienv tab_i indxseq, iftenv imaxdur tab_i indxseq, iftmxgrpdrs note: ifq1 tab_i indxnotabs * 5, iftfreqs ifq2 tab_i indxnotabs * 5 + 1, iftfreqs ifq3 tab_i indxnotabs * 5 + 2, iftfreqs ifq4 tab_i indxnotabs * 5 + 3, iftfreqs ifq5 tab_i indxnotabs * 5 + 4, iftfreqs idur tab_i indxnotabs, iftdurs idb tab_i indxnotabs, iftdb idb1, idb2 SS2_dbs_4 idb, ienv, imaxdur, idur if ienv == 1 || ienv == 2 || ienv == 5 then; bei gemeinsamem anfang istart = istartseq else; sonst startpunkt als differenz zur maximaldauer der sequenz istart = istartseq + (imaxdur - idur) endif event_i "i", isubinstr, istart/76.2, idur/76.2, ifq1, ifq2, ifq3

, ifq4, ifq5, idb1, idb2 if iprintjn == 1 then prints "%d.%d.%d.%d%t%t%.2f%t%t%.3f%t%t%.2f%t%t%.3f%t%t %.2f%t%t%.2f%t%t%.0f%t%.0f%n", 4, int(indxseq/5) + 1, (indxseq%5) + 1, indxnote + 1, istart, istart/76.2, idur, idur/76.2, ifq1, ifq5, idb1, idb2 endif indxnotabs = indxnotabs + 1 loop_lt indxnote, 1, icount, note loop_lt indxseq, 1, ftlen(iftcounts), seq endop opcode SS2_TrigEvents_5, 0, iiiiiii ;lst die events fr teil 5 aus und druckt sie aus wenn iprintjn=1 iftstarts, iftfreqs, iftdurs, iftdbs, iftcount, isubinstr, iprintjn xin indxnotabs = 0 indxseq = 0 seq: indxnote = 0 icount tab_i indxseq, iftcount note: istart tab_i indxnotabs, iftstarts ifq1 tab_i indxnotabs * 5, iftfreqs ifq2 tab_i indxnotabs * 5 + 1, iftfreqs ifq3 tab_i indxnotabs * 5 + 2, iftfreqs ifq4 tab_i indxnotabs * 5 + 3, iftfreqs ifq5 tab_i indxnotabs * 5 + 4, iftfreqs idur tab_i indxnotabs, iftdurs idb1 tab_i indxnotabs * 2, iftdbs idb2 tab_i indxnotabs * 2 + 1, iftdbs event_i "i", isubinstr, istart/76.2, idur/76.2, ifq1, ifq2, ifq3 , ifq4, ifq5, idb1, idb2 if iprintjn == 1 then prints "%d.%d.%d.%d%t%t%.2f%t%t%.3f%t%t%.2f%t%t%.3f%t%t %.2f%t%t%.2f%t%t%.0f%t%.0f%n", 5, int(indxseq/5) + 1, (indxseq%5) + 1, indxnote + 1, istart, istart/76.2, idur, idur/76.2, ifq1, ifq5, idb1, idb2 endif indxnotabs = indxnotabs + 1 loop_lt indxnote, 1, icount, note loop_lt indxseq, 1, ftlen(iftcount), seq endop opcode SS2_TrigEvents_Coda, i, iiiiiii ;lst die events fr die coda aus und druckt sie aus wenn iprintjn=1 iftdur, iftfreq, iftdbs, iftser, istart, isubinstr, iprintjn xin indx = 0 loop: iserval tab_i indx, iftser ifq1, ifq2, ifq3, ifq4, ifq5 SS2_FreqsAusGTSS iftfreq, 1, 1, 1, iserval idur SS2_ValsAusGTSS iftdur, 1, 1, 5, iserval idb SS2_ValsAusGTSS iftdbs, 1, 2, 1, iserval ;hllkurven if iserval > 3 then; reihe hat 4 oder 5: crescendo if idb < -8 then; das ist natrlich ein halber witz, aber idb1 = -30; das erste cresc fngt bei -30 db an else idb1 = -40; das zweite dagegen bei -40 endif idb2 = idb else; diminuendo if idb < -6 then; s.o. was den witz angeht ...

idb2 else idb2 endif idb1 endif

= = =

-30 -40 idb

event_i "i", isubinstr, istart/76.2, idur/76.2, ifq1, ifq2, ifq3 , ifq4, ifq5, idb1, idb2 if iprintjn == 1 then prints "Coda.%d%t%t%.2f%t%t%.3f%t%t%.2f%t%t%.3f%t%t%.2f %t%t%.2f%t%t%.0f%t%.0f%n", indx+1, istart, istart/76.2, idur, idur/76.2, ifq1, ifq5, idb1, idb2 endif istart = istart + idur loop_lt indx, 1, ftlen(iftser), loop xout istart; zeit nach dem ende des letzten events endop ;============================================================================; ;============================================================================; ;============================================================================; ; II. GENERIERUNG DER STRUKTUREN UND KLNGE ; ;============================================================================; ;============================================================================; ;============================================================================; instr 1 ;;GUI-INPUT UND ALLGEMEINE EINSTELLUNGEN isubinstr = 10; instrument das die klnge aufhrt kprintlines invalue "printlines"; ob jede note mit ihren werten augedruckt w erden soll (0=nein, 1=ja) iprintlines = i(kprintlines) kwdmix invalue "wdmix";(zwischen 0=trocken und 1=hallig) kroomsize invalue "roomsize"; 0-1 (fr freeverb) khfdamp invalue "hfdamp"; abschwchung der hohen frequenzen (0-1) (fr freeverb) kshowdb invalue "showdb"; 0=reine amplituden, 1=db als anzeige in der GUI kdbrange invalue "dbrange"; wenn db-anzeige: welcher bereich wird angezei gt ;============================================================================; ;============================================================================; ; A. DIE REIHEN UND DIE ZAHLENQUADRATE ; ;============================================================================; ;============================================================================; iReihe ftgen 0, 0, -5, -2, 3, 5, 1, 4, 2; das einzig gegebene ifzwaf = 5 ^ (1/25); 25ste wurzel aus 5 ift_R1 SS2_Transp_R iReihe; macht aus der grundreihe das erste zahle nquadrat R1 ift_Abst_R1 SS2_HopAbst ift_R1; abstnde der elemente der zeilen 2-5 in R1 zu den elementen von zeile 1 ift_R2 SS2_Hop ift_R1, 5, 2, ift_Abst_R1; zahlenquadrat R2 ift_R3 SS2_Hop ift_R1, 10, 3, ift_Abst_R1; zahlenquadrat R3 ift_R4 SS2_Hop ift_R1, 15, 4, ift_Abst_R1; zahlenquadrat R4 ift_R5 SS2_Hop ift_R1, 20, 5, ift_Abst_R1; zahlenquadrat R5 ift_U1 SS2_Umk ift_R1; umkehrung von R1 ift_U2 SS2_Umk ift_R2; umkehrung von R2 ift_U3 SS2_Umk ift_R3; umkehrung von R3 ift_U4 SS2_Umk ift_R4; umkehrung von R4

ift_U5

SS2_Umk ift_R5; umkehrung von R5 prints "%n%nERZEUGE ZAHLENQUADRATE:%n%n" TableDumpSimpS ift_R1, 0, "\nR1:", 5 TableDumpSimpS ift_R2, 0, "R2:", 5 TableDumpSimpS ift_R3, 0, "R3:", 5 TableDumpSimpS ift_R4, 0, "R4:", 5 TableDumpSimpS ift_R5, 0, "R5:", 5 TableDumpSimpS ift_U1, 0, "U1:", 5 TableDumpSimpS ift_U2, 0, "U2:", 5 TableDumpSimpS ift_U3, 0, "U3:", 5 TableDumpSimpS ift_U4, 0, "U4:", 5 TableDumpSimpS ift_U5, 0, "U5:", 5

;============================================================================; ;============================================================================; ; B. GRUNDTABELLEN FR FREQUENZEN, DAUERN, INTENSITTEN ; ;============================================================================; ;============================================================================; ;81 frequenzen auf der basis 100 hz im verhltnis 5^(1/25) ift_Freqs TabMultRecurs_i 81, 100, ifzwaf ;dauern auf der basis 2.5 cm (0.039 sec) im selben verhltnis ift_Durs TabMultRecurs_i 61, 2.5, ifzwaf; dauern in centimetern (1 sec = 76.2 cm) ift_Durs TabRvrs_i ift_Durs; umgekehrte reihenfolge ;intensitten zwischen -30 und 0 als "hin und her" ift_Intens SS2_MkGlob_dB_Tab 0, -30 prints "%n%nERZEUGE MATERIALTABELLEN:%n%n" TableDumpSimpS ift_Freqs, 0, "\nFREQUENZEN (Hz):", 5 TableDumpSimpS ift_Durs, 2, "\nDAUERN (cm):", 5 TableDumpSimpS ift_Intens, 0, "\nINTENSITTEN (dB):", 5

;============================================================================; ;============================================================================; ; C. DIE EREIGNISSE IN DEN EINZELNEN TEILEN ; ;============================================================================; ;============================================================================; ;Ich benutze folgende, an Silberhorns Terminologie angelehnte Ausdrcke: ;a) 5 Sinustne bilden einen KLANG oder eine KLANGMISCHUNG. Jede im Verlauf ; des Stcks vorkommende Klangmischung wird als EREIGNIS, TON oder NOTE ; bezeichnet. ;b) 1-5 Tne bilden eine SEQUENZ. ;c) 5 Sequenzen bilden eine GRUPPE ODER SEQUENZGRUPPE. ;d) 5 Sequenzgruppen bilden einen TEIL. ;e) 5 Teile bilden, zusammen mit der "Coda", das ganze Stck. ; ; ; ; ; ; ; ;

;============================================================================; ; 1. TEIL 1 ; ;============================================================================; ;;eine hllkurve fr jede note in diesem teil (1=crescendo, 2=diminuendo) iftenv_1 ftgen 0, 0, -75, -2, 2, 1, 1, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2,\ 2, 1, 1, 2, 2, 2,

1, 2, 1, 2, 2, 2,

2, 1, 2, 1, 2,\ 1, 2, 1, 2, 2, 2, 1, 2, 1,\ 2, 2, 2, 1, 2, 2,

2, 1, 2, 2, 2,

1, 2, 2,

1, 2, 2, 1, 2,\

1, 2, 2, 2, 1, 2, 1, 2, 2, 2, 1, 2, 1, 2, 2 istart_1 = 0; absoluter startzeitpunkt dieses teils iftcounts_1 = ift_R5; R5 bestimmt die anzahl der elemente in j eder sequenz iftfreqs_1 SS2_MkParamTab_Meth1 ift_Freqs, iftcounts_1, ift_R1, 3, ift_R2, ift_R1, ift_R2, ift_R3, 1; liste mit allen frequenzen iftdurs_1 SS2_MkParamTab_Meth1 ift_Durs, iftcounts_1, ift_R3, 1, ift_R4, i ft_R3, ift_R4, ift_R5, 0; liste mit dauern iftdb_1 SS2_MkParamTab_Meth1 ift_Intens, iftcounts_1, ift_R2, 5, ift_R3, ift_R2, ift_R3, ift_R4, 0; liste mit intensitten iftstarts_1 SS2_Starts_part ift_Durs, iftcounts_1, ift_R4, 1, ift_U5, ift_R4 , ift_R5, ift_R1, istart_1; startzeiten (eine pro sequenz) prints "%n%n" ; TableDumpSimp iftfreqs_1, 0, 5 ; TableDumpSimp iftdurs_1, 0, 5 ; TableDumpSimp iftdb_1, 0, 5 ; TableDumpSimp iftstarts_1, 1, 5 prints "%n%nERZEUGE EVENTLISTE TEIL 1 (Events als Teil. Sequenzgruppe.Sequenz.Ton):%n%n" prints "Event%t%tStart (cm)%tStart (sec)%tDauer (cm)%tD auer (sec)%tFreqInf (Hz)%tFreqSup (Hz)%tdB1%tdB2%n" SS2_TrigEvents_1 iftstarts_1, iftcounts_1, iftfreqs_1, iftdurs_1 , iftdb_1, iftenv_1, isubinstr, iprintlines

;============================================================================; ; 2. TEIL 2 ; ;============================================================================; ;;TABELLE FR DIE MGLICHEN HLLKURVEN IN TEIL 2: ; 1 = gemeinsamer beginn, diminuendo, abbruch der krzeren tne hher als -40 dB wegen gemeinsamem "fluchtpunkt" ; 2 = gemeinsamer beginn, crescendo der einzeltne ; 3 = gemeinsames ende, diminuendo der einzeltne ; 4 = gemeinsames ende, crescendo, anfang der krzeren tne hher als -40 dB wegen gem einsamem "fluchtpunkt" ; 5 = gemeinsames ende, crescendo der einzeltne iftenv_2 ftgen 0, 0, -25, -2, 1, 2, 4, 3, 5,\ 1, 4, 3, 5, 2,\ 1, 4, 5, 2, 3,\ 4, 3, 1, 5, 2,\ 3, 1, 4, 5, 2 istart_2 tab_i ftlen(iftstarts_1) - 1, iftstarts_1; absoluter s tartzeitpunkt dieses teils iftcounts_2 = ift_R1; R1 bestimmt die anzahl der elemente in j eder sequenz iftfreqs_2 SS2_MkParamTab_Meth1 ift_Freqs, iftcounts_2, ift_R2, 5, ift_R3, ift_R4, ift_R5, ift_R1, 1; liste mit allen frequenzen iftdurnorm_2 SS2_MkParamTab_Meth1 ift_Durs, iftcounts_2, ift_R4, 3, ift_R5, i ft_R1, ift_R2, ift_R3, 0; liste mit "eigentlichen" dauern iftdurs_2 SS2_durs2 iftdurnorm_2, iftcounts_2, iftenv_2; liste mit m odifizierten dauern (s.o. bei opcode SS2_durs2)

iftdb_2 SS2_MkParamTab_Meth1 ift_Intens, iftcounts_2, ift_R3, 2, ift_R4, ift_R5, ift_R1, ift_R2, 0; liste mit intensitten iftstarts_2 SS2_Starts_part ift_Durs, iftcounts_2, ift_R5, 3, ift_U1, ift_R2 , ift_R3, ift_R4, istart_2; startzeiten (1 pro seq) prints "%n%n" ; TableDumpSimp iftfreqs_2, 0, 5 ; TableDumpSimp iftdurs_2, 2, 5 ; TableDumpSimp iftdb_2, 0, 5 ; TableDumpSimp iftstarts_2, 1, 5 prints "%n%nERZEUGE EVENTLISTE TEIL 2 (Events als Teil. Sequenzgruppe.Sequenz.Ton):%n%n" prints "Event%t%tStart (cm)%tStart (sec)%tDauer (cm)%tD auer (sec)%tFreqInf (Hz)%tFreqSup (Hz)%tdB1%tdB2%n"; SS2_TrigEvents_2 iftstarts_2, iftcounts_2, iftfreqs_2, iftdurs_2 , iftdb_2, iftenv_2, isubinstr, iprintlines ;============================================================================; ; 3. TEIL 3 ; ;============================================================================; istart_3 tab_i ftlen(iftstarts_2) - 1, iftstarts_2; absoluter s tartzeitpunkt dieses teils iftcounts_3 = ift_R2; R2 bestimmt die anzahl der elemente in j eder sequenz iftfreqs_3 SS2_MkParamTab_Meth2 ift_Freqs, iftcounts_3, ift_R3, ift_R4, ift _R2, ift_R3, ift_R4, 1; liste mit allen frequenzen iftdurs_3 SS2_MkParamTab_Meth1 ift_Durs, iftcounts_3, ift_R5, 4, ift_R1, i ft_R4, ift_R5, ift_R1, 0; liste mit dauern iftdb_3 SS2_MkParamTab_Meth2 ift_Intens, iftcounts_3, ift_R4, ift_R5, ift_R4, if t_R5, ift_R1, 0; liste mit intensitten iftstarts_3 SS2_Starts_3 ift_Durs, iftcounts_3, ift_R1, 4, ift_U2, ift_R5, i ft_R1, ift_R2, istart_3; startzeiten (eine pro note) ; prints "%n%n" ; TableDumpSimp iftfreqs_3, 0, 5 ; TableDumpSimp iftdurs_3, 2, 5 ; TableDumpSimp iftdb_3, 0, 5 ; TableDumpSimp iftstarts_3, 1, 5 prints "%n%nERZEUGE EVENTLISTE TEIL 3 (Events als Teil. Sequenzgruppe.Sequenz.Ton):%n%n" prints "Event%t%tStart (cm)%tStart (sec)%tDauer (cm)%tD auer (sec)%tFreqInf (Hz)%tFreqSup (Hz)%tdB1%tdB2%n" SS2_TrigEvents_3 iftstarts_3, iftcounts_3, iftfreqs_3, iftdurs_3 , iftdb_3, isubinstr, iprintlines ;============================================================================; ; 4. TEIL 4 ; ;============================================================================; ;;TABELLE FR DIE MGLICHEN HLLKURVEN IN TEIL 4: ; 1 = gemeinsamer beginn, diminuendo, abbruch der krzeren tne hher als -40 dB wegen gemeinsamem "fluchtpunkt" ; 2 = gemeinsamer beginn, crescendo der einzeltne ; 3 = gemeinsames ende, diminuendo der einzeltne ; 4 = gemeinsames ende, crescendo, anfang der krzeren tne hher als -40 dB wegen gem einsamem "fluchtpunkt" ; 5 = gemeinsamer beginn, diminuendo der einzeltne (dies der einzige unterschied zu den in teil 2 gebrauchten formen) iftenv_4 ftgen 0, 0, -25, -2, 2, 5, 4, 3, 1,\

2, 2, 2, 2,

1, 3, 5, 3,

5, 1, 1, 5,

4, 4, 3, 1,

3,\ 5,\ 4,\ 4

istart_4 tab_i ftlen(iftstarts_3) - 1, iftstarts_3; absoluter s tartzeitpunkt dieses teils iftcounts_4 = ift_R3; R3 bestimmt die anzahl der elemente in j eder sequenz iftfreqs_4 SS2_MkParamTab_Meth2 ift_Freqs, iftcounts_4, ift_R4, ift_R5, ift _R5, ift_R1, ift_R2, 1; liste mit allen frequenzen iftdurnorm_4 SS2_MkParamTab_Meth1 ift_Durs, iftcounts_4, ift_R1, 2, ift_R2, i ft_R2, ift_R3, ift_R4, 0; liste mit "eigentlichen" dauern iftdurs_4 SS2_durs4 iftdurnorm_4, iftcounts_4, iftenv_4; liste mit m odifizierten dauern (s.o. bei opcode SS2_durs2) iftdb_4 SS2_dbtab_4 ift_Intens, iftcounts_4, ift_R5, 1, ift_R1, ift_R1, ift_ R2, ift_R3, iftenv_4; liste mit intensitten iftstarts_4 SS2_Starts_part ift_Durs, iftcounts_4, ift_R2, 2, ift_U3, ift_R3 , ift_R4, ift_R5, istart_4; startzeiten (1 pro seq) ; prints "%n%n" ; TableDumpSimp iftfreqs_4, 0, 5 ; TableDumpSimp iftdurs_4, 2, 5 ; TableDumpSimp iftdb_4, 0, 5 ; TableDumpSimp iftstarts_4, 1, 5 prints "%n%nERZEUGE EVENTLISTE TEIL 4 (Events als Teil. Sequenzgruppe.Sequenz.Ton):%n%n" prints "Event%t%tStart (cm)%tStart (sec)%tDauer (cm)%tD auer (sec)%tFreqInf (Hz)%tFreqSup (Hz)%tdB1%tdB2%n"; SS2_TrigEvents_4 iftstarts_4, iftcounts_4, iftfreqs_4, iftdurs_4 , iftdb_4, iftenv_4, isubinstr, iprintlines

;============================================================================; ; 5. TEIL 5 ; ;============================================================================; ;;ABSOLUTE STARTZEIT (in cm) istart_5 tab_i ;;TNE PRO SEQUENZ iftcounts_5 = eder sequenz ftlen(iftstarts_4) - 1, iftstarts_4 ift_R4; R4 bestimmt die anzahl der elemente in j

;;EREIGNISTYPEN ;1 = wie in Teil 1 (Einzeltne aneinander anschlieend), 2 = wie in Teil 2 und 4 (Ak korde geimsam beginnend oder endend), 3 = wie in Teil 3 (Einzeltne isoliert) ifteventtyps_5 ftgen 0, 0, -25, -2, 3, 1, 2, 1, 2,\ 2, 3, 2, 1, 1,\ 2, 3, 1, 2, 1,\ 2, 2, 3, 1, 1,\ 2, 2, 1, 1, 3 ;;HLLKURVEN ;A) FR EREIGNISSE VOM TYP 1 (mehrere tne hintereinander mit je eigener hllkurve) ;insgesamt gibt es 10 sequenzen vom typ 1; hier durch zeilenwechsel getrennt (1= cresc, 2=dim) iftenv_5_typ1 ftgen 0, 0, -30, -2, 2,\ 1, 2, 2, 1, 2,\ 2, 2, 1, 2,\

2,\ 1, 2, 1,\ 1, 2,\ 1, 2, 2, 1,\ 2, 1, 2,\ 2, 2, 2, 2, 2,\ 1, 2 ;B) FR EREIGNISSE VOM TYP 2 (akkorde) (diesmal alle hllkurventypen, also 6) ; 1 = gemeinsamer beginn, diminuendo, abbruch der krzeren tne hher als -40 dB wegen gemeinsamem "fluchtpunkt" ; 2 = gemeinsamer beginn, crescendo der einzeltne ; 3 = gemeinsames ende, diminuendo der einzeltne ; 4 = gemeinsames ende, crescendo, anfang der krzeren tne hher als -40 dB wegen gem einsamem "fluchtpunkt" ; 5 = gemeinsamer beginn, diminuendo der einzeltne ; 6 = gemeinsames ende, crescendo der einzeltne ;insgesamt gibt es 10 sequenzen vom typ 2 (s.o. ifteventtyps_5: in jeder sequenz gruppe 2) iftenv_5_typ2 ftgen 0, 0, -10, -2, 5, 6, 3, 2, 1, 4, 2, 3, 2, 3 ;;FREQUENZEN ;eigentlich wre es so (selbe methode wie in teil 3 und 4) ;(iftfreqs_5 SS2_Freqtab_3 ift_Freqs, iftcounts_5, ift_R5, ift_R1, ift_R3, if t_R4, ift_R5) ;aber in verschiedenen sequenzen wird eine 2 an die stelle der (untransponierten ) gruppe gesetzt. ;diese sequenzen lassen sich in 2 fnferreihen darstellen (jeweils position in ein er sequenzgruppe): irpl5a ftgen 0, 0, -5, -2, 1, 4, 2, 5, 3; das macht noch eine n guten eindruck ... irpl5b ftgen 0, 0, -5, -2, 2, 2, 5, 3, 5; aber das ist gar ke ine ordentliche reihe =( ;deshalb wirds jetzt so: iftfreqs_5 SS2_Freqtab_5 ift_Freqs, iftcounts_5, ift_R5, ift_R1, ift_R3, if t_R4, ift_R5, irpl5a, irpl5b ;;DAUERN ;grundlegende dauerntabelle iftdurs_5a SS2_MkParamTab_Meth2 ift_Durs, iftcounts_5, ift_R2, ift_R3, ift_ R5, ift_R1, ift_R2, 0 ;vernderung der dauern bei akkorden (wie in teil 2 und 4) iftdurs_5 SS2_durs5 iftdurs_5a, ifteventtyps_5, iftcounts_5, iftenv_ 5_typ2 ;;STARTS iftstarts_5a SS2_MkParamTab_Meth2 ift_Durs, iftcounts_5, ift_R3, ift_U4, ift_ R1, ift_R2, ift_R3, 0 iftstarts_5 SS2_Starts_5 iftstarts_5a, iftcounts_5, ifteventtyps_5, iftdu rs_5, iftenv_5_typ2, istart_5 ;;LAUTSTRKEN iftdbs_5a SS2_MkParamTab_Meth2 ift_Intens, iftcounts_5, ift_R1, ift_R2, if t_R4, ift_R5, ift_R1, 0 ;von dieser vermutlichen Grundlage gibt es so viele Abweichungen, dass vorerst n ur eine Liste dieser Abweichungen sinnvoll: Paare aus zu-ersetzender-index und w ert-an-dieser-stelle ;(die liste knnte ziemlich reduziert werden durch anwendung einiger regeln - nchst esmal ...) iftkorrdbs_5 ftgen 0, 0, -92, -2,\

0, -22, 1, -18, 2, -17, 3, -15,\ 6, -18,\ 7, -26, 8, -27, 9, -30, 10, -29, 11 , -28,\ 12, -21, 13, -18,\ 19, -30,\ 21, -22, 22, -29, 23, -18,\ 25, -4,\ 31, -12, 32, -13, 33, -17, 34, -4,\ 36, -21, 38, -10,\ 39, -30, 40, -29, 41, -27,\ 46, -23,\ 47, -15,\ 48, -24, 50, -13,\ 53, -21, 54, -9, 55, -21, 56, -13,\ 59, -7,\ 61, -14, 62, -11, 63, -7, 64, -5,\ 66, -11, 67, -13, 68, -18, 69, -21,\ 70, -29, 71, -23,\ 73, -19 iftdbs_5a, iftkorrdbs_5 iftdbs_5b, iftcounts_5, ifteventtyps_5, iftenv_5

iftdbs_5b SS2_dbtab_5b iftdbs_5 SS2_dbs_5 _typ1, iftenv_5_typ2, iftdurs_5

;;AUSLSEN DER EREIGNISSE prints "%n%nERZEUGE EVENTLISTE TEIL 5 (Events als Teil. Sequenzgruppe.Sequenz.Ton):%n%n" prints "Event%t%tStart (cm)%tStart (sec)%tDauer (cm)%tD auer (sec)%tFreqInf (Hz)%tFreqSup (Hz)%tdB1%tdB2%n" SS2_TrigEvents_5 iftstarts_5, iftfreqs_5, iftdurs_5, iftdbs_5, i ftcounts_5, isubinstr, iprintlines ; ; ; ; ; ; TableDumpSimp TableDumpSimp TableDumpSimp TableDumpSimp TableDumpSimp TableDumpSimp iftfreqs_5, 0, 5 iftdurs_5, 2, 5 iftstarts_5a, 1, 5 iftstarts_5, 1, 5 iftdbs_5b, 0, 5 iftdbs_5, 0, 10

;============================================================================; ; 6. CODA ; ;============================================================================; istart_coda tab_i ftlen(iftstarts_5) - 1, iftstarts_5 prints "%n%nERZEUGE EVENTLISTE CODA (Events als Teil.Se quenzgruppe.Sequenz.Ton):%n%n" prints "Event%t%tStart (cm)%tStart (sec)%tDauer (cm)%tD auer (sec)%tFreqInf (Hz)%tFreqSup (Hz)%tdB1%tdB2%n" iend SS2_TrigEvents_Coda ift_Durs, ift_Freqs, ift_Intens, iReihe, ist art_coda, isubinstr, iprintlines ;============================================================================; ; 7. BERECHNUNG DER GESAMTDAUER UND AUDIO-OUTPUT ; ;============================================================================; ;; reine gesamtdauern plus nachhallzeit berechnen p3 = (iend / 76.2) + 5

;; trockenes signal von instr 10 empfangen und mit verhallung mischen gadryL init 0 gadryR init 0 awetL, awetR freeverb gadryL, gadryR, kroomsize, khfdamp aoutL = (1-kwdmix) * gadryL + (kwdmix * awetL) aoutR = (1-kwdmix) * gadryR + (kwdmix * awetR) outs aoutL, aoutR ;; an die GUI schicken kTrigDisp metro 10 ShowLED_a "outL", aoutL, kTrigDisp, kshowdb, kdbrange ShowLED_a "outR", aoutR, kTrigDisp, kshowdb, kdbrange ShowOver_a "outLover", aoutL, kTrigDisp, 2 ShowOver_a "outRover", aoutR, kTrigDisp, 2 ;; globales audio zurcksetzen gadryL = 0 gadryR = 0 endin ;============================================================================; ; 8. UNTERINSTRUMENT ZUR ERZEUGUNG EINER KLANGMISCHUNG ; ;============================================================================; instr 10 ifreq1 = p4 ifreq2 = p5 ifreq3 = p6 ifreq4 = p7 ifreq5 = p8 idb1 = p9; -dB am anfang idb2 = p10; -dB am ende kpanwidth invalue "panwidth"; 0=mono, 1=breites stereopanorama (tief=links , hoch=rechts) kampcorr invalue "vol"; lautstrkefaktor (je nach hallanteil einstellen) adb linseg idb1, p3, idb2 aenv linen ampdb(adb), .01, p3, .01 a1 oscili aenv*kampcorr, ifreq1, 1 a2 oscili aenv*kampcorr, ifreq2, 1 a3 oscili aenv*kampcorr, ifreq3, 1 a4 oscili aenv*kampcorr, ifreq4, 1 a5 oscili aenv*kampcorr, ifreq5, 1 aout sum a1, a2, a3, a4, a5 ;stereo-panorama irel = (log(ifreq1/100) / log(5)) * 25; ergibt werte zwischen 0=tiefste und 60=hc hste frequenz ipan = irel / 60; 0-1 kpan = (ipan * kpanwidth) + (1 - kpanwidth) / 2; spreizung um 0.5 als zentrum je nach kpanwidth aL, aR pan2 aout, kpan gadryL = gadryL+aL gadryR = gadryR+aR endin </CsInstruments> <CsScore> f 1 0 4096 10 1; sinus i 1 0 1; p3 wird intern berechnet e </CsScore> </CsoundSynthesizer>

<MacOptions> Version: 3 Render: Real Ask: Yes Functions: ioObject Listing: Window WindowBounds: 400 22 421 728 CurrentView: io IOViewEdit: On Options: -b128 -A -s -m167 -R </MacOptions> <MacGUI> ioView background {43690, 43690, 32639} ioText {24, 86} {365, 249} label 0.000000 0.00100 "" center "Lucida Grande" 16 { 0, 0, 0} {65280, 65280, 65280} nobackground border Hall (freeverb) ioText {24, 364} {365, 180} label 0.000000 0.00100 "" center "Lucida Grande" 16 {0, 0, 0} {65280, 65280, 65280} nobackground border Panorama und Lautstrke ioSlider {31, 507} {250, 29} 0.000000 0.500000 0.200000 vol ioText {155, 475} {97, 32} label 0.000000 0.00100 "" center "Lucida Grande" 12 { 0, 0, 0} {65280, 65280, 65280} nobackground noborder Lautstrke ioMeter {28, 558} {336, 22} {0, 59904, 0} "out1_post" 0.363636 "outL" 0.000000 f ill 1 0 mouse ioMeter {362, 558} {27, 22} {50176, 3584, 3072} "outLover" 0.000000 "outLover" 0 .000000 fill 1 0 mouse ioMeter {28, 585} {336, 22} {0, 59904, 0} "out2_post" 0.526316 "outR" 0.000000 f ill 1 0 mouse ioMeter {362, 585} {27, 22} {50176, 3584, 3072} "outRover" 0.000000 "outRover" 0 .000000 fill 1 0 mouse ioSlider {126, 145} {160, 31} 0.000000 1.000000 0.443750 wdmix ioText {28, 144} {97, 32} label 0.000000 0.00100 "" center "Lucida Grande" 12 {0 , 0, 0} {65280, 65280, 65280} nobackground noborder Trocken ioText {288, 145} {97, 31} label 0.000000 0.00100 "" center "Lucida Grande" 12 { 0, 0, 0} {65280, 65280, 65280} nobackground noborder Verhallt ioText {148, 116} {110, 29} label 0.000000 0.00100 "" center "Lucida Grande" 12 {0, 0, 0} {65280, 65280, 65280} nobackground noborder Mischung ioSlider {128, 211} {160, 31} 0.000000 1.000000 0.525000 roomsize ioText {30, 210} {97, 32} label 0.000000 0.00100 "" center "Lucida Grande" 12 {0 , 0, 0} {65280, 65280, 65280} nobackground noborder Klein ioText {290, 211} {97, 31} label 0.000000 0.00100 "" center "Lucida Grande" 12 { 0, 0, 0} {65280, 65280, 65280} nobackground noborder Gro ioText {146, 177} {110, 30} label 0.000000 0.00100 "" center "Lucida Grande" 12 {0, 0, 0} {65280, 65280, 65280} nobackground noborder Raumgre ioSlider {128, 279} {160, 31} 0.000000 1.000000 0.456250 hfdamp ioText {30, 278} {97, 32} label 0.000000 0.00100 "" center "Lucida Grande" 12 {0 , 0, 0} {65280, 65280, 65280} nobackground noborder Nein ioText {290, 279} {97, 31} label 0.000000 0.00100 "" center "Lucida Grande" 12 { 0, 0, 0} {65280, 65280, 65280} nobackground noborder Ja ioText {31, 245} {352, 31} label 0.000000 0.00100 "" center "Lucida Grande" 12 { 0, 0, 0} {65280, 65280, 65280} nobackground noborder Abschwchung der hohen Freque nzen ioSlider {150, 428} {132, 32} 0.000000 1.000000 1.000000 panwidth ioText {27, 429} {122, 32} label 0.000000 0.00100 "" center "Lucida Grande" 12 { 0, 0, 0} {65280, 65280, 65280} nobackground noborder Eng (Mono) ioText {284, 429} {97, 31} label 0.000000 0.00100 "" center "Lucida Grande" 12 { 0, 0, 0} {65280, 65280, 65280} nobackground noborder Weit ioText {28, 396} {352, 31} label 0.000000 0.00100 "" center "Lucida Grande" 12 { 0, 0, 0} {65280, 65280, 65280} nobackground noborder Stereopanorama ioText {281, 506} {98, 31} display 0.000000 0.00100 "vol" center "Lucida Grande" 12 {0, 0, 0} {65280, 65280, 65280} nobackground noborder 0.2000 ioText {24, 8} {366, 78} label 0.000000 0.00100 "" center "Lucida Grande" 16 {0,

0, 0} {65280, 65280, 65280} nobackground noborder KARLHEINZ STOCKHAUSEN: STUDIE IIIn Csound generiert von Joachim HeintzVersion 1, November 2009 ioCheckbox {30, 659} {20, 20} on printlines ioText {54, 655} {352, 31} label 0.000000 0.00100 "" left "Lucida Grande" 12 {0, 0, 0} {65280, 65280, 65280} nobackground noborder Alle Klangereignisse in der K onsole ausgeben ioText {309, 615} {80, 25} editnum 40.000000 0.100000 "dbrange" left "Lucida Gra nde" 8 {0, 0, 0} {65280, 65280, 65280} nobackground noborder 40.000000 ioText {230, 614} {80, 26} label 0.000000 0.00100 "" left "Helvetica" 12 {0, 0, 0} {65280, 65280, 65280} nobackground noborder dB-Bereich ioText {27, 616} {91, 25} label 0.000000 0.00100 "" left "Helvetica" 12 {0, 0, 0 } {65280, 65280, 65280} nobackground noborder Anzeige als ioMenu {117, 615} {109, 26} 1 303 "Amplituden,dB" showdb </MacGUI>