## Late-breaking news: (Sept., 2009): CSL 5.0 (JUCE) Released

| #### Get the CSL 5.0 Src ZIP file (5.0d: Sept. 16, 2009) #### Get the JUCE 1.50 extensions #### Get the CSL DataZIP #### Get the CSL Doc ZIP #### Go to the CSL mailing list page

## The CREATE Signal Library (CSL) Project

The CREATE Signal Library (CSL, pron. "sizzle") is a cross-platform general-purpose software framework for sound synthesis and digital audio signal processing. It is implemented as a C++ class library to be used as a stand-alone synthesis server, or embedded as a library into other programs.
CSL provides simple and reusable implementations of all common sound synthesis and processing techniques, and includes support for a wide variety of audio I/O interfaces such as PortAudio, RTAudio, JACK, VST, CoreAudio and JUCE. As illistrated in the screen shots below, we generally use JUCE for graphical user interfaces to CSL programs (Qt is also still supported).
In previous versions, it was complicated to install CSL because it used a variety of 3rd-party APIs for sound playback (e.g., PortAudio), sound file I/O (e.g., libSndFile), FFT (e.g., FFTW), and GUI-building (e.g., Qt). As of CSL 5.0, we have based the system on JUCE (Jules' Utility Class Extensions, see here); this means that frameworks for real-time sound I/O, sound file I/O, and GUI construction are the same. Note that we use an extended version of JUCE 1.50; see the download links below for our enhancements.

### CSL Downloads

> #### Documentation

> - ICMC 2006 CSL 4.0 Metamodel Paper
> - CSL Presentation Slides (good quick intro and examples)
> - ICMC 2003 CSL 3 Paper (the best general reference to CSL)
> - CSL "Manual" (obsolete but still useful)
> - Doxygen on-line API manual for CSL 5
> - Get API doc (tgz tarball of Doxygen HTML pages)
> - CSL mailing list admin page
> - For more examples of CSL applications, see here

> #### Source/Data/Doc ZIP files

> - CSL version 5.0 source ZIP file (5.0d: Sept. 16, 2009)
> - CSL Doc (9 MB PDF & Doxygen files)
> - CSL Test Data (99 MB snd files, HRTF data, etc.)
> - CSL "old" code (somewhat stale or unsupported apps)

> #### Support Libraries

> - CSL 5.0 extensions to JUCE 1.50 (added methods for sound file I/O; un-tar this file in the base JUCE folder)
> - CSL support libraries (PortAudio, PortMIDI, LibSndFile, FFTW, etc.) ZIP file with binaries for Intel/Mac (not needed for CSL 5.0)

> #### Related Packages

> - Chandrasekhar Ramakrishnan's Occam (OSC-to-MIDI)
> - Garry Kling's Macco (MIDI-to-OSC)
> - GestureSensor drivers: EBeam, FlockOfBirds, P5 Glove, DataGlove, Matrix, etc. (C++ for MS-Windows)

### Project Description

#### Introduction

The CREATE Signal Library (CSL) is a flexible, portable, and scalable C++ software framework for sound synthesis and digital signal processing. The following sections describe the basic system requirements and present the current design and its implementation, giving extensive code examples along the way. The initial design of CSL dates back to 1998, but the current (version 4.2) implementation was undertaken by students in the MAT 240D Sound Synthesis Techniques course at UCSB in the Spring of 2006. A simple C++ implementation of a sound synthesis framework (in less than 1000 lines) was introduced at the start of the class, and during the quarter the students added a large number of synthesis classes (refining the basic framework significantly as they went). CSL is now an open source project; the current source code and documentation can be retrieved over the Internet from http://FASTLabInc.com/CSL/.

#### What CSL is

CSL is a simple yet powerful library of sound synthesis and signal processing functions. It is packaged as an object-oriented class hierarchy for standard DSP and computer music techniques, and is suitable for integration into existing applications, or use as a stand-alone synthesis/processing server. CSL is similar to the JSyn (Burke), CommonLispMusic (Schottstaedt), STK (Cook), and Cmix (Lansky) frameworks in that it is integrated as a library into a general-purpose programming language, rather than being a separate “sound compiler” as in the Music-N family of languages (Pope). CSL is designed from the ground up to be used in distributed systems, with several CSL programs running as servers on a local-area network. These CSL DSP servers receive control commands via the network and send their output sample blocks to other servers over the network.

#### What CSL is not

CSL is not a music-specific programming language such as Music-N or SuperCollider (McCartney); rather, CSL programs (i.e., CSL-based servers) are written in C++ and compiled with the CSL library. CSL has no graphical user interface (as in Max [Puckette] or Kyma [Scaletti]), but it is expected that GUIs will be built that manipulate “patches” and “scores” for CSL. CSL is not a music representation language such as Smoke (Pope), rather it is a low-level synthesis and processing engine. CSL has no scheduler, it simply responds to in-coming control messages (received, e.g., via MIDI or OSC) as fast as it can.
This flexibility means, however, that CSL can serve a number of different purposes, from being used as a plug-in library for other applications to serving as the basis of synthesis servers for other front-end languages, such as MPEG4/SAOL.

#### CSL and JUCE

In the most recent version, CSL has been simplified to use the sound and sound file I/O facilities of JUCE (Jules' Utility Class Extensions). This means that fewer out-board libraries and APIs need to be installed to start using CSL. Users can still use other sound IO APIs (e.g., portAudio, RTAudio or platform-native APIs) or sound-file APIs (e.g., libSoundFile), but the JUCE-only version is simpler to install and get running. The only 3rd-party library needed for the CSL core is JUCE.

#### The CSL Core

In contrast to the traditional MusicN stand-alone sound compiler, CSL is packaged as a class library in a general-purpose programming language (C++). The simplest CSL program is a 5-line main() function in a simple C program, and it is intended that CSL can be used in several ways, including for the development of stand-alone interactive (MIDIor OSC-driven) sound synthesis programs, serving as a plugin library for other applications or plug-in hosts, or as a back-end DSP library for programs written in scripting languages. CSL is designed from the ground up to be used in distributed systems, where networks of CSL programs run as servers on a local-area network, streaming control commands (MIDI and OSC) and sample buffers (RTP) between them.

#### CSL Example

> // This is a simple FM test program -- paste this into a main() function
> float frq = 440.0f; // float values for freq and dur
> float dur = 0.2f;
> JUCEIO theIO; // create a JUCE IO object
> Sine car, mod(frq); // declare 2 oscillators: carrier and modulator
> // amplitude env = std ADSR
> ADSR a_env(dur, 0.1, 0.1, (dur - 0.6), 1);
> // index env = time/value breakpoints
> Envelope i_env(dur, 0, 0, 0.1, 2, 0.2, 1, 2.2, 8, dur, 0);
> a_env.setScale(0.2); // make ampl envelope quieter
> i_env.setScale(frq * 3.0f); // multiply index envelope by mod freq * 3 (index depth)
> mod.setScale(i_env); // scale the modulator by its envelope
> mod.setOffset(frq); // add in the base freq
> car.setFrequency(mod); // set the carrier's frequency
> car.setScale(a_env); // scale the carrier's output by the amplitude envelope
> logMsg("CSL playing FM..."); // print a message and play
> theIO.setRoot(car); // set the IO's root to be the FM carrier
> theIO.open(); // open the IO
> theIO.start(); // start the driver callbacks and it plays!
> a_env.trigger(); // reset the envelopes to time 0
> i_env.trigger();
> sleepSec(dur + 0.25); // sleep for dur plus a bit
> logMsg("CSL done.");
> theIO.stop(); // stop the driver and close down
> theIO.close();

#### Getting started using CSL

We assume CSL users are proficient C++ programmers and know the native development environment of their platform.

Down-load and unpack JUCE V 1.50 and compile its base library.

Down-load and unpack CSL 5.0 and read the documentation. CSL assumes it's installed in the folder ~/Code/CSL; there are some default settings in CSL/Kernel/CSL_Types.h that have to be changed if you put it somewhere else. The system assumes JUCE is in ~/Code/juce (../juce from the root of the CSL hierarchy).
The best way to get started is to look at the Doxygen-generated API documentation in
Doc/api_doc.tgz
You can untar this file to get the full HTML doc and to print out and study the files
CSL/Kernel/CSL_Types.h (note the system defaults here)
CSL/Kernel/CSL_Core.h (the kernel classes are here)
and
CSL/Sources/SimpleSines.{h,cpp} (this is a tutorial for writing unit generators)
To compile the sources, you may need to create the links in the CSL/Includes folder; to do this, open a UNIX shell (AKA terminal) and execute the commands,
### change to the Includes folder
cd ~/Code/CSL/CSL/Includes

### make symbolic links from the include files to this folder
ln -s ../*/*.h .
ln -s ../Spatializers/*/*.h .

Now, you should be able to use the Mac XCode project in JUCE, the premake script and makefile in Linux, or to build an Eclipse project on Windows. The supplied VisualStudio projects are known to produce errors because of CSL's non-Windows-compatible header and code.

Here's the JUCE demo GUI's Menu List

- Oscillator Tests

  > Simple sines
  > Standard waveforms
  > Scaled sine
  > Wavetable interpolation
  > AM/FM sines
  > Dump AM/FM sines
  > SumOfSines cached
  > SumOfSines non-cached
  > Wavetable from file
  > Sweep test

- Source Tests

  > Noise tests
  > Plucked string
  > Mono Snd file player
  > Stereo Snd file player
  > Snd file transpose
  > FM instrument
  > Snd file instrument
  > Fancy FM instrument
  > IFFT synthesis
  > Vector IFFT

- Envelope Tests

> > Glissando
> > Swell
> > Freq envelope
> > AR sine
> > AR sine 2
> > AM/FM envelopes
> > ADSR 2
> > ADSR FM
> > Rand Freq envelope
> > Envelope scaling
> > Fancy FM

- Effect Tests

> > Clipper
> > FIR filter
> > All filters
> > Dynamic filters
> > Reverb
> > Stereo-verb
> > Multi-tap

- Panner Tests

> > Stereo panner
> > N2M panner
> > Mixer
> > Panning mixer
> > Osc bank
> > CMap IO
> > HRTF horiz circles
> > HRTF axial circles
> > HRTF median circles
> > Ambisonics
> > VBAP

The source code for all these tests is in the CSL/Tests directory (and file group in the IDE); it's a good way to learn CSL to run the JUCE demo in an XCode/Eclipse debugger and set breakpoints in the test functions while using the GUI.

For more information, please contact Stephen Pope [stephen (at) FASTLabInc.com].