OpenAL32/alMidi.c

   1
   2 #include "config.h"
   3
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <limits.h>
   8
   9 #include "alMain.h"
  10 #include "alMidi.h"
  11 #include "alError.h"
  12 #include "alThunk.h"
  13 #include "evtqueue.h"
  14 #include "rwlock.h"
  15 #include "alu.h"
  16
  17 #include "midi/base.h"
  18
  19
  20 MidiSynth *SynthCreate(ALCdevice *device)
  21 {
  22     MidiSynth *synth = NULL;
  23     if(!synth) synth = SSynth_create(device);
  24     if(!synth) synth = FSynth_create(device);
  25     if(!synth) synth = DSynth_create(device);
  26     return synth;
  27 }
  28
  29
  30 AL_API void AL_APIENTRY alMidiSoundfontSOFT(ALuint id)
  31 {
  32     alMidiSoundfontvSOFT(1, &id);
  33 }
  34
  35 AL_API void AL_APIENTRY alMidiSoundfontvSOFT(ALsizei count, const ALuint *ids)
  36 {
  37     ALCdevice *device;
  38     ALCcontext *context;
  39     MidiSynth *synth;
  40     ALenum err;
  41
  42     context = GetContextRef();
  43     if(!context) return;
  44
  45     if(count < 0)
  46         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
  47
  48     device = context->Device;
  49     synth = device->Synth;
  50
  51     WriteLock(&synth->Lock);
  52     if(synth->State == AL_PLAYING || synth->State == AL_PAUSED)
  53         alSetError(context, AL_INVALID_OPERATION);
  54     else
  55     {
  56         err = V(synth,selectSoundfonts)(context, count, ids);
  57         if(err != AL_NO_ERROR)
  58             alSetError(context, err);
  59     }
  60     WriteUnlock(&synth->Lock);
  61
  62 done:
  63     ALCcontext_DecRef(context);
  64 }
  65
  66
  67 AL_API void AL_APIENTRY alMidiEventSOFT(ALuint64SOFT time, ALenum event, ALsizei channel, ALsizei param1, ALsizei param2)
  68 {
  69     ALCdevice *device;
  70     ALCcontext *context;
  71     ALenum err;
  72
  73     context = GetContextRef();
  74     if(!context) return;
  75
  76     if(!(event == AL_NOTEOFF_SOFT || event == AL_NOTEON_SOFT ||
  77          event == AL_KEYPRESSURE_SOFT || event == AL_CONTROLLERCHANGE_SOFT ||
  78          event == AL_PROGRAMCHANGE_SOFT || event == AL_CHANNELPRESSURE_SOFT ||
  79          event == AL_PITCHBEND_SOFT))
  80         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
  81     if(!(channel >= 0 && channel <= 15))
  82         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
  83     if(!(param1 >= 0 && param1 <= 127))
  84         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
  85     if(!(param2 >= 0 && param2 <= 127))
  86         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
  87
  88     device = context->Device;
  89     ALCdevice_Lock(device);
  90     err = MidiSynth_insertEvent(device->Synth, time, event|channel, param1, param2);
  91     ALCdevice_Unlock(device);
  92     if(err != AL_NO_ERROR)
  93         alSetError(context, err);
  94
  95 done:
  96     ALCcontext_DecRef(context);
  97 }
  98
  99 AL_API void AL_APIENTRY alMidiSysExSOFT(ALuint64SOFT time, const ALbyte *data, ALsizei size)
 100 {
 101     ALCdevice *device;
 102     ALCcontext *context;
 103     ALenum err;
 104
 105     context = GetContextRef();
 106     if(!context) return;
 107
 108     if(!data || size < 0)
 109         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 110
 111     device = context->Device;
 112     ALCdevice_Lock(device);
 113     err = MidiSynth_insertSysExEvent(device->Synth, time, data, size);
 114     ALCdevice_Unlock(device);
 115     if(err != AL_NO_ERROR)
 116         alSetError(context, err);
 117
 118 done:
 119     ALCcontext_DecRef(context);
 120 }
 121
 122 AL_API void AL_APIENTRY alMidiPlaySOFT(void)
 123 {
 124     ALCcontext *context;
 125     MidiSynth *synth;
 126
 127     context = GetContextRef();
 128     if(!context) return;
 129
 130     synth = context->Device->Synth;
 131     WriteLock(&synth->Lock);
 132     MidiSynth_setState(synth, AL_PLAYING);
 133     WriteUnlock(&synth->Lock);
 134
 135     ALCcontext_DecRef(context);
 136 }
 137
 138 AL_API void AL_APIENTRY alMidiPauseSOFT(void)
 139 {
 140     ALCcontext *context;
 141     MidiSynth *synth;
 142
 143     context = GetContextRef();
 144     if(!context) return;
 145
 146     synth = context->Device->Synth;
 147     WriteLock(&synth->Lock);
 148     MidiSynth_setState(synth, AL_PAUSED);
 149     WriteUnlock(&synth->Lock);
 150
 151     ALCcontext_DecRef(context);
 152 }
 153
 154 AL_API void AL_APIENTRY alMidiStopSOFT(void)
 155 {
 156     ALCdevice *device;
 157     ALCcontext *context;
 158     MidiSynth *synth;
 159
 160     context = GetContextRef();
 161     if(!context) return;
 162
 163     device = context->Device;
 164     synth = device->Synth;
 165
 166     WriteLock(&synth->Lock);
 167     MidiSynth_setState(synth, AL_STOPPED);
 168
 169     ALCdevice_Lock(device);
 170     V0(synth,stop)();
 171     ALCdevice_Unlock(device);
 172     WriteUnlock(&synth->Lock);
 173
 174     ALCcontext_DecRef(context);
 175 }
 176
 177 AL_API void AL_APIENTRY alMidiResetSOFT(void)
 178 {
 179     ALCdevice *device;
 180     ALCcontext *context;
 181     MidiSynth *synth;
 182
 183     context = GetContextRef();
 184     if(!context) return;
 185
 186     device = context->Device;
 187     synth = device->Synth;
 188
 189     WriteLock(&synth->Lock);
 190     MidiSynth_setState(synth, AL_INITIAL);
 191
 192     ALCdevice_Lock(device);
 193     V0(synth,reset)();
 194     ALCdevice_Unlock(device);
 195     WriteUnlock(&synth->Lock);
 196
 197     ALCcontext_DecRef(context);
 198 }
 199
 200
 201 AL_API void AL_APIENTRY alMidiGainSOFT(ALfloat value)
 202 {
 203     ALCdevice *device;
 204     ALCcontext *context;
 205
 206     context = GetContextRef();
 207     if(!context) return;
 208
 209     if(!(value >= 0.0f && isfinite(value)))
 210         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 211
 212     device = context->Device;
 213     V(device->Synth,setGain)(value);
 214
 215 done:
 216     ALCcontext_DecRef(context);
 217 }