STRUM-IT CAL script

[Alan Kempster]

In his STRUM-IT CAL script Douglas Fetter makes this comment:

" I have included STRUM-IT.TXT which is this very same CAL routine but with full variable names, in a readable structure, & including comments. "

I can't find the STRUM-IT.TXT file anywhere, but would love to read through it. Does anyone have a copy?

[Glenn Stanton]

there is a text section in the beginning of the strum-it.cal file which might be what you're looking for?

per this old thread: http://forum.cakewalk.com/Strum-it-cal-m1432672.aspx

Quote

;;  Strum-It.CAL, written 1991 by Douglas L. Fetter [UID 5476]
;;;
;;  This CAL routine was written to alter chords entered in Step Record mode,
;;  to give them a strummed or arpeggio effect (as for guitar, harp, piano).
;;  A special feature of this Strum-It.CAL routine is that it will actually
;;  sort the notes occurring at the same event time so that when played back
;;  they will be in proper arpeggio low note to high note order. But this low
;;  to high note order is not a restriction, this CAL routine allows the user
;;  to specify a strum that goes instead from high note to low note; or even
;;  an alternating low to high on the 1st chord, high to low 2nd chord, low
;;  to high 3rd chord, etc. as is sometimes played on a guitar or similar
;;  strummed string instrument.
;;;
;;  The user will first be requested to enter the number of ticks to be used
;;  to separate the notes occurring at the same event time to produce a strum
;;  effect. The value a user enters is dependent upon both the tempo of the
;;  piece as well as the number of ticks per quarter note as specified in
;;  the timebase setting. (Experiment with a small section until the desired
;;  strum effect is achieved.)
;;;
;;  Next the user is requested to enter a value which represents the order in
;;  which the strummed notes are to be played (low to high, high to low, or
;;  an alternating order which starts out with a low to high strum first).
;;;
;;  The CAL routine then scans through the note events of the selected track,
;;  looking for those notes which occur at the exact same times. The routine
;;  saves these events in internal buffer space and deletes them from the
;;  track. When a note event of a later time is found, the stored notes are
;;  inserted back into the track in the requested low to high or high to low
;;  order with the start times of these stored chord notes progressively
;;  advanced by the tick value specified by the user. Then, since shifting
;;  notes later in time may cause them to overlap with other notes later in
;;  the track, the durations of each of the shifted notes is reduced by the
;;  number of ticks by which it has been advanced in the creation of this
;;  strum effect.
;;;
;;  (Example specifying Tick Value = 8, and Low to High Order:
;;         ------- Before -------          ------- After --------
;;           Time    Key Vel  Dur            Time    Key Vel  Dur
;;         2:01:000  E 5  64  119          2:01:000  C 5  64  119
;;         2:01:000  C 5  64  119          2:01:008  E 5  64  111
;;         2:01:000  A#5  64  119          2:01:016  F 5  64  103
;;         2:01:000  F 5  64  119          2:01:024  A#5  64   95
;;;
;;  Chords of up to 6 notes can be handled by this CAL routine. If more than
;;  6 notes are found occurring at the same event time, a message will appear
;;  in the bottom status line indicating the Measure:Beat:Tick time where the
;;  more than 6 notes occurs. To abort the process after this error, the user
;;  hits ESC and then uses the Cakewalk Edit UNDO function to get back to the
;;  original unaltered state. However, by hitting any key other than ESC, the
;;  CAL routine will continue to normal completion. At the location where the
;;  more than 6 notes were detected, the first 6 notes found will be properly
;;  sorted & arpeggiated; the additional note(s) found at the same time will
;;  be left unaltered in time and duration.
;;;
;;  USER WARNINGS:
;;   1) As there is considerable processing performed while running this CAL
;;      routine, it runs quite slowly. Therefore, the user is advised to
;;      work first with a small section of a track while adjusting to get a
;;      separating tick value that gives the desired strumming effect.
;;   2) Since the note durations are adjusted downward to compensate for the
;;      the shift of notes later in time, the user must be careful that the
;;      initial note values are long enough such that when reduced they do
;;      not go down to zero or below (which result in note durations which
;;      wrap around the maximum duration value 65535).
;;   3) The user should only run this CAL routine on a single track at a time
;;      since it cannot detect notes at the same time in another track & the
;;      last note events in one track will be inserted back into a subsequent
;;      marked track, which can eventually cause an execution error.
;;;
; ***************************************************************************
; * This CAL routine is pushing the maximum size limitations which Cakewalk *
; * Pro will allow; if the body portion is increased by 30 or more characters
; * it will cause a "Source line/expression too long" ERROR. For this reason*
; * the following executable routine does not make use of longer, meaningful*
; * variable names and the code is not formatted into an indented structure *
; * nor contain comments that would aid readability. For this reason I have *
; * included STRUM-IT.TXT which is this very same CAL routine but with full *
; * variable names, in a readable structure, & including comments. However, *
; * the larger amount of text that this creates will not permit the version *
; * of this CAL routine in STRUM-IT.TXT to be executed.                     *
; ***************************************************************************

