Test plan for Ableton Link opcodes.

Test plan for Ableton Link opcodes.

<CsoundSynthesizer>
<CsLicense>
TEST FOR ABLETON LINK OPCODES
Michael Gogins
12 January 2017
</CsLicense>
<CsOptions>
-odac
</CsOptions>

<CsInstruments>
sr=44100
kr=441
ksmps=100
nchnls=2
alwayson "LinkMonitor"

instr LinkMonitor
i_link link_create 72
printf_i "i_link: %g\n", 1, i_link
link_enable i_link, 1
k_trigger, k_beat, k_phase, k_time link_metro i_link, 4
k_peers link_peers i_link
k_tempo link_tempo_get i_link
printf "LinkMonitor: i_link: %g k_trigger: %f beat: %f k_phase: %f time: %f tempo: %f peers: %f\n", k_trigger, i_link, k_trigger, k_beat, k_phase, k_time, k_tempo, k_peers
endin

</CsInstruments>

<CsScore>
f 0 360
</CsScore>

</CsoundSynthesizer>

error: pathspec 'Opcodes/ableton_link_test.csd' did not match any file(s) known to git


added test

added test

<CsoundSynthesizer>
<CsOptions>
-d
</CsOptions>
<CsInstruments>

instr 1
kS[] init 2
kS[0] = 1
   printk2 kS[0]
endin

</CsInstruments>
<CsScore>

i1 0 1

</CsScore>
</CsoundSynthesizer>
<bsbPanel>
 Widgets
 <objectName/>
 <x>614</x>
 <y>61</y>
 <width>695</width>
 <height>747</height>
 <visible>true</visible>
 <uuid/>
 <bgcolor mode="nobackground">
  <r>231</r>
  <g>46</g>
  255
 </bgcolor>
 <bsbObject version="2" type="BSBVSlider">
  <objectName>slider1</objectName>
  <x>5</x>
  <y>5</y>
  <width>20</width>
  <height>100</height>
  <uuid>{fe924818-39b1-44b5-b240-331a49ca0049}</uuid>
  <visible>true</visible>
  <midichan>0</midichan>
  <midicc>-3</midicc>
  <minimum>0.00000000</minimum>
  <maximum>1.00000000</maximum>
  <value>0.00000000</value>
  <mode>lin</mode>
  <mouseControl act="jump">continuous</mouseControl>
  <resolution>-1.00000000</resolution>
  <randomizable group="0">false</randomizable>
 </bsbObject>
</bsbPanel>
<bsbPresets>
</bsbPresets>
<MacGUI>
ioView nobackground {59367, 11822, 65535}
ioSlider {5, 5} {20, 100} 0.000000 1.000000 0.000000 slider1
</MacGUI>

error: pathspec 'tests/commandline/test_arrays_constant_index.csd' did not match any file(s) known to git


added opencl opcode example

added opencl opcode example

<CsoundSynthesizer>
<CsOptions>
--opcode-lib=./libclops.dylib
</CsOptions>
<CsInstruments>

ksmps = 64
0dbfs = 1

instr 1
ifftsize = 2048
ihopsize = 512
ibins = 1024
asig1,adp diskin "/users/victor/audio/metheny.wav",1,0,1
fsig = pvsanal(asig1, ifftsize,ihopsize, ifftsize, 1)
asig = cladsynth(fsig,1,1,ibins)
asig = linenr(asig,0.001,0.01,0.01)
    out(asig*0.5)

endin

instr 2
ifftsize = 2048
ihopsize = 512
ibins = 1024
asig1,adp diskin "/users/victor/audio/metheny.wav",1,0,1
fsig = pvsanal(asig1, ifftsize,ihopsize, ifftsize, 1)
asig = pvsadsyn(fsig,ibins,1)
asig = linenr(asig,0.001,0.01,0.01)
    out(asig*0.5)

endin

</CsInstruments>
<CsScore>
i1 0 5
</CsScore>
</CsoundSynthesizer>

error: pathspec 'Opcodes/opencl/cladsyn.csd' did not match any file(s) known to git


Delete trapped2.csd

Delete trapped2.csd

remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/gogins/gogins.github.io.git/'


Create array_a_arithm.csd

Create array_a_arithm.csd

simple test for +=, -=, *=, /= on audio arrays

<CsoundSynthesizer>
<CsOptions>
-odac -m128
</CsOptions>
<CsInstruments>
sr = 44100
ksmps = 64
nchnls = 2
0dbfs = 1

//test for +=, -=, *=, /= on audio arrays

instr 1
 gaArr1[] init 2
 gaArr1[0] poscil .2, 400
 gaArr1[1] poscil .2, 500
 gaArr2[] init 2
 gaArr2[0] poscil .2, 600
 gaArr2[1] poscil .2, 700
endin

instr 2
 aOutArr[] = gaArr1
 aOutArr += gaArr2
 outch p4, aOutArr[p4-1]
endin

instr 3
 aOutArr[] = gaArr1
 aOutArr *= gaArr2
 outch p4, aOutArr[p4-1]
endin

instr 4
 aOutArr[] = gaArr1
 aOutArr -= gaArr1 //results in silence
 outch p4, aOutArr[p4-1]
endin

instr 5
 aOutArr[] = gaArr1
 aOutArr /= (gaArr2+1)
 outch p4, aOutArr[p4-1]
endin

</CsInstruments>
<CsScore>
i 1 0 16
i 2 0 2 1
i 2 2 2 2
i 3 4 2 1
i 3 6 2 2
i 4 8 2 1
i 4 10 2 2
i 5 12 2 1
i 5 14 2 2
</CsScore>
</CsoundSynthesizer>

error: pathspec 'tests/commandline/arrays/array_a_arithm.csd' did not match any file(s) known to git


Test plan for Ableton Link opcodes.

Test plan for Ableton Link opcodes.


no message

no message

<CsoundSynthesizer>
<CsOptions>
csound -f -h -+rtmidi=null -M0 -d -n -m7 temp.orc temp.sco
</CsOptions>
<CsInstruments>
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; O R C H E S T R A   F O R   V S T   P L U G I N   U S E
; Copyright (c) 2005 by Michael Gogins.
; All rights reserved.
;
; There is one input buss for each effect,
; and each instrument has a send to each buss.
;
; Mixer levels are set with instr 1.
;
; Numbered instruments range from 2 through 100.
;
; Effects range from 200 up.
;
; Incorporated instruments can be named and wrapped
; with numbered instrument definitions.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; HEADER
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

sr                      =                       44100
; Adjust ksmps for best balance between performance and stability.
ksmps                                   =                       30
nchnls                  =                       2
0dbfs                   =                       32767

; Note that -1 dB for float is 29205.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Tables
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Waveform for the string-pad
giwave                  ftgen                   1, 0, 8193,     10,     1, .5, .33, .25,  .0, .1,  .1, .1
gisine                  ftgen                   2, 0, 65537,    10,     1
giharpsichord           ftgen                   0, 0, 8193,     7,      -1, 1024, 1, 1024, -1 ; Kelley harpsichord.
gicosine                ftgen                   0, 0, 65537,    11,     1 ; Cosine wave. Get that noise down on the most widely used table!
giexponentialrise       ftgen                   0, 0, 8193,     5,      .001, 513, 1 ; Exponential rise.
githirteen              ftgen                   0, 0, 8193,     9,      1, .3, 0
giln                    ftgen                   0, 0, 8193,     -12,    20.0 ; Unscaled ln(I(x)) from 0 to 20.0.
gibergeman              ftgen                   0, 0, 8193,     10,     .28, 1, .74, .66, .78, .48, .05, .33, .12, .08, .01, .54, .19, .08, .05, .16, .01, .11, .3, .02, .2 ; Bergeman f1
gicookblank             ftgen                   0, 0, 8193,     10,     0 ; Blank wavetable for some Cook FM opcodes.
gicook3                 ftgen                   0, 0, 8193,     10,     1, .4, .2, .1, .1, .05
gikellyflute            ftgen                   0, 0, 8193,     10,     1, .25, .1 ; Kelley flute.
gichebychev             ftgen                   0, 0, 8193,     -7,     -1, 150, .1, 110, 0, 252, 0
giffitch1               ftgen                   0, 0, 8193,     10,     1
giffitch2               ftgen                   0, 0, 8193,     5,      1, 1024, .01
giffitch3               ftgen                   0, 0, 8193,     5,      1, 1024, .001
; Rotor Tables
gitonewheel1            ftgen                   0, 0, 8193,     10,     1, .02, .01
gitonewheel2            ftgen                   0, 0, 8193,     10,     1, 0, .2, 0, .1, 0, .05, 0, .02
; Rotating Speaker Filter Envelopes
gitonewheel3            ftgen                   0, 0, 8193,     7,      0, 110, 0, 18, 1, 18, 0, 110, 0
gitonewheel4            ftgen                   0, 0, 8193,     7,      0, 80, .2, 16, 1, 64, 1, 16, .2, 80, 0
; Distortion Tables
gitonewheel5            ftgen                   0, 0, 8193,     8,      -.8, 336, -.78,  800, -.7, 5920, .7,  800, .78, 336, .8
gitonewheel6            ftgen                   0, 0, 8193,     8       -.8, 336, -.76, 3000, -.7, 1520, .7, 3000, .76, 336, .8

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Instruments
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

                        instr                   1 ; Tone wheel organ by Mikelson
                        mididefault             60, p3
                        midinoteonoct           p4, p5
; Pitch.
ifrequency              =                       cpsoct(p4)
; Amplitude.
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5) / 16.0
; Constant-power pan.
iangle                  =                       p6 / 2.0
ijunk7                  =                       p7
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
ileftpan                =                       sqrt(2.0) / 2.0 * (cos(iangle) + sin(iangle)) * iamplitude;
irightpan               =                       sqrt(2.0) / 2.0 * (cos(iangle) - sin(iangle)) * iamplitude;
iattack                 =                       .05
isustain                =                       p3
irelease                =                       .1
iduration               =                       iattack + isustain + irelease
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linseg                  0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
iphase                  =                       p2
ikey                    =                       12 * int(p4 - 6) + 100 * (p4 - 6)
ifqc                    =                       ifrequency
; The lower tone wheels have increased odd harmonic content.
iwheel1                 =                       ((ikey - 12) > 12 ? gitonewheel1 : gitonewheel2)
iwheel2                 =                       ((ikey +  7) > 12 ? gitonewheel1 : gitonewheel2)
iwheel3                 =                        (ikey       > 12 ? gitonewheel1 : gitonewheel2)
iwheel4                 =                       1
;  Start Dur   Amp   Pitch SubFund Sub3rd Fund 2nd 3rd 4th 5th 6th 8th
;i1   0    6    200    8.04   8       8     8    8   3   2   1   0   4
asubfund                oscili                  8, .5*ifqc,      iwheel1, iphase/(ikey-12)
asub3rd                 oscili                  8, 1.4983*ifqc,  iwheel2, iphase/(ikey+7)
afund                   oscili                  8, ifqc,         iwheel3, iphase/ikey
a2nd                    oscili                  8, 2*ifqc,       iwheel4, iphase/(ikey+12)
a3rd                    oscili                  3, 2.9966*ifqc,  iwheel4, iphase/(ikey+19)
a4th                    oscili                  2, 4*ifqc,       iwheel4, iphase/(ikey+24)
a5th                    oscili                  1, 5.0397*ifqc,  iwheel4, iphase/(ikey+28)
a6th                    oscili                  0, 5.9932*ifqc,  iwheel4, iphase/(ikey+31)
a8th                    oscili                  4, 8*ifqc,       iwheel4, iphase/(ikey+36)
asignal                 =                       kdamping * (asubfund + asub3rd + afund + a2nd + a3rd + a4th + a5th + a6th + a8th)
asig1                   =                       asignal * irightpan
asig2                   =                       asignal * ileftpan
						outs					asig1, asig2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

						instr                   Xanadu1
