自学教程：C++ ALCcontext_DecRef函数代码示例

AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint value){    ALCcontext *Context;    ALCdevice  *Device;    ALeffect   *ALEffect;    Context = GetContextRef();    if(!Context) return;    Device = Context->Device;    if((ALEffect=LookupEffect(Device, effect)) == NULL)        alSetError(Context, AL_INVALID_NAME);    else    {        if(param == AL_EFFECT_TYPE)        {            ALboolean isOk = (value == AL_EFFECT_NULL);            ALint i;            for(i = 0;!isOk && EffectList[i].val;i++)            {                if(value == EffectList[i].val &&                   !DisabledEffects[EffectList[i].type])                    isOk = AL_TRUE;            }            if(isOk)                InitEffectParams(ALEffect, value);            else                alSetError(Context, AL_INVALID_VALUE);        }        else        {            /* Call the appropriate handler */            V(ALEffect,setParami)(Context, param, value);        }    }    ALCcontext_DecRef(Context);}

AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *values){    ALCcontext *Context;    ALCdevice  *Device;    ALfilter   *ALFilter;    Context = GetContextRef();    if(!Context) return;    Device = Context->Device;    LockFilterList(Device);    if((ALFilter=LookupFilter(Device, filter)) == NULL)        alSetError(Context, AL_INVALID_NAME, "Invalid filter ID %u", filter);    else    {        /* Call the appropriate handler */        ALfilter_getParamfv(ALFilter, Context, param, values);    }    UnlockFilterList(Device);    ALCcontext_DecRef(Context);}

AL_API void AL_APIENTRY alMidiResetSOFT(void){    ALCdevice *device;    ALCcontext *context;    MidiSynth *synth;    context = GetContextRef();    if(!context) return;    device = context->Device;    synth = device->Synth;    WriteLock(&synth->Lock);    V(synth,setState)(AL_INITIAL);    ALCdevice_Lock(device);    V0(synth,reset)();    ALCdevice_Unlock(device);    WriteUnlock(&synth->Lock);    ALCcontext_DecRef(context);}

AL_API ALint AL_APIENTRY alGetInteger(ALenum pname){    ALCcontext *Context;    ALint value = 0;    Context = GetContextRef();    if(!Context) return 0;    switch(pname)    {        case AL_DOPPLER_FACTOR:            value = (ALint)Context->DopplerFactor;            break;        case AL_DOPPLER_VELOCITY:            value = (ALint)Context->DopplerVelocity;            break;        case AL_DISTANCE_MODEL:            value = (ALint)Context->DistanceModel;            break;        case AL_SPEED_OF_SOUND:            value = (ALint)Context->flSpeedOfSound;            break;        case AL_DEFERRED_UPDATES_SOFT:            value = (ALint)Context->DeferUpdates;            break;        default:            alSetError(Context, AL_INVALID_ENUM);            break;    }    ALCcontext_DecRef(Context);    return value;}

AL_API void AL_APIENTRY alGetPresetivSOFT(ALuint id, ALenum param, ALint *values){    ALCdevice *device;    ALCcontext *context;    ALsfpreset *preset;    ALsizei i;    context = GetContextRef();    if(!context) return;    device = context->Device;    if((preset=LookupPreset(device, id)) == NULL)        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);    switch(param)    {        case AL_MIDI_PRESET_SOFT:            values[0] = preset->Preset;            break;        case AL_MIDI_BANK_SOFT:            values[0] = preset->Bank;            break;        case AL_FONTSOUNDS_SIZE_SOFT:            values[0] = preset->NumSounds;            break;        case AL_FONTSOUNDS_SOFT:            for(i = 0;i < preset->NumSounds;i++)                values[i] = preset->Sounds[i]->id;            break;        default:            SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);    }done:    ALCcontext_DecRef(context);}

AL_API void AL_APIENTRY alMidiSysExSOFT(ALuint64SOFT time, const ALbyte *data, ALsizei size){    ALCdevice *device;    ALCcontext *context;    ALenum err;    context = GetContextRef();    if(!context) return;    if(!data || size < 0)        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);    device = context->Device;    ALCdevice_Lock(device);    err = MidiSynth_insertSysExEvent(device->Synth, time, data, size);    ALCdevice_Unlock(device);    if(err != AL_NO_ERROR)        alSetError(context, err);done:    ALCcontext_DecRef(context);}

