SchemeMosaic v0.4 documentation

Table of Contents

Description

SchemeMosaic is a digital music mashup tool inspired by Steven Hazel's soundmosaic. The main technique employed is concatenative synthesis. You can find out more about that on wikipedia.

SchemeMosaic is written in S7 Scheme as an extension to the Snd editor, and is released under the GPL Version 3. Right now SchemeMosaic is under construction, and only tested with Snd 19.7 and greater.

The goal is to reimplement soundmosaic with improved sound quality, new features, and musical intelligence so that it can slice and dice beats and remap tones (and, possibly someday, morph songs into each other with the use of Autotalent and other algorithms.)

SchemeMosaic is designed to assist with making various kinds of electronic music, such as so-called chopped and screwed or vaporwave music. When you run SchemeMosaic, the input file is sliced into (usually) beat-sized regions; these beat-slices are then subject to chopping (rearrangement, repetition, skipping) and screwing (pitch-shifting, time-stretching, and other effects.) With various helper functions, SchemeMosaic will automatically chop and screw according to your specifications. This can include arbitrary Scheme code with the full power of Snd at your disposal.

Future versions will include GUI support (via Snd-GTK and GNU Emacs) for fully interactive chop-and-screw sessions. The goal is a kind of audiovisual exploratory concatenative synthesis. Output can be saved to WAV or FLAC for use with other applications such as Audacity, Mixxx, LMMS, Ardour, and so on.

SchemeMosaic can use Soundtouch to guess the tempo (beats per minute) of a song. The soundstretch command line program must be installed. If you can't get that working, or if the result is inaccurate, try out the BPM detection in Mixxx and enter the number it reports into SchemeMosaic.

New videos

Audio highlights

Various snippets of vaporwavey improvisation.

Installation

See http://xelf.me/guide.html for GNU/Linux and Windows 10 install instructions.

Please see also the Emacs side documentation: http://xelf.me/emacs-mosaic.html

Source code repository

The source code may be found here: https://gitlab.com/dto/mosaic-el

Overview of usage

To get started, load and initialize SchemeMosaic:

(load "/path/to/mosaic.scm") 
(set! (mosaic-project-directory) "/path/to/mydir")
(mosaic-initialize)

The sound slices that SchemeMosaic processes are called regions. SchemeMosaic keeps a special hash table where a set of properties for each region are recorded. Each property list is the descriptor of its region. As stored in the hash table *REGION->PROPERTIES*, these data together with the corresponding regions constitute the database being used for concatenative synthesis. The descriptors are the keys used to search for sounds in the database. You can match against the entire database, or any subset at a time.

The objects that generate sound mosaics are called synths. The main way of getting things done is to call GENERATE-REGIONS on synths of various synth classes, and mix, match, and chain them. SPLICE-SYNTHS or other functions can be used to combine synths.

The object system used by SchemeMosaic is the one included with Snd, defined in stuff.scm and s7test.scm, plus a few tweaks of my own. To avoid conflicts with other programs, I append a caret to the names of the main OO symbols so that you use DEFINE-CLASS^, DEFINE-METHOD^, and MAKE-INSTANCE^. The system it implements is a simplified CLOS.

Using Snd's included Emacs mode is highly recommended when working with SchemeMosaic. In fact, EmacsMosaic depends on it ;) See the included file mosaic.el for more information on EmacsMosaic.

To find your project files easily, you may wish to set (MOSAIC-PROJECT-DIRECTORY) to something like /home/username/myproject/ and then make calls to (PROJECT-FILE FILENAME).

SchemeMosaic creates lots of temporary files. You may wish to increase your system's open files limit. (1024 is not enough.)

