Updating ma_resource_manager_data source while it's playing

[erikjalevik]

I have written an audio player-type implementation, which lets you play a file, then seek, pause, stop, resume etc. It's using the low-level API and the resource manager for streaming, i.e. ma_resource_manager_data_source_init.

When testing, I noticed some odd intermittent hangs and asserts in the flac code being triggered. Which led me to this issue explaining that we can't read PCM frames in the audio callback and seek from the main thread. That made me wonder which data source operations are safe to do from the main thread, while an audio callback is up and running reading data from the same source?

Currently, my audio callback is only calling ma_data_source_read_pcm_frames, while the main thread can call any of the following at various points:

• ma_data_source_get_cursor_in_pcm_frames
• ma_data_source_get_data_format
• ma_data_source_get_length_in_pcm_frames
• ma_data_source_get_length_in_seconds
• ma_data_source_get_range_in_pcm_frames
• ma_data_source_seek_to_pcm_frame
• ma_data_source_set_looping
• ma_data_source_set_range_in_pcm_frames

Are they all unsafe without synchronisation?

[erikjalevik]

I just tried GPT-4 as well, and it gives a seemingly very reasonable answer. Is it correct?

GPT:

Generally, you should avoid performing any operation that modifies the internal state of a data source from the main thread while the audio callback is reading from it. The operations that are potentially unsafe without synchronization are:

• ma_data_source_seek_to_pcm_frame()
• ma_data_source_set_looping()
• ma_data_source_set_range_in_pcm_frames()

These operations modify the internal state of the data source and may cause conflicts if the audio callback is reading data at the same time.

The following operations should be safe to use without synchronization, as they only retrieve information from the data source:

• ma_data_source_get_cursor_in_pcm_frames()
• ma_data_source_get_data_format()
• ma_data_source_get_length_in_pcm_frames()
• ma_data_source_get_length_in_seconds()
• ma_data_source_get_range_in_pcm_frames()

[orcmid]

This is disturbing for two reasons.

First, one can get bad advice from StackOverflow already, although the comments about an item may be a tip-off.

Now we have a new problem. GPT-4 (and presumably GitHub Co-Pilot) provide plausible-seeming explanations.

In either case, these need to be used in a manner that can be verified by the concerned party (you). In the above case, there is enough that could be confirmed by checking the miniaudio code. The problem of relying on this in a test is that unless a race condition is detected, you won't know if there isn't an undetected one that will burn you in production. Understanding the code and where there can be thread interference and race conditions is what's called for.

Asking someone else to confirm such sources is not what's called for here. I know that seems harsh. But think about you being the one receiving such a question. And from many others.

I don't have a good response, only a concern about a future source of complaints after relying on an AI's analysis. An alternative, higher-level audio abstraction might serve better. Otherwise, all I can say is it is necessary to become more expert at this level to achieve reliable results in releasable software that you intend to support. It pains me to say this. David provides awesome support, and if he spanks me for this, I will deserve it.

Hang in there Erik.

[erikjalevik]

I hear and share your concerns, Dennis. It was in no way my intention to somehow imply that this was an authoritative answer, hence why I asked David first, and then as an afterthought: hmm, I wonder what GPT would say.

One of the difficulties with these LLMs is indeed separating the hallucinations from the factual answers.

As a developer, I'm currently in the process of evaluating what ChatGPT is capable of, throwing all sorts of stuff at it, since it seems like a necessity to be able to harness this tech in the future. Not to mention that it is damn fascinating!

Happy to remove the GPT-generated comment if it's considered bad form.

[orcmid]

Please don't remove your question. It is an informative discussion. I notice that GitHub Co-Pilot might be more useful. I also see that Microsoft is including Co-Pilot in Visual Studio Code, and I definitely want to see how that works out for inspection of code of mine. I don't expect Co-Pilot to find it favorable, but who knows :).

My simple point is that if we rely on AI's about code or code-related questions, it's on us to figure out how dependable a response is. The consultation can still be useful in giving us some ideas to check-out.

[mackron]

It's not very well documented, and is something I need to improve in time. Certainly you cannot seek - that's the biggest one and also the most common one I see in the wild.

There are other functions that are not thread safe, but they're the kind of things you would set up once at start up and then leave so they're not as important. These include anything that modifies the internal state of the data source, such as set_range() and set_loop_point().

ChatGPT is wrong about a few of these. set_looping() should be safe - that's using an explicit atomic operation for setting the internal flag. Also, get_length() is not safe to call from another thread while in the middle of reading in the general case. There are some backends where the length can only be determined by decoding the entire file. MP3 is an example. In this case, retrieving the length will result in the internal decoder changing it's state which will obviously break your reading process in the audio thread. You generally shouldn't be calling anything that fires any backend callbacks because the backend could be doing anything. I think ChatGPT is just guessing by assuming that "get" = safe and "set" = unsafe. It's making overly simplified assumptions.

I have added a note to my todo list to make this clearer in the documentation. I also have future plans to auto-generate some API reference documentation which will hopefully make it clearer - it'd be good to have an explicit mention in the reference docs as to whether or not it's safe to call some function while in the middle of reading.

[erikjalevik]

Very useful, thanks a lot.