How to determine whether a node's data callback will be called ("active" in the graph)?

[khiner]

Context

I implement an IO connection matrix in my application with sources as columns and destinations as rows. It is possible to set up configurations in which any node is not ultimately connected (either directly or through a series of connections) to the graph endpoint node. I also use a custom MA "monitor" node for each node's input/output - this custom node is simply a passthrough that copies the frames on each data callback to a buffer of size device.playback.internalSampleRate, which is then rendered to a waveform plot.

Needs/Questions

1. When the graph connections are changed such that a given node's data callback is no longer called (since the node is no longer pulled from), I would like to zero out its input/output monitor nodes' buffers. Currently, its data callback will just stop being called by MA, so my monitors' plots will just freeze at the most recent buffer.

2. I would also like to indicate in the node's view whether the node is "processing" - whether it's ultimately connected to the graph endpoint node and its data callback is continually being called.

What is the best way to determine whether any given node should expect its data callback to be called (whether it's "active" in the graph)?

The two ways I've thought of are:

1. On every connection change in my application, traverse the graph, mimicking how MA does when it pulls from the endpoint to all sources, marking all nodes I reach as "active."
2. For each node, track when its data callback was most recently called. Consider the node inactive after some duration (e.g., some small multiple of device.playback.internalSampleRate).

The first one seems tricky and heavy, especially since traversing through input buses is somewhat involved. The second one has the problem of needing a magic number for the duration where I'm confident calling a node inactive, especially when the definitive answer is known via method 1.

Does this all sound right? Am I missing something in the API that would make my life easier? Or any other ideas?

Thank you!

[khiner]

I thought of a third way, which is basically doing (1), but with my application's connection matrix state instead of traversing the MA graph. I think I'll go this route for now, but still curious about any thoughts/suggestions!

[mackron]

Sorry for my exceptionally slow response to your questions. So miniaudio doesn't explicitly expose connection state retrieval APIs, the main reason being that the node graph is (mostly) lock-free while being thread-safe and as a result is rather non-trivial. A simple API like ma_node_is_connected() is not quite a simple as it sounds. However, typically a program will be maintaining it's own state and will have some kind of knowledge of the connection status, such as whatever logic was used when deciding to call ma_node_attach/detach_output_bus() in the first place. That's what I'd recommend you do in you case, which sounds just like your third suggestion.

[khiner]

Great, thanks! This approach worked out - I keep a connection adjacency list and do DFS on each node to see if there's a path to the graph endpoint node.