ishift      =           .00666667               ;shift it 8/1200.
ipch        =           cpspch(p5)              ;convert parameter 5 to cps.
ioct        =           octpch(p5)              ;convert parameter 5 to oct.
kvib        oscili       1/120, ipch/50, gisine       ;vibrato
ag          pluck       2000, cpsoct(ioct+kvib), 1000, 1, 1
agleft      pluck       2000, cpsoct(ioct+ishift), 1000, 1, 1
agright     pluck       2000, cpsoct(ioct-ishift), 1000, 1, 1
kf1         expon       .1, p3, 1.0             ;exponential from 0.1 to 1.0
kf2         expon       1.0, p3, .1             ;exponential from 1.0 to 0.1
adump       delayr      2.0                     ;set delay line of 2.0 sec
atap1       deltapi     kf1                     ;tap delay line with kf1 func.
atap2       deltapi     kf2                     ;tap delay line with kf2 func.
ad1         deltap      2.0                     ;delay 2 sec.
ad2         deltap      1.1                     ;delay 1.1 sec.
            delayw      ag                      ;put ag signal into delay line.
            outs        agleft+atap1+ad1, agright+atap2+ad2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   2 ; Xanadu instr 1
                        mididefault             60, p3
                        midinoteonoct           p4, p5
                        ; print                         p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
; Envelope initialization.
iattack                 =                       0.005
isustain                =                       p3
irelease                =                       0.05
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linsegr                 0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
iduration               =                       p3 + iattack + irelease
ifrequency              =                       cpsoct(p4)
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5) / 2000.
ijunk6                  =                       p6
; Constant-power pan.
ipi                     =                       4.0 * taninv(1.0)
iradians                =                       p7 * ipi / 2.0
itheta                  =                       iradians / 2.0
; Translate angle in [-1, 1] to left and right gain factors.
irightgain              =                       (sqrt(2.0) / 2.0 * (cos(itheta) + sin(itheta))) * iamplitude
ileftgain               =                       (sqrt(2.0) / 2.0 * (cos(itheta) - sin(itheta))) * iamplitude
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
asig1, asig2            subinstr                "Xanadu1", p4, pchoct(p4)
asig1                   =                       asig1 * kdamping * irightgain
asig2                   =                       asig2 * kdamping * ileftgain
						outs					asig1, asig2
                        endin

                        instr                   Xanadu2
ishift      =           .00666667               ;shift it 8/1200.
ipch        =           cpspch(p5 - 4)              ;convert parameter 5 to cps.
ioct        =           octpch(p5)              ;convert parameter 5 to oct.
kvib        oscili       1/80, 6.1, gisine       ;vibrato
iattack                 =                       0.05
isustain                =                       p3
irelease                =                       0.05
kdamping                linseg                  0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
ag          pluck       1000, cpsoct(ioct + kvib), 1000,gisine, 1
agleft      pluck       1000, cpsoct(ioct+ishift), 1000,gisine, 1
agright     pluck       1000, cpsoct(ioct-ishift), 1000,gisine, 1
adump       delayr      0.4                     ;set delay line of 0.3 sec
ad1         deltap      0.1                     ;delay 100 msec.
ad2         deltap      0.2                     ;delay 200 msec.
            delayw      ag * kdamping                      ;put ag sign into del line.
            outs        kdamping *(agleft+ad1), kdamping*(agright+ad2)
endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   3 ; Xanadu instr 2
                        mididefault             60, p3
                        midinoteonoct           p4, p5
                        ; print                         p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
; Envelope initialization.
iattack                 =                       0.05
isustain                =                       p3
irelease                =                       0.05
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linseg                  0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
iduration               =                       p3 + iattack + irelease
ifrequency              =                       cpsoct(p4)
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5) / 600.
ijunk6                  =                       p6
; Constant-power pan.
ipi                     =                       4.0 * taninv(1.0)
iradians                =                       p7 * ipi / 2.0
itheta                  =                       iradians / 2.0
; Translate angle in [-1, 1] to left and right gain factors.
irightgain              =                       (sqrt(2.0) / 2.0 * (cos(itheta) + sin(itheta))) * iamplitude
ileftgain               =                       (sqrt(2.0) / 2.0 * (cos(itheta) - sin(itheta))) * iamplitude
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
asig1, asig2            subinstr                "Xanadu2", p4, pchoct(p4)
asig1                   =                       asig1 * kdamping * irightgain
asig2                   =                       asig2 * kdamping * ileftgain
						outs					asig1, asig2
endin

                        instr                   Xanadu3
ishift      =           .00666667               ;shift it 8/1200.
ipch        =           cpspch(p5)              ;convert parameter 5 to cps.
ioct        =           octpch(p5)              ;convert parameter 5 to oct.
kadsr       linseg      0, p3/3, 1.0, p3/3, 1.0, p3/3, 0 ;ADSR envelope
kmodi       linseg      0, p3/3, 5, p3/3, 3, p3/3, 0 ;ADSR envelope for I
kmodr       linseg      p6, p3, p7              ;r moves from p6->p7 in p3 sec.
a1          =           kmodi*(kmodr-1/kmodr)/2
a1ndx       =           abs(a1*2/20)            ;a1*2 is normalized from 0-1.
a2          =           kmodi*(kmodr+1/kmodr)/2
a3          tablei      a1ndx,giln, 1             ;lookup tbl in f3, normal index
ao1         oscili       a1, ipch, gicosine             ;cosine
a4          =           exp(-0.5*a3+ao1)
ao2         oscili       a2*ipch, ipch, gicosine        ;cosine
aoutl       oscili       1000*kadsr*a4, ao2+cpsoct(ioct+ishift), gisine ;fnl outleft
aoutr       oscili       1000*kadsr*a4, ao2+cpsoct(ioct-ishift), gisine ;fnl outright
            outs        aoutl, aoutr
            endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   4 ; Xanadu instr 3
                        mididefault             60, p3
                        midinoteonoct           p4, p5
                        ; print                         p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
; Envelope initialization.
iattack                 =                       0.05
isustain                =                       p3
irelease                =                       0.05
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linseg                  0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
iduration               =                       p3 + iattack + irelease
ifrequency              =                       cpsoct(p4)
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5) / 2400.
ijunk6                  =                       p6
; Constant-power pan.
ipi                     =                       4.0 * taninv(1.0)
iradians                =                       p7 * ipi / 2.0
itheta                  =                       iradians / 2.0
; Translate angle in [-1, 1] to left and right gain factors.
irightgain              =                       (sqrt(2.0) / 2.0 * (cos(itheta) + sin(itheta))) * iamplitude
ileftgain               =                       (sqrt(2.0) / 2.0 * (cos(itheta) - sin(itheta))) * iamplitude
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
asig1, asig2            subinstr                "Xanadu3", p4, pchoct(p4), 5.07, 0.5, 1.7
asig1                   =                       asig1 * kdamping * irightgain
asig2                   =                       asig2 * kdamping * ileftgain
						outs					asig1, asig2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   5 ; Tone wheel organ by Mikelson
                        mididefault             60, p3
                        midinoteonoct           p4, p5
; Pitch.
ifrequency              =                       cpsoct(p4)
; Amplitude.
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5) / 16.0
; Constant-power pan.
iangle                  =                       p6 / 2.0
ijunk7                  =                       p7
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
ileftpan                =                       sqrt(2.0) / 2.0 * (cos(iangle) + sin(iangle)) * iamplitude;
irightpan               =                       sqrt(2.0) / 2.0 * (cos(iangle) - sin(iangle)) * iamplitude;
iattack                 =                       .05
isustain                =                       p3
irelease                =                       .1
iduration               =                       iattack + isustain + irelease
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linseg                  0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
iphase                  =                       p2
ikey                    =                       12 * int(p4 - 6) + 100 * (p4 - 6)
ifqc                    =                       ifrequency
; The lower tone wheels have increased odd harmonic content.
iwheel1                 =                       ((ikey - 12) > 12 ? gitonewheel1 : gitonewheel2)
iwheel2                 =                       ((ikey +  7) > 12 ? gitonewheel1 : gitonewheel2)
iwheel3                 =                        (ikey       > 12 ? gitonewheel1 : gitonewheel2)
iwheel4                 =                       1
;  Start Dur   Amp   Pitch SubFund Sub3rd Fund 2nd 3rd 4th 5th 6th 8th
;i1   0    6    200    8.04   8       8     8    8   3   2   1   0   4
asubfund                oscili                  8, .5*ifqc,      iwheel1, iphase/(ikey-12)
asub3rd                 oscili                  8, 1.4983*ifqc,  iwheel2, iphase/(ikey+7)
afund                   oscili                  8, ifqc,         iwheel3, iphase/ikey
a2nd                    oscili                  8, 2*ifqc,       iwheel4, iphase/(ikey+12)
a3rd                    oscili                  3, 2.9966*ifqc,  iwheel4, iphase/(ikey+19)
a4th                    oscili                  2, 4*ifqc,       iwheel4, iphase/(ikey+24)
a5th                    oscili                  1, 5.0397*ifqc,  iwheel4, iphase/(ikey+28)
a6th                    oscili                  0, 5.9932*ifqc,  iwheel4, iphase/(ikey+31)
a8th                    oscili                  4, 8*ifqc,       iwheel4, iphase/(ikey+36)
asignal                 =                       kdamping * (asubfund + asub3rd + afund + a2nd + a3rd + a4th + a5th + a6th + a8th)
asig1                   =                       asignal * irightpan
asig2                   =                       asignal * ileftpan
						outs					asig1, asig2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   6 ; Guitar, Michael Gogins
                        ; print                         p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
                        mididefault             60, p3
                        midinoteonoct           p4, p5
