video_cadence_estimator_unittest.cc

// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "media/filters/video_cadence_estimator.h"

#include <math.h>
#include <stddef.h>

#include <memory>

#include "base/numerics/safe_conversions.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "base/strings/stringprintf.h"
#include "base/test/scoped_feature_list.h"
#include "base/time/time.h"
#include "media/base/media_switches.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace media {

// See VideoCadenceEstimator header for more details.
constexpr auto kMinimumAcceptableTimeBetweenGlitches = …;

// Slows down the given |fps| according to NTSC field reduction standards; see
// http://en.wikipedia.org/wiki/Frame_rate#Digital_video_and_television
static double NTSC(double fps) { … }

static base::TimeDelta Interval(double hertz) { … }

std::vector<int> CreateCadenceFromString(const std::string& cadence) { … }

static void VerifyCadenceVectorWithCustomDeviationAndDrift(
    VideoCadenceEstimator* estimator,
    double frame_hertz,
    double render_hertz,
    base::TimeDelta deviation,
    base::TimeDelta acceptable_drift,
    const std::string& expected_cadence) { … }

static void VerifyCadenceVectorWithCustomDrift(
    VideoCadenceEstimator* estimator,
    double frame_hertz,
    double render_hertz,
    base::TimeDelta acceptable_drift,
    const std::string& expected_cadence) { … }

static void VerifyCadenceVectorWithCustomDeviation(
    VideoCadenceEstimator* estimator,
    double frame_hertz,
    double render_hertz,
    base::TimeDelta deviation,
    const std::string& expected_cadence) { … }

static void VerifyCadenceVector(VideoCadenceEstimator* estimator,
                                double frame_hertz,
                                double render_hertz,
                                const std::string& expected_cadence) { … }

// Spot check common display and frame rate pairs for correctness.
TEST(VideoCadenceEstimatorTest, CadenceCalculations) { … }

// Check the extreme case that max_acceptable_drift is larger than
// minimum_time_until_max_drift.
TEST(VideoCadenceEstimatorTest, CadenceCalculationWithLargeDrift) { … }

TEST(VideoCadenceEstimatorTest, SimpleCadenceTest) { … }

// Check the case that the estimator excludes variable FPS case from Cadence.
TEST(VideoCadenceEstimatorTest, CadenceCalculationWithLargeDeviation) { … }

TEST(VideoCadenceEstimatorTest, CadenceVariesWithAcceptableDrift) { … }

TEST(VideoCadenceEstimatorTest, CadenceVariesWithAcceptableGlitchTime) { … }

TEST(VideoCadenceEstimatorTest, CadenceHystersisPreventsOscillation) { … }

TEST(VideoCadenceEstimatorTest, RenderIntervalChangingSkipsHystersis) { … }

void VerifyCadenceSequence(VideoCadenceEstimator* estimator,
                           double frame_rate,
                           double display_rate,
                           std::vector<int> expected_cadence) { … }

}  // namespace media
chromium/media/filters/video_cadence_estimator_unittest.cc