;Prolog
;
(do
 (int E 0)            ; EventCnt ; used to provide processing status
 (int C 0)            ; NoteCnt  ; count of notes of 1 chord held in buffers
 (dword T 4294967295) ; NoteTime ; time value of notes being held in buffers
 (dword U)            ; EvntTime ; time of next note event to be processed
 (int M)              ; Measure  ; measure of next note event for error msg
 (int B)              ; Beat     ; beat of next note event for error msg
 (int I)              ; Tick     ; tick of next note event for error msg
 (int D 10)           ; Delta    ; ticks entered by user for note separation
 (int O 0)            ; Offset   ; accumlative delta for chord note separation
 (int H 0)            ; HowStrum ; user enters how strum is to be performed
 (int S)              ; StrumDir ; 0=> Low Note to High, 1=> High Note to Low
 (int X)              ; NextChn  ; channel of next note being processed
 (int Y)              ; ChnBuf1  ; note channel buffer #1 (lowest note)
 (int Z)              ; ChnBuf2  ; note channel buffer #2
 (int a)              ; ChnBuf3  ; note channel buffer #3
 (int b)              ; ChnBuf4  ; note channel buffer #4
 (int c)              ; ChnBuf5  ; note channel buffer #5
 (int d)              ; ChnBuf6  ; note channel buffer #6 (highest note)
 (int e)              ; NextKey  ; key of next note being processed
 (int f)              ; KeyBuf1  ; note key buffer #1 (lowest note)
 (int g)              ; KeyBuf2  ; note key buffer #2
 (int h)              ; KeyBuf3  ; note key buffer #3
 (int i)              ; KeyBuf4  ; note key buffer #4
 (int j)              ; KeyBuf5  ; note key buffer #5
 (int k)              ; KeyBuf6  ; note key buffer #6 (highest note)
 (int l)              ; NextVel  ; velocity of next note being processed
 (int m)              ; VelBuf1  ; note velocity buffer #1 (lowest note)
 (int n)              ; VelBuf2  ; note velocity buffer #2
 (int o)              ; VelBuf3  ; note velocity buffer #3
 (int p)              ; VelBuf4  ; note velocity buffer #4
 (int q)              ; VelBuf5  ; note velocity buffer #5
 (int r)              ; VelBuf6  ; note velocity buffer #6 (highest note)
 (int s)              ; NextDur  ; duration of next note being processed
 (int t)              ; DurBuf1  ; note duration buffer #1 (lowest note)
 (int u)              ; DurBuf2  ; note duration buffer #2
 (int v)              ; DurBuf3  ; note duration buffer #3
 (int x)              ; DurBuf4  ; note duration buffer #4
 (int y)              ; DurBuf5  ; note duration buffer #5
 (int z)              ; DurBuf6  ; note duration buffer #6 (highest note)

 (getInt D "How many ticks should be used to separate strummed notes?" 1 100)
 (getInt H "Direction: 0 => Low to High, 1 => High to Low, 2 => Alternate" 0 2)

 

Edited March 14 by Glenn Stanton