Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

/*

 *  Midi synth routines for the Emu8k/Emu10k1

 *

 *  Copyright (C) 1999 Steve Ratcliffe

 *  Copyright (c) 1999-2000 Takashi Iwai <tiwai@suse.de>

 *

 *  Contains code based on awe_wave.c by Takashi Iwai

 *

 *   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 "emux_voice.h"

#include <sound/asoundef.h>

/*

 * Prototypes

 */

/*

 * Ensure a value is between two points

 * macro evaluates its args more than once, so changed to upper-case.

 */

#define LIMITVALUE(x, a, b) do { if ((x) < (a)) (x) = (a); else if ((x) > (b)) (x) = (b); } while (0)

#define LIMITMAX(x, a) do {if ((x) > (a)) (x) = (a); } while (0)

static int get_zone(struct snd_emux *emu, struct snd_emux_port *port,

                    int *notep, int vel, struct snd_midi_channel *chan,

                    struct snd_sf_zone **table);

static int get_bank(struct snd_emux_port *port, struct snd_midi_channel *chan);

static void terminate_note1(struct snd_emux *emu, int note,

                            struct snd_midi_channel *chan, int free);

static void exclusive_note_off(struct snd_emux *emu, struct snd_emux_port *port,

                               int exclass);

static void terminate_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int free);

static void update_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int update);

static void setup_voice(struct snd_emux_voice *vp);

static int calc_pan(struct snd_emux_voice *vp);

static int calc_volume(struct snd_emux_voice *vp);

static int calc_pitch(struct snd_emux_voice *vp);

/*

 * Start a note.

 */

void

snd_emux_note_on(void *p, int note, int vel, struct snd_midi_channel *chan)

{

        struct snd_emux *emu;

        int i, key, nvoices;

        struct snd_emux_voice *vp;

        struct snd_sf_zone *table[SNDRV_EMUX_MAX_MULTI_VOICES];

        unsigned long flags;

        struct snd_emux_port *port;

        port = p;

        snd_assert(port != NULL && chan != NULL, return);

        emu = port->emu;

        snd_assert(emu != NULL, return);

        snd_assert(emu->ops.get_voice != NULL, return);

        snd_assert(emu->ops.trigger != NULL, return);

        key = note; /* remember the original note */

        nvoices = get_zone(emu, port, &note, vel, chan, table);

        if (! nvoices)

                return;

        /* exclusive note off */

        for (i = 0; i < nvoices; i++) {

                struct snd_sf_zone *zp = table[i];

                if (zp && zp->v.exclusiveClass)

                        exclusive_note_off(emu, port, zp->v.exclusiveClass);

        }

#if 0 // seems not necessary

        /* Turn off the same note on the same channel. */

        terminate_note1(emu, key, chan, 0);

#endif

        spin_lock_irqsave(&emu->voice_lock, flags);

        for (i = 0; i < nvoices; i++) {

                /* set up each voice parameter */

                /* at this stage, we don't trigger the voice yet. */

                if (table[i] == NULL)

                        continue;

                vp = emu->ops.get_voice(emu, port);

                if (vp == NULL || vp->ch < 0)

                        continue;

                if (STATE_IS_PLAYING(vp->state))

                        emu->ops.terminate(vp);

                vp->time = emu->use_time++;

                vp->chan = chan;

                vp->port = port;

                vp->key = key;

                vp->note = note;

                vp->velocity = vel;

                vp->zone = table[i];

                if (vp->zone->sample)

                        vp->block = vp->zone->sample->block;

                else

                        vp->block = NULL;

                setup_voice(vp);

                vp->state = SNDRV_EMUX_ST_STANDBY;

                if (emu->ops.prepare) {

                        vp->state = SNDRV_EMUX_ST_OFF;

                        if (emu->ops.prepare(vp) >= 0)

                                vp->state = SNDRV_EMUX_ST_STANDBY;

                }

        }

        /* start envelope now */

        for (i = 0; i < emu->max_voices; i++) {

                vp = &emu->voices[i];

                if (vp->state == SNDRV_EMUX_ST_STANDBY &&

                    vp->chan == chan) {

                        emu->ops.trigger(vp);

                        vp->state = SNDRV_EMUX_ST_ON;

                        vp->ontime = jiffies; /* remember the trigger timing */

                }

        }

        spin_unlock_irqrestore(&emu->voice_lock, flags);

#ifdef SNDRV_EMUX_USE_RAW_EFFECT

        if (port->port_mode == SNDRV_EMUX_PORT_MODE_OSS_SYNTH) {

                /* clear voice position for the next note on this channel */

                struct snd_emux_effect_table *fx = chan->private;

                if (fx) {

                        fx->flag[EMUX_FX_SAMPLE_START] = 0;

                        fx->flag[EMUX_FX_COARSE_SAMPLE_START] = 0;

                }

        }

#endif

}