iattack                 =                       .01
isustain                =                       p3
irelease                =                       .05
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linsegr                 0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
ifrequency              =                       cpsoct(p4)
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5) * 5
ijunk6                  =                       p6
; Constant-power pan.
ipi                     =                       4.0 * taninv(1.0)
iradians                =                       p7 * ipi / 2.0
itheta                  =                       iradians / 2.0
; Translate angle in [-1, 1] to left and right gain factors.
irightgain              =                       sqrt(2.0) / 2.0 * (cos(itheta) + sin(itheta))
ileftgain               =                       sqrt(2.0) / 2.0 * (cos(itheta) - sin(itheta))
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
kamp                    linseg                  0.0, iattack, iamplitude, isustain, iamplitude, irelease, 0.0
asigcomp                pluck                   kamp, 440, 440, 0, 1
asig                    pluck                   kamp, ifrequency, ifrequency, 0, 1
af1                     reson                   asig, 110, 80
af2                     reson                   asig, 220, 100
af3                     reson                   asig, 440, 80
aout                    balance                 0.6 * af1+ af2 + 0.6 * af3 + 0.4 * asig, asigcomp
kexp                    expseg                  1.0, iattack, 2.0, isustain, 1.0, irelease, 1.0
kenv                    =                       kexp - 1.0
asig1                   =                       aout * ileftgain * kenv * kdamping,
asig2                   =                       aout* irightgain * kenv * kdamping
						outs					asig1, asig2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   7 ; Harpsichord, James Kelley
                        mididefault             60, p3
                        midinoteonoct           p4, p5
                        ; print                         p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
; Envelope initialization.
iattack                 =                       0.005
isustain                =                       p3
irelease                =                       0.05
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linsegr                 0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
iduration               =                       p3 + iattack + irelease
ifrequency              =                       cpsoct(p4 + 1)
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5) * 2.0
ijunk6                  =                       p6
; Constant-power pan.
ipi                     =                       4.0 * taninv(1.0)
iradians                =                       p7 * ipi / 2.0
itheta                  =                       iradians / 2.0
; Translate angle in [-1, 1] to left and right gain factors.
irightgain              =                       sqrt(2.0) / 2.0 * (cos(itheta) + sin(itheta))
ileftgain               =                       sqrt(2.0) / 2.0 * (cos(itheta) - sin(itheta))
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
; KONTROL
kenvelope               transeg                 0, iamplitude, iduration, -3, 1.0, irelease, -2.5, 0
; AUDIO
apluck                  pluck                   iamplitude, ifrequency, ifrequency, 0, 1
aharp                   oscili                  kenvelope, ifrequency, giharpsichord
aharp2                  balance                 apluck, aharp
aoutsignal              =                       apluck + aharp2
asig1                   =                       aoutsignal * ileftgain * kdamping
asig2                   =                       aoutsignal * irightgain * kdamping
						outs					asig1, asig2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   8 ; Heavy metal model, Perry Cook
                        mididefault             60, p3
                        midinoteonoct           p4, p5
                        ; print                         p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
iattack                 =                       0.01
idecay                  =                       2.0
isustain                =                       p3
irelease                =                       0.125
                        ; xtratim                       iattack + idecay + irelease
p3                      =                       iattack + iattack + idecay + irelease
kdamping                linsegr                 0.0, iattack, 1.0, idecay + isustain, 1.0, irelease, 0.0
iindex                  =                       1
icrossfade              =                       3
ivibedepth              =                       0.02
iviberate               =                       4.8
ifn1                    =                       gisine
ifn2                    =                       giexponentialrise
ifn3                    =                       githirteen
ifn4                    =                       gisine
ivibefn                 =                       gicosine
ifrequency              =                       cpsoct(p4)
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5) * 32.0
ijunk6                  =                       p6
; Constant-power pan.
ipi                     =                       4.0 * taninv(1.0)
iradians                =                       p7 * ipi / 2.0
itheta                  =                       iradians / 2.0
; Translate angle in [-1, 1] to left and right gain factors.
irightgain              =                       sqrt(2.0) / 2.0 * (cos(itheta) + sin(itheta)) * iamplitude
ileftgain               =                       sqrt(2.0) / 2.0 * (cos(itheta) - sin(itheta)) * iamplitude
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
; AUDIO
adecay                  transeg                 0.0, iattack, 4, 1.0, idecay, -4, 0.1, irelease, -4, 0.0
asignal                 fmmetal                 0.1, ifrequency, iindex, icrossfade, ivibedepth, iviberate, ifn1, ifn2, ifn3, ifn4, ivibefn
asig1                   =                       asignal * ileftgain * kdamping * adecay
asig2                   =                       asignal * irightgain * kdamping * adecay
						outs					asig1, asig2
endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   9 ; Xing by Andrew Horner
; p4 pitch in octave.pch
; original pitch        = A6
; range                 = C6 - C7
; extended range        = F4 - C7
                        mididefault             60, p3
                        midinoteonoct           p4, p5
                        ; print                 p2, p3, p4, p5, p7, p8, p9, p10, p11
isine                   =                       1
iinstrument             =                       p1
istarttime              =                       p2
isustain                =                       p3
iattack                 =                       .005
irelease                =                       .06
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linseg                  0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
ioctave                 =                       p4
ifrequency              =                       cpsoct(ioctave)
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5) * 875.0
iphase                  =                       p6
; Constant-power pan.
ipi                     =                       4.0 * taninv(1.0)
ixpan                   =                       p7
iradians                =                       ixpan * ipi / 2.0
itheta                  =                       iradians / 2.0
; Translate angle in [-1, 1] to left and right gain factors.
irightgain              =                       sqrt(2.0) / 2.0 * (cos(itheta) + sin(itheta))
ileftgain               =                       sqrt(2.0) / 2.0 * (cos(itheta) - sin(itheta))
iypan                   =                       p8
izpan                   =                       p9
imason                  =                       p10
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11

idur                    =                       p3
ifreq                   =                       ifrequency
iamp                    =                       iamplitude
inorm                   =                       32310

aamp1                   linseg                  0,.001,5200,.001,800,.001,3000,.0025,1100,.002,2800,.0015,1500,.001,2100,.011,1600,.03,1400,.95,700,1,320,1,180,1,90,1,40,1,20,1,12,1,6,1,3,1,0,1,0
kdevamp1                linseg                  0, .05, .3, idur - .05, 0
kdev1                   oscili                  kdevamp1, 6.7, gisine, .8
amp1                    =                       aamp1 * (1 + kdev1)

aamp2                   linseg                  0,.0009,22000,.0005,7300,.0009,11000,.0004,5500,.0006,15000,.0004,5500,.0008,2200,.055,7300,.02,8500,.38,5000,.5,300,.5,73,.5,5.,5,0,1,1
kdevamp2                linseg                  0,.12,.5,idur-.12,0
kdev2                   oscili                  kdevamp2, 10.5, gisine, 0
amp2                    =                       aamp2 * (1 + kdev2)

aamp3                   linseg                  0,.001,3000,.001,1000,.0017,12000,.0013,3700,.001,12500,.0018,3000,.0012,1200,.001,1400,.0017,6000,.0023,200,.001,3000,.001,1200,.0015,8000,.001,1800,.0015,6000,.08,1200,.2,200,.2,40,.2,10,.4,0,1,0
kdevamp3                linseg                  0, .02, .8, idur - .02, 0
kdev3                   oscili                  kdevamp3, 70, gisine ,0
amp3                    =                       aamp3 * (1 + kdev3),

awt1                    oscili                  amp1, ifreq, gisine
awt2                    oscili                  amp2, 2.7 * ifreq, gisine
awt3                    oscili                  amp3, 4.95 * ifreq, gisine
asig                    =                       awt1 + awt2 + awt3
krel                    linenr                  1,0, idur, .06
asig                    =                       asig * krel * (iamp / inorm)
asig1                   =                       asig * ileftgain * kdamping *.005
asig2                   =                       asig * irightgain * kdamping *.005
						outs					asig1, asig2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   10 ; FM modulated left and right detuned chorusing, Thomas Kung
                        ; print                         p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
                        mididefault             60, p3
                        midinoteonoct           p4, p5
iattack                 =                       0.333333
irelease                =                       0.25
isustain                =                       p3
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linseg                  0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5) / 400
iphase                  =                       p6
; Constant-power pan.
; x location ranges from hard left = -1 through center = 0 to hard right = 1.
; angle of pan ranges from hard left = - pi / 2 through center = 0 to hard right = pi / 2.
ix                      =                       p7
iangle                  =                       ix * 3.14159265359 / 2.0
ileftpan                =                       sqrt(2.0) / 2.0 * (cos(iangle) + sin(iangle))
irightpan               =                       sqrt(2.0) / 2.0 * (cos(iangle) - sin(iangle))
iy                      =                       p8
iz                      =                       p9
imason                  =                       p10
ihomogeneity            =                       p11
ip6                     =                       0.3
ip7                     =                       2.2
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
; shift it.
ishift                  =                       4.0 / 12000
; convert parameter 5 to cps.
ipch                    =                       cpsoct(p4)
; convert parameter 5 to oct.
ioct                    =                       p4
; KONTROL
kadsr                   linen                   1.0, iattack, irelease, 0.01
kmodi                   linseg                  0, iattack, 5, isustain, 2, irelease, 0
; r moves from ip6 to ip7 in p3 secs.
kmodr                   linseg                  ip6, p3, ip7
; AUDIO
a1                      =                       kmodi * (kmodr - 1 / kmodr) / 2
; a1*2 is argument normalized from 0-1.
a1ndx                   =                       abs(a1 * 2 / 20)
a2                      =                       kmodi * (kmodr + 1 / kmodr) / 2
; Look up table is in f43, normalized index.
a3                      tablei                  a1ndx, giln, 1
; Cosine
ao1                     oscili                  a1, ipch, gicosine
a4                      =                       exp(-0.5 * a3 + ao1)
; Cosine
ao2                     oscili                  a2 * ipch, ipch, gicosine
; Final output left
aoutl                   oscili                  iamplitude * kadsr * a4, ao2 + cpsoct(ioct + ishift), gisine
; Final output right
aoutr                   oscili                  iamplitude * kadsr * a4, ao2 + cpsoct(ioct - ishift), gisine
asig1                   =                       ileftpan * aoutl * kdamping
asig2                   =                       irightpan * aoutr * kdamping
						outs					asig1, asig2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   11 ; String pad
