Added single stream read/write, callback capability

README.md

@@ -106,14 +106,31 @@ AudioStream is an abstract type, which currently has a PortAudioStream subtype
 that writes to the sound card, and a TestAudioStream that is used in the unit
 tests.
 
-Currently only 1 stream at a time is supported so there's no reason to provide
+With the method PortAudioStream, which uses the default input and output device(s), 
+only 1 stream at a time is supported, so there's no reason to provide
 an explicit stream to the `play` function. The stream has a root mixer field
 which is an instance of the AudioMixer type, so that multiple AudioNodes
 can be heard at the same time. Whenever a new frame of audio is needed by the
 sound card, the stream calls the `render` method on the root audio mixer, which
 will in turn call the `render` methods on any input AudioNodes that are set
 up as inputs.
 
+When a Pa_AudioStream is created via a call to 
+Pa_AudioStream(device_index, channels=2, input=false,
+                              sample_rate::Integer=44100,
+                              framesPerBuffer::Integer=2048,
+                              show_warnings::Bool=false,
+                              sample_format::PaSampleFormat=paInt16,
+                              callback=0)
+a single stream is opened for reading or writing. This returns a Pa_AudioStream on success, 
+which is used either via the functions AudioIO.read(::Pa_AudioStream) or 
+AudioIO.write(::Pa_AudioStream, buffer) for read and write respectively.
+
+If nonblocking I/O is needed, a callback may be passed to the Pa_AudioStream constructor, 
+which is provided by the user and should return a buffer of frames if used for output and should
+handle a buffer of frames as an argument if used as input. This is similar
+to the methods used by PyAudio's python interface to PortAudio. See the examples also.
+
 Installation
 ------------
 

REQUIRE

@@ -1,4 +1,5 @@
 julia 0.3-
 BinDeps
+Compat
 @osx Homebrew
 @windows WinRPM

examples/callback_bands.jl

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+# Examples for Julia AudioIO module
+
+# display relative (not absolute) dB of bass, mid, treble bands
+
+using AudioIO, DSP
+
+
+"""
+Custom callback for read, processes passed data array
+"""
+function process_read(buf)
+    fchunk = map(Float64, buf)
+    pgram = welch_pgram(fchunk, 4096, 0, fs=SRATE*CHANNELS)
+    pxx = power(pgram)
+    frqs = freq(pgram)
+    bass = log(sum(abs(pxx[(frqs .<= 640.0) & (frqs .> 100.0)])))
+    midrange = log(sum(abs(pxx[(frqs .<= 5120.0) & (frqs .> 640.0)])))
+    treble = log(sum(abs(pxx[(frqs .<= 20480.0) & (frqs .> 5120.0)])))
+    println("bass $bass, midrange $midrange, treble $treble")
+end
+
+CHUNKSIZE = 40960
+FORMAT = AudioIO.paInt16
+CHANNELS = Cint(2)
+SRATE = 44100
+istream = AudioIO.open_read(Cint(0), CHANNELS, SRATE, CHUNKSIZE,
+                            false, FORMAT, process_read)
+println("Starting callback type reading, control-C to stop")
+
+while true
+    sleep(20)
+end

