[CODE]
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

#include <jack/jack.h>

jack_port_t *port_recepteur;
jack_port_t *port_emetteur;
jack_client_t *client;
[/CODE]

[CODE]
/**
*Petite fonction permettant de réaliser le process réellement éxécuté.
*/
int
process (jack_nframes_t trames, void *arg)
{
	jack_default_audio_sample_t *entree, *sortie;
	
	entree = jack_port_get_buffer (port_recepteur, trames);
	sortie = jack_port_get_buffer (port_emetteur, trames);
	memcpy (sortie, entree,
		sizeof (jack_default_audio_sample_t) * trames);

	return 0;      
}
[/CODE]

[CODE]
void
jack_shutdown (void *arg)
{
	exit (1);
}
[/CODE]

[CODE]
int
main (int argc, char *argv[])
{
	const char **ports;
	const char *nom_client = "simple";
	const char *nom_serveur = NULL;
	jack_options_t options = JackNullOption;
	jack_status_t status;
	
	/* Ouvre une connexion vers le serveur JACK */

	client = jack_client_open (nom_client, options, &status, nom_serveur);
	if (client == NULL) {
		fprintf (stderr, "jack_client_open() echec, "
			 "status = 0x%2.0x\n", status);
		if (status & JackServerFailed) {
			fprintf (stderr, "Impossible de se connecter au serveur JACK\n");
		}
		exit (1);
	}
	if (status & JackServerStarted) {
		fprintf (stderr, "Serveur JACK en cours d'execution\n");
	}
	if (status & JackNameNotUnique) {
		nom_client = jack_get_client_name(client);
		fprintf (stderr, "nom unique `%s' pris\n", nom_client);
	}

	/* On appelle le processus définit plus haut tant qu'il y a des choses a faire
	*/

	jack_set_process_callback (client, process, 0);

	/* On dit au serveur JACK d'appeler la fonction jack_shutdown si on en a besoin
	*/

	jack_on_shutdown (client, jack_shutdown, 0);

	/* On affiche le taux d echantillonnage courant.
	 */

	printf ("taux d echantillonnage : %" PRIu32 "\n",
		jack_get_sample_rate (client));

	/* on fait deux ports en utilisant les valeurs par défaut */

	port_recepteur = jack_port_register (client, "input",
					 JACK_DEFAULT_AUDIO_TYPE,
					 JackPortIsInput, 0);
	port_emetteur = jack_port_register (client, "output",
					  JACK_DEFAULT_AUDIO_TYPE,
					  JackPortIsOutput, 0);

	if ((port_recepteur == NULL) || (port_emetteur == NULL)) {
		fprintf(stderr, "plus de ports JACK disponibles\n");
		exit (1);
	}

	/* On est pret pour activer JACK ! Tout en faisant attention aux eventuelles erreurs */

	if (jack_activate (client)) {
		fprintf (stderr, "impossible d activer JACK");
		exit (1);
	}
	/* on connecte les ports
	 */

	ports = jack_get_ports (client, NULL, NULL,
				JackPortIsPhysical|JackPortIsOutput);
	if (ports == NULL) {
		fprintf(stderr, "pas de port disponible\n");
		exit (1);
	}

	if (jack_connect (client, ports[0], jack_port_name (port_recepteur))) {
		fprintf (stderr, "pas de port disponible\n");
	}

	free (ports);
	
	ports = jack_get_ports (client, NULL, NULL,
				JackPortIsPhysical|JackPortIsInput);
	if (ports == NULL) {
		fprintf(stderr, "pas de port disponible\n");
		exit (1);
	}

	if (jack_connect (client, jack_port_name (port_emetteur), ports[0])) {
		fprintf (stderr, "pas de port disponible\n");
	}

	free (ports);
	/* on continue à tourner tant qu'il n'y a pas de contrordre */

	sleep (-1);

	/* Il est important de fermer le client.
	*/

	jack_client_close (client);
	exit (0);
}
[/CODE]