/*

 * Release a note in response to a midi note off.

 */

void

snd_emux_note_off(void *p, int note, int vel, struct snd_midi_channel *chan)

{

        int ch;

        struct snd_emux *emu;

        struct snd_emux_voice *vp;

        unsigned long flags;

        struct snd_emux_port *port;

        port = p;

        snd_assert(port != NULL && chan != NULL, return);

        emu = port->emu;

        snd_assert(emu != NULL, return);

        snd_assert(emu->ops.release != NULL, return);

        spin_lock_irqsave(&emu->voice_lock, flags);

        for (ch = 0; ch < emu->max_voices; ch++) {

                vp = &emu->voices[ch];

                if (STATE_IS_PLAYING(vp->state) &&

                    vp->chan == chan && vp->key == note) {

                        vp->state = SNDRV_EMUX_ST_RELEASED;

                        if (vp->ontime == jiffies) {

                                /* if note-off is sent too shortly after

                                 * note-on, emuX engine cannot produce the sound

                                 * correctly.  so we'll release this note

                                 * a bit later via timer callback.

                                 */

                                vp->state = SNDRV_EMUX_ST_PENDING;

                                if (! emu->timer_active) {

                                        emu->tlist.expires = jiffies + 1;

                                        add_timer(&emu->tlist);

                                        emu->timer_active = 1;

                                }

                        } else

                                /* ok now release the note */

                                emu->ops.release(vp);

                }

        }

        spin_unlock_irqrestore(&emu->voice_lock, flags);

}

/*

 * timer callback

 *

 * release the pending note-offs

 */

void snd_emux_timer_callback(unsigned long data)

{

        struct snd_emux *emu = (struct snd_emux *) data;

        struct snd_emux_voice *vp;

        unsigned long flags;

        int ch, do_again = 0;

        spin_lock_irqsave(&emu->voice_lock, flags);

        for (ch = 0; ch < emu->max_voices; ch++) {

                vp = &emu->voices[ch];

                if (vp->state == SNDRV_EMUX_ST_PENDING) {

                        if (vp->ontime == jiffies)

                                do_again++; /* release this at the next interrupt */

                        else {

                                emu->ops.release(vp);

                                vp->state = SNDRV_EMUX_ST_RELEASED;

                        }

                }

        }

        if (do_again) {

                emu->tlist.expires = jiffies + 1;

                add_timer(&emu->tlist);

                emu->timer_active = 1;

        } else

                emu->timer_active = 0;

        spin_unlock_irqrestore(&emu->voice_lock, flags);

}

/*

 * key pressure change

 */

void

snd_emux_key_press(void *p, int note, int vel, struct snd_midi_channel *chan)

{

        int ch;

        struct snd_emux *emu;

        struct snd_emux_voice *vp;

        unsigned long flags;

        struct snd_emux_port *port;

        port = p;

        snd_assert(port != NULL && chan != NULL, return);

        emu = port->emu;

        snd_assert(emu != NULL, return);

        snd_assert(emu->ops.update != NULL, return);

        spin_lock_irqsave(&emu->voice_lock, flags);

        for (ch = 0; ch < emu->max_voices; ch++) {

                vp = &emu->voices[ch];

                if (vp->state == SNDRV_EMUX_ST_ON &&

                    vp->chan == chan && vp->key == note) {

                        vp->velocity = vel;

                        update_voice(emu, vp, SNDRV_EMUX_UPDATE_VOLUME);

                }

        }

        spin_unlock_irqrestore(&emu->voice_lock, flags);

}

