Orestis Papadopoulos

How I Track My Blog’s Analytics with Val Town

2025-04-15T09:33:36+03:00

Random morning thoughts: how many people actually visit this blog? Where do they come from? What if I could just spend a little time to build my own analytics?

I used Plausible Analytics for a while, it's a great Firebase alternative and worth checking out. It has a smooth interface and is easy to set up. However, I realized I don’t need all the features it offers, and the traffic I get is (probably — last time I checked) not huge. So my needs for analytics are really simple:

I want to know:

How many people visit my blog (in the last week, month, year)
Where they come from (which social media, search engine, etc.)
Which posts are the most visited

It shouldn't be that hard, right?

Server Setup

I decided to use Val Town’s free tier to set up an HTTP server backed by a simple SQLite database. Val Town is a website where you can write serverless JavaScript functions, with an emphasis on collaboration.

The server basically has two endpoints:

A POST endpoint that registers events by writing to a SQLite database.
A GET endpoint that returns all the events found in the database.

It also serves a JS script. This script gets injected into the of every page of my blog (you just got injected too) and sends events to the POST endpoint.

In order to protect the server from unauthorized reads, different keys (and header) for the GET endpoint. Finally, serving the script directly from the server allows for easier API key updates for the POST endpoint. Ideally in the future, I would like to create a mechanism for automatically expiring/rotating the keys (any tips would be appreciated).

Events

An event looks like this:

{
    "url": "https://orjpap.github.io/",
    "referrer": "https://www.google.com/",
    "timestamp": "2025-04-15T10:19:48.580Z",
    "user_agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15"
}

You can store up to 10MB in SQLite on the free plan. GPT estimates each row to be around 290–300 bytes, which means I can probably store about 35k events. In the very pleasant event of reaching the max limit, I can download my data as JSON, store it somewhere, and then delete and continue tracking or upgrade to a paid tier.

Viewing the Data

I can directly manage the sqlite database using a very handy val called sqlite_explorer. It allows me to run SQL queries and offers a basic UI that gets the job done.

I also made a Swift script to read my analytics through the terminal. It's quite primitive, but it's all I need to check every once in a while.

That’s pretty much it! I’m really impressed that I pulled this together in less than a day. I’m glad it’s already running and even more glad I’ve already managed to collect some data from real users.

Feel free to fork my Val Town server if you're interested in rolling your own analytics.

Special thanks to John Syomochkin for his tips about securing the GET endpoint.

AVAudioEffectNode: Configurable Input-Output

2024-12-01T08:33:36+02:00

In my previous post, I have come up with a simplistic implementation of an AVAudioEffectNode with a custom render block. At that time, I assumed a fixed setup with two channels and a sample rate of 44,100 Hz. However, a reader recently reached out, asking how to adapt this for an audio effect that converts stereo input to mono output. This inspired me to modify the AVAudioEffectNode class for greater flexibility.

Key Changes

To accommodate different input and output configurations, I made the following updates:

Dynamic Bus Arrays: Instead of using fixed input and output busses, I implemented lazy-loaded bus arrays. This allows for more dynamic configuration:

private lazy var inputBusArray: AUAudioUnitBusArray = {
	let defaultAudioFormat = AVAudioFormat(standardFormatWithSampleRate: 44100, channels: 2)!
	let inputBus = try! AUAudioUnitBus(format: defaultAudioFormat)
	return AUAudioUnitBusArray(audioUnit: self, busType: .input, busses: [inputBus])
}()
private lazy var outputBusArray: AUAudioUnitBusArray = {
	let defaultAudioFormat = AVAudioFormat(standardFormatWithSampleRate: 44100, channels: 2)!
	let outputBus = try! AUAudioUnitBus(format: defaultAudioFormat)
	return AUAudioUnitBusArray(audioUnit: self, busType: .output, busses: [outputBus])
}()

Overriding Bus Properties needed for AUV3 implementation

public override var inputBusses: AUAudioUnitBusArray {
	return inputBusArray
}

public override var outputBusses: AUAudioUnitBusArray {
	return outputBusArray
}

For the full implementation, check out this gist.

Usage

You can now easily change the input and output formats using:

avAudioEffectNode.auAudioUnit.inputBusses.replaceBusses
avAudioEffectNode.auAudioUnit.outputBusses.replaceBusses

Here's an example using the symclip node from my previous example:

print(symClipNode. inputFormat (forBus: 0))
// prints: 

let audioFormat = AVAudioFormat(standardFormatWithSampleRate: 48000, channels: 1)!
let inputBuss = try AUAudioUnitBus(format: audioFormat)

symClipNode.auAudioUnit.inputBusses.replaceBusses([inputBuss])

print(symClipNode.inputFormat (forBus: 0))
// prints: 

Bonus: BYOB (Bring your own buffers) input pulling

