Unable to record audio on MacOS

[TnTora]

macOS 15.2 (x86)

I'm trying to run the following script to test this module but it seems I am failing to get proper audio.

import soundcard as sc
import soundfile as sf

default_mic = sc.default_microphone()

data = default_mic.record(samplerate=48000, numframes=48000*5)
print(data)
sf.write(file="out.wav", data=data, samplerate=48000)

Here is the result of print(data)

[[ 0.00875521  0.00859588]
 [ 0.01109303  0.01090191]
 [ 0.01041745  0.01023482]
 ...
 [-0.00246532 -0.00247982]
 [-0.00246533 -0.00247982]
 [-0.00246533 -0.00247983]]

Listening to the output file I hear a few frames of proper audio followed by a short high pitched noise and then silence.
I tried using the internal mic, an external mic and a virtual one (blackhole) but got the same result with all of them.

Something I noticed while testing recording system audio using blackhole as a mic is that if audio is already playing when I run the script I get something like the array above. If I start the script and then immediately play audio I get

[[-0. -0.]
 [-0. -0.]
 [-0. -0.]
 ...
 [-0. -0.]
 [-0. -0.]
 [-0. -0.]]

I tried recording the same system audio as above using the library sounddevice and got proper audio, this is the numpy array

[[ 2.1381495e-03  1.9403318e-03]
 [ 3.4074080e-03  3.1864089e-03]
 [ 4.5137000e-03  4.3309033e-03]
 ...
 [ 1.0739344e-05  2.2570629e-04]
 [ 2.0904181e-04  4.3157060e-04]
 [-2.0285620e-04  3.7671925e-05]]

Am I missing something?

[TnTora]

After some more testing I noticed I get clean audio using samplerate=44100

[bastibe]

Did you get any kind of error message when the sound was glitched? MacOS is the only operating system that does not provide built-in resampling in their audio stack, so SoundCard adds its own as a postprocessing step if the sampling rate can't be set natively. Apparently this is glitched on your system.

What version of MacOS are you running? I swear they change things every version just to mess with developers.

[TnTora]

I am on macOS 15.2 (x86), Python 3.13.1 installed via homebrew.

There are no error messages when I run the script.

[TnTora]

I did some more testing. I tried using most of the sample rates listed in the blackhole virtual mic as well as a few more random ones to see how the resampler behaves, here is what I got:

• 11025 22050 44100 88200 176400 352800 (many multiples of 11025)- works fine
• 48000 72000 - a few frames of actual audio followed by an high pitched noise and then silence
• 96000 144000 192000 240000 384000 (many multiples of 48000) - distorted audio
• 120000 168000 - distorted and sped up
• 8000 16000 22000 and probably many more - ('error during sample rate conversion:', -50)

[bastibe]

That is fascinating. Thank you for the analysis. Evidently, something is very wrong with the resampler.

I currently don't have much time to look into this. There's a link to the documentation and a code example in the code (the comment just before class _Resampler).

This seems to have worked without issue in the past. I wonder what changed that causes the breakage on your machine. Any help with this would be greatly appreciated.

[TnTora]

I think I might have found the problem.

I modified this AudioConverter example code to use the same formats as soundcard and the resampling worked perfectly. So I checked the differences in implementation and ended up focusing on the while loop where AudioConverterFillComplexBuffer is called.

Here is part of the while loop in the code I linked:

