/* * Copyright (c) 2014 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 "media/engine/webrtc_video_engine.h" #include <stdio.h> #include <algorithm> #include <cstdint> #include <initializer_list> #include <set> #include <string> #include <type_traits> #include <utility> #include "absl/algorithm/container.h" #include "absl/container/inlined_vector.h" #include "absl/functional/bind_front.h" #include "absl/strings/match.h" #include "absl/types/optional.h" #include "api/make_ref_counted.h" #include "api/media_stream_interface.h" #include "api/media_types.h" #include "api/priority.h" #include "api/rtc_error.h" #include "api/rtp_transceiver_direction.h" #include "api/units/time_delta.h" #include "api/units/timestamp.h" #include "api/video/resolution.h" #include "api/video/video_codec_type.h" #include "api/video_codecs/scalability_mode.h" #include "api/video_codecs/sdp_video_format.h" #include "api/video_codecs/video_codec.h" #include "api/video_codecs/video_decoder_factory.h" #include "api/video_codecs/video_encoder.h" #include "api/video_codecs/video_encoder_factory.h" #include "call/call.h" #include "call/packet_receiver.h" #include "call/receive_stream.h" #include "call/rtp_transport_controller_send_interface.h" #include "common_video/frame_counts.h" #include "common_video/include/quality_limitation_reason.h" #include "media/base/codec.h" #include "media/base/media_channel.h" #include "media/base/media_constants.h" #include "media/base/rid_description.h" #include "media/base/rtp_utils.h" #include "media/engine/webrtc_media_engine.h" #include "modules/rtp_rtcp/include/receive_statistics.h" #include "modules/rtp_rtcp/include/report_block_data.h" #include "modules/rtp_rtcp/include/rtcp_statistics.h" #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "modules/rtp_rtcp/source/rtp_util.h" #include "modules/video_coding/svc/scalability_mode_util.h" #include "rtc_base/checks.h" #include "rtc_base/dscp.h" #include "rtc_base/experiments/field_trial_parser.h" #include "rtc_base/logging.h" #include "rtc_base/socket.h" #include "rtc_base/strings/string_builder.h" #include "rtc_base/time_utils.h" #include "rtc_base/trace_event.h" namespace cricket { namespace { ParseRtpPayloadType; ParseRtpSsrc; constexpr int64_t kUnsignaledSsrcCooldownMs = …; // TODO(bugs.webrtc.org/13166): Remove AV1X when backwards compatibility is not // needed. constexpr char kAv1xCodecName[] = …; // This constant is really an on/off, lower-level configurable NACK history // duration hasn't been implemented. const int kNackHistoryMs = …; const int kDefaultRtcpReceiverReportSsrc = …; // Minimum time interval for logging stats. const int64_t kStatsLogIntervalMs = …; const char* StreamTypeToString( webrtc::VideoSendStream::StreamStats::StreamType type) { … } bool IsEnabled(const webrtc::FieldTrialsView& trials, absl::string_view name) { … } bool IsDisabled(const webrtc::FieldTrialsView& trials, absl::string_view name) { … } void AddDefaultFeedbackParams(Codec* codec, const webrtc::FieldTrialsView& trials) { … } // Helper function to determine whether a codec should use the [35, 63] range. // Should be used when adding new codecs (or variants). bool IsCodecValidForLowerRange(const Codec& codec) { … } // Get the default set of supported codecs. // is_decoder_factory is needed to keep track of the implict assumption that any // H264 decoder also supports constrained base line profile. // Also, is_decoder_factory is used to decide whether FlexFEC video format // should be advertised as supported. template <class T> std::vector<webrtc::SdpVideoFormat> GetDefaultSupportedFormats( const T* factory, bool is_decoder_factory, const webrtc::FieldTrialsView& trials) { … } // This function will assign dynamic payload types (in the range [96, 127] // and then [35, 63]) to the input codecs, and also add ULPFEC, RED, FlexFEC, // and associated RTX codecs for recognized codecs (VP8, VP9, H264, and RED). // It will also add default feedback params to the codecs. std::vector<Codec> AssignPayloadTypesAndAddRtx( const std::vector<webrtc::SdpVideoFormat>& supported_formats, bool include_rtx, const webrtc::FieldTrialsView& trials) { … } // TODO(kron): Perhaps it is better to move the implicit knowledge to the place // where codecs are negotiated. template <class T> std::vector<Codec> GetPayloadTypesAndDefaultCodecs( const T* factory, bool is_decoder_factory, bool include_rtx, const webrtc::FieldTrialsView& trials) { … } static std::string CodecVectorToString(const std::vector<Codec>& codecs) { … } static bool ValidateCodecFormats(const std::vector<Codec>& codecs) { … } static bool ValidateStreamParams(const StreamParams& sp) { … } // Returns true if the given codec is disallowed from doing simulcast. bool IsCodecDisabledForSimulcast(bool legacy_scalability_mode, webrtc::VideoCodecType codec_type) { … } bool IsLayerActive(const webrtc::RtpEncodingParameters& layer) { … } int NumActiveStreams(const webrtc::RtpParameters& rtp_parameters) { … } absl::optional<int> NumSpatialLayersFromEncoding( const webrtc::RtpParameters& rtp_parameters, size_t idx) { … } std::map<uint32_t, webrtc::VideoSendStream::StreamStats> MergeInfoAboutOutboundRtpSubstreams( const std::map<uint32_t, webrtc::VideoSendStream::StreamStats>& substreams) { … } bool IsActiveFromEncodings( absl::optional<uint32_t> ssrc, const std::vector<webrtc::RtpEncodingParameters>& encodings) { … } bool IsScalabilityModeSupportedByCodec( const Codec& codec, const std::string& scalability_mode, const webrtc::VideoSendStream::Config& config) { … } // Fallback to default value if the scalability mode is unset or unsupported by // the codec. void FallbackToDefaultScalabilityModeIfNotSupported( const Codec& codec, const webrtc::VideoSendStream::Config& config, std::vector<webrtc::RtpEncodingParameters>& encodings) { … } // Generate the list of codec parameters to pass down based on the negotiated // "codecs". Note that VideoCodecSettings correspond to concrete codecs like // VP8, VP9, H264 while VideoCodecs correspond also to "virtual" codecs like // RTX, ULPFEC, FLEXFEC. std::vector<VideoCodecSettings> MapCodecs(const std::vector<Codec>& codecs) { … } bool NonFlexfecReceiveCodecsHaveChanged(std::vector<VideoCodecSettings> before, std::vector<VideoCodecSettings> after) { … } std::string CodecSettingsVectorToString( const std::vector<VideoCodecSettings>& codecs) { … } void ExtractCodecInformation( rtc::ArrayView<const VideoCodecSettings> recv_codecs, std::map<int, int>& rtx_associated_payload_types, std::set<int>& raw_payload_types, std::vector<webrtc::VideoReceiveStreamInterface::Decoder>& decoders) { … } int ParseReceiveBufferSize(const webrtc::FieldTrialsView& trials) { … } } // namespace // --------------- WebRtcVideoEngine --------------------------- WebRtcVideoEngine::WebRtcVideoEngine( std::unique_ptr<webrtc::VideoEncoderFactory> video_encoder_factory, std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory, const webrtc::FieldTrialsView& trials) : … { … } WebRtcVideoEngine::~WebRtcVideoEngine() { … } std::unique_ptr<VideoMediaSendChannelInterface> WebRtcVideoEngine::CreateSendChannel( webrtc::Call* call, const MediaConfig& config, const VideoOptions& options, const webrtc::CryptoOptions& crypto_options, webrtc::VideoBitrateAllocatorFactory* video_bitrate_allocator_factory) { … } std::unique_ptr<VideoMediaReceiveChannelInterface> WebRtcVideoEngine::CreateReceiveChannel( webrtc::Call* call, const MediaConfig& config, const VideoOptions& options, const webrtc::CryptoOptions& crypto_options) { … } std::vector<Codec> WebRtcVideoEngine::send_codecs(bool include_rtx) const { … } std::vector<Codec> WebRtcVideoEngine::recv_codecs(bool include_rtx) const { … } std::vector<webrtc::RtpHeaderExtensionCapability> WebRtcVideoEngine::GetRtpHeaderExtensions() const { … } // Free function, exported for testing std::map<uint32_t, webrtc::VideoSendStream::StreamStats> MergeInfoAboutOutboundRtpSubstreamsForTesting( const std::map<uint32_t, webrtc::VideoSendStream::StreamStats>& substreams) { … } // --------------- WebRtcVideoSendChannel ---------------------- WebRtcVideoSendChannel::WebRtcVideoSendChannel( webrtc::Call* call, const MediaConfig& config, const VideoOptions& options, const webrtc::CryptoOptions& crypto_options, webrtc::VideoEncoderFactory* encoder_factory, webrtc::VideoDecoderFactory* decoder_factory, webrtc::VideoBitrateAllocatorFactory* bitrate_allocator_factory) : … { … } WebRtcVideoSendChannel::~WebRtcVideoSendChannel() { … } rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings> WebRtcVideoSendChannel::WebRtcVideoSendStream::ConfigureVideoEncoderSettings( const Codec& codec) { … } std::vector<VideoCodecSettings> WebRtcVideoSendChannel::SelectSendVideoCodecs( const std::vector<VideoCodecSettings>& remote_mapped_codecs) const { … } bool WebRtcVideoSendChannel::GetChangedSenderParameters( const VideoSenderParameters& params, ChangedSenderParameters* changed_params) const { … } bool WebRtcVideoSendChannel::SetSenderParameters( const VideoSenderParameters& params) { … } void WebRtcVideoSendChannel::RequestEncoderFallback() { … } void WebRtcVideoSendChannel::RequestEncoderSwitch( const webrtc::SdpVideoFormat& format, bool allow_default_fallback) { … } bool WebRtcVideoSendChannel::ApplyChangedParams( const ChangedSenderParameters& changed_params) { … } webrtc::RtpParameters WebRtcVideoSendChannel::GetRtpSendParameters( uint32_t ssrc) const { … } webrtc::RTCError WebRtcVideoSendChannel::SetRtpSendParameters( uint32_t ssrc, const webrtc::RtpParameters& parameters, webrtc::SetParametersCallback callback) { … } absl::optional<Codec> WebRtcVideoSendChannel::GetSendCodec() const { … } bool WebRtcVideoSendChannel::SetSend(bool send) { … } bool WebRtcVideoSendChannel::SetVideoSend( uint32_t ssrc, const VideoOptions* options, rtc::VideoSourceInterface<webrtc::VideoFrame>* source) { … } bool WebRtcVideoSendChannel::ValidateSendSsrcAvailability( const StreamParams& sp) const { … } bool WebRtcVideoSendChannel::AddSendStream(const StreamParams& sp) { … } bool WebRtcVideoSendChannel::RemoveSendStream(uint32_t ssrc) { … } bool WebRtcVideoSendChannel::GetStats(VideoMediaSendInfo* info) { … } void WebRtcVideoSendChannel::FillSenderStats( VideoMediaSendInfo* video_media_info, bool log_stats) { … } void WebRtcVideoSendChannel::FillBitrateInfo( BandwidthEstimationInfo* bwe_info) { … } void WebRtcVideoSendChannel::FillSendCodecStats( VideoMediaSendInfo* video_media_info) { … } void WebRtcVideoSendChannel::OnPacketSent(const rtc::SentPacket& sent_packet) { … } void WebRtcVideoSendChannel::OnReadyToSend(bool ready) { … } void WebRtcVideoSendChannel::OnNetworkRouteChanged( absl::string_view transport_name, const rtc::NetworkRoute& network_route) { … } void WebRtcVideoSendChannel::SetInterface(MediaChannelNetworkInterface* iface) { … } void WebRtcVideoSendChannel::SetFrameEncryptor( uint32_t ssrc, rtc::scoped_refptr<webrtc::FrameEncryptorInterface> frame_encryptor) { … } void WebRtcVideoSendChannel::SetEncoderSelector( uint32_t ssrc, webrtc::VideoEncoderFactory::EncoderSelectorInterface* encoder_selector) { … } WebRtcVideoSendChannel::WebRtcVideoSendStream::VideoSendStreamParameters:: VideoSendStreamParameters( webrtc::VideoSendStream::Config config, const VideoOptions& options, int max_bitrate_bps, const absl::optional<VideoCodecSettings>& codec_settings) : … { … } WebRtcVideoSendChannel::WebRtcVideoSendStream::WebRtcVideoSendStream( webrtc::Call* call, const StreamParams& sp, webrtc::VideoSendStream::Config config, const VideoOptions& options, bool enable_cpu_overuse_detection, int max_bitrate_bps, const absl::optional<VideoCodecSettings>& codec_settings, const absl::optional<std::vector<webrtc::RtpExtension>>& rtp_extensions, // TODO(deadbeef): Don't duplicate information between send_params, // rtp_extensions, options, etc. const VideoSenderParameters& send_params) : … { … } WebRtcVideoSendChannel::WebRtcVideoSendStream::~WebRtcVideoSendStream() { … } bool WebRtcVideoSendChannel::WebRtcVideoSendStream::SetVideoSend( const VideoOptions* options, rtc::VideoSourceInterface<webrtc::VideoFrame>* source) { … } webrtc::DegradationPreference WebRtcVideoSendChannel::WebRtcVideoSendStream::GetDegradationPreference() const { … } const std::vector<uint32_t>& WebRtcVideoSendChannel::WebRtcVideoSendStream::GetSsrcs() const { … } void WebRtcVideoSendChannel::WebRtcVideoSendStream::SetCodec( const VideoCodecSettings& codec_settings) { … } void WebRtcVideoSendChannel::WebRtcVideoSendStream::SetSenderParameters( const ChangedSenderParameters& params) { … } webrtc::RTCError WebRtcVideoSendChannel::WebRtcVideoSendStream::SetRtpParameters( const webrtc::RtpParameters& new_parameters, webrtc::SetParametersCallback callback) { … } webrtc::RtpParameters WebRtcVideoSendChannel::WebRtcVideoSendStream::GetRtpParameters() const { … } void WebRtcVideoSendChannel::WebRtcVideoSendStream::SetFrameEncryptor( rtc::scoped_refptr<webrtc::FrameEncryptorInterface> frame_encryptor) { … } void WebRtcVideoSendChannel::WebRtcVideoSendStream::SetEncoderSelector( webrtc::VideoEncoderFactory::EncoderSelectorInterface* encoder_selector) { … } void WebRtcVideoSendChannel::WebRtcVideoSendStream::UpdateSendState() { … } webrtc::VideoEncoderConfig WebRtcVideoSendChannel::WebRtcVideoSendStream::CreateVideoEncoderConfig( const Codec& codec) const { … } void WebRtcVideoSendChannel::WebRtcVideoSendStream::ReconfigureEncoder( webrtc::SetParametersCallback callback) { … } void WebRtcVideoSendChannel::WebRtcVideoSendStream::SetSend(bool send) { … } std::vector<VideoSenderInfo> WebRtcVideoSendChannel::WebRtcVideoSendStream::GetPerLayerVideoSenderInfos( bool log_stats) { … } VideoSenderInfo WebRtcVideoSendChannel::WebRtcVideoSendStream::GetAggregatedVideoSenderInfo( const std::vector<VideoSenderInfo>& infos) const { … } void WebRtcVideoSendChannel::WebRtcVideoSendStream::FillBitrateInfo( BandwidthEstimationInfo* bwe_info) { … } void WebRtcVideoSendChannel::WebRtcVideoSendStream:: SetEncoderToPacketizerFrameTransformer( rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) { … } void WebRtcVideoSendChannel::WebRtcVideoSendStream::RecreateWebRtcStream() { … } void WebRtcVideoSendChannel::WebRtcVideoSendStream::GenerateKeyFrame( const std::vector<std::string>& rids) { … } void WebRtcVideoSendChannel::GenerateSendKeyFrame( uint32_t ssrc, const std::vector<std::string>& rids) { … } void WebRtcVideoSendChannel::SetEncoderToPacketizerFrameTransformer( uint32_t ssrc, rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) { … } // ------------------------ WebRtcVideoReceiveChannel --------------------- WebRtcVideoReceiveChannel::WebRtcVideoReceiveChannel( webrtc::Call* call, const MediaConfig& config, const VideoOptions& options, const webrtc::CryptoOptions& crypto_options, webrtc::VideoDecoderFactory* decoder_factory) : … { … } WebRtcVideoReceiveChannel::~WebRtcVideoReceiveChannel() { … } void WebRtcVideoReceiveChannel::SetReceiverFeedbackParameters( bool lntf_enabled, bool nack_enabled, webrtc::RtcpMode rtcp_mode, absl::optional<int> rtx_time) { … } webrtc::RtpParameters WebRtcVideoReceiveChannel::GetRtpReceiverParameters( uint32_t ssrc) const { … } webrtc::RtpParameters WebRtcVideoReceiveChannel::GetDefaultRtpReceiveParameters() const { … } bool WebRtcVideoReceiveChannel::GetChangedReceiverParameters( const VideoReceiverParameters& params, ChangedReceiverParameters* changed_params) const { … } bool WebRtcVideoReceiveChannel::SetReceiverParameters( const VideoReceiverParameters& params) { … } void WebRtcVideoReceiveChannel::SetReceiverReportSsrc(uint32_t ssrc) { … } void WebRtcVideoReceiveChannel::ChooseReceiverReportSsrc( const std::set<uint32_t>& choices) { … } void WebRtcVideoReceiveChannel::SetReceive(bool receive) { … } bool WebRtcVideoReceiveChannel::ValidateReceiveSsrcAvailability( const StreamParams& sp) const { … } void WebRtcVideoReceiveChannel::DeleteReceiveStream( WebRtcVideoReceiveStream* stream) { … } bool WebRtcVideoReceiveChannel::AddRecvStream(const StreamParams& sp) { … } bool WebRtcVideoReceiveChannel::AddRecvStream(const StreamParams& sp, bool default_stream) { … } void WebRtcVideoReceiveChannel::ConfigureReceiverRtp( webrtc::VideoReceiveStreamInterface::Config* config, webrtc::FlexfecReceiveStream::Config* flexfec_config, const StreamParams& sp) const { … } bool WebRtcVideoReceiveChannel::RemoveRecvStream(uint32_t ssrc) { … } void WebRtcVideoReceiveChannel::ResetUnsignaledRecvStream() { … } absl::optional<uint32_t> WebRtcVideoReceiveChannel::GetUnsignaledSsrc() const { … } void WebRtcVideoReceiveChannel::OnDemuxerCriteriaUpdatePending() { … } void WebRtcVideoReceiveChannel::OnDemuxerCriteriaUpdateComplete() { … } bool WebRtcVideoReceiveChannel::SetSink( uint32_t ssrc, rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { … } void WebRtcVideoReceiveChannel::SetDefaultSink( rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { … } bool WebRtcVideoReceiveChannel::GetStats(VideoMediaReceiveInfo* info) { … } void WebRtcVideoReceiveChannel::FillReceiverStats( VideoMediaReceiveInfo* video_media_info, bool log_stats) { … } void WebRtcVideoReceiveChannel::FillReceiveCodecStats( VideoMediaReceiveInfo* video_media_info) { … } void WebRtcVideoReceiveChannel::OnPacketReceived( const webrtc::RtpPacketReceived& packet) { … } bool WebRtcVideoReceiveChannel::MaybeCreateDefaultReceiveStream( const webrtc::RtpPacketReceived& packet) { … } void WebRtcVideoReceiveChannel::ReCreateDefaultReceiveStream( uint32_t ssrc, absl::optional<uint32_t> rtx_ssrc) { … } void WebRtcVideoReceiveChannel::SetInterface( MediaChannelNetworkInterface* iface) { … } void WebRtcVideoReceiveChannel::SetFrameDecryptor( uint32_t ssrc, rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor) { … } bool WebRtcVideoReceiveChannel::SetBaseMinimumPlayoutDelayMs(uint32_t ssrc, int delay_ms) { … } absl::optional<int> WebRtcVideoReceiveChannel::GetBaseMinimumPlayoutDelayMs( uint32_t ssrc) const { … } std::vector<webrtc::RtpSource> WebRtcVideoReceiveChannel::GetSources( uint32_t ssrc) const { … } WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream( webrtc::Call* call, const StreamParams& sp, webrtc::VideoReceiveStreamInterface::Config config, bool default_stream, const std::vector<VideoCodecSettings>& recv_codecs, const webrtc::FlexfecReceiveStream::Config& flexfec_config) : … { … } WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream:: ~WebRtcVideoReceiveStream() { … } webrtc::VideoReceiveStreamInterface& WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::stream() { … } webrtc::FlexfecReceiveStream* WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::flexfec_stream() { … } const std::vector<uint32_t>& WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::GetSsrcs() const { … } std::vector<webrtc::RtpSource> WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::GetSources() { … } webrtc::RtpParameters WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::GetRtpParameters() const { … } bool WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::ReconfigureCodecs( const std::vector<VideoCodecSettings>& recv_codecs) { … } void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::SetFeedbackParameters( bool lntf_enabled, bool nack_enabled, webrtc::RtcpMode rtcp_mode, absl::optional<int> rtx_time) { … } void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::SetFlexFecPayload( int payload_type) { … } void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::SetReceiverParameters( const ChangedReceiverParameters& params) { … } void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream:: RecreateReceiveStream() { … } void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream:: CreateReceiveStream() { … } void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::StartReceiveStream() { … } void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::StopReceiveStream() { … } void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::OnFrame( const webrtc::VideoFrame& frame) { … } bool WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::IsDefaultStream() const { … } void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::SetFrameDecryptor( rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor) { … } bool WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream:: SetBaseMinimumPlayoutDelayMs(int delay_ms) { … } int WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream:: GetBaseMinimumPlayoutDelayMs() const { … } void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::SetSink( rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { … } VideoReceiverInfo WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::GetVideoReceiverInfo( bool log_stats) { … } void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream:: SetRecordableEncodedFrameCallback( std::function<void(const webrtc::RecordableEncodedFrame&)> callback) { … } void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream:: ClearRecordableEncodedFrameCallback() { … } void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::GenerateKeyFrame() { … } void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream:: SetDepacketizerToDecoderFrameTransformer( rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) { … } void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::SetLocalSsrc( uint32_t ssrc) { … } void WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream::UpdateRtxSsrc( uint32_t ssrc) { … } WebRtcVideoReceiveChannel::WebRtcVideoReceiveStream* WebRtcVideoReceiveChannel::FindReceiveStream(uint32_t ssrc) { … } // RTC_RUN_ON(worker_thread_) void WebRtcVideoReceiveChannel::ProcessReceivedPacket( webrtc::RtpPacketReceived packet) { … } void WebRtcVideoReceiveChannel::SetRecordableEncodedFrameCallback( uint32_t ssrc, std::function<void(const webrtc::RecordableEncodedFrame&)> callback) { … } void WebRtcVideoReceiveChannel::ClearRecordableEncodedFrameCallback( uint32_t ssrc) { … } void WebRtcVideoReceiveChannel::RequestRecvKeyFrame(uint32_t ssrc) { … } void WebRtcVideoReceiveChannel::SetDepacketizerToDecoderFrameTransformer( uint32_t ssrc, rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) { … } // ------------------------- VideoCodecSettings -------------------- VideoCodecSettings::VideoCodecSettings(const Codec& codec) : … { … } bool VideoCodecSettings::operator==(const VideoCodecSettings& other) const { … } bool VideoCodecSettings::EqualsDisregardingFlexfec( const VideoCodecSettings& a, const VideoCodecSettings& b) { … } bool VideoCodecSettings::operator!=(const VideoCodecSettings& other) const { … } } // namespace cricket
Codebase Browser
chromium