Further below is a dictionary for all the important elements of SchemeMosaic. To get an overview of how things work, check out the following entries:

  • SYNTH - Base class for SchemeMosaic sound generators.
  • MOSAIC-SYNTH - Chop'n'screw utility class.
  • MAKE-INSTANCE^ - Make a new object of any class.
  • FILE->SYNTH - Load any sound file into a new synth.
  • MOSAIC-PROJECT-DIRECTORY - Where SchemeMosaic looks for files.
  • PROJECT-FILE - How to look for files.
  • REMEMBER-REGION-PROPERTIES - Selecting what you want to match.
  • MATCH-PROPERTIES - Finding regions that matching properties exactly.
  • FUZZY-MATCH-PROPERTIES - Matching regions more flexibly.
  • MATCH-REGIONS - Matching up regions whose properties match.
  • SHIFT-MATCH-REGIONS - Pitch shifting to correct suboptimal matches.
  • SHUFFLE - Rearranging and processing groups of regions.
  • GENERATE-REGIONS - The synth computes its output.
  • FIND-REGIONS - Cache output on demand.
  • MERGE-SOUND - Concatenate regions into a single sound.
  • SYNTH-SOUND - Concatenate a synth's output into a single sound.
  • MIX-SOUNDS - Mix two sounds.
  • CHAIN-SYNTHS - Connect the input of one synth to the output of another.
  • SPLICE-SYNTHS - Use sound from one synth and structure from another.

Example with audio

Here is an audio sample of SchemeMosaic automatically matching vocal and guitar elements to a backing track that is also chopped and screwed, with a bit of postprocessing in Mixxx and Audacity.

If you want to plug in some files and get going, there is an included function SONG-TEST. Here is the code, which you can copy and modify to get started easily making your own sound mosaics.

(define^ (song-test base-file vocal-file solo-file)
  (let* ((tempo (find-tempo base-file))
	 (slice-size (/ tempo 60 4)) ;; a quarter note, i.e. one beat
	 (vocal (file->synth-verbatim vocal-file slice-size))
	 (solo (file->synth-verbatim solo-file slice-size))
	 (base (make-instance^ 'mosaic-synth
			       :processor (lambda (regions)
					    (map (lambda (r)
						   (shift-region r 0.741))
						 (shuffle-8 regions
							    frasier-8)))
			       :input-file base-file
			       :tempo tempo
			       :slice-size slice-size))
	 (vocal->base (shift-match-synths base vocal))
	 (solo->base (shift-match-synths base solo)))
    (close-all-sounds)
    (let ((sound (new-sound :channels 2)))
      (mix-synth base sound)
      (mix-synth vocal->base sound)
      (mix-synth solo->base sound)
      (arrange-mixes))))

NOTE: You must have the Soundtouch library and Soundstretch command-line program installed for the function FIND-TEMPO to work.

If Snd stutters on playing the mixed tracks together, try saving the file first (with Control-X Control-S) to mixdown the tracks. You can avoid stuttering with proper setup; check the Snd manual for more information.

Differences between SchemeMosaic and the original soundmosaic

  • SchemeMosaic, by default, applies click reduction when merging fragments.
  • SchemeMosaic does not scale source regions to match the amplitude of the target region. This may be added as an option so that results can follow the amplitude contour of the target if desired, but doing it by default can cause problems with a cappella vocals. If a quiet area is matched to a louder one, soundmosaic will scale it up. When this is applied to the near-silences between words in an a cappella vocal track, the result is bursts of loud noise in between better matches.
  • SchemeMosaic can pitch-shift suboptimal pitch matches, and has many other new features.

Known issues

  • After processing with SchemeMosaic, opening the Regions dialog hangs Snd. Call (FORGET-ALL-REGIONS) after SchemeMosaic (but before editing further) if you need to use this dialog.
  • The Motif version of Snd glitches out when using SchemeMosaic due to repeated opening and closing of files. I'm currently working on a fix. In the interim, you should use the GTK version, or suppress the GUI with the "-b" command line option.
  • Time-stretching needs improvement. It isn't terrible, but sounds too reverberated for my taste. Some "new improved" stretching/shifting functions are under construction, and are named STRETCH-REGION* and SHIFT-REGION* instead of SHIFT-REGION and STRETCH-REGION. SchemeMosaic will try to offer several options in each category while choosing reasonable defaults.
  • FIND-STRUCTURE can fail with "no generalized set for symbol-setter" when it is run for the first time. As a workaround, you can run (SEQUITUR-TEST-1) before working with it.
  • MIX-PAIRWISE and MIX-SYNTHS sometimes malfunction and cause Snd to hang. Don't use these two functions for now; instead, use MIX-SOUNDS, MERGE-SOUND, and SYNTH-SOUND. Or better yet, try out MIX-SYNTH (notice there is only one "S") and ARRANGE-MIXES.