/*

 * Modulate the voices which belong to the channel

 */

void

snd_emux_update_channel(struct snd_emux_port *port, struct snd_midi_channel *chan, int update)

{

        struct snd_emux *emu;

        struct snd_emux_voice *vp;

        int i;

        unsigned long flags;

        if (! update)

                return;

        emu = port->emu;

        snd_assert(emu != NULL, return);

        snd_assert(emu->ops.update != NULL, return);

        spin_lock_irqsave(&emu->voice_lock, flags);

        for (i = 0; i < emu->max_voices; i++) {

                vp = &emu->voices[i];

                if (vp->chan == chan)

                        update_voice(emu, vp, update);

        }

        spin_unlock_irqrestore(&emu->voice_lock, flags);

}

/*

 * Modulate all the voices which belong to the port.

 */

void

snd_emux_update_port(struct snd_emux_port *port, int update)

{

        struct snd_emux *emu;

        struct snd_emux_voice *vp;

        int i;

        unsigned long flags;

        if (! update)

                return;

        emu = port->emu;

        snd_assert(emu != NULL, return);

        snd_assert(emu->ops.update != NULL, return);

        spin_lock_irqsave(&emu->voice_lock, flags);

        for (i = 0; i < emu->max_voices; i++) {

                vp = &emu->voices[i];

                if (vp->port == port)

                        update_voice(emu, vp, update);

        }

        spin_unlock_irqrestore(&emu->voice_lock, flags);

}

/*

 * Deal with a controller type event.  This includes all types of

 * control events, not just the midi controllers

 */

void

snd_emux_control(void *p, int type, struct snd_midi_channel *chan)

{

        struct snd_emux_port *port;

        port = p;

        snd_assert(port != NULL && chan != NULL, return);

        switch (type) {

        case MIDI_CTL_MSB_MAIN_VOLUME:

        case MIDI_CTL_MSB_EXPRESSION:

                snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_VOLUME);

                break;

        case MIDI_CTL_MSB_PAN:

                snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_PAN);

                break;

        case MIDI_CTL_SOFT_PEDAL:

#ifdef SNDRV_EMUX_USE_RAW_EFFECT

                /* FIXME: this is an emulation */

                snd_emux_send_effect(port, chan, EMUX_FX_CUTOFF, -160,

                                     EMUX_FX_FLAG_ADD);

#endif

                break;

        case MIDI_CTL_PITCHBEND:

                snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_PITCH);

                break;

        case MIDI_CTL_MSB_MODWHEEL:

        case MIDI_CTL_CHAN_PRESSURE:

                snd_emux_update_channel(port, chan,

                                        SNDRV_EMUX_UPDATE_FMMOD |

                                        SNDRV_EMUX_UPDATE_FM2FRQ2);

                break;

        }

        if (port->chset.midi_mode == SNDRV_MIDI_MODE_XG) {

                snd_emux_xg_control(port, chan, type);

        }

}

/*

 * terminate note - if free flag is true, free the terminated voice

 */

static void

terminate_note1(struct snd_emux *emu, int note, struct snd_midi_channel *chan, int free)

{

        int  i;

        struct snd_emux_voice *vp;

        unsigned long flags;

        spin_lock_irqsave(&emu->voice_lock, flags);

        for (i = 0; i < emu->max_voices; i++) {

                vp = &emu->voices[i];

                if (STATE_IS_PLAYING(vp->state) && vp->chan == chan &&

                    vp->key == note)

                        terminate_voice(emu, vp, free);

        }

        spin_unlock_irqrestore(&emu->voice_lock, flags);

}

/*

 * terminate note - exported for midi emulation

 */

void

snd_emux_terminate_note(void *p, int note, struct snd_midi_channel *chan)

{

        struct snd_emux *emu;

        struct snd_emux_port *port;

        port = p;

        snd_assert(port != NULL && chan != NULL, return);

        emu = port->emu;

        snd_assert(emu != NULL, return);

        snd_assert(emu->ops.terminate != NULL, return);

        terminate_note1(emu, note, chan, 1);

}

