Function UpdateInternal

engine/sound/src/sound_openal.cpp:1264–1343

    }

    static Result UpdateInternal(SoundSystem* sound)
    {
        DM_PROFILE(__FUNCTION__);

        if (IsAudioInterrupted())
        {
            // We can't play sounds when Audio was interrupted by OS event (Phone call, Alarm etc)
            return RESULT_OK;
        }

        DM_MUTEX_OPTIONAL_SCOPED_LOCK(sound->m_Mutex);

        // feed buffers for active streams
        uint16_t i = 0;
        while (i < sound->m_InstancesActive.Size()) {
            uint16_t instance_index = sound->m_InstancesActive[i];
            SoundInstance &instance = sound->m_Instances[instance_index];
            ALuint source = sound->m_Sources[instance.m_SourceIndex];
            if (instance.m_BufferCount) {
                // drain any processed buffers
                ALuint source = sound->m_Sources[instance.m_SourceIndex];
                ALint buffers_processed = 0;
                alGetSourcei(source, AL_BUFFERS_PROCESSED,
                            &buffers_processed);
                assert(buffers_processed <= instance.m_BufferCount);
                while (buffers_processed) {
                    ALuint buffer;
                    alSourceUnqueueBuffers(source, 1, &buffer);
                    checkForAlErrors("alSourceUnqueueBuffers");
                    --buffers_processed;
                    --instance.m_BufferCount;
                }
            }
            ALenum state;
            alGetSourcei(source, AL_SOURCE_STATE, &state);
            if (instance.m_Playing) {
                // feed new buffers and handle looping
                while (instance.m_BufferCount < sound->m_BuffersPerSource) {
                    dmSoundCodec::Result r = Feed(&instance);
                    if (r == dmSoundCodec::RESULT_OK) {
                        // noop
                    } else if (r == dmSoundCodec::RESULT_END_OF_STREAM) {
                        break;
                    } else {
                        // error
                        dmLogError("AL source feed error: %i\n", (int)r);
                        instance.m_Playing = false;
                        break;
                    }
                }
                if (instance.m_BufferCount && state != AL_PLAYING) {
                    alSourcePlay(source);
                    checkForAlErrors("alSourcePlay");
                }
            } else {
                // if we're no longer playing this instance, we still need to wait for its buffers to finish
                if (state != AL_PLAYING) {
                    // setting AL_BUFFER to AL_NONE will unqueue any buffers