; String-pad borrowed from the piece "Dorian Gray",
; http://akozar.spymac.net/music/ Modified to fit my needs
                        ; print                         p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
                        mididefault             60, p3
                        midinoteonoct           p4, p5
    ij1=p1
    ij2=p2
    ij3=p3
    ij4=p4
    ij5=p5
    ij6=p6
    ij7=p7
    ij8=p8
    ij9=p9
    ij10=p10
    ij11=p11
  ihz  = cpsoct(p4)
  idb  = p5
  ipos = p7
  iamp = ampdb(idb) * 1.5

  ; Slow attack and release
  kctrl   linseg  0, p3*0.5, iamp, p3*.5, 0
  ; Slight chorus effect
  afund   oscili   kctrl, ihz,      giwave       ; audio oscillator
  acel1   oscili   kctrl, ihz - .1, giwave       ; audio oscillator - flat
  acel2   oscili   kctrl, ihz + .1, giwave       ; audio oscillator - sharp
  asig    =   afund + acel1 + acel2

  ; Cut-off high frequencies depending on midi-velocity
  ; (larger velocity implies more brighter sound)
  asig butterlp asig, (p5-60)*40+900

  ; Panning
  ippan =       ipos*1.570796325  ; half of PI (radians of 90o angle)
  ipleft        =       cos(ippan)        ; half sign "down"
  ipright       =       sin(ippan)        ; half sign "up"
  ; print giwave,ihz,iamp,ipos,ipleft,ipright
  asig1 = asig*ipleft;
  asig2 = asig*ipright;
						outs					asig1, asig2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   12 ; Filtered chorus, Michael Bergeman
                        ; print                 p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
                        mididefault             60, p3
                        midinoteonoct           p4, p5
; Original pfields
; p1 p2 p3 p4 p5 p6 p7 p8 p9
; ins st dur db func at dec freq1 freq2
iattack                 =                       0.03
isustain                =                       p3
irelease                =                       0.52
                        ; xtratim                       iattack + irelease
p3                      =                       p3 + iattack + irelease
kdamping                linseg                  0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
ip4                     =                       p5
idb                     =                       ampdb(p5) * 1.5
ijunk6                  =                       p6
; Constant-power pan.
ipi                     =                       4.0 * taninv(1.0)
iradians                =                       p7 * ipi / 2.0
itheta                  =                       iradians / 2.0
; Translate angle in [-1, 1] to left and right gain factors.
irightgain              =                       sqrt(2.0) / 2.0 * (cos(itheta) + sin(itheta))
ileftgain               =                       sqrt(2.0) / 2.0 * (cos(itheta) - sin(itheta))
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
ip5                     =                       gibergeman
ip3                     =                       p3
ip6                     =                       p3 * .25
ip7                     =                       p3 * .75
ip8                     =                       cpsoct(p4 - .01)
ip9                     =                       cpsoct(p4 + .01)
ip10                    =                       p10
isc                     =                       idb * .333
k1                      line                    40, p3, 800
k2                      line                    440, p3, 220
k3                      linen                   isc, ip6, p3, ip7
k4                      line                    800, ip3,40
k5                      line                    220, ip3,440
k6                      linen                   isc, ip6, ip3, ip7
k7                      linen                   1, ip6, ip3, ip7
a5                      oscili                  k3, ip8, ip5
a6                      oscili                  k3, ip8 * .999, ip5
a7                      oscili                  k3, ip8 * 1.001, ip5
a1                      =                       a5 + a6 + a7
a8                      oscili                  k6, ip9, ip5
a9                      oscili                  k6, ip9 * .999, ip5
a10                     oscili                  k6, ip9 * 1.001, ip5
a11                     =                       a8 + a9 + a10
a2                      butterbp                a1, k1, 40
a3                      butterbp                a2, k5, k2 * .8
a4                      balance                 a3, a1
a12                     butterbp                a11, k4, 40
a13                     butterbp                a12, k2, k5 * .8
a14                     balance                 a13, a11
a15                     reverb2                 a4, 5, .3
a16                     reverb2                 a4, 4, .2
a17                     =                       (a15 + a4) * ileftgain * k7
a18                     =                       (a16 + a4) * irightgain * k7
asig1                   =                       a17 * kdamping
asig2                   =                       a18 * kdamping
						outs					asig1, asig2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   13 ; Plain plucked string, Michael Gogins
                        ; print                         p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
                        mididefault             60, p3
                        midinoteonoct           p4, p5
iattack                 =                       .002
isustain                =                       p3
irelease                =                       .075
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linseg                  0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
ifrequency              =                       cpsoct(p4)
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5) * 1.25
ijunk6                  =                       p6
; Constant-power pan.
ipi                     =                       4.0 * taninv(1.0)
iradians                =                       p7 * ipi / 2.0
itheta                  =                       iradians / 2.0
; Translate angle in [-1, 1] to left and right gain factors.
irightgain              =                       sqrt(2.0) / 2.0 * (cos(itheta) + sin(itheta))
ileftgain               =                       sqrt(2.0) / 2.0 * (cos(itheta) - sin(itheta))
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
kenvelope               transeg                 0, iattack, -4, iamplitude,  isustain, -4, iamplitude / 10.0, irelease, -4, 0
aexcite                 oscili                  1, 1, gisine
;asignal1               wgpluck                 ifrequency * 1.00003, 1.0, .5, .1, 10, 1000, aexcite
;asignal2               wgpluck                 ifrequency * 0.99997, 1.0, .5, .1, 10, 1000, aexcite
asignal1                pluck                   1, ifrequency, ifrequency * 1.002, 0, 1
asignal2                pluck                   1, ifrequency * 1.003, ifrequency, 0, 1
apluckout               =                       (asignal1 + asignal2) * kenvelope
asig1                   =                       ileftgain * apluckout * kdamping
asig2                   =                       irightgain * apluckout * kdamping
						outs					asig1, asig2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr 14                ; Rhodes electric piano model, Perry Cook
                        ; print                         p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
                        mididefault             60, p3
                        midinoteonoct           p4, p5
iattack                 =                       0.01
isustain                =                       p3
irelease                =                       0.125
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linsegr                 0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
iindex                  =                       4
icrossfade              =                       3
ivibedepth              =                       0.2
iviberate               =                       6
ifn1                    =                       gisine
ifn2                    =                       gicosine
ifn3                    =                       gisine
ifn4                    =                       gicookblank
ivibefn                 =                       gisine
ifrequency              =                       cpsoct(p4)
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5) * 1.25
ijunk6                  =                       p6
; Constant-power pan.
ipi                     =                       4.0 * taninv(1.0)
iradians                =                       p7 * ipi / 2.0
itheta                  =                       iradians / 2.0
; Translate angle in [-1, 1] to left and right gain factors.
irightgain              =                       sqrt(2.0) / 2.0 * (cos(itheta) + sin(itheta))
ileftgain               =                       sqrt(2.0) / 2.0 * (cos(itheta) - sin(itheta))
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
; AUDIO
asignal                 fmrhode                 iamplitude, ifrequency, iindex, icrossfade, ivibedepth, iviberate, ifn1, ifn2, ifn3, ifn4, ivibefn
asig1                   =                       ileftgain * asignal * kdamping
asig2                   =                       irightgain * asignal * kdamping
						outs					asig1, asig2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr 15                ; Tubular bell model, Perry Cook
                        ; print                         p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
                        mididefault             60, p3
                        midinoteonoct           p4, p5
iattack                 =                       0.01
isustain                =                       p3
irelease                =                       0.125
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linsegr                 0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
iindex                  =                       1
icrossfade              =                       2
ivibedepth              =                       0.2
iviberate               =                       6
ifn1                    =                       gisine
ifn2                    =                       gicook3
ifn3                    =                       gisine
ifn4                    =                       gisine
ivibefn                 =                       gicosine
ifrequency              =                       cpsoct(p4)
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5) * 2.0
; Constant-power pan.
ipi                     =                       4.0 * taninv(1.0)
iradians                =                       p7 * ipi / 2.0
itheta                  =                       iradians / 2.0
; Translate angle in [-1, 1] to left and right gain factors.
irightgain              =                       sqrt(2.0) / 2.0 * (cos(itheta) + sin(itheta))
ileftgain               =                       sqrt(2.0) / 2.0 * (cos(itheta) - sin(itheta))
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
; AUDIO
asignal                 fmbell                  1.0, ifrequency, iindex, icrossfade, ivibedepth, iviberate, ifn1, ifn2, ifn3, ifn4, ivibefn
asig1                   =                       ileftgain * asignal * iamplitude * kdamping
asig2                   =                       irightgain * asignal * iamplitude * kdamping
						outs					asig1, asig2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   16 ; FM moderate index, Michael Gogins
                        ; print                         p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
                        mididefault             60, p3
                        midinoteonoct           p4, p5
icarrier                =                       1
iratio                  =                       1.25
ifmamplitude            =                       8
index                   =                       5.4
iattack                 =                       0.02
isustain                =                       p3
irelease                =                       0.05
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linsegr                 0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
ifrequency              =                       cpsoct(p4)
ifrequencyb             =                       ifrequency * 1.003
icarrierb               =                       icarrier * 1.004
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5)
ijunk6                  =                       p6
; Constant-power pan.
ipi                     =                       4.0 * taninv(1.0)
iradians                =                       p7 * ipi / 2.0
itheta                  =                       iradians / 2.0
; Translate angle in [-1, 1] to left and right gain factors.
irightgain              =                       sqrt(2.0) / 2.0 * (cos(itheta) + sin(itheta))
ileftgain               =                       sqrt(2.0) / 2.0 * (cos(itheta) - sin(itheta))
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
kindenv                 expseg                  .000001, iattack, 1, isustain, .125, irelease, .000001
        kindex                  =                       kindenv * index * ifmamplitude
aouta                   foscili                 iamplitude, ifrequency, icarrier, iratio, index, 1
aoutb                   foscili                 iamplitude, ifrequencyb, icarrierb, iratio, index, 1
; Plus amplitude correction.
afmout                  =                       (aouta + aoutb) * kindenv
asig1                   =                       ileftgain * afmout * kdamping
asig2                   =                       irightgain * afmout * kdamping
						outs					asig1, asig2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   17 ; FM moderate index 2, Michael Gogins
                        ; print                         p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
                        mididefault             60, p3
                        midinoteonoct           p4, p5
icarrier                =                       1
iratio                  =                       1
ifmamplitude            =                       6
index                   =                       2.5
iattack                 =                       0.02
isustain                =                       p3
irelease                =                       0.05
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linsegr                 0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
ifrequency              =                       cpsoct(p4)
ifrequencyb             =                       ifrequency * 1.003
icarrierb               =                       icarrier * 1.004
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5)
ijunk6                  =                       p6
; Constant-power pan.
; x location ranges from hard left = -1 through center = 0 to hard right = 1.
; angle of pan ranges from hard left = - pi / 2 through center = 0 to hard right = pi / 2.
ix                      =                       p7
iangle                  =                       ix * 3.14159265359 / 2.0
ileftpan                =                       sqrt(2.0) / 2.0 * (cos(iangle) + sin(iangle))
irightpan               =                       sqrt(2.0) / 2.0 * (cos(iangle) - sin(iangle))
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
; KONTROL
kindenv                 expseg                  .000001, iattack, 1.0, isustain, .0125, irelease, .000001
kindex                  =                       kindenv * index * ifmamplitude - .000001
; AUDIO
aouta                   foscili                 iamplitude, ifrequency, icarrier, iratio, index, 1
aoutb                   foscili                 iamplitude, ifrequencyb, icarrierb, iratio, index, 1
; Plus amplitude correction.
afmout                  =                       (aouta + aoutb) * kindenv
asig1                   =                       ileftpan * afmout * kdamping
asig2                   =                       irightpan * afmout * kdamping
						outs					asig1, asig2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   18 ; Guitar, Michael Gogins
                        ; print                         p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
                        mididefault             60, p3
                        midinoteonoct           p4, p5
