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

Revert of Wire up send-side bandwidth estimation. (patchset #8 id:140001 of https://codereview.webrtc.org/1338203003/ )

Browse Source 
Reason for revert:
Breaking some Android bots.
https://chromegw.corp.google.com/i/client.webrtc/builders/Android32%20Tests%20%28L%20Nexus5%29

Original issue's description:
> Wire up send-side bandwidth estimation.
>
> BUG=webrtc:4173
>
> Committed: https://crrev.com/ef165eefc79cf28bb67779afe303cc2365885547
> Cr-Commit-Position: refs/heads/master@{#10012}

TBR=stefan@webrtc.org, kjellander@webrtc.org
NOPRESUBMIT=false
NOTREECHECKS=false
NOTRY=false
BUG=webrtc:4173

Review URL: https://codereview.webrtc.org/1362923002 .

Cr-Commit-Position: refs/heads/master@{#10029}
This commit is contained in:
Erik Språng
2015-09-23 13:51:47 +02:00
parent d5c75b1a0b
commit c9bbeb0354
26 changed files with 111 additions and 428 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
webrtc/modules/modules.gyp
View File

@ -215,7 +215,6 @@
'pacing/packet_router_unittest.cc',
'remote_bitrate_estimator/bwe_simulations.cc',
'remote_bitrate_estimator/include/mock/mock_remote_bitrate_observer.h',
'remote_bitrate_estimator/include/mock/mock_remote_bitrate_estimator.h',
'remote_bitrate_estimator/inter_arrival_unittest.cc',
'remote_bitrate_estimator/overuse_detector_unittest.cc',
'remote_bitrate_estimator/rate_statistics_unittest.cc',

4
webrtc/modules/remote_bitrate_estimator/BUILD.gn
View File

@ -36,11 +36,7 @@ source_set("rbe_components") {
"overuse_estimator.h",
"remote_bitrate_estimator_abs_send_time.cc",
"remote_bitrate_estimator_single_stream.cc",
"remote_estimator_proxy.cc",
"remote_estimator_proxy.h",
"send_time_history.cc",
"transport_feedback_adapter.cc",
"transport_feedback_adapter.h",
]
configs += [ "../..:common_config" ]

1
webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.cc
View File

@ -107,7 +107,6 @@ void TransportFeedbackAdapter::OnTransportFeedback(
<< ". Send time history too small?";
}
}
RTC_DCHECK(bitrate_estimator_.get() != nullptr);
bitrate_estimator_->IncomingPacketFeedbackVector(packet_feedback_vector);
}

3
webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
View File

@ -111,8 +111,7 @@ enum RTCPPacketType : uint32_t {
kRtcpRemb = 0x10000,
kRtcpTransmissionTimeOffset = 0x20000,
kRtcpXrReceiverReferenceTime = 0x40000,
kRtcpXrDlrrReportBlock = 0x80000,
kRtcpTransportFeedback = 0x100000,
kRtcpXrDlrrReportBlock = 0x80000
};
enum KeyFrameRequestMethod

10
webrtc/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
View File

@ -60,11 +60,7 @@ class RtcpFormatRembTest : public ::testing::Test {
RtcpFormatRembTest()
: over_use_detector_options_(),
system_clock_(Clock::GetRealTimeClock()),
dummy_rtp_rtcp_impl_(nullptr),
receive_statistics_(ReceiveStatistics::Create(system_clock_)),
rtcp_sender_(nullptr),
rtcp_receiver_(nullptr),
test_transport_(nullptr),
remote_bitrate_observer_(),
remote_bitrate_estimator_(new RemoteBitrateEstimatorSingleStream(
&remote_bitrate_observer_,
@ -91,9 +87,9 @@ void RtcpFormatRembTest::SetUp() {
configuration.remote_bitrate_estimator = remote_bitrate_estimator_.get();
dummy_rtp_rtcp_impl_ = new ModuleRtpRtcpImpl(configuration);
rtcp_sender_ =
new RTCPSender(false, system_clock_, receive_statistics_.get(), nullptr);
rtcp_receiver_ = new RTCPReceiver(system_clock_, false, nullptr, nullptr,
nullptr, nullptr, dummy_rtp_rtcp_impl_);
new RTCPSender(false, system_clock_, receive_statistics_.get(), NULL);
rtcp_receiver_ = new RTCPReceiver(system_clock_, false, NULL, NULL, NULL,
dummy_rtp_rtcp_impl_);
test_transport_ = new TestTransport(rtcp_receiver_);
EXPECT_EQ(0, rtcp_sender_->RegisterSendTransport(test_transport_));

4
webrtc/modules/rtp_rtcp/source/rtcp_packet.h
View File

@ -91,9 +91,6 @@ class RtcpPacket {
size_t max_length,
PacketReadyCallback* callback) const;
// Size of this packet in bytes (including headers, excluding nested packets).
virtual size_t BlockLength() const = 0;
protected:
RtcpPacket() {}
@ -112,6 +109,7 @@ class RtcpPacket {
size_t* index,
RtcpPacket::PacketReadyCallback* callback) const;
virtual size_t BlockLength() const = 0;
size_t HeaderLength() const;
static const size_t kHeaderLength = 4;

51
webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
View File

@ -17,7 +17,6 @@
#include "webrtc/base/checks.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
#include "webrtc/system_wrappers/interface/logging.h"
@ -30,15 +29,12 @@ using namespace RTCPHelp;
// The number of RTCP time intervals needed to trigger a timeout.
const int kRrTimeoutIntervals = 3;
const int64_t kMaxWarningLogIntervalMs = 10000;
RTCPReceiver::RTCPReceiver(
Clock* clock,
bool receiver_only,
RtcpPacketTypeCounterObserver* packet_type_counter_observer,
RtcpBandwidthObserver* rtcp_bandwidth_observer,
RtcpIntraFrameObserver* rtcp_intra_frame_observer,
TransportFeedbackObserver* transport_feedback_observer,
ModuleRtpRtcpImpl* owner)
: TMMBRHelp(),
_clock(clock),
@ -50,7 +46,6 @@ RTCPReceiver::RTCPReceiver(
CriticalSectionWrapper::CreateCriticalSection()),
_cbRtcpBandwidthObserver(rtcp_bandwidth_observer),
_cbRtcpIntraFrameObserver(rtcp_intra_frame_observer),
_cbTransportFeedbackObserver(transport_feedback_observer),
_criticalSectionRTCPReceiver(
CriticalSectionWrapper::CreateCriticalSection()),
main_ssrc_(0),
@ -66,9 +61,7 @@ RTCPReceiver::RTCPReceiver(
_lastReceivedRrMs(0),
_lastIncreasedSequenceNumberMs(0),
stats_callback_(NULL),
packet_type_counter_observer_(packet_type_counter_observer),
num_skipped_packets_(0),
last_skipped_packets_warning_(clock->TimeInMilliseconds()) {
packet_type_counter_observer_(packet_type_counter_observer) {
memset(&_remoteSenderInfo, 0, sizeof(_remoteSenderInfo));
}
@ -356,9 +349,6 @@ RTCPReceiver::IncomingRTCPPacket(RTCPPacketInformation& rtcpPacketInformation,
// generic application messages
HandleAPPItem(*rtcpParser, rtcpPacketInformation);
break;
case RTCPPacketTypes::kTransportFeedback:
HandleTransportFeedback(rtcpParser, &rtcpPacketInformation);
break;
default:
rtcpParser->Iterate();
break;
@ -371,19 +361,6 @@ RTCPReceiver::IncomingRTCPPacket(RTCPPacketInformation& rtcpPacketInformation,
main_ssrc_, packet_type_counter_);
}
num_skipped_packets_ += rtcpParser->NumSkippedBlocks();
int64_t now = _clock->TimeInMilliseconds();
if (now - last_skipped_packets_warning_ >= kMaxWarningLogIntervalMs &&
num_skipped_packets_ > 0) {
last_skipped_packets_warning_ = now;
LOG(LS_WARNING)
<< num_skipped_packets_
<< " RTCP blocks were skipped due to being malformed or of "
"unrecognized/unsupported type, during the past "
<< (kMaxWarningLogIntervalMs / 1000) << " second period.";
}
return 0;
}
@ -1275,17 +1252,6 @@ void RTCPReceiver::HandleAPPItem(RTCPUtility::RTCPParserV2& rtcpParser,
rtcpParser.Iterate();
}
void RTCPReceiver::HandleTransportFeedback(
RTCPUtility::RTCPParserV2* rtcp_parser,
RTCPHelp::RTCPPacketInformation* rtcp_packet_information) {
rtcp::RtcpPacket* packet = rtcp_parser->ReleaseRtcpPacket();
RTC_DCHECK(packet != nullptr);
rtcp_packet_information->rtcpPacketTypeFlags |= kRtcpTransportFeedback;
rtcp_packet_information->transport_feedback_.reset(
static_cast<rtcp::TransportFeedback*>(packet));
rtcp_parser->Iterate();
}
int32_t RTCPReceiver::UpdateTMMBR() {
int32_t numBoundingSet = 0;
uint32_t bitrate = 0;
@ -1355,11 +1321,11 @@ void RTCPReceiver::TriggerCallbacksFromRTCPPacket(
local_ssrc = main_ssrc_;
}
if (!receiver_only_ &&
(rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpSrReq)) {
rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpSrReq) {
_rtpRtcp.OnRequestSendReport();
}
if (!receiver_only_ &&
(rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpNack)) {
rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpNack) {
if (rtcpPacketInformation.nackSequenceNumbers.size() > 0) {
LOG(LS_VERBOSE) << "Incoming NACK length: "
<< rtcpPacketInformation.nackSequenceNumbers.size();
@ -1410,17 +1376,6 @@ void RTCPReceiver::TriggerCallbacksFromRTCPPacket(
now);
}
}
if (_cbTransportFeedbackObserver &&
(rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpTransportFeedback)) {
uint32_t media_source_ssrc =
rtcpPacketInformation.transport_feedback_->GetMediaSourceSsrc();
if (media_source_ssrc == main_ssrc_ ||
registered_ssrcs_.find(media_source_ssrc) !=
registered_ssrcs_.end()) {
_cbTransportFeedbackObserver->OnTransportFeedback(
*rtcpPacketInformation.transport_feedback_.get());
}
}
}
if (!receiver_only_) {

9
webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
View File

@ -34,7 +34,6 @@ public:
RtcpPacketTypeCounterObserver* packet_type_counter_observer,
RtcpBandwidthObserver* rtcp_bandwidth_observer,
RtcpIntraFrameObserver* rtcp_intra_frame_observer,
TransportFeedbackObserver* transport_feedback_observer,
ModuleRtpRtcpImpl* owner);
virtual ~RTCPReceiver();
@ -217,10 +216,6 @@ protected:
void HandleAPPItem(RTCPUtility::RTCPParserV2& rtcpParser,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation);
void HandleTransportFeedback(
RTCPUtility::RTCPParserV2* rtcp_parser,
RTCPHelp::RTCPPacketInformation* rtcp_packet_information);
private:
typedef std::map<uint32_t, RTCPHelp::RTCPReceiveInformation*>
ReceivedInfoMap;
@ -246,7 +241,6 @@ protected:
CriticalSectionWrapper* _criticalSectionFeedbacks;
RtcpBandwidthObserver* const _cbRtcpBandwidthObserver;
RtcpIntraFrameObserver* const _cbRtcpIntraFrameObserver;
TransportFeedbackObserver* const _cbTransportFeedbackObserver;
CriticalSectionWrapper* _criticalSectionRTCPReceiver;
uint32_t main_ssrc_;
@ -288,9 +282,6 @@ protected:
RtcpPacketTypeCounter packet_type_counter_;
RTCPUtility::NackStats nack_stats_;
size_t num_skipped_packets_;
int64_t last_skipped_packets_warning_;
};
} // namespace webrtc
#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_RECEIVER_H_

4
webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.cc
View File

@ -13,7 +13,6 @@
#include <assert.h> // assert
#include <string.h> // memset
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
namespace webrtc {
@ -37,7 +36,8 @@ RTCPPacketInformation::RTCPPacketInformation()
rtp_timestamp(0),
xr_originator_ssrc(0),
xr_dlrr_item(false),
VoIPMetric(nullptr) {}
VoIPMetric(NULL) {
}
RTCPPacketInformation::~RTCPPacketInformation()
{

5
webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h
View File

@ -20,9 +20,6 @@
#include "webrtc/typedefs.h"
namespace webrtc {
namespace rtcp {
class TransportFeedback;
}
namespace RTCPHelp
{
@ -87,8 +84,6 @@ public:
bool xr_dlrr_item;
RTCPVoIPMetric* VoIPMetric;
rtc::scoped_ptr<rtcp::TransportFeedback> transport_feedback_;
private:
RTC_DISALLOW_COPY_AND_ASSIGN(RTCPPacketInformation);
};

33
webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
View File

@ -33,7 +33,9 @@ namespace { // Anonymous namespace; hide utility functions and classes.
class TestTransport : public Transport,
public NullRtpData {
public:
explicit TestTransport() : rtcp_receiver_(nullptr) {}
explicit TestTransport()
: rtcp_receiver_(NULL) {
}
void SetRTCPReceiver(RTCPReceiver* rtcp_receiver) {
rtcp_receiver_ = rtcp_receiver;
}
@ -76,8 +78,8 @@ class RtcpReceiverTest : public ::testing::Test {
configuration.outgoing_transport = test_transport_;
configuration.remote_bitrate_estimator = remote_bitrate_estimator_.get();
rtp_rtcp_impl_ = new ModuleRtpRtcpImpl(configuration);
rtcp_receiver_ = new RTCPReceiver(&system_clock_, false, nullptr, nullptr,
nullptr, nullptr, rtp_rtcp_impl_);
rtcp_receiver_ = new RTCPReceiver(&system_clock_, false, NULL, NULL, NULL,
rtp_rtcp_impl_);
test_transport_->SetRTCPReceiver(rtcp_receiver_);
}
~RtcpReceiverTest() {
@ -360,8 +362,7 @@ TEST_F(RtcpReceiverTest, GetRtt) {
rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
// No report block received.
EXPECT_EQ(
-1, rtcp_receiver_->RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr));
EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc, NULL, NULL, NULL, NULL));
rtcp::ReportBlock rb;
rb.To(kSourceSsrc);
@ -373,12 +374,10 @@ TEST_F(RtcpReceiverTest, GetRtt) {
EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC);
EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags);
EXPECT_EQ(1u, rtcp_packet_info_.report_blocks.size());
EXPECT_EQ(
0, rtcp_receiver_->RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr));
EXPECT_EQ(0, rtcp_receiver_->RTT(kSenderSsrc, NULL, NULL, NULL, NULL));
// Report block not received.
EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc + 1, nullptr, nullptr, nullptr,
nullptr));
EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc + 1, NULL, NULL, NULL, NULL));
}
TEST_F(RtcpReceiverTest, InjectIjWithNoItem) {
@ -590,7 +589,7 @@ TEST_F(RtcpReceiverTest, InjectXrVoipPacket) {
xr.WithVoipMetric(&voip_metric);
rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build());
EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
ASSERT_TRUE(rtcp_packet_info_.VoIPMetric != nullptr);
ASSERT_TRUE(rtcp_packet_info_.VoIPMetric != NULL);
EXPECT_EQ(kLossRate, rtcp_packet_info_.VoIPMetric->lossRate);
EXPECT_EQ(kRtcpXrVoipMetric, rtcp_packet_info_.rtcpPacketTypeFlags);
}
@ -844,7 +843,7 @@ TEST_F(RtcpReceiverTest, ReceiveReportTimeout) {
TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) {
// This call is expected to fail because no data has arrived.
EXPECT_EQ(-1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
EXPECT_EQ(-1, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
}
TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) {
@ -865,7 +864,7 @@ TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) {
rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build());
EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
TMMBRSet candidate_set;
candidate_set.VerifyAndAllocateSet(1);
EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(1, 0, &candidate_set));
@ -891,7 +890,7 @@ TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) {
ssrcs.insert(kMediaFlowSsrc);
rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs);
EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
}
TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) {
@ -912,7 +911,7 @@ TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) {
rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build());
EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
}
TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) {
@ -939,7 +938,7 @@ TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) {
system_clock_.AdvanceTimeMilliseconds(5000);
}
// It is now starttime + 15.
EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
TMMBRSet candidate_set;
candidate_set.VerifyAndAllocateSet(3);
EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set));
@ -948,7 +947,7 @@ TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) {
// seconds, timing out the first packet.
system_clock_.AdvanceTimeMilliseconds(12000);
// Odd behaviour: Just counting them does not trigger the timeout.
EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
EXPECT_EQ(2, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set));
EXPECT_EQ(kSenderSsrc + 1, candidate_set.Ssrc(0));
}
@ -1009,7 +1008,7 @@ TEST_F(RtcpReceiverTest, Callbacks) {
EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss,
kCumulativeLoss, kJitter));
rtcp_receiver_->RegisterRtcpStatisticsCallback(nullptr);
rtcp_receiver_->RegisterRtcpStatisticsCallback(NULL);
// Add arbitrary numbers, callback should not be called (retain old values).
rtcp::ReportBlock rb2;

