Envoi de voix sur UDP avec API Java Sound

Certaines pensées, avec une mise en garde que je n'ai pas d'expérience directe pour essayer d'utiliser UDP.

Il me semble que des paquets manquants et hors de commande (supposés avec UDP) devraient être «traités» ou bien les discontinuités attendues créeraient continuellement des clics perturbateurs. Mais idk comment cela est normalement fait. Filtres? Tampon? Encapsulation des données de paquets dans Windowing (Hann ou Hamming?) Cadres pour combler les discontinuités de paquets?

javax.sound.samplé est assez proche du son natal. Voici un bon article à faire référence à des considérations relatives à la teneur en temps réel, à faible latence Audio basé sur Java.

Enfin, je suis capable de répondre à ma propre question ici. J'ai utilisé alsa API fort> (Linux), pulseaudio strong> (Linux) et jackaudio fort> (Linux) pour rendre le programme presque en temps réel (moins de 1 SEC Delay). L'API de blocage de Pulseaudio était beaucoup plus agréable à utiliser que Alsa et Jackaudio, mais j'ai expérimenté le même type de retard que j'avais connu avec Java Sound API. Jackaudio est un serveur audio à faible latence pour le travail audio professionnel. J'ai vu cet exemple: https://github.com/jackaudio/example -Clients / blob / maître / simple_client.c et s'est vite rendu compte que c'était pour la sortie mono. J'ai modifié le code un peu pour le rendre stéréo, puis ajouté des sockets UDP et une deuxième fonction de rappel. Les fonctions de rappel fonctionnent comme si elles sont des threads séparés, il n'était donc pas nécessaire d'introduire des threads POSIX.

Le code n'est pas parfait, probablement pas un bon moyen d'utiliser Jackaudio et a des tonnes de bugs. Cependant, je pense que c'est un bon point de départ pour ceux qui sont intéressés par ce genre de choses. Pour l'utiliser, d'abord installer jackaudio code> serveur et fichiers de développement via le gestionnaire de packages de votre distribution. P>

Faites-moi savoir s'il y a un meilleur moyen de mettre en œuvre la même fonctionnalité avec tout ensemble d'outils Disponible là-bas. P>

Jackaudio H2>

Solution Jackaudio: strong> p>

#define ALSA_PCM_NEW_HW_PARAMS_API

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <errno.h>
#include <alsa/asoundlib.h>

#define PORT 8080

int create_UDP_socket_receive()
{
    struct sockaddr_in server;
    int sock;
    if((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
    {
        perror("Socket");
        exit(EXIT_FAILURE);
    }

    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(PORT);
    server.sin_addr.s_addr = INADDR_ANY;

    if (bind(sock, (struct sockaddr *)&server, sizeof(server)) < 0)
    {
        perror("bind()");
        exit(EXIT_FAILURE);
    }

    return sock;
}

int main() {
    long loops;
    int rc;
    int size;
    snd_pcm_t *handle;
    snd_pcm_hw_params_t *params;
    unsigned int val;
    int dir;
    snd_pcm_uframes_t frames;

  /* Open PCM device for playback. */
    rc = snd_pcm_open(&handle, "default", SND_PCM_STREAM_PLAYBACK, 0);
    if (rc < 0) {
        fprintf(stderr, "unable to open pcm device: %s\n", snd_strerror(rc));
        exit(1);
    }

  /* Allocate a hardware parameters object. */
    snd_pcm_hw_params_alloca(&params);

  /* Fill it in with default values. */
    snd_pcm_hw_params_any(handle, params);

  /* Set the desired hardware parameters. */

  /* Interleaved mode */
    snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED);

  /* Signed 16-bit little-endian format */
    snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_S16_LE);

  /* Two channels (stereo) */
    snd_pcm_hw_params_set_channels(handle, params, 2);

  /* 44100 bits/second sampling rate (CD quality) */
    val = 44100;
    snd_pcm_hw_params_set_rate_near(handle, params, &val, &dir);

  /* Set period size to 32 frames. */
    frames = 32;
    snd_pcm_hw_params_set_period_size_near(handle, params, &frames, &dir);

  /* Write the parameters to the driver */
    rc = snd_pcm_hw_params(handle, params);
    if (rc < 0) {
        fprintf(stderr, "unable to set hw parameters: %s\n", snd_strerror(rc));
        exit(1);
    }

    /* Use a buffer large enough to hold one period */
    snd_pcm_hw_params_get_period_size(params, &frames, &dir);
    
    size = frames * 4; /* 2 bytes/sample, 2 channels */
    char buffer[size];

    int nread;
    int socket = create_UDP_socket_receive();

    snd_pcm_hw_params_get_period_time(params, &val, &dir);

    while (1) {

        if((nread = recvfrom(socket, buffer, sizeof(buffer), 0, NULL, NULL)) < 0)
        {
            perror("recvfrom()");
            exit(EXIT_FAILURE);
        }

        // write(1, buffer, sizeof(buffer));

        rc = snd_pcm_writei(handle, buffer, frames);
        if (rc == -EPIPE) {
        /* EPIPE means underrun */
            fprintf(stderr, "underrun occurred\n");
            snd_pcm_prepare(handle);
        } else if (rc < 0) {
            fprintf(stderr, "error from writei: %s\n", snd_strerror(rc));
        }  else if (rc != (int)frames) {
            fprintf(stderr, "short write, write %d frames\n", rc);
        }
    }

    snd_pcm_drain(handle);
    snd_pcm_close(handle);
    free(buffer);

    return 0;
}