libaaudio/tests/test_clock_model.cpp

/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// Unit tests for Isochronous Clock Model

#include <math.h>
#include <stdlib.h>


#include <aaudio/AAudio.h>
#include <audio_utils/clock.h>
#include <client/IsochronousClockModel.h>
#include <gtest/gtest.h>

using namespace aaudio;

// We can use arbitrary values here because we are not opening a real audio stream.
#define SAMPLE_RATE             48000
#define HW_FRAMES_PER_BURST     48
// Sometimes we need a (double) value to avoid misguided Build warnings.
#define NANOS_PER_BURST         ((double) NANOS_PER_SECOND * HW_FRAMES_PER_BURST / SAMPLE_RATE)

class ClockModelTestFixture: public ::testing::Test {
public:
    ClockModelTestFixture() {
    }

    void SetUp() {
        model.setSampleRate(SAMPLE_RATE);
        model.setFramesPerBurst(HW_FRAMES_PER_BURST);
    }

    void TearDown() {
    }

    ~ClockModelTestFixture()  {
        // cleanup any pending stuff, but no exceptions allowed
    }

    /** Test processing of timestamps when the hardware may be slightly off from
     * the expected sample rate.
     * @param hardwareFramesPerSecond  sample rate that may be slightly off
     * @param numLoops number of iterations
     * @param hardwarePauseTime  number of seconds to jump forward at halfway point
     */
    void checkDriftingClock(double hardwareFramesPerSecond,
                            int numLoops,
                            double hardwarePauseTime = 0.0) {
        int checksToSkip = 0;
        const int64_t startTimeNanos = 500000000; // arbitrary
        int64_t jumpOffsetNanos = 0;

        srand48(123456); // arbitrary seed for repeatable test results
        model.start(startTimeNanos);

        const int64_t startPositionFrames = HW_FRAMES_PER_BURST; // hardware
        // arbitrary time for first burst
        const int64_t markerTime = startTimeNanos + NANOS_PER_MILLISECOND
                + (200 * NANOS_PER_MICROSECOND);

        // Should set initial marker.
        model.processTimestamp(startPositionFrames, markerTime);
        ASSERT_EQ(startPositionFrames, model.convertTimeToPosition(markerTime));

        double elapsedTimeSeconds = 0.0;
        for (int i = 0; i < numLoops; i++) {
            // Calculate random delay over several bursts.
            const double timeDelaySeconds = 10.0 * drand48() * NANOS_PER_BURST / NANOS_PER_SECOND;
            elapsedTimeSeconds += timeDelaySeconds;
            const int64_t elapsedTimeNanos = (int64_t)(elapsedTimeSeconds * NANOS_PER_SECOND);
            const int64_t currentTimeNanos = startTimeNanos + elapsedTimeNanos;
            // Simulate DSP running at the specified rate.
            const int64_t currentTimeFrames = startPositionFrames +
                                        (int64_t)(hardwareFramesPerSecond * elapsedTimeSeconds);
            const int64_t numBursts = currentTimeFrames / HW_FRAMES_PER_BURST;
            const int64_t hardwarePosition = startPositionFrames
                    + (numBursts * HW_FRAMES_PER_BURST);

            // Simulate a pause in the DSP where the position freezes for a length of time.
            if (i == numLoops / 2) {
                jumpOffsetNanos = (int64_t)(hardwarePauseTime * NANOS_PER_SECOND);
                checksToSkip = 5; // Give the model some time to catch up.
            }

            // Apply drifting timestamp. Add a random time to simulate the
            // random sampling of the clock that occurs when polling the DSP clock.
            int64_t sampledTimeNanos = (int64_t) (currentTimeNanos
                    + jumpOffsetNanos
                    + (drand48() * NANOS_PER_BURST));
            model.processTimestamp(hardwarePosition, sampledTimeNanos);

            if (checksToSkip > 0) {
                checksToSkip--;
            } else {
                // When the model is drifting it may be pushed forward or backward.
                const int64_t modelPosition = model.convertTimeToPosition(sampledTimeNanos);
                if (hardwareFramesPerSecond >= SAMPLE_RATE) { // fast hardware
                    ASSERT_LE(hardwarePosition - HW_FRAMES_PER_BURST, modelPosition);
                    ASSERT_GE(hardwarePosition + HW_FRAMES_PER_BURST, modelPosition);
                } else {
                    // Slow hardware. If this fails then the model may be drifting
                    // forward in time too slowly. Increase kDriftNanos.
                    ASSERT_LE(hardwarePosition, modelPosition);
                    ASSERT_GE(hardwarePosition + (2 * HW_FRAMES_PER_BURST), modelPosition);
                }
            }
        }
    }

