zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "Revert "Revert "Add ProtectionBitrateCalculator as an abstract class. ProtectionBitrateCalculatorDefault implements ProtectionBitrateCalculator. Register VideoSendStream to packet feedback"""

Browse Source 
This reverts commit 718d8631b0294a8bdc56366b68c51e2f04cd0c9e.

Reason for revert: <INSERT REASONING HERE>

Original change's description:
> Revert "Revert "Add ProtectionBitrateCalculator as an abstract class. ProtectionBitrateCalculatorDefault implements ProtectionBitrateCalculator. Register VideoSendStream to packet feedback""
> 
> This reverts commit 53d901332c2eb43cad0da5768c6f7a8c4aeb9590.
> 
> Reason for revert: root cause has been found and will be addressed in the patch.The root cause was protection_bitrate_calculator_ is now destructed before worker_queue_, and worker_queue_ may contain tasks which involves protection_bitrate_calculator_, so they need to be destructed in the opposite order.
> That was not an issue since before this cl we didn't allocate protection_bitrate_calculator_ on the heap.
> 
> Original change's description:
> > Revert "Add ProtectionBitrateCalculator as an abstract class. ProtectionBitrateCalculatorDefault implements ProtectionBitrateCalculator. Register VideoSendStream to packet feedback"
> >
> > This reverts commit e58e91b6d143ef847f8df24b19de4ba98cdb6f72.
> >
> > Reason for revert: Breaks downstream project b/70848177
> >
> > Original change's description:
> > > Add ProtectionBitrateCalculator as an abstract class. ProtectionBitrateCalculatorDefault implements ProtectionBitrateCalculator. Register VideoSendStream to packet feedback
> > >
> > > Bug: webrtc:8656
> > > Change-Id: Iab4f6ab8997cb082762218afc8580e9985ac2522
> > > Reviewed-on: https://webrtc-review.googlesource.com/33010
> > > Commit-Queue: Ying Wang <yinwa@webrtc.org>
> > > Reviewed-by: Stefan Holmer <stefan@webrtc.org>
> > > Cr-Commit-Position: refs/heads/master@{#21348}
> >
> > TBR=stefan@webrtc.org,philipel@webrtc.org,yinwa@webrtc.org
> >
> > Change-Id: Ic186ba78be429bd1046ceac15051a3382b6ffc4f
> > No-Presubmit: true
> > No-Tree-Checks: true
> > No-Try: true
> > Bug: webrtc:8656
> > Reviewed-on: https://webrtc-review.googlesource.com/35080
> > Commit-Queue: Lu Liu <lliuu@webrtc.org>
> > Reviewed-by: Lu Liu <lliuu@webrtc.org>
> > Cr-Commit-Position: refs/heads/master@{#21374}
> 
> TBR=stefan@webrtc.org,philipel@webrtc.org,lliuu@webrtc.org,yujo@chromium.org,yinwa@webrtc.org
> 
> Change-Id: Ie2b5a2a2ead0f20ac67c1ea9b8d192af66bddf8d
> No-Presubmit: true
> No-Tree-Checks: true
> No-Try: true
> Bug: webrtc:8656
> Reviewed-on: https://webrtc-review.googlesource.com/35320
> Reviewed-by: Stefan Holmer <stefan@webrtc.org>
> Reviewed-by: Ying Wang <yinwa@webrtc.org>
> Commit-Queue: Ying Wang <yinwa@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#21409}

TBR=stefan@webrtc.org,philipel@webrtc.org,lliuu@webrtc.org,yujo@chromium.org,yinwa@webrtc.org

Change-Id: I9773aaa942054dcfbab6002a5d713ab3526b0534
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: webrtc:8656
Reviewed-on: https://webrtc-review.googlesource.com/35700
Reviewed-by: Ying Wang <yinwa@webrtc.org>
Commit-Queue: Ying Wang <yinwa@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#21410}
This commit is contained in:
Ying Wang
2017-12-21 12:26:19 +00:00
committed by Commit Bot
parent 718d8631b0
commit 38a31b0af6
7 changed files with 64 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
modules/video_coding/BUILD.gn
View File

@ -57,9 +57,8 @@ rtc_static_library("video_coding") {
"packet.h", "packet.h",
"packet_buffer.cc", "packet_buffer.cc",
"packet_buffer.h", "packet_buffer.h",
"protection_bitrate_calculator.cc",
"protection_bitrate_calculator.h", "protection_bitrate_calculator.h",
"protection_bitrate_calculator_default.cc",
"protection_bitrate_calculator_default.h",
"qp_parser.cc", "qp_parser.cc",
"qp_parser.h", "qp_parser.h",
"receiver.cc", "receiver.cc",

23
modules/video_coding/protection_bitrate_calculator_default.cc → modules/video_coding/protection_bitrate_calculator.cc
View File

@ -8,13 +8,13 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
#include "modules/video_coding/protection_bitrate_calculator_default.h" #include "modules/video_coding/protection_bitrate_calculator.h"
namespace webrtc { namespace webrtc {
using rtc::CritScope; using rtc::CritScope;
ProtectionBitrateCalculatorDefault::ProtectionBitrateCalculatorDefault( ProtectionBitrateCalculator::ProtectionBitrateCalculator(
Clock* clock, Clock* clock,
VCMProtectionCallback* protection_callback) VCMProtectionCallback* protection_callback)
: clock_(clock), : clock_(clock),
@ -23,22 +23,21 @@ ProtectionBitrateCalculatorDefault::ProtectionBitrateCalculatorDefault(
clock_->TimeInMilliseconds())), clock_->TimeInMilliseconds())),
max_payload_size_(1460) {} max_payload_size_(1460) {}
ProtectionBitrateCalculatorDefault::~ProtectionBitrateCalculatorDefault(void) { ProtectionBitrateCalculator::~ProtectionBitrateCalculator(void) {
loss_prot_logic_->Release(); loss_prot_logic_->Release();
} }
void ProtectionBitrateCalculatorDefault::SetEncodingData( void ProtectionBitrateCalculator::SetEncodingData(size_t width,
size_t width, size_t height,
size_t height, size_t num_temporal_layers,
size_t num_temporal_layers, size_t max_payload_size) {
size_t max_payload_size) {
CritScope lock(&crit_sect_); CritScope lock(&crit_sect_);
loss_prot_logic_->UpdateFrameSize(width, height); loss_prot_logic_->UpdateFrameSize(width, height);
loss_prot_logic_->UpdateNumLayers(num_temporal_layers); loss_prot_logic_->UpdateNumLayers(num_temporal_layers);
max_payload_size_ = max_payload_size; max_payload_size_ = max_payload_size;
} }
uint32_t ProtectionBitrateCalculatorDefault::SetTargetRates( uint32_t ProtectionBitrateCalculator::SetTargetRates(
uint32_t estimated_bitrate_bps, uint32_t estimated_bitrate_bps,
int actual_framerate_fps, int actual_framerate_fps,
uint8_t fraction_lost, uint8_t fraction_lost,
@ -139,8 +138,8 @@ uint32_t ProtectionBitrateCalculatorDefault::SetTargetRates(
return estimated_bitrate_bps * (1.0 - protection_overhead_rate); return estimated_bitrate_bps * (1.0 - protection_overhead_rate);
} }
void ProtectionBitrateCalculatorDefault::SetProtectionMethod(bool enable_fec, void ProtectionBitrateCalculator::SetProtectionMethod(bool enable_fec,
bool enable_nack) { bool enable_nack) {
media_optimization::VCMProtectionMethodEnum method(media_optimization::kNone); media_optimization::VCMProtectionMethodEnum method(media_optimization::kNone);
if (enable_fec && enable_nack) { if (enable_fec && enable_nack) {
method = media_optimization::kNackFec; method = media_optimization::kNackFec;
@ -153,7 +152,7 @@ void ProtectionBitrateCalculatorDefault::SetProtectionMethod(bool enable_fec,
loss_prot_logic_->SetMethod(method); loss_prot_logic_->SetMethod(method);
} }
void ProtectionBitrateCalculatorDefault::UpdateWithEncodedData( void ProtectionBitrateCalculator::UpdateWithEncodedData(
const EncodedImage& encoded_image) { const EncodedImage& encoded_image) {
const size_t encoded_length = encoded_image._length; const size_t encoded_length = encoded_image._length;
CritScope lock(&crit_sect_); CritScope lock(&crit_sect_);

58
modules/video_coding/protection_bitrate_calculator.h
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2017 The WebRTC project authors. All Rights Reserved. * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
* *
* Use of this source code is governed by a BSD-style license * 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 * that can be found in the LICENSE file in the root of the source
@ -13,7 +13,6 @@
#include <list> #include <list>
#include <memory> #include <memory>
#include <vector>
#include "modules/include/module_common_types.h" #include "modules/include/module_common_types.h"
#include "modules/video_coding/include/video_coding.h" #include "modules/video_coding/include/video_coding.h"
@ -23,38 +22,57 @@
namespace webrtc { namespace webrtc {
// ProtectionBitrateCalculator calculates how much of the allocated network
// capacity that can be used by an encoder and how much that
// is needed for redundant packets such as FEC and NACK. It uses an
// implementation of |VCMProtectionCallback| to set new FEC parameters and get
// the bitrate currently used for FEC and NACK.
// Usage:
// Setup by calling SetProtectionMethod and SetEncodingData.
// For each encoded image, call UpdateWithEncodedData.
// Each time the bandwidth estimate change, call SetTargetRates. SetTargetRates
// will return the bitrate that can be used by an encoder.
// A lock is used to protect internal states, so methods can be called on an
// arbitrary thread.
class ProtectionBitrateCalculator { class ProtectionBitrateCalculator {
public: public:
virtual ~ProtectionBitrateCalculator() {} ProtectionBitrateCalculator(Clock* clock,
VCMProtectionCallback* protection_callback);
~ProtectionBitrateCalculator();
virtual void SetProtectionMethod(bool enable_fec, bool enable_nack) = 0; void SetProtectionMethod(bool enable_fec, bool enable_nack);
// Informs media optimization of initial encoding state. // Informs media optimization of initial encoding state.
virtual void SetEncodingData(size_t width, void SetEncodingData(size_t width,
size_t height, size_t height,
size_t num_temporal_layers, size_t num_temporal_layers,
size_t max_payload_size) = 0; size_t max_payload_size);
// Returns target rate for the encoder given the channel parameters. // Returns target rate for the encoder given the channel parameters.
// Inputs: estimated_bitrate_bps - the estimated network bitrate in bits/s. // Inputs: estimated_bitrate_bps - the estimated network bitrate in bits/s.
// actual_framerate - encoder frame rate. // actual_framerate - encoder frame rate.
// fraction_lost - packet loss rate in % in the network. // fraction_lost - packet loss rate in % in the network.
// round_trip_time_ms - round trip time in milliseconds. // round_trip_time_ms - round trip time in milliseconds.
virtual uint32_t SetTargetRates(uint32_t estimated_bitrate_bps, uint32_t SetTargetRates(uint32_t estimated_bitrate_bps,
int actual_framerate, int actual_framerate,
uint8_t fraction_lost, uint8_t fraction_lost,
int64_t round_trip_time_ms) = 0; int64_t round_trip_time_ms);
virtual uint32_t SetTargetRates(uint32_t estimated_bitrate_bps,
std::vector<uint8_t> loss_mask_vector,
int64_t round_trip_time_ms) = 0;
// Informs of encoded output. // Informs of encoded output.
virtual void UpdateWithEncodedData(const EncodedImage& encoded_image) = 0; void UpdateWithEncodedData(const EncodedImage& encoded_image);
virtual void OnLossMaskVector(const std::vector<bool> loss_mask_vector) = 0; private:
enum { kBitrateAverageWinMs = 1000 };
Clock* const clock_;
VCMProtectionCallback* const protection_callback_;
rtc::CriticalSection crit_sect_;
std::unique_ptr<media_optimization::VCMLossProtectionLogic> loss_prot_logic_
RTC_GUARDED_BY(crit_sect_);
size_t max_payload_size_ RTC_GUARDED_BY(crit_sect_);
RTC_DISALLOW_COPY_AND_ASSIGN(ProtectionBitrateCalculator);
}; };
} // namespace webrtc } // namespace webrtc
#endif // MODULES_VIDEO_CODING_PROTECTION_BITRATE_CALCULATOR_H_ #endif // MODULES_VIDEO_CODING_PROTECTION_BITRATE_CALCULATOR_H_

87
modules/video_coding/protection_bitrate_calculator_default.h
View File

@ -1,87 +0,0 @@
/*
* Copyright (c) 2016 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 MODULES_VIDEO_CODING_PROTECTION_BITRATE_CALCULATOR_DEFAULT_H_
#define MODULES_VIDEO_CODING_PROTECTION_BITRATE_CALCULATOR_DEFAULT_H_
#include <list>
#include <memory>
#include <vector>
#include "modules/include/module_common_types.h"
#include "modules/video_coding/include/video_coding.h"
#include "modules/video_coding/media_opt_util.h"
#include "modules/video_coding/protection_bitrate_calculator.h"
#include "rtc_base/criticalsection.h"
#include "system_wrappers/include/clock.h"
namespace webrtc {
// ProtectionBitrateCalculator calculates how much of the allocated network
// capacity that can be used by an encoder and how much that
// is needed for redundant packets such as FEC and NACK. It uses an
// implementation of |VCMProtectionCallback| to set new FEC parameters and get
// the bitrate currently used for FEC and NACK.
// Usage:
// Setup by calling SetProtectionMethod and SetEncodingData.
// For each encoded image, call UpdateWithEncodedData.
// Each time the bandwidth estimate change, call SetTargetRates. SetTargetRates
// will return the bitrate that can be used by an encoder.
// A lock is used to protect internal states, so methods can be called on an
// arbitrary thread.
class ProtectionBitrateCalculatorDefault : public ProtectionBitrateCalculator {
public:
ProtectionBitrateCalculatorDefault(
Clock* clock,
VCMProtectionCallback* protection_callback);
~ProtectionBitrateCalculatorDefault();
void SetProtectionMethod(bool enable_fec, bool enable_nack) override;
// Informs media optimization of initial encoding state.
void SetEncodingData(size_t width,
size_t height,
size_t num_temporal_layers,
size_t max_payload_size) override;
uint32_t SetTargetRates(uint32_t estimated_bitrate_bps,
std::vector<uint8_t> loss_mask_vector,
int64_t round_trip_time_ms) override {
return 0;
}
void OnLossMaskVector(const std::vector<bool> loss_mask_vector) override {}
// Returns target rate for the encoder given the channel parameters.
// Inputs: estimated_bitrate_bps - the estimated network bitrate in bits/s.
// actual_framerate - encoder frame rate.
// fraction_lost - packet loss rate in % in the network.
// round_trip_time_ms - round trip time in milliseconds.
uint32_t SetTargetRates(uint32_t estimated_bitrate_bps,
int actual_framerate,
uint8_t fraction_lost,
int64_t round_trip_time_ms) override;
// Informs of encoded output.
void UpdateWithEncodedData(const EncodedImage& encoded_image) override;
private:
enum { kBitrateAverageWinMs = 1000 };
Clock* const clock_;
VCMProtectionCallback* const protection_callback_;
rtc::CriticalSection crit_sect_;
std::unique_ptr<media_optimization::VCMLossProtectionLogic> loss_prot_logic_
RTC_GUARDED_BY(crit_sect_);
size_t max_payload_size_ RTC_GUARDED_BY(crit_sect_);
RTC_DISALLOW_COPY_AND_ASSIGN(ProtectionBitrateCalculatorDefault);
};
} // namespace webrtc
#endif // MODULES_VIDEO_CODING_PROTECTION_BITRATE_CALCULATOR_DEFAULT_H_

4
modules/video_coding/protection_bitrate_calculator_unittest.cc
View File

@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
#include "modules/video_coding/protection_bitrate_calculator_default.h" #include "modules/video_coding/protection_bitrate_calculator.h"
#include "system_wrappers/include/clock.h" #include "system_wrappers/include/clock.h"
#include "test/gtest.h" #include "test/gtest.h"
@ -46,7 +46,7 @@ class ProtectionBitrateCalculatorTest : public ::testing::Test {
SimulatedClock clock_; SimulatedClock clock_;
ProtectionCallback protection_callback_; ProtectionCallback protection_callback_;
ProtectionBitrateCalculatorDefault media_opt_; ProtectionBitrateCalculator media_opt_;
}; };
TEST_F(ProtectionBitrateCalculatorTest, ProtectsUsingFecBitrate) { TEST_F(ProtectionBitrateCalculatorTest, ProtectsUsingFecBitrate) {

73
video/video_send_stream.cc
View File

@ -11,14 +11,12 @@
#include <algorithm> #include <algorithm>
#include <cmath> #include <cmath>
#include <set>
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include "call/rtp_transport_controller_send_interface.h" #include "call/rtp_transport_controller_send_interface.h"
#include "call/video_send_stream.h"
#include "common_types.h" // NOLINT(build/include) #include "common_types.h" // NOLINT(build/include)
#include "common_video/include/video_bitrate_allocator.h" #include "common_video/include/video_bitrate_allocator.h"
#include "modules/bitrate_controller/include/bitrate_controller.h" #include "modules/bitrate_controller/include/bitrate_controller.h"
@ -28,7 +26,6 @@
#include "modules/rtp_rtcp/include/rtp_rtcp.h" #include "modules/rtp_rtcp/include/rtp_rtcp.h"
#include "modules/rtp_rtcp/source/rtp_sender.h" #include "modules/rtp_rtcp/source/rtp_sender.h"
#include "modules/utility/include/process_thread.h" #include "modules/utility/include/process_thread.h"
#include "modules/video_coding/protection_bitrate_calculator_default.h"
#include "modules/video_coding/utility/ivf_file_writer.h" #include "modules/video_coding/utility/ivf_file_writer.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
#include "rtc_base/file.h" #include "rtc_base/file.h"
@ -39,12 +36,11 @@
#include "system_wrappers/include/field_trial.h" #include "system_wrappers/include/field_trial.h"
#include "video/call_stats.h" #include "video/call_stats.h"
#include "video/payload_router.h" #include "video/payload_router.h"
#include "call/video_send_stream.h"
namespace webrtc { namespace webrtc {
static const int kMinSendSidePacketHistorySize = 600; static const int kMinSendSidePacketHistorySize = 600;
static const int kSendSideSeqNumSetMaxSize = 15000;
namespace { namespace {
// We don't do MTU discovery, so assume that we have the standard ethernet MTU. // We don't do MTU discovery, so assume that we have the standard ethernet MTU.
@ -248,8 +244,7 @@ class VideoSendStreamImpl : public webrtc::BitrateAllocatorObserver,
public webrtc::OverheadObserver, public webrtc::OverheadObserver,
public webrtc::VCMProtectionCallback, public webrtc::VCMProtectionCallback,
public VideoStreamEncoder::EncoderSink, public VideoStreamEncoder::EncoderSink,
public VideoBitrateAllocationObserver, public VideoBitrateAllocationObserver {
public webrtc::PacketFeedbackObserver {
public: public:
VideoSendStreamImpl( VideoSendStreamImpl(
SendStatisticsProxy* stats_proxy, SendStatisticsProxy* stats_proxy,
@ -288,11 +283,6 @@ class VideoSendStreamImpl : public webrtc::BitrateAllocatorObserver,
void SetTransportOverhead(size_t transport_overhead_per_packet); void SetTransportOverhead(size_t transport_overhead_per_packet);
// From PacketFeedbackObserver.
void OnPacketAdded(uint32_t ssrc, uint16_t seq_num) override;
void OnPacketFeedbackVector(
const std::vector<PacketFeedback>& packet_feedback_vector) override;
private: private:
class CheckEncoderActivityTask; class CheckEncoderActivityTask;
class EncoderReconfiguredTask; class EncoderReconfiguredTask;
@ -333,11 +323,11 @@ class VideoSendStreamImpl : public webrtc::BitrateAllocatorObserver,
void SignalEncoderActive(); void SignalEncoderActive();
const bool send_side_bwe_with_overhead_; const bool send_side_bwe_with_overhead_;
SendStatisticsProxy* const stats_proxy_; SendStatisticsProxy* const stats_proxy_;
const VideoSendStream::Config* const config_; const VideoSendStream::Config* const config_;
std::map<uint32_t, RtpState> suspended_ssrcs_; std::map<uint32_t, RtpState> suspended_ssrcs_;
std::unique_ptr<ProtectionBitrateCalculator> protection_bitrate_calculator_;
ProcessThread* module_process_thread_; ProcessThread* module_process_thread_;
rtc::ThreadChecker module_process_thread_checker_; rtc::ThreadChecker module_process_thread_checker_;
rtc::TaskQueue* const worker_queue_; rtc::TaskQueue* const worker_queue_;
@ -364,6 +354,7 @@ class VideoSendStreamImpl : public webrtc::BitrateAllocatorObserver,
VideoStreamEncoder* const video_stream_encoder_; VideoStreamEncoder* const video_stream_encoder_;
EncoderRtcpFeedback encoder_feedback_; EncoderRtcpFeedback encoder_feedback_;
ProtectionBitrateCalculator protection_bitrate_calculator_;
RtcpBandwidthObserver* const bandwidth_observer_; RtcpBandwidthObserver* const bandwidth_observer_;
// RtpRtcp modules, declared here as they use other members on construction. // RtpRtcp modules, declared here as they use other members on construction.
@ -382,8 +373,6 @@ class VideoSendStreamImpl : public webrtc::BitrateAllocatorObserver,
size_t overhead_bytes_per_packet_ size_t overhead_bytes_per_packet_
RTC_GUARDED_BY(overhead_bytes_per_packet_crit_); RTC_GUARDED_BY(overhead_bytes_per_packet_crit_);
size_t transport_overhead_bytes_per_packet_; size_t transport_overhead_bytes_per_packet_;
std::set<uint16_t> feedback_packet_seq_num_set_;
}; };
// TODO(tommi): See if there's a more elegant way to create a task that creates // TODO(tommi): See if there's a more elegant way to create a task that creates
@ -596,6 +585,7 @@ VideoSendStream::VideoSendStream(
// Only signal target bitrate for screenshare streams, for now. // Only signal target bitrate for screenshare streams, for now.
video_stream_encoder_->SetBitrateObserver(send_stream_.get()); video_stream_encoder_->SetBitrateObserver(send_stream_.get());
} }
ReconfigureVideoEncoder(std::move(encoder_config)); ReconfigureVideoEncoder(std::move(encoder_config));
} }
@ -709,10 +699,6 @@ VideoSendStreamImpl::VideoSendStreamImpl(
stats_proxy_(stats_proxy), stats_proxy_(stats_proxy),
config_(config), config_(config),
suspended_ssrcs_(std::move(suspended_ssrcs)), suspended_ssrcs_(std::move(suspended_ssrcs)),
protection_bitrate_calculator_(
rtc::MakeUnique<ProtectionBitrateCalculatorDefault>(
Clock::GetRealTimeClock(),
this)),
module_process_thread_(nullptr), module_process_thread_(nullptr),
worker_queue_(worker_queue), worker_queue_(worker_queue),
check_encoder_activity_task_(nullptr), check_encoder_activity_task_(nullptr),
@ -728,6 +714,7 @@ VideoSendStreamImpl::VideoSendStreamImpl(
encoder_feedback_(Clock::GetRealTimeClock(), encoder_feedback_(Clock::GetRealTimeClock(),
config_->rtp.ssrcs, config_->rtp.ssrcs,
video_stream_encoder), video_stream_encoder),
protection_bitrate_calculator_(Clock::GetRealTimeClock(), this),
bandwidth_observer_(transport->send_side_cc()->GetBandwidthObserver()), bandwidth_observer_(transport->send_side_cc()->GetBandwidthObserver()),
rtp_rtcp_modules_(CreateRtpRtcpModules( rtp_rtcp_modules_(CreateRtpRtcpModules(
config_->send_transport, config_->send_transport,
@ -824,8 +811,6 @@ VideoSendStreamImpl::VideoSendStreamImpl(
config_->encoder_settings.payload_type, config_->encoder_settings.payload_type,
config_->encoder_settings.payload_name.c_str()); config_->encoder_settings.payload_name.c_str());
} }
// Signal congestion controller this object is ready for OnPacket* callbacks.
transport_->send_side_cc()->RegisterPacketFeedbackObserver(this);
RTC_DCHECK(config_->encoder_settings.encoder); RTC_DCHECK(config_->encoder_settings.encoder);
RTC_DCHECK_GE(config_->encoder_settings.payload_type, 0); RTC_DCHECK_GE(config_->encoder_settings.payload_type, 0);
@ -869,7 +854,7 @@ VideoSendStreamImpl::~VideoSendStreamImpl() {
RTC_DCHECK(!payload_router_.IsActive()) RTC_DCHECK(!payload_router_.IsActive())
<< "VideoSendStreamImpl::Stop not called"; << "VideoSendStreamImpl::Stop not called";
RTC_LOG(LS_INFO) << "~VideoSendStreamInternal: " << config_->ToString(); RTC_LOG(LS_INFO) << "~VideoSendStreamInternal: " << config_->ToString();
transport_->send_side_cc()->DeRegisterPacketFeedbackObserver(this);
for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
transport_->packet_router()->RemoveSendRtpModule(rtp_rtcp); transport_->packet_router()->RemoveSendRtpModule(rtp_rtcp);
delete rtp_rtcp; delete rtp_rtcp;
@ -981,7 +966,7 @@ void VideoSendStreamImpl::OnEncoderConfigurationChanged(
size_t number_of_temporal_layers = size_t number_of_temporal_layers =
streams.back().temporal_layer_thresholds_bps.size() + 1; streams.back().temporal_layer_thresholds_bps.size() + 1;
protection_bitrate_calculator_->SetEncodingData( protection_bitrate_calculator_.SetEncodingData(
streams[0].width, streams[0].height, number_of_temporal_layers, streams[0].width, streams[0].height, number_of_temporal_layers,
config_->rtp.max_packet_size); config_->rtp.max_packet_size);
@ -1017,7 +1002,7 @@ EncodedImageCallback::Result VideoSendStreamImpl::OnEncodedImage(
check_encoder_activity_task_->UpdateEncoderActivity(); check_encoder_activity_task_->UpdateEncoderActivity();
} }
protection_bitrate_calculator_->UpdateWithEncodedData(encoded_image); protection_bitrate_calculator_.UpdateWithEncodedData(encoded_image);
EncodedImageCallback::Result result = payload_router_.OnEncodedImage( EncodedImageCallback::Result result = payload_router_.OnEncodedImage(
encoded_image, codec_specific_info, fragmentation); encoded_image, codec_specific_info, fragmentation);
@ -1123,7 +1108,7 @@ void VideoSendStreamImpl::ConfigureProtection() {
// Currently, both ULPFEC and FlexFEC use the same FEC rate calculation logic, // Currently, both ULPFEC and FlexFEC use the same FEC rate calculation logic,
// so enable that logic if either of those FEC schemes are enabled. // so enable that logic if either of those FEC schemes are enabled.
protection_bitrate_calculator_->SetProtectionMethod( protection_bitrate_calculator_.SetProtectionMethod(
flexfec_enabled || IsUlpfecEnabled(), nack_enabled); flexfec_enabled || IsUlpfecEnabled(), nack_enabled);
} }
@ -1231,7 +1216,7 @@ uint32_t VideoSendStreamImpl::OnBitrateUpdated(uint32_t bitrate_bps,
// Get the encoder target rate. It is the estimated network rate - // Get the encoder target rate. It is the estimated network rate -
// protection overhead. // protection overhead.
encoder_target_rate_bps_ = protection_bitrate_calculator_->SetTargetRates( encoder_target_rate_bps_ = protection_bitrate_calculator_.SetTargetRates(
payload_bitrate_bps, stats_proxy_->GetSendFrameRate(), fraction_loss, payload_bitrate_bps, stats_proxy_->GetSendFrameRate(), fraction_loss,
rtt); rtt);
@ -1332,41 +1317,5 @@ void VideoSendStreamImpl::SetTransportOverhead(
} }
} }
void VideoSendStreamImpl::OnPacketAdded(uint32_t ssrc, uint16_t seq_num) {
if (!worker_queue_->IsCurrent()) {
worker_queue_->PostTask([&] { this->OnPacketAdded(ssrc, seq_num); });
return;
}
const auto& ssrcs = config_->rtp.ssrcs;
if (std::find(ssrcs.begin(), ssrcs.end(), ssrc) != ssrcs.end()) {
feedback_packet_seq_num_set_.insert(seq_num);
if (feedback_packet_seq_num_set_.size() > kSendSideSeqNumSetMaxSize) {
feedback_packet_seq_num_set_.erase(feedback_packet_seq_num_set_.begin());
}
}
}
void VideoSendStreamImpl::OnPacketFeedbackVector(
const std::vector<PacketFeedback>& packet_feedback_vector) {
if (!worker_queue_->IsCurrent()) {
worker_queue_->PostTask(
[&] { this->OnPacketFeedbackVector(packet_feedback_vector); });
return;
}
// Lost feedbacks are not considered to be lost packets.
std::vector<bool> loss_mask_vector;
for (const PacketFeedback& packet : packet_feedback_vector) {
if (auto it = feedback_packet_seq_num_set_.find(packet.sequence_number) !=
feedback_packet_seq_num_set_.end()) {
const bool lost = packet.arrival_time_ms == PacketFeedback::kNotReceived;
loss_mask_vector.push_back(lost);
feedback_packet_seq_num_set_.erase(it);
}
}
if (loss_mask_vector.empty())
return;
protection_bitrate_calculator_->OnLossMaskVector(loss_mask_vector);
}
} // namespace internal } // namespace internal
} // namespace webrtc } // namespace webrtc

1
video/video_send_stream.h
View File

@ -19,6 +19,7 @@
#include "call/video_receive_stream.h" #include "call/video_receive_stream.h"
#include "call/video_send_stream.h" #include "call/video_send_stream.h"
#include "common_video/libyuv/include/webrtc_libyuv.h" #include "common_video/libyuv/include/webrtc_libyuv.h"
#include "modules/video_coding/protection_bitrate_calculator.h"
#include "rtc_base/criticalsection.h" #include "rtc_base/criticalsection.h"
#include "rtc_base/event.h" #include "rtc_base/event.h"
#include "rtc_base/task_queue.h" #include "rtc_base/task_queue.h"