Reloading AKAudioFile in AKSequencer using AKCallbackInstrument.noteOff?

Question

First, I called a AKMIDISampler to play an audio file, and then assigned it to AKSequencer. The 'midi' file I used is just a 2 bars long, C3 note, single track midi file, exactly as long as the audio file I wanted to play. But, in calling AKAudioFile, I wanted to choose mp3 file randomly. I temporarily made 1.mp3, 2.mp3 and 3.mp3 as below.

    let track = AKMIDISampler()
    let sequencer = AKSequencer(filename: "midi")

    try? track.loadAudioFile(AKAudioFile(readFileName: String(arc4random_uniform(3)+1) + ".mp3"))

    sequencer.tracks[0].setMIDIOutput(track.midiIn)
    // Tempo track I had to made to remove sine wave
    sequencer.tracks[1].setMIDIOutput(track.midiIn)

And did some sequencer settings,

    sequencer.setTempo(128.0)
    sequencer.setLength(AKDuration(beats: 8))

    sequencer.setLoopInfo(AKDuration(beats: 8), numberOfLoops: 4)
    sequencer.preroll()

and assigned AKMIDISampler to AudioKit.output, then did sequencer.play().

The sequencer playback was successful! It loaded among three mp3 files randomly, and played 8 beats (2 bars), looped for 4 times exactly.

But my goal is to load random MP3 files every time the loop repeats. It seems like the sequencer only plays the first assigned mp3 file when looping. I am struggling finding a solution to this.

Perhaps I could use "AKCallbackInstrument"? Since I play audiofile through a midi note in this case, I might reset "loadAudioFile" whenever the midi note is off? In that way I might loop the sequencer and play random a audio file in every loop. This is just an idea, but for me now it is hard to write it properly. I hope I am on the right track. It would be great if I could get an advice here. <3

Answer 1

It was very helpful, c_booth! Thanks to you, I made a huge progress today. Here's what I've written based on your advise. First, I made an array of AKPlayers include 6 mp3 files. They're assigned to AKMixer, and then I called sequencer and callback instrument. I made a track and a note on the sequencer, which calls 'playRandom' function on every noteOn :

let players: [AKPlayer] = {
    do {
        let filenames = ["a1.mp3", "a2.mp3", "a3.mp3", "b1.mp3", "b2.mp3", "b3.mp3"]
        return try filenames.map { AKPlayer(audioFile: try AKAudioFile(readFileName: $0)) }
    } catch {
        fatalError()
    }
}()

func playRandom() {
    let playerIndex = Int(arc4random_uniform(UInt32(players.count)))
    players[playerIndex].play()
}

func addTracks() {
    let track = sequencer.newTrack()!
    track.add(noteNumber: 48, velocity: 127, position: AKDuration(beats: 0), duration: AKDuration(beats: 16), channel: 0)
    track.setMIDIOutput(callbackInst.midiIn)
    callbackInst.callback = { status, note, vel in
        guard status == .noteOn else { return }
        self.playRandom()
    }
}

func sequencerSettings() {
    sequencer.setTempo(128.0)
    sequencer.setLength(AKDuration(beats: 16))
    sequencer.setLoopInfo(AKDuration(beats: 16), numberOfLoops: 4)
    sequencer.preroll()
}

func makeConnections() {
    players.forEach { $0 >>> mixer }
}

func startAudioEngine() {
    AudioKit.output = mixer
    do {
        try AudioKit.start()
    } catch {
        print(error)
        fatalError()
    }
}

func startSequencer() {
    sequencer.play()
}

This worked great. It randomly selects one from 6 mp3 files (they are all the same length, 128bpm and 16 beats). What I found strange here is, though, the first playback plays two audio files at once. It works fine after the second loop. I changed the numberOfLoop setting, enableLooping(), etc but still the same - plays two files on the first playback. The trackcount is still 1, and I only called one AKPlayer as you could see. Is there anything I can do about this?

Also, ultimately, I'd like to call hundreds of mp3 files on the array, as what I'm trying to make is a sort of DJing app (something like Ableton Live preset). Do you think it's a good idea to use AKPlayer, assuming this code will load mp3 files from the cloud and stream it to the user? Much appreciated. <3

Answer 2

You're definitely on the right track - you can easily get random audio files to loop at a fixed interval with AKSequencer + AKCallbackInstrument. But I wouldn't worry about trying to reload on the NoteOff message.

I would first load each mp3 into a separate player (e.g., AKAppleSampler) in an array (e.g.,you could call it players) and create a method that will trigger one of these players at random:

func playRandom() {
    let playerIndex = Int(arc4random_uniform(UInt32(players.count)))
    try? players[playerIndex].play()
}

When you create your sequencer, add a track and assign it to an AKCallbackInstrument. The callback function for this AKCallbackInstrument will call playRandom when it receives a noteOn message.

seq = AKSequencer()
track = seq.newTrack()!
callbackInst = AKCallbackInstrument()
track.setMIDIOutput(callbackInst.midiIn)
callbackInst.callback = { status, note, vel in 
    guard status == .noteOn else { return }
    self.playRandom()
}

It isn't necessary to load the sequencer with a MIDI file. You could just add the triggering MIDI event directly to the track.

track.add(noteNumber: 48, // i.e., C3
      velocity: 127,
      position: AKDuration(beats: 0), // noteOn message here
      duration: AKDuration(beats: 8), // noteOff 8 beats later
      channel: 0)

Your problem with the sine wave is probably being caused by an extra track (probably tempo track) in the MIDI file which you created which hasn't been assigned an output. You can avoid the problem altogether by adding the MIDI events directly.

In principle, you could use the callback to check for noteOff events and trigger code from the noteOff, but I wouldn't recommend it in your case. There is no good reason to re-use a single player for multiple audiofiles. Loading the file is where you are most likely to create an error. What happens if your file hasn't finished playing and you try to load another one? The resources needed to keep multiple players in memory is pretty trivial - if you're going to play the same file more than once, it is cleaner and safer to load it once and keep the player in memory.