Revision as of 17:57, 27 September 2017

Homework #1: Real-time Audio: Buffers, Callbacks, Waveforms

Due date: 2017.10.3 11:59:59pm, Tuesday.

Let's get cookin'.

Specification (part 1 of 4): Real-time Audio

• create a program that is capable of real-time audio input/output
• give it name (e.g., sig-gen; creative names are always welcome)
  • start with this very basic [1] For an simple introduction to makefiles, check out this link
• next, add real-time audio support, using the RtAudio Library (version 4.0.10 or later)
  • even though it's useful to briefly look through the package, the only files you'll need are:
    • RtAudio.h (the header file for RtAudio, it contains the class definitions)
    • RtAudio.cpp (the implementation)
    • RtError.h (header containing various error handling constructs for RtAudio)
  • it may be useful to browse the RtAudio documentation and the example programs in the RtAudio distribution
• implement the callback function to generate the expect number of samples per call for a sine wave at 440Hz
• the overall behavior when you run the program should be a continuous sine tone at 440hz...
• to quit: press enter

Specification (part 2 of 4): Waveforms

• modify your program to take command line arguments and generate different signals, depending the command line flag you specify:

    sig-gen [type] [frequency] [width]
        [type]: --sine | --pulse | --noise | --impulse
        [frequency]: (a number > 0, no applicable to noise)
        [width]: pulse width (only applicable to pulse)

• where the flags correspond to the following signals:
  • --sine : sine wave
  • --pulse : rectangular pulse wave, the width ([0.0-1.0]) controls the pulse width (e.g., width=.5 should result in a square wave)
  • --noise : white noise
  • --impulse : impluse train, the frequency should determine the impulse train's fundamental period
• it might be a good idea to output the usage (as show above), if insufficient or incorrect parameters are given
• you'll need to implement a simple command line parser, with basic error checking (e.g., what to do when invalid/irrelevant parameters are provided?)
• you'll also need to organize your code a bit, to selectively generate the request signal

See Signal generator hints if needed.

Specification (part 3 of 4): One Ring to Modulate Them All

• Next, add another command line flag:
  • --input : mic/line input (make sure to enable it in the code when initializing RtAudio)
• if specified, this flag tells the program to take the mic/line input and and multiply it against the signal being generated, and output the result!

Specification (part 4 of 4): add ChucK!

• Lastly, added ChucK as a module to your program
• download this boilerplate project that includes ChucK (as library and API)
• modeled after this, add ChucK to your program (or alternately, replace charles.cpp with your .cpp file, and modify the top-level makefile accordingly!)
• study chuck.h in core/, everything you'd need to do is done with this file:
  • instantiate a ChucK object
  • set parameters
  • initialize the ChucK object (initialize(...))
  • compile one or more files (e.g., as specified from the command line)
  • start ChucK
  • very importantly, drive chuck from your callback function
• write a few short ChucK programs to verify the signals your generated in parts 2 and 3
  • sine
  • pulse wave
  • white noise
  • impulse train
  • ring modulating

Note

• have fun with it!!!
• your code should compile and run on the CCRMA machines
• comment your code!
• choose your own coding conventions - but be consistent
• you are welcome to work together, but you must do/turn in your own work (you'll likely get more out of it this way)
• some considerations:
  • how to organize the code for the various types of signals?
  • how much error-checking and error-reporting on the command line arguments?

Testing Audio Output

ChucK code for reference

Deliverables

turn in all files + readme through coursework

• 1) Create a zip/tar file and put all the files in there. The required files are:
  • source code to the project (*.h, *.cpp, *.ck makefile, etc.)
  • a short README text section that:
    • instructions on building the project (for example, anyone in the class should be able to download
    • conveys your ideas/comments in constructing each program
    • describes any difficulties you encountered in the process
    • lists any collaborators
• 2) upload zip/tar file to Canvas!