Logo Search packages:      
Sourcecode: nekobee version File versions  Download package

nekobee_synth.c

/* nekobee DSSI software synthesizer plugin
 *
 * Copyright (C) 2004 Sean Bolton and others.
 *
 * Portions of this file may have come from Steve Brookes'
 * nekobee, copyright (C) 1999 S. J. Brookes.
 * Portions of this file may have come from Peter Hanappe's
 * Fluidsynth, copyright (C) 2003 Peter Hanappe and others.
 * Portions of this file may have come from Chris Cannam and Steve
 * Harris's public domain DSSI example code.
 *
 * 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., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307, USA.
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <pthread.h>

#include <ladspa.h>

#include "nekobee.h"
#include "nekobee_synth.h"
#include "nekobee_voice.h"
#include "gui_data.h"

/*
 * nekobee_synth_all_voices_off
 *
 * stop processing all notes immediately
 */
void
nekobee_synth_all_voices_off(nekobee_synth_t *synth)
{
    int i;
    nekobee_voice_t *voice;

    for (i = 0; i < synth->voices; i++) {
        //voice = synth->voice[i];
                    voice = synth->voice;
        if (_PLAYING(voice)) {
            nekobee_voice_off(voice);
        }
    }
    for (i = 0; i < 8; i++) synth->held_keys[i] = -1;
}

/*
 * nekobee_synth_note_off
 *
 * handle a note off message
 */
void
nekobee_synth_note_off(nekobee_synth_t *synth, unsigned char key, unsigned char rvelocity)
{
    int i, count = 0;
    nekobee_voice_t *voice;

    for (i = 0; i < synth->voices; i++) {

            voice = synth->voice;
        if (_PLAYING(voice)) {
            XDB_MESSAGE(XDB_NOTE, " nekobee_synth_note_off: key %d rvel %d voice %d note id %d\n", key, rvelocity, i, voice->note_id);
            nekobee_voice_note_off(synth, voice, key, 64);
            count++;
        }
    }

    if (!count)
        nekobee_voice_remove_held_key(synth, key);
}

/*
 * nekobee_synth_all_notes_off
 *
 * put all notes into the released state
 */
void
nekobee_synth_all_notes_off(nekobee_synth_t* synth)
{
    int i;
    nekobee_voice_t *voice;

    /* reset the sustain controller */
    synth->cc[MIDI_CTL_SUSTAIN] = 0;
    for (i = 0; i < synth->voices; i++) {
        //voice = synth->voice[i];
            voice = synth->voice;
        if (_ON(voice) || _SUSTAINED(voice)) {
            nekobee_voice_release_note(synth, voice);
        }
    }
}

/*
 * nekobee_synth_note_on
 */
void
nekobee_synth_note_on(nekobee_synth_t *synth, unsigned char key, unsigned char velocity)
{
    nekobee_voice_t* voice;


        voice = synth->voice;
        if (_PLAYING(synth->voice)) {
            XDB_MESSAGE(XDB_NOTE, " nekobee_synth_note_on: retriggering mono voice on new key %d\n", key);
        }


    voice->note_id  = synth->note_id++;

    nekobee_voice_note_on(synth, voice, key, velocity);
}




/*
 * nekobee_synth_update_volume
 */
void
nekobee_synth_update_volume(nekobee_synth_t* synth)
{
    synth->cc_volume = (float)(synth->cc[MIDI_CTL_MSB_MAIN_VOLUME] * 128 +
                               synth->cc[MIDI_CTL_LSB_MAIN_VOLUME]) / 16256.0f;
    if (synth->cc_volume > 1.0f)
        synth->cc_volume = 1.0f;
    /* don't need to check if any playing voices need updating, because it's global */
}

/*
 * nekobee_synth_control_change
 */
