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; }