| /* gnu_javax_sound_midi_dssi_DSSISynthesizer.c - DSSI Synth |
| Copyright (C) 2005 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath 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, or (at your option) |
| any later version. |
| |
| GNU Classpath 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 GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| /* The original get_port_default() and set_control() routines were |
| * copied from the DSSI source distribution and are covered by the |
| * following copyright and license... |
| * |
| * Copyright 2004 Chris Cannam, Steve Harris and Sean Bolton. |
| * |
| * Permission to use, copy, modify, distribute, and sell this software |
| * for any purpose is hereby granted without fee, provided that the |
| * above copyright notice and this permission notice are included in |
| * all copies or substantial portions of the software. |
| */ |
| |
| #include <config.h> |
| #include <gnu_javax_sound_midi_dssi_DSSISynthesizer.h> |
| #include <math.h> |
| |
| #include "dssi_data.h" |
| |
| /* Define this for debug output. */ |
| #undef DEBUG_DSSI_PROVIDER |
| |
| static void set_control (dssi_data *data, snd_seq_event_t *event); |
| |
| |
| /** |
| * The jack callback routine. |
| * |
| * This function is called by the jack audio system in its own thread |
| * whenever it needs new audio data. |
| * |
| */ |
| static int |
| process (jack_nframes_t nframes, void *arg) |
| { |
| dssi_data *data = (dssi_data *) arg; |
| int index; |
| jack_default_audio_sample_t *buffer; |
| |
| /* Look through the event buffer to see if any control values |
| need changing. */ |
| for ( index = data->midiEventReadIndex; |
| index != data->midiEventWriteIndex; |
| index = (index + 1) % EVENT_BUFFER_SIZE) |
| { |
| if (data->midiEventBuffer[index].type == SND_SEQ_EVENT_CONTROLLER) |
| set_control (data, & data->midiEventBuffer[index]); |
| } |
| |
| if (data->desc->run_synth) |
| { |
| /* Call the synth audio processing routine. */ |
| data->desc->run_synth |
| (data->plugin_handle, |
| nframes, |
| &data->midiEventBuffer[data->midiEventReadIndex], |
| data->midiEventWriteIndex - data->midiEventReadIndex); |
| } |
| else |
| if (data->desc->run_multiple_synths) |
| { |
| snd_seq_event_t *events = |
| &data->midiEventBuffer[data->midiEventReadIndex]; |
| unsigned long event_count = |
| data->midiEventWriteIndex - data->midiEventReadIndex; |
| |
| /* Call the synth audio processing routine. */ |
| data->desc->run_multiple_synths |
| (1, |
| & (data->plugin_handle), |
| nframes, |
| &events, |
| &event_count); |
| } |
| |
| /* Update the read index on our circular buffer. */ |
| data->midiEventReadIndex = data->midiEventWriteIndex; |
| |
| /* Copy output from the synth to jack. |
| |
| FIXME: This is hack that only gets one channel from the synth and |
| send that to both jack ports (until we handle stero synths |
| properly). |
| |
| FIXME: Can we avoid this copying? */ |
| buffer = jack_port_get_buffer(data->jack_left_output_port, nframes); |
| memcpy (buffer, data->left_buffer, nframes * sizeof(LADSPA_Data)); |
| buffer = jack_port_get_buffer(data->jack_right_output_port, nframes); |
| memcpy (buffer, data->left_buffer, nframes * sizeof(LADSPA_Data)); |
| |
| return 0; |
| } |
| |
| |
| /** |
| * Calculate a reasonable default value for a specific control port. |
| * This is mostly copied from the DSSI example code. Copyright info |
| * is found at the top of this file. |
| * |
| */ |
| static LADSPA_Data |
| get_port_default (const LADSPA_Descriptor *plugin, |
| int port, jack_nframes_t sample_rate) |
| { |
| LADSPA_PortRangeHint hint = plugin->PortRangeHints[port]; |
| float lower = hint.LowerBound * |
| (LADSPA_IS_HINT_SAMPLE_RATE(hint.HintDescriptor) ? sample_rate : 1.0f); |
| float upper = hint.UpperBound * |
| (LADSPA_IS_HINT_SAMPLE_RATE(hint.HintDescriptor) ? sample_rate : 1.0f); |
| |
| if (!LADSPA_IS_HINT_HAS_DEFAULT(hint.HintDescriptor)) |
| { |
| if (!LADSPA_IS_HINT_BOUNDED_BELOW(hint.HintDescriptor) || |
| !LADSPA_IS_HINT_BOUNDED_ABOVE(hint.HintDescriptor)) |
| { |
| /* No hint, its not bounded, wild guess */ |
| return 0.0f; |
| } |
| |
| if (lower <= 0.0f && upper >= 0.0f) |
| { |
| /* It spans 0.0, 0.0 is often a good guess */ |
| return 0.0f; |
| } |
| |
| /* No clues, return minimum */ |
| return lower; |
| } |
| |
| /* Try all the easy ones */ |
| |
| if (LADSPA_IS_HINT_DEFAULT_0(hint.HintDescriptor)) |
| return 0.0f; |
| else if (LADSPA_IS_HINT_DEFAULT_1(hint.HintDescriptor)) |
| return 1.0f; |
| else if (LADSPA_IS_HINT_DEFAULT_100(hint.HintDescriptor)) |
| return 100.0f; |
| else if (LADSPA_IS_HINT_DEFAULT_440(hint.HintDescriptor)) |
| return 440.0f; |
| |
| /* All the others require some bounds */ |
| |
| if (LADSPA_IS_HINT_BOUNDED_BELOW(hint.HintDescriptor) |
| && (LADSPA_IS_HINT_DEFAULT_MINIMUM(hint.HintDescriptor))) |
| return lower; |
| |
| if (LADSPA_IS_HINT_BOUNDED_ABOVE(hint.HintDescriptor)) |
| { |
| if (LADSPA_IS_HINT_DEFAULT_MAXIMUM(hint.HintDescriptor)) |
| return upper; |
| |
| if (LADSPA_IS_HINT_BOUNDED_BELOW(hint.HintDescriptor)) |
| { |
| if (LADSPA_IS_HINT_DEFAULT_LOW(hint.HintDescriptor)) |
| return lower * 0.75f + upper * 0.25f; |
| else if (LADSPA_IS_HINT_DEFAULT_MIDDLE(hint.HintDescriptor)) |
| return lower * 0.5f + upper * 0.5f; |
| else if (LADSPA_IS_HINT_DEFAULT_HIGH(hint.HintDescriptor)) |
| return lower * 0.25f + upper * 0.75f; |
| } |
| } |
| |
| /* fallback */ |
| return 0.0f; |
| } |
| |
| /** |
| * Set a control value by mapping the MIDI event to a suitable value |
| * for this control. |
| * This is mostly copied from the DSSI example code. Copyright info |
| * is found at the top of this file. |
| * |
| */ |
| static void |
| set_control(dssi_data *data, snd_seq_event_t *event) |
| { |
| unsigned control = event->data.control.param; |
| unsigned port = data->control_port_map[control]; |
| |
| const LADSPA_Descriptor *p = data->desc->LADSPA_Plugin; |
| |
| LADSPA_PortRangeHintDescriptor d = p->PortRangeHints[port].HintDescriptor; |
| |
| LADSPA_Data lb = p->PortRangeHints[port].LowerBound * |
| (LADSPA_IS_HINT_SAMPLE_RATE(p->PortRangeHints[port].HintDescriptor) ? |
| data->sample_rate : 1.0f); |
| |
| LADSPA_Data ub = p->PortRangeHints[port].UpperBound * |
| (LADSPA_IS_HINT_SAMPLE_RATE(p->PortRangeHints[port].HintDescriptor) ? |
| data->sample_rate : 1.0f); |
| |
| float value = (float)event->data.control.value; |
| |
| if (!LADSPA_IS_HINT_BOUNDED_BELOW(d)) |
| { |
| if (!LADSPA_IS_HINT_BOUNDED_ABOVE(d)) |
| { |
| /* unbounded: might as well leave the value alone. */ |
| } |
| else |
| { |
| /* bounded above only. just shift the range. */ |
| value = ub - 127.0f + value; |
| } |
| } |
| else |
| { |
| if (!LADSPA_IS_HINT_BOUNDED_ABOVE(d)) |
| { |
| /* bounded below only. just shift the range. */ |
| value = lb + value; |
| } |
| else |
| { |
| /* bounded both ends. more interesting. */ |
| if (LADSPA_IS_HINT_LOGARITHMIC(d)) |
| { |
| const float llb = logf(lb); |
| const float lub = logf(ub); |
| |
| value = expf(llb + ((lub - llb) * value / 127.0f)); |
| } |
| else |
| { |
| value = lb + ((ub - lb) * value / 127.0f); |
| } |
| } |
| } |
| |
| #ifdef DEBUG_DSSI_PROVIDER |
| printf("MIDI controller %d=%d -> control in %u=%f\n", |
| event->data.control.param, |
| event->data.control.value, |
| data->control_value_map[control], value); |
| #endif |
| |
| data->control_values[data->control_value_map[control]] = value; |
| } |
| |
| /** |
| * Open a new synthesizer. This currently involves instantiating a |
| * new synth, creating a new jack client connection, and activating |
| * both. |
| * |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_javax_sound_midi_dssi_DSSISynthesizer_open_1 |
| (JNIEnv *env, jclass clazz __attribute__((unused)), jlong handle) |
| { |
| unsigned int port_count, j, cindex; |
| const char **ports; |
| int controller = 0; |
| dssi_data *data = (dssi_data *) (long) handle; |
| if ((data->jack_client = jack_client_new (data->desc->LADSPA_Plugin->Label)) == 0) |
| { |
| /* JCL_ThrowException (env, "javax/sound/midi/MidiUnavailableException", */ |
| JCL_ThrowException (env, "java/io/IOException", |
| "can't create jack client"); |
| return; |
| } |
| |
| /* Get the jack sample rate, which may be used in default control port |
| value calculations. */ |
| data->sample_rate = jack_get_sample_rate (data->jack_client); |
| |
| data->plugin_handle = |
| (data->desc->LADSPA_Plugin->instantiate)(data->desc->LADSPA_Plugin, |
| data->sample_rate); |
| |
| if (jack_set_process_callback (data->jack_client, process, data) != 0) |
| { |
| JCL_ThrowException (env, "java/io/IOException", |
| "can't set jack process callback"); |
| return; |
| } |
| |
| data->jack_left_output_port = |
| jack_port_register (data->jack_client, "output_left", |
| JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0); |
| data->jack_right_output_port = |
| jack_port_register (data->jack_client, "output_right", |
| JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0); |
| |
| /* Count the number of controls and audio ouput ports. */ |
| port_count = data->control_count = 0; |
| for (j = 0; j < data->desc->LADSPA_Plugin->PortCount; j++) |
| { |
| LADSPA_PortDescriptor pod = |
| data->desc->LADSPA_Plugin->PortDescriptors[j]; |
| |
| if (LADSPA_IS_PORT_AUDIO(pod) && LADSPA_IS_PORT_OUTPUT(pod)) |
| port_count++; |
| else if (LADSPA_IS_PORT_CONTROL(pod) && LADSPA_IS_PORT_INPUT(pod)) |
| data->control_count++; |
| } |
| |
| /* Allocate the array of control values. */ |
| data->control_values = |
| (LADSPA_Data *) JCL_malloc (env, |
| data->control_count * sizeof (LADSPA_Data)); |
| |
| /* Initialize the MIDI control map. */ |
| memset (data->control_value_map, 0, data->control_count * sizeof(unsigned)); |
| |
| /* Create buffers for each port. */ |
| for (cindex = 0, j = 0; j < data->desc->LADSPA_Plugin->PortCount; j++) |
| { |
| LADSPA_PortDescriptor pod = |
| data->desc->LADSPA_Plugin->PortDescriptors[j]; |
| if (LADSPA_IS_PORT_AUDIO(pod) && LADSPA_IS_PORT_OUTPUT(pod)) |
| { |
| data->left_buffer = |
| (float *) calloc(jack_get_buffer_size(data->jack_client), |
| sizeof(float)); |
| (data->desc->LADSPA_Plugin->connect_port)(data->plugin_handle, j, |
| data->left_buffer); |
| } |
| else |
| if (LADSPA_IS_PORT_CONTROL(pod) && LADSPA_IS_PORT_INPUT(pod)) |
| { |
| /* This is an input control port. Connect it to a properly |
| initialized value in our controller value array. */ |
| (data->desc->LADSPA_Plugin->connect_port) |
| (data->plugin_handle, j, &(data->control_values[cindex])); |
| data->control_values[cindex] = |
| get_port_default (data->desc->LADSPA_Plugin, |
| j, data->sample_rate); |
| |
| /* Set up the mapping between MIDI controllers and this |
| contoller value. */ |
| if (data->desc->get_midi_controller_for_port) |
| { |
| controller = data->desc-> |
| get_midi_controller_for_port(data->plugin_handle, j); |
| |
| if ((controller != DSSI_NONE) && DSSI_IS_CC(controller)) |
| { |
| data->control_value_map[DSSI_CC_NUMBER(controller)] = cindex; |
| data->control_port_map[DSSI_CC_NUMBER(controller)] = j; |
| |
| #ifdef DEBUG_DSSI_PROVIDER |
| printf ("MIDI Controller 0x%x [%s] = %g\n", |
| DSSI_CC_NUMBER(controller), |
| data->desc->LADSPA_Plugin->PortNames[j], |
| data->control_values[cindex]); |
| #endif |
| } |
| } |
| |
| cindex++; |
| } |
| } |
| |
| (data->desc->LADSPA_Plugin->activate)(data->plugin_handle); |
| |
| if (jack_activate (data->jack_client)) |
| JCL_ThrowException (env, "java/io/IOException", |
| "can't activate jack client"); |
| |
| /* Try to connect the synth output to hardware audio ports. */ |
| ports = jack_get_ports (data->jack_client, NULL, NULL, |
| JackPortIsPhysical | JackPortIsInput); |
| if (ports) |
| { |
| if (ports[0] && ports[1]) |
| { |
| /* Don't bother checking return values. Failing is OK. */ |
| jack_connect (data->jack_client, |
| jack_port_name (data->jack_left_output_port), |
| ports[0]); |
| jack_connect (data->jack_client, |
| jack_port_name (data->jack_right_output_port), |
| ports[1]); |
| } |
| free(ports); |
| } |
| } |
| |
| /** |
| * This is called when we receive a new MIDI CONTROL CHANGE message. |
| * Simply stick an appropriate event in the event buffer. This will |
| * get processed in the jack callback function. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_javax_sound_midi_dssi_DSSISynthesizer_controlChange_1 |
| (JNIEnv *env __attribute__((unused)), jclass clazz __attribute__((unused)), |
| jlong handle, jint channel, jint control, jint value) |
| { |
| dssi_data *data = JLONG_TO_PTR(dssi_data,handle); |
| |
| /* Insert this event in the event buffer. */ |
| snd_seq_event_t *ev = & data->midiEventBuffer[data->midiEventWriteIndex]; |
| |
| /* Set the event value. */ |
| snd_seq_ev_set_controller (ev, channel, control, value); |
| |
| data->midiEventWriteIndex = |
| (data->midiEventWriteIndex + 1) % EVENT_BUFFER_SIZE; |
| } |
| |
| /** |
| * This is called when we receive a new MIDI NOTE ON message. Simply |
| * stick an appropriate event in the event buffer. This will get |
| * processed in the jack callback function. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_javax_sound_midi_dssi_DSSISynthesizer_noteOn_1 |
| (JNIEnv *env __attribute__((unused)), jclass clazz __attribute__((unused)), |
| jlong handle, jint channel, jint note, jint velocity) |
| { |
| dssi_data *data = JLONG_TO_PTR(dssi_data,handle); |
| |
| /* Insert this event in the event buffer. */ |
| snd_seq_event_t *ev = & data->midiEventBuffer[data->midiEventWriteIndex]; |
| |
| ev->type = SND_SEQ_EVENT_NOTEON; |
| ev->data.control.channel = channel; |
| ev->data.note.note = note; |
| ev->data.note.velocity = velocity; |
| |
| data->midiEventWriteIndex = |
| (data->midiEventWriteIndex + 1) % EVENT_BUFFER_SIZE; |
| } |
| |
| /** |
| * This is called when we receive a new MIDI NOTE OFF message. Simply |
| * stick an appropriate event in the event buffer. This will get |
| * processed in the jack callback function. |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_javax_sound_midi_dssi_DSSISynthesizer_noteOff_1 |
| (JNIEnv *env __attribute__((unused)), |
| jclass clazz __attribute__((unused)), |
| jlong handle, jint channel, jint note, jint velocity) |
| { |
| dssi_data *data = JLONG_TO_PTR(dssi_data,handle); |
| |
| /* Insert this event in the event buffer. */ |
| snd_seq_event_t *ev = & data->midiEventBuffer[data->midiEventWriteIndex]; |
| |
| ev->type = SND_SEQ_EVENT_NOTEOFF; |
| ev->data.control.channel = channel; |
| ev->data.note.note = note; |
| ev->data.note.velocity = velocity; |
| |
| data->midiEventWriteIndex = |
| (data->midiEventWriteIndex + 1) % EVENT_BUFFER_SIZE; |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gnu_javax_sound_midi_dssi_DSSISynthesizer_setPolyPressure_1 |
| (JNIEnv *env __attribute__((unused)), jclass clazz __attribute__((unused)), |
| jlong handle __attribute__((unused)), jint channel __attribute__((unused)), |
| jint note __attribute__((unused)), jint velocity __attribute__((unused))) |
| { |
| } |
| |
| JNIEXPORT jint JNICALL |
| Java_gnu_javax_sound_midi_dssi_DSSISynthesizer_getPolyPressure_1 |
| (JNIEnv *env __attribute__((unused)), jclass clazz __attribute__((unused)), |
| jlong handle __attribute__((unused)), jint channel __attribute__((unused)), |
| jint note __attribute__((unused))) |
| { |
| return 0; |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_gnu_javax_sound_midi_dssi_DSSISynthesizer_close_1 |
| (JNIEnv *env __attribute__((unused)), jclass clazz __attribute__((unused)), |
| jlong handle __attribute__((unused))) |
| { |
| } |
| |
| /* FIXME: These next three functions are really inefficient because |
| we're instantiating and cleaning up plugin instances just to query |
| values. */ |
| |
| JNIEXPORT jstring JNICALL |
| Java_gnu_javax_sound_midi_dssi_DSSISynthesizer_getProgramName_1 |
| (JNIEnv *env, jclass clazz __attribute__((unused)), |
| jlong handle, jint index) |
| { |
| LADSPA_Handle lhandle; |
| jstring name = (jstring) NULL; |
| dssi_data *data = JLONG_TO_PTR(dssi_data, handle); |
| if (data->desc->get_program == NULL) |
| return NULL; |
| lhandle = |
| (data->desc->LADSPA_Plugin->instantiate)(data->desc->LADSPA_Plugin, |
| 48000); |
| const DSSI_Program_Descriptor *program = |
| (data->desc->get_program)(lhandle, (unsigned long) index); |
| if (program) |
| name = (*env)->NewStringUTF (env, program->Name); |
| (data->desc->LADSPA_Plugin->cleanup)(lhandle); |
| |
| return name; |
| } |
| |
| JNIEXPORT jint JNICALL |
| Java_gnu_javax_sound_midi_dssi_DSSISynthesizer_getProgramBank_1 |
| (JNIEnv *env __attribute__((unused)), jclass clazz __attribute__((unused)), |
| jlong handle, jint index) |
| { |
| LADSPA_Handle lhandle; |
| jint result = -1; |
| dssi_data *data = JLONG_TO_PTR(dssi_data, handle); |
| lhandle = |
| (data->desc->LADSPA_Plugin->instantiate)(data->desc->LADSPA_Plugin, |
| 48000); |
| const DSSI_Program_Descriptor *program = |
| (data->desc->get_program)(lhandle, (unsigned long) index); |
| if (program) |
| result = (jint) program->Bank; |
| (data->desc->LADSPA_Plugin->cleanup)(lhandle); |
| return result; |
| } |
| |
| JNIEXPORT jint JNICALL |
| Java_gnu_javax_sound_midi_dssi_DSSISynthesizer_getProgramProgram_1 |
| (JNIEnv *env __attribute__((unused)), jclass clazz __attribute__((unused)), |
| jlong handle, jint index) |
| { |
| LADSPA_Handle lhandle; |
| jint result = -1; |
| dssi_data *data = JLONG_TO_PTR(dssi_data, handle); |
| lhandle = |
| (data->desc->LADSPA_Plugin->instantiate)(data->desc->LADSPA_Plugin, |
| 48000); |
| const DSSI_Program_Descriptor *program = |
| (data->desc->get_program)(lhandle, (unsigned long) index); |
| if (program) |
| result = (jint) program->Program; |
| (data->desc->LADSPA_Plugin->cleanup)(lhandle); |
| return result; |
| } |
| |
| |
| JNIEXPORT void JNICALL |
| Java_gnu_javax_sound_midi_dssi_DSSISynthesizer_selectProgram_1 |
| (JNIEnv *env __attribute__((unused)), jclass clazz __attribute__((unused)), |
| jlong handle, jint bank, jint program) |
| { |
| dssi_data *data = JLONG_TO_PTR(dssi_data, handle); |
| |
| (data->desc->select_program)(data->plugin_handle, |
| (unsigned) bank, (unsigned) program); |
| } |