audio_utils/tests/timestampverifier_tests.cpp

/*
 * Copyright 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.
 */

//#define LOG_NDEBUG 0
#define LOG_TAG "audio_utils_timestampverifier_tests"

#include <audio_utils/TimestampVerifier.h>

#include <stdio.h>
#include <gtest/gtest.h>

// Ensure that all TimestampVerifier mutators are really constexpr and free from
// nasty system calls (in case called from a SCHED_FIFO thread).
static constexpr auto makeVerifier(
        size_t N, uint32_t sampleRate, size_t errors, size_t discontinuities) {
    android::TimestampVerifier<int64_t, int64_t> tv;

    int64_t f = 0;
    int64_t t = 0;
    for (size_t i = 0; i < N; ++i) {
        tv.add(f, t, sampleRate);
        f += sampleRate;
        t += (int64_t)1e9;
    }
    for (size_t i = 0; i < discontinuities; ++i) {
        tv.discontinuity(tv.DISCONTINUITY_MODE_CONTINUOUS);
    }
    for (size_t i = 0; i < errors; ++i) {
        tv.error();
    }
    return tv;
}

TEST(TimestampVerifier, sanity)
{
    constexpr android::TimestampVerifier<int64_t, int64_t> tv;

    // The timestamp verifier must be embeddable in a memcpy structure just like pod.
    // We use is_trivially_copyable and is_trivially_destructible for this test.
    static_assert(std::is_trivially_copyable<decltype(tv)>::value,
        "TimestampVerifier must be trivially copyable");
    static_assert(std::is_trivially_destructible<decltype(tv)>::value,
        "TimestampVerifier must be trivially destructible");

    constexpr android::audio_utils::Statistics<double> s = tv.getJitterMs();

    EXPECT_EQ(std::numeric_limits<double>::infinity(), s.getMin());
    EXPECT_EQ(-std::numeric_limits<double>::infinity(), s.getMax());

    constexpr int64_t frames[] { 0, 48000 };
    constexpr int64_t timeNs[] { 0, 1000000000 };
    constexpr android::TimestampVerifier<int64_t, int64_t> tv2(frames, timeNs, 48000);
    EXPECT_EQ(0., tv2.getJitterMs().getMax());
    EXPECT_EQ(0., tv2.getJitterMs().getMin());
    EXPECT_EQ(0., tv2.getJitterMs().getMean());
    EXPECT_EQ(1, tv2.getJitterMs().getN());

    // We should get a perfect straight line estimate as there is no noise.
    double a, b, r2;
    tv2.estimateSampleRate(a, b, r2);
    EXPECT_EQ(0., a);
    EXPECT_EQ(48000., b);
    EXPECT_NEAR(1., r2, std::numeric_limits<double>::epsilon());

    constexpr android::TimestampVerifier<int64_t, int64_t> tv3 =
            makeVerifier(8 /* N */, 48000 /* sampleRate */, 10 /* errors */, 10 /* disc */);
    EXPECT_EQ(8, tv3.getN());
    EXPECT_EQ(10, tv3.getErrors());
    EXPECT_EQ(1, tv3.getDiscontinuities());  // consecutive discontinuities read as 1.
    EXPECT_EQ(0., tv3.getJitterMs().getMax());
    EXPECT_EQ(0., tv3.getJitterMs().getMin());
    EXPECT_EQ(0., tv3.getJitterMs().getMean());

    constexpr auto first = tv3.getFirstTimestamp();
    constexpr auto last = tv3.getLastTimestamp();

    EXPECT_EQ(0, first.mFrames);
    EXPECT_EQ(0, first.mTimeNs);
    EXPECT_EQ(48000 * (8 - 1), last.mFrames);
    EXPECT_EQ((int64_t)1e9 * (8 - 1), last.mTimeNs);
    EXPECT_EQ((uint32_t)48000, tv3.getSampleRate());
    EXPECT_EQ(0, tv3.getColds());

    tv3.estimateSampleRate(a, b, r2);
    EXPECT_EQ(0., a);
    EXPECT_EQ(48000., b);
    EXPECT_NEAR(1., r2, std::numeric_limits<double>::epsilon());
}

TEST(TimestampVerifier, discontinuity_zero)
{
    android::TimestampVerifier<int64_t, int64_t> tv;

    // Add timestamps advancing at normal rate over 2 seconds
    tv.add(0, 0, 48000);
    tv.add(48000, 1000000000, 48000);
    tv.add(96000, 2000000000, 48000);

    // Raise (mode zero) discontinuity at "3 seconds"
    tv.discontinuity(tv.DISCONTINUITY_MODE_ZERO);
    // Add timestamp where frame count has reset to zero (and not advancing)
    tv.add(0, 3000000000, 48000);

    // The last corrected timestamp after discontinuity (mode zero) should be zeroed
    EXPECT_EQ(0., tv.getLastCorrectedTimestamp().mFrames);
    EXPECT_EQ(3000000000., tv.getLastCorrectedTimestamp().mTimeNs);

    // Add timestamp where frame count has not advanced from zero, but time has advanced 100 ms more
    tv.add(0, 3100000000, 48000);

    // The last corrected frame should be the raw timestamp if not advancing at normal rate
    EXPECT_EQ(0., tv.getLastCorrectedTimestamp().mFrames);
    EXPECT_EQ(3100000000., tv.getLastCorrectedTimestamp().mTimeNs);

    // Add imperfect normal advancing timestamps
    tv.add(48000*0.9, 4100000000*1.1, 48000);
    tv.add(96000*1.1, 5100000000*0.9, 48000);

    // Last corrected timestamp frame count should not be raw (or zero) as timestamps are now
    // advancing at a (imperfect) normal rate (but the time should, as implementation uses frame
    // rather than time correction).
    EXPECT_NE(0, tv.getLastCorrectedTimestamp().mFrames);
    EXPECT_NE(96000*1.1, tv.getLastCorrectedTimestamp().mFrames);
    EXPECT_EQ(5100000000*0.9, tv.getLastCorrectedTimestamp().mTimeNs);
}