iattack                 =                       .01
isustain                =                       p3
irelease                =                       .05
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linsegr                 0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
ifrequency              =                       cpsoct(p4)
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5) * 5
ijunk6                  =                       p6
; Constant-power pan.
ipi                     =                       4.0 * taninv(1.0)
iradians                =                       p7 * ipi / 2.0
itheta                  =                       iradians / 2.0
; Translate angle in [-1, 1] to left and right gain factors.
irightgain              =                       sqrt(2.0) / 2.0 * (cos(itheta) + sin(itheta))
ileftgain               =                       sqrt(2.0) / 2.0 * (cos(itheta) - sin(itheta))
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
kamp                    linseg                  0.0, iattack, iamplitude, isustain, iamplitude, irelease, 0.0
asigcomp                pluck                   kamp, 440, 440, 0, 1
asig                    pluck                   kamp, ifrequency, ifrequency, 0, 1
af1                     reson                   asig, 110, 80
af2                     reson                   asig, 220, 100
af3                     reson                   asig, 440, 80
aout                    balance                 0.6 * af1+ af2 + 0.6 * af3 + 0.4 * asig, asigcomp
kexp                    expseg                  1.0, iattack, 2.0, isustain, 1.0, irelease, 1.0
kenv                    =                       kexp - 1.0
asig1                   =                       aout * ileftgain * kenv * kdamping,
asig2                   =                       aout* irightgain * kenv * kdamping
						outs					asig1, asig2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   19 ;  Flute, James Kelley
                        ; print                         p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
                        mididefault             60, p3
                        midinoteonoct           p4, p5
; Do some phasing.
icpsp1                  =                       cpsoct(p4 - .0002)
icpsp2                  =                       cpsoct(p4 + .0002)
; Normalize to 80 dB = ampdb(80).
ip6                     =                       ampdb(p5)
ijunk6                  =                       p6
; Constant-power pan.
ipi                     =                       4.0 * taninv(1.0)
iradians                =                       p7 * ipi / 2.0
itheta                  =                       iradians / 2.0
; Translate angle in [-1, 1] to left and right gain factors.
irightgain              =                       sqrt(2.0) / 2.0 * (cos(itheta) + sin(itheta))
ileftgain               =                       sqrt(2.0) / 2.0 * (cos(itheta) - sin(itheta))
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
iattack                 =                       0.04
isustain                =                       p3
irelease                =                       0.15
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linseg                  0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
ip4                     =                       0
                        if                      (ip4 == int(ip4 / 2) * 2) goto initslurs
                        ihold
initslurs:
iatttm                  =                       0.09
idectm                  =                       0.1
isustm                  =                       p3 - iatttm - idectm
idec                    =                       ip6
ireinit                 =                       -1
                        if                      (ip4 > 1) goto checkafterslur
ilast                   =                       0
checkafterslur:
                        if                      (ip4 == 1 || ip4 == 3) goto doneslurs
idec                    =                       0
ireinit                 =                       0
; KONTROL
doneslurs:
                        if                      (isustm <= 0)   goto simpleenv
kamp                    linseg                  ilast, iatttm, ip6, isustm, ip6, idectm, idec, 0, idec
                        goto                    doneenv
simpleenv:
kamp                    linseg                  ilast, p3 / 2,ip6, p3 / 2, idec, 0, idec
doneenv:
ilast                   =                       ip6
; Some vibrato.
kvrandamp               rand                    .1
kvamp                   =                       (8 + p4) *.06 + kvrandamp
kvrandfreq              rand                    1
kvfreq                  =                       5.5 + kvrandfreq
kvbra                   oscili                  kvamp, kvfreq, 1, ireinit
kfreq1                  =                       icpsp1 + kvbra
kfreq2                  =                       icpsp2 + kvbra
; Noise for burst at beginning of note.
knseenv                 expon                   ip6 / 4, .2, 1
; AUDIO
anoise1                 rand                    knseenv
anoise                  tone                    anoise1, 200
a1                      oscili                  kamp, kfreq1, gikellyflute, ireinit
a2                      oscili                  kamp, kfreq2, gikellyflute, ireinit
a3                      =                       a1 + a2 + anoise
asig1                   =                       a3 * ileftgain * kdamping
asig2                   =                       a3 * irightgain * kdamping
						outs					asig1, asig2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   20 ; Delayed plucked string, Michael Gogins
                        ; print                         p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
                        mididefault             60, p3
                        midinoteonoct           p4, p5
iattack                 =                       0.02
isustain                =                       p3
irelease                =                       0.15
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linseg                  0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
ioctave                 =                       p4
ihertz                  =                       cpsoct(ioctave)
; Detuning of strings by 4 cents each way.
idetune                 =                       4.0 / 1200.0
ihertzleft              =                       cpsoct(ioctave + idetune)
ihertzright             =                       cpsoct(ioctave - idetune)
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5)
ijunk6                  =                       p6
; Constant-power pan.
; x location ranges from hard left = -1 through center = 0 to hard right = 1.
; Angle of pan ranges from hard left = - pi / 2 through center = 0 to hard right = pi / 2.
ix                      =                       p7
iangle                  =                       ix * 3.14159265359 / 2.0
ileftpan                =                       sqrt(2.0) / 2.0 * (cos(iangle) + sin(iangle))
irightpan               =                       sqrt(2.0) / 2.0 * (cos(iangle) - sin(iangle))
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
; INITIALIZATION
igenleft                =                       gisine
igenright               =                       gicosine
; KONTROL
kvibrato                oscili                  1.0 / 120.0, 7.0, 1
; AUDIO
kexponential            expseg                  1.0, p3 + iattack, 0.0001, irelease, .0001
kenvelope               =                       (kexponential - 0.0001) * kdamping
ag                      pluck                   iamplitude, cpsoct(ioctave + kvibrato), 200, igenleft, 1
agleft                  pluck                   iamplitude, ihertzleft, 200, igenleft, 1
agright                 pluck                   iamplitude, ihertzright, 200, igenright, 1
imsleft                 =                       0.2 * 1000
imsright                =                       0.21 * 1000
adelayleft              vdelay                  ag * kenvelope, imsleft, imsleft + 100
adelayright             vdelay                  ag * kenvelope, imsright, imsright + 100
asignal                 =                       kdamping * (agleft + adelayleft + agright + adelayright)
; Highpass filter to exclude speaker cone excursions.
asignal1                butterhp                asignal, 32.0
asignal2                balance                 asignal1, asignal
asig1                   =                       ileftpan * asignal * kdamping
asig2                   =                       irightpan * asignal * kdamping
						outs					asig1, asig2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   21 ; Melody (Chebyshev / FM / additive), Jon Nelson
                        ; print                         p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
                        mididefault             60, p3
                        midinoteonoct           p4, p5
; Pitch.
i1                      =                       cpsoct(p4)
; Amplitude.
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5) * 1.0 / 5000.0
; Constant-power pan.
iangle                  =                       p6 / 2.0
ijunk7                  =                       p7
ijunk8                  =                       p8
ijunk9                  =                       p9
ijunk10                 =                       p10
ijunk11                 =                       p11
ileftpan                =                       sqrt(2.0) / 2.0 * (cos(iangle) + sin(iangle)) * iamplitude;
irightpan               =                       sqrt(2.0) / 2.0 * (cos(iangle) - sin(iangle)) * iamplitude;
;ip6                    =                       cheby no
ip6                     =                       gichebychev
iattack                 =                       .05
isustain                =                       p3
irelease                =                       .1
iduration               =                       iattack + isustain + irelease
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linseg                  0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
k100                    randi                   1,10
k101                    oscili                  1, 5 + k100, gisine
k102                    linseg                  0, .5, 1, (iduration - .5), 1
k100                    =                       i1 + (k101 * k102)
; Envelope for driving oscillator.
k1                      linenr                  .5, iduration * .3, iduration * .2, 0.01
k2                      line                    1, iduration, .5
k1                      =                       k2 * k1
; Amplitude envelope.
k10                     expseg                  .0001, iattack, iamplitude, isustain, iamplitude * .8, irelease, .0001
k10                     =                       (k10 - .0001) * kdamping
; Power to partials.
k20                     linseg                  1.485, iattack, 1.5, (isustain + irelease), 1.485
;a1-3 are for cheby with p6=1-4
a1                      oscili                  k1, k100 - .025, gicook3
; Tables a1 to fn13, others normalize,
a2                      tablei                  a1, ip6, 1, .5
a3                      balance                 a2, a1
; Try other waveforms as well.
a4                      foscil                  1, k100 + .04, 1, 2.005, k20, gisine
a5                      oscili                  1, k100, gisine
a6                      =                       ((a3 * .1) + (a4 * .1) + (a5 * .8)) * k10
a7                      comb                    a6, .5, 1 / i1
a8                      =                       (a6 * .9) + (a7 * .1)
a9          balance         a8, a1 * 32767.0
asig1                   =                       (a9 * ileftpan) * kdamping
asig2                   =                       (a9 * irightpan) * kdamping
						outs					asig1, asig2
                        endin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                        instr                   22 ; Enhanced FM bell, John ffitch
                        ; print                         p2, p3, p4, p5, p6, p7, p8, p9, p10, p11
                        mididefault             60, p3
                        midinoteonoct           p4, p5
iinstrument             =                       p1
istarttime              =                       p2
iattack                 =                       .005
isustain                =                       p3
irelease                =                       .06
                        ; xtratim                       iattack + irelease
p3                      =                       isustain + iattack + irelease
kdamping                linsegr                 0.0, iattack, 1.0, isustain, 1.0, irelease, 0.0
ioctave                 =                       p4
ifrequency              =                       cpsoct(ioctave)
; Normalize so iamplitude for p5 of 80 == ampdb(80).
iamplitude              =                       ampdb(p5) / 3
iphase                  =                       p6
; Constant-power pan.
ipi                     =                       4.0 * taninv(1.0)
ixpan                   =                       p7
iradians                =                       ixpan * ipi / 2.0
itheta                  =                       iradians / 2.0
; Translate angle in [-1, 1] to left and right gain factors.
irightgain              =                       sqrt(2.0) / 2.0 * (cos(itheta) + sin(itheta))
ileftgain               =                       sqrt(2.0) / 2.0 * (cos(itheta) - sin(itheta))
iypan                   =                       p8
izpan                   =                       p9
imason                  =                       p10
ihomogeneity            =                       p11
idur                    =                       15
iamp                    =                       iamplitude
ifenv                   =                       giffitch2                       ; BELL SETTINGS:
ifdyn                   =                       giffitch3                       ; AMP AND INDEX ENV ARE EXPONENTIAL
ifq1                    =                       cpsoct(p4 - 1) * 5              ; DECREASING, N1:N2 IS 5:7, imax=10
if1                     =                       giffitch1                               ; DURATION = 15 sec
ifq2                    =                       cpsoct(p4 - 1) * 7
if2                     =                       giffitch1
imax                    =                       10
aenv                    oscili                  iamp, 1 / idur, ifenv           ; ENVELOPE
adyn                    oscili                  ifq2 * imax, 1 / idur, ifdyn    ; DYNAMIC
anoise                  rand                    50
amod                    oscili                  adyn + anoise, ifq2, if2        ; MODULATOR
acar                    oscili                  aenv, ifq1 + amod, if1          ; CARRIER
                        timout                  0.5, idur, noisend
