WalkThrough_Dev_SimpleMidiClient

PipeManMusic edited this page Apr 27, 2013 · 3 revisions

Taking JACK MIDI input and outputting sound is demonstrated by https://github.com/jackaudio/example-clients/blob/master/midisine.c

midisine.c

/*
    Copyright (C) 2004 Ian Esten

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#include <jack/jack.h>
#include <jack/midiport.h>

jack_port_t *input_port;
jack_port_t *output_port;
jack_default_audio_sample_t ramp=0.0;
jack_default_audio_sample_t note_on;
unsigned char note = 0;
jack_default_audio_sample_t note_frqs[128];

void calc_note_frqs(jack_default_audio_sample_t srate)
{
    int i;
    for(i=0; i<128; i++)
    {
        note_frqs[i] = (2.0 * 440.0 / 32.0) * pow(2, (((jack_default_audio_sample_t)i - 9.0) / 12.0)) / srate;
    }
}

int process(jack_nframes_t nframes, void *arg)
{
    int i;
    void* port_buf = jack_port_get_buffer(input_port, nframes);
    jack_default_audio_sample_t *out = (jack_default_audio_sample_t *) jack_port_get_buffer (output_port, nframes);
    jack_midi_event_t in_event;
    jack_nframes_t event_index = 0;
    jack_nframes_t event_count = jack_midi_get_event_count(port_buf);
    if(event_count > 1)
    {
        printf(" midisine: have %d events\n", event_count);
        for(i=0; i<event_count; i++)
        {
            jack_midi_event_get(&in_event, port_buf, i);
            printf("    event %d time is %d. 1st byte is 0x%x\n", i, in_event.time, *(in_event.buffer));
        }
/*      printf("1st byte of 1st event addr is %p\n", in_events[0].buffer);*/
    }
    jack_midi_event_get(&in_event, port_buf, 0);
    for(i=0; i<nframes; i++)
    {
        if((in_event.time == i) && (event_index < event_count))
        {
            if( ((*(in_event.buffer) & 0xf0)) == 0x90 )
            {
                /* note on */
                note = *(in_event.buffer + 1);
                note_on = 1.0;
            }
            else if( ((*(in_event.buffer)) & 0xf0) == 0x80 )
            {
                /* note off */
                note = *(in_event.buffer + 1);
                note_on = 0.0;
            }
            event_index++;
            if(event_index < event_count)
                jack_midi_event_get(&in_event, port_buf, event_index);
        }
        ramp += note_frqs[note];
        ramp = (ramp > 1.0) ? ramp - 2.0 : ramp;
        out[i] = note_on*sin(2*M_PI*ramp);
    }
    return 0;      
}

int srate(jack_nframes_t nframes, void *arg)
{
    printf("the sample rate is now %" PRIu32 "/sec\n", nframes);
    calc_note_frqs((jack_default_audio_sample_t)nframes);
    return 0;
}

void jack_shutdown(void *arg)
{
    exit(1);
}

int main(int narg, char **args)
{
    jack_client_t *client;

    if ((client = jack_client_open ("midi_test", JackNullOption, NULL)) == 0)
    {
        fprintf(stderr, "jack server not running?\n");
        return 1;
    }

    calc_note_frqs(jack_get_sample_rate (client));

    jack_set_process_callback (client, process, 0);

    jack_set_sample_rate_callback (client, srate, 0);

    jack_on_shutdown (client, jack_shutdown, 0);

    input_port = jack_port_register (client, "midi_in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
    output_port = jack_port_register (client, "audio_out", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);

    if (jack_activate (client))
    {
        fprintf(stderr, "cannot activate client");
        return 1;
    }

    /* run until interrupted */
    while(1)
    {
        sleep(1);
    }
    jack_client_close(client);
    exit (0);
}

Producing JACK MIDI output is demonstrated by https://github.com/jackaudio/example-clients/blob/master/midiseq.c

midiseq.c

/*
    Copyright (C) 2004 Ian Esten

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include <jack/jack.h>
#include <jack/midiport.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

jack_client_t *client;
jack_port_t *output_port;

unsigned char* note_frqs;
jack_nframes_t* note_starts;
jack_nframes_t* note_lengths;
jack_nframes_t num_notes;
jack_nframes_t loop_nsamp;
jack_nframes_t loop_index;

void usage()
{
    fprintf(stderr, "usage: jack_midiseq name nsamp [startindex note nsamp] ...... [startindex note nsamp]\n");
    fprintf(stderr, "eg: jack_midiseq Sequencer 24000 0 60 8000 12000 63 8000\n");
    fprintf(stderr, "will play a 1/2 sec loop (if srate is 48khz) with a c4 note at the start of the loop\n");
    fprintf(stderr, "that lasts for 12000 samples, then a d4# that starts at 1/4 sec that lasts for 800 samples\n");
}

int process(jack_nframes_t nframes, void *arg)
{
    int i,j;
    void* port_buf = jack_port_get_buffer(output_port, nframes);
    unsigned char* buffer;
    jack_midi_clear_buffer(port_buf);
    /*memset(buffer, 0, nframes*sizeof(jack_default_audio_sample_t));*/

    for(i=0; i<nframes; i++)
    {
        for(j=0; j<num_notes; j++)
        {
            if(note_starts[j] == loop_index)
            {
                buffer = jack_midi_event_reserve(port_buf, i, 3);
/*              printf("wrote a note on, port buffer 0x%x\n", port_buf, buffer);*/
                buffer[2] = 64;     /* velocity */
                buffer[1] = note_frqs[j];
                buffer[0] = 0x90;   /* note on */
            }
            else if(note_starts[j] + note_lengths[j] == loop_index)
            {
                buffer = jack_midi_event_reserve(port_buf, i, 3);
/*              printf("wrote a note off, port buffer 0x%x\n", port_buf, buffer);*/
                buffer[2] = 64;     /* velocity */
                buffer[1] = note_frqs[j];
                buffer[0] = 0x80;   /* note off */
            }
        }
        loop_index = loop_index+1 >= loop_nsamp ? 0 : loop_index+1;
    }
    return 0;
}

int main(int narg, char **args)
{
    int i;
    jack_nframes_t nframes;
    if((narg<6) || ((narg-3)%3 !=0))
    {
        usage();
        exit(1);
    }
    if((client = 0)
    {
        fprintf (stderr, "jack server not running?\n");
        return 1;
    }
    jack_set_process_callback (client, process, 0);
    output_port = jack_port_register (client, "out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
    nframes = jack_get_buffer_size(client);
    loop_index = 0;
    num_notes = (narg - 3)/3;
    note_frqs = malloc(num_notes*sizeof(unsigned char));
    note_starts = malloc(num_notes*sizeof(unsigned char));
    note_lengths = malloc(num_notes*sizeof(jack_nframes_t));
    loop_nsamp = atoi(args[2]);
    for(i=0; i<num_notes; i++)
    {
        note_starts[i] = atoi(args[3 + 3*i]);
        note_frqs[i] = atoi(args[4 + 3*i]);
        note_lengths[i] = atoi(args[5 + 3*i]);
    }

    if (jack_activate(client))
    {
        fprintf (stderr, "cannot activate client");
        return 1;
    }

    while (1)
    {
        sleep(1);
    };

}