AL_API void AL_APIENTRY alMidiStopSOFT(void){    ALCdevice *device;    ALCcontext *context;    MidiSynth *synth;    context = GetContextRef();    if(!context) return;    device = context->Device;    synth = device->Synth;    WriteLock(&synth->Lock);    MidiSynth_setState(synth, AL_STOPPED);    ALCdevice_Lock(device);    V0(synth,stop)();    ALCdevice_Unlock(device);    WriteUnlock(&synth->Lock);    ALCcontext_DecRef(context);}

AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *effectslots){    ALCcontext *Context;    ALeffectslot *slot;    ALsizei i;    Context = GetContextRef();    if(!Context) return;    al_try    {        CHECK_VALUE(Context, n >= 0);        for(i = 0;i < n;i++)        {            if((slot=LookupEffectSlot(Context, effectslots[i])) == NULL)                al_throwerr(Context, AL_INVALID_NAME);            if(slot->ref != 0)                al_throwerr(Context, AL_INVALID_OPERATION);        }        // All effectslots are valid        for(i = 0;i < n;i++)        {            if((slot=RemoveEffectSlot(Context, effectslots[i])) == NULL)                continue;            FreeThunkEntry(slot->id);            RemoveEffectSlotArray(Context, slot);            ALeffectState_Destroy(slot->EffectState);            memset(slot, 0, sizeof(*slot));            al_free(slot);        }    }    al_endtry;    ALCcontext_DecRef(Context);}

AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *effectslots){    ALCcontext *context;    ALeffectslot *slot;    ALsizei i;    context = GetContextRef();    if(!context) return;    LockEffectSlotsWrite(context);    if(!(n >= 0))        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);    for(i = 0;i < n;i++)    {        if((slot=LookupEffectSlot(context, effectslots[i])) == NULL)            SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);        if(ReadRef(&slot->ref) != 0)            SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);    }    // All effectslots are valid    for(i = 0;i < n;i++)    {        if((slot=RemoveEffectSlot(context, effectslots[i])) == NULL)            continue;        FreeThunkEntry(slot->id);        RemoveEffectSlotList(context, slot);        DeinitEffectSlot(slot);        memset(slot, 0, sizeof(*slot));        al_free(slot);    }done:    UnlockEffectSlotsWrite(context);    ALCcontext_DecRef(context);}

AL_API ALvoid AL_APIENTRY alGetIntegerv(ALenum pname,ALint *data){    ALCcontext *Context;    if(data)    {        switch(pname)        {            case AL_DOPPLER_FACTOR:            case AL_DOPPLER_VELOCITY:            case AL_DISTANCE_MODEL:            case AL_SPEED_OF_SOUND:            case AL_DEFERRED_UPDATES_SOFT:                *data = alGetInteger(pname);                return;        }    }    Context = GetContextRef();    if(!Context) return;    if(data)    {        switch(pname)        {            default:                alSetError(Context, AL_INVALID_ENUM);                break;        }    }    else    {        // data is a NULL pointer        alSetError(Context, AL_INVALID_VALUE);    }    ALCcontext_DecRef(Context);}

AL_API ALvoid AL_APIENTRY alGetListeneri(ALenum param, ALint *value){    ALCcontext *Context;    Context = GetContextRef();    if(!Context) return;    al_try    {        CHECK_VALUE(Context, value);        switch(param)        {            case AL_PRIORITY_SLOTS:                *value = (ALint)Context->PrioritySlots;                break;            default:                al_throwerr(Context, AL_INVALID_ENUM);        }    }    al_endtry;    ALCcontext_DecRef(Context);}

AL_API ALboolean AL_APIENTRY alIsEnabled(ALenum capability){    ALCcontext *Context;    ALboolean value=AL_FALSE;    Context = GetContextRef();    if(!Context) return AL_FALSE;    switch(capability)    {        case AL_SOURCE_DISTANCE_MODEL:            value = Context->SourceDistanceModel;            break;        default:            alSetError(Context, AL_INVALID_ENUM);            break;    }    ALCcontext_DecRef(Context);    return value;}

AL_API void AL_APIENTRY alGetBuffer3i(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3){    ALCdevice *device;    ALCcontext *context;    context = GetContextRef();    if(!context) return;    device = context->Device;    if(LookupBuffer(device, buffer) == NULL)        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);    if(!(value1 && value2 && value3))        SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);    switch(param)    {    default:        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);    }done:    ALCcontext_DecRef(context);}

AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *value){    ALCcontext *context;    ALeffectslot *slot;    context = GetContextRef();    if(!context) return;    if((slot=LookupEffectSlot(context, effectslot)) == NULL)        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);    switch(param)    {    case AL_EFFECTSLOT_GAIN:        *value = slot->Gain;        break;    default:        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);    }done:    ALCcontext_DecRef(context);}

AL_API ALvoid AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects){    ALCcontext *context;    ALsizei cur;    context = GetContextRef();    if(!context) return;    if(n < 0)        alSetError(context, AL_INVALID_VALUE, "Generating %d effects", n);    else for(cur = 0;cur < n;cur++)    {        ALeffect *effect = AllocEffect(context);        if(!effect)        {            alDeleteEffects(cur, effects);            break;        }        effects[cur] = effect->id;    }    ALCcontext_DecRef(context);}

AL_API ALboolean AL_APIENTRY alIsEnabled(ALenum capability){    ALCcontext *context;    ALboolean value=AL_FALSE;    context = GetContextRef();    if(!context) return AL_FALSE;    switch(capability)    {    case AL_SOURCE_DISTANCE_MODEL:        value = context->SourceDistanceModel;        break;    default:        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);    }done:    ALCcontext_DecRef(context);    return value;}

AL_API ALboolean AL_APIENTRY alIsExtensionPresent(const ALchar *extName){    ALboolean ret = AL_FALSE;    ALCcontext *Context;    const char *ptr;    size_t len;    Context = GetContextRef();    if(!Context) return AL_FALSE;    al_try    {        CHECK_VALUE(Context, extName);        len = strlen(extName);        ptr = Context->ExtensionList;        while(ptr && *ptr)        {            if(strncasecmp(ptr, extName, len) == 0 &&               (ptr[len] == '/0' || isspace(ptr[len])))            {                ret = AL_TRUE;                break;            }            if((ptr=strchr(ptr, ' ')) != NULL)            {                do {                    ++ptr;                } while(isspace(*ptr));            }        }    }    al_endtry;    ALCcontext_DecRef(Context);    return ret;}

AL_API void AL_APIENTRY alGetListener3i(ALenum eParam, ALint *plValue1, ALint *plValue2, ALint *plValue3){    ALCcontext *Context;    Context = GetContextRef();    if(!Context) return;    if(plValue1 && plValue2 && plValue3)    {        switch (eParam)        {            case AL_POSITION:                LockContext(Context);                *plValue1 = (ALint)Context->Listener.Position[0];                *plValue2 = (ALint)Context->Listener.Position[1];                *plValue3 = (ALint)Context->Listener.Position[2];                UnlockContext(Context);                break;            case AL_VELOCITY:                LockContext(Context);                *plValue1 = (ALint)Context->Listener.Velocity[0];                *plValue2 = (ALint)Context->Listener.Velocity[1];                *plValue3 = (ALint)Context->Listener.Velocity[2];                UnlockContext(Context);                break;            default:                alSetError(Context, AL_INVALID_ENUM);                break;        }    }    else        alSetError(Context, AL_INVALID_VALUE);    ALCcontext_DecRef(Context);}

AL_API void AL_APIENTRY alLoadSoundfontSOFT(ALuint id, size_t(*cb)(ALvoid*,size_t,ALvoid*), ALvoid *user){    ALCdevice *device;    ALCcontext *context;    ALsoundfont *sfont;    Reader reader;    context = GetContextRef();    if(!context) return;    device = context->Device;    if(id == 0)        SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);    if(!(sfont=LookupSfont(device, id)))        SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);    WriteLock(&sfont->Lock);    if(ReadRef(&sfont->ref) != 0)    {        WriteUnlock(&sfont->Lock);        SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);    }    if(sfont->NumPresets > 0)    {        WriteUnlock(&sfont->Lock);        SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);    }    reader.cb = cb;    reader.ptr = user;    reader.error = 0;    loadSf2(&reader, sfont, context);    WriteUnlock(&sfont->Lock);done:    ALCcontext_DecRef(context);}