Roadmap

  • Fix bugs!
  • Make a nice new set of documented example usages.
  • More synth classes using cool stuff from Snd libraries.
  • Emacs Cell-mode based step sequencer and synth arranger.
  • Full Snd UI integration and menus.
  • Implement rhythm system and allow abstract compositions.
  • MIDI support via ELPA's MIDI-KBD.
  • Looping and live improvisation via Ecasound.

Dictionary

mosaic-synth

"MOSAIC-SYNTH is a utility class for chopping, screwing, and matching multiple elements to a backing track that may itself also be chopped, screwed, etc.

The following keywords are available during initialization with MAKE-INSTANCE^:

  • INPUT-FILE, the file to read and slice.
  • OUTPUT-FILE, the file to write. By default this is (MOSAIC-TEMP-FILE).
  • TEMPO, the number of beats per minute of the INPUT-FILE. The default value #f means to use FIND-TEMPO.
  • SLICE-SIZE, the length in seconds of each slice. The default is a quarter note (relative to the TEMPO).
  • MEASURE-LENGTH, number of beats per measure. By default this is 4.
  • PROCESSOR, a function of one argument (a list of regions to operate on). It can rearrange and transform the regions (nondestructively of course) into new output regions. See SHUFFLE and SHUFFLE-8.
  • SRATE, the sampling rate.

After initialization, the following fields will be filled:

  • INPUT-REGIONS, the sliced input file.
  • OUTPUT-REGIONS, the resulting mosaic.
  • SOUND, the resulting output sound. It will be configured to display beats/measures on the X axis, and you can use (ENABLE-SNAP-MARK-TO-BEAT) to position marks on beats in Snd. See also: DISABLE-SNAP-MARK-TO-BEAT, ENABLE-SNAP-MIX-TO-BEAT.
  • SOURCE-REGIONS, the same as INPUT-REGIONS.
  • TARGET-REGIONS, the same as OUTPUT-REGIONS.

These last two are for chaining mosaic-synths with other synths. See also CHAIN-SYNTHS and SPLICE-SYNTHS.

Unlike other SYNTH classes, all the processing is done during INITIALIZE-INSTANCE. GENERATE-REGIONS just returns the mosaic-synth's OUTPUT-REGIONS."

synth

"SYNTH is the SchemeMosaic base class for concatenative synthesis generators. Each synth object is both a consumer and producer of regions. The following slots are available to initialize with keyword arguments during MAKE-INSTANCE^:

  • TARGET-REGIONS, the sequence of regions you are trying to reconstruct or emulate.
  • SOURCE-REGIONS, the sequence of regions to choose from during matching against the TARGET-REGIONS. The output will be composed of these, or some transformation thereof.
  • RANDOM-MATCH?, telling the synth whether to randomly choose one match whenever multiple simultaneous matches occur. By default this is set to #t. When this is #f instead, the first match is always chosen.
  • PARAMS-FN, a function to compute the descriptors. This is optional and by default is REGION->DESCRIPTOR, which caches commonly used properties.

During initialization of a synth object, the following slots are filled automatically based on the parameters given to MAKE-INSTANCE^:

  • DESCRIPTORS, the sequence of property alists corresponding to each of the TARGET-REGIONS.
  • GRAMMAR, a set of production rules derived from structural analysis of the DESCRIPTORS.
  • AXIOM, a mixed sequence containing both variables and descriptors, which expands back into DESCRIPTORS when passed to GENERATE-PHRASE.

