CREATE Logo

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

CSL demo GUI

The CREATE Signal Library (CSL) Project CSL classes

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

Related Packages

CSL Granulator 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

CSLL Spectrogram 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

oscillator classses

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

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].

line