Stuttering audio with CsoundPerformanceThread

JasonHallen · January 24, 2021, 4:03pm

I’ve run into a stuttering audio issue on my MacBook Pro on Catalina. Here’s the scenario. I’m generating a Csound score, sending the full CSD file to an instance of Csound via ctcsound, and then playing and pausing the performance with CsoundPerformanceThread.

The stuttering audio occurs whenever the system’s sound output device is set to “MacBook Pro Speakers” or “External Headphones”. The stuttering goes away whenever the system’s sound output device is set to my “Scarlett 2i2 USB” audio interface or my docking station’s “USB audio CODEC”. Here are audio examples of the stuttering and non-stuttering.

I’ve never run into this stuttering issue before with my Csound projects, but this is my first time working with the CsoundPerformanceThread. Have any of you had experience with this stuttering issue? Could you give me guidance on how to fix this?

Thanks!
Jason

joachim · January 24, 2021, 5:11pm

not sure it is related, but did you see françois’ explanation here?

github.com

csound/ctcsound/blob/master/cookbook/03-threading.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multithreading\n",
    "In the preceding recipes, there was a single thread running; this is the default way to use Python, due to the GIL (Global Interpreter Lock). Then, the user has the possibility to interact with the Csound instance during the performance loop. This is illustrated in the following diagram:\n",
    "\n",
    "![Single Thread](img/03-threading-a.png)\n",
    "\n",
    "To use Csound in a more flexible way, one can use multithreading. Because of the GIL limitations, it is better to yield the multithread machinery through C libraries. When a C function is called from Python using ctypes, the GIL is released during the function call.\n",
    "\n",
    "Csound has an helper class called CsoundPerformanceThread. When there is a running Csound instance, one can start a new thread by creating a new object of type CsoundPerformanceThread with a reference to the Csound instance as argument. Then, the main Python thread will run allowing the user to interract with it, while the performance thread will run concurrently in the C world, outside of the GIL. The user can send messages to the performance thread, each message being sent with a call to a C function through ctypes, releasing the GIL during the function call. Those messages can be: _play(), pause(), togglePause(), stop(), record(), stopRecord(), scoreEvent(), inputMessage(), setScoreOffsetSeconds(), join(),_ or _flushMessageQueue()_.\n",
    "\n",
    "When a very long score is used, it is thus easy to implement a REPL (read-eval-print loop) system around Csound. This is illustrated in the following diagram:\n",
    "\n",
    "![Multithreading with CsoundPerformanceThread](img/03-threading-b.png)\n",
    "\n",
    "So let's start a Csound instance from Python, with a four hours long score:"

This file has been truncated. show original

JasonHallen · January 24, 2021, 5:36pm

Thanks, Joachim. I believe I am following Francois’ instructions from that notebook. Here’s a simplified version of my Python code. The while True: block is the GUI event loop. I hit “Generate” to produce a Csound score, load it into the Csound instance with .compileCsdText(), .start() the Csound instance, and create a CsoundPerformanceThread. Hitting “Play” and “Pause” then triggers the corresponding methods of CsoundPerformanceThread.

The thing that confuses me is why this program works perfectly fine on some output devices but stutters on the other output devices on my Mac.

while True:
        event, values = window.read(timeout=100)
        if event == sg.WIN_CLOSED or event == 'Exit':
            break

        if event == "Generate":
            csd = generate_score(values, cs)
            pt = ctcsound.CsoundPerformanceThread(cs.csound())
        if event == "Play":
            pt.play()
        if event == "Pause":
            pt.pause()
        if event == "Stop":
            pt.stop()
            pt.join()
            cs.reset()
        if event == "Rec":
            pt.record("test.wav",44100, 2)
        if event == "StopRec":
            pt.stopRecord()

window.close()


def generate_score(values, cs):
    piece = Piece(melody_voices=values["-MELODY-"], drum_voices=values["-DRUMS-"], bass_voices=values["-BASS-"], tempo=values["-TEMPO-"], swing=values["-SWING-"])
    score = piece.perform() # NOTE, different than the Csound.perform() function

    with open("orchestra.orc","r") as csnd_orchestra:
        csd = ""
        for line in csnd_orchestra:
            csd += line

    csd = csd + score + '''

    s
    i 1 0 1 0 0 0
    i -1000 2 0

    </CsScore>
    </CsoundSynthesizer>
    '''
    ret = cs.compileCsdText(csd)
    if ret == ctcsound.CSOUND_SUCCESS:
        cs.start()
    return csd

JasonHallen · January 24, 2021, 10:05pm

Could this be a CoreAudio issue? I’m reading about some complaints with Apple’s CoreAudio. Do you think it’d be worth exploring JACK? I’ve never used JACK, but I’m open to anything that’ll fix this stuttering issue.

JasonHallen · January 24, 2021, 10:33pm

Adding -+rtaudio=coreaudio in the CsOptions section of the CSD solved the problem. The Pause button now works cleanly without audio stutter.

Jason

rory · January 24, 2021, 10:37pm

Thanks for posting the solution. The only time I use Python with Csound is for generating graphs, no real time output at all. Although my knowledge of Python is limited I found ctcsound to be very well put together. Good to hear that it’s working fine for you too.