OpenAL32/alPreset.c

   1
   2 #include "config.h"
   3
   4 #include <stdlib.h>
   5 #include <string.h>
   6
   7 #include "alMain.h"
   8 #include "alMidi.h"
   9 #include "alError.h"
  10 #include "alThunk.h"
  11
  12 #include "midi/base.h"
  13
  14
  15 extern inline struct ALsfpreset *LookupPreset(ALCdevice *device, ALuint id);
  16 extern inline struct ALsfpreset *RemovePreset(ALCdevice *device, ALuint id);
  17
  18 static void ALsfpreset_Construct(ALsfpreset *self);
  19 void ALsfpreset_Destruct(ALsfpreset *self);
  20
  21
  22 AL_API void AL_APIENTRY alGenPresetsSOFT(ALsizei n, ALuint *ids)
  23 {
  24     ALCcontext *context;
  25     ALsizei cur = 0;
  26
  27     context = GetContextRef();
  28     if(!context) return;
  29
  30     if(!(n >= 0))
  31         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
  32
  33     for(cur = 0;cur < n;cur++)
  34     {
  35         ALsfpreset *preset = NewPreset(context);
  36         if(!preset)
  37         {
  38             alDeletePresetsSOFT(cur, ids);
  39             break;
  40         }
  41
  42         ids[cur] = preset->id;
  43     }
  44
  45 done:
  46     ALCcontext_DecRef(context);
  47 }
  48
  49 AL_API ALvoid AL_APIENTRY alDeletePresetsSOFT(ALsizei n, const ALuint *ids)
  50 {
  51     ALCdevice *device;
  52     ALCcontext *context;
  53     ALsfpreset *preset;
  54     ALsizei i;
  55
  56     context = GetContextRef();
  57     if(!context) return;
  58
  59     if(!(n >= 0))
  60         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
  61
  62     device = context->Device;
  63     for(i = 0;i < n;i++)
  64     {
  65         /* Check for valid ID */
  66         if((preset=LookupPreset(device, ids[i])) == NULL)
  67             SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
  68         if(preset->ref != 0)
  69             SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
  70     }
  71
  72     for(i = 0;i < n;i++)
  73     {
  74         if((preset=LookupPreset(device, ids[i])) == NULL)
  75             continue;
  76         DeletePreset(preset, device);
  77     }
  78
  79 done:
  80     ALCcontext_DecRef(context);
  81 }
  82
  83 AL_API ALboolean AL_APIENTRY alIsPresetSOFT(ALuint id)
  84 {
  85     ALCcontext *context;
  86     ALboolean ret;
  87
  88     context = GetContextRef();
  89     if(!context) return AL_FALSE;
  90
  91     ret = LookupPreset(context->Device, id) ? AL_TRUE : AL_FALSE;
  92
  93     ALCcontext_DecRef(context);
  94
  95     return ret;
  96 }
  97
  98 AL_API void AL_APIENTRY alPresetiSOFT(ALuint id, ALenum param, ALint value)
  99 {
 100     ALCdevice *device;
 101     ALCcontext *context;
 102     ALsfpreset *preset;
 103
 104     context = GetContextRef();
 105     if(!context) return;
 106
 107     device = context->Device;
 108     if((preset=LookupPreset(device, id)) == NULL)
 109         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 110     if(preset->ref != 0)
 111         SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
 112     switch(param)
 113     {
 114         case AL_MIDI_PRESET_SOFT:
 115             if(!(value >= 0 && value <= 127))
 116                 SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 117             preset->Preset = value;
 118             break;
 119
 120         case AL_MIDI_BANK_SOFT:
 121             if(!(value >= 0 && value <= 128))
 122                 SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 123             preset->Bank = value;
 124             break;
 125
 126         default:
 127             SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 128     }
 129
 130 done:
 131     ALCcontext_DecRef(context);
 132 }
 133
 134 AL_API void AL_APIENTRY alPresetivSOFT(ALuint id, ALenum param, const ALint *values)
 135 {
 136     ALCdevice *device;
 137     ALCcontext *context;
 138     ALsfpreset *preset;
 139
 140     switch(param)
 141     {
 142         case AL_MIDI_PRESET_SOFT:
 143         case AL_MIDI_BANK_SOFT:
 144             alPresetiSOFT(id, param, values[0]);
 145             return;
 146     }
 147
 148     context = GetContextRef();
 149     if(!context) return;
 150
 151     device = context->Device;
 152     if((preset=LookupPreset(device, id)) == NULL)
 153         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 154     if(preset->ref != 0)
 155         SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
 156     switch(param)
 157     {
 158         default:
 159             SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 160     }
 161
 162 done:
 163     ALCcontext_DecRef(context);
 164 }
 165
 166 AL_API void AL_APIENTRY alGetPresetivSOFT(ALuint id, ALenum param, ALint *values)
 167 {
 168     ALCdevice *device;
 169     ALCcontext *context;
 170     ALsfpreset *preset;
 171     ALsizei i;
 172
 173     context = GetContextRef();
 174     if(!context) return;
 175
 176     device = context->Device;
 177     if((preset=LookupPreset(device, id)) == NULL)
 178         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 179     switch(param)
 180     {
 181         case AL_MIDI_PRESET_SOFT:
 182             values[0] = preset->Preset;
 183             break;
 184
 185         case AL_MIDI_BANK_SOFT:
 186             values[0] = preset->Bank;
 187             break;
 188
 189         case AL_FONTSOUNDS_SIZE_SOFT:
 190             values[0] = preset->NumSounds;
 191             break;
 192
 193         case AL_FONTSOUNDS_SOFT:
 194             for(i = 0;i < preset->NumSounds;i++)
 195                 values[i] = preset->Sounds[i]->id;
 196             break;
 197
 198         default:
 199             SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 200     }
 201
 202 done:
 203     ALCcontext_DecRef(context);
 204 }
 205
 206 AL_API void AL_APIENTRY alPresetFontsoundsSOFT(ALuint id, ALsizei count, const ALuint *fsids)
 207 {
 208     ALCdevice *device;
 209     ALCcontext *context;
 210     ALsfpreset *preset;
 211     ALfontsound **sounds;
 212     ALsizei i;
 213
 214     context = GetContextRef();
 215     if(!context) return;
 216
 217     device = context->Device;
 218     if(!(preset=LookupPreset(device, id)))
 219         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 220     if(count < 0)
 221         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 222
 223     if(preset->ref != 0)
 224         SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
 225
 226     if(count == 0)
 227         sounds = NULL;
 228     else
 229     {
 230         sounds = calloc(count, sizeof(sounds[0]));
 231         if(!sounds)
 232             SET_ERROR_AND_GOTO(context, AL_OUT_OF_MEMORY, done);
 233
 234         for(i = 0;i < count;i++)
 235         {
 236             if(!(sounds[i]=LookupFontsound(device, fsids[i])))
 237             {
 238                 free(sounds);
 239                 SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 240             }
 241         }
 242     }
 243
 244     for(i = 0;i < count;i++)
 245         IncrementRef(&sounds[i]->ref);
 246
 247     sounds = ExchangePtr((XchgPtr*)&preset->Sounds, sounds);
 248     count = ExchangeInt(&preset->NumSounds, count);
 249
 250     for(i = 0;i < count;i++)
 251         DecrementRef(&sounds[i]->ref);
 252     free(sounds);
 253
 254 done:
 255     ALCcontext_DecRef(context);
 256 }
 257
 258
 259 ALsfpreset *NewPreset(ALCcontext *context)
 260 {
 261     ALCdevice *device = context->Device;
 262     ALsfpreset *preset;
 263     ALenum err;
 264
 265     preset = calloc(1, sizeof(*preset));
 266     if(!preset)
 267         SET_ERROR_AND_RETURN_VALUE(context, AL_OUT_OF_MEMORY, NULL);
 268     ALsfpreset_Construct(preset);
 269
 270     err = NewThunkEntry(&preset->id);
 271     if(err == AL_NO_ERROR)
 272         err = InsertUIntMapEntry(&device->PresetMap, preset->id, preset);
 273     if(err != AL_NO_ERROR)
 274     {
 275         ALsfpreset_Destruct(preset);
 276         memset(preset, 0, sizeof(*preset));
 277         free(preset);
 278
 279         SET_ERROR_AND_RETURN_VALUE(context, err, NULL);
 280     }
 281
 282     return preset;
 283 }
 284
 285 void DeletePreset(ALsfpreset *preset, ALCdevice *device)
 286 {
 287     RemovePreset(device, preset->id);
 288
 289     ALsfpreset_Destruct(preset);
 290     memset(preset, 0, sizeof(*preset));
 291     free(preset);
 292 }
 293
 294
 295 static void ALsfpreset_Construct(ALsfpreset *self)
 296 {
 297     self->ref = 0;
 298
 299     self->Preset = 0;
 300     self->Bank = 0;
 301
 302     self->Sounds = NULL;
 303     self->NumSounds = 0;
 304
 305     self->id = 0;
 306 }
 307
 308 void ALsfpreset_Destruct(ALsfpreset *self)
 309 {
 310     ALsizei i;
 311
 312     FreeThunkEntry(self->id);
 313     self->id = 0;
 314
 315     for(i = 0;i < self->NumSounds;i++)
 316         DecrementRef(&self->Sounds[i]->ref);
 317     free(self->Sounds);
 318     self->Sounds = NULL;
 319     self->NumSounds = 0;
 320 }
 321
 322
 323 /* ReleaseALPresets
 324  *
 325  * Called to destroy any presets that still exist on the device
 326  */
 327 void ReleaseALPresets(ALCdevice *device)
 328 {
 329     ALsizei i;
 330     for(i = 0;i < device->PresetMap.size;i++)
 331     {
 332         ALsfpreset *temp = device->PresetMap.array[i].value;
 333         device->PresetMap.array[i].value = NULL;
 334
 335         ALsfpreset_Destruct(temp);
 336
 337         memset(temp, 0, sizeof(*temp));
 338         free(temp);
 339     }
 340 }