knenv                   linseg                  iamp, 0.2, iamp, 0.3, 0
anoise3                 rand                    knenv
anoise4                 butterbp                anoise3, iamp, 100
anoise5                 balance                 anoise4, anoise3
noisend:
arvb                    nreverb                 acar, 2, 0.1
asignal                 =                       acar + anoise5 + arvb
asig1                   =                       asignal * ileftgain * kdamping
asig2                   =                       asignal * irightgain * kdamping
						outs					asig1, asig2
                        endin
</CsInstruments>
<CsScore>
</CsScore>
</CsoundSynthesizer>

error: pathspec 'examples/CsoundVST-nomixer.csd' did not match any file(s) known to git


added array udo tests

added array udo tests

<CsoundSynthesizer>
<CsOptions>
-d
</CsOptions>
<CsInstruments>

opcode Test,k,[k]

kS[] xin
k1 = kS[0]
   xout ks1

endop

instr 1

;kS[] init 2
; ks[0] = 1
;k2 Test kS[]
   ;printk2 k2

endin

</CsInstruments>
<CsScore>

i1 0 1

</CsScore>
</CsoundSynthesizer>
<bsbPanel>
 Widgets
 <objectName/>
 <x>614</x>
 <y>61</y>
 <width>695</width>
 <height>747</height>
 <visible>true</visible>
 <uuid/>
 <bgcolor mode="nobackground">
  <r>231</r>
  <g>46</g>
  255
 </bgcolor>
 <bsbObject version="2" type="BSBVSlider">
  <objectName>slider1</objectName>
  <x>5</x>
  <y>5</y>
  <width>20</width>
  <height>100</height>
  <uuid>{fe924818-39b1-44b5-b240-331a49ca0049}</uuid>
  <visible>true</visible>
  <midichan>0</midichan>
  <midicc>-3</midicc>
  <minimum>0.00000000</minimum>
  <maximum>1.00000000</maximum>
  <value>0.00000000</value>
  <mode>lin</mode>
  <mouseControl act="jump">continuous</mouseControl>
  <resolution>-1.00000000</resolution>
  <randomizable group="0">false</randomizable>
 </bsbObject>
</bsbPanel>
<bsbPresets>
</bsbPresets>
<MacGUI>
ioView nobackground {59367, 11822, 65535}
ioSlider {5, 5} {20, 100} 0.000000 1.000000 0.000000 slider1
</MacGUI>

error: pathspec 'tests/commandline/test_karrays_udo.csd' did not match any file(s) known to git


Added example to assets.

Added example to assets.

error: pathspec 'android/CSDPlayer/assets/Csound6AndroidExamples/Boulanger/trapped.csd' did not match any file(s) known to git


Added missing -M0 option.

Added missing -M0 option.


no message

no message


Example/test for OSC

Example/test for OSC

<CsoundSynthesizer>

<CsInstruments>
instr 1
    OSCsend     1, "",7770, "/foo/bar", 4, 42, "FOO"
endin

</CsInstruments>

<CsScore>
i1 0 1
e
</CsScore>

</CsoundSynthesizer>

error: pathspec 'examples/osc.csd' did not match any file(s) known to git


added commandline csd to test various array operations

<CsoundSynthesizer>
<CsOptions>
-m0
</CsOptions>
<CsInstruments>
ksmps = 32

/****UDOs for printing one-dim arrays****/
  opcode PrtArr1i, 0, i[]ojjj
iArr[], istart, iend, iprec, ippr xin
iprint     init       0
ippr       =          (ippr == -1 ? 10 : ippr)
iend       =          (iend == -1 ? lenarray(iArr) : iend)
iprec      =          (iprec == -1 ? 3 : iprec)
indx       =          istart
Sformat    sprintf    "%%%d.%df, ", iprec+3, iprec
Sdump      sprintf    "%s", "["
loop:
Snew       sprintf    Sformat, iArr[indx]
Sdump      strcat     Sdump, Snew
imod       =          (indx+1-istart) % ippr
 if imod == 0 && indx != iend-1 then
           printf_i   "%s\n", iprint+1, Sdump
Sdump      strcpy     " "
 endif
iprint     =          iprint + 1
           loop_lt    indx, 1, iend, loop
ilen       strlen     Sdump
Slast      strsub     Sdump, 0, ilen-2
           printf_i   "%s]\n", iprint+1, Slast
  endop
  opcode PrtArr1k, 0, k[]POVVO
kArr[], ktrig, kstart, kend, kprec, kppr xin
kprint     init       0
kndx       init       0
if ktrig > 0 then
kppr       =          (kppr == 0 ? 10 : kppr)
kend       =          (kend == -1 || kend == .5 ? lenarray(kArr) : kend)
kprec      =          (kprec == -1 || kprec == .5 ? 3 : kprec)
kndx       =          kstart
Sformat    sprintfk   "%%%d.%df, ", kprec+3, kprec
Sdump      sprintfk   "%s", "["
loop:
Snew       sprintfk   Sformat, kArr[kndx]
Sdump      strcatk    Sdump, Snew
kmod       =          (kndx+1-kstart) % kppr
 if kmod == 0 && kndx != kend-1 then
           printf     "%s\n", kprint+1, Sdump
Sdump      strcpyk    " "
 endif
kprint     =          kprint + 1
           loop_lt    kndx, 1, kend, loop
klen       strlenk    Sdump
Slast      strsubk    Sdump, 0, klen-2
           printf     "%s]\n", kprint+1, Slast
endif
  endop
  opcode PrtArr1S, 0, S[]oj
SArr[], istart, iend xin
iend       =          (iend == -1 ? lenarray(SArr) : iend)
indx       =          istart
           printf_i   "%s", 1, "["
 until indx >= iend-1 do
           printf_i    "%s, ", 1, SArr[indx]
indx       +=         1
 enduntil
           printf_i   "%s]\n", 1, SArr[indx]
  endop

    giSine  ftgen   0, 0, 8, 10, 1

instr Fillarray
    prints "\n instr Fillarray\n"
;different types, one dim
    iArr1d[] fillarray 1, 2, 3
    kArr1d[] fillarray 1, 2, 3
    SArr1d[] fillarray "a", "b", "c"
    PrtArr1i iArr1d
    PrtArr1k kArr1d
    PrtArr1S SArr1d
;different types, two dims
    iArr2d[][] init 2, 3
    iArr2d fillarray 1, 2, 3, 4, 5, 6
    kArr2d[][] init 3, 2
    kArr2d fillarray 1, 2, 3, 4, 5, 6
    SArr2d[] init 2, 3
    SArr2d fillarray "a", "b", "c", "e", "f", "g"
;two dims, arrays as arguments
;    iArr1[] fillarray 1, 2, 3
;    iArr2[] fillarray 4, 5, 6
;    iArrcmb[][] fillarray iArr1, iArr2
    turnoff
endin

instr Lenarray
    prints "\n instr Lenarray\n"
    iArr1d[] fillarray 1, 2, 3
    kArr1d[] fillarray 1, 2, 3
    SArr1d[] fillarray "a", "b", "c"
    print lenarray(iArr1d)
    print lenarray(SArr1d)
    printk 0, lenarray(kArr1d)
    turnoff
endin

instr Slicearray
    prints "\n instr Sclicearray\n"
;i-rate
   iArr[]  fillarray  1, 2, 3, 4, 5, 6, 7, 8, 9
   iArr1[] init       5
   iArr2[] init       4
   iArr1   slicearray iArr, 0, 4
   iArr2   slicearray iArr, 5, 8
           PrtArr1i   iArr1
           PrtArr1i   iArr2
;k-rate
   kArr[]  fillarray  1, 2, 3, 4, 5, 6, 7, 8, 9
   kArr1[] init       5
   kArr2[] init       4
   kArr1   slicearray iArr, 0, 4
   kArr2   slicearray iArr, 5, 8
           PrtArr1k   kArr1
           PrtArr1k   kArr2
;string arrays
   SArr[]  fillarray  "a", "b", "c", "d", "e"
   SArr1[] init       3
   SArr2[] init       2
   SArr1   slicearray SArr, 0, 2
   SArr2   slicearray SArr, 3, 4
           PrtArr1S   SArr1
           PrtArr1S   SArr2
           turnoff
endin

instr Copyf2array
    prints "\n instr Copyf2array\n"
;i-rate
    iArr[]  init       8
    copyf2array iArr, giSine
    PrtArr1i iArr
;k-rate
    kArr[]  init       8
    copyf2array kArr, giSine
    PrtArr1k kArr
    turnoff
endin

instr Copya2ftab
    prints "\n instr Copya2ftab\n"
;i-rate
    iArr[]  fillarray  1, 2, 3, 4, 5, 6, 7, 8
    iFt1 ftgen 0, 0, lenarray(iArr), 2, 0
    copya2ftab iArr, iFt1
    prints "iFt1 values = "
    iIndx = 0
    until iIndx == lenarray(iArr) do
    printf_i "%.3f ", iIndx+1, table:i(iIndx, iFt1)
    iIndx += 1
    enduntil
    prints "\n"
;k-rate
    kArr[]  fillarray  1, 2, 3, 4, 5, 6, 7, 8
    iFt2 ftgen 0, 0, 8, 2, 0
    copya2ftab kArr, iFt2
    printks "iFt2 values = ", 0
    kIndx = 0
    until kIndx == lenarray(kArr) do
    printf "%.3f ", kIndx+1, table:k(kIndx, iFt2)
    kIndx += 1
    enduntil
    printks "\n", 0
    turnoff
endin

instr Arr_Num_Math
;+, -, *, / between an array and a number
    prints "\n instr Arr_Num_Math\n"
;i-rate
    iArr1[] fillarray 1, 2, 3
    iArr2[] = iArr1 + 10
    iArr3[] = iArr2 - 10
    iArr4[] = iArr3 * 10
    iArr5[] = iArr4 / 10
    prints "iArr1 = "
    PrtArr1i iArr1
    prints "iArr2 = iArr1 + 10: "
    PrtArr1i iArr2
    prints "iArr3 = iArr2 - 10: "
    PrtArr1i iArr3
    prints "iArr4 = iArr3 * 10: "
    PrtArr1i iArr4
    prints "iArr5 = iArr4 / 10: "
    PrtArr1i iArr5
