156 lines
4.7 KiB
C
156 lines
4.7 KiB
C
/*
|
|
* Routines for Gravis UltraSound soundcards - Sample support
|
|
* Copyright (c) by Jaroslav Kysela <perex@suse.cz>
|
|
*
|
|
*
|
|
* 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 <sound/driver.h>
|
|
#include <linux/time.h>
|
|
#include <sound/core.h>
|
|
#include <sound/gus.h>
|
|
|
|
/*
|
|
*
|
|
*/
|
|
|
|
static void select_instrument(snd_gus_card_t * gus, snd_gus_voice_t * v)
|
|
{
|
|
snd_seq_kinstr_t *instr;
|
|
|
|
#if 0
|
|
printk("select instrument: cluster = %li, std = 0x%x, bank = %i, prg = %i\n",
|
|
v->instr.cluster,
|
|
v->instr.std,
|
|
v->instr.bank,
|
|
v->instr.prg);
|
|
#endif
|
|
instr = snd_seq_instr_find(gus->gf1.ilist, &v->instr, 0, 1);
|
|
if (instr != NULL) {
|
|
if (instr->ops) {
|
|
if (!strcmp(instr->ops->instr_type, SNDRV_SEQ_INSTR_ID_SIMPLE))
|
|
snd_gf1_simple_init(v);
|
|
}
|
|
snd_seq_instr_free_use(gus->gf1.ilist, instr);
|
|
}
|
|
}
|
|
|
|
/*
|
|
*
|
|
*/
|
|
|
|
static void event_sample(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v)
|
|
{
|
|
if (v->sample_ops && v->sample_ops->sample_stop)
|
|
v->sample_ops->sample_stop(p->gus, v, SAMPLE_STOP_IMMEDIATELY);
|
|
v->instr.std = ev->data.sample.param.sample.std;
|
|
if (v->instr.std & 0xff000000) { /* private instrument */
|
|
v->instr.std &= 0x00ffffff;
|
|
v->instr.std |= (unsigned int)ev->source.client << 24;
|
|
}
|
|
v->instr.bank = ev->data.sample.param.sample.bank;
|
|
v->instr.prg = ev->data.sample.param.sample.prg;
|
|
select_instrument(p->gus, v);
|
|
}
|
|
|
|
static void event_cluster(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v)
|
|
{
|
|
if (v->sample_ops && v->sample_ops->sample_stop)
|
|
v->sample_ops->sample_stop(p->gus, v, SAMPLE_STOP_IMMEDIATELY);
|
|
v->instr.cluster = ev->data.sample.param.cluster.cluster;
|
|
select_instrument(p->gus, v);
|
|
}
|
|
|
|
static void event_start(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v)
|
|
{
|
|
if (v->sample_ops && v->sample_ops->sample_start)
|
|
v->sample_ops->sample_start(p->gus, v, ev->data.sample.param.position);
|
|
}
|
|
|
|
static void event_stop(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v)
|
|
{
|
|
if (v->sample_ops && v->sample_ops->sample_stop)
|
|
v->sample_ops->sample_stop(p->gus, v, ev->data.sample.param.stop_mode);
|
|
}
|
|
|
|
static void event_freq(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v)
|
|
{
|
|
if (v->sample_ops && v->sample_ops->sample_freq)
|
|
v->sample_ops->sample_freq(p->gus, v, ev->data.sample.param.frequency);
|
|
}
|
|
|
|
static void event_volume(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v)
|
|
{
|
|
if (v->sample_ops && v->sample_ops->sample_volume)
|
|
v->sample_ops->sample_volume(p->gus, v, &ev->data.sample.param.volume);
|
|
}
|
|
|
|
static void event_loop(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v)
|
|
{
|
|
if (v->sample_ops && v->sample_ops->sample_loop)
|
|
v->sample_ops->sample_loop(p->gus, v, &ev->data.sample.param.loop);
|
|
}
|
|
|
|
static void event_position(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v)
|
|
{
|
|
if (v->sample_ops && v->sample_ops->sample_pos)
|
|
v->sample_ops->sample_pos(p->gus, v, ev->data.sample.param.position);
|
|
}
|
|
|
|
static void event_private1(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v)
|
|
{
|
|
if (v->sample_ops && v->sample_ops->sample_private1)
|
|
v->sample_ops->sample_private1(p->gus, v, (unsigned char *)&ev->data.sample.param.raw8);
|
|
}
|
|
|
|
typedef void (gus_sample_event_handler_t)(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v);
|
|
|
|
static gus_sample_event_handler_t *gus_sample_event_handlers[9] = {
|
|
event_sample,
|
|
event_cluster,
|
|
event_start,
|
|
event_stop,
|
|
event_freq,
|
|
event_volume,
|
|
event_loop,
|
|
event_position,
|
|
event_private1
|
|
};
|
|
|
|
void snd_gus_sample_event(snd_seq_event_t *ev, snd_gus_port_t *p)
|
|
{
|
|
int idx, voice;
|
|
snd_gus_card_t *gus = p->gus;
|
|
snd_gus_voice_t *v;
|
|
unsigned long flags;
|
|
|
|
idx = ev->type - SNDRV_SEQ_EVENT_SAMPLE;
|
|
if (idx < 0 || idx > 8)
|
|
return;
|
|
for (voice = 0; voice < 32; voice++) {
|
|
v = &gus->gf1.voices[voice];
|
|
if (v->use && v->client == ev->source.client &&
|
|
v->port == ev->source.port &&
|
|
v->index == ev->data.sample.channel) {
|
|
spin_lock_irqsave(&gus->event_lock, flags);
|
|
gus_sample_event_handlers[idx](ev, p, v);
|
|
spin_unlock_irqrestore(&gus->event_lock, flags);
|
|
return;
|
|
}
|
|
}
|
|
}
|