stats.h

Go to the documentation of this file.

#ifndef MILLICAST_API_STATS_H
#define MILLICAST_API_STATS_H
 
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
#include "millicast-sdk/diagnostics.h"
#include "millicast-sdk/exports.h"
 
namespace millicast {
namespace rtcstats {
 
enum class Type {
  CODEC,
  OUTBOUND_RTP,
  INBOUND_RTP,
  REMOTE_INBOUND_RTP,
  REMOTE_OUTBOUND_RTP,
  MEDIA_SOURCE,
  AUDIO_SOURCE,
  VIDEO_SOURCE,
  RTC_ICE_CANDIDATE
};
 
struct Stats {
  int64_t timestamp;
 
  std::string id;
 
  Type type;
 
  template <typename T>
  const T* cast_to() const {
    return static_cast<const T*>(this);
  }
 
  virtual ~Stats() = default;
};
 
struct Codecs : public Stats {
  enum class Type { ENCODE, DECODE };
  static constexpr auto STYPE = ::millicast::rtcstats::Type::CODEC;
 
  unsigned long payload_type;
  std::string transport_id;
  std::string mime_type;
 
  std::optional<Type> codec_type;
  std::optional<unsigned long> clock_rate;
  std::optional<unsigned long> channels;
  std::optional<std::string> sdp_fmtp_line;
};
 
struct RTCIceCandidatePair : public Stats {
  static constexpr auto STYPE = Type::RTC_ICE_CANDIDATE;
  std::optional<double> total_round_trip_time;
  std::optional<double> current_round_trip_time;
  std::optional<double> available_outgoing_bitrate;
  std::optional<double> available_incoming_bitrate;
};
 
struct RtpStream : public Stats {
  unsigned long ssrc;
  std::string kind;
  std::optional<std::string> transport_id;
  std::optional<std::string> codec_id;
};
 
struct ReceivedRtpStream : public RtpStream {
  static constexpr auto STYPE = Type::INBOUND_RTP;
 
  std::optional<unsigned long long> packets_received;
  std::optional<double> jitter;
  std::optional<long long> packets_lost;
  std::optional<unsigned long long> frames_dropped;
};
 
struct InboundRtpStream : public ReceivedRtpStream {
  static constexpr auto STYPE = Type::INBOUND_RTP;
 
  std::optional<std::string> remote_id;
  std::optional<std::string> mid;
  std::optional<std::string> track_identifier;
  std::optional<unsigned long> frames_decoded;
  std::optional<unsigned long> key_frames_decoded;
  std::optional<unsigned long> nack_count;
  std::optional<unsigned long long> fir_count;
  std::optional<unsigned long long> pli_count;
  std::optional<unsigned long> frames_received;
  std::optional<unsigned long> frame_width;
  std::optional<unsigned long> frame_height;
  std::optional<double> frames_per_second;
  std::optional<unsigned long long> bytes_received;
  std::optional<unsigned long long> header_bytes_received;
  std::optional<unsigned long long> last_packet_received_timestamp;
  std::optional<double> audio_level;
  std::optional<double> total_audio_energy;
  std::optional<unsigned long long> fec_packets_received;
  std::optional<unsigned long long> fec_packets_discarded;
  std::optional<unsigned long long> total_samples_received;
  std::optional<unsigned long long> concealed_samples;
  std::optional<unsigned long long> silent_concealed_samples;
  std::optional<unsigned long long> concealment_events;
  std::optional<unsigned long long> inserted_samples_for_deceleration;
  std::optional<unsigned long long> removed_samples_for_acceleration;
  std::optional<unsigned long long> frames_assembled_from_multiple_packets;
  std::optional<double> total_samples_duration;
  std::optional<std::string> decoder_implementation;
 
  std::optional<unsigned long long> retransmitted_packets_received;
  std::optional<unsigned long long> retransmitted_bytes_received;
 
  std::optional<double> jitter_buffer_delay;
  std::optional<double> jitter_buffer_target_delay;
  std::optional<double> jitter_buffer_minimum_delay;
  std::optional<double> total_processing_delay;
  std::optional<double> total_decode_time;
  std::optional<double> total_assembly_time;
  std::optional<double> total_inter_frame_delay;
  std::optional<double> total_squared_inter_frame_delay;
 
  std::optional<uint32_t> freeze_count;
  std::optional<double> total_freezes_duration;
 
  std::optional<uint32_t> pause_count;
  std::optional<double> total_pauses_duration;
 
