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     ALsizei i;
 105
 106     context = GetContextRef();
 107     if(!context) return;
 108
 109     if(!data || size < 0)
 110         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 111     for(i = 0;i < size;i++)
 112     {
 113         if((data[i]&0x80))
 114             SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 115     }
 116
 117     device = context->Device;
 118     ALCdevice_Lock(device);
 119     err = MidiSynth_insertSysExEvent(device->Synth, time, data, size);
 120     ALCdevice_Unlock(device);
 121     if(err != AL_NO_ERROR)
 122         alSetError(context, err);
 123
 124 done:
 125     ALCcontext_DecRef(context);
 126 }
 127
 128 AL_API void AL_APIENTRY alMidiPlaySOFT(void)
 129 {
 130     ALCcontext *context;
 131     MidiSynth *synth;
 132
 133     context = GetContextRef();
 134     if(!context) return;
 135
 136     synth = context->Device->Synth;
 137     WriteLock(&synth->Lock);
 138     MidiSynth_setState(synth, AL_PLAYING);
 139     WriteUnlock(&synth->Lock);
 140
 141     ALCcontext_DecRef(context);
 142 }
 143
 144 AL_API void AL_APIENTRY alMidiPauseSOFT(void)
 145 {
 146     ALCcontext *context;
 147     MidiSynth *synth;
 148
 149     context = GetContextRef();
 150     if(!context) return;
 151
 152     synth = context->Device->Synth;
 153     WriteLock(&synth->Lock);
 154     MidiSynth_setState(synth, AL_PAUSED);
 155     WriteUnlock(&synth->Lock);
 156
 157     ALCcontext_DecRef(context);
 158 }
 159
 160 AL_API void AL_APIENTRY alMidiStopSOFT(void)
 161 {
 162     ALCdevice *device;
 163     ALCcontext *context;
 164     MidiSynth *synth;
 165
 166     context = GetContextRef();
 167     if(!context) return;
 168
 169     device = context->Device;
 170     synth = device->Synth;
 171
 172     WriteLock(&synth->Lock);
 173     MidiSynth_setState(synth, AL_STOPPED);
 174
 175     ALCdevice_Lock(device);
 176     V0(synth,stop)();
 177     ALCdevice_Unlock(device);
 178     WriteUnlock(&synth->Lock);
 179
 180     ALCcontext_DecRef(context);
 181 }
 182
 183 AL_API void AL_APIENTRY alMidiResetSOFT(void)
 184 {
 185     ALCdevice *device;
 186     ALCcontext *context;
 187     MidiSynth *synth;
 188
 189     context = GetContextRef();
 190     if(!context) return;
 191
 192     device = context->Device;
 193     synth = device->Synth;
 194
 195     WriteLock(&synth->Lock);
 196     MidiSynth_setState(synth, AL_INITIAL);
 197
 198     ALCdevice_Lock(device);
 199     V0(synth,reset)();
 200     ALCdevice_Unlock(device);
 201     WriteUnlock(&synth->Lock);
 202
 203     ALCcontext_DecRef(context);
 204 }
 205
 206
 207 AL_API void AL_APIENTRY alMidiGainSOFT(ALfloat value)
 208 {
 209     ALCdevice *device;
 210     ALCcontext *context;
 211
 212     context = GetContextRef();
 213     if(!context) return;
 214
 215     if(!(value >= 0.0f && isfinite(value)))
 216         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 217
 218     device = context->Device;
 219     V(device->Synth,setGain)(value);
 220
 221 done:
 222     ALCcontext_DecRef(context);
 223 }