void
nekobee_synth_control_change(nekobee_synth_t *synth, unsigned int param, signed int value)
{
    synth->cc[param] = value;

    switch (param) {

      case MIDI_CTL_MSB_MAIN_VOLUME:
      case MIDI_CTL_LSB_MAIN_VOLUME:
        nekobee_synth_update_volume(synth);
        break;
      case MIDI_CTL_ALL_SOUNDS_OFF:
        nekobee_synth_all_voices_off(synth);
        break;

      case MIDI_CTL_RESET_CONTROLLERS:
        nekobee_synth_init_controls(synth);
        break;

      case MIDI_CTL_ALL_NOTES_OFF:
        nekobee_synth_all_notes_off(synth);
        break;

      /* what others should we respond to? */

      /* these we ignore (let the host handle):
       *  BANK_SELECT_MSB
       *  BANK_SELECT_LSB
       *  DATA_ENTRY_MSB
       *  NRPN_MSB
       *  NRPN_LSB
       *  RPN_MSB
       *  RPN_LSB
       * -FIX- no! we need RPN (0, 0) Pitch Bend Sensitivity!
       */
    }
}

/*
 * nekobee_synth_init_controls
 */
void
nekobee_synth_init_controls(nekobee_synth_t *synth)
{
    int i;

    synth->current_program = -1;
    for (i = 0; i < 128; i++) {
        synth->cc[i] = 0;
    }

    synth->cc[7] = 127;                  /* full volume */
    nekobee_synth_update_volume(synth);
}

/*
 * nekobee_synth_select_program
 */
void
nekobee_synth_select_program(nekobee_synth_t *synth, unsigned long bank,
                            unsigned long program)
{
    if (bank || program >= 128) return;
    synth->current_program = program;
    nekobee_voice_set_ports(synth, &synth->patches[program]);
}

/*
 * nekobee_data_friendly_patches
 *
 * give the new user a default set of good patches to get started with
 */
void
nekobee_data_friendly_patches(nekobee_synth_t *synth)
{
    pthread_mutex_lock(&synth->patches_mutex);
        memcpy(&synth->patches[0], &nekobee_init_voice, sizeof(nekobee_patch_t));
synth->vcf_accent=0;
    pthread_mutex_unlock(&synth->patches_mutex);
}

/*
 * nekobee_synth_set_program_descriptor
 */
int
nekobee_synth_set_program_descriptor(nekobee_synth_t *synth,
                                    DSSI_Program_Descriptor *pd,
                                    unsigned long bank, unsigned long program)
{
    if (bank || program >= 128) {
        return 0;
    }
    pd->Bank = 0;
    pd->Program = 0;
    pd->Name = "none"; // needs some kind of name in the descriptor
    return 1;

}

/*
 * nekobee_synth_render_voices
 */
void
nekobee_synth_render_voices(nekobee_synth_t *synth, LADSPA_Data *out, unsigned long sample_count,
                        int do_control_update)
{
    unsigned long i;
      float res,wow;

    /* clear the buffer */
    for (i = 0; i < sample_count; i++)
        out[i] = 0.0f;

      // we can do anything that must be updated all the time here
      // this is called even when a voice isn't playing

      // approximate a log scale
      res = 1-*(synth->resonance);
      wow = res*res;
      wow = wow/10.0f;  
      
      // as the resonance is increased, "wow" slows down the accent attack
      if ((synth->voice->velocity>90) && (synth->vcf_accent < synth->voice->vcf_eg)) {
      synth->vcf_accent=(0.985-wow)*synth->vcf_accent+(0.015+wow)*synth->voice->vcf_eg;
      } else {
      synth->vcf_accent=(0.985-wow)*synth->vcf_accent;      // or just decay
      }

    if (synth->voice->velocity>90) {
      synth->vca_accent=0.95*synth->vca_accent+0.05 ; // ramp up accent on with a time constant
      } else {
      synth->vca_accent=0.95*synth->vca_accent;             // accent off with time constant
      }
#if defined(XSYNTH_DEBUG) && (XSYNTH_DEBUG & XDB_AUDIO)
out[0] += 0.10f; /* add a 'buzz' to output so there's something audible even when quiescent */
#endif /* defined(XSYNTH_DEBUG) && (XSYNTH_DEBUG & XDB_AUDIO) */
if (_PLAYING(synth->voice)) {
      nekobee_voice_render(synth, synth->voice, out, sample_count, do_control_update);
}
}

Generated by  Doxygen 1.6.0   Back to index