Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 155 insertions, 0 deletions

diff --git a/sound/isa/gus/gus_sample.c b/sound/isa/gus/gus_sample.c
new file mode 100644
index 000000000000..4290e03acd51
--- /dev/null
+++ b/sound/isa/gus/gus_sample.c
@@ -0,0 +1,155 @@
+/*
+ *  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;
+                }
+        }
+}