    IsochronousClockModel model;
};

// Check default setup.
TEST_F(ClockModelTestFixture, clock_setup) {
    ASSERT_EQ(SAMPLE_RATE, model.getSampleRate());
    ASSERT_EQ(HW_FRAMES_PER_BURST, model.getFramesPerBurst());
}

// Test delta calculations.
TEST_F(ClockModelTestFixture, clock_deltas) {
    int64_t position = model.convertDeltaTimeToPosition(NANOS_PER_SECOND);
    ASSERT_EQ(SAMPLE_RATE, position);

    // Deltas are not quantized.
    // Compare time to the equivalent position in frames.
    constexpr int64_t kNanosPerBurst = HW_FRAMES_PER_BURST * NANOS_PER_SECOND / SAMPLE_RATE;
    position = model.convertDeltaTimeToPosition(NANOS_PER_SECOND + (kNanosPerBurst / 2));
    ASSERT_EQ(SAMPLE_RATE + (HW_FRAMES_PER_BURST / 2), position);

    int64_t time = model.convertDeltaPositionToTime(SAMPLE_RATE);
    ASSERT_EQ(NANOS_PER_SECOND, time);

    // Compare position in frames to the equivalent time.
    time = model.convertDeltaPositionToTime(SAMPLE_RATE + (HW_FRAMES_PER_BURST / 2));
    ASSERT_EQ(NANOS_PER_SECOND + (kNanosPerBurst / 2), time);
}

// start() should force the internal markers
TEST_F(ClockModelTestFixture, clock_start) {
    const int64_t startTime = 100000;
    model.start(startTime);

    int64_t position = model.convertTimeToPosition(startTime);
    EXPECT_EQ(0, position);

    int64_t time = model.convertPositionToTime(position);
    EXPECT_EQ(startTime, time);

    time = startTime + (500 * NANOS_PER_MICROSECOND);
    position = model.convertTimeToPosition(time);
    EXPECT_EQ(0, position);
}

// timestamps moves the window if outside the bounds
TEST_F(ClockModelTestFixture, clock_timestamp) {
    const int64_t startTime = 100000000;
    model.start(startTime);

    const int64_t position = HW_FRAMES_PER_BURST; // hardware
    int64_t markerTime = startTime + NANOS_PER_MILLISECOND + (200 * NANOS_PER_MICROSECOND);

    // Should set marker.
    model.processTimestamp(position, markerTime);
    EXPECT_EQ(position, model.convertTimeToPosition(markerTime));

    // convertTimeToPosition rounds down
    EXPECT_EQ(position, model.convertTimeToPosition(markerTime + (73 * NANOS_PER_MICROSECOND)));

    // convertPositionToTime rounds up
    EXPECT_EQ(markerTime + (int64_t)NANOS_PER_BURST, model.convertPositionToTime(position + 17));
}

#define NUM_LOOPS_DRIFT   200000

TEST_F(ClockModelTestFixture, clock_no_drift) {
    checkDriftingClock(SAMPLE_RATE, NUM_LOOPS_DRIFT);
}

// Test drifting hardware clocks.
// It is unlikely that real hardware would be off by more than this amount.

// Test a slow clock. This will cause the times to be later than expected.
// This will push the clock model window forward and cause it to drift.
TEST_F(ClockModelTestFixture, clock_slow_drift) {
    checkDriftingClock(0.99998 * SAMPLE_RATE, NUM_LOOPS_DRIFT);
}

// Test a fast hardware clock. This will cause the times to be earlier
// than expected. This will cause the clock model to jump backwards quickly.
TEST_F(ClockModelTestFixture, clock_fast_drift) {
    checkDriftingClock(1.00002 * SAMPLE_RATE, NUM_LOOPS_DRIFT);
}

// Simulate a pause in the DSP, which can occur if the DSP reroutes the audio.
TEST_F(ClockModelTestFixture, clock_jump_forward_500) {
    checkDriftingClock(SAMPLE_RATE, NUM_LOOPS_DRIFT, 0.500);
}