int
_install_keyword(vector keywords, char *string,
int (*handler) (struct config *, vector),
int (*print) (struct config *, char *, int, void *), int unique)
{
int i = 0;
struct keyword *keyword;
/* fetch last keyword */
keyword = VECTOR_SLOT(keywords, VECTOR_SIZE(keywords) - 1);
/* position to last sub level */
for (i = 0; i < sublevel; i++)
keyword =
VECTOR_SLOT(keyword->sub, VECTOR_SIZE(keyword->sub) - 1);
/* First sub level allocation */
if (!keyword->sub)
keyword->sub = vector_alloc();
if (!keyword->sub)
return 1;
/* add new sub keyword */
return keyword_alloc(keyword->sub, string, handler, print, unique);
}
vector
read_value_block(void)
{
char *buf;
int i;
char *str = NULL;
char *dup;
vector vec = NULL;
vector elements = vector_alloc();
if (!elements)
return NULL;
buf = (char *) MALLOC(MAXBUF);
if (!buf)
return NULL;
while (read_line(buf, MAXBUF)) {
vec = alloc_strvec(buf);
if (vec) {
str = VECTOR_SLOT(vec, 0);
if (!strcmp(str, EOB)) {
free_strvec(vec);
break;
}
if (VECTOR_SIZE(vec))
for (i = 0; i < VECTOR_SIZE(vec); i++) {
str = VECTOR_SLOT(vec, i);
dup = (char *) MALLOC(strlen(str) + 1);
if (!dup)
goto out;
memcpy(dup, str, strlen(str));
if (!vector_alloc_slot(elements)) {
free_strvec(vec);
goto out1;
}
vector_set_slot(elements, dup);
}
free_strvec(vec);
}
memset(buf, 0, MAXBUF);
}
FREE(buf);
return elements;
out1:
FREE(dup);
out:
FREE(buf);
return NULL;
}
static inline ALeffectslot *LookupEffectSlot(ALCcontext *context, ALuint id)
{
id--;
if(UNLIKELY(id >= VECTOR_SIZE(context->EffectSlotList)))
return NULL;
return VECTOR_ELEM(context->EffectSlotList, id);
}
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];
}
int
alloc_value_block(vector strvec, void (*alloc_func) (vector))
{
char *buf;
char *str = NULL;
vector vec = NULL;
buf = (char *) MALLOC(MAXBUF);
if (!buf)
return 1;
while (read_line(buf, MAXBUF)) {
vec = alloc_strvec(buf);
if (vec) {
str = VECTOR_SLOT(vec, 0);
if (!strcmp(str, EOB)) {
free_strvec(vec);
break;
}
if (VECTOR_SIZE(vec))
(*alloc_func) (vec);
free_strvec(vec);
}
memset(buf, 0, MAXBUF);
}
FREE(buf);
return 0;
}
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;
}
}
void
alloc_track(list track_list, vector strvec)
{
interface *ifp = NULL;
tracked_if *tip = NULL;
int weight = 0;
char *tracked = VECTOR_SLOT(strvec, 0);
ifp = if_get_by_ifname(tracked);
/* Ignoring if no interface found */
if (!ifp) {
log_message(LOG_INFO, " %s no match, ignoring...", tracked);
return;
}
if (VECTOR_SIZE(strvec) >= 3 &&
!strcmp(VECTOR_SLOT(strvec, 1), "weight")) {
weight = atoi(VECTOR_SLOT(strvec, 2));
if (weight < -254 || weight > 254) {
log_message(LOG_INFO, " %s: weight must be between "
"[-254..254] inclusive. Ignoring...", tracked);
weight = 0;
}
}
tip = (tracked_if *) MALLOC(sizeof (tracked_if));
tip->ifp = ifp;
tip->weight = weight;
list_add(track_list, tip);
}
struct keyword *
find_keyword(vector keywords, vector v, char * name)
{
struct keyword *keyword;
int i;
int len;
if (!name || !keywords)
return NULL;
if (!v)
v = keywords;
len = strlen(name);
for (i = 0; i < VECTOR_SIZE(v); i++) {
keyword = VECTOR_SLOT(v, i);
if ((strlen(keyword->string) == len) &&
!strcmp(keyword->string, name))
return keyword;
if (keyword->sub) {
keyword = find_keyword(keywords, keyword->sub, name);
if (keyword)
return keyword;
}
}
return NULL;
}
void main(int argc, char * argv[]){
glutInit(&argc, argv);
Vector3D *v1 = new Vector3D(2, 3, 5);
Vector3D *v2 = new Vector3D(4, 2, 1);
printf("Dot product: %f\n", v1->dotProduct(*v2));
printf("Magnitude v1: %f\n", v1->magnitude());
printf("Magnitude v2: %f\n", v2->magnitude());
printf("Angle between: %f\n", v1->theta(*v2));
VERTEX3D v[] = { { 0, 0, 0 }, { 1, 0, 0 }, { 0, 1, 0 } };
LINE l[] = { { 0, 1 }, { 1, 2 }, { 0, 2 } };
//Step 1: Initialize GLUT
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutInitWindowSize(800, 600);
//Step 2: Create window
mainWindow = glutCreateWindow("3D Solar System");
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
renderWindow();
Object3D *cube = new Object3D(v, VECTOR_SIZE(v));
Object3D *line = new Object3D(v, l, VECTOR_SIZE(v), VECTOR_SIZE(l));
RenderManager *rmg = RenderManager::getInstance();
rmg->RegisterObject(cube);
rmg->RegisterObject(line);
//Step 3: Handlers Functions
glutDisplayFunc(Display);
glutReshapeFunc(Reshape);
glutIdleFunc(Display);
glutKeyboardFunc(keyPressed); // Tell GLUT to use the method "keyPressed" for key presses
//glutKeyboardFunc(keyUp);
glutMainLoop();
}
static ALCenum qsa_open_playback(ALCdevice* device, const ALCchar* deviceName)
{
qsa_data *data;
int card, dev;
int status;
data = (qsa_data*)calloc(1, sizeof(qsa_data));
if(data == NULL)
return ALC_OUT_OF_MEMORY;
if(!deviceName)
deviceName = qsaDevice;
if(strcmp(deviceName, qsaDevice) == 0)
status = snd_pcm_open_preferred(&data->pcmHandle, &card, &dev, SND_PCM_OPEN_PLAYBACK);
else
{
const DevMap *iter;
if(VECTOR_SIZE(DeviceNameMap) == 0)
deviceList(SND_PCM_CHANNEL_PLAYBACK, &DeviceNameMap);
#define MATCH_DEVNAME(iter) ((iter)->name && strcmp(deviceName, (iter)->name)==0)
VECTOR_FIND_IF(iter, const DevMap, DeviceNameMap, MATCH_DEVNAME);
#undef MATCH_DEVNAME
if(iter == VECTOR_ITER_END(DeviceNameMap))
{
free(data);
return ALC_INVALID_DEVICE;
}
status = snd_pcm_open(&data->pcmHandle, iter->card, iter->dev, SND_PCM_OPEN_PLAYBACK);
}
if(status < 0)
{
free(data);
return ALC_INVALID_DEVICE;
}
data->audio_fd = snd_pcm_file_descriptor(data->pcmHandle, SND_PCM_CHANNEL_PLAYBACK);
if(data->audio_fd < 0)
{
snd_pcm_close(data->pcmHandle);
free(data);
return ALC_INVALID_DEVICE;
}
al_string_copy_cstr(&device->DeviceName, deviceName);
device->ExtraData = data;
return ALC_NO_ERROR;
}
/* Use the mount_options list to parse options into flags.
* Also return list of unrecognized options if unrecognized!=NULL */
static int parse_mount_options(char *options, char **unrecognized)
{
int flags = MS_SILENT;
// Loop through options
for (;;) {
int i;
char *comma = strchr(options, ',');
if (comma) *comma = 0;
// Find this option in mount_options
for (i = 0; i < VECTOR_SIZE(mount_options); i++) {
if (!strcasecmp(mount_options[i].name, options)) {
long fl = mount_options[i].flags;
if (fl < 0) flags &= fl;
else flags |= fl;
break;
}
}
// If unrecognized not NULL, append unrecognized mount options */
if (unrecognized && i == VECTOR_SIZE(mount_options)) {
// Add it to strflags, to pass on to kernel
i = *unrecognized ? strlen(*unrecognized) : 0;
*unrecognized = xrealloc(*unrecognized, i+strlen(options)+2);
// Comma separated if it's not the first one
if (i) (*unrecognized)[i++] = ',';
strcpy((*unrecognized)+i, options);
}
// Advance to next option, or finish
if (comma) {
*comma = ',';
options = ++comma;
} else break;
}
return flags;
}
static inline ALeffect *LookupEffect(ALCdevice *device, ALuint id)
{
EffectSubList *sublist;
ALuint lidx = (id-1) >> 6;
ALsizei slidx = (id-1) & 0x3f;
if(UNLIKELY(lidx >= VECTOR_SIZE(device->EffectList)))
return NULL;
sublist = &VECTOR_ELEM(device->EffectList, lidx);
if(UNLIKELY(sublist->FreeMask & (U64(1)<<slidx)))
return NULL;
return sublist->Effects + slidx;
}
int
process_stream(vector keywords)
{
int i;
int r = 0;
struct keyword *keyword;
char *str;
char *buf;
vector strvec;
buf = MALLOC(MAXBUF);
if (!buf)
return 1;
while (read_line(buf, MAXBUF)) {
strvec = alloc_strvec(buf);
memset(buf,0, MAXBUF);
if (!strvec)
continue;
str = VECTOR_SLOT(strvec, 0);
if (!strcmp(str, EOB) && kw_level > 0) {
free_strvec(strvec);
break;
}
for (i = 0; i < VECTOR_SIZE(keywords); i++) {
keyword = VECTOR_SLOT(keywords, i);
if (!strcmp(keyword->string, str)) {
if (keyword->handler)
r += (*keyword->handler) (strvec);
if (keyword->sub) {
kw_level++;
r += process_stream(keyword->sub);
kw_level--;
}
break;
}
}
free_strvec(strvec);
}
FREE(buf);
return r;
}
void *
set_value(vector strvec)
{
char *str = VECTOR_SLOT(strvec, 1);
int size = strlen(str);
int i = 0;
int len = 0;
char *alloc = NULL;
char *tmp;
if (*str == '"') {
for (i = 2; i < VECTOR_SIZE(strvec); i++) {
str = VECTOR_SLOT(strvec, i);
len += strlen(str);
if (!alloc)
alloc =
(char *) MALLOC(sizeof (char *) *
(len + 1));
else {
alloc =
REALLOC(alloc, sizeof (char *) * (len + 1));
tmp = VECTOR_SLOT(strvec, i-1);
if (alloc && *str != '"' && *tmp != '"')
strncat(alloc, " ", 1);
}
if (alloc && i != VECTOR_SIZE(strvec)-1)
strncat(alloc, str, strlen(str));
}
} else {
alloc = MALLOC(sizeof (char *) * (size + 1));
if (alloc)
memcpy(alloc, str, size);
}
return alloc;
}
void
free_strvec(vector strvec)
{
unsigned int i;
char *str;
if (!strvec)
return;
for (i = 0; i < VECTOR_SIZE(strvec); i++)
if ((str = VECTOR_SLOT(strvec, i)) != NULL)
FREE(str);
vector_free(strvec);
}
void
dump_strvec(vector strvec)
{
int i;
char *str;
if (!strvec)
return;
printf("String Vector : ");
for (i = 0; i < VECTOR_SIZE(strvec); i++) {
str = VECTOR_SLOT(strvec, i);
printf("[%i]=%s ", i, str);
}
printf("\n");
}
void
free_keywords(vector keywords)
{
struct keyword *keyword;
int i;
if (!keywords)
return;
for (i = 0; i < VECTOR_SIZE(keywords); i++) {
keyword = VECTOR_SLOT(keywords, i);
if (keyword->sub)
free_keywords(keyword->sub);
FREE(keyword);
}
vector_free(keywords);
}
void
dump_strvec(vector strvec)
{
unsigned int i;
char *str;
if (!strvec)
return;
log_print("string vector : ");
for (i = 0; i < VECTOR_SIZE(strvec); i++) {
str = VECTOR_SLOT(strvec, i);
log_print("[%i]=%s ", i, str);
}
log_print("\n");
}
/* Set instances group pointer */
void
vrrp_sync_set_group(vrrp_sgroup *vgroup)
{
vrrp_rt *vrrp;
char *str;
int i;
for (i = 0; i < VECTOR_SIZE(vgroup->iname); i++) {
str = VECTOR_SLOT(vgroup->iname, i);
vrrp = vrrp_get_instance(str);
if (vrrp) {
if (LIST_ISEMPTY(vgroup->index_list))
vgroup->index_list = alloc_list(NULL, NULL);
list_add(vgroup->index_list, vrrp);
vrrp->sync = vgroup;
}
}
}
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 void
vrrp_vip_handler(vector strvec)
{
vrrp_rt *vrrp = LIST_TAIL_DATA(vrrp_data->vrrp);
char *buf;
char *str = NULL;
vector vec = NULL;
int nbvip = 0;
buf = (char *) MALLOC(MAXBUF);
while (read_line(buf, MAXBUF)) {
vec = alloc_strvec(buf);
if (vec) {
str = VECTOR_SLOT(vec, 0);
if (!strcmp(str, EOB)) {
free_strvec(vec);
break;
}
if (VECTOR_SIZE(vec)) {
nbvip++;
if (nbvip > VRRP_MAX_VIP) {
log_message(LOG_INFO,
"VRRP_Instance(%s) "
"trunc to the first %d VIPs.",
vrrp->iname, VRRP_MAX_VIP);
log_message(LOG_INFO,
" => Declare others VIPs into"
" the excluded vip block");
} else
alloc_vrrp_vip(vec);
}
free_strvec(vec);
}
memset(buf, 0, MAXBUF);
}
FREE(buf);
}
void
alloc_track_script(list track_list, vector strvec)
{
vrrp_script *vsc = NULL;
tracked_sc *tsc = NULL;
int weight = 0;
char *tracked = VECTOR_SLOT(strvec, 0);
vsc = find_script_by_name(tracked);
/* Ignoring if no interface found */
if (!vsc) {
log_message(LOG_INFO, " %s no match, ignoring...", tracked);
return;
}
/* default weight */
weight = vsc->weight;
if (VECTOR_SIZE(strvec) >= 3 &&
!strcmp(VECTOR_SLOT(strvec, 1), "weight")) {
weight = atoi(VECTOR_SLOT(strvec, 2));
if (weight < -254 || weight > 254) {
weight = vsc->weight;
log_message(LOG_INFO, " %s: weight must be between [-254..254]"
" inclusive, ignoring...",
tracked);
}
}
tsc = (tracked_sc *) MALLOC(sizeof (tracked_sc));
tsc->scr = vsc;
tsc->weight = weight;
vsc->inuse++;
list_add(track_list, tsc);
}
static ALCenum WinMMOpenPlayback(ALCdevice *Device, const ALCchar *deviceName)
{
WinMMData *data = NULL;
const al_string *iter, *end;
UINT DeviceID;
MMRESULT res;
if(VECTOR_SIZE(PlaybackDevices) == 0)
ProbePlaybackDevices();
// Find the Device ID matching the deviceName if valid
iter = VECTOR_ITER_BEGIN(PlaybackDevices);
end = VECTOR_ITER_END(PlaybackDevices);
for(; iter != end; iter++)
{
if(!al_string_empty(*iter) &&
(!deviceName || al_string_cmp_cstr(*iter, deviceName) == 0))
{
DeviceID = (UINT)(iter - VECTOR_ITER_BEGIN(PlaybackDevices));
break;
}
}
if(iter == end)
return ALC_INVALID_VALUE;
data = calloc(1, sizeof(*data));
if(!data)
return ALC_OUT_OF_MEMORY;
Device->ExtraData = data;
retry_open:
memset(&data->Format, 0, sizeof(WAVEFORMATEX));
if(Device->FmtType == DevFmtFloat)
{
data->Format.wFormatTag = WAVE_FORMAT_IEEE_FLOAT;
data->Format.wBitsPerSample = 32;
}
else
{
data->Format.wFormatTag = WAVE_FORMAT_PCM;
if(Device->FmtType == DevFmtUByte || Device->FmtType == DevFmtByte)
data->Format.wBitsPerSample = 8;
else
data->Format.wBitsPerSample = 16;
}
data->Format.nChannels = ((Device->FmtChans == DevFmtMono) ? 1 : 2);
data->Format.nBlockAlign = data->Format.wBitsPerSample *
data->Format.nChannels / 8;
data->Format.nSamplesPerSec = Device->Frequency;
data->Format.nAvgBytesPerSec = data->Format.nSamplesPerSec *
data->Format.nBlockAlign;
data->Format.cbSize = 0;
if((res=waveOutOpen(&data->WaveHandle.Out, DeviceID, &data->Format, (DWORD_PTR)&WaveOutProc, (DWORD_PTR)Device, CALLBACK_FUNCTION)) != MMSYSERR_NOERROR)
{
if(Device->FmtType == DevFmtFloat)
{
Device->FmtType = DevFmtShort;
goto retry_open;
}
ERR("waveOutOpen failed: %u\n", res);
goto failure;
}
al_string_copy(&Device->DeviceName, VECTOR_ELEM(PlaybackDevices, DeviceID));
return ALC_NO_ERROR;
failure:
if(data->WaveHandle.Out)
waveOutClose(data->WaveHandle.Out);
free(data);
Device->ExtraData = NULL;
return ALC_INVALID_VALUE;
}
static ALCenum WinMMOpenCapture(ALCdevice *Device, const ALCchar *deviceName)
{
const al_string *iter, *end;
ALbyte *BufferData = NULL;
DWORD CapturedDataSize;
WinMMData *data = NULL;
ALint BufferSize;
UINT DeviceID;
MMRESULT res;
ALuint i;
if(VECTOR_SIZE(CaptureDevices) == 0)
ProbeCaptureDevices();
// Find the Device ID matching the deviceName if valid
iter = VECTOR_ITER_BEGIN(CaptureDevices);
end = VECTOR_ITER_END(CaptureDevices);
for(; iter != end; iter++)
{
if(!al_string_empty(*iter) &&
(!deviceName || al_string_cmp_cstr(*iter, deviceName) == 0))
{
DeviceID = (UINT)(iter - VECTOR_ITER_BEGIN(CaptureDevices));
break;
}
}
if(iter == end)
return ALC_INVALID_VALUE;
switch(Device->FmtChans)
{
case DevFmtMono:
case DevFmtStereo:
break;
case DevFmtQuad:
case DevFmtX51:
case DevFmtX51Side:
case DevFmtX61:
case DevFmtX71:
return ALC_INVALID_ENUM;
}
switch(Device->FmtType)
{
case DevFmtUByte:
case DevFmtShort:
case DevFmtInt:
case DevFmtFloat:
break;
case DevFmtByte:
case DevFmtUShort:
case DevFmtUInt:
return ALC_INVALID_ENUM;
}
data = calloc(1, sizeof(*data));
if(!data)
return ALC_OUT_OF_MEMORY;
Device->ExtraData = data;
memset(&data->Format, 0, sizeof(WAVEFORMATEX));
data->Format.wFormatTag = ((Device->FmtType == DevFmtFloat) ?
WAVE_FORMAT_IEEE_FLOAT : WAVE_FORMAT_PCM);
data->Format.nChannels = ChannelsFromDevFmt(Device->FmtChans);
data->Format.wBitsPerSample = BytesFromDevFmt(Device->FmtType) * 8;
data->Format.nBlockAlign = data->Format.wBitsPerSample *
data->Format.nChannels / 8;
data->Format.nSamplesPerSec = Device->Frequency;
data->Format.nAvgBytesPerSec = data->Format.nSamplesPerSec *
data->Format.nBlockAlign;
data->Format.cbSize = 0;
if((res=waveInOpen(&data->WaveHandle.In, DeviceID, &data->Format, (DWORD_PTR)&WaveInProc, (DWORD_PTR)Device, CALLBACK_FUNCTION)) != MMSYSERR_NOERROR)
{
ERR("waveInOpen failed: %u\n", res);
goto failure;
}
// Allocate circular memory buffer for the captured audio
CapturedDataSize = Device->UpdateSize*Device->NumUpdates;
// Make sure circular buffer is at least 100ms in size
if(CapturedDataSize < (data->Format.nSamplesPerSec / 10))
CapturedDataSize = data->Format.nSamplesPerSec / 10;
data->Ring = CreateRingBuffer(data->Format.nBlockAlign, CapturedDataSize);
if(!data->Ring)
goto failure;
InitRef(&data->WaveBuffersCommitted, 0);
// Create 4 Buffers of 50ms each
BufferSize = data->Format.nAvgBytesPerSec / 20;
BufferSize -= (BufferSize % data->Format.nBlockAlign);
BufferData = calloc(4, BufferSize);
if(!BufferData)
goto failure;
for(i = 0; i < 4; i++)
{
memset(&data->WaveBuffer[i], 0, sizeof(WAVEHDR));
data->WaveBuffer[i].dwBufferLength = BufferSize;
data->WaveBuffer[i].lpData = ((i==0) ? (CHAR*)BufferData :
(data->WaveBuffer[i-1].lpData +
data->WaveBuffer[i-1].dwBufferLength));
data->WaveBuffer[i].dwFlags = 0;
data->WaveBuffer[i].dwLoops = 0;
waveInPrepareHeader(data->WaveHandle.In, &data->WaveBuffer[i], sizeof(WAVEHDR));
waveInAddBuffer(data->WaveHandle.In, &data->WaveBuffer[i], sizeof(WAVEHDR));
IncrementRef(&data->WaveBuffersCommitted);
}
if(althrd_create(&data->thread, CaptureThreadProc, Device) != althrd_success)
goto failure;
al_string_copy(&Device->DeviceName, VECTOR_ELEM(CaptureDevices, DeviceID));
return ALC_NO_ERROR;
failure:
if(BufferData)
{
for(i = 0; i < 4; i++)
waveInUnprepareHeader(data->WaveHandle.In, &data->WaveBuffer[i], sizeof(WAVEHDR));
free(BufferData);
}
if(data->Ring)
DestroyRingBuffer(data->Ring);
if(data->WaveHandle.In)
waveInClose(data->WaveHandle.In);
free(data);
Device->ExtraData = NULL;
return ALC_INVALID_VALUE;
}
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;
}
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 ALCenum qsa_open_capture(ALCdevice* device, const ALCchar* deviceName)
{
qsa_data *data;
int card, dev;
int format=-1;
int status;
data=(qsa_data*)calloc(1, sizeof(qsa_data));
if (data==NULL)
{
return ALC_OUT_OF_MEMORY;
}
if(!deviceName)
deviceName = qsaDevice;
if(strcmp(deviceName, qsaDevice) == 0)
status = snd_pcm_open_preferred(&data->pcmHandle, &card, &dev, SND_PCM_OPEN_CAPTURE);
else
{
const DevMap *iter;
if(VECTOR_SIZE(CaptureNameMap) == 0)
deviceList(SND_PCM_CHANNEL_CAPTURE, &CaptureNameMap);
#define MATCH_DEVNAME(iter) ((iter)->name && strcmp(deviceName, (iter)->name)==0)
VECTOR_FIND_IF(iter, const DevMap, CaptureNameMap, MATCH_DEVNAME);
#undef MATCH_DEVNAME
if(iter == VECTOR_ITER_END(CaptureNameMap))
{
free(data);
return ALC_INVALID_DEVICE;
}
status = snd_pcm_open(&data->pcmHandle, iter->card, iter->dev, SND_PCM_OPEN_CAPTURE);
}
if(status < 0)
{
free(data);
return ALC_INVALID_DEVICE;
}
data->audio_fd = snd_pcm_file_descriptor(data->pcmHandle, SND_PCM_CHANNEL_CAPTURE);
if(data->audio_fd < 0)
{
snd_pcm_close(data->pcmHandle);
free(data);
return ALC_INVALID_DEVICE;
}
al_string_copy_cstr(&device->DeviceName, deviceName);
device->ExtraData = data;
switch (device->FmtType)
{
case DevFmtByte:
format=SND_PCM_SFMT_S8;
break;
case DevFmtUByte:
format=SND_PCM_SFMT_U8;
break;
case DevFmtShort:
format=SND_PCM_SFMT_S16_LE;
break;
case DevFmtUShort:
format=SND_PCM_SFMT_U16_LE;
break;
case DevFmtInt:
format=SND_PCM_SFMT_S32_LE;
break;
case DevFmtUInt:
format=SND_PCM_SFMT_U32_LE;
break;
case DevFmtFloat:
format=SND_PCM_SFMT_FLOAT_LE;
break;
}
/* we actually don't want to block on reads */
snd_pcm_nonblock_mode(data->pcmHandle, 1);
/* Disable mmap to control data transfer to the audio device */
snd_pcm_plugin_set_disable(data->pcmHandle, PLUGIN_DISABLE_MMAP);
/* configure a sound channel */
memset(&data->cparams, 0, sizeof(data->cparams));
data->cparams.mode=SND_PCM_MODE_BLOCK;
data->cparams.channel=SND_PCM_CHANNEL_CAPTURE;
data->cparams.start_mode=SND_PCM_START_GO;
data->cparams.stop_mode=SND_PCM_STOP_STOP;
data->cparams.buf.block.frag_size=device->UpdateSize*
ChannelsFromDevFmt(device->FmtChans)*BytesFromDevFmt(device->FmtType);
data->cparams.buf.block.frags_max=device->NumUpdates;
data->cparams.buf.block.frags_min=device->NumUpdates;
data->cparams.format.interleave=1;
data->cparams.format.rate=device->Frequency;
data->cparams.format.voices=ChannelsFromDevFmt(device->FmtChans);
data->cparams.format.format=format;
if(snd_pcm_plugin_params(data->pcmHandle, &data->cparams) < 0)
{
snd_pcm_close(data->pcmHandle);
free(data);
device->ExtraData=NULL;
return ALC_INVALID_VALUE;
}
return ALC_NO_ERROR;
}
void aluInitRenderer(ALCdevice *device, ALint hrtf_id, enum HrtfRequestMode hrtf_appreq, enum HrtfRequestMode hrtf_userreq)
{
const char *mode;
bool headphones;
int bs2blevel;
size_t i;
device->Hrtf = NULL;
al_string_clear(&device->Hrtf_Name);
device->Render_Mode = NormalRender;
memset(&device->Dry.Ambi, 0, sizeof(device->Dry.Ambi));
device->Dry.CoeffCount = 0;
device->Dry.NumChannels = 0;
if(device->FmtChans != DevFmtStereo)
{
ALuint speakermap[MAX_OUTPUT_CHANNELS];
const char *devname, *layout = NULL;
AmbDecConf conf, *pconf = NULL;
if(hrtf_appreq == Hrtf_Enable)
device->Hrtf_Status = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
ambdec_init(&conf);
devname = al_string_get_cstr(device->DeviceName);
switch(device->FmtChans)
{
case DevFmtQuad: layout = "quad"; break;
case DevFmtX51: layout = "surround51"; break;
case DevFmtX51Rear: layout = "surround51rear"; break;
case DevFmtX61: layout = "surround61"; break;
case DevFmtX71: layout = "surround71"; break;
/* Mono, Stereo, and B-Fornat output don't use custom decoders. */
case DevFmtMono:
case DevFmtStereo:
case DevFmtBFormat3D:
break;
}
if(layout)
{
const char *fname;
if(ConfigValueStr(devname, "decoder", layout, &fname))
{
if(!ambdec_load(&conf, fname))
ERR("Failed to load layout file %s\n", fname);
else
{
if(conf.ChanMask > 0xffff)
ERR("Unsupported channel mask 0x%04x (max 0xffff)\n", conf.ChanMask);
else
{
if(MakeSpeakerMap(device, &conf, speakermap))
pconf = &conf;
}
}
}
}
if(pconf && GetConfigValueBool(devname, "decoder", "hq-mode", 0))
{
if(!device->AmbiDecoder)
device->AmbiDecoder = bformatdec_alloc();
}
else
{
bformatdec_free(device->AmbiDecoder);
device->AmbiDecoder = NULL;
}
if(!pconf)
InitPanning(device);
else if(device->AmbiDecoder)
InitHQPanning(device, pconf, speakermap);
else
InitCustomPanning(device, pconf, speakermap);
ambdec_deinit(&conf);
return;
}
bformatdec_free(device->AmbiDecoder);
device->AmbiDecoder = NULL;
headphones = device->IsHeadphones;
if(device->Type != Loopback)
{
const char *mode;
if(ConfigValueStr(al_string_get_cstr(device->DeviceName), NULL, "stereo-mode", &mode))
{
if(strcasecmp(mode, "headphones") == 0)
headphones = true;
else if(strcasecmp(mode, "speakers") == 0)
headphones = false;
else if(strcasecmp(mode, "auto") != 0)
ERR("Unexpected stereo-mode: %s\n", mode);
}
}
if(hrtf_userreq == Hrtf_Default)
{
bool usehrtf = (headphones && hrtf_appreq != Hrtf_Disable) ||
(hrtf_appreq == Hrtf_Enable);
if(!usehrtf) goto no_hrtf;
device->Hrtf_Status = ALC_HRTF_ENABLED_SOFT;
if(headphones && hrtf_appreq != Hrtf_Disable)
device->Hrtf_Status = ALC_HRTF_HEADPHONES_DETECTED_SOFT;
}
else
{
if(hrtf_userreq != Hrtf_Enable)
{
if(hrtf_appreq == Hrtf_Enable)
device->Hrtf_Status = ALC_HRTF_DENIED_SOFT;
goto no_hrtf;
}
device->Hrtf_Status = ALC_HRTF_REQUIRED_SOFT;
}
if(VECTOR_SIZE(device->Hrtf_List) == 0)
{
VECTOR_DEINIT(device->Hrtf_List);
device->Hrtf_List = EnumerateHrtf(device->DeviceName);
}
if(hrtf_id >= 0 && (size_t)hrtf_id < VECTOR_SIZE(device->Hrtf_List))
{
const HrtfEntry *entry = &VECTOR_ELEM(device->Hrtf_List, hrtf_id);
if(GetHrtfSampleRate(entry->hrtf) == device->Frequency)
{
device->Hrtf = entry->hrtf;
al_string_copy(&device->Hrtf_Name, entry->name);
}
}
for(i = 0;!device->Hrtf && i < VECTOR_SIZE(device->Hrtf_List);i++)
{
const HrtfEntry *entry = &VECTOR_ELEM(device->Hrtf_List, i);
if(GetHrtfSampleRate(entry->hrtf) == device->Frequency)
{
device->Hrtf = entry->hrtf;
al_string_copy(&device->Hrtf_Name, entry->name);
}
}
if(device->Hrtf)
{
device->Render_Mode = HrtfRender;
if(ConfigValueStr(al_string_get_cstr(device->DeviceName), NULL, "hrtf-mode", &mode))
{
if(strcasecmp(mode, "full") == 0)
device->Render_Mode = HrtfRender;
else if(strcasecmp(mode, "basic") == 0)
device->Render_Mode = NormalRender;
else
ERR("Unexpected hrtf-mode: %s\n", mode);
}
TRACE("HRTF enabled, \"%s\"\n", al_string_get_cstr(device->Hrtf_Name));
InitHrtfPanning(device);
return;
}
device->Hrtf_Status = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
no_hrtf:
TRACE("HRTF disabled\n");
bs2blevel = ((headphones && hrtf_appreq != Hrtf_Disable) ||
(hrtf_appreq == Hrtf_Enable)) ? 5 : 0;
if(device->Type != Loopback)
ConfigValueInt(al_string_get_cstr(device->DeviceName), NULL, "cf_level", &bs2blevel);
if(bs2blevel > 0 && bs2blevel <= 6)
{
device->Bs2b = al_calloc(16, sizeof(*device->Bs2b));
bs2b_set_params(device->Bs2b, bs2blevel, device->Frequency);
device->Render_Mode = StereoPair;
TRACE("BS2B enabled\n");
InitPanning(device);
return;
}
TRACE("BS2B disabled\n");
device->Render_Mode = NormalRender;
if(ConfigValueStr(al_string_get_cstr(device->DeviceName), NULL, "stereo-panning", &mode))
{
if(strcasecmp(mode, "paired") == 0)
device->Render_Mode = StereoPair;
else if(strcasecmp(mode, "uhj") != 0)
ERR("Unexpected stereo-panning: %s\n", mode);
}
if(device->Render_Mode == NormalRender)
{
device->Uhj_Encoder = al_calloc(16, sizeof(Uhj2Encoder));
TRACE("UHJ enabled\n");
InitUhjPanning(device);
return;
}
TRACE("UHJ disabled\n");
InitPanning(device);
}
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);
}