AL_API ALvoid AL_APIENTRY alDisable(ALenum capability){    ALCcontext *context;    context = GetContextRef();    if(!context) return;    WriteLock(&context->PropLock);    switch(capability)    {    case AL_SOURCE_DISTANCE_MODEL:        context->SourceDistanceModel = AL_FALSE;        break;    default:        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);    }    if(!ATOMIC_LOAD(&context->DeferUpdates, almemory_order_acquire))        UpdateListenerProps(context);done:    WriteUnlock(&context->PropLock);    ALCcontext_DecRef(context);}

AL_API ALvoid AL_APIENTRY alProcessUpdatesSOFT(void){    ALCcontext *context;    context = GetContextRef();    if(!context) return;    if(ExchangeInt(&context->DeferUpdates, AL_FALSE))    {        ALsizei pos;        LockContext(context);        LockUIntMapRead(&context->SourceMap);        for(pos = 0;pos < context->SourceMap.size;pos++)        {            ALsource *Source = context->SourceMap.array[pos].value;            ALenum new_state;            if((Source->state == AL_PLAYING || Source->state == AL_PAUSED) &&               Source->Offset >= 0.0)            {                ReadLock(&Source->queue_lock);                ApplyOffset(Source);                ReadUnlock(&Source->queue_lock);            }            new_state = ExchangeInt(&Source->new_state, AL_NONE);            if(new_state)                SetSourceState(Source, context, new_state);        }        UnlockUIntMapRead(&context->SourceMap);        UnlockContext(context);    }    ALCcontext_DecRef(context);}

AL_API void AL_APIENTRY alListener3i(ALenum param, ALint value1, ALint value2, ALint value3){    ALCcontext *context;    switch(param)    {    case AL_POSITION:    case AL_VELOCITY:        alListener3f(param, (ALfloat)value1, (ALfloat)value2, (ALfloat)value3);        return;    }    context = GetContextRef();    if(!context) return;    switch(param)    {    default:        SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);    }done:    ALCcontext_DecRef(context);}

AL_API ALvoid AL_APIENTRY alListenerf(ALenum eParam, ALfloat flValue){    ALCcontext *Context;    Context = GetContextRef();    if(!Context) return;    switch(eParam)    {        case AL_GAIN:            if(flValue >= 0.0f && isfinite(flValue))            {                Context->Listener.Gain = flValue;                Context->UpdateSources = AL_TRUE;            }            else                alSetError(Context, AL_INVALID_VALUE);            break;        case AL_METERS_PER_UNIT:            if(flValue > 0.0f && isfinite(flValue))            {                Context->Listener.MetersPerUnit = flValue;                Context->UpdateSources = AL_TRUE;            }            else                alSetError(Context, AL_INVALID_VALUE);            break;        default:            alSetError(Context, AL_INVALID_ENUM);            break;    }    ALCcontext_DecRef(Context);}

AL_API ALvoid AL_APIENTRY alDisable(ALenum capability){    ALCcontext *Context;    Context = GetContextRef();    if(!Context) return;    al_try    {        switch(capability)        {            case AL_SOURCE_DISTANCE_MODEL:                Context->SourceDistanceModel = AL_FALSE;                Context->UpdateSources = AL_TRUE;                break;            default:                al_throwerr(Context, AL_INVALID_ENUM);        }    }    al_endtry;    ALCcontext_DecRef(Context);}

AL_API ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters){    ALCcontext *context;    ALsizei cur = 0;    context = GetContextRef();    if(!context) return;    if(!(n >= 0))        alSetError(context, AL_INVALID_VALUE, "Generating %d filters", n);    else for(cur = 0;cur < n;cur++)    {        ALfilter *filter = AllocFilter(context);        if(!filter)        {            alDeleteFilters(cur, filters);            break;        }        filters[cur] = filter->id;    }    ALCcontext_DecRef(context);}