Cool project and demo on recent Modular November Community Meeting

[shakfu]

Thanks for sharing your amazing project.

I'm not so familiar with Mojo but excited about its promise. I've been waiting for Mojo to reach 1.0, so I subscribed to its YouTube channel and this led me to watch your recent demo during the modular community meeting. I'm super-impressed with MMMAudio and what it can do.

One of my projects is py-js, which includes a bunch of Python3 externals for Max/MSP. I'd love to create a Max/MSP external which uses python/Mojo for DSP so it can connect with other Max/MSP objects.

I'm looking forward on learning more about this space from your project!

S

[tedmoore]

I'd love to create a Max/MSP external which uses python/Mojo for DSP

That's a cool idea.

[spluta]

Look into MMMAudio.py. In there we use PyAudio to pull samples from MMMAudio. But it doesn't have to do it that way. If you look at def plot, it pulls samples for plotting outside the audio block. If you can get this to work with Max, you just need to make a function that pulls the number of samples needed per max audio block. Easier said than done, but if you can get the plumbing working in Max, this could be really cool.

[shakfu]

@spluta Thanks for the advice

To do this efficiently would probably need to access Mojo via it's c or c++ api. From what I understand, in the mojo faq, it's not there yet:

What about interoperability with other languages like C/C++?
Yes, we want to enable developers to port code from languages other than Python to Mojo as well. We expect that due to Mojo’s similarity to the C/C++ type systems, migrating code from C/C++ should work well and it’s in our roadmap.

Nonetheless, one other less efficient way would be to use the python c-api which then calls mojo from python.

It would likely look like a python c-api analog to this code from luajit_external.h in my luajit-max project and use something like your MMMAudioBridge.

//------------------------------------------------------------------------------
// DSP Callbacks (Inline Implementations)
//------------------------------------------------------------------------------

/**
 * Standard dsp64 handler: called when DSP is compiled.
 *
 * @param engine - Lua engine instance
 * @param context - External-specific context (for object_method)
 * @param dsp64 - DSP object
 * @param count - Inlet connection count
 * @param samplerate - Current sample rate
 * @param maxvectorsize - Maximum vector size
 * @param flags - DSP flags
 * @param perform_func - perform64 function to register
 */
static inline void luajit_handle_dsp64(luajit_engine* engine,
                                       void* context,
                                       t_object *dsp64,
                                       short *count,
                                       double samplerate,
                                       long maxvectorsize,
                                       long flags,
                                       void* perform_func)
{
    post("sample rate: %f", samplerate);
    post("maxvectorsize: %d", maxvectorsize);

    // Store sample rate and vector size
    engine->samplerate = samplerate;
    engine->vectorsize = maxvectorsize;

    // Update Lua global
    lua_engine_set_samplerate(engine->L, samplerate);

    object_method(dsp64, gensym("dsp_add64"), context, perform_func, 0, NULL);
}

/**
 * Standard perform64 handler: audio processing callback.
 *
 * @param engine - Lua engine instance
 * @param dsp64 - DSP object
 * @param ins - Input audio buffers
 * @param numins - Number of inputs
 * @param outs - Output audio buffers
 * @param numouts - Number of outputs
 * @param sampleframes - Number of samples to process
 * @param flags - DSP flags
 * @param userparam - User parameter (unused)
 */
static inline void luajit_handle_perform64(luajit_engine* engine,
                                           t_object *dsp64,
                                           double **ins,
                                           long numins,
                                           double **outs,
                                           long numouts,
                                           long sampleframes,
                                           long flags,
                                           void *userparam)
{
    t_double *inL = ins[0];     // Input from first inlet
    t_double *outL = outs[0];   // Output to first outlet
    int n = sampleframes;
    double prev = engine->prev_sample;

    // If in error state, output silence
    if (engine->in_error_state) {
        while (n--) {
            *outL++ = 0.0;
        }
        return;
    }

    // Convert params to float array for lua_engine
    float float_params[LUAJIT_MAX_PARAMS];
    for (int i = 0; i < engine->num_params; i++) {
        float_params[i] = (float)engine->params[i];
    }

    while (n--) {
        // Use dynamic parameter version
        prev = lua_engine_call_dsp_dynamic(engine->L, engine->func_ref, &engine->in_error_state,
                                           *inL++, prev, n, float_params, engine->num_params);
        *outL++ = prev;
    }

    engine->prev_sample = prev;
}