How to attach ma_sound to ma_node_graph

[mincequi]

I am trying to define a nodegraph wich can be attached inbetween a ma_sound object an a ma_engine. The nodegraph shall carry multiple instances of filters. However, your API is apparently not supposed to be used like this. Attaching a ma_sound to a ma_node_graph fails with MA_INVALID_OPERATION.
Let me express with a code snippet what i am trying to achieve:

#include <assert.h>
#include <stdio.h>
#include "miniaudio.h"

int main(int argc, char** argv)
{
    ma_result result;
    ma_engine engine;

    if (argc < 2) {
        printf("No input file.");
        return -1;
    }

    result = ma_engine_init(NULL, &engine);
    if (result != MA_SUCCESS) {
        printf("Failed to initialize audio engine.");
        return -1;
    }

    ma_sound sound;
    result = ma_sound_init_from_file(&engine, argv[1], 0, NULL, NULL, &sound);
    if (result != MA_SUCCESS) {
        printf("Failed to init sound from file.");
        return -1;
    }

    // Init node graph
    ma_node_graph_config graphConfig = ma_node_graph_config_init(2);
    ma_node_graph nodeGraph;
    ma_node_graph_init(&graphConfig, NULL, &nodeGraph);

    // Init filter
    ma_lpf_node_config filerConfig = ma_lpf_node_config_init(2, 48000.0, 500.0, 2);
    ma_lpf_node filterNode;
    ma_lpf_node_init(&nodeGraph, &filerConfig, NULL, &filterNode);

    // Wiring things together:
    // Sound -> NodeGraph -> Engine
    // THIS FAILS:
    assert(ma_node_attach_output_bus(&sound, 0, &nodeGraph, 0) == MA_SUCCESS);
    assert(ma_node_attach_output_bus(&nodeGraph , 0, &filterNode, 0) == MA_SUCCESS);
    assert(ma_node_attach_output_bus(&filterNode, 0, ma_node_graph_get_endpoint(&nodeGraph), 0) == MA_SUCCESS);
    assert(ma_node_attach_output_bus(ma_node_graph_get_endpoint(&nodeGraph), 0, ma_engine_get_endpoint(&engine), 0) == MA_SUCCESS);

    // THIS SUCCEEDS:
    //ma_node_attach_output_bus(&sound, 0, &filterNode, 0);
    //ma_node_attach_output_bus(&filterNode, 0, ma_engine_get_endpoint(&engine), 0);

    ma_sound_start(&sound);
    printf("Press Enter to quit...");
    getchar();

    ma_engine_uninit(&engine);

    return 0;
}

The line assert(ma_node_attach_output_bus(&sound, 0, &nodeGraph, 0) == MA_SUCCESS); fails here, while attaching a single filter inbetween ma_sound and ma_engine works.

How could I realise and/or group a set of filters together?

Thanks in advance.

[mackron]

A few issues here. First of all, the ma_engine object is a node graph, so there's no need to create a separate ma_node_graph object. Just use ma_engine_get_node_graph(&engine) to get a pointer to the node graph.

Regarding your assertion, when you attach a node to the graph, you attach it to another node. You're passing in &nodeGraph which is not a node. You need to attach it to the endpoint of the graph:

ma_node_attach_output_bus(&sound, 0, ma_node_graph_get_endpoint(&nodeGraph), 0)

You didn't get a compilation error because the ma_node type is actually void* and the compiler just implicitly casts it. miniaudio does not hold your hand, so you need to be careful.

So just to summarise, when you attach a node to the graph, you need to attach it to another node, not directly to the ma_node_graph object. The graph has an endpoint node which is retrieved with ma_node_graph_get_endpoint(). Secondly, the engine itself is a node graph and there's no need for a separate ma_node_graph object for what you're trying to do.

(Moving this to the discussion section.)

[mincequi]

Ok, mostly understood, i guess.

But how is the ma_node_graph then actually used? If i want something to be attached at its end (like another engine), i would use its endpoint, right? But what if i want to attach the output of a ma_sound to the input of a ma_node_graph?
My plan is actually, to make the ma_node_graph reusable and that's why i dod not want to use the node graph of the engine.

This is what i want to achieve:
sound -> filter bank -> engine

The filter bank shall be reusable and contains several filters. Its input and output might be disconnected at some point in time and reconnected to some other sound or engine object.

[mackron]

I don't think miniaudio works the way you're hoping it would work. The fundamental problem is that a node needs to be owned by a node graph, so you can't just have one instantiation of a node which is moved around between different graphs. It's not designed to be used like that. You would need to have separate instances for each engine/graph you'd want to attach too.

I would set up your filter bank to just be a structure of nodes. Something like below:

struct filter_bank
{
    ma_node inputNode; // Connect inputs to this, and connect this to your filter nodes
    ma_node filterNodes0, filterNode1, etc., etc.; // Connect these together and eventually the output node
    ma_node outputNode; // Connect this to a node in the graph.
}

Then instantiate one of these for each graph you want to attach to. If you insist on using a graph as the wrapper, you would need to build a custom node.

What I think I need to add to miniaudio is sort of like a "sub-graph" system, which I've considered before but just haven't been able to think of a good way to do it. It would just be like the filter bank part of your set up, but would still be tied to a specific node graph.

(A quick note regarding my earlier comment. I looked at the code just now and apparently I did indeed set it up so that ma_node_graph is a node that can be connected as an input to another node. I don't even remember doing that - I wonder if it might have been some experimental stuff that I forgot to get rid of. However, it does not support attaching any input nodes, and I think it's buggy because a node needs to be owned by a node graph, but in this case it's using itself as the owner which creates this weird cyclic dependency. I'll probably be removing that in the next API-breaking release and create a new type of node called ma_node_graph_node which takes 0 inputs and 1 output and uses ma_node_graph_read_pcm_frames() for the output data.)

[mincequi]

Yeah, that was the point that confused me. I thought a node-graph can/should be used as a kind of "sub-graph".
Anyhow, this helped a lot and i can continue with my implementation.

Btw: i am writing a C++ wrapper for miniaudio. Are you interested in providing this together with the official miniaudio?
However, i would add a proper cmake script and deliver as static library (with multiple sources) instead of a single header.