Mumble controlled solution (audio voice activated) PTT/audio squelch

[FilipStadler]

Programming a plugin is not so easy for me - have have to lean alot more about the api etc. ;)

What I am looking for is something simular to this

A squelch (SQL) output to be connected with the transceiver's PTT (push to talk) input in order to set the transceiver to transmit-mode when audio is received from the mumble server.

Old solution https://github.com/hostfer/mumbleptt or https://github.com/dk7lst/mumbleRF simular project in some way also https://github.com/talkkonnect/talkkonnect fokus on this but in some countries you are not allowed to modify the radio.

A linux mumble plugin would be nice because the someone speaks on the chanal (not our self) it should "press" PTT possible with a a timer (Tranmission limit counter ) for safety .

Its almost how the audio input side is made on mumble but I need it on the audio output side - it would be possible to have this running as a seperate task that just monitor the output maybe via a pipewire sink and on audio can call/execte a external bash script that can a raspberry gpio pins or on pc maybe rs232 can signal to a radio we now have audio to transmit and with some delay just like the mumble input is done because it have to "press" the PTT key on radio and hold it for a while.

I have been looking and searching every where for possible workarounds and a pipewire sqeulch would be a possible maybe dirty workaroud to have a (squelch on the audio output from mumble on the mumble-chanal - but I am not sure about how it works with the signal if I have to look on the signal/audio level at all or if can do on demand, so when somebody speaks on the chanal it make the connection from pipewire monitor output to a (virtual sink device ptt) and when no audio it removes the session until somebody speaks on the chanal again it should make a new session.

Some use modified soundcard and specieal hardware - but would be nice to use gpio or serial rs232

I am sure alot ham/cb operators would switch from Teamspeak/zello to mumble if a universel linux mumble plugin for did exist for the current mumble because its opensource and very great audio with opus and running on small low power devices.

Any suggestions about a dirty pipewire workaround and ways to monitor the audio on a mumble chanal ?

[FilipStadler]

I have a few problems to assing the Mumble output via pipewire to the vu-ptt, but when connected it just calls a extern bash ptt script that does gpio control.

But it would be cool if mumble was able to run a script if and when somebody is speaking on the chanal. It would be usefull for other things also not just radio but other intercoms, speakers - this a just dirty way maybe but can ICE be used but would need connection to ice

cat vu-ptt.c

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <pulse/simple.h>
#include <pulse/error.h>
#include <unistd.h> // For usleep

#define SAMPLE_RATE 44100
#define BUFFER_SIZE 1024
#define THRESHOLD 1000.0 // Tærskelværdi for lydstyrke til at udløse PTT
#define DELAY 1000000 // Forsinkelse i mikrosekunder (1 sekund)

int main(int argc, char *argv[]) {
struct pa_simple *pa_stream = NULL;
struct pa_sample_spec ss;
int error;

// Set up PulseAudio sample specification
ss.format = PA_SAMPLE_S16LE;  // 16-bit little-endian samples
ss.channels = 1;              // Mono
ss.rate = SAMPLE_RATE;        // 44100 Hz sample rate

// Specify the source to listen to
const char *source_name = "Mumble";

// Create a new PulseAudio stream
pa_stream = pa_simple_new(
    NULL,                  // Use default PulseAudio server
    "VU PTT Meter",            // Application name
    PA_STREAM_RECORD,      // Stream direction (record)
    NULL,                  // Use default audio device
    "record",              // Stream name
    &ss,                   // Pointer to sample specification
    NULL,                  // Use default channel map
    NULL,                  // Use default buffer attributes
    &error                 // Pointer to error variable
);

if (!pa_stream) {
    fprintf(stderr, "Error initializing PulseAudio stream: %s\n", pa_strerror(error));
    return 1;
}

printf("Voice Meter running...\n");

while (1) {
    int16_t buffer[BUFFER_SIZE];
    float rms = 0.0;

    // Read audio data from PulseAudio stream
    if (pa_simple_read(pa_stream, buffer, sizeof(buffer), &error) < 0) {
        fprintf(stderr, "Error reading from PulseAudio stream: %s\n", pa_strerror(error));
        pa_simple_free(pa_stream);
        return 1;
    }

    // Calculate RMS
    for (int i = 0; i < BUFFER_SIZE; i++) {
        rms += buffer[i] * buffer[i];
    }
    rms = sqrt(rms / BUFFER_SIZE);

    // Print RMS value to the screen
    printf("\rLydstyrke (RMS): %.2f", rms);
    fflush(stdout);

    // Check if RMS exceeds the threshold and show notification
    if (rms > THRESHOLD) {
        printf("\nPTT\n");
        system("/home/adminsen/bin/ptt");
        usleep(DELAY);  // Add delay
    }
}

// Cleanup
if (pa_stream)
    pa_simple_free(pa_stream);

return 0;

}