From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- .../libwebrtc/video/video_send_stream_impl.h | 180 +++++++++++++++++++++ 1 file changed, 180 insertions(+) create mode 100644 third_party/libwebrtc/video/video_send_stream_impl.h (limited to 'third_party/libwebrtc/video/video_send_stream_impl.h') diff --git a/third_party/libwebrtc/video/video_send_stream_impl.h b/third_party/libwebrtc/video/video_send_stream_impl.h new file mode 100644 index 0000000000..f145450655 --- /dev/null +++ b/third_party/libwebrtc/video/video_send_stream_impl.h @@ -0,0 +1,180 @@ +/* + * Copyright 2018 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 VIDEO_VIDEO_SEND_STREAM_IMPL_H_ +#define VIDEO_VIDEO_SEND_STREAM_IMPL_H_ + +#include +#include + +#include +#include +#include +#include + +#include "absl/types/optional.h" +#include "api/field_trials_view.h" +#include "api/task_queue/pending_task_safety_flag.h" +#include "api/task_queue/task_queue_base.h" +#include "api/video/encoded_image.h" +#include "api/video/video_bitrate_allocation.h" +#include "api/video/video_bitrate_allocator.h" +#include "api/video_codecs/video_encoder.h" +#include "call/bitrate_allocator.h" +#include "call/rtp_config.h" +#include "call/rtp_transport_controller_send_interface.h" +#include "call/rtp_video_sender_interface.h" +#include "modules/include/module_common_types.h" +#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" +#include "modules/utility/maybe_worker_thread.h" +#include "modules/video_coding/include/video_codec_interface.h" +#include "rtc_base/experiments/field_trial_parser.h" +#include "rtc_base/system/no_unique_address.h" +#include "rtc_base/task_utils/repeating_task.h" +#include "rtc_base/thread_annotations.h" +#include "video/config/video_encoder_config.h" +#include "video/send_statistics_proxy.h" +#include "video/video_stream_encoder_interface.h" + +namespace webrtc { +namespace internal { + +// Pacing buffer config; overridden by ALR config if provided. +struct PacingConfig { + explicit PacingConfig(const FieldTrialsView& field_trials); + PacingConfig(const PacingConfig&); + PacingConfig& operator=(const PacingConfig&) = default; + ~PacingConfig(); + FieldTrialParameter pacing_factor; + FieldTrialParameter max_pacing_delay; +}; + +// VideoSendStreamImpl implements internal::VideoSendStream. +// It is created and destroyed on `rtp_transport_queue`. The intent is to +// decrease the need for locking and to ensure methods are called in sequence. +// Public methods except `DeliverRtcp` must be called on `rtp_transport_queue`. +// DeliverRtcp is called on the libjingle worker thread or a network thread. +// An encoder may deliver frames through the EncodedImageCallback on an +// arbitrary thread. +class VideoSendStreamImpl : public webrtc::BitrateAllocatorObserver, + public VideoStreamEncoderInterface::EncoderSink { + public: + VideoSendStreamImpl(Clock* clock, + SendStatisticsProxy* stats_proxy, + RtpTransportControllerSendInterface* transport, + BitrateAllocatorInterface* bitrate_allocator, + VideoStreamEncoderInterface* video_stream_encoder, + const VideoSendStream::Config* config, + int initial_encoder_max_bitrate, + double initial_encoder_bitrate_priority, + VideoEncoderConfig::ContentType content_type, + RtpVideoSenderInterface* rtp_video_sender, + const FieldTrialsView& field_trials); + ~VideoSendStreamImpl() override; + + void DeliverRtcp(const uint8_t* packet, size_t length); + void StartPerRtpStream(std::vector active_layers); + void Stop(); + + // TODO(holmer): Move these to RtpTransportControllerSend. + std::map GetRtpStates() const; + + std::map GetRtpPayloadStates() const; + + const absl::optional& configured_pacing_factor() const { + return configured_pacing_factor_; + } + + private: + // Implements BitrateAllocatorObserver. + uint32_t OnBitrateUpdated(BitrateAllocationUpdate update) override; + + // Implements VideoStreamEncoderInterface::EncoderSink + void OnEncoderConfigurationChanged( + std::vector streams, + bool is_svc, + VideoEncoderConfig::ContentType content_type, + int min_transmit_bitrate_bps) override; + + void OnBitrateAllocationUpdated( + const VideoBitrateAllocation& allocation) override; + void OnVideoLayersAllocationUpdated( + VideoLayersAllocation allocation) override; + + // Implements EncodedImageCallback. The implementation routes encoded frames + // to the `payload_router_` and `config.pre_encode_callback` if set. + // Called on an arbitrary encoder callback thread. + EncodedImageCallback::Result OnEncodedImage( + const EncodedImage& encoded_image, + const CodecSpecificInfo* codec_specific_info) override; + + // Implements EncodedImageCallback. + void OnDroppedFrame(EncodedImageCallback::DropReason reason) override; + + // Starts monitoring and sends a keyframe. + void StartupVideoSendStream(); + // Removes the bitrate observer, stops monitoring and notifies the video + // encoder of the bitrate update. + void StopVideoSendStream() RTC_RUN_ON(rtp_transport_queue_); + + void ConfigureProtection(); + void ConfigureSsrcs(); + void SignalEncoderTimedOut(); + void SignalEncoderActive(); + MediaStreamAllocationConfig GetAllocationConfig() const + RTC_RUN_ON(rtp_transport_queue_); + + RTC_NO_UNIQUE_ADDRESS SequenceChecker thread_checker_; + Clock* const clock_; + const bool has_alr_probing_; + const PacingConfig pacing_config_; + + SendStatisticsProxy* const stats_proxy_; + const VideoSendStream::Config* const config_; + + MaybeWorkerThread* const rtp_transport_queue_; + + RepeatingTaskHandle check_encoder_activity_task_ + RTC_GUARDED_BY(rtp_transport_queue_); + + std::atomic_bool activity_; + bool timed_out_ RTC_GUARDED_BY(rtp_transport_queue_); + + RtpTransportControllerSendInterface* const transport_; + BitrateAllocatorInterface* const bitrate_allocator_; + + bool disable_padding_; + int max_padding_bitrate_; + int encoder_min_bitrate_bps_; + uint32_t encoder_max_bitrate_bps_; + uint32_t encoder_target_rate_bps_; + double encoder_bitrate_priority_; + + VideoStreamEncoderInterface* const video_stream_encoder_; + + RtcpBandwidthObserver* const bandwidth_observer_; + RtpVideoSenderInterface* const rtp_video_sender_; + + rtc::scoped_refptr transport_queue_safety_ = + PendingTaskSafetyFlag::CreateDetached(); + + // Context for the most recent and last sent video bitrate allocation. Used to + // throttle sending of similar bitrate allocations. + struct VbaSendContext { + VideoBitrateAllocation last_sent_allocation; + absl::optional throttled_allocation; + int64_t last_send_time_ms; + }; + absl::optional video_bitrate_allocation_context_ + RTC_GUARDED_BY(rtp_transport_queue_); + const absl::optional configured_pacing_factor_; +}; +} // namespace internal +} // namespace webrtc +#endif // VIDEO_VIDEO_SEND_STREAM_IMPL_H_ -- cgit v1.2.3