/*

 * Terminate all the notes

 */

void

snd_emux_terminate_all(struct snd_emux *emu)

{

        int i;

        struct snd_emux_voice *vp;

        unsigned long flags;

        spin_lock_irqsave(&emu->voice_lock, flags);

        for (i = 0; i < emu->max_voices; i++) {

                vp = &emu->voices[i];

                if (STATE_IS_PLAYING(vp->state))

                        terminate_voice(emu, vp, 0);

                if (vp->state == SNDRV_EMUX_ST_OFF) {

                        if (emu->ops.free_voice)

                                emu->ops.free_voice(vp);

                        if (emu->ops.reset)

                                emu->ops.reset(emu, i);

                }

                vp->time = 0;

        }

        /* initialize allocation time */

        emu->use_time = 0;

        spin_unlock_irqrestore(&emu->voice_lock, flags);

}

EXPORT_SYMBOL(snd_emux_terminate_all);

/*

 * Terminate all voices associated with the given port

 */

void

snd_emux_sounds_off_all(struct snd_emux_port *port)

{

        int i;

        struct snd_emux *emu;

        struct snd_emux_voice *vp;

        unsigned long flags;

        snd_assert(port != NULL, return);

        emu = port->emu;

        snd_assert(emu != NULL, return);

        snd_assert(emu->ops.terminate != NULL, return);

        spin_lock_irqsave(&emu->voice_lock, flags);

        for (i = 0; i < emu->max_voices; i++) {

                vp = &emu->voices[i];

                if (STATE_IS_PLAYING(vp->state) &&

                    vp->port == port)

                        terminate_voice(emu, vp, 0);

                if (vp->state == SNDRV_EMUX_ST_OFF) {

                        if (emu->ops.free_voice)

                                emu->ops.free_voice(vp);

                        if (emu->ops.reset)

                                emu->ops.reset(emu, i);

                }

        }

        spin_unlock_irqrestore(&emu->voice_lock, flags);

}

/*

 * Terminate all voices that have the same exclusive class.  This

 * is mainly for drums.

 */

static void

exclusive_note_off(struct snd_emux *emu, struct snd_emux_port *port, int exclass)

{

        struct snd_emux_voice *vp;

        int  i;

        unsigned long flags;

        spin_lock_irqsave(&emu->voice_lock, flags);

        for (i = 0; i < emu->max_voices; i++) {

                vp = &emu->voices[i];

                if (STATE_IS_PLAYING(vp->state) && vp->port == port &&

                    vp->reg.exclusiveClass == exclass) {

                        terminate_voice(emu, vp, 0);

                }

        }

        spin_unlock_irqrestore(&emu->voice_lock, flags);

}

/*

 * terminate a voice

 * if free flag is true, call free_voice after termination

 */

static void

terminate_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int free)

{

        emu->ops.terminate(vp);

        vp->time = emu->use_time++;

        vp->chan = NULL;

        vp->port = NULL;

        vp->zone = NULL;

        vp->block = NULL;

        vp->state = SNDRV_EMUX_ST_OFF;

        if (free && emu->ops.free_voice)

                emu->ops.free_voice(vp);

}

/*

 * Modulate the voice

 */

static void

update_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int update)

{

        if (!STATE_IS_PLAYING(vp->state))

                return;

        if (vp->chan == NULL || vp->port == NULL)

                return;

        if (update & SNDRV_EMUX_UPDATE_VOLUME)

                calc_volume(vp);

        if (update & SNDRV_EMUX_UPDATE_PITCH)

                calc_pitch(vp);

        if (update & SNDRV_EMUX_UPDATE_PAN) {

                if (! calc_pan(vp) && (update == SNDRV_EMUX_UPDATE_PAN))

                        return;

        }

        emu->ops.update(vp, update);

}

#if 0 // not used

/* table for volume target calculation */

static unsigned short voltarget[16] = {

        0xEAC0, 0xE0C8, 0xD740, 0xCE20, 0xC560, 0xBD08, 0xB500, 0xAD58,

        0xA5F8, 0x9EF0, 0x9830, 0x91C0, 0x8B90, 0x85A8, 0x8000, 0x7A90

};

