Subversion Repositories openrisc

/* 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);

}