;k-rate
    kArr1[] fillarray -1, -2, -3
    kArr2[] = kArr1 + 10
    kArr3[] = kArr2 - 10
    kArr4[] = kArr3 * 10
    kArr5[] = kArr4 / 10
    printks "kArr1 = ", 0
    PrtArr1k kArr1
    printks "kArr2 = kArr1 + 10: ", 0
    PrtArr1k kArr2
    printks "kArr3 = kArr2 - 10: ", 0
    PrtArr1k kArr3
    printks "kArr4 = kArr3 * 10: ", 0
    PrtArr1k kArr4
    printks "kArr5 = kArr4 / 10: ", 0
    PrtArr1k kArr5
    turnoff
endin

instr Arr_Arr_Math
; +, -, *, / between two arrays
    prints "\n instr Arr_Arr_Math\n"
;i-rate
    iArr1[] fillarray 1, 2, 3
    iArr2[] fillarray 4, 5, 6
    iArr3[] = iArr1 + iArr2
    iArr4[] = iArr1 - iArr2
    iArr5[] = iArr1 * iArr2
    iArr6[] = iArr1 / iArr2
    prints "iArr1 = "
    PrtArr1i iArr1
    prints "iArr2 = "
    PrtArr1i iArr2
    prints "iArr3[] = iArr1 + iArr2:\n        "
    PrtArr1i iArr3
    prints "iArr4[] = iArr1 - iArr2:\n        "
    PrtArr1i iArr4
    prints "iArr5[] = iArr1 * iArr2:\n        "
    PrtArr1i iArr5
    prints "iArr6[] = iArr1 / iArr2:\n        "
    PrtArr1i iArr6
;k-rate
    kArr1[] fillarray -1, -2, -3
    kArr2[] fillarray -4, -5, -6
    kArr3[] = kArr1 + kArr2
    kArr4[] = kArr1 - kArr2
    kArr5[] = kArr1 * kArr2
    kArr6[] = kArr1 / kArr2
    printks "kArr1 = ", 0
    PrtArr1k kArr1
    printks "kArr2 = ", 0
    PrtArr1k kArr2
    printks "kArr3[] = kArr1 + kArr2:\n        ", 0
    PrtArr1k kArr3
    printks "kArr4[] = kArr1 - kArr2:\n        ", 0
    PrtArr1k kArr4
    printks "kArr5[] = kArr1 * kArr2:\n        ", 0
    PrtArr1k kArr5
    printks "kArr6[] = kArr1 / kArr2:\n        ", 0
    PrtArr1k kArr6
    turnoff
endin

instr Minarray
    prints "\n instr Minarray\n"
;i-rate
    iArr[] fillarray -1, 0, 1.1, -3.3, 17
    iMin, iPos minarray iArr
    prints "iArr = "
    PrtArr1i iArr
    prints "iMin = value %.3f at index %d\n", iMin, iPos
;k-rate
    kArr[] fillarray -1, 0, 1.1, -3.3, 17
    kMin, kPos minarray kArr
    printks "kArr = ", 0
    PrtArr1k kArr
    printks "kMin = value %.3f at index %d\n", 0, kMin, kPos
    turnoff
endin

instr Maxarray
    prints "\n instr Maxarray\n"
;i-rate
    iArr[] fillarray -1, 0, 1.1, -3.3, 17
    iMax, iPos maxarray iArr
    prints "iArr = "
    PrtArr1i iArr
    prints "iMax = value %.3f at index %d\n", iMax, iPos
;k-rate
    kArr[] fillarray -1, 0, 1.1, -3.3, 17
    kMax, kPos maxarray kArr
    printks "kArr = ", 0
    PrtArr1k kArr
    printks "kMax = value %.3f at index %d\n", 0, kMax, kPos
    turnoff
endin

instr Sumarray
    prints "\n instr Sumarray\n"
;i-rate
    iArr[] fillarray -1, 0, 1.1, -3.3, 17
    iSum sumarray iArr
    prints "iArr = "
    PrtArr1i iArr
    prints "iSum = %.3f\n", iSum
;k-rate
    kArr[] fillarray -1, 0, 1.1, -3.3, 17
    kSum sumarray kArr
    printks "kArr = ", 0
    PrtArr1k kArr
    printks "kSum = %.3f\n", 0, kSum
    turnoff
endin

instr Scalearray
    prints "\n instr Scalearray\n"
;i-rate
    iArr[] fillarray -1, 0, 1.1, -3.3, 17
    prints "iArr before scaling: "
    PrtArr1i iArr
    scalearray iArr, 0, 10
    prints "iArr after scaling (0..10): "
    PrtArr1i iArr
;k-rate
    kArr[] fillarray -1, 0, 1.1, -3.3, 17
    printks "kArr before scaling: ", 0
    PrtArr1k kArr
    scalearray kArr, 0, 10
    printks "kArr after scaling (0..10): ", 0
    PrtArr1k kArr
    turnoff
endin

instr Maparray
    prints "\n instr Maparray\n"
;i-rate
    iArr1[] fillarray 1, 2, 3, 4, 5
    iArr2[] init 5
    iArr2 maparray iArr1, "sqrt"
    prints "iArr1 = "
    PrtArr1i iArr1
    prints "applied sqrt function to it = "
    PrtArr1i iArr2
;k-rate
    kArr1[] fillarray 1, 2, 3, 4, 5
    kArr2[] init 5
    kArr2 maparray kArr1, "sqrt"
    printks "kArr1 = ", 0
    PrtArr1k kArr1
    printks "applied sqrt function to it = ", 0
    PrtArr1k kArr2
    turnoff
endin

instr Assign
    prints "\n instr Assign\n"
;i-rate
    iArr1[] fillarray 1, 2, 3, 4, 5
    iArr2[] = iArr1
    PrtArr1i iArr2
;string array
    Sarr1[] fillarray "is", "this", "really", "possible", "?"
    ;not yet ...=)
;    Sarr2[] = Sarr1
;    PrtArr1S Sarr2
;k-rate
    kArr1[] fillarray 1, 2, 3, 4, 5
    kArr2[] = kArr1
    PrtArr1k kArr2
    turnoff
endin

instr Genarray
    prints "\n instr Genarray\n"
;i-rate
    iArr1[] genarray   1, 5
    iArr2[] genarray   -1, 1, 0.5
    iArr3[] genarray   1, -1, -0.5
    iArr4[] genarray   -1, 1, 0.6
    PrtArr1i iArr1
    PrtArr1i iArr2
    PrtArr1i iArr3
    PrtArr1i iArr4
;k-rate
    kArr1[] genarray_i   1, 5
    kArr2[] genarray_i   -1, 1, 0.5
    kArr3[] genarray_i   1, -1, -0.5
    kArr4[] genarray_i   -1, 1, 0.6
    PrtArr1k kArr1
    PrtArr1k kArr2
    PrtArr1k kArr3
    PrtArr1k kArr4
    turnoff
endin

</CsInstruments>
<CsScore>
i "Fillarray" 0 .01
i "Lenarray" .01 .01
i "Slicearray" .02 .01
i "Copyf2array" .03 .01
i "Copya2ftab" .04 .01
i "Arr_Num_Math" .05 .01
i "Arr_Arr_Math" .06 .01
i "Minarray" .07 .01
i "Maxarray" .08 .01
i "Sumarray" .09 .01
i "Scalearray" .1 .01
i "Maparray" .11 .01
i "Assign" .12 .01
i "Genarray" .13 .01
</CsScore>
</CsoundSynthesizer>
<bsbPanel>
 Widgets
 <objectName/>
 <x>758</x>
 <y>141</y>
 <width>541</width>
 <height>240</height>
 <visible>true</visible>
 <uuid/>
 <bgcolor mode="nobackground">
  <r>255</r>
  <g>255</g>
  255
 </bgcolor>
 <bsbObject version="2" type="BSBButton">
  <objectName>_Browse</objectName>
  <x>73</x>
  <y>27</y>
  <width>100</width>
  <height>30</height>
  <uuid>{737b2ca7-2fac-4257-ae57-7863dd7b6135}</uuid>
  <visible>true</visible>
  <midichan>0</midichan>
  <midicc>0</midicc>
  <type>value</type>
  <pressedValue>1.00000000</pressedValue>
  <stringvalue>/home/jh/Joachim/Stuecke/25Siononmiro/z_produktion_angela_2014/teil1_trocken.wav</stringvalue>
  <text>button0</text>
  <image>/</image>
  <eventLine>i1 0 10</eventLine>
  <latch>false</latch>
  <latched>false</latched>
 </bsbObject>
 <bsbObject version="2" type="BSBLineEdit">
  <objectName>Browse1</objectName>
  <x>28</x>
  <y>67</y>
  <width>462</width>
  <height>29</height>
  <uuid>{111f96a6-2d30-48ad-aa25-27efb2119419}</uuid>
  <visible>true</visible>
  <midichan>0</midichan>
  <midicc>0</midicc>
  bla
  <alignment>left</alignment>
  Arial
  <fontsize>10</fontsize>
  <precision>3</precision>
  <color>
   <r>0</r>
   <g>0</g>
   0
  </color>
  <bgcolor mode="nobackground">
   <r>206</r>
   <g>206</g>
   206
  </bgcolor>
  <background>nobackground</background>
 </bsbObject>
 <bsbObject version="2" type="BSBLineEdit">
  <objectName>bla</objectName>
  <x>28</x>
  <y>118</y>
  <width>462</width>
  <height>29</height>
  <uuid>{f8350608-e7d4-472f-8e21-2eaf0248a8e3}</uuid>
  <visible>true</visible>
  <midichan>0</midichan>
  <midicc>0</midicc>
  aaaaaaaaaaaaaaaaaaaaaaaaa
  <alignment>left</alignment>
  Arial
  <fontsize>10</fontsize>
  <precision>3</precision>
  <color>
   <r>0</r>
   <g>0</g>
   0
  </color>
  <bgcolor mode="nobackground">
   <r>206</r>
   <g>206</g>
   206
  </bgcolor>
  <background>nobackground</background>
 </bsbObject>
</bsbPanel>
<bsbPresets>
</bsbPresets>

error: pathspec 'tests/commandline/test_array_operations.csd' did not match any file(s) known to git


added test file for issue #579 (not yet linked into test suite)

<CsoundSynthesizer>
;<CsOptions>
;</CsOptions>
; ==============================================
<CsInstruments>

sr	=	44100
ksmps	=	1
;nchnls	=	2
0dbfs	=	1

opcode test_udo, k,0
 xout 0
endop

instr 1
  kval = test_udo()

endin