Aside from INITIALIZE-INSTANCE, the main way of using a synth after creation is to call its GENERATE-REGIONS (or FIND-REGIONS) method with a suitable phrase (i.e. a suitable sequence of descriptors that the synth will attempt to match in its output.) "

(all-suffixes symbol seq)

#<unspecified>

(annotate property region (value #t))

#<unspecified>

(annotate-up-and-down-beats-8 a b c d e f g h)

#<unspecified>

(append-symbol s (seq *sequence*))

#<unspecified>

(append-trailing-slash string)

"Return a copy of STRING with a slash appended."

(arrange-mixes)

"Spread out mixes vertically so they don't overlap."

(chain-synths (s1 synth) s2 (phrase #f))

"Make a copy of S1, but with the generated regions of S2 spliced in as the SOURCE-REGIONS (or concatenated as INPUT-FILE, in the case of mosaic-synths) of S1. INITIALIZE-INSTANCE is called on the new synth. PHRASE is passed through to GENERATE-REGIONS when obtaining the output of S2."

(cleanup)

"Free up resources."

(clear-resources)

#<unspecified>

(close-all-sounds)

"Close all Snd sounds."

(close-other-sounds sound)

"Close all sounds except SOUND."

(configure-sound-for-mosaic sound tempo measure-length)

"Set up the properties of SOUND to display musical time."

(convert-rule simple-rule (params-fn (lambda (s) (list s))))

#<unspecified>

(count-uses search-symbol)

#<unspecified>

(current-synth)

#<unspecified>

(current-synth?)

#<unspecified>

(define-class^ class-name inherited-classes (slots ()) (methods ()))

"Define a new class."

(define-method^ (name (instance class) :rest body))

"Define a new method."

(define-selection-via-marks-here)

"Select the area between the markers surrounding the cursor."

(del-assoc key lst)

#<unspecified>

(delete-last-symbol!)

#<unspecified>

(delete-rule! deleted-symbol)

#<unspecified>

(descriptor-properties-only properties)

"The function DESCRIPTOR-PROPERTIES-ONLY removes floating point properties from the alist PROPERTIES. A descriptor must contain only discrete properties to be matched, i.e. no floating point numbers allowed.

This function also removes the special POSITION property. Position is a discrete property, but should be matched through other means."

(descriptor? x)

"Return #t if the argument X is a region descriptor."

(disable-snap-mark-to-beat)

"Allow marks to be positioned anywhere."

(disable-snap-mix-to-beat)

"Allow mixes to be positioned anywhere."

(echo-sound sound (time 0.25) (scaler 0.4))

"Add delay (echo) to a sound. Try using (quarter-note) or (eighth-note) as values for TIME."

(eighth-note)

#<unspecified>

(emacs-mosaic?)

"Return #t if EmacsMosaic is present."

(emit-org-entries)

#<unspecified>

(enable-snap-mark-to-beat)

"Make sure dragged marks always end up on beat boundaries."

(enable-snap-mix-to-beat)

"Make sure dragged mixes always end up on beat boundaries."

(enforce-utility!)

#<unspecified>

(ensure-phrase (s synth) phrase)

"Return a default phrase for this synth if PHRASE is #f."

(expand-selection-to-all-channels)

"Expand the current selection to all channels of the current sound."

(extend-left-maybe! sym)

#<unspecified>

(extend-right-maybe! sym)

#<unspecified>

(extract-channel filename snd chn)

#<unspecified>

(file->synth file (slice-size (mosaic-slice-size)))

"Load FILE into a new synth at slice size SLICE-SIZE."

(file->synth-verbatim file (slice-size (mosaic-slice-size)))

"Load FILE into a new PASS-THROUGH-SYNTH at slice size SLICE-SIZE."

(find-axiom grammar)

"Return the axiom sequence of GRAMMAR."

(find-grammar regions)

"Return the grammar found by FIND-STRUCTURE when analyzing REGIONS."

(find-highest-amplitudes region)

#<unspecified>

(find-pair seq a b)

#<unspecified>

(find-regions (s synth) (phrase #f) (force? #f))

"FIND-REGIONS is a caching front end to GENERATE-REGIONS. When you call FIND-REGIONS for the first time on a synth, the OUTPUT-REGIONS slot will be filled with the result of GENERATE-REGIONS, and the next time FIND-REGIONS is called it will return the cached OUTPUT-REGIONS unless the FORCE? argument is given."

(find-resource-file index)

#<unspecified>

(find-sound-structure regions (show? #f) (properties-fn descriptor-properties-only))

"Return the structure Sequitur finds for REGIONS. SHOW? determines whether to show each step for debugging. PROPERTIES-FN should remove any properties you don't want to match on. By default this is DISCRETE-PROPERTIES-ONLY."

(find-structure seq (reparse? #f) (show? #f))

"Return a hash table of production rules characterizing the structure found by Sequitur upon analyzing SEQUENCE. The argument SHOW? means whether to display each step; this is used for debugging. The parameter REPARSE? indicates whether to use oblivious reparsing, but this is not yet implemented."

(find-tempo file)

"Attempt to use Soundtouch to find tempo of FILE."

(flatten lst)

#<unspecified>

(float-vector->region fv)

#<unspecified>

(forget-all-region-properties)

"Clear all cached region properties."

(forget-all-regions)

"Forget all Snd regions."

(forget-region-properties region)

"Clear the cached properties of REGION."

(framples* r)

#<unspecified>

(fuzzy-match-descriptors descriptor-1 descriptor-2 (match-fn equal?))

#<unspecified>

(fuzzy-match-properties properties regions (match-fn equal?))

"Similar to MATCH-PROPERTIES, but matches two regions if any property value is MATCH-FN between them, whereas regular MATCH-PROPERTIES requires that all property values match."

(generate-phrase grammar phrase)

"Expand PHRASE using the rules in GRAMMAR."

(generate-regions (s synth) (phrase #f))

"Generate a new sound (as a sequence of regions) from the current synth. Return a sequence of regions matching the sequence of properties that expands from PHRASE. See also GENERATE-PHRASE and the functions RESYNTHESIS-TEST-1 and RESYNTHESIS-TEST-2 etc. If not supplied with a PHRASE, the synth will choose the axiom (i.e. the entire structure.) You can use (SHOW-GRAMMAR (MY-SYNTH 'GRAMMAR)) to get an idea what values to try giving for PHRASE."

(grammar-rule grammar symbol)

#<unspecified>

(half-note)

#<unspecified>

(identity-regions regions)

#<unspecified>

(initialize-instance (s synth))

"This method is called after an object is created. As in any method you define with DEFINE-METHOD^, you can use (CALL-NEXT-METHOD) within the body to invoke the parent class method."

(initialize-mosaic)

"Set up the Snd environment for SchemeMosaic. This will increase Snd's maximum region limit to a high number."

(insert-region* r pos snd chn)

#<unspecified>

(join-regions a b)

"Return a new region that is the concatenation of regions A and B."

(kodaly-regions (slice-size *kodaly-slice-size*))

#<unspecified>

(last-symbol (seq *sequence*))

#<unspecified>

(loudest-freqs pairs (n 2))

#<unspecified>

(loudest-notes pairs (n 2))

#<unspecified>

(make-graphable seq)

#<unspecified>

(make-instance^ class . args)

"Create a new object instance of class CLASS with the initialization keyword argument/value pairs in ARGS."

(make-region* beg end snd chn)

#<unspecified>

(make-variable-name)

#<unspecified>

(match-properties properties regions (match-fn equal?))

"Return a list of regions from REGIONS (if any) matching PROPERTIES. This is also used by GENERATE-REGIONS. By default, the REGIONS come from the current synth's SOURCE-REGIONS; if these are empty, then from TARGET-REGIONS. If this isn't what you want, pass the REGIONS you want to search instead. MATCH-FN determines the equality test used for matching descriptors. To match against the entire database instead of just the contents of this synth, pass (MOSAIC-ALL-REGIONS) as the REGIONS argument."

(match-regions score-function target-regions source-regions)

"Attempt to match each region in TARGET-REGIONS with its \"best match\" in SOURCE-REGIONS. The regions are compared via SCORE-FUNCTION, which by default is PITCH-DISTANCE. MATCH-REGIONS returns a list of regions chosen from SOURCE-REGIONS chosen to best match (in each case) their respective TARGET-REGIONS. See also MATCH-PROPERTIES and FUZZY-MATCH-PROPERTIES."

(match-synths s1 s2)

"Make a new MATCH-SYNTH matching the output of synth S2 to the output of synth S1."

(merge-pairwise snd chn regions1 regions2)

"Merge REGIONS-1 and REGIONS-2 pairwise into the sound SND, but align the beginnings of respective region pairs so that the outcome is the same as having used MIX-PAIRWISE first and then MERGE-SOUND."

(merge-sound snd regions)

"Merge a list of REGIONS into one sound, SND. Applies click reduction."

(merge-sound-insert snd (chn 0) regions)

#<unspecified>

(merge-sound-insert-raw snd (chn 0) regions)

#<unspecified>

(merge-sound-insert^ fn snd (chn 0) regions)

#<unspecified>

(merge-sound-raw snd regions)

"Merge a list of REGIONS into one sound, SND. Does not apply click reduction."

(mix-pairwise regions1 regions2)

"Return a list of regions where the first of each set are mixed together, the second of each set, etc. The output regions are the same size as the longer of the two regions being mixed at each step."

(mix-pulse a)

#<unspecified>

(mix-regions a b)

"Return a new region that is the mix of regions A and B."

(mix-sounds a b)

"Return a new sound that is the mix of sounds A and B."

(mix-synth syn sound name)

"Mix the output of the synth SYN into the sound SOUND. You may wish to call ARRANGE-MIXES after several uses of MIX-SYNTH."

(mix-synths s1 s2)

"Mix pairwise the output regions of S2 into those of S1, and return a new synth whose Sequitur structure is retained from S1 but whose regions are mixed together."

(mixdown :rest spec)

"Mix multiple sounds with amplitudes applied. Example: (MIXDOWN MY-SOUND-1 0.8 MY-SOUND-2 0.5 …)"

(mixdown-synths :rest spec)

"Like MIXDOWN, but the sound arguments are synths."

(morph-match-synths target-synth source-synth (tolerance 5.0))

"Make a new synth morphing the output of synth SOURCE-SYNTH to the output of synth TARGET-SYNTH. The regions of SOURCE-SYNTH are matched, pitch-shifted, and then stretched to the length of the regions of TARGET-SYNTH. The TOLERANCE argument only affects shift-matching."

(mosaic-a4-pitch)

"Master tuning parameter. Pitch of A above middle C. You can set this with (SET! (MOSAIC-A4-PITCH) VALUE)."

(mosaic-all-regions)

"Return a list of all the regions in the database."

(mosaic-output-file)

"Where to place final SchemeMosaic output for this run."

(mosaic-project-directory)

"Base directory for finding project files. See also PROJECT-FILE. You can set this with (SET! (MOSAIC-PROJECT-DIRECTORY) \"/my/path\""

(mosaic-resource index)

#<unspecified>

(mosaic-session-directory)

"Base directory for finding session files. See also SESSION-FILE. You can set this with (SET! (MOSAIC-SESSION-DIRECTORY) \"/my/path\")"

(mosaic-slice-size (tempo *mosaic-beats-per-minute*) (divisor *mosaic-beats-per-measure*))

#<unspecified>

(nonterminal? symbol)

#<unspecified>

(normalize-region-properties! region)

"Rewrite a region's property list so that the alist entries are sorted alphabetically by property name. This is done to set up property alists for comparison with EQUAL? and other functions."

(note->pitch note)

"Return the pitch of MIDI note NOTE."

(note-lists-only properties)

#<unspecified>

(org-docstring spec)

#<unspecified>

(pair-symbol a b)

#<unspecified>

(pair-variable a b)

#<unspecified>

(pitch->note pitch)

"Return the MIDI note number closest to PITCH."

(pitch-distance region-1 region-2)

#<unspecified>

(prefixes symbol seq)

#<unspecified>

(process-sound^ func block-len snd chn)

#<unspecified>

(project-file file)

"Return the full path name of FILE within your project directory. To access subdirectories you can put slashes in the FILE argument."

(pulse-mosaic file bpm)

#<unspecified>

(quarter-note)

#<unspecified>

(quiet-region region)

#<unspecified>

(random-choose lst)

#<unspecified>

(record-pair! a b c)

#<unspecified>

(reduce-clicks pos len snd chn)

"Attempt to reduce clicks at edges of concatenated sections."

(region->descriptor r)

"Default function for mapping a region to its descriptor. Here we pre-cache spectra, pitch, and note properties by default when regions are added to a synth."

(region-loudest-pitch region)

#<unspecified>

(region-note* region)

#<unspecified>

(region-notes* region)

#<unspecified>

(region-pitch* region)

#<unspecified>

(region-pitch-simple region)

#<unspecified>

(region-pitches* region)

#<unspecified>

(region-property property region)

"Return the value of property PROPERTY for REGION."

(region-spectrum* region)

#<unspecified>

(remember-region-properties names region)

"Cache the properties listed in NAMES for REGION. This currently only works for SPECTRUM, PITCH, NOTE, PITCHES, and NOTES. Of these, the first three are cached by default anyway upon loading into a synth; if you want to analyze NOTES etc, do: (REMEMBER-REGION-PROPERTIES '(NOTES) MY-REGION) first."

(remove-duplicates* seq (eq-func? equal?))

#<unspecified>

(remove-duplicates** seq (eq-func? equal?))

#<unspecified>

(reparse! (seq *sequence*))

#<unspecified>

(replace-pair! seq a b c)

#<unspecified>

(resynthesis-test-1)

#<unspecified>

(resynthesis-test-1a)

#<unspecified>

(resynthesis-test-2)

#<unspecified>

(resynthesis-test-2a)

#<unspecified>

(resynthesis-test-2b)

#<unspecified>

(resynthesis-test-2c)

#<unspecified>

(rewrite-expansion! expansion symbol definition)

#<unspecified>

(rule-expansions g)

#<unspecified>

(rule-variable g)

#<unspecified>

(save-region* region file)

#<unspecified>

(scale-region region (amp 1.0))

"Amplify REGION by AMP."

(scan-sound^ func block-len snd chn (save-position? #t))

"Scan through a sound and call (FUNC beg end snd chn) for each block of BLOCK-LEN seconds in length, collecting the results in a list."

(search-mark-backward pos snd chn)

#<unspecified>

(search-mark-forward pos snd chn)

#<unspecified>

(second-last-symbol (seq *sequence*))

#<unspecified>

(seen-pair? a b)

#<unspecified>

(sequitur-test-1 (reparse? #f) (show? #f))

#<unspecified>

(sequitur-test-2 (reparse? #f) (show? #f))

#<unspecified>

(session-file file)

"Return the full path name of FILE within your session directory. To access subdirectories you can put slashes in the FILE argument."

(set-mosaic-a4-pitch value)

#<unspecified>

(set-region-property! property region value)

"Set the value of PROPERTY in REGION to VALUE."

(shift-match-regions target-regions source-regions (tolerance 5.0))

"Works like MATCH-REGIONS, but pitch shifts the best match if the best match is more than TOLERANCE Hz off the target pitch."

(shift-match-synths s1 s2 (tolerance 5.0))

"Make a new SHIFT-MATCH-SYNTH matching the output of synth S2 to the output of synth S1."

(shift-region region factor)

"Pitch shift REGION by FACTOR."

(shift-region* region factor)

#<unspecified>

(show-grammar grammar)

"Display the rules of GRAMMAR."

(show-progress s)

#<unspecified>

(show-structure (grammar *symbols*))

#<unspecified>

(shuffle regions pattern (amount 1.0))

"Rearrange the REGIONS according to the PATTERN. Every group of four regions is bound to variables A B C D and then PATTERN is evaluated to produce the results. Specify (D C B A) instead to reverse every four regions, and so on. Because PATTERN is evaluated, you can include arbitrary code modifying the regions A, B, C, and D in any way you like, including SHIFT-REGION, STRETCH-REGION, and so on."

(shuffle-8 regions pattern (amount 1.0))

"Like SHUFFLE, but taking eight regions at a time and giving eight variables: A B C D E F G H."

(silent-region region)

"Return a silent region the same length as REGION."

(simple-drum)

#<unspecified>

(simple-expansion symbol)

#<unspecified>

(sixteenth-note)

#<unspecified>

(skatter-regions regions)

#<unspecified>

(skitter-regions regions)

#<unspecified>

(snap-all-marks-to-beat snd chn)

"Snap all marks to beats in the sound SND, without having to drag them. This doesn't enable or disable snapping of dragged marks to beats, it just moves them."

(song-test base-file vocal-file solo-file)

#<unspecified>

(sort-frequencies amps freqs)

#<unspecified>

(sound->region! name-or-sound)

"Convert SOUND (object or filename) to a region. Closes SOUND."

(special-match* var input)

#<unspecified>

(speed-region region factor)

#<unspecified>

(splice-synths s1 s2)

"Make a copy of S1, but with the TARGET-REGIONS of S2 spliced in as the SOURCE-REGIONS of S1. The new synth keeps S1's class, Sequitur structure, and other data. See also RESYNTHESIS-TEST-2."

(split-sound-to-regions block-len snd (chn 0))

"Split the sound SND into regions of size SLICE-SIZE seconds in length."

(startup)

"Begin with a clean slate, no sounds open, and all resources cleared up."

(stretch-match-regions target-regions source-regions (stretch-fn stretch-region))

"Works like MATCH-REGIONS, but stretches the SOURCE-REGIONS to match the lengths of their corresponding TARGET-REGIONS. Because SchemeMosaic's stretch functions still need work, the result may be less than optimal. Try passing STRETCH-REGION* (or your own function) instead of STRETCH-REGION."

(stretch-match-synths s1 s2)

"Make a new STRETCH-MATCH-SYNTH stretching the output of synth S2 to the output of synth S1."

(stretch-region region factor)

"Time stretch REGION by FACTOR."

(stretch-region* region factor)

#<unspecified>

(structure-rules structure)

#<unspecified>

(suffixes symbol seq)

#<unspecified>

(synth-sound s)

"Return a new sound composed of the generated regions of the synth S."

(takes2-regions (slice-size *kodaly-slice-size*))

#<unspecified>

(terminal? symbol)

#<unspecified>

(trailing-slash? string)

"Return #t if there is a slash at the end of STRING."

(try-match t score-function source)

#<unspecified>

(useful-rule? search-symbol)

#<unspecified>

(vaporwave (pattern vapor-8))

#<unspecified>

(variables)

#<unspecified>

(verify-all-terminals phrase)

#<unspecified>

(violin-region (start-time 0) duration frequency amplitude)

#<unspecified>

(warp region (shift 1.0) (stretch 1.0) (seglen 0.15) (hop 0.05) (ramp 0.01))

#<unspecified>

(whitney-regions (slice-size *kodaly-slice-size*))

#<unspecified>

(whole-note)

#<unspecified>

(write-error-timestamp-file text)

#<unspecified>

(write-timestamp-file (n #f))

#<unspecified>

Author: David O'Toole <dto@xelf.me>

Created: 2019-12-04 Wed 11:09

Validate