When the input and output have different buffer counts (2 in and 1 out in our reader's case) you have to BYOB.

Here's a sane (and not very Swifty) way of doing this:

let sumNode = AVAudioEffectNode(renderBlock: { actionFlags, timestamp, frameCount, outputBusNumber,
	outputData, renderEvent, pullInputBlock -> AUAudioUnitStatus in

	let bufferSizeBytes = MemoryLayout<Float>.size * Int (frameCount)
	var inputBufferlist = AudioBufferList.allocate(maximumBuffers: 2)

	inputBufferList[0] = AudioBuffer (mNumberChannels: 1,
									  mDataByteSize: UInt32(bufferSizeBytes),
									  mData: malloc(bufferSizeBytes))
	inputBufferList[1] = AudioBuffer (mNumberChannels: 1,
									  mDataByteSize: UInt32(bufferSizeBytes),
									  mData: malloc(bufferSizeBytes))
	// Pull the audio from the input
	let inputStatus = pullInputBlock?(actionFlags, timestamp, frameCount, 0, inputBufferList.unsafeMutablePointer)
	
	if inputStatus != noErr {
		return inputStatus ?? KAudioUnitErr_FailedInitialization
	}

	let ablPointer = UnsafeMutableAudioBufferListPointer(outputData)
	for buffer in ablPointer {
		// do your summing here
		let input = UnsafePointer<Float>(inputBufferList[0].mData!.assumingMemoryBound(to: Float.self))
		...
	}
｝

Since you allocated you are now also responsible for freeing when you are done with the block:

for buffer in inputBufferList {
	free(buffer.mData)
}
free(inputBufferList.unsafeMutablePointer)

Unfortunately some of those C-APIs don't translate well to Swift and can be hard to use even when you know what you are doing.

Feel free to contact me for tips, feedback, opinions or sending me your cool audio effects.

Thank you for reading!

AVAudioEffectNode: painless low level audio effects written in Swift

2024-09-19T09:33:36+03:00

In a previous post, I covered two AVFoundation nodes that can generate sound or tap into the output of an existing node. If you experiment with them, you'll quickly realize:

AVAudioSourceNode has 0 inputs and 1 output.
AVAudioSinkNode has 1 input and 0 outputs.

This means we can't use these nodes to create audio effects directly, since an audio effect needs (at least) 1 input and 1 output.

For creating audio effects, we typically use Audio Units. The AUv3 standard is built on the App Extensions model, meaning your plug-in is an extension contained within an app. Apple provides examples on how to do this, but they are often full of boilerplate and can be challenging to the uninitiated—where's the fun in that, right?

And by fun, I mean fun like Novocaine, an Objective-C library that "takes the pain out of high-performance audio on iOS and macOS." Following a similar approach, I'll guide you through the simplest way I’ve found to create a user-friendly API for building audio effects in Swift using AVFoundation.

AudioUnit, AUAudioUnit, AVAudioUnit (Send Help!)

Now, let's dive into creating our own AVAudioEffectNode. The API should look something like this:

let myEffectNode = AVAudioEffectNode(renderBlock: { -- our render block --})

Since we’re using AVFoundation, we need to create an AVAudioNode that can attach to the engine. This is where AVAudioUnit comes in, acting as a wrapper for Audio Units within AVFoundation. There are specialized subclasses like AVAudioUnitEffect, which we’ll be using later.

If you're new to this, a good starting point is the AUComponent.h header file in Xcode (just Cmd+Click on AudioUnit to access it). Here’s a quick summary:

Audio Units contain render blocks that handle the audio processing.
You create your own Audio Unit by subclassing AUAudioUnit (since AudioUnit is just a typealias).
An AudioComponentDescription is used to describe the unit, which is later instantiated.

AudioComponentDescription

Here's how to define an AudioComponentDescription for our custom effect:

import AVFoundation

extension AudioComponentDescription {
    static let AVAudioEffectNodeAudioUnit = AudioComponentDescription(
        componentType: kAudioUnitType_Effect,
        componentSubType: fourCharCodeFrom("avae"), // provide your own
        componentManufacturer: fourCharCodeFrom("orjp"), // provide your own
        componentFlags: 0,
        componentFlagsMask: 0
    )
}

func fourCharCodeFrom(_ string : String) -> FourCharCode {
    assert(string.count == 4, "String length must be 4")
    var result : FourCharCode = 0
    for char in string.utf16 {
        result = (result << 8) + FourCharCode(char)
    }
    return result
}

In this example, we specify the componentType as kAudioUnitType_Effect because we’re building an effect. You also need to define custom four-character codes for SubType and Manufacturer. I’ve added a helper function to simplify that.

Note: If you're debugging a macOS app and encounter the error Code=-3000 "invalidComponentID", set the componentFlags to AudioComponentFlags.sandboxSafe.rawValue.

Custom AUAudioUnit

Next, we subclass AUAudioUnit to create AVAudioEffectNodeAudioUnit, this is our custom Audio Unit:

We’ll need to override the internalRenderBlock to pass in our custom render logic.
We’ll also need to define one input and one output bus by overriding inputBusses and outputBusses.

class AVAudioEffectNodeAudioUnit: AUAudioUnit {
    let inputBus: AUAudioUnitBus
    let outputBus: AUAudioUnitBus

    var _internalRenderBlock: AUInternalRenderBlock

    public override init(
        componentDescription: AudioComponentDescription,
        options: AudioComponentInstantiationOptions = []
    ) throws {
        let audioFormat = AVAudioFormat(standardFormatWithSampleRate: 44100, channels: 2)!

        inputBus = try AUAudioUnitBus(format: audioFormat)
        outputBus = try AUAudioUnitBus(format: audioFormat)

        _internalRenderBlock = { _, _, _, _, _, _, _ in
            return kAudioUnitErr_Uninitialized
        }

        try super.init(componentDescription: componentDescription, options: options)
    }

    public override var inputBusses: AUAudioUnitBusArray {
        return AUAudioUnitBusArray(audioUnit: self, busType: .input, busses: [inputBus])
    }


    public override var outputBusses: AUAudioUnitBusArray {
        return AUAudioUnitBusArray(audioUnit: self, busType: .output, busses: [outputBus])
    }

    public override var internalRenderBlock: AUInternalRenderBlock {
        return _internalRenderBlock
    }
}

Time for the glue.

Now that we’ve created the core, let’s glue everything together by creating an AVAudioEffectNode class. This will inherit from AVAudioUnitEffect, and we’ll write a convenience initializer that allows us to pass in a render block—much like the AVAudioSourceNode API.

class AVAudioEffectNode: AVAudioUnitEffect {
    convenience init(renderBlock: @escaping AUInternalRenderBlock) {
        AUAudioUnit.registerSubclass(AVAudioEffectNodeAudioUnit.self,
                                     as: .AVAudioEffectNodeAudioUnit,
                                     name: "AVAudioEffectNode",
                                     version: 0)

        self.init(audioComponentDescription: .AVAudioEffectNodeAudioUnit)

        let audioEffectAudioUnit = self.auAudioUnit as! AVAudioEffectNodeAudioUnit
        audioEffectAudioUnit._internalRenderBlock = renderBlock
	 }
}

First, we register our custom AUAudioUnit using the AudioComponentDescription we defined earlier.
Next, we initialize the AVAudioUnitEffect using its inherited initializer.
Finally, we retrieve the auAudioUnit, cast it to our custom subclass, and pass the render block.

Example: Symmetrical Clipping Effect

Here’s an example of how to implement a symmetrical clipping effect using AVAudioEffectNode. Symmetrical clipping is commonly used in overdrive simulations to clip both positive and negative waveform peaks evenly.

import AVFoundation

let symClipThreshold: Float = 1.0/3.0 // higher denominator > more clipping

let symClipNode = AVAudioEffectNode(renderBlock: { actionFlags, timestamp, frameCount, outputBusNumber, outputData, renderEvent, pullInputBlock -> AUAudioUnitStatus in

    // Pull the audio from the input
    let inputStatus = pullInputBlock?(actionFlags, timestamp, frameCount, 0, outputData)

    if inputStatus != noErr {
        return inputStatus ?? kAudioUnitErr_FailedInitialization
    }

    let ablPointer = UnsafeMutableAudioBufferListPointer(outputData)
    for buffer in ablPointer {
        let input = UnsafePointer<Float>(buffer.mData!.assumingMemoryBound(to: Float.self))
        let outputBuffer = UnsafeMutablePointer<Float>(buffer.mData!.assumingMemoryBound(to: Float.self))
        let processed = symClip(input: input, count: Int(frameCount))
        for i in 0..<Int(frameCount) {
            outputBuffer[i] = processed[i]
        }
    }

    return noErr
})

// "Overdrive" simlation with symmetrical clipping from DAFX (2011) translated to Swift
// Author: Dutilleux, ZΓΆlzer
// Symmetrical clipping clips both positive and negative amplitude peaks of a waveform evenly
func symClip(input: UnsafePointer<Float>, count: Int) -> [Float] {
    var output = [Float](repeating: 0.0, count: count)

    for i in 0..<count {
        let x = input[i]
        if abs(x) < symClipThreshold {
            output[i] = 2.0 * x
        } else if abs(x) >= symClipThreshold && abs(x) <= 2.0 * symClipThreshold {
            if x > 0 {
                output[i] = (3.0 - pow((2.0 - x * 3.0), 2.0)) / 3.0
            } else {
                output[i] = -(3.0 - pow((2.0 - abs(x) * 3.0), 2.0)) / 3.0
            }
        } else if abs(x) > 2.0 * symClipThreshold {
            if x > 0 {
                output[i] = 1.0
            } else {
                output[i] = -1.0
            }
        }
    }

    return output
}

Putting the Nodes Together

You can now connect any kind of AVAudioEngineNode to your shiny new audio effect:

let engine = AVAudioEngine()

engine.attach(sineWaveNode)
engine.attach(symClipNode)

engine.connect(sineWaveNode, to: symClipNode, format: nil)
engine.connect(symClipNode, to: engine.mainMixerNode, format: nil)

engine.mainMixerNode.volume = 0.4

try! engine.start()
CFRunLoopRun()
engine.stop()

Coda

All in all, combining a source node, sink node, and effect node creates a robust and flexible API for low-level audio processing and generation with AVFoundation. I'm excited to see where AVFoundation is headed and hopeful that future updates will bring even more user-friendly Swift APIs for audio development.

You can find the full example as an Xcode project on my github.

Feel free to contact me for tips, feedback, opinions or sending me your cool audio effects.

Thank you for reading!

CaseSequencable: Put your enums in order

2022-05-25T18:33:36+03:00

Enums are often used to model states. If we want to move to the next state (in order of declaration) we have to do the switch dance:

enum MyState {
  case sleeping
  case working
  case chilling
}

var myState: MyState = .sleeping

func nextState() {
	switch myState {
    case sleeping:
    ....
  }
}

By conforming an enum toCaseIterable type, we can access a collection of all of the type’s cases by using the type’s allCases property. The allCases property is compiler synthesized (for enums that don’t have associated values) and provides the cases in order of their declaration.

We can implement a simple protocol named CaseSequencable which inherits from the CaseIterable protocol:

protocol CaseSequencable: CaseIterable, Equatable {
    var nextCase: Self { get }
}

extension CaseSequencable {
    var nextCase: Self {
        // allCases is compiler synthesized (for enums without associated values)
        // there is no possible way for self to not exist in allCases
        // if you manually conform to CaseIterable it will crash :D
        let selfIndex = Self.allCases.firstIndex(of:self)!

        let nextIndex = Self.allCases.index(after: selfIndex)
        if nextIndex == Self.allCases.endIndex {
            return Self.allCases[Self.allCases.startIndex]
        } else {
            return Self.allCases[nextIndex]
        }
    }
}

And use it in the following way:

enum MyState: CaseSequencable {
  case sleeping
  case working
  case chilling
}

var myState: MyState = .sleeping

myState // .sleeping
myState.next // .working
myState.next.next // .chilling
myState.next.next.next // .sleeping (loops back to the first case)

Feel free to contact me or tweet to me on Twitter for tips, feedback, opinions.

Thank you for reading!

UserDefaultsPersistable: Save and Load any struct to/from UserDefaults

2021-10-10T18:33:36+03:00

The user’s defaults database is a key-value store that let’s you persist data across app launches. It is meant to be used to store user preferences. Using the Codeable protocol and a JSONEncoder you can very easily convert Swift types to JSON data in order to store them.

Save/Load Codeable structs

To save data into UserDefaults you must first encode it as JSON, and then save it using a specified key like this:

struct Settings: Codeable {
  ...
}

let userSettings = Settings()

let encoder = JSONEncoder()
if let encoded = try? encoder.encode(userSettings) {
    UserDefaults.standard.set(encoded, forKey: "archiveKey")
}

Then you can load it like this:

if let savedSettingsData = UserDefaults.standard.object(forKey: "archiveKey") as? Data else {
    let decoder = JSONDecoder()
    let loadedSettings = try? decoder.decode(Settings.self, from: savedSettingsData) // Settings?
}

Reusability

Using Swift protocols and protocol inheritance, we can define aUserDefaultsPersistable protocol:

protocol DefaultInitializable {
  init()
}

protocol UserDefaultsPersistable: Codable, DefaultInitializable {
    static var key: String {get}
}

We also defined another protocol called DefaultInitializable for types than can be initialized with a default value using a default initializer. The default value will be used in cases where we’re looking for the specific type in UserDefaults and it does not exist.

In order to provide a default implementation of save and load functions we will also create a UserDefaultsPersister:

struct UserDefaultsPersister<A: UserDefaultsPersistable> {
    static func save(_ value: A) {
        let encoder = JSONEncoder()
        if let encoded = try? encoder.encode(value) {
            UserDefaults.standard.set(encoded, forKey: A.key)
        }
    }

    static func load() -> A {
        guard let savedSettingsData = UserDefaults.standard.object(forKey: A.key) as? Data else {
            return A()
        }

        let decoder = JSONDecoder()
        let loadedSettings = try? decoder.decode(A.self, from: savedSettingsData)
        return loadedSettings ?? A()
    }
}

And provide the default implementations for UserDefaultsPersistable protocol:

extension UserDefaultsPersistable {
    func save() {
        UserDefaultsPersister.save(self)
    }

    static func load() -> Self {
        return UserDefaultsPersister.load()
    }
}

Usage

For example, if you want to persist your app’s Audio settings:

struct AudioPreferences: UserDefaultsPersistable {
    static var key = "userAudioPreferences"
    var volume = 1.0 // default value
    var bass = 0.5
    var treble = 0.5
    var quality = 1.0
}

var audioPreferences = AudioPreferences.load()

// user modifies volume
audioPreferences.volume = 1.0
audioPreferences.save() // Audio preferences are saved in user defaults

Declaring a type to be UserDefaultsPersistable allows you to easily store it in UserDefaults by only specifying a key. Obviously with this approach you can’t store more than one instance of the same type but when it comes to storing user preferences this is a safety mechanism rather than a limitation.

Feel free to contact me for tips, feedback, opinions.

Thank you for reading!

How To Upload Data To A Server: Multipart/Form-Data HTTP Requests in Swift

2021-04-26T18:33:36+03:00

So you are making your first face beautifier© app and it’s about time to upload some images to a server. The backend person asks you to do it via a type of HTTP POST request known as multipart/form-data. Soon you come to realise that URLSession does not provide you with an out of the box URLRequest or DataTask for this specific task, despite the fact that this is a very standard way of uploading data.

And that’s when you reach for Alamofire.

Or you can stick with URLSession and make your own MultipartFormDataRequest

It works like this:

func uploadImage(imageData: Data) {
    let request = MultipartFormDataRequest(url: URL(string: "https://server.com/uploadPicture")!)
    request.addDataField(named: "profilePicture", data: imageData, mimeType: "img/jpeg")
    URLSession.shared.dataTask(with: request, completionHandler: {
        ...
    }).resume()
}

MultipartFormDataRequest is very similar to a URLRequest in that it is initialised by a URL. The URL endpoint that you will be sending data to.

Use addTextField to send text and addDataField to send anything that can be converted to Data (images, audio, Grand Theft Auto 2 savefiles, you name it)

struct MultipartFormDataRequest {
    private let boundary: String = UUID().uuidString
    private var httpBody = NSMutableData()
    let url: URL

    init(url: URL) {
        self.url = url
    }

    func addTextField(named name: String, value: String) {
        httpBody.append(textFormField(named: name, value: value))
    }

    private func textFormField(named name: String, value: String) -> String {
        var fieldString = "--\(boundary)\r\n"
        fieldString += "Content-Disposition: form-data; name=\"\(name)\"\r\n"
        fieldString += "Content-Type: text/plain; charset=ISO-8859-1\r\n"
        fieldString += "Content-Transfer-Encoding: 8bit\r\n"
        fieldString += "\r\n"
        fieldString += "\(value)\r\n"

        return fieldString
    }

    func addDataField(named name: String, data: Data, mimeType: String) {
        httpBody.append(dataFormField(named: name, data: data, mimeType: mimeType))
    }

    private func dataFormField(named name: String,
                               data: Data,
                               mimeType: String) -> Data {
        let fieldData = NSMutableData()

        fieldData.append("--\(boundary)\r\n")
        fieldData.append("Content-Disposition: form-data; name=\"\(name)\"\r\n")
        fieldData.append("Content-Type: \(mimeType)\r\n")
        fieldData.append("\r\n")
        fieldData.append(data)
        fieldData.append("\r\n")

        return fieldData as Data
    }
}

extension NSMutableData {
  func append(_ string: String) {
    if let data = string.data(using: .utf8) {
      self.append(data)
    }
  }
}

You also need a function to convert a MultipartFormDataRequest to a URLRequest in order to be able to create URLSessionDataTasks

func asURLRequest() -> URLRequest {
    var request = URLRequest(url: url)

    request.httpMethod = "POST"
    request.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")

    httpBody.appendString("--\(boundary)--")
    request.httpBody = httpBody as Data
    return request
}

Bonus round:

A handy URLSession extension. You can also make this an upload task, or use background sessions etc.

extension URLSession {
    func dataTask(with request: MultipartFormDataRequest,
                  completionHandler: @escaping (Data?, URLResponse?, Error?) -> Void)
    -> URLSessionDataTask {
        return dataTask(with: request.asURLRequest(), completionHandler: completionHandler)
    }
}

And this is it. You can now upload your image to the server. A very good example of how simple (or scary) HTTP can be.

I didn’t go into much detail about the HTTP specifics because:

This is a sort of tl;dr blog post where I’m sharing some (I hope) useful code with you
Donny Wals has done an excellent job at explaining this in his blog post
You can read about it here

Feel free to contact me for tips, feedback, opinions.

Thank you for reading!

AVAudioSourceNode, AVAudioSinkNode: Low-Level Audio In Swift

2020-06-19T18:33:36+03:00

Apple introduced AVAudioSourceNode and AVAudioSinkNode in WWDC2019. These two new AVAudio nodes are part of the AVFoundation framework and can be used in macOS 10.15 and iOS 13 onwards.

They provide a way to process input from an audio device/file, and generating output to a device/file, sample by sample.

AVAudioSourceNode sends audio to an AVAudioEngine node. The audio is computed in a callback and can be rendered in real-time or offline modes.

AVAudioSinkNode receives audio from an AVAudioEngine node. The audio is processed in a callback and can be rendered in real-time or offline modes.

The following code outputs five seconds of white noise using an AVAudioSourceNode:

import AVFoundation

func whiteNoise() -> Float {
	return Float.random(in: -1.0...1.0)
}

let whiteNoiseGenerator = AVAudioSourceNode() { (silence, timeStamp, frameCount, audioBufferList) ->
    OSStatus in
    let ablPointer = UnsafeMutableAudioBufferListPointer(audioBufferList)
    for frame in 0..<Int(frameCount) {
        let value = whiteNoise()
        for buffer in ablPointer {
            let buf: UnsafeMutableBufferPointer<Float> = UnsafeMutableBufferPointer(buffer)
            buf[frame] = value
        }
    }
    return noErr
}

let engine = AVAudioEngine()
engine.attach(whiteNoiseGenerator)
engine.connect(whiteNoiseGenerator, to: engine.mainMixerNode, format: nil)
engine.mainMixerNode.outputVolume = 0.5

try! engine.start()
sleep(5)
engine.stop()

Two things might baffle Swift programmers in this example:

UnsafeMutableAudioBufferListPointer and UnsafeMutableBufferPointer.

By default, Swift is memory safe: It prevents direct access to memory and makes sure you’ve initialized everything before you use it. But you can also use unsafe Swift, which lets you access memory directly through pointers. In this example we use an UnsafeMutableBufferPointer instance in low level operations to eliminate uniqueness checks and bounds checks. I recommend reading Unsafe Swift by Paulo Andrande to get a better understanding of the unsafe side of Swift.
The OSStatus return type.

Almost every Apple C API function signals success or failure through their return value, which is of type OSStatus. Any status other than noErr (which is 0) signals an error. You can find more details here

Why unsafe Swift?

First of all unsafe Swift lets you work with pointers and interoprate with C libraries.

In addition, unsafe Swift can help you gain a performance boost by sacrificing memory safety. The code you write in the AVAudioSourceNode’s block must be realtime compliant. Your callback is called in a real-time thread with a hard deadline. @44,1khz sampling rate with a buffer size of 512 samples gives you ~11ms to complete processing in your callback. If that’s not the case, you get silence. That time limit prohibits:

Memory Allocations
Using Locks
Network Requests or any kind of I/O
Memory boundary checks/uniqueness checks
Checking your Twitter

Check out this guide on writing high-performance Swift code.

Conclusion

AVFoundation really suprised me. It provides a clear, powerful API that can be used to generate audio and I’m looking forward making some stuff with it. I’m wondering how it compares to the Audio Unit impementation performance-wise, or if there’s no difference at all because a core audio implementation is hiding under the hood of the two new AVAudioNodes.

Feel free to contact me or tweet to me on Twitter if you have any additional tips or feedback.

Thanks!

Jekyll: Testing Swift Code Blocks

2020-05-04T18:33:36+03:00

Reading through last week's iOSDevWeekly I came across Doctest, an exciting new project that aims to make Swift documentation testable.

The idea is, you can run swift-doctest giving it a bunch of .swift files and then it evaluates code blocks in your documentation, returning test results for the given conditions.

It turns out that you can run swift-doctest on Markdown files too. What if, we could inject a nice little swift-doctest every time jekyll renders our static website? That way we can test codeblocks in blog posts and even get it done automatically on every build.

Install DocTest

Via Homebrew:

$ brew install swiftdocorg/formulae/swift-doctest

Or Manually:

$ git clone https://github.com/SwiftDocOrg/DocTest
$ cd DocTest
$ make install

Jekyll Hook

note: these are my first 6 lines of Ruby, please be gentle with me

# Put this in a file called swift-doctest.rb on a _plugins folder in your blog root foolder
Jekyll::Hooks.register :posts, :pre_render do |post|
	if post.data['doctest'] == true
		value = %x( echo;echo 'swift-doctest for #{post.path}';swift-doctest #{post.path}; echo;)
		puts value
	end
end

This Jekyl Hook runs every time your site is built, before the .md files get rendered to .html files. I put it at this point so that I can do something more sophisticated in the future by probably injecting some html to show me the failed test results.

In order to enable swift-doctest for a post, add doctest: true to the post's front matter.

Take it for a spin

Start a codeblock with ```swift doctest and then, add an annotation in the format => (Type) = (Value), to test the expected type and value of the expression:

struct User {
	let name: String
}

let user = User(name: "Foo")
let anotherUser = User(name: "Bar")
user.name == anotherUser.name // => Bool = true

Now if you run bundle exec jekyll serve to build and serve your site, the terminal will print a failed test in the TAP format

...

swift-doctest for /_posts/.md
TAP version 13
1..2
not ok 1 - `user.name == anotherUser.name` produces `Bool = false`, expected `Bool = true`
  ---
  column: 37
  file: /_posts/.md
  line: 6
  ...
  
...

Nice! If you just change the example to:

struct User {
	let name: String
}

let user = User(name: "Foo")
let anotherUser = User(name: "Bar")
user.name == anotherUser.name // => Bool = false

And just save the file, you will see:

...

swift-doctest for /_posts/.md
TAP version 13
1..1
ok 1 - `user.name == anotherUser.name` produces `Bool = false`
  ---
  column: 36
  file: /_posts/.md
  line: 6
  ...
  
...

Conclusion

That's all you need in order to enable testing for Swift codeblocks in your Jekyll site!

Keep your eyes peeled for further updates to the very promising Doctest since it's still on its early days.

Feel free to contact me or tweet to me on Twitter if you have any additional tips or feedback.

Thanks!

AVAudioSourceNode, AVAudioSinkNode: how I deleted a repo in less than 48hours

2020-05-04T18:33:36+03:00

Two days ago, I set out to create a simple Swift library for real-time audio processing. I was aiming to provide a boilerplate-free way of processing input from an audio device/file, and generating output to a device/file, sample by sample (or frame by frame).

Last time I checked there was AudioKit, which is great and you should check it out, but a big dependency to add to a project were you only need to process some audio as well as Core Audio. Apple's lowest level of abstraction audio framework, Core Audio (initially released in 2003), which on the front page of its documentation clearly states: "Use the Core Audio framework to interact with device’s audio hardware."

An audio unit is a software object that performs some sort of work on a stream of audio, frame by frame. Being so close to the hardware comes with a lot of responsibilities, that's why Audio Units take time and code to set up and make sure that everything is OK.

The hello world of audio generators is a sinewave. But let's make some noise instead. In order to do this with Core Audio we need to:

Find the default output audio component
Create a new instance of an audio unit and attach it to it
Set the renderBlock property of the audio unit to our noise callback
Start the audio unit
Sleep on the current thread so that we can hear the audio being generated on the real-time thread.
Clean up the audio unit

I made a wrapper that provided the following API:

let device = ProcessAudio.defaultOutput
// Make some noise
device.connect { _, buffer, bufferSize in
    for frameNumber in 0..<Int(bufferSize) {
        data[frameNumber] = Float32.random(in: 0..<1)
    }
})
device.start()
sleep(5)
device.stop()

Turns out AVAudioSourceNode and AVAudioSinkNode introduced in WWDC2019, can be used in the exact same way.

Conclusion

That's all you need in order to enable testing for Swift codeblocks in your Jekyll site!

Keep your eyes peeled for further updates to the very promising Doctest since it's still on its early days.

Feel free to contact me or tweet to me on Twitter if you have any additional tips or feedback.

Thanks!

Podfast: a Podcast Discovery App

2020-05-02T18:33:36+03:00

I can clearly recall my mother's disappointment once she realised she couldn’t listen to the radio through her new iPhone. Which made total sense to me.

At the time there was only a built-in app called Podcasts that allowed you to listen to podcasts. Also, Generation Z's complete lack of interest in the radio experience had already signaled the start of a new era. Podcasting, once an obscure process of transmitting audio content, had now become a distinguished medium for its distribution.

When old media are replaced by new ones, some of their features are dropped ‘cause they no longer serve a purpose. Podfast was inspired by the original process of discovering new radio stations through AM/FM scanning, a process so undoubtedly joyous and adventuresome for quite a few people that there's even a hobby invented for indulging in it, called DXing. My idea was that the concept of radio discovery can incorporate so much more user value than just the induction of nostalgic feelings to the users (like, creating a typewriter app does, for example). Since ideas transcend media, its essence could be rebottled and repurposed for the Podcast era and even be further expanded.

I thought hard on the radio discovery process and I found that the main characteristics defining it are:

Chance: In case you don’t tune in to your favourite program in time, chance is always involved in the program you will tune in to eventually, also in its elapsed time.
Audio Cues: instead of visual cues. Even though you can see which frequency corresponds to a specific position of the knob, only the audio provides you with information about whether you are going to like what you hear or not.
Locality: When you move to another country or region, you will tune in to entirely different stations.

Implementation

Getting started, at the top level, I described what I was trying to build in the form of a simple user story:

As a listener I want to discover podcasts by scrolling while listening to them

This was pretty much it. This single user story has since spawned a lot of other stories, tasks, sub-tasks etc. These sub-stories all revolve around the three above-mentioned characteristics. The process was: (a) think of a scenario (b) write code that implements it (c) assess the value it adds for the user (d) integrate it into the app. That's how I made an iOS app prototype pretty quickly, implementing this user story into local podcast audio files and just a UISlider.

Your browser does not support the video tag.

My next step was to use some real data sources. I turned to iTunes RSS Feed Generator, a publicly accessible API which returns a JSON file with the Top 100 Podcasts in different regions, regularly updated on an almost weekly basis. After collecting this data I had to jump through some hoops - I won’t bore you with the details - to get the metadata for each podcast (XML RSS feed parsing anyone? 😁) but thankfully, the podcast RSS feed tags are properly standardized in order to get parsed by iTunes, Spotify etc.

At this point, I realised that the less the app's core logic knows about the specifics of the various data sources, the better for the app. To achieve this separation, I spent some weeks researching the most common app architecture patterns and ended up re-writing my hacky/scripty view controller logic by using something very similar to Viper and Uncle Bob's clean architecture but not exactly any of them. For those of you who are interested, you can take a look at the folder called Use Cases and let me know what you think (I’m suspecting I have committed some over-abstraction crimes here). Anyway, my goal behind all this was very clear: I wanted to be able to switch data sources on a whim, without having to re-write half of my app. This proved to be very valuable when remote configuration feeding podcast data was added.

I also noticed that podcasts could be organised by category and that was pretty neat, since such a minimal visual cue is not prominent enough to distract the user from listening. Finally, I replaced the slider with a UICollectionView to display the category names and also wrote some simple collision logic:

Your browser does not support the video tag.

That was the prototype I showed to the visual artist/writer Vasia Bakogianni, also known as @kroutsef and asked her to work as a graphic designer for the app. She took it all in and we got straight to work. After a few interesting conversations, brainstorming sessions and design iterations she came up with the app icon:

Vasia has not only worked as a designer for the project, but since she is an avid podcast listener, she has also provided valuable feedback on the user experience, as well as hours of interesting app and non-app related conversations. After taking a short break, where we had to work on various other projects, we got back to ‘Podfast’ and decided to push towards the app release by setting a strict release date. Since we’d done a lot of groundwork and the concept had already been solidified, we finalized the designing aspect of it shortly after:

From a software perspective we agreed on a subset of features that would be included in the release, a sort of minimum viable product (MVP) approach, based on the following principle: before making a significant time and effort investment we have to set out to release the product, deliver it to the users and then channel their input back into the process of development.

Shortly prior to the big release, I realised that since there is streaming involved and the loading time experience ranges from “seemingly instant” to "slower than death caused by a natural cause”, we needed a way to indicate the buffering state. We decided to go with something different from the established spinner/loader pattern and use radio static sounds. The current, simplified implementation has a static sound sample played when AVPlayer is having a rough time buffering. Of course, there is definitely room for improvement by obviously inserting procedural sound design into the concept. Spinners are the ultimate playground for graphic designers, so let's also give sound designers the opportunity to indicate loading states.

Your browser does not support the video tag.

Over a period of one week and a few micro-features later, some of which are:

Categories are sorted out by “most listened”
A listen is defined as “1 minute of listening”
Podcast details appear after 30 seconds of listening to a podcast, in order to encourage the listener to pay attention to the audio.
The episode seek time is related to the app's start time.
Curated podcast sources can by dynamically added to the data set. Thanks to Firebase Remote Configuration,

we finally had our 1.0 release!

Where to next?

You can download the app for free from the App Store and give it a try.

Our users have already done a great job sharing their feedback with us. We are bound to release an update soon, with improved features that were assimilated thanks to their suggestions. We would also love to hear your own feedback on the app Send us an email or get in touch on Twitter @orjpap, @kroutsef. Feel free to share with us your favourite podcasts and the category they belong to as well, so we can add them to our collection.

There is still a lot to learn and improve, so further optimization in the departments of streaming logic, sound design and visuals of the app is inevitable. Besides, we’re planning to introduce the parameter of locality mentioned above. Instead of just selecting from the US Top 100 and our curated podcasts, the user will be able to discover podcasts that are popular in their respective country.

An Android app is also in the making by Petros Koutsokeras

The source code is available for free and can be found on Github, I'm open to discussions about the implementation/architecture of the app and points that can and should be improved.

To sum up, I will just quote Vasia's carefully crafted words:

Podfast is, after all, not a digital radio simulation that aspires to send you on a nostalgia trip. It is a tool that re-establishes the user trust in a carefully selected bunch of cultural products picked by the users themselves without strain.

Orestis Papadopoulos

How I Track My Blog’s Analytics with Val Town

Server Setup

Events

Viewing the Data

Sharing

AVAudioEffectNode: Configurable Input-Output

Key Changes

Usage

Bonus: BYOB (Bring your own buffers) input pulling

AVAudioEffectNode: painless low level audio effects written in Swift

AudioUnit, AUAudioUnit, AVAudioUnit (Send Help!)

AudioComponentDescription

Custom AUAudioUnit

Time for the glue.

Example: Symmetrical Clipping Effect

Putting the Nodes Together

Coda

CaseSequencable: Put your enums in order

UserDefaultsPersistable: Save and Load any struct to/from UserDefaults

Save/Load Codeable structs

Reusability

Usage

How To Upload Data To A Server: Multipart/Form-Data HTTP Requests in Swift

AVAudioSourceNode, AVAudioSinkNode: Low-Level Audio In Swift

Why unsafe Swift?

Conclusion

Jekyll: Testing Swift Code Blocks

Install DocTest

Jekyll Hook

Take it for a spin

Conclusion

AVAudioSourceNode, AVAudioSinkNode: how I deleted a repo in less than 48hours

Conclusion

Podfast: a Podcast Discovery App

Implementation

Where to next?