while(1)
    {
        // wrap the destination buffer in an AudioBufferList
        AudioBufferList convertedData;
        convertedData.mNumberBuffers = 1;
        convertedData.mBuffers[0].mNumberChannels = mySettings->inputFormat.mChannelsPerFrame;
        convertedData.mBuffers[0].mDataByteSize = outputBufferSize;
        convertedData.mBuffers[0].mData = outputBuffer;
        
        // now call the audioConverter to transcode the data. This function will call
        // the callback function as many times as required to fulfill the request.
        UInt32 ioOutputDataPackets = packetsPerBuffer;
        OSStatus error = AudioConverterFillComplexBuffer(audioConverter,
                                                         MyAudioConverterCallback,
                                                         mySettings,
                                                         &ioOutputDataPackets,
                                                         &convertedData,
                                                         (mySettings->inputFilePacketDescriptions ? mySettings->inputFilePacketDescriptions : nil));
        if (error || !ioOutputDataPackets)
        {
            //        fprintf(stderr, "err: %ld, packets: %ld\n", err, ioOutputDataPackets);
            break;    // this is our termination condition
        }

The buffer is set on each loop. Based on this I modified the _Resampler.resample function to:

def resample(self, data):
        self.todo = numpy.array(data, dtype='float32')
        while len(self.todo) > 0:
            self.outsize[0] = self.blocksize
            self.outbuffer.mNumberBuffers = 1
            self.outbuffer.mBuffers[0].mNumberChannels = self.channels
            self.outbuffer.mBuffers[0].mDataByteSize = self.blocksize*4*self.channels
            self.outbuffer.mBuffers[0].mData = self.outdata

            status = _au.AudioConverterFillComplexBuffer(self.audioconverter[0],
                                                         self._converter_callback,
                                                         _ffi.NULL,
                                                         self.outsize,
                                                         self.outbuffer,
                                                         _ffi.NULL)

            if status != 0 and status != -1:
                raise RuntimeError('error during sample rate conversion:', status)

            array = numpy.frombuffer(_ffi.buffer(self.outdata), dtype='float32').copy()

            self.queue.append(array[:self.outsize[0]*self.channels])

        converted_data = numpy.concatenate(self.queue)
        self.queue.clear()

        return converted_data.reshape([-1, self.channels])

This got rid of all the errors and achieved working audio for all the sample rates I tested.

Since my curiosity was picked, I monitored some of the variables in the original resample function and the converter_callback and got some interesting results for numberpackets and self.outbuffer[0].mBuffers[0].mDataByteSize:

Recording: 48000
numberpackets: 487, len(self.todo): 512, self.blocksize: 512
numberpackets: 470, len(self.todo): 25, self.blocksize: 512
numberpackets: 445, len(self.todo): 0, self.blocksize: 512
numberpackets: 25, len(self.todo): 512, self.blocksize: 512
numberpackets: 24, len(self.todo): 487, self.blocksize: 512
numberpackets: 25, len(self.todo): 463, self.blocksize: 512
numberpackets: 25, len(self.todo): 438, self.blocksize: 512
numberpackets: 25, len(self.todo): 413, self.blocksize: 512
numberpackets: 25, len(self.todo): 388, self.blocksize: 512
numberpackets: 24, len(self.todo): 363, self.blocksize: 512
numberpackets: 25, len(self.todo): 339, self.blocksize: 512
numberpackets: 25, len(self.todo): 314, self.blocksize: 512
........
numberpackets: 2, len(self.todo): 14, self.blocksize: 512
numberpackets: 2, len(self.todo): 12, self.blocksize: 512
numberpackets: 2, len(self.todo): 10, self.blocksize: 512
numberpackets: 2, len(self.todo): 8, self.blocksize: 512
numberpackets: 2, len(self.todo): 6, self.blocksize: 512
numberpackets: 1, len(self.todo): 4, self.blocksize: 512
numberpackets: 2, len(self.todo): 3, self.blocksize: 512
numberpackets: 2, len(self.todo): 1, self.blocksize: 512
numberpackets: 1, len(self.todo): 0, self.blocksize: 512
numberpackets: 1, len(self.todo): 512, self.blocksize: 512
numberpackets: 1, len(self.todo): 511, self.blocksize: 512
numberpackets: 1, len(self.todo): 510, self.blocksize: 512
numberpackets: 1, len(self.todo): 509, self.blocksize: 512
numberpackets: 1, len(self.todo): 508, self.blocksize: 512
numberpackets: 1, len(self.todo): 507, self.blocksize: 512
numberpackets: 1, len(self.todo): 506, self.blocksize: 512

numberpackets stays at 1 for the rest of the recording which results in basically no audio.
Here is the corresponding self.outbuffer[0].mBuffers[0].mDataByteSize:

self.outbuffer[0].mBuffers[0].mDataByteSize: 4096
self.outbuffer[0].mBuffers[0].mDataByteSize: 4096
self.outbuffer[0].mBuffers[0].mDataByteSize: 216
self.outbuffer[0].mBuffers[0].mDataByteSize: 216
......
self.outbuffer[0].mBuffers[0].mDataByteSize: 216
self.outbuffer[0].mBuffers[0].mDataByteSize: 144
self.outbuffer[0].mBuffers[0].mDataByteSize: 144
self.outbuffer[0].mBuffers[0].mDataByteSize: 144
.......
self.outbuffer[0].mBuffers[0].mDataByteSize: 144
self.outbuffer[0].mBuffers[0].mDataByteSize: 136
self.outbuffer[0].mBuffers[0].mDataByteSize: 136
self.outbuffer[0].mBuffers[0].mDataByteSize: 136
self.outbuffer[0].mBuffers[0].mDataByteSize: 136
.......
self.outbuffer[0].mBuffers[0].mDataByteSize: 136
self.outbuffer[0].mBuffers[0].mDataByteSize: 104
self.outbuffer[0].mBuffers[0].mDataByteSize: 104
self.outbuffer[0].mBuffers[0].mDataByteSize: 104
......
self.outbuffer[0].mBuffers[0].mDataByteSize: 104
self.outbuffer[0].mBuffers[0].mDataByteSize: 88
self.outbuffer[0].mBuffers[0].mDataByteSize: 88
self.outbuffer[0].mBuffers[0].mDataByteSize: 88
.....
self.outbuffer[0].mBuffers[0].mDataByteSize: 88
self.outbuffer[0].mBuffers[0].mDataByteSize: 64
self.outbuffer[0].mBuffers[0].mDataByteSize: 64
.....
self.outbuffer[0].mBuffers[0].mDataByteSize: 64
self.outbuffer[0].mBuffers[0].mDataByteSize: 40
self.outbuffer[0].mBuffers[0].mDataByteSize: 40
self.outbuffer[0].mBuffers[0].mDataByteSize: 40
......
self.outbuffer[0].mBuffers[0].mDataByteSize: 40
self.outbuffer[0].mBuffers[0].mDataByteSize: 16
self.outbuffer[0].mBuffers[0].mDataByteSize: 16
self.outbuffer[0].mBuffers[0].mDataByteSize: 16
......
self.outbuffer[0].mBuffers[0].mDataByteSize: 16
self.outbuffer[0].mBuffers[0].mDataByteSize: 8
self.outbuffer[0].mBuffers[0].mDataByteSize: 8
self.outbuffer[0].mBuffers[0].mDataByteSize: 8
self.outbuffer[0].mBuffers[0].mDataByteSize: 8
self.outbuffer[0].mBuffers[0].mDataByteSize: 8

stays at 8 for the rest of the recording.
With some sample rates it would go all the way down to 0 and result in a error -50 (Bad parameter)

This is what I get now with the modified resample function:

numberpackets: 487, len(self.todo): 512, self.blocksize: 512
numberpackets: 470, len(self.todo): 25, self.blocksize: 512
numberpackets: 445, len(self.todo): 0, self.blocksize: 512
numberpackets: 470, len(self.todo): 512, self.blocksize: 512
numberpackets: 471, len(self.todo): 42, self.blocksize: 512
numberpackets: 429, len(self.todo): 0, self.blocksize: 512
numberpackets: 471, len(self.todo): 512, self.blocksize: 512
numberpackets: 470, len(self.todo): 41, self.blocksize: 512
numberpackets: 429, len(self.todo): 0, self.blocksize: 512
numberpackets: 471, len(self.todo): 512, self.blocksize: 512
numberpackets: 470, len(self.todo): 41, self.blocksize: 512
numberpackets: 429, len(self.todo): 0, self.blocksize: 512
......
numberpackets: 470, len(self.todo): 512, self.blocksize: 512
numberpackets: 471, len(self.todo): 42, self.blocksize: 512
numberpackets: 429, len(self.todo): 0, self.blocksize: 512
numberpackets: 470, len(self.todo): 512, self.blocksize: 512
numberpackets: 471, len(self.todo): 42, self.blocksize: 512
numberpackets: 429, len(self.todo): 0, self.blocksize: 512
numberpackets: 471, len(self.todo): 512, self.blocksize: 512
numberpackets: 470, len(self.todo): 41, self.blocksize: 512
numberpackets: 429, len(self.todo): 0, self.blocksize: 512
numberpackets: 471, len(self.todo): 512, self.blocksize: 512
numberpackets: 470, len(self.todo): 41, self.blocksize: 512
numberpackets: 429, len(self.todo): 0, self.blocksize: 512
numberpackets: 470, len(self.todo): 512, self.blocksize: 512
numberpackets: 471, len(self.todo): 42, self.blocksize: 512
numberpackets: 429, len(self.todo): 0, self.blocksize: 512

Given these results self.outbuffer.mBuffers[0].mDataByteSize might be the only one needed to be reset, and it does work if I only reset that parameter, so I'm not sure if I should keep or remove the others.

[TnTora]

Also, while researching this bug I noticed something else.

The _AudioUnit class always uses the default sample rate of 44.1 kHz for input, so trying to record audio with a microphone that does not support that sample rate (e.g. my headphones integrated mic caps at 16 kHz) or is configured to use a different one in Audio MIDI Setup results in empty data.

My mic is set to 48 kHz in Audio MIDI Setup and I have chosen 48000 as samplerate to record in soundcard as well, this is the current result:

Recording: 48000
self.samplerate: 44100.0
self.resample: 0.91875
data 48000: 
[[-0. -0.]
 [-0. -0.]
 [-0. -0.]
 ...
 [-0. -0.]
 [-0. -0.]
 [-0. -0.]]

To fix this I got the sample rate from the current device and set self.samplerate to that as shown in the documentation linked in the comment you pointed out.

class _AudioUnit:

def __init__(self, iotype, device, samplerate, channels, blocksize):
        self._iotype = iotype

     .........

        if iotype == 'input':
            self.enableinput = True
            self.enableoutput = False
            self._au_scope = _cac.kAudioUnitScope_Output
            self._au_element = 1
        elif iotype == 'output':
            self.enableinput = False
            self.enableoutput = True
            self._au_scope = _cac.kAudioUnitScope_Input
            self._au_element = 0

        self.device = device

        blocksize = blocksize or self.blocksize

        if iotype == 'input':
            # Get the input device format
            curr_device_format = self._get_property(_cac.kAudioUnitProperty_StreamFormat,
                                                    _cac.kAudioUnitScope_Input,
                                                    1,
                                                    "AudioStreamBasicDescription")

            self.samplerate = curr_device_format[0].mSampleRate
            self.resample = self.samplerate/samplerate
        else:
            self.resample = 1
            self.samplerate = samplerate

........

This is the new result:

Recording: 48000
self.samplerate: 48000.0
self.resample: 1.0
data 48000: 
[[-0.35554582 -0.34935975]
 [-0.34293708 -0.34665108]
 [-0.34207642 -0.34924468]
 ...
 [ 0.19956093  0.31311467]
 [ 0.16753812  0.35256022]
 [ 0.1553586   0.3396605 ]]

which outputs the correct audio.

[bastibe]

Thank you so much for figuring this out! This has had me stumped for a long time!

And my apologies for not responding quickly, I was travelling over the weekend.

Would you like to contribute these changes as a pull request? That way, your contribution will be recorded in the commit history.

[TnTora]

I created a pull request. It's my first time creating one so let me know if there is anything I should change.