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 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 HRESULT probe_devices(IMMDeviceEnumerator *devenum, EDataFlow flowdir, vector_DevMap *list)
{
IMMDeviceCollection *coll;
IMMDevice *defdev = NULL;
HRESULT hr;
UINT count;
UINT i;
hr = IMMDeviceEnumerator_EnumAudioEndpoints(devenum, flowdir, DEVICE_STATE_ACTIVE, &coll);
if(FAILED(hr))
{
ERR("Failed to enumerate audio endpoints: 0x%08lx\n", hr);
return hr;
}
count = 0;
hr = IMMDeviceCollection_GetCount(coll, &count);
if(SUCCEEDED(hr) && count > 0)
{
clear_devlist(list);
if(!VECTOR_RESERVE(*list, count+1))
{
IMMDeviceCollection_Release(coll);
return E_OUTOFMEMORY;
}
hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum, flowdir,
eMultimedia, &defdev);
}
if(SUCCEEDED(hr) && defdev != NULL)
add_device(defdev, list);
for(i = 0;i < count;++i)
{
IMMDevice *device;
if(FAILED(IMMDeviceCollection_Item(coll, i, &device)))
continue;
if(device != defdev)
add_device(device, list);
IMMDevice_Release(device);
}
if(defdev) IMMDevice_Release(defdev);
IMMDeviceCollection_Release(coll);
return S_OK;
}
t3_highlight_match_t *t3_highlight_new_match(const t3_highlight_t *highlight) {
t3_highlight_match_t *result = malloc(sizeof(t3_highlight_match_t));
if (result == NULL)
return NULL;
VECTOR_INIT(result->mapping);
if (!VECTOR_RESERVE(result->mapping)) {
free(result);
return NULL;
}
result->highlight = highlight;
memset(&VECTOR_LAST(result->mapping), 0, sizeof(state_mapping_t));
t3_highlight_reset(result, 0);
return result;
}
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_RESERVE(CaptureDevices, 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)
{
al_string_copy_cstr(&dname, DEVNAME_HEAD);
al_string_append_wcstr(&dname, WaveCaps.szPname);
if(count != 0)
{
char str[64];
snprintf(str, sizeof(str), " #%d", count+1);
al_string_append_cstr(&dname, str);
}
count++;
#define MATCH_ENTRY(i) (al_string_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", al_string_get_cstr(dname), i);
}
VECTOR_PUSH_BACK(CaptureDevices, dname);
}
}
static dst_idx_t find_state(t3_highlight_match_t *match, pattern_idx_t highlight_state, pattern_extra_t *extra,
const char *dynamic_line, int dynamic_length, const char *dynamic_pattern)
{
size_t i;
if (highlight_state <= EXIT_STATE) {
dst_idx_t return_state;
for (return_state = match->state; highlight_state < EXIT_STATE && return_state > 0; highlight_state++)
return_state = match->mapping.data[return_state].parent;
return return_state > 0 ? match->mapping.data[return_state].parent : 0;
}
if (highlight_state == NO_CHANGE)
return match->state;
/* Check if the state is already mapped. */
for (i = match->state + 1; i < match->mapping.used; i++) {
if (match->mapping.data[i].parent == match->state && match->mapping.data[i].highlight_state == highlight_state &&
/* Either neither is a match with dynamic back reference, or both are.
For safety we ensure that the found state actually has information
about a dynamic back reference. */
(extra == NULL ||
(extra != NULL && extra->dynamic_name != NULL && match->mapping.data[i].dynamic != NULL &&
dynamic_length == match->mapping.data[i].dynamic->extracted_length &&
memcmp(dynamic_line, match->mapping.data[i].dynamic->extracted, dynamic_length) == 0)))
return i;
}
if (!VECTOR_RESERVE(match->mapping))
return 0;
VECTOR_LAST(match->mapping).parent = match->state;
VECTOR_LAST(match->mapping).highlight_state = highlight_state;
VECTOR_LAST(match->mapping).dynamic = NULL;
if (extra != NULL && extra->dynamic_name != NULL) {
int replace_count = 0, i;
char *pattern, *patptr;
dynamic_state_t *new_dynamic;
for (i = 0; i < dynamic_length; i++) {
if (dynamic_line[i] == 0 || (dynamic_line[i] == '\\' && i + 1 < dynamic_length && dynamic_line[i + 1] == 'E'))
replace_count++;
}
/* Build the following pattern:
(?(DEFINE)(?<%s>\Q%s\E))%s
Note that the pattern between \Q and \E must be escaped for 0 bytes and \E.
*/
/* 22 bytes for fixed prefix and 0 byte, dynamic_length for the matched text,
5 * replace_count for replacing 0 bytes and the \ in any \E's in the matched text,
the length of the name of the pattern to insert and the length of the original
regular expression to be inserted. */
if ((pattern = malloc(21 + dynamic_length + replace_count * 5 + strlen(extra->dynamic_name) + strlen(dynamic_pattern))) == NULL) {
/* Undo VECTOR_RESERVE performed above. */
match->mapping.used--;
return 0;
}
if ((new_dynamic = malloc(sizeof(dynamic_state_t))) == NULL) {
/* Undo VECTOR_RESERVE performed above. */
match->mapping.used--;
free(pattern);
return 0;
}
if ((new_dynamic->extracted = malloc(dynamic_length)) == NULL) {
/* Undo VECTOR_RESERVE performed above. */
match->mapping.used--;
free(new_dynamic);
free(pattern);
return 0;
}
new_dynamic->extracted_length = dynamic_length;
memcpy(new_dynamic->extracted, dynamic_line, dynamic_length);
sprintf(pattern, "(?(DEFINE)(?<%s>\\Q", extra->dynamic_name);
patptr = pattern + strlen(pattern);
for (i = 0; i < dynamic_length; i++) {
if (dynamic_line[i] == 0 || (dynamic_line[i] == '\\' && i + 1 < dynamic_length && dynamic_line[i + 1] == 'E')) {
*patptr++ = '\\';
*patptr++ = 'E';
*patptr++ = '\\';
*patptr++ = dynamic_line[i] == 0 ? '0' : '\\';
*patptr++ = '\\';
*patptr++ = 'Q';
} else {
*patptr++ = dynamic_line[i];
}
}
strcpy(patptr, "\\E))");
strcat(patptr, dynamic_pattern);
if (!_t3_compile_highlight(pattern, &new_dynamic->regex, NULL, match->highlight->flags & ~T3_HIGHLIGHT_VERBOSE_ERROR, NULL)) {
/* Undo VECTOR_RESERVE performed above. */
match->mapping.used--;
free(new_dynamic->extracted);
free(new_dynamic);
free(pattern);
return 0;
}
VECTOR_LAST(match->mapping).dynamic = new_dynamic;
free(pattern);
}
return match->mapping.used - 1;
}
