// This programme captures audio from 8 sources then mixes and plays them back out.
// It is intended to demonstrate using JACK and FFADO with a Focusrite Saffire Pro 10 I/O
//
// It is compiled using the following command
// gcc -Wall -ljack -lpthread -lrt -o inOut inOut.c
//
// A.Greensted
// September 2010


#define _GNU_SOURCE	// Declare this as GNU source so the prototype for asprintf is defined
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <unistd.h>
#include <jack/jack.h>

#define NUM_INPUT_PORTS 8	// Number of capture ports to connect to

int allConnected;												// Flag specifying all inputs and outputs are connected
jack_port_t **inputPortArray;								// Array of pointers to input ports
jack_port_t *outputPort;									// Pointer to output port
jack_default_audio_sample_t **inputBufferArray;		// Array of pointers to input buffers


// This is called by the JACK server in a
// special realtime thread once for each audio cycle.
int jackProcess(jack_nframes_t nframes, void *arg)
{
	int portNum;
	jack_nframes_t frameNum;
	jack_default_audio_sample_t *outputBuffer;

	// Only proceed if all ports have been connected
	if (allConnected == 0) return 0;

	// Get pointers to the capture port buffers
	for (portNum=0 ; portNum<NUM_INPUT_PORTS ; portNum++)
	{
		inputBufferArray[portNum] = jack_port_get_buffer(inputPortArray[portNum], nframes);
	}

	// Get the output buffer
	outputBuffer = jack_port_get_buffer(outputPort, nframes);

	// Iterate through input buffers, mixing samples, then writing
	// to the output buffer
	for (frameNum=0; frameNum<nframes; frameNum++)
	{
		float val = 0;

		for (portNum=0; portNum<NUM_INPUT_PORTS; portNum++) {
			val += inputBufferArray[portNum][frameNum];
		}

		outputBuffer[frameNum] = val / NUM_INPUT_PORTS;
	}

	return 0;
}

// JACK calls this shutdown callback if the server ever shuts down
// or decides to disconnect the client
void jackShutdown(void *arg)
{
	printf("Jack shutdown\n");
	exit(1);
}


int main(void)
{
	printf("Input Output Test\nUse ctrl-c to exit\n\n");

	int portNum;
	jack_status_t status;

	// Initialise connected flag to signal that the input ports and output
	// are yet to be registered and connected
	allConnected = 0;

	// Open a client connection to the JACK server
	// The provided server name is null so the default server is selected
	jack_client_t *client = jack_client_open("InOutTest", JackNullOption, &status, NULL);

	// Make sure the client was opened
	if (client == NULL) {
		fprintf(stderr, "jack_client_open() failed, status = 0x%2.0x\n", status);
		if (status & JackServerFailed) fprintf(stderr, "Unable to connect to JACK server\n");
		exit (1);
	}

	// Tell the JACK server to call jackProcess when there is work to be done
	jack_set_process_callback(client, jackProcess, 0);

	// Tell the JACK server to call jackShutdown if it ever shuts down
	jack_on_shutdown(client, jackShutdown, 0);

	// Create an array of audio sample pointers
	// Each pointer points to the start of an audio buffer, one for each capture channel
	inputBufferArray = (jack_default_audio_sample_t**) malloc(NUM_INPUT_PORTS * sizeof(jack_default_audio_sample_t*));

	// Create an array of input ports
	inputPortArray = (jack_port_t**) malloc(NUM_INPUT_PORTS * sizeof(jack_port_t*));

	// Register each input port
	for (portNum=0 ; portNum<NUM_INPUT_PORTS ; portNum ++)
	{
		// Create port name
		char* portName;
		if (asprintf(&portName, "input%d", portNum) < 0) {
			fprintf(stderr, "Could not create portname for port %d", portNum);
			exit(1);
		}

		// Register the capture port
		inputPortArray[portNum] = jack_port_register(client, portName, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
		if (inputPortArray[portNum] == NULL) {
			fprintf(stderr, "Could not create input port %d\n", portNum);
			exit(1);
		}
	}

	// Register the output port
	outputPort = jack_port_register(client, "output", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
	if (outputPort == NULL) {
		fprintf(stderr, "Could not create output port\n");
		exit(1);
	}

	// Tell the JACK server that we are ready. The jackProcess callback will now start running
	if (jack_activate(client)) {
		fprintf(stderr, "Could not activate client");
		exit(1);
	}

	// Get a list of capture ports
	const char **ports = jack_get_ports(client, "system:capture", NULL, JackPortIsPhysical|JackPortIsOutput);
	if (ports == NULL) {
		fprintf(stderr, "No physical capture ports\n");
		exit(1);
	}

	// List the found capture ports
	printf("Found capture ports:\n");
	for (portNum=0 ; ports[portNum]!=NULL ; portNum++) printf(" '%s'\n", ports[portNum]);

	// Connect the capture ports to the input ports
	for (portNum=0 ; portNum<NUM_INPUT_PORTS ; portNum ++)
	{
		if (ports[portNum] == NULL) {
			fprintf(stderr, "Not enough capture ports. Port num %d not found\n", portNum);
			exit(1);
		}

		if (jack_connect(client, ports[portNum], jack_port_name(inputPortArray[portNum]))) {
			fprintf(stderr, "Cannot connect input port\n");
			exit(1);
		}
	}

	// Free memory used for port names
	free(ports);

	// Get a list of ALSA playback ports
	ports = jack_get_ports(client, "alsa_out:playback", NULL, JackPortIsInput);
	if (ports == NULL) {
		fprintf(stderr, "No ALSA playback ports\n");
		exit (1);
	}

	// List the found playback ports
	printf("Found playback ports:\n");
	for (portNum=0 ; ports[portNum]!=NULL ; portNum++) printf(" '%s'\n", ports[portNum]);

	// Connect the playback port to the output port
	if (jack_connect(client, jack_port_name(outputPort), ports[0])) {
		fprintf(stderr, "cannot connect output port\n");
	}

	// Free memory used for port names
	free(ports);

	// Flag that all ports are now connected
	allConnected = 1;

	// Sleep and allow streaming from input to output via jackProcess callback
	sleep(-1);

	// Clean up
	// Note that these wont actually get called when the client
	// is stopped using ctrl-c
	jack_client_close(client);
	free(inputBufferArray);
	free(inputPortArray);

	return 0;
}