Adaptive framerate limiter

sf::Clock frameClock;

double desiredRefreshRate = 60.0;
double frameSkipPreventionPenalty = desiredRefreshRate / 300;
double definiteFramerateTarget = desiredRefreshRate - frameSkipPreventionPenalty;
const sf::Time minAdaptiveFrameTimeMicros = sf::microseconds((sf::Int64) (1000000.0f / (definiteFramerateTarget * 2.0)));
const sf::Time maxAdaptiveFrameTimeMicros = sf::microseconds((sf::Int64) (1000000.0f / (definiteFramerateTarget * 0.5)));

const sf::Time idealFrameTime = sf::microseconds((sf::Int64) (1000000.0 / definiteFramerateTarget));

// Frame time backlog
const int frameTimeMemorySize = (int) (desiredRefreshRate * 1.5 + 2); // Adapt within 1.5 seconds
sf::Int64* frameTimeMemoryMicros = (sf::Int64*) malloc(sizeof(sf::Int64) * frameTimeMemorySize);

// Start filled with ideal frame time
std::fill_n(frameTimeMemoryMicros, frameTimeMemorySize, idealFrameTime.asMicroseconds());
sf::Int64 frameTimeMemoryMicrosSum = frameTimeMemorySize * idealFrameTime.asMicroseconds();

int frameTimeOldestMemorySlot = 0;
sf::Int64 recentMicros;
sf::Int64 oldMicros;

sf::Time assumedFrameTime = idealFrameTime;
sf::Time elapsedFrameTime;
sf::Time frameTime;
sf::Time sceneTime;
sf::Time previousSceneTime;
sf::Time intendedSleepDuration;
sf::Time afterSleepTime;
sf::Time actualSleepDuration;
sf::Time oversleepDuration;
sf::Time correctiveFrameTime;

while (window->isOpen()) {

    frameClock.restart();

    sceneTime = sceneClock.getElapsedTime();
    frameTime = sceneTime - previousSceneTime;

    if (frameTime < sf::Time::Zero) { // The clock was reset
        frameTime = sceneTime;
        previousSceneTime = sf::Time::Zero;
    } else {
        previousSceneTime = sceneTime;
    }

    if (frameTime > sf::Time::Zero) {
        parseInput(frameTime);
        renderScene(sceneTime);
        window->display(); // Swap buffers
        glFlush();
    }

    if (definiteFramerateTarget > 0.0) { // Use our method?

        elapsedFrameTime = frameClock.getElapsedTime();
        intendedSleepDuration = assumedFrameTime - elapsedFrameTime;

        // There is time to sleep
        if (intendedSleepDuration > sf::Time::Zero) {

            //timeBeginPeriod(1); // Setting this at program start gives better accuracy
            sf::sleep(intendedSleepDuration);
            //timeEndPeriod(1);

            afterSleepTime = frameClock.getElapsedTime();
            actualSleepDuration = afterSleepTime - elapsedFrameTime;
            oversleepDuration = actualSleepDuration - intendedSleepDuration;
            correctiveFrameTime = idealFrameTime - oversleepDuration;

            if (correctiveFrameTime < minAdaptiveFrameTimeMicros) {
                correctiveFrameTime = minAdaptiveFrameTimeMicros;
            } else if (correctiveFrameTime > maxAdaptiveFrameTimeMicros) {
                correctiveFrameTime = maxAdaptiveFrameTimeMicros;
            }

            recentMicros = correctiveFrameTime.asMicroseconds();
            oldMicros = frameTimeMemoryMicros[frameTimeOldestMemorySlot];

            frameTimeMemoryMicrosSum += recentMicros - oldMicros;
            frameTimeMemoryMicros[frameTimeOldestMemorySlot] = recentMicros;
            frameTimeOldestMemorySlot = (frameTimeOldestMemorySlot + 1) % frameTimeMemorySize;

            assumedFrameTime = sf::microseconds(frameTimeMemoryMicrosSum / frameTimeMemorySize);
        } // else don't touch the adaptive FPS we have "learned" so far, and just move on.
    }

    glFinish(); // If the frame is still not done rendering, block.
}