A brief talk about how audio systems can be used to exchange digital data. The emphasis will be on iOS devices using Apple's audio frameworks with code written in Swift. Keith studied Russian language and literature in school. He then realized that all of the jobs are in computers. He started writing apps for iOS in 2008. He created a proximity-based mobile device pairing system using ultrasonic sound waves at Circle 38. Later, he went on to help build the Acompli app for iOS, which was acquired by Microsoft last year. Now, he’s working at Microsoft in SF on the Outlook iOS app.

12. /// A tiny value that can be easily transferred acoustically between devices.
public struct Token {
public let value: UInt16
/// create a token from an unsigned 16-bit quantity
public init(_ value: UInt16)
/// create a token from 16 bits with the most-significant-bit first
public init(bigEndianBits bits: [Bit])
/// extract the bits in most-significant-bit-first order
internal var bigEndianBits: [Bit] { get }
}
Protocol (1/2)

13. /// a more concise name for the pointer to buffers of our audio data
typealias FloatBuffer = UnsafeMutablePointer<Float>
// protocol parameters
let sampleRate: Float = 44100 // samples per second
let baseFreq: Float = 843.8 // hertz
let fftLength: Int = 4096
let toneBinStride: Int = 8
// derived constants
let firstToneBin = hz2bin(Float(baseFreq))
let freqSpacing = bin2hz(firstToneBin + toneBinStride) - bin2hz(firstToneBin)
let lastToneBin = firstToneBin + ((Token.numBits-1) * toneBinStride)
let toneBins = firstToneBin.stride(through: lastToneBin, by: toneBinStride)
Protocol (2/2)

15. /// generates a buffer of 32-bit float audio samples where the
/// provided `token` is encoded in the frequency domain
/// according to the "audio barcode" protocol.
func encode(token: Token, buffer: FloatBuffer, numSamples: Int) {
// generate a tone for each bit that is turned on
for (i, bit) in token.bigEndianBits.enumerate()
where bit == .One {
let freq = baseFreq + (Float(i) * freqSpacing)
tone(Float(freq), buffer: buffer, numSamples: numSamples)
}
}
Transmit (1/4)

16. /// mixes a tone with frequency 'hz' into 'buffer'
private func tone(hz: Float, buffer: FloatBuffer, numSamples: Int) {
let x = twoPi * hz / sampleRate
for i in 0..<numSamples {
buffer[i] += sinf(Float(i) * x)
}
}
Transmit (2/4)

17. Transmit (3/4)
self.engine = AVAudioEngine()
self.toneGen = AVAudioPlayerNode()
self.engine.attachNode(self.toneGen)
self.audioFormat = AVAudioFormat(standardFormatWithSampleRate:
Double(sampleRate), channels: 1)
self.engine.connect(self.toneGen,
to: self.engine.outputNode,
format: self.audioFormat)
try! AVAudioSession.sharedInstance()
.setCategory(AVAudioSessionCategoryPlayAndRecord)
try! engine.start()

18. Transmit (4/4)
let pcmBuffer = AVAudioPCMBuffer(PCMFormat: audioFormat,
frameCapacity: AVAudioFrameCount(10 * sampleRate))
let bufferRaw = pcmBuffer.floatChannelData[0]
let numFrames = Int(pcmBuffer.frameCapacity)
encode(token, buffer: bufferRaw, numSamples: numFrames)
pcmBuffer.frameLength = AVAudioFrameCount(numFrames)
toneGen.scheduleBuffer(pcmBuffer, atTime: nil, options: .Loops) {
print("buffer finished playing")
}
toneGen.play()

20. Receive (1/4)
let desiredBufferSize = AVAudioFrameCount(1 * sampleRate)
inputNode.installTapOnBus(0, bufferSize: desiredBufferSize, format: nil) {
pcmBuffer, time in
let rawBuffer = pcmBuffer.floatChannelData[0]
if let token = decode(rawBuffer, numSamples: fftLength) {
print("got token", token)
}
}

21. func decode(inputSamples: FloatBuffer, numSamples: Int) -> Token? {
// ...snip... allocate raw memory
// de-interleave to get the audio input into the format that vDSP wants
let (evenSamples, oddSamples) = deinterleave(inputSamples, inputLength: fftLength)
// perform the DFT
vDSP_DFT_Execute(setup, evenSamples, oddSamples, outReal, outImaginary)
// compute magnitudes for each frequency bin (convert from complex to real)
var freqComplex = DSPSplitComplex(realp: outReal, imagp: outImaginary)
vDSP_zvmags(&freqComplex, 1, freqMagnitudes, 1, vDSP_Length(fftLength/2))
// analyze
let token = decodeStage2(freqMagnitudes, numMagnitudes: fftLength/2)
// ...snip... cleanup raw memory
return token
}
Receive (2/4)

22. private func decodeStage2(magnitudes: FloatBuffer, numMagnitudes: Int) -> Token? {
// estimate the noise floor by using the magnitude in nearby bins
let preBins = [firstToneBin-7, firstToneBin-6, firstToneBin-5]
let postBins = [lastToneBin+5, lastToneBin+6, lastToneBin+7]
let noiseFloor = (preBins + postBins)
.map { magnitudes[$0] }
.mean()
// find the magnitude of the tallest peak
var peak: Float = 0.0
for bin in toneBins {
peak = max(peak, magnitudes[bin])
}
// ... continued on next slide
Receive (3/4)

23. // ... continued from decodeStage2 on prev slide
// bail out early if the signal isn't strong enough
if peak/noiseFloor < 5.0 {
return nil
}
// set the hard-decision threshold to be above the noise floor
// but also not too high that it would reject weak tones
let threshold = (0.1 * (peak - noiseFloor)) + noiseFloor
// decide which tones are present and which are not
var bits = [Bit]()
for bin in toneBins {
let magnitude = magnitudes[bin]
let isOn = magnitude > threshold
bits.append(isOn ? .One : .Zero)
}
return Token(bigEndianBits: bits)
}
Receive (4/4)

25. https://github.com/klazuka/CotapTechTalk
Source code and demo app
Contact info
klazuka@gmail.com
Recommended DSP Book
Understanding Digital Signal Processing
by Richard G. Lyons