rtp_transport_controller_send.cc | Explore in Territory

/*
 *  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.
 */
#include "call/rtp_transport_controller_send.h"

#include <cstdint>
#include <memory>
#include <utility>
#include <vector>

#include "absl/strings/match.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "api/task_queue/pending_task_safety_flag.h"
#include "api/task_queue/task_queue_base.h"
#include "api/transport/goog_cc_factory.h"
#include "api/transport/network_types.h"
#include "api/units/data_rate.h"
#include "api/units/time_delta.h"
#include "api/units/timestamp.h"
#include "call/rtp_video_sender.h"
#include "logging/rtc_event_log/events/rtc_event_remote_estimate.h"
#include "logging/rtc_event_log/events/rtc_event_route_change.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "rtc_base/rate_limiter.h"

namespace webrtc {
namespace {
static const int64_t kRetransmitWindowSizeMs = …;
static const size_t kMaxOverheadBytes = …;

constexpr TimeDelta kPacerQueueUpdateInterval = …;

TargetRateConstraints ConvertConstraints(int min_bitrate_bps,
                                         int max_bitrate_bps,
                                         int start_bitrate_bps,
                                         Clock* clock) { … }

TargetRateConstraints ConvertConstraints(const BitrateConstraints& contraints,
                                         Clock* clock) { … }

bool IsRelayed(const rtc::NetworkRoute& route) { … }
}  // namespace

RtpTransportControllerSend::RtpTransportControllerSend(
    const RtpTransportConfig& config)
    : … { … }

RtpTransportControllerSend::~RtpTransportControllerSend() { … }

RtpVideoSenderInterface* RtpTransportControllerSend::CreateRtpVideoSender(
    const std::map<uint32_t, RtpState>& suspended_ssrcs,
    const std::map<uint32_t, RtpPayloadState>& states,
    const RtpConfig& rtp_config,
    int rtcp_report_interval_ms,
    Transport* send_transport,
    const RtpSenderObservers& observers,
    std::unique_ptr<FecController> fec_controller,
    const RtpSenderFrameEncryptionConfig& frame_encryption_config,
    rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) { … }

void RtpTransportControllerSend::DestroyRtpVideoSender(
    RtpVideoSenderInterface* rtp_video_sender) { … }

void RtpTransportControllerSend::RegisterSendingRtpStream(
    RtpRtcpInterface& rtp_module) { … }

void RtpTransportControllerSend::DeRegisterSendingRtpStream(
    RtpRtcpInterface& rtp_module) { … }

void RtpTransportControllerSend::UpdateControlState() { … }

void RtpTransportControllerSend::UpdateCongestedState() { … }

absl::optional<bool> RtpTransportControllerSend::GetCongestedStateUpdate()
    const { … }

PacketRouter* RtpTransportControllerSend::packet_router() { … }

NetworkStateEstimateObserver*
RtpTransportControllerSend::network_state_estimate_observer() { … }

RtpPacketSender* RtpTransportControllerSend::packet_sender() { … }

void RtpTransportControllerSend::SetAllocatedSendBitrateLimits(
    BitrateAllocationLimits limits) { … }
void RtpTransportControllerSend::SetPacingFactor(float pacing_factor) { … }
void RtpTransportControllerSend::SetQueueTimeLimit(int limit_ms) { … }
StreamFeedbackProvider*
RtpTransportControllerSend::GetStreamFeedbackProvider() { … }

void RtpTransportControllerSend::ReconfigureBandwidthEstimation(
    const BandwidthEstimationSettings& settings) { … }

void RtpTransportControllerSend::RegisterTargetTransferRateObserver(
    TargetTransferRateObserver* observer) { … }

bool RtpTransportControllerSend::IsRelevantRouteChange(
    const rtc::NetworkRoute& old_route,
    const rtc::NetworkRoute& new_route) const { … }

void RtpTransportControllerSend::OnNetworkRouteChanged(
    absl::string_view transport_name,
    const rtc::NetworkRoute& network_route) { … }
void RtpTransportControllerSend::OnNetworkAvailability(bool network_available) { … }
NetworkLinkRtcpObserver* RtpTransportControllerSend::GetRtcpObserver() { … }
int64_t RtpTransportControllerSend::GetPacerQueuingDelayMs() const { … }
absl::optional<Timestamp> RtpTransportControllerSend::GetFirstPacketTime()
    const { … }
void RtpTransportControllerSend::EnablePeriodicAlrProbing(bool enable) { … }
void RtpTransportControllerSend::OnSentPacket(
    const rtc::SentPacket& sent_packet) { … }

void RtpTransportControllerSend::ProcessSentPacket(
    const rtc::SentPacket& sent_packet) { … }

// RTC_RUN_ON(task_queue_)
void RtpTransportControllerSend::ProcessSentPacketUpdates(
    NetworkControlUpdate updates) { … }

void RtpTransportControllerSend::OnReceivedPacket(
    const ReceivedPacket& packet_msg) { … }

void RtpTransportControllerSend::UpdateBitrateConstraints(
    const BitrateConstraints& updated) { … }

void RtpTransportControllerSend::SetSdpBitrateParameters(
    const BitrateConstraints& constraints) { … }

void RtpTransportControllerSend::SetClientBitratePreferences(
    const BitrateSettings& preferences) { … }

absl::optional<BitrateConstraints>
RtpTransportControllerSend::ApplyOrLiftRelayCap(bool is_relayed) { … }

void RtpTransportControllerSend::OnTransportOverheadChanged(
    size_t transport_overhead_bytes_per_packet) { … }

void RtpTransportControllerSend::AccountForAudioPacketsInPacedSender(
    bool account_for_audio) { … }

void RtpTransportControllerSend::IncludeOverheadInPacedSender() { … }

void RtpTransportControllerSend::EnsureStarted() { … }

void RtpTransportControllerSend::OnReceiverEstimatedMaxBitrate(
    Timestamp receive_time,
    DataRate bitrate) { … }

void RtpTransportControllerSend::OnRttUpdate(Timestamp receive_time,
                                             TimeDelta rtt) { … }

void RtpTransportControllerSend::NotifyBweOfPacedSentPacket(
    const RtpPacketToSend& packet,
    const PacedPacketInfo& pacing_info) { … }

void RtpTransportControllerSend::OnTransportFeedback(
    Timestamp receive_time,
    const rtcp::TransportFeedback& feedback) { … }

void RtpTransportControllerSend::OnRemoteNetworkEstimate(
    NetworkStateEstimate estimate) { … }

void RtpTransportControllerSend::MaybeCreateControllers() { … }

void RtpTransportControllerSend::UpdateNetworkAvailability() { … }

void RtpTransportControllerSend::UpdateInitialConstraints(
    TargetRateConstraints new_contraints) { … }

void RtpTransportControllerSend::StartProcessPeriodicTasks() { … }

void RtpTransportControllerSend::UpdateControllerWithTimeInterval() { … }

void RtpTransportControllerSend::UpdateStreamsConfig() { … }

void RtpTransportControllerSend::PostUpdates(NetworkControlUpdate update) { … }

void RtpTransportControllerSend::OnReport(
    Timestamp receive_time,
    rtc::ArrayView<const ReportBlockData> report_blocks) { … }

}  // namespace webrtc
chromium/third_party/webrtc/call/rtp_transport_controller_send.cc