</CsInstruments>
; ==============================================
<CsScore>
i1 0 0.1
</CsScore>
</CsoundSynthesizer>

error: pathspec 'tests/commandline/udo/test_udo_xout_const.csd' did not match any file(s) known to git


Delete trapped.csd

Delete trapped.csd


no message

no message

<CsoundSynthesizer>
<CsOptions>
csound -RWdo temp.wav temp.orc temp.sco
</CsOptions>
<CsInstruments>
sr = 44100
kr = 4410
ksmps = 10
nchnls = 2

gihandle1 vstinit "c:/projects/music/library/polyiblit.dll", 1

instr 1
ichannel = p1
ikey = p4
ivelocity = p5
vstout gihandle1,144,ichannel, ikey, ivelocity
ain1 = 0
ab1, ab2 vstplug gihandle1, ain1, ain1
outs ab1, ab2
endin</CsInstruments>
<CsScore>
i 1 0 10 60 60
i 1 2 1 72 60
i 1 2 2 64 60
i 1 15 15 60 60
i 1 15 15 64 60
i 1 15 15 62 60

</CsScore>
</CsoundSynthesizer>

error: pathspec 'examples/vstcsound.csd' did not match any file(s) known to git


Add example CSD file

Add example CSD file

<CsoundSynthesizer>
<CsInstruments>
// This is a Csound orchestra file for testing a Pygments <http://pygments.org>
// lexer. Csound single-line comments can be preceded by a pair of forward
// slashes...
; ...or a semicolon.

/* Block comments begin with /* and end with */

// Orchestras begin with a header of audio parameters.
nchnls = 1
nchnls_i = 1
sr = 44100
0dbfs = 1
ksmps = 10

// The control rate kr = sr / ksmps can be omitted when the number of audio
// samples in a control period (ksmps) is set, but kr may appear in older
// orchestras.
kr = 4410

// Orchestras contain instruments. These begin with the keyword instr followed
// by a comma-separated list of numbers or names of the instrument. Instruments
// end at the endin keyword and cannot be nested.
instr 1, N_a_M_e_, +Name
  // Instruments contain statements. Here is a typical statement:
  aSignal oscil 0dbfs, 440, 1
  // Statements are terminated with a newline (possibly preceded by a comment).
  // To write a statement on several lines, precede the newline with a
  // backslash.
  prints \
    "hello, world\n";comment

  // Csound 6 introduced function syntax for opcodes with one or zero outputs.
  // The oscil statement above is the same as
  aSignal = oscil(0dbfs, 440, 1)

  // Instruments can contain control structures.
  kNote = p3
  if (kNote == 0) then
    kFrequency = 220
  elseif kNote == 1 then // Parentheses around binary expressions are optional.
    kFrequency = 440
  endif

  // Csound 6 introduced looping structures.
  iIndex = 0
  while iIndex < 5 do
    print iIndex
    iIndex += 1
  od
  iIndex = 0
  until iIndex >= 5 do
    print iIndex
    iIndex += 1
  enduntil
  // Both kinds of loops can be terminated by either od or enduntil.

  // Single-line strings are enclosed in double-quotes.
  prints "string\\\r\n\t\""
  // Multi-line strings are enclosed in pairs of curly braces.
  prints {{
    hello,

    world
  }}

  // Instruments often end with a statement containing an output opcode.
  outc aSignal
endin

// Orchestras can also contain user-defined opcodes (UDOs). Here is an
// oscillator with one audio-rate output and two control-rate inputs:
opcode anOscillator, a, kk
  kAmplitude, kFrequency xin
  aSignal vco2 kAmplitude, kFrequency
  xout aSignal
endop
instr TestOscillator
  outc(anOscillator(0dbfs, 110))
endin

// Python can be executed in Csound
// <http://www.csounds.com/manual/html/pyrun.html>. So can Lua
// <http://www.csounds.com/manual/html/lua.html>.
pyruni {{
import random

pool = [(1 + i / 10.0) ** 1.2 for i in range(100)]

def get_number_from_pool(n, p):
  if random.random() < p:
    i = int(random.random() * len(pool))
    pool[i] = n
  return random.choice(pool)
}}

// The Csound preprocessor supports conditional compilation and including files.
#ifdef DEBUG
#undef DEBUG
#include "filename.orc"
#endif

// The preprocessor also supports object- and function-like macros. This is an
// object-like macro that defines a number:
#define A_HZ #440#

// This is a function-like macro:
#define OSCIL_MACRO(VOLUME'FREQUENCY'TABLE) #oscil $VOLUME, $FREQUENCY, $TABLE#

// Bodies of macros are enclosed in # and can contain newlines. The arguments of
// function-like macros are separated by single-quotes. Uses of macros are
// prefixed with a dollar sign.
instr TestMacro
  aSignal $OSCIL_MACRO(1'$A_HZ'1)
  // Not unlike PHP, macros expand in double-quoted strings.
  prints "The frequency of the oscillator is $A_HZ Hz.\n"
  out aSignal
endin

// Here are other things to note about Csound.

// There are two bitwise NOT operators, ~ and ¬ (U+00AC). The latter is common
// on keyboards in the United Kingdom
// <https://en.wikipedia.org/wiki/British_and_American_keyboards>.
instr TestBitwiseNOT
  print ~42
  print ¬42
endin

// Csound uses # for bitwise XOR, which the Csound manual calls bitwise
// non-equivalence <http://www.csounds.com/manual/html/opnonequiv.html>.
instr TestBitwiseXOR
  print 0 # 0
  print 0 # 1
  print 1 # 0
  print 1 # 1
endin

// Loops and if-then statements are relatively recent additions to Csound. There
// are many flow-control opcodes that involve goto and labels.
instr TestGoto
  // This...
  if p3 > 0 goto if_label
  goto else_label
if_label:
  prints "if branch\n"
  goto endif_label
else_label:
  prints "else branch\n"
endif_label:

  // ...is the same as this.
  if p3 > 0 then
    prints "if branch\n"
  else
    prints "else branch\n"
  endif

  // This...
  iIndex = 0
loop_label:
  print iIndex
  iIndex += 1
  if iIndex < 10 goto loop_label

  // ...is the same as this...
  iIndex = 0
loop_lt_label:
  print iIndex
  loop_lt iIndex, 1, 10, loop_lt_label

  // ...and this.
  iIndex = 0
  while iIndex < 10 do
    print iIndex
    iIndex += 1
  od
endin

// The prints and printks opcodes
// <https://github.com/csound/csound/blob/develop/OOps/ugrw1.c#L831>, arguably
// the primary methods of logging output, treat certain sequences of characters
// different from printf in C.
instr TestPrints
  // ^ prints an ESCAPE character (U+001B), not a CIRCUMFLEX ACCENT character
  // (U+005E). ^^ prints a CIRCUMFLEX ACCENT.
  prints "^^\n"
  // ~ prints an ESCAPE character (U+001B) followed by a [, not a TILDE
  // character (U+007E). ~~ prints a TILDE.
  prints "~~\n"
  // \A, \B, \N, \R, and \T correspond to the escaped lowercase characters (that
  // is, BELL (U+0007), BACKSPACE (U+0008), new line (U+000A), CARRIAGE RETURN
  // (U+000D), and tab (U+0009)).
  prints "\T\R\N"
  // %n, %r, and %t are the same as \n, \r, and \t, as are %N, %R, and %T.
  prints "%t%r%n"
  // %! prints a semicolon. This is a hold-over from old versions of Csound that
  // allowed comments to begin in strings.
  prints "; %!\n"
endin

// The arguments of function-like macros can be separated by # instead of '.
// These two lines define the same macro.
#define OSCIL_MACRO(VOLUME'FREQUENCY'TABLE) #oscil $VOLUME, $FREQUENCY, $TABLE#
#define OSCIL_MACRO(VOLUME#FREQUENCY#TABLE) #oscil $VOLUME, $FREQUENCY, $TABLE#

// Uses of macros can optionally be suffixed with a period.
instr TestMacroPeriodSuffix
  aSignal $OSCIL_MACRO.(1'$A_HZ'1)
  prints "The frequency of the oscillator is $A_HZ.Hz.\n"
  out aSignal
endin

// Csound has @ and @@ operator-like macros that, when followed by a literal
// non-negative integer, expand to the next power of 2 and the next power of 2
// plus 1:
//    @x = 2^(ceil(log2(x + 1))), x >= 0
//   @@0 = 2
//   @@x = 2^(ceil(log2(x))) + 1, x > 0
// These macros are in
// <https://github.com/csound/csound/blob/develop/Engine/csound_orc.l#L542> (and
// <https://github.com/csound/csound/blob/develop/Engine/csound_sco.lex#L202>)
// and are described at <http://www.csounds.com/manual/html/ScoreEval.html>.
instr TestAt
  prints "%d  %2d  %2d\n", 0, @0, @@0
  prints "%d  %2d  %2d\n", 1, @1, @@1
  prints "%d  %2d  %2d\n", 2, @2, @@2
  prints "%d  %2d  %2d\n", 3, @3, @@3
  prints "%d  %2d  %2d\n", 4, @4, @@4
  prints "%d  %2d  %2d\n", 5, @5, @@5
  prints "%d  %2d  %2d\n", 6, @6, @@6
  prints "%d  %2d  %2d\n", 7, @7, @@7
  prints "%d  %2d  %2d\n", 8, @8, @@8
  prints "%d  %2d  %2d\n", 9, @9, @@9
endin

// Including newlines in macros can lead to confusing code, but it tests the
// lexer.
instr MacroAbuse
  if 1 == 1 then
    prints "on\n"
#define FOO#
BAR
#endif // This ends the if statement. It is not a preprocessor directive.
endin
</CsInstruments>
<CsScore>
f 1 0 16384 10 1
i "N_a_M_e_" 0 2
i "TestOscillator" 2 2
i "TestBitwiseNOT" 0 1
i "TestBitwiseXOR" 0 1
i "TestGoto" 0 1
i "TestMacroPeriodSuffix" 4 1
i "TestAt" 0 1
i "MacroAbuse" 0 1
e
</CsScore>
</CsoundSynthesizer>

error: pathspec 'tests/examplefiles/test.csd' did not match any file(s) known to git


Removed -+rtaudio=null part from this csd file.

OSX/Csound OSX Examples/Csound OSX Examples/ButtonTest/buttonTest.csd

error: pathspec 'OSX/Csound' did not match any file(s) known to git
error: pathspec 'Examples/Csound' did not match any file(s) known to git
error: pathspec 'Examples/ButtonTest/buttonTest.csd' did not match any file(s) known to git


Removed unused instruments.

Removed unused instruments.

OSX/Csound OSX Examples/Csound OSX Examples/SimpleTest1/test.csd

error: pathspec 'OSX/Csound' did not match any file(s) known to git
error: pathspec 'Examples/Csound' did not match any file(s) known to git
error: pathspec 'Examples/SimpleTest1/test.csd' did not match any file(s) known to git