static void deviceList(int type, vector_DevMap *devmap)
{
snd_ctl_t* handle;
snd_pcm_info_t pcminfo;
int max_cards, card, err, dev;
DevMap entry;
char name[1024];
struct snd_ctl_hw_info info;
void* temp;
max_cards = snd_cards();
if(max_cards < 0)
return;
VECTOR_RESERVE(*devmap, max_cards+1);
VECTOR_RESIZE(*devmap, 0);
entry.name = strdup(qsaDevice);
entry.card = 0;
entry.dev = 0;
VECTOR_PUSH_BACK(*devmap, entry);
for(card = 0;card < max_cards;card++)
{
if((err=snd_ctl_open(&handle, card)) < 0)
continue;
if((err=snd_ctl_hw_info(handle, &info)) < 0)
{
snd_ctl_close(handle);
continue;
}
for(dev = 0;dev < (int)info.pcmdevs;dev++)
{
if((err=snd_ctl_pcm_info(handle, dev, &pcminfo)) < 0)
continue;
if((type==SND_PCM_CHANNEL_PLAYBACK && (pcminfo.flags&SND_PCM_INFO_PLAYBACK)) ||
(type==SND_PCM_CHANNEL_CAPTURE && (pcminfo.flags&SND_PCM_INFO_CAPTURE)))
{
snprintf(name, sizeof(name), "%s [%s] (hw:%d,%d)", info.name, pcminfo.name, card, dev);
entry.name = strdup(name);
entry.card = card;
entry.dev = dev;
VECTOR_PUSH_BACK(*devmap, entry);
TRACE("Got device \"%s\", card %d, dev %d\n", name, card, dev);
}
}
snd_ctl_close(handle);
}
}
static void GenModList_accumGen(GenModList *self, const Generator *gen)
{
Generator *i = VECTOR_ITER_BEGIN(self->gens);
Generator *end = VECTOR_ITER_END(self->gens);
for(;i != end;i++)
{
if(i->mGenerator == gen->mGenerator)
{
if(gen->mGenerator == 43 || gen->mGenerator == 44)
{
/* Range generators accumulate by taking the intersection of
* the two ranges.
*/
ALushort low = maxu(i->mAmount&0x00ff, gen->mAmount&0x00ff);
ALushort high = minu(i->mAmount&0xff00, gen->mAmount&0xff00);
i->mAmount = low | high;
}
else
i->mAmount += gen->mAmount;
return;
}
}
if(VECTOR_PUSH_BACK(self->gens, *gen) == AL_FALSE)
{
ERR("Failed to insert generator (from %d elements)\n", VECTOR_SIZE(self->gens));
return;
}
if(gen->mGenerator < 60)
VECTOR_BACK(self->gens).mAmount += DefaultGenValue[gen->mGenerator];
}
static void GenModList_insertGen(GenModList *self, const Generator *gen, ALboolean ispreset)
{
Generator *i = VECTOR_ITER_BEGIN(self->gens);
Generator *end = VECTOR_ITER_END(self->gens);
for(;i != end;i++)
{
if(i->mGenerator == gen->mGenerator)
{
i->mAmount = gen->mAmount;
return;
}
}
if(ispreset &&
(gen->mGenerator == 0 || gen->mGenerator == 1 || gen->mGenerator == 2 ||
gen->mGenerator == 3 || gen->mGenerator == 4 || gen->mGenerator == 12 ||
gen->mGenerator == 45 || gen->mGenerator == 46 || gen->mGenerator == 47 ||
gen->mGenerator == 50 || gen->mGenerator == 54 || gen->mGenerator == 57 ||
gen->mGenerator == 58))
return;
if(VECTOR_PUSH_BACK(self->gens, *gen) == AL_FALSE)
{
ERR("Failed to insert generator (from %d elements)\n", VECTOR_SIZE(self->gens));
return;
}
}
AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
{
ALCcontext *context;
VECTOR(ALeffectslot*) slotvec;
ALsizei cur;
ALenum err;
context = GetContextRef();
if(!context) return;
VECTOR_INIT(slotvec);
if(!(n >= 0))
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
if(!VECTOR_RESERVE(slotvec, n))
SET_ERROR_AND_GOTO(context, AL_OUT_OF_MEMORY, done);
for(cur = 0;cur < n;cur++)
{
ALeffectslot *slot = al_calloc(16, sizeof(ALeffectslot));
err = AL_OUT_OF_MEMORY;
if(!slot || (err=InitEffectSlot(slot)) != AL_NO_ERROR)
{
al_free(slot);
alDeleteAuxiliaryEffectSlots(cur, effectslots);
SET_ERROR_AND_GOTO(context, err, done);
}
err = NewThunkEntry(&slot->id);
if(err == AL_NO_ERROR)
err = InsertUIntMapEntry(&context->EffectSlotMap, slot->id, slot);
if(err != AL_NO_ERROR)
{
FreeThunkEntry(slot->id);
DELETE_OBJ(slot->Params.EffectState);
al_free(slot);
alDeleteAuxiliaryEffectSlots(cur, effectslots);
SET_ERROR_AND_GOTO(context, err, done);
}
aluInitEffectPanning(slot);
VECTOR_PUSH_BACK(slotvec, slot);
effectslots[cur] = slot->id;
}
err = AddEffectSlotArray(context, VECTOR_BEGIN(slotvec), n);
if(err != AL_NO_ERROR)
{
alDeleteAuxiliaryEffectSlots(cur, effectslots);
SET_ERROR_AND_GOTO(context, err, done);
}
done:
VECTOR_DEINIT(slotvec);
ALCcontext_DecRef(context);
}
static void add_device(IMMDevice *device, LPCWSTR devid, vector_DevMap *list)
{
DevMap entry;
AL_STRING_INIT(entry.name);
entry.devid = strdupW(devid);
get_device_name(device, &entry.name);
TRACE("Got device \"%s\", \"%ls\"\n", al_string_get_cstr(entry.name), entry.devid);
VECTOR_PUSH_BACK(*list, entry);
}
static int
type_make(ir_unit_t *iu, int type)
{
for(int i = 0; i < VECTOR_LEN(&iu->iu_types); i++) {
ir_type_t *it = &VECTOR_ITEM(&iu->iu_types, i);
if(it->it_code == type)
return i;
}
iu->iu_types_created = 1;
ir_type_t it;
int r = VECTOR_LEN(&iu->iu_types);
it.it_code = type;
VECTOR_PUSH_BACK(&iu->iu_types, it);
return r;
}
static BOOL CALLBACK DSoundEnumDevices(GUID *guid, const WCHAR *desc, const WCHAR* UNUSED(drvname), void *data)
{
vector_DevMap *devices = data;
OLECHAR *guidstr = NULL;
DevMap *iter, *end;
DevMap entry;
HRESULT hr;
int count;
if(!guid)
return TRUE;
AL_STRING_INIT(entry.name);
count = 0;
do {
al_string_copy_wcstr(&entry.name, desc);
if(count != 0)
{
char str[64];
snprintf(str, sizeof(str), " #%d", count+1);
al_string_append_cstr(&entry.name, str);
}
count++;
iter = VECTOR_ITER_BEGIN(*devices);
end = VECTOR_ITER_END(*devices);
for(;iter != end;++iter)
{
if(al_string_cmp(entry.name, iter->name) == 0)
break;
}
} while(iter != end);
entry.guid = *guid;
hr = StringFromCLSID(guid, &guidstr);
if(SUCCEEDED(hr))
{
TRACE("Got device \"%s\", GUID \"%ls\"\n", al_string_get_cstr(entry.name), guidstr);
CoTaskMemFree(guidstr);
}
VECTOR_PUSH_BACK(*devices, entry);
return TRUE;
}
static BOOL CALLBACK DSoundEnumDevices(GUID *guid, const WCHAR *desc, const WCHAR* UNUSED(drvname), void *data)
{
vector_DevMap *devices = data;
OLECHAR *guidstr = NULL;
DevMap entry;
HRESULT hr;
int count;
if(!guid)
return TRUE;
AL_STRING_INIT(entry.name);
count = 0;
while(1)
{
const DevMap *iter;
al_string_copy_cstr(&entry.name, DEVNAME_HEAD);
al_string_append_wcstr(&entry.name, desc);
if(count != 0)
{
char str[64];
snprintf(str, sizeof(str), " #%d", count+1);
al_string_append_cstr(&entry.name, str);
}
#define MATCH_ENTRY(i) (al_string_cmp(entry.name, (i)->name) == 0)
VECTOR_FIND_IF(iter, const DevMap, *devices, MATCH_ENTRY);
if(iter == VECTOR_END(*devices)) break;
#undef MATCH_ENTRY
count++;
}
entry.guid = *guid;
hr = StringFromCLSID(guid, &guidstr);
if(SUCCEEDED(hr))
{
TRACE("Got device \"%s\", GUID \"%ls\"\n", al_string_get_cstr(entry.name), guidstr);
CoTaskMemFree(guidstr);
}
VECTOR_PUSH_BACK(*devices, entry);
return TRUE;
}
static void ProbePlaybackDevices(void)
{
al_string *iter, *end;
ALuint numdevs;
ALuint i;
clear_devlist(&PlaybackDevices);
numdevs = waveOutGetNumDevs();
VECTOR_RESERVE(PlaybackDevices, numdevs);
for(i = 0; i < numdevs; i++)
{
WAVEOUTCAPSW WaveCaps;
al_string dname;
AL_STRING_INIT(dname);
if(waveOutGetDevCapsW(i, &WaveCaps, sizeof(WaveCaps)) == MMSYSERR_NOERROR)
{
ALuint count = 0;
do {
al_string_copy_wcstr(&dname, WaveCaps.szPname);
if(count != 0)
{
char str[64];
snprintf(str, sizeof(str), " #%d", count+1);
al_string_append_cstr(&dname, str);
}
count++;
iter = VECTOR_ITER_BEGIN(PlaybackDevices);
end = VECTOR_ITER_END(PlaybackDevices);
for(; iter != end; iter++)
{
if(al_string_cmp(*iter, dname) == 0)
break;
}
} while(iter != end);
TRACE("Got device \"%s\", ID %u\n", al_string_get_cstr(dname), i);
}
VECTOR_PUSH_BACK(PlaybackDevices, dname);
}
}
static void ProbeCaptureDevices(void)
{
ALuint numdevs;
ALuint i;
clear_devlist(&CaptureDevices);
numdevs = waveInGetNumDevs();
VECTOR_RESIZE(CaptureDevices, 0, numdevs);
for(i = 0;i < numdevs;i++)
{
WAVEINCAPSW WaveCaps;
const al_string *iter;
al_string dname;
AL_STRING_INIT(dname);
if(waveInGetDevCapsW(i, &WaveCaps, sizeof(WaveCaps)) == MMSYSERR_NOERROR)
{
ALuint count = 0;
while(1)
{
alstr_copy_cstr(&dname, DEVNAME_HEAD);
alstr_append_wcstr(&dname, WaveCaps.szPname);
if(count != 0)
{
char str[64];
snprintf(str, sizeof(str), " #%d", count+1);
alstr_append_cstr(&dname, str);
}
count++;
#define MATCH_ENTRY(i) (alstr_cmp(dname, *(i)) == 0)
VECTOR_FIND_IF(iter, const al_string, CaptureDevices, MATCH_ENTRY);
if(iter == VECTOR_END(CaptureDevices)) break;
#undef MATCH_ENTRY
}
TRACE("Got device \"%s\", ID %u\n", alstr_get_cstr(dname), i);
}
VECTOR_PUSH_BACK(CaptureDevices, dname);
}
}
static void add_device(IMMDevice *device, vector_DevMap *list)
{
LPWSTR devid;
HRESULT hr;
hr = IMMDevice_GetId(device, &devid);
if(SUCCEEDED(hr))
{
DevMap entry;
AL_STRING_INIT(entry.name);
entry.devid = strdupW(devid);
get_device_name(device, &entry.name);
CoTaskMemFree(devid);
TRACE("Got device \"%s\", \"%ls\"\n", al_string_get_cstr(entry.name), entry.devid);
VECTOR_PUSH_BACK(*list, entry);
}
}
static int
type_make_pointer(ir_unit_t *iu, int type, int may_create)
{
for(int i = 0; i < VECTOR_LEN(&iu->iu_types); i++) {
ir_type_t *it = &VECTOR_ITEM(&iu->iu_types, i);
if(it->it_code == IR_TYPE_POINTER && it->it_pointer.pointee == type)
return i;
}
if(!may_create)
return -1;
iu->iu_types_created = 1;
ir_type_t it;
int r = VECTOR_LEN(&iu->iu_types);
it.it_code = IR_TYPE_POINTER;
it.it_pointer.pointee = type;
VECTOR_PUSH_BACK(&iu->iu_types, it);
return r;
}
static void GenModList_insertMod(GenModList *self, const Modulator *mod)
{
Modulator *i = VECTOR_ITER_BEGIN(self->mods);
Modulator *end = VECTOR_ITER_END(self->mods);
for(;i != end;i++)
{
if(i->mDstOp == mod->mDstOp && i->mSrcOp == mod->mSrcOp &&
i->mAmtSrcOp == mod->mAmtSrcOp && i->mTransOp == mod->mTransOp)
{
i->mAmount = mod->mAmount;
return;
}
}
if(VECTOR_PUSH_BACK(self->mods, *mod) == AL_FALSE)
{
ERR("Failed to insert modulator (from %d elements)\n", VECTOR_SIZE(self->mods));
return;
}
}
static void GenModList_accumMod(GenModList *self, const Modulator *mod)
{
Modulator *i = VECTOR_ITER_BEGIN(self->mods);
Modulator *end = VECTOR_ITER_END(self->mods);
for(;i != end;i++)
{
if(i->mDstOp == mod->mDstOp && i->mSrcOp == mod->mSrcOp &&
i->mAmtSrcOp == mod->mAmtSrcOp && i->mTransOp == mod->mTransOp)
{
i->mAmount += mod->mAmount;
return;
}
}
if(VECTOR_PUSH_BACK(self->mods, *mod) == AL_FALSE)
{
ERR("Failed to insert modulator (from %d elements)\n", VECTOR_SIZE(self->mods));
return;
}
if(mod->mSrcOp == 0x0502 && mod->mDstOp == 48 && mod->mAmtSrcOp == 0 && mod->mTransOp == 0)
VECTOR_BACK(self->mods).mAmount += 960;
else if(mod->mSrcOp == 0x0102 && mod->mDstOp == 8 && mod->mAmtSrcOp == 0 && mod->mTransOp == 0)
VECTOR_BACK(self->mods).mAmount += -2400;
else if(mod->mSrcOp == 0x000D && mod->mDstOp == 6 && mod->mAmtSrcOp == 0 && mod->mTransOp == 0)
VECTOR_BACK(self->mods).mAmount += 50;
else if(mod->mSrcOp == 0x0081 && mod->mDstOp == 6 && mod->mAmtSrcOp == 0 && mod->mTransOp == 0)
VECTOR_BACK(self->mods).mAmount += 50;
else if(mod->mSrcOp == 0x0582 && mod->mDstOp == 48 && mod->mAmtSrcOp == 0 && mod->mTransOp == 0)
VECTOR_BACK(self->mods).mAmount += 960;
else if(mod->mSrcOp == 0x028A && mod->mDstOp == 17 && mod->mAmtSrcOp == 0 && mod->mTransOp == 0)
VECTOR_BACK(self->mods).mAmount += 1000;
else if(mod->mSrcOp == 0x058B && mod->mDstOp == 48 && mod->mAmtSrcOp == 0 && mod->mTransOp == 0)
VECTOR_BACK(self->mods).mAmount += 960;
else if(mod->mSrcOp == 0x00DB && mod->mDstOp == 16 && mod->mAmtSrcOp == 0 && mod->mTransOp == 0)
VECTOR_BACK(self->mods).mAmount += 200;
else if(mod->mSrcOp == 0x00DD && mod->mDstOp == 15 && mod->mAmtSrcOp == 0 && mod->mTransOp == 0)
VECTOR_BACK(self->mods).mAmount += 200;
/*else if(mod->mSrcOp == 0x020E && mod->mDstOp == ?initialpitch? && mod->mAmtSrcOp == 0x0010 && mod->mTransOp == 0)
VECTOR_BACK(self->mods).mAmount += 12700;*/
}
static ALeffect *AllocEffect(ALCcontext *context)
{
ALCdevice *device = context->Device;
EffectSubList *sublist, *subend;
ALeffect *effect = NULL;
ALsizei lidx = 0;
ALsizei slidx;
almtx_lock(&device->EffectLock);
sublist = VECTOR_BEGIN(device->EffectList);
subend = VECTOR_END(device->EffectList);
for(;sublist != subend;++sublist)
{
if(sublist->FreeMask)
{
slidx = CTZ64(sublist->FreeMask);
effect = sublist->Effects + slidx;
break;
}
++lidx;
}
if(UNLIKELY(!effect))
{
const EffectSubList empty_sublist = { 0, NULL };
/* Don't allocate so many list entries that the 32-bit ID could
* overflow...
*/
if(UNLIKELY(VECTOR_SIZE(device->EffectList) >= 1<<25))
{
almtx_unlock(&device->EffectLock);
alSetError(context, AL_OUT_OF_MEMORY, "Too many effects allocated");
return NULL;
}
lidx = (ALsizei)VECTOR_SIZE(device->EffectList);
VECTOR_PUSH_BACK(device->EffectList, empty_sublist);
sublist = &VECTOR_BACK(device->EffectList);
sublist->FreeMask = ~U64(0);
sublist->Effects = al_calloc(16, sizeof(ALeffect)*64);
if(UNLIKELY(!sublist->Effects))
{
VECTOR_POP_BACK(device->EffectList);
almtx_unlock(&device->EffectLock);
alSetError(context, AL_OUT_OF_MEMORY, "Failed to allocate effect batch");
return NULL;
}
slidx = 0;
effect = sublist->Effects + slidx;
}
memset(effect, 0, sizeof(*effect));
InitEffectParams(effect, AL_EFFECT_NULL);
/* Add 1 to avoid effect ID 0. */
effect->id = ((lidx<<6) | slidx) + 1;
sublist->FreeMask &= ~(U64(1)<<slidx);
almtx_unlock(&device->EffectLock);
return effect;
}
static void probe_devices(snd_pcm_stream_t stream, vector_DevMap *DeviceList)
{
const char *main_prefix = "plughw:";
snd_ctl_t *handle;
snd_ctl_card_info_t *info;
snd_pcm_info_t *pcminfo;
int card, err, dev;
DevMap entry;
clear_devlist(DeviceList);
snd_ctl_card_info_malloc(&info);
snd_pcm_info_malloc(&pcminfo);
AL_STRING_INIT(entry.name);
AL_STRING_INIT(entry.device_name);
al_string_copy_cstr(&entry.name, alsaDevice);
al_string_copy_cstr(&entry.device_name, GetConfigValue(NULL, "alsa", (stream==SND_PCM_STREAM_PLAYBACK) ?
"device" : "capture", "default"));
VECTOR_PUSH_BACK(*DeviceList, entry);
card = -1;
if((err=snd_card_next(&card)) < 0)
ERR("Failed to find a card: %s\n", snd_strerror(err));
ConfigValueStr(NULL, "alsa", prefix_name(stream), &main_prefix);
while(card >= 0)
{
const char *card_prefix = main_prefix;
const char *cardname, *cardid;
char name[256];
snprintf(name, sizeof(name), "hw:%d", card);
if((err = snd_ctl_open(&handle, name, 0)) < 0)
{
ERR("control open (hw:%d): %s\n", card, snd_strerror(err));
goto next_card;
}
if((err = snd_ctl_card_info(handle, info)) < 0)
{
ERR("control hardware info (hw:%d): %s\n", card, snd_strerror(err));
snd_ctl_close(handle);
goto next_card;
}
cardname = snd_ctl_card_info_get_name(info);
cardid = snd_ctl_card_info_get_id(info);
snprintf(name, sizeof(name), "%s-%s", prefix_name(stream), cardid);
ConfigValueStr(NULL, "alsa", name, &card_prefix);
dev = -1;
while(1)
{
const char *device_prefix = card_prefix;
const char *devname;
char device[128];
if(snd_ctl_pcm_next_device(handle, &dev) < 0)
ERR("snd_ctl_pcm_next_device failed\n");
if(dev < 0)
break;
snd_pcm_info_set_device(pcminfo, dev);
snd_pcm_info_set_subdevice(pcminfo, 0);
snd_pcm_info_set_stream(pcminfo, stream);
if((err = snd_ctl_pcm_info(handle, pcminfo)) < 0) {
if(err != -ENOENT)
ERR("control digital audio info (hw:%d): %s\n", card, snd_strerror(err));
continue;
}
devname = snd_pcm_info_get_name(pcminfo);
snprintf(name, sizeof(name), "%s-%s-%d", prefix_name(stream), cardid, dev);
ConfigValueStr(NULL, "alsa", name, &device_prefix);
snprintf(name, sizeof(name), "%s, %s (CARD=%s,DEV=%d)",
cardname, devname, cardid, dev);
snprintf(device, sizeof(device), "%sCARD=%s,DEV=%d",
device_prefix, cardid, dev);
TRACE("Got device \"%s\", \"%s\"\n", name, device);
AL_STRING_INIT(entry.name);
AL_STRING_INIT(entry.device_name);
al_string_copy_cstr(&entry.name, name);
al_string_copy_cstr(&entry.device_name, device);
VECTOR_PUSH_BACK(*DeviceList, entry);
}
snd_ctl_close(handle);
next_card:
if(snd_card_next(&card) < 0) {
ERR("snd_card_next failed\n");
break;
}
}
snd_pcm_info_free(pcminfo);
snd_ctl_card_info_free(info);
}
AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
{
ALCdevice *device;
ALCcontext *context;
ALsizei cur;
context = GetContextRef();
if(!context) return;
if(n < 0)
SETERR_GOTO(context, AL_INVALID_VALUE, done, "Generating %d effect slots", n);
if(n == 0) goto done;
LockEffectSlotList(context);
device = context->Device;
for(cur = 0;cur < n;cur++)
{
ALeffectslotPtr *iter = VECTOR_BEGIN(context->EffectSlotList);
ALeffectslotPtr *end = VECTOR_END(context->EffectSlotList);
ALeffectslot *slot = NULL;
ALenum err = AL_OUT_OF_MEMORY;
for(;iter != end;iter++)
{
if(!*iter)
break;
}
if(iter == end)
{
if(device->AuxiliaryEffectSlotMax == VECTOR_SIZE(context->EffectSlotList))
{
UnlockEffectSlotList(context);
alDeleteAuxiliaryEffectSlots(cur, effectslots);
SETERR_GOTO(context, AL_OUT_OF_MEMORY, done,
"Exceeding %u auxiliary effect slot limit", device->AuxiliaryEffectSlotMax);
}
VECTOR_PUSH_BACK(context->EffectSlotList, NULL);
iter = &VECTOR_BACK(context->EffectSlotList);
}
slot = al_calloc(16, sizeof(ALeffectslot));
if(!slot || (err=InitEffectSlot(slot)) != AL_NO_ERROR)
{
al_free(slot);
UnlockEffectSlotList(context);
alDeleteAuxiliaryEffectSlots(cur, effectslots);
SETERR_GOTO(context, err, done, "Effect slot object allocation failed");
}
aluInitEffectPanning(slot);
slot->id = (iter - VECTOR_BEGIN(context->EffectSlotList)) + 1;
*iter = slot;
effectslots[cur] = slot->id;
}
AddActiveEffectSlots(effectslots, n, context);
UnlockEffectSlotList(context);
done:
ALCcontext_DecRef(context);
}
static void
types_new_rec_handler(struct ir_unit *iu, int op,
unsigned int argc, const ir_arg_t *argv)
{
ir_type_t it;
const char *ctx = "types";
assert(iu->iu_types_created == 0);
switch(op) {
case TYPE_CODE_NUMENTRY:
if(argc < 1)
parser_error(iu, "%s: Short NUMENTRY record", ctx);
VECTOR_SET_CAPACITY(&iu->iu_types, argv[0].i64);
return;
case TYPE_CODE_VOID:
it.it_code = IR_TYPE_VOID;
break;
case TYPE_CODE_FLOAT:
it.it_code = IR_TYPE_FLOAT;
break;
case TYPE_CODE_DOUBLE:
it.it_code = IR_TYPE_DOUBLE;
break;
case TYPE_CODE_INTEGER:
if(argv[0].i64 == 1) {
it.it_code = IR_TYPE_INT1;
} else if(argv[0].i64 == 8) {
it.it_code = IR_TYPE_INT8;
} else if(argv[0].i64 == 16) {
it.it_code = IR_TYPE_INT16;
} else if(argv[0].i64 == 32) {
it.it_code = IR_TYPE_INT32;
} else if(argv[0].i64 == 64) {
it.it_code = IR_TYPE_INT64;
} else if(argv[0].i64 < 64) {
it.it_code = IR_TYPE_INTx;
it.it_bits = argv[0].i64;
} else {
parser_error(iu, "%s: Integer width %d bit not supported",
ctx, (int)argv[0].i64);
}
break;
case TYPE_CODE_ARRAY:
it.it_code = IR_TYPE_ARRAY;
it.it_array.num_elements = argv[0].i64;
it.it_array.element_type = argv[1].i64;
break;
case TYPE_CODE_STRUCT_NAME:
free(iu->iu_current_struct_name);
iu->iu_current_struct_name = read_str_from_argv(argc, argv);
return;
case TYPE_CODE_STRUCT_NAMED:
it.it_struct.name = iu->iu_current_struct_name;
iu->iu_current_struct_name = NULL;
if(0)
case TYPE_CODE_STRUCT_ANON:
it.it_struct.name = NULL;
it.it_code = IR_TYPE_STRUCT;
it.it_struct.num_elements = argc - 1;
it.it_struct.elements = malloc(it.it_struct.num_elements *
sizeof(it.it_struct.elements[0]));
{
const int packed = !!argv[0].i64;
int offset = 0;
int ba = 1; // Biggest alignment
for(int i = 0; i < it.it_struct.num_elements; i++) {
int t = argv[i + 1].i64;
it.it_struct.elements[i].type = t;
int s = type_sizeof(iu, t);
if(!packed) {
int a = type_alignment(iu ,t);
offset = VMIR_ALIGN(offset, a);
ba = MAX(ba, a);
}
it.it_struct.elements[i].offset = offset;
offset += s;
}
it.it_struct.size = packed ? offset : VMIR_ALIGN(offset, ba);
it.it_struct.alignment = ba;
}
break;
case TYPE_CODE_POINTER:
it.it_code = IR_TYPE_POINTER;
it.it_pointer.pointee = argv[0].i64;
break;
case TYPE_CODE_FUNCTION:
if(argc < 2)
parser_error(iu, "%s: Invalid # of args (%d) for function type",
ctx, argc);
it.it_code = IR_TYPE_FUNCTION;
it.it_function.varargs = argv[0].i64;
it.it_function.return_type = argv[1].i64;
it.it_function.num_parameters = argc - 2;
it.it_function.parameters =
malloc(it.it_function.num_parameters * sizeof(int));
for(int i = 0; i < it.it_function.num_parameters; i++)
it.it_function.parameters[i] = argv[2 + i].i64;
break;
case TYPE_CODE_METADATA:
it.it_code = IR_TYPE_METADATA;
break;
case TYPE_CODE_LABEL:
it.it_code = IR_TYPE_LABEL;
break;
case TYPE_CODE_OPAQUE:
it.it_code = IR_TYPE_OPAQUE;
break;
case TYPE_CODE_VECTOR:
printf("Vector of %s x %d\n",
type_str_index(iu, argv[1].i64),
(int)argv[0].i64);
// break;
default:
printargs(argv, argc);
parser_error(iu, "%s: Unknown op %d", ctx, op);
}
VECTOR_PUSH_BACK(&iu->iu_types, it);
}
static ALfilter *AllocFilter(ALCcontext *context)
{
ALCdevice *device = context->Device;
FilterSubList *sublist, *subend;
ALfilter *filter = NULL;
ALsizei lidx = 0;
ALsizei slidx;
almtx_lock(&device->FilterLock);
sublist = VECTOR_BEGIN(device->FilterList);
subend = VECTOR_END(device->FilterList);
for(;sublist != subend;++sublist)
{
if(sublist->FreeMask)
{
slidx = CTZ64(sublist->FreeMask);
filter = sublist->Filters + slidx;
break;
}
++lidx;
}
if(UNLIKELY(!filter))
{
const FilterSubList empty_sublist = { 0, NULL };
/* Don't allocate so many list entries that the 32-bit ID could
* overflow...
*/
if(UNLIKELY(VECTOR_SIZE(device->FilterList) >= 1<<25))
{
almtx_unlock(&device->FilterLock);
alSetError(context, AL_OUT_OF_MEMORY, "Too many filters allocated");
return NULL;
}
lidx = (ALsizei)VECTOR_SIZE(device->FilterList);
VECTOR_PUSH_BACK(device->FilterList, empty_sublist);
sublist = &VECTOR_BACK(device->FilterList);
sublist->FreeMask = ~U64(0);
sublist->Filters = al_calloc(16, sizeof(ALfilter)*64);
if(UNLIKELY(!sublist->Filters))
{
VECTOR_POP_BACK(device->FilterList);
almtx_unlock(&device->FilterLock);
alSetError(context, AL_OUT_OF_MEMORY, "Failed to allocate filter batch");
return NULL;
}
slidx = 0;
filter = sublist->Filters + slidx;
}
memset(filter, 0, sizeof(*filter));
InitFilterParams(filter, AL_FILTER_NULL);
/* Add 1 to avoid filter ID 0. */
filter->id = ((lidx<<6) | slidx) + 1;
sublist->FreeMask &= ~(U64(1)<<slidx);
almtx_unlock(&device->FilterLock);
return filter;
}
void ALsoundfont_deleteSoundfont(ALsoundfont *self, ALCdevice *device)
{
ALsfpreset **presets;
ALsizei num_presets;
VECTOR(ALbuffer*) buffers;
ALsizei i;
VECTOR_INIT(buffers);
presets = ExchangePtr((XchgPtr*)&self->Presets, NULL);
num_presets = ExchangeInt(&self->NumPresets, 0);
for(i = 0;i < num_presets;i++)
{
ALsfpreset *preset = presets[i];
ALfontsound **sounds;
ALsizei num_sounds;
ALboolean deleting;
ALsizei j;
sounds = ExchangePtr((XchgPtr*)&preset->Sounds, NULL);
num_sounds = ExchangeInt(&preset->NumSounds, 0);
DeletePreset(device, preset);
preset = NULL;
for(j = 0;j < num_sounds;j++)
DecrementRef(&sounds[j]->ref);
/* Some fontsounds may not be immediately deletable because they're
* linked to another fontsound. When those fontsounds are deleted
* they should become deletable, so use a loop until all fontsounds
* are deleted. */
do {
deleting = AL_FALSE;
for(j = 0;j < num_sounds;j++)
{
if(sounds[j] && ReadRef(&sounds[j]->ref) == 0)
{
ALbuffer *buffer;
deleting = AL_TRUE;
if((buffer=ATOMIC_LOAD(&sounds[j]->Buffer)) != NULL)
{
ALbuffer **iter;
#define MATCH_BUFFER(_i) (buffer == *(_i))
VECTOR_FIND_IF(iter, ALbuffer*, buffers, MATCH_BUFFER);
if(iter == VECTOR_ITER_END(buffers))
VECTOR_PUSH_BACK(buffers, buffer);
#undef MATCH_BUFFER
}
DeleteFontsound(device, sounds[j]);
sounds[j] = NULL;
}
}
} while(deleting);
free(sounds);
}
ALsoundfont_Destruct(self);
free(self);
#define DELETE_BUFFER(iter) do { \
assert(ReadRef(&(*(iter))->ref) == 0); \
DeleteBuffer(device, *(iter)); \
} while(0)
VECTOR_FOR_EACH(ALbuffer*, buffers, DELETE_BUFFER);
#undef DELETE_BUFFER
VECTOR_DEINIT(buffers);
}