3
webrtc/modules/rtp_rtcp/source/rtcp_sender.h
View File

@ -33,6 +33,9 @@ namespace webrtc {
class ModuleRtpRtcpImpl;
class RTCPReceiver;
namespace rtcp {
class TransportFeedback;
}
class NACKStringBuilder {
public:
NACKStringBuilder();

70
webrtc/modules/rtp_rtcp/source/rtcp_utility.cc
View File

@ -8,9 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/base/checks.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
#include <assert.h>
#include <math.h> // ceil
@ -57,7 +55,6 @@ RTCPUtility::RTCPParserV2::RTCPParserV2(const uint8_t* rtcpData,
_ptrRTCPBlockEnd(NULL),
_state(ParseState::State_TopLevel),
_numberOfBlocks(0),
num_skipped_blocks_(0),
_packetType(RTCPPacketTypes::kInvalid) {
Validate();
}
@ -83,9 +80,6 @@ RTCPUtility::RTCPParserV2::Packet() const
return _packet;
}
rtcp::RtcpPacket* RTCPUtility::RTCPParserV2::ReleaseRtcpPacket() {
return rtcp_packet_.release();
}
RTCPUtility::RTCPPacketTypes
RTCPUtility::RTCPParserV2::Begin()
{
@ -153,7 +147,7 @@ RTCPUtility::RTCPParserV2::Iterate()
IterateAppItem();
break;
default:
RTC_NOTREACHED() << "Invalid state!";
assert(false); // Invalid state!
break;
}
}
@ -176,7 +170,7 @@ RTCPUtility::RTCPParserV2::IterateTopLevel()
_ptrRTCPBlockEnd = _ptrRTCPData + header.BlockSize();
if (_ptrRTCPBlockEnd > _ptrRTCPDataEnd)
{
++num_skipped_blocks_;
// Bad block!
return;
}
@ -225,11 +219,12 @@ RTCPUtility::RTCPParserV2::IterateTopLevel()
ParseIJ();
return;
}
case PT_RTPFB:
FALLTHROUGH();
case PT_RTPFB: // Fall through!
case PT_PSFB:
{
if (!ParseFBCommon(header)) {
const bool ok = ParseFBCommon(header);
if (!ok)
{
// Nothing supported found, continue to next block!
break;
}
@ -257,7 +252,6 @@ RTCPUtility::RTCPParserV2::IterateTopLevel()
}
default:
// Not supported! Skip!
++num_skipped_blocks_;
EndCurrentBlock();
break;
}
@ -1166,26 +1160,28 @@ bool RTCPUtility::RTCPParserV2::ParseXrUnsupportedBlockType(
}
bool RTCPUtility::RTCPParserV2::ParseFBCommon(const RtcpCommonHeader& header) {
RTC_CHECK((header.packet_type == PT_RTPFB) ||
assert((header.packet_type == PT_RTPFB) ||
(header.packet_type == PT_PSFB)); // Parser logic check
const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
// 4 * 3, RFC4585 section 6.1
if (length < 12) {
LOG(LS_WARNING)
<< "Invalid RTCP packet: Too little data (" << length
<< " bytes) left in buffer to parse a 12 byte RTPFB/PSFB message.";
if (length < 12) // 4 * 3, RFC4585 section 6.1
{
EndCurrentBlock();
return false;
}
_ptrRTCPData += 4; // Skip RTCP header
uint32_t senderSSRC = ByteReader<uint32_t>::ReadBigEndian(_ptrRTCPData);
_ptrRTCPData += 4;
uint32_t senderSSRC = *_ptrRTCPData++ << 24;
senderSSRC += *_ptrRTCPData++ << 16;
senderSSRC += *_ptrRTCPData++ << 8;
senderSSRC += *_ptrRTCPData++;
uint32_t mediaSSRC = ByteReader<uint32_t>::ReadBigEndian(_ptrRTCPData);
_ptrRTCPData += 4;
uint32_t mediaSSRC = *_ptrRTCPData++ << 24;
mediaSSRC += *_ptrRTCPData++ << 16;
mediaSSRC += *_ptrRTCPData++ << 8;
mediaSSRC += *_ptrRTCPData++;
if (header.packet_type == PT_RTPFB) {
// Transport layer feedback
@ -1202,6 +1198,12 @@ bool RTCPUtility::RTCPParserV2::ParseFBCommon(const RtcpCommonHeader& header) {
return true;
}
case 2:
{
// used to be ACK is this code point, which is removed
// conficts with http://tools.ietf.org/html/draft-levin-avt-rtcp-burst-00
break;
}
case 3:
{
// TMMBR
@ -1234,23 +1236,10 @@ bool RTCPUtility::RTCPParserV2::ParseFBCommon(const RtcpCommonHeader& header) {
// Note: No state transition, SR REQ is empty!
return true;
}
case 15: {
_packetType = RTCPPacketTypes::kTransportFeedback;
rtcp_packet_ =
rtcp::TransportFeedback::ParseFrom(_ptrRTCPData - 12, length);
// Since we parse the whole packet here, keep the TopLevel state and
// just end the current block.
if (rtcp_packet_.get()) {
EndCurrentBlock();
return true;
}
break;
}
default:
break;
}
// Unsupported RTPFB message. Skip and move to next block.
++num_skipped_blocks_;
EndCurrentBlock();
return false;
} else if (header.packet_type == PT_PSFB) {
// Payload specific feedback
@ -1298,11 +1287,14 @@ bool RTCPUtility::RTCPParserV2::ParseFBCommon(const RtcpCommonHeader& header) {
break;
}
EndCurrentBlock();
return false;
}
else
{
RTC_NOTREACHED();
assert(false);
EndCurrentBlock();
return false;
}
}
@ -1662,10 +1654,6 @@ RTCPUtility::RTCPParserV2::ParseAPPItem()
return true;
}
size_t RTCPUtility::RTCPParserV2::NumSkippedBlocks() const {
return num_skipped_blocks_;
}
RTCPUtility::RTCPPacketIterator::RTCPPacketIterator(uint8_t* rtcpData,
size_t rtcpDataLength)
: _ptrBegin(rtcpData),

11
webrtc/modules/rtp_rtcp/source/rtcp_utility.h
View File

@ -13,15 +13,11 @@
#include <stddef.h> // size_t, ptrdiff_t
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_config.h"
#include "webrtc/typedefs.h"
namespace webrtc {
namespace rtcp {
class RtcpPacket;
}
namespace RTCPUtility {
class NackStats {
@ -298,9 +294,6 @@ enum class RTCPPacketTypes {
kApp,
kAppItem,
// draft-holmer-rmcat-transport-wide-cc-extensions
kTransportFeedback,
};
struct RTCPRawPacket {
@ -366,12 +359,10 @@ class RTCPParserV2 {
RTCPPacketTypes PacketType() const;
const RTCPPacket& Packet() const;
rtcp::RtcpPacket* ReleaseRtcpPacket();
const RTCPRawPacket& RawPacket() const;
ptrdiff_t LengthLeft() const;
bool IsValid() const;
size_t NumSkippedBlocks() const;
RTCPPacketTypes Begin();
RTCPPacketTypes Iterate();
@ -463,11 +454,9 @@ class RTCPParserV2 {
ParseState _state;
uint8_t _numberOfBlocks;
size_t num_skipped_blocks_;
RTCPPacketTypes _packetType;
RTCPPacket _packet;
rtc::scoped_ptr<webrtc::rtcp::RtcpPacket> rtcp_packet_;
};
class RTCPPacketIterator {

1
webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
View File

@ -78,7 +78,6 @@ ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Configuration& configuration)
configuration.rtcp_packet_type_counter_observer,
configuration.bandwidth_callback,
configuration.intra_frame_callback,
configuration.transport_feedback_callback,
this),
clock_(configuration.clock),
audio_(configuration.audio),

63
webrtc/video/end_to_end_tests.cc
View File

@ -15,7 +15,6 @@
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/checks.h"
#include "webrtc/base/event.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/call.h"
#include "webrtc/frame_callback.h"
@ -1446,68 +1445,6 @@ TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) {
tester.RunTest();
}
TEST_F(EndToEndTest, ReceivesTransportFeedback) {
static const int kExtensionId = 5;
class TransportFeedbackObserver : public test::DirectTransport {
public:
TransportFeedbackObserver(rtc::Event* done_event) : done_(done_event) {}
virtual ~TransportFeedbackObserver() {}
bool SendRtcp(const uint8_t* data, size_t length) override {
RTCPUtility::RTCPParserV2 parser(data, length, true);
EXPECT_TRUE(parser.IsValid());
RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
if (packet_type == RTCPUtility::RTCPPacketTypes::kTransportFeedback) {
done_->Set();
break;
}
packet_type = parser.Iterate();
}
return test::DirectTransport::SendRtcp(data, length);
}
rtc::Event* done_;
};
class TransportFeedbackTester : public MultiStreamTest {
public:
TransportFeedbackTester() : done_(false, false) {}
virtual ~TransportFeedbackTester() {}
protected:
void Wait() override {
EXPECT_TRUE(done_.Wait(CallTest::kDefaultTimeoutMs));
}
void UpdateSendConfig(
size_t stream_index,
VideoSendStream::Config* send_config,
VideoEncoderConfig* encoder_config,
test::FrameGeneratorCapturer** frame_generator) override {
send_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId));
}
void UpdateReceiveConfig(
size_t stream_index,
VideoReceiveStream::Config* receive_config) override {
receive_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId));
}
virtual test::DirectTransport* CreateReceiveTransport() {
return new TransportFeedbackObserver(&done_);
}
private:
rtc::Event done_;
} tester;
tester.RunTest();
}
TEST_F(EndToEndTest, ObserversEncodedFrames) {
class EncodedFrameTestObserver : public EncodedFrameObserver {
public:

94
webrtc/video/rampup_tests.cc
View File

@ -11,18 +11,14 @@
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/checks.h"
#include "webrtc/base/common.h"
#include "webrtc/base/event.h"
#include "webrtc/modules/pacing/include/packet_router.h"
#include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.h"
#include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.h"
#include "webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.h"
#include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
#include "webrtc/system_wrappers/interface/thread_wrapper.h"
#include "webrtc/test/testsupport/perf_test.h"
#include "webrtc/video/rampup_tests.h"
@ -74,22 +70,14 @@ StreamObserver::StreamObserver(const SsrcMap& rtx_media_ssrcs,
rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config));
rtp_rtcp_->SetREMBStatus(true);
rtp_rtcp_->SetRTCPStatus(kRtcpNonCompound);
packet_router_.reset(new PacketRouter());
packet_router_->AddRtpModule(rtp_rtcp_.get());
rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
kAbsSendTimeExtensionId);
rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
kTransmissionTimeOffsetExtensionId);
rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
kTransportSequenceNumberExtensionId);
payload_registry_->SetRtxPayloadType(RampUpTest::kSendRtxPayloadType,
RampUpTest::kFakeSendPayloadType);
}
StreamObserver::~StreamObserver() {
packet_router_->RemoveRtpModule(rtp_rtcp_.get());
}
void StreamObserver::set_expected_bitrate_bps(
unsigned int expected_bitrate_bps) {
rtc::CritScope lock(&crit_);
@ -175,10 +163,6 @@ void StreamObserver::SetRemoteBitrateEstimator(RemoteBitrateEstimator* rbe) {
remote_bitrate_estimator_.reset(rbe);
}
PacketRouter* StreamObserver::GetPacketRouter() {
return packet_router_.get();
}
void StreamObserver::ReportResult(const std::string& measurement,
size_t value,
const std::string& units) {
@ -387,48 +371,6 @@ EventTypeWrapper LowRateStreamObserver::Wait() {
return test_done_->Wait(test::CallTest::kLongTimeoutMs);
}
class SendBitrateAdapter {
public:
static const int64_t kPollIntervalMs = 250;
SendBitrateAdapter(const Call& call,
const std::vector<uint32_t>& ssrcs,
RemoteBitrateObserver* bitrate_observer)
: event_(false, false),
call_(call),
ssrcs_(ssrcs),
bitrate_observer_(bitrate_observer) {
RTC_DCHECK(bitrate_observer != nullptr);
poller_thread_ = ThreadWrapper::CreateThread(&SendBitrateAdapterThread,
this, "SendBitratePoller");
RTC_DCHECK(poller_thread_->Start());
}
virtual ~SendBitrateAdapter() {
event_.Set();
poller_thread_->Stop();
}
private:
static bool SendBitrateAdapterThread(void* obj) {
return static_cast<SendBitrateAdapter*>(obj)->PollStats();
}
bool PollStats() {
Call::Stats stats = call_.GetStats();
bitrate_observer_->OnReceiveBitrateChanged(ssrcs_,
stats.send_bandwidth_bps);
return !event_.Wait(kPollIntervalMs);
}
rtc::Event event_;
rtc::scoped_ptr<ThreadWrapper> poller_thread_;
const Call& call_;
const std::vector<uint32_t> ssrcs_;
RemoteBitrateObserver* const bitrate_observer_;
};
void RampUpTest::RunRampUpTest(size_t num_streams,
unsigned int start_bitrate_bps,
const std::string& extension_type,
@ -449,8 +391,6 @@ void RampUpTest::RunRampUpTest(size_t num_streams,
CreateSendConfig(num_streams, &stream_observer);
send_config_.rtp.extensions.clear();
rtc::scoped_ptr<SendBitrateAdapter> send_bitrate_adapter_;
if (extension_type == RtpExtension::kAbsSendTime) {
stream_observer.SetRemoteBitrateEstimator(
new RemoteBitrateEstimatorAbsSendTime(
@ -458,11 +398,6 @@ void RampUpTest::RunRampUpTest(size_t num_streams,
kRemoteBitrateEstimatorMinBitrateBps));
send_config_.rtp.extensions.push_back(RtpExtension(
extension_type.c_str(), kAbsSendTimeExtensionId));
} else if (extension_type == RtpExtension::kTransportSequenceNumber) {
stream_observer.SetRemoteBitrateEstimator(new RemoteEstimatorProxy(
Clock::GetRealTimeClock(), stream_observer.GetPacketRouter()));
send_config_.rtp.extensions.push_back(RtpExtension(
extension_type.c_str(), kTransportSequenceNumberExtensionId));
} else {
stream_observer.SetRemoteBitrateEstimator(
new RemoteBitrateEstimatorSingleStream(
@ -514,18 +449,10 @@ void RampUpTest::RunRampUpTest(size_t num_streams,
CreateStreams();
CreateFrameGeneratorCapturer();
if (extension_type == RtpExtension::kTransportSequenceNumber) {
send_bitrate_adapter_.reset(
new SendBitrateAdapter(*sender_call_.get(), ssrcs, &stream_observer));
}
Start();
EXPECT_EQ(kEventSignaled, stream_observer.Wait());
// Destroy the SendBitrateAdapter (if any) to stop the poller thread in it,
// otherwise we might get a data race with the destruction of the call.
send_bitrate_adapter_.reset();
Stop();
DestroyStreams();
}
@ -636,25 +563,4 @@ TEST_F(RampUpTest, AbsSendTimeSingleStreamWithHighStartBitrate) {
RunRampUpTest(1, 0.9 * kSingleStreamTargetBps, RtpExtension::kAbsSendTime,
false, false);
}
TEST_F(RampUpTest, TransportSequenceNumberSingleStream) {
RunRampUpTest(1, 0, RtpExtension::kTransportSequenceNumber, false, false);
}
TEST_F(RampUpTest, TransportSequenceNumberSimulcast) {
RunRampUpTest(3, 0, RtpExtension::kTransportSequenceNumber, false, false);
}
TEST_F(RampUpTest, TransportSequenceNumberSimulcastWithRtx) {
RunRampUpTest(3, 0, RtpExtension::kTransportSequenceNumber, true, false);
}
TEST_F(RampUpTest, TransportSequenceNumberSimulcastByRedWithRtx) {
RunRampUpTest(3, 0, RtpExtension::kTransportSequenceNumber, true, true);
}
TEST_F(RampUpTest, TransportSequenceNumberSingleStreamWithHighStartBitrate) {
RunRampUpTest(1, 0.9 * kSingleStreamTargetBps,
RtpExtension::kTransportSequenceNumber, false, false);
}
} // namespace webrtc

6
webrtc/video/rampup_tests.h
View File

@ -26,11 +26,9 @@ namespace webrtc {
static const int kTransmissionTimeOffsetExtensionId = 6;
static const int kAbsSendTimeExtensionId = 7;
static const int kTransportSequenceNumberExtensionId = 8;
static const unsigned int kSingleStreamTargetBps = 1000000;
class Clock;
class PacketRouter;
class ReceiveStatistics;
class RtpHeaderParser;
class RTPPayloadRegistry;
@ -43,7 +41,6 @@ class StreamObserver : public newapi::Transport, public RemoteBitrateObserver {
StreamObserver(const SsrcMap& rtx_media_ssrcs,
newapi::Transport* feedback_transport,
Clock* clock);
virtual ~StreamObserver();
void set_expected_bitrate_bps(unsigned int expected_bitrate_bps);
@ -60,8 +57,6 @@ class StreamObserver : public newapi::Transport, public RemoteBitrateObserver {
void SetRemoteBitrateEstimator(RemoteBitrateEstimator* rbe);
PacketRouter* GetPacketRouter();
private:
void ReportResult(const std::string& measurement,
size_t value,
@ -72,7 +67,6 @@ class StreamObserver : public newapi::Transport, public RemoteBitrateObserver {
const rtc::scoped_ptr<EventWrapper> test_done_;
const rtc::scoped_ptr<RtpHeaderParser> rtp_parser_;
rtc::scoped_ptr<RtpRtcp> rtp_rtcp_;
rtc::scoped_ptr<PacketRouter> packet_router_;
internal::TransportAdapter feedback_transport_;
const rtc::scoped_ptr<ReceiveStatistics> receive_stats_;
const rtc::scoped_ptr<RTPPayloadRegistry> payload_registry_;

21
webrtc/video/screenshare_loopback.cc
View File

@ -139,8 +139,6 @@ int DurationSecs() {
return static_cast<int>(FLAGS_duration);
}
DEFINE_bool(send_side_bwe, true, "Use send-side bandwidth estimation");
DEFINE_string(
force_fieldtrials,
"",
@ -164,12 +162,19 @@ void Loopback() {
call_bitrate_config.max_bitrate_bps = flags::MaxBitrateKbps() * 1000;
VideoQualityTest::Params params{
{flags::Width(), flags::Height(), flags::Fps(),
flags::MinBitrateKbps() * 1000, flags::TargetBitrateKbps() * 1000,
flags::MaxBitrateKbps() * 1000, flags::Codec(),
flags::NumTemporalLayers(), flags::MinTransmitBitrateKbps() * 1000,
call_bitrate_config, flags::TLDiscardThreshold(),
flags::FLAGS_send_side_bwe},
{
flags::Width(),
flags::Height(),
flags::Fps(),
flags::MinBitrateKbps() * 1000,
flags::TargetBitrateKbps() * 1000,
flags::MaxBitrateKbps() * 1000,
flags::Codec(),
flags::NumTemporalLayers(),
flags::MinTransmitBitrateKbps() * 1000,
call_bitrate_config,
flags::TLDiscardThreshold()
},
{}, // Video specific.
{true, flags::SlideChangeInterval(), flags::ScrollDuration()},
{"screenshare", 0.0, 0.0, flags::DurationSecs(), flags::OutputFilename()},

18
webrtc/video/video_loopback.cc
View File

@ -140,8 +140,6 @@ int DurationSecs() {
return static_cast<int>(FLAGS_duration);
}
DEFINE_bool(send_side_bwe, true, "Use send-side bandwidth estimation");
} // namespace flags
void Loopback() {
@ -160,13 +158,19 @@ void Loopback() {
std::string clip = flags::Clip();
std::string graph_title = clip.empty() ? "" : "video " + clip;
VideoQualityTest::Params params{
{flags::Width(), flags::Height(), flags::Fps(),
flags::MinBitrateKbps() * 1000, flags::TargetBitrateKbps() * 1000,
flags::MaxBitrateKbps() * 1000, flags::Codec(),
{
flags::Width(),
flags::Height(),
flags::Fps(),
flags::MinBitrateKbps() * 1000,
flags::TargetBitrateKbps() * 1000,
flags::MaxBitrateKbps() * 1000,
flags::Codec(),
flags::NumTemporalLayers(),
0, // No min transmit bitrate.
call_bitrate_config, flags::TLDiscardThreshold(),
flags::FLAGS_send_side_bwe},
call_bitrate_config,
flags::TLDiscardThreshold()
},
{clip},
{}, // Screenshare specific.
{graph_title, 0.0, 0.0, flags::DurationSecs(), flags::OutputFilename()},

11
webrtc/video/video_quality_test.cc
View File

@ -32,8 +32,6 @@
namespace webrtc {
static const int kTransportSeqExtensionId =
VideoQualityTest::kAbsSendTimeExtensionId + 1;
static const int kSendStatsPollingIntervalMs = 1000;
static const int kPayloadTypeVP8 = 123;
static const int kPayloadTypeVP9 = 124;
@ -600,15 +598,6 @@ void VideoQualityTest::SetupFullStack(const Params& params,
send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]);
send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
send_config_.rtp.extensions.clear();
if (params.common.send_side_bwe) {
send_config_.rtp.extensions.push_back(RtpExtension(
RtpExtension::kTransportSequenceNumber, kTransportSeqExtensionId));
} else {
send_config_.rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId));
}
// Automatically fill out streams[0] with params.
VideoStream* stream = &encoder_config_.streams[0];
stream->width = params.common.width;

1
webrtc/video/video_quality_test.h
View File

@ -38,7 +38,6 @@ class VideoQualityTest : public test::CallTest {
int min_transmit_bps;
Call::Config::BitrateConfig call_bitrate_config;
size_t tl_discard_threshold;
bool send_side_bwe;
} common;
struct { // Video-specific settings.
std::string clip_name;

2
webrtc/video/video_receive_stream.cc
View File

@ -140,7 +140,7 @@ VideoReceiveStream::VideoReceiveStream(int num_cpu_cores,
channel_group_(channel_group),
channel_id_(channel_id) {
RTC_CHECK(channel_group_->CreateReceiveChannel(
channel_id_, &transport_adapter_, num_cpu_cores, config));
channel_id_, &transport_adapter_, num_cpu_cores));
vie_channel_ = channel_group_->GetChannel(channel_id_);

2
webrtc/video/video_send_stream.cc
View File

@ -120,7 +120,7 @@ VideoSendStream::VideoSendStream(
RTC_DCHECK(!config_.rtp.ssrcs.empty());
RTC_CHECK(channel_group->CreateSendChannel(
channel_id_, &transport_adapter_, &stats_proxy_,
config.pre_encode_callback, num_cpu_cores, config_));
config.pre_encode_callback, num_cpu_cores, config_.rtp.ssrcs));
vie_channel_ = channel_group_->GetChannel(channel_id_);
vie_encoder_ = channel_group_->GetEncoder(channel_id_);

78
webrtc/video_engine/vie_channel_group.cc
View File

@ -18,7 +18,6 @@
#include "webrtc/modules/remote_bitrate_estimator/include/send_time_history.h"
#include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.h"
#include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.h"
#include "webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.h"
#include "webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
#include "webrtc/modules/utility/interface/process_thread.h"
@ -146,6 +145,7 @@ ChannelGroup::ChannelGroup(ProcessThread* process_thread)
: remb_(new VieRemb()),
bitrate_allocator_(new BitrateAllocator()),
call_stats_(new CallStats()),
encoder_state_feedback_(new EncoderStateFeedback()),
packet_router_(new PacketRouter()),
pacer_(new PacedSender(Clock::GetRealTimeClock(),
packet_router_.get(),
@ -153,12 +153,6 @@ ChannelGroup::ChannelGroup(ProcessThread* process_thread)
PacedSender::kDefaultPaceMultiplier *
BitrateController::kDefaultStartBitrateKbps,
0)),
remote_bitrate_estimator_(
new WrappingBitrateEstimator(remb_.get(), Clock::GetRealTimeClock())),
remote_estimator_proxy_(
new RemoteEstimatorProxy(Clock::GetRealTimeClock(),
packet_router_.get())),
encoder_state_feedback_(new EncoderStateFeedback()),
process_thread_(process_thread),
pacer_thread_(ProcessThread::Create("PacerThread")),
// Constructed last as this object calls the provided callback on
@ -166,12 +160,14 @@ ChannelGroup::ChannelGroup(ProcessThread* process_thread)
bitrate_controller_(
BitrateController::CreateBitrateController(Clock::GetRealTimeClock(),
this)) {
remote_bitrate_estimator_.reset(new WrappingBitrateEstimator(
remb_.get(), Clock::GetRealTimeClock()));
call_stats_->RegisterStatsObserver(remote_bitrate_estimator_.get());
pacer_thread_->RegisterModule(pacer_.get());
pacer_thread_->Start();
process_thread->RegisterModule(remote_estimator_proxy_.get());
process_thread->RegisterModule(remote_bitrate_estimator_.get());
process_thread->RegisterModule(call_stats_.get());
process_thread->RegisterModule(bitrate_controller_.get());
@ -183,10 +179,7 @@ ChannelGroup::~ChannelGroup() {
process_thread_->DeRegisterModule(bitrate_controller_.get());
process_thread_->DeRegisterModule(call_stats_.get());
process_thread_->DeRegisterModule(remote_bitrate_estimator_.get());
process_thread_->DeRegisterModule(remote_estimator_proxy_.get());
call_stats_->DeregisterStatsObserver(remote_bitrate_estimator_.get());
if (transport_feedback_adapter_.get())
call_stats_->DeregisterStatsObserver(transport_feedback_adapter_.get());
RTC_DCHECK(channel_map_.empty());
RTC_DCHECK(!remb_->InUse());
RTC_DCHECK(vie_encoder_map_.empty());
@ -197,30 +190,7 @@ bool ChannelGroup::CreateSendChannel(int channel_id,
SendStatisticsProxy* stats_proxy,
I420FrameCallback* pre_encode_callback,
int number_of_cores,
const VideoSendStream::Config& config) {
TransportFeedbackObserver* transport_feedback_observer = nullptr;
bool transport_seq_enabled = false;
for (const RtpExtension& extension : config.rtp.extensions) {
if (extension.name == RtpExtension::kTransportSequenceNumber) {
transport_seq_enabled = true;
break;
}
}
if (transport_seq_enabled) {
if (transport_feedback_adapter_.get() == nullptr) {
transport_feedback_adapter_.reset(new TransportFeedbackAdapter(
bitrate_controller_->CreateRtcpBandwidthObserver(),
Clock::GetRealTimeClock(), process_thread_));
transport_feedback_adapter_->SetBitrateEstimator(
new RemoteBitrateEstimatorAbsSendTime(
transport_feedback_adapter_.get(), Clock::GetRealTimeClock(),
RemoteBitrateEstimator::kDefaultMinBitrateBps));
call_stats_->RegisterStatsObserver(transport_feedback_adapter_.get());
}
transport_feedback_observer = transport_feedback_adapter_.get();
}
const std::vector<uint32_t>& ssrcs = config.rtp.ssrcs;
const std::vector<uint32_t>& ssrcs) {
RTC_DCHECK(!ssrcs.empty());
rtc::scoped_ptr<ViEEncoder> vie_encoder(new ViEEncoder(
channel_id, number_of_cores, process_thread_, stats_proxy,
@ -230,9 +200,7 @@ bool ChannelGroup::CreateSendChannel(int channel_id,
}
ViEEncoder* encoder = vie_encoder.get();
if (!CreateChannel(channel_id, transport, number_of_cores,
vie_encoder.release(), ssrcs.size(), true,
remote_bitrate_estimator_.get(),
transport_feedback_observer)) {
vie_encoder.release(), ssrcs.size(), true)) {
return false;
}
ViEChannel* channel = channel_map_[channel_id];
@ -246,27 +214,11 @@ bool ChannelGroup::CreateSendChannel(int channel_id,
return true;
}
bool ChannelGroup::CreateReceiveChannel(
int channel_id,
bool ChannelGroup::CreateReceiveChannel(int channel_id,
Transport* transport,
int number_of_cores,
const VideoReceiveStream::Config& config) {
bool send_side_bwe = false;
for (const RtpExtension& extension : config.rtp.extensions) {
if (extension.name == RtpExtension::kTransportSequenceNumber) {
send_side_bwe = true;
break;
}
}
RemoteBitrateEstimator* bitrate_estimator;
if (send_side_bwe) {
bitrate_estimator = remote_estimator_proxy_.get();
} else {
bitrate_estimator = remote_bitrate_estimator_.get();
}
return CreateChannel(channel_id, transport, number_of_cores, nullptr, 1,
false, bitrate_estimator, nullptr);
int number_of_cores) {
return CreateChannel(channel_id, transport, number_of_cores,
nullptr, 1, false);
}
bool ChannelGroup::CreateChannel(int channel_id,
@ -274,15 +226,13 @@ bool ChannelGroup::CreateChannel(int channel_id,
int number_of_cores,
ViEEncoder* vie_encoder,
size_t max_rtp_streams,
bool sender,
RemoteBitrateEstimator* bitrate_estimator,
TransportFeedbackObserver* feedback_observer) {
bool sender) {
rtc::scoped_ptr<ViEChannel> channel(new ViEChannel(
number_of_cores, transport, process_thread_,
encoder_state_feedback_->GetRtcpIntraFrameObserver(),
bitrate_controller_->CreateRtcpBandwidthObserver(), feedback_observer,
bitrate_estimator, call_stats_->rtcp_rtt_stats(), pacer_.get(),
packet_router_.get(), max_rtp_streams, sender));
bitrate_controller_->CreateRtcpBandwidthObserver(), nullptr,
remote_bitrate_estimator_.get(), call_stats_->rtcp_rtt_stats(),
pacer_.get(), packet_router_.get(), max_rtp_streams, sender));
if (channel->Init() != 0) {
return false;
}

17
webrtc/video_engine/vie_channel_group.h
View File

@ -19,8 +19,6 @@
#include "webrtc/base/criticalsection.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
#include "webrtc/video_receive_stream.h"
#include "webrtc/video_send_stream.h"
namespace webrtc {
@ -54,11 +52,10 @@ class ChannelGroup : public BitrateObserver {
SendStatisticsProxy* stats_proxy,
I420FrameCallback* pre_encode_callback,
int number_of_cores,
const VideoSendStream::Config& config);
const std::vector<uint32_t>& ssrcs);
bool CreateReceiveChannel(int channel_id,
Transport* transport,
int number_of_cores,
const VideoReceiveStream::Config& config);
int number_of_cores);
void DeleteChannel(int channel_id);
ViEChannel* GetChannel(int channel_id) const;
ViEEncoder* GetEncoder(int channel_id) const;
@ -86,19 +83,16 @@ class ChannelGroup : public BitrateObserver {
int number_of_cores,
ViEEncoder* vie_encoder,
size_t max_rtp_streams,
bool sender,
RemoteBitrateEstimator* bitrate_estimator,
TransportFeedbackObserver* feedback_observer);
bool sender);
ViEChannel* PopChannel(int channel_id);
rtc::scoped_ptr<VieRemb> remb_;
rtc::scoped_ptr<BitrateAllocator> bitrate_allocator_;
rtc::scoped_ptr<CallStats> call_stats_;
rtc::scoped_ptr<RemoteBitrateEstimator> remote_bitrate_estimator_;
rtc::scoped_ptr<EncoderStateFeedback> encoder_state_feedback_;
rtc::scoped_ptr<PacketRouter> packet_router_;
rtc::scoped_ptr<PacedSender> pacer_;
rtc::scoped_ptr<RemoteBitrateEstimator> remote_bitrate_estimator_;
rtc::scoped_ptr<RemoteEstimatorProxy> remote_estimator_proxy_;
rtc::scoped_ptr<EncoderStateFeedback> encoder_state_feedback_;
ChannelMap channel_map_;
// Maps Channel id -> ViEEncoder.
mutable rtc::CriticalSection encoder_map_crit_;
@ -109,7 +103,6 @@ class ChannelGroup : public BitrateObserver {
rtc::scoped_ptr<ProcessThread> pacer_thread_;
rtc::scoped_ptr<BitrateController> bitrate_controller_;
rtc::scoped_ptr<TransportFeedbackAdapter> transport_feedback_adapter_;
};
} // namespace webrtc