  std::optional<uint64_t> jitter_buffer_emitted_count;
  std::optional<uint64_t> estimated_playout_timestamp;
  std::optional<double> min_playout_delay;
};
 
struct SentRtpStream : public RtpStream {
  static constexpr auto STYPE = Type::OUTBOUND_RTP;
  unsigned long packets_sent;
  unsigned long retransmitted_packets_sent;
  unsigned long long bytes_sent;
  unsigned long retransmitted_bytes_sent;
  unsigned long long header_bytes_sent;
};
 
struct OutboundRtpStream : public SentRtpStream {
  static constexpr auto STYPE = Type::OUTBOUND_RTP;
  std::optional<std::string> sender_id;
  std::optional<std::string> remote_id;
  std::optional<double> target_bitrate;
  std::optional<unsigned long> frame_width;
  std::optional<unsigned long> frame_height;
  std::optional<double> frames_per_second;
  std::optional<unsigned long> frames_sent;
  std::optional<unsigned long> huge_frames_sent;
  std::optional<unsigned long> total_packet_send_delay;
  std::optional<unsigned long> frames_encoded;
  std::optional<unsigned long> key_frames_encoded;
  std::optional<unsigned long> total_encoded_bytes_target;
  std::optional<unsigned long> nack_count;
  std::optional<unsigned long> fir_count;
  std::optional<unsigned long> pli_count;
  std::optional<unsigned long> qp_sum;
  std::optional<std::string> quality_limitation_durations;
  std::optional<unsigned int> quality_limitation_resolution_changes;
  std::optional<std::string> quality_limitation_reason;
  std::optional<std::string> encoder_implementation;
};
 
struct RemoteOutboundRtpStream : public SentRtpStream {
  static constexpr auto STYPE = Type::REMOTE_OUTBOUND_RTP;
  std::string local_id;
  double remote_timestamp;
  unsigned long long reports_sent;
  double round_trip_time;
  unsigned long long round_trip_time_measurements;
  double total_round_trip_time;
};
 
struct RemoteInboundRtpStream : public ReceivedRtpStream {
  static constexpr auto STYPE = Type::REMOTE_INBOUND_RTP;
  std::string local_id;
  double round_trip_time;
  double total_round_trip_time;
  unsigned long round_trip_time_measurements;
  double fraction_lost;  // fraction packet loss
};
 
struct MediaSource : public Stats {
  static constexpr auto STYPE = Type::MEDIA_SOURCE;
  std::string track_identifier;
  std::string kind;
};
 
struct VideoSource : public MediaSource {
  static constexpr auto STYPE = Type::VIDEO_SOURCE;
  std::optional<unsigned long> width;
  std::optional<unsigned long> height;
  std::optional<unsigned long> frames;
  std::optional<double> frames_per_second;
};
 
struct AudioSource : public MediaSource {
  static constexpr auto STYPE = Type::AUDIO_SOURCE;
  std::optional<double> audio_level;
  std::optional<double> total_audio_energy;
  std::optional<double> total_samples_duration;
  std::optional<double> echo_return_loss;
  std::optional<double> echo_return_loss_enhancement;
};
}  // namespace rtcstats
 
using StatObject = std::unique_ptr<const rtcstats::Stats>;
 
class MILLICAST_API StatsReport {
 public:
  class const_iterator {  // NOLINT
    std::map<std::string, StatObject>::const_iterator _it;
 
   public:
    const_iterator(std::map<std::string, StatObject>::const_iterator it)
        : _it(it) {}
    const_iterator(const_iterator&& other) = default;
    ~const_iterator() = default;
 
    const_iterator& operator++() {
      ++_it;
      return *this;
    }
    const_iterator& operator++(int) { return ++(*this); }
    const rtcstats::Stats& operator*() const { return *_it->second.get(); }
    const rtcstats::Stats* operator->() const { return _it->second.get(); }
    bool operator==(const const_iterator& other) const {
      return _it == other._it;
    }
    bool operator!=(const const_iterator& other) const {
      return !(*this == other);
    }
  };
 
  StatsReport();
  virtual ~StatsReport() = default;
 
  virtual void add_stats(StatObject stats) = 0;
  [[nodiscard]] virtual const rtcstats::Stats* get(
      const std::string& id) const = 0;
  template <typename T>
  const T* get_as(const std::string& id) const {
    const rtcstats::Stats* stats = get(id);
    if (!stats || stats->type != T::STYPE) {
      return nullptr;
    }
 
    return stats->cast_to<const T>();
  }
 
  [[nodiscard]] virtual const_iterator begin() const = 0;
  [[nodiscard]] virtual const_iterator end() const = 0;
 
  template <typename T>
  std::vector<const T*> get_stats_of_type() const {
    std::vector<const T*> stats_of_type;
    for (const auto& stats : *this) {
      if (stats.type == T::STYPE) {
        stats_of_type.push_back(stats.cast_to<const T>());
      }
    }
    return stats_of_type;
  }
  virtual StreamDetails stream_details() const = 0;
 
  // Removes the stats object from the report, returning ownership of it or null
  // if there is no object with `id`.
  virtual StatObject take(const std::string& id) = 0;
 
  [[nodiscard]] virtual size_t size() const = 0;
};
 
}  // namespace millicast
 
#endif /* MILLICAST_API_STATS_H */