examples/callback_read_write.jl

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+
+# Examples for Julia AudioIO module
+
+using AudioIO
+
+CHUNKSIZE = 40960
+FORMAT = AudioIO.paInt16
+CALLBACK_DATATYPE = AudioIO.PaSampleFormat_to_T(FORMAT)
+CHANNELS = 2
+SRATE = 44100
+RECORD_SECONDS = 3
+
+BUFFER = zeros(Int16, SRATE * RECORD_SECONDS * 4)
+BUFSIZE = SRATE * RECORD_SECONDS
+
+"""
+choose the devices for 2 channel IO
+"""
+function choose_input_output()
+    devices = get_audio_devices()
+    indev = -1
+    outdev = -1
+    for aud in devices
+        println("$(aud.device_index) $(aud.name)")
+        if (aud.max_input_channels == CHANNELS) & (indev == -1 )
+            indev = aud.device_index
+        end
+        if(aud.max_output_channels == CHANNELS) & (outdev == -1)
+            outdev = aud.device_index
+        end
+    end
+    if indev == -1
+        info("Appropriate input device not found.")
+    elseif outdev == -1
+        info("Appropriate output device not found.")
+    else
+        info("Using input device ", bytestring(devices[indev + 1].name), 
+             ", number ", devices[indev + 1].device_index, 
+             " and output device ", bytestring(devices[outdev + 1].name), 
+             ", number ", devices[outdev + 1].device_index)
+    end
+    return indev, outdev
+end
+
+read_position = 0
+"""
+Custom callback for read, processes passed data array
+"""
+function store_read(buf)
+    read_size = length(buf)
+    global read_position
+    if read_position + read_size > length(BUFFER)
+        read_size = length(BUFFER) - read_position
+    end
+    if read_size > 0
+        BUFFER[read_position + 1 : read_position + read_size] = 
+            buf[1: read_size]
+        read_position += read_size
+    end
+end
+
+write_position = 0
+"""
+Custom callback for write, returns data array
+"""
+function get_writeable()
+    write_size = CHUNKSIZE * CHANNELS
+    global write_position
+    if write_position + write_size > length(BUFFER)
+        write_position = length(BUFFER) - write_size
+        retval = 1
+    end
+    start_position = write_position + 1
+    write_position += write_size
+    buf = BUFFER[start_position: write_position]
+    buf
+end
+
+INS, OUTS = choose_input_output()
+
+istream = AudioIO.open_read(INS, CHANNELS, SRATE, CHUNKSIZE,
+                            false, FORMAT, store_read)
+println("Started callback type reading device number $INS")
+sleep(5)
+AudioIO.Pa_CloseStream(istream.stream)
+
+ostream = AudioIO.open_write(OUTS, CHANNELS, SRATE, CHUNKSIZE, 
+                             false, FORMAT, get_writeable)
+println("Started callback type writing device number $OUTS")
+sleep(3)
+AudioIO.Pa_CloseStream(ostream.stream)

examples/read_and_write.jl

@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+
+# Examples for Julia AudioIO module
+
+using AudioIO
+
+CHUNKSIZE = 40960
+FORMAT = AudioIO.paInt16
+CHANNELS = 2
+SRATE = 44100
+RECORD_SECONDS = 3
+
+BUFFER = zeros(Int16, SRATE * RECORD_SECONDS * 4)
+BUFSIZE = SRATE * RECORD_SECONDS
+
+"""
+choose the devices for 2 channel IO
+"""
+function choose_input_output()
+    devices = get_audio_devices()
+    indev = -1
+    outdev = -1
+    for aud in devices
+        println("$(aud.device_index) $(aud.name)")
+        if (aud.max_input_channels == CHANNELS) & (indev == -1 )
+            indev = aud.device_index
+        end
+        if(aud.max_output_channels == CHANNELS) & (outdev == -1)
+            outdev = aud.device_index
+        end
+    end
+    if indev == -1
+        info("Appropriate input device not found.")
+    elseif outdev == -1
+        info("Appropriate output device not found.")
+    else
+        info("Using input device ", bytestring(devices[indev + 1].name), 
+             ", number ", devices[indev + 1].device_index, 
+             " and output device ", bytestring(devices[outdev + 1].name), 
+             ", number ", devices[outdev + 1].device_index)
+    end
+    return indev, outdev
+end
+
+"""
+read from input
+"""
+function read_blocking(devnum, buffer)
+    instream = AudioIO.open_read(devnum, CHANNELS, SRATE, CHUNKSIZE)
+    buf = AudioIO.read(instream, BUFSIZE)
+    buflen = length(buf)
+    buffer[1: buflen] = buf[1: buflen]
+    AudioIO.Pa_CloseStream(instream.stream)
+end
+
+"""
+write to output
+"""
+function write_blocking(devnum, buffer)
+    outstream = AudioIO.open_write(devnum, CHANNELS, SRATE, CHUNKSIZE)
+    AudioIO.write(outstream, buffer)
+    AudioIO.Pa_CloseStream(outstream.stream)
+end
+
+"""
+Create a string of numbers representing a sinewave audio tone
+"""
+function make_note_buffer(frequency, amplitude, duration, srate)
+    N = round(Int, srate / frequency)
+    T = round(Int, frequency * duration)  # repeat for T cycles
+    dt = 1.0 / srate
+    tone = zeros(Int16, (N + N) * T)
+    idx = 1
+    while idx < (N + N) * T
+        tone[idx] = round(Int, amplitude * sin(2 * pi * frequency * 
+                                idx * dt) * 32767.0)
+        tone[idx + 1] = tone[idx]
+        idx += 2
+    end
+    tone
+end
+
+"""
+Write a note to output device
+"""
+function play_note(frequency, amplitude, duration, srate, ostream)
+    note = make_note_buffer(frequency, amplitude, duration, srate)
+    AudioIO.write(ostream, note)
+end
+
+INS, OUTS = choose_input_output()
+
+read_blocking(INS, BUFFER)
+println("Finished blocking type reading device number $INS")
+println("Recording volume is $(mean(abs(BUFFER))*(100/16783))% of max")
+sleep(2)
+
+write_blocking(OUTS, BUFFER)
+println("Finished blocking type writing device number $OUTS")
+
+outstream = AudioIO.open_write(OUTS, CHANNELS, SRATE, CHUNKSIZE)
+# play the C major scale
+scale = [130.8, 146.8, 164.8, 174.6, 195.0, 220.0, 246.9, 261.6]
+for note in scale
+    play_note(note, 0.1, 0.75, SRATE, outstream)
+end
+# up an octave
+for note in scale[2:8]
+    play_note(2*note, 0.1, 0.75, SRATE, outstream)
+end

