rtc_event_audio_network_adaptation.h

Enable keyboard shortcuts

/*

 *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.

 *  Use of this source code is governed by a BSD-style license

 *  that can be found in the LICENSE file in the root of the source

 *  tree. An additional intellectual property rights grant can be found

 *  in the file PATENTS.  All contributing project authors may

 *  be found in the AUTHORS file in the root of the source tree.

*/

#ifndef LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_AUDIO_NETWORK_ADAPTATION_H_

#define LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_AUDIO_NETWORK_ADAPTATION_H_

#include <cstddef>

#include <cstdint>

#include <memory>

#include <optional>

#include <string>

#include <vector>

#include "absl/strings/string_view.h"

#include "api/array_view.h"

#include "api/rtc_event_log/rtc_event.h"

#include "api/units/timestamp.h"

#include "logging/rtc_event_log/events/rtc_event_log_parse_status.h"

#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"

namespace webrtc {

struct LoggedAudioNetworkAdaptationEvent {

  LoggedAudioNetworkAdaptationEvent() = default;

  LoggedAudioNetworkAdaptationEvent(Timestamp timestamp,

                                    const AudioEncoderRuntimeConfig& config)

      : timestamp(timestamp), config(config) {}

  int64_t log_time_us() const { return timestamp.us(); }

  int64_t log_time_ms() const { return timestamp.ms(); }

  Timestamp log_time() const { return timestamp; }

  Timestamp timestamp = Timestamp::MinusInfinity();

  AudioEncoderRuntimeConfig config;

};

struct AudioEncoderRuntimeConfig;

class RtcEventAudioNetworkAdaptation final : public RtcEvent {

 public:

  static constexpr Type kType = Type::AudioNetworkAdaptation;

  explicit RtcEventAudioNetworkAdaptation(

      const AudioEncoderRuntimeConfig& config);

  ~RtcEventAudioNetworkAdaptation() override;

  Type GetType() const override { return kType; }

  bool IsConfigEvent() const override { return false; }

  std::unique_ptr<RtcEventAudioNetworkAdaptation> Copy() const;

  const std::optional<int>& bitrate_bps() const { return bitrate_bps_; }

  const std::optional<int>& frame_length_ms() const { return frame_length_ms_; }

  const std::optional<float>& uplink_packet_loss_fraction() const {

    return uplink_packet_loss_fraction_;

  const std::optional<bool>& enable_fec() const { return enable_fec_; }

  const std::optional<bool>& enable_dtx() const { return enable_dtx_; }

  const std::optional<size_t>& num_channels() const { return num_channels_; }

  static std::string Encode(ArrayView<const RtcEvent*> /* batch */) {

    // TODO(terelius): Implement

    return "";

  static RtcEventLogParseStatus Parse(

      absl::string_view /* encoded_bytes */,

      bool /* batched */,

      std::vector<LoggedAudioNetworkAdaptationEvent>& /* output */) {

    // TODO(terelius): Implement

    return RtcEventLogParseStatus::Error("Not Implemented", __FILE__, __LINE__);

 private:

  RtcEventAudioNetworkAdaptation(const RtcEventAudioNetworkAdaptation&) =

      default;

  std::optional<int> bitrate_bps_;

  std::optional<int> frame_length_ms_;

  std::optional<float> uplink_packet_loss_fraction_;

  std::optional<bool> enable_fec_;

  std::optional<bool> enable_dtx_;

  std::optional<size_t> num_channels_;

};

}  // namespace webrtc

#endif  // LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_AUDIO_NETWORK_ADAPTATION_H_