#endif

#define LO_BYTE(v)      ((v) & 0xff)

#define HI_BYTE(v)      (((v) >> 8) & 0xff)

/*

 * Sets up the voice structure by calculating some values that

 * will be needed later.

 */

static void

setup_voice(struct snd_emux_voice *vp)

{

        struct soundfont_voice_parm *parm;

        int pitch;

        /* copy the original register values */

        vp->reg = vp->zone->v;

#ifdef SNDRV_EMUX_USE_RAW_EFFECT

        snd_emux_setup_effect(vp);

#endif

        /* reset status */

        vp->apan = -1;

        vp->avol = -1;

        vp->apitch = -1;

        calc_volume(vp);

        calc_pitch(vp);

        calc_pan(vp);

        parm = &vp->reg.parm;

        /* compute filter target and correct modulation parameters */

        if (LO_BYTE(parm->modatkhld) >= 0x80 && parm->moddelay >= 0x8000) {

                parm->moddelay = 0xbfff;

                pitch = (HI_BYTE(parm->pefe) << 4) + vp->apitch;

                if (pitch > 0xffff)

                        pitch = 0xffff;

                /* calculate filter target */

                vp->ftarget = parm->cutoff + LO_BYTE(parm->pefe);

                LIMITVALUE(vp->ftarget, 0, 255);

                vp->ftarget <<= 8;

        } else {

                vp->ftarget = parm->cutoff;

                vp->ftarget <<= 8;

                pitch = vp->apitch;

        }

        /* compute pitch target */

        if (pitch != 0xffff) {

                vp->ptarget = 1 << (pitch >> 12);

                if (pitch & 0x800) vp->ptarget += (vp->ptarget*0x102e)/0x2710;

                if (pitch & 0x400) vp->ptarget += (vp->ptarget*0x764)/0x2710;

                if (pitch & 0x200) vp->ptarget += (vp->ptarget*0x389)/0x2710;

                vp->ptarget += (vp->ptarget >> 1);

                if (vp->ptarget > 0xffff) vp->ptarget = 0xffff;

        } else

                vp->ptarget = 0xffff;

        if (LO_BYTE(parm->modatkhld) >= 0x80) {

                parm->modatkhld &= ~0xff;

                parm->modatkhld |= 0x7f;

        }

        /* compute volume target and correct volume parameters */

        vp->vtarget = 0;

#if 0 /* FIXME: this leads to some clicks.. */

        if (LO_BYTE(parm->volatkhld) >= 0x80 && parm->voldelay >= 0x8000) {

                parm->voldelay = 0xbfff;

                vp->vtarget = voltarget[vp->avol % 0x10] >> (vp->avol >> 4);

        }

#endif

        if (LO_BYTE(parm->volatkhld) >= 0x80) {

                parm->volatkhld &= ~0xff;

                parm->volatkhld |= 0x7f;

        }

}

/*

 * calculate pitch parameter

 */

static unsigned char pan_volumes[256] = {

0x00,0x03,0x06,0x09,0x0c,0x0f,0x12,0x14,0x17,0x1a,0x1d,0x20,0x22,0x25,0x28,0x2a,

0x2d,0x30,0x32,0x35,0x37,0x3a,0x3c,0x3f,0x41,0x44,0x46,0x49,0x4b,0x4d,0x50,0x52,

0x54,0x57,0x59,0x5b,0x5d,0x60,0x62,0x64,0x66,0x68,0x6a,0x6c,0x6f,0x71,0x73,0x75,

0x77,0x79,0x7b,0x7c,0x7e,0x80,0x82,0x84,0x86,0x88,0x89,0x8b,0x8d,0x8f,0x90,0x92,

0x94,0x96,0x97,0x99,0x9a,0x9c,0x9e,0x9f,0xa1,0xa2,0xa4,0xa5,0xa7,0xa8,0xaa,0xab,

0xad,0xae,0xaf,0xb1,0xb2,0xb3,0xb5,0xb6,0xb7,0xb9,0xba,0xbb,0xbc,0xbe,0xbf,0xc0,