examples/record_to_wav.jl

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+
+# Examples for Julia AudioIO module
+
+using AudioIO
+using WAV
+
+CHUNKSIZE = 40960
+FORMAT = AudioIO.paInt16
+CHANNELS = 2
+SRATE = 44100
+RECORD_SECONDS = 20
+
+"""
+choose the devices for 2 channel IO
+"""
+function choose_input_output()
+    devices = get_audio_devices()
+    indev = -1
+    outdev = -1
+    for aud in devices
+        println("$(aud.device_index) $(aud.name)")
+        if (aud.max_input_channels == CHANNELS) & (indev == -1 )
+            indev = aud.device_index
+        end
+        if(aud.max_output_channels == CHANNELS) & (outdev == -1)
+            outdev = aud.device_index
+        end
+    end
+    if indev == -1
+        info("Appropriate input device not found.")
+    elseif outdev == -1
+        info("Appropriate output device not found.")
+    else
+        info("Using input device ", bytestring(devices[indev + 1].name), 
+             ", number ", devices[indev + 1].device_index, 
+             " and output device ", bytestring(devices[outdev + 1].name), 
+             ", number ", devices[outdev + 1].device_index)
+    end
+    return indev, outdev
+end
+
+"""
+read from input
+"""
+function record_audio(devnum, seconds)
+    instream = AudioIO.open_read(devnum, CHANNELS, SRATE, CHUNKSIZE)
+    bufsize = seconds * SRATE
+    buf = AudioIO.read(instream, bufsize)
+    AudioIO.Pa_CloseStream(instream.stream)
+    buf
+end
+
+"""
+write to WAV file
+"""
+function write_as_WAV(buffer, filename="temp.WAV")
+    fio = open(filename, "w")
+    WAV.wavwrite(deinterlace_stereo(buffer), fio, Fs=SRATE)
+end
+
+"""
+interlaced to noninterlaced stereo data
+"""
+function deinterlace_stereo(buffer)
+    reshape([buffer[1:2:end]; buffer[2:2:end]], 
+            (floor(Int, length(buffer)/2), 2))
+end
+
+INS, OUTS = choose_input_output()
+
+println("Starting recording...")
+BUF = record_audio(INS, RECORD_SECONDS)
+println("Finished reading from device number $INS")
+println("Recording volume was $(mean(abs(BUF))*(100/16783))% of max")
+
+write_as_WAV(BUF)
+println("Finished writing to WAV file.")

src/AudioIO.jl

@@ -1,7 +1,9 @@
 module AudioIO
+using Compat
+importall Base.Operators
 
 # export the basic API
-export play, stop, get_audio_devices
+export play, stop, get_audio_devices, open_read, open_write, read, write
 
 # default stream used when none is given
 _stream = nothing

src/nodes.jl

@@ -13,7 +13,7 @@ end
 
 # Generates a sin tone at the given frequency
 
-type SinOscRenderer{T<:Union(Float32, AudioNode)} <: AudioRenderer
+@compat type SinOscRenderer{T<:Union{Float32, AudioNode}} <: AudioRenderer
     freq::T
     phase::Float32
     buf::AudioBuf
@@ -124,7 +124,7 @@ end
 Base.push!(mixer::AudioMixer, node::AudioNode) = push!(mixer.renderer.inputs, node)
 
 #### Gain ####
-type GainRenderer{T<:Union(Float32, AudioNode)} <: AudioRenderer
+@compat type GainRenderer{T<:Union{Float32, AudioNode}} <: AudioRenderer
     in1::AudioNode
     in2::T
     buf::AudioBuf
@@ -228,7 +228,7 @@ function play(arr::AudioBuf, args...)
 end
 
 # If the array is the wrong floating type, convert it
-function play{T <: FloatingPoint}(arr::Array{T}, args...)
+@compat function play{T <: AbstractFloat}(arr::Array{T}, args...)
     arr = convert(AudioBuf, arr)
     play(arr, args...)
 end