TimestampEstimator.hpp

Go to the documentation of this file.

#ifndef AGGREGATOR_TIMESTAMP_ESTIMATOR_HPP
#define AGGREGATOR_TIMESTAMP_ESTIMATOR_HPP

#include <base/Time.hpp>
#include <base/CircularBuffer.hpp>
#include <vector>

#include <aggregator/TimestampEstimatorStatus.hpp>

namespace aggregator
{
    class TimestampEstimator
    {
        base::Time m_zero;

        double m_window;

        boost::circular_buffer<double> m_samples;

        double m_last;

        std::vector<long> m_lost;

        int m_lost_threshold;

        int m_lost_total;

        bool m_got_full_window;

        double getPeriodInternal() const;

        double m_base_time_reset;

        double m_base_time_reset_offset;

        double m_latency;

        double m_latency_raw;

        double m_initial_latency;

        double m_max_jitter;

        double m_initial_period;

        int m_missing_samples_total;

        unsigned int m_missing_samples;

        int64_t m_last_index;

        bool m_have_last_index;

        base::Time m_last_reference;

        int m_expected_losses;

        int m_rejected_expected_losses;

        int m_expected_loss_timeout;

        void resetBaseTime(double new_value, double reset_time);

        void internalReset(double window,
                           double initial_period,
                           double min_latency,
                           int lost_threshold = 2);

        void pushSample(double time);

    public:
        TimestampEstimator(base::Time window,
                           base::Time initial_period,
                           base::Time min_latency,
                           int lost_threshold = 2);
        TimestampEstimator(base::Time window,
                           base::Time initial_period,
                           int lost_threshold = 2);
        TimestampEstimator(base::Time window = base::Time(),
                           int lost_threshold = 2);

        void reset();

        void reset(base::Time window,
                           int lost_threshold = 2);

        void reset(base::Time window,
                           base::Time initial_period,
                           int lost_threshold = 2);

        void reset(base::Time window,
                           base::Time initial_period,
                           base::Time min_latency,
                           int lost_threshold = 2);

        base::Time update(base::Time ts);

        base::Time update(base::Time ts, int64_t index);

        void updateLoss();

        void updateReference(base::Time ts);

        base::Time getPeriod() const;

        void shortenSampleList(double current);

        int getLostSampleCount() const;

        bool haveEstimate() const;

        base::Time getLatency() const;

        base::Time getMaxJitter() const;

        TimestampEstimatorStatus getStatus() const;

        void dumpInternalState() const;
    };
}

#endif