admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Delete test/constants.h

Browse Source 
It's not possible to use constants.h for all RTP extensions
after the number of extensions exceeds 14, which is the maximum
number of one-byte RTP extensions. This is because some extensions
would have to be assigned a number greater than 14, even if the
test only involves 14 extensions or less.

For uniformity's sake, this CL also edits some files to use an
enum as the files involved in this CL, rather than free-floating
const-ints.

Bug: webrtc:10288
Change-Id: Ib5e58ad72c4d3756f4c4f6521f140ec59617f3f5
Reviewed-on: https://webrtc-review.googlesource.com/c/123048
Commit-Queue: Elad Alon <eladalon@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26728}
This commit is contained in:
Elad Alon 2019-02-17 22:16:52 +01:00 committed by Commit Bot
parent 8d2e228991
commit 389b1672a3
25 changed files with 326 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
audio/audio_send_stream_tests.cc
View File

@ -8,8 +8,11 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include <string>
#include <utility>
#include <vector>
#include "test/call_test.h"
#include "test/constants.h"
#include "test/field_trial.h"
#include "test/gtest.h"
#include "test/rtcp_packet_parser.h"
@ -18,6 +21,11 @@ namespace webrtc {
namespace test {
namespace {
enum : int { // The first valid value is 1.
kAudioLevelExtensionId = 1,
kTransportSequenceNumberExtensionId,
};
class AudioSendTest : public SendTest {
public:
AudioSendTest() : SendTest(CallTest::kDefaultTimeoutMs) {}
@ -103,8 +111,8 @@ TEST_F(AudioSendStreamCallTest, SupportsAudioLevel) {
class AudioLevelObserver : public AudioSendTest {
public:
AudioLevelObserver() : AudioSendTest() {
EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
kRtpExtensionAudioLevel, test::kAudioLevelExtensionId));
EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
kAudioLevelExtensionId));
}
Action OnSendRtp(const uint8_t* packet, size_t length) override {
@ -127,8 +135,8 @@ TEST_F(AudioSendStreamCallTest, SupportsAudioLevel) {
AudioSendStream::Config* send_config,
std::vector<AudioReceiveStream::Config>* receive_configs) override {
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kAudioLevelUri, test::kAudioLevelExtensionId));
send_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelExtensionId));
}
void PerformTest() override {

4
audio/test/audio_bwe_integration_test.cc
View File

@ -23,6 +23,10 @@ namespace webrtc {
namespace test {
namespace {
enum : int { // The first valid value is 1.
kTransportSequenceNumberExtensionId = 1,
};
// Wait a second between stopping sending and stopping receiving audio.
constexpr int kExtraProcessTimeMs = 1000;
} // namespace

5
modules/rtp_rtcp/source/rtp_sender_audio_unittest.cc
View File

@ -22,7 +22,10 @@
namespace webrtc {
namespace {
const int kAudioLevelExtensionId = 9;
enum : int { // The first valid value is 1.
kAudioLevelExtensionId = 1,
};
const uint16_t kSeqNum = 33;
const uint32_t kSsrc = 725242;
const uint8_t kAudioLevel = 0x5a;

23
modules/rtp_rtcp/source/rtp_sender_unittest.cc
View File

@ -40,16 +40,19 @@
namespace webrtc {
namespace {
const int kTransmissionTimeOffsetExtensionId = 1;
const int kAbsoluteSendTimeExtensionId = 14;
const int kTransportSequenceNumberExtensionId = 13;
const int kVideoTimingExtensionId = 12;
const int kMidExtensionId = 11;
const int kGenericDescriptorId = 10;
const int kAudioLevelExtensionId = 9;
const int kRidExtensionId = 8;
const int kRepairedRidExtensionId = 7;
const int kVideoRotationExtensionId = 5;
enum : int { // The first valid value is 1.
kAbsoluteSendTimeExtensionId = 1,
kAudioLevelExtensionId,
kGenericDescriptorId,
kMidExtensionId,
kRepairedRidExtensionId,
kRidExtensionId,
kTransmissionTimeOffsetExtensionId,
kTransportSequenceNumberExtensionId,
kVideoRotationExtensionId,
kVideoTimingExtensionId,
};
const int kPayload = 100;
const int kRtxPayload = 98;
const uint32_t kTimestamp = 10;

17
modules/rtp_rtcp/source/rtp_sender_video_unittest.cc
View File

@ -34,13 +34,16 @@ namespace {
using ::testing::ElementsAre;
constexpr int kTransmissionTimeOffsetExtensionId = 1;
constexpr int kAbsoluteSendTimeExtensionId = 14;
constexpr int kTransportSequenceNumberExtensionId = 13;
constexpr int kVideoTimingExtensionId = 12;
constexpr int kGenericDescriptorId = 10;
constexpr int kFrameMarkingExtensionId = 6;
constexpr int kVideoRotationExtensionId = 5;
enum : int { // The first valid value is 1.
kAbsoluteSendTimeExtensionId = 1,
kFrameMarkingExtensionId,
kGenericDescriptorId,
kTransmissionTimeOffsetExtensionId,
kTransportSequenceNumberExtensionId,
kVideoRotationExtensionId,
kVideoTimingExtensionId,
};
constexpr int kPayload = 100;
constexpr uint32_t kTimestamp = 10;
constexpr uint16_t kSeqNum = 33;

3
test/BUILD.gn
View File

@ -656,8 +656,6 @@ rtc_source_set("test_common") {
sources = [
"call_test.cc",
"call_test.h",
"constants.cc",
"constants.h",
"drifting_clock.cc",
"drifting_clock.h",
"encoder_settings.cc",
@ -748,6 +746,7 @@ rtc_source_set("test_common") {
"../video",
"//testing/gtest",
"//third_party/abseil-cpp/absl/memory",
"//third_party/abseil-cpp/absl/types:optional",
]
if (!is_android && !build_with_chromium) {
deps += [ "../modules/video_capture:video_capture_internal_impl" ]

64
test/call_test.cc
View File

@ -65,6 +65,29 @@ CallTest::~CallTest() {
});
}
void CallTest::RegisterRtpExtension(const RtpExtension& extension) {
for (const RtpExtension& registered_extension : rtp_extensions_) {
if (registered_extension.id == extension.id) {
ASSERT_EQ(registered_extension.uri, extension.uri)
<< "Different URIs associated with ID " << extension.id << ".";
ASSERT_EQ(registered_extension.encrypt, extension.encrypt)
<< "Encryption mismatch associated with ID " << extension.id << ".";
return;
} else { // Different IDs.
// Different IDs referring to the same extension probably indicate
// a mistake in the test.
ASSERT_FALSE(registered_extension.uri == extension.uri &&
registered_extension.encrypt == extension.encrypt)
<< "URI " << extension.uri
<< (extension.encrypt ? " with " : " without ")
<< "encryption already registered with a different "
<< "ID (" << extension.id << " vs. " << registered_extension.id
<< ").";
}
}
rtp_extensions_.push_back(extension);
}
void CallTest::RunBaseTest(BaseTest* test) {
task_queue_.SendTask([this, test]() {
num_video_streams_ = test->GetNumVideoStreams();
@ -235,25 +258,23 @@ void CallTest::CreateVideoSendConfig(VideoSendStream::Config* video_config,
video_config->rtp.payload_name = "FAKE";
video_config->rtp.payload_type = kFakeVideoSendPayloadType;
video_config->rtp.extmap_allow_mixed = true;
video_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId));
video_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kVideoContentTypeUri, kVideoContentTypeExtensionId));
video_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kGenericFrameDescriptorUri, kGenericDescriptorExtensionId));
AddRtpExtensionByUri(RtpExtension::kTransportSequenceNumberUri,
&video_config->rtp.extensions);
AddRtpExtensionByUri(RtpExtension::kVideoContentTypeUri,
&video_config->rtp.extensions);
AddRtpExtensionByUri(RtpExtension::kGenericFrameDescriptorUri,
&video_config->rtp.extensions);
if (video_encoder_configs_.empty()) {
video_encoder_configs_.emplace_back();
FillEncoderConfiguration(kVideoCodecGeneric, num_video_streams,
&video_encoder_configs_.back());
}
for (size_t i = 0; i < num_video_streams; ++i)
video_config->rtp.ssrcs.push_back(kVideoSendSsrcs[num_used_ssrcs + i]);
video_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kVideoRotationUri, kVideoRotationExtensionId));
video_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kColorSpaceUri, kColorSpaceExtensionId));
AddRtpExtensionByUri(RtpExtension::kVideoRotationUri,
&video_config->rtp.extensions);
AddRtpExtensionByUri(RtpExtension::kColorSpaceUri,
&video_config->rtp.extensions);
}
void CallTest::CreateAudioAndFecSendConfigs(size_t num_audio_streams,
@ -666,6 +687,25 @@ FlexfecReceiveStream::Config* CallTest::GetFlexFecConfig() {
return &flexfec_receive_configs_[0];
}
absl::optional<RtpExtension> CallTest::GetRtpExtensionByUri(
const std::string& uri) const {
for (const auto& extension : rtp_extensions_) {
if (extension.uri == uri) {
return extension;
}
}
return absl::nullopt;
}
void CallTest::AddRtpExtensionByUri(
const std::string& uri,
std::vector<RtpExtension>* extensions) const {
const absl::optional<RtpExtension> extension = GetRtpExtensionByUri(uri);
if (extension) {
extensions->push_back(*extension);
}
}
constexpr size_t CallTest::kNumSsrcs;
const int CallTest::kDefaultWidth;
const int CallTest::kDefaultHeight;

10
test/call_test.h
View File

@ -15,6 +15,7 @@
#include <string>
#include <vector>
#include "absl/types/optional.h"
#include "api/test/video/function_video_decoder_factory.h"
#include "api/test/video/function_video_encoder_factory.h"
#include "api/video/video_bitrate_allocator_factory.h"
@ -71,6 +72,8 @@ class CallTest : public ::testing::Test {
static const std::map<uint8_t, MediaType> payload_type_map_;
protected:
void RegisterRtpExtension(const RtpExtension& extension);
// RunBaseTest overwrites the audio_state of the send and receive Call configs
// to simplify test code.
void RunBaseTest(BaseTest* test);
@ -216,6 +219,13 @@ class CallTest : public ::testing::Test {
SingleThreadedTaskQueueForTesting task_queue_;
private:
absl::optional<RtpExtension> GetRtpExtensionByUri(
const std::string& uri) const;
void AddRtpExtensionByUri(const std::string& uri,
std::vector<RtpExtension>* extensions) const;
std::vector<RtpExtension> rtp_extensions_;
rtc::scoped_refptr<AudioProcessing> apm_send_;
rtc::scoped_refptr<AudioProcessing> apm_recv_;
rtc::scoped_refptr<TestAudioDeviceModule> fake_send_audio_device_;

27
test/constants.cc
View File

@ -1,27 +0,0 @@
/*
* Copyright (c) 2015 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 "test/constants.h"
namespace webrtc {
namespace test {
const int kAudioLevelExtensionId = 5;
const int kTOffsetExtensionId = 6;
const int kAbsSendTimeExtensionId = 7;
const int kTransportSequenceNumberExtensionId = 8;
const int kVideoRotationExtensionId = 9;
const int kVideoContentTypeExtensionId = 10;
const int kVideoTimingExtensionId = 11;
const int kGenericDescriptorExtensionId = 12;
const int kColorSpaceExtensionId = 13;
} // namespace test
} // namespace webrtc

24
test/constants.h
View File

@ -1,24 +0,0 @@
/*
* Copyright (c) 2015 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.
*/
namespace webrtc {
namespace test {
extern const int kAudioLevelExtensionId;
extern const int kTOffsetExtensionId;
extern const int kAbsSendTimeExtensionId;
extern const int kTransportSequenceNumberExtensionId;
extern const int kVideoRotationExtensionId;
extern const int kVideoContentTypeExtensionId;
extern const int kVideoTimingExtensionId;
extern const int kGenericDescriptorExtensionId;
extern const int kColorSpaceExtensionId;
} // namespace test
} // namespace webrtc

11
test/rtp_rtcp_observer.h
View File

@ -12,6 +12,7 @@
#include <map>
#include <memory>
#include <utility>
#include <vector>
#include "api/test/simulated_network.h"
@ -21,7 +22,6 @@
#include "rtc_base/critical_section.h"
#include "rtc_base/event.h"
#include "system_wrappers/include/field_trial.h"
#include "test/constants.h"
#include "test/direct_transport.h"
#include "test/gtest.h"
@ -71,14 +71,7 @@ class RtpRtcpObserver {
protected:
RtpRtcpObserver() : RtpRtcpObserver(0) {}
explicit RtpRtcpObserver(int event_timeout_ms)
: parser_(RtpHeaderParser::Create()), timeout_ms_(event_timeout_ms) {
parser_->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
kTOffsetExtensionId);
parser_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
kAbsSendTimeExtensionId);
parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
kTransportSequenceNumberExtensionId);
}
: parser_(RtpHeaderParser::Create()), timeout_ms_(event_timeout_ms) {}
rtc::Event observation_complete_;
const std::unique_ptr<RtpHeaderParser> parser_;

7
test/scenario/video_stream.cc
View File

@ -27,8 +27,13 @@
namespace webrtc {
namespace test {
namespace {
enum : int { // The first valid value is 1.
kTransportSequenceNumberExtensionId = 1,
kVideoContentTypeExtensionId,
kVideoRotationRtpExtensionId,
};
constexpr int kDefaultMaxQp = cricket::WebRtcVideoChannel::kDefaultQpMax;
const int kVideoRotationRtpExtensionId = 4;
uint8_t CodecTypeToPayloadType(VideoCodecType codec_type) {
switch (codec_type) {
case VideoCodecType::kVideoCodecGeneric:

13
video/end_to_end_tests/bandwidth_tests.cc
View File

@ -26,6 +26,11 @@
#include "test/video_encoder_proxy_factory.h"
namespace webrtc {
namespace {
enum : int { // The first valid value is 1.
kAbsSendTimeExtensionId = 1,
};
} // namespace
class BandwidthEndToEndTest : public test::CallTest {
public:
@ -42,8 +47,8 @@ TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
send_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
(*receive_configs)[0].rtp.remb = true;
(*receive_configs)[0].rtp.transport_cc = false;
}
@ -87,8 +92,8 @@ class BandwidthStatsTest : public test::EndToEndTest {
VideoEncoderConfig* encoder_config) override {
if (!send_side_bwe_) {
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
send_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
(*receive_configs)[0].rtp.remb = true;
(*receive_configs)[0].rtp.transport_cc = false;
}

18
video/end_to_end_tests/codec_tests.cc
View File

@ -27,11 +27,22 @@
#include "test/gtest.h"
namespace webrtc {
namespace {
enum : int { // The first valid value is 1.
kColorSpaceExtensionId = 1,
kVideoRotationExtensionId,
};
} // namespace
class CodecEndToEndTest : public test::CallTest,
public testing::WithParamInterface<std::string> {
public:
CodecEndToEndTest() : field_trial_(GetParam()) {}
CodecEndToEndTest() : field_trial_(GetParam()) {
RegisterRtpExtension(
RtpExtension(RtpExtension::kColorSpaceUri, kColorSpaceExtensionId));
RegisterRtpExtension(RtpExtension(RtpExtension::kVideoRotationUri,
kVideoRotationExtensionId));
}
private:
test::ScopedFieldTrials field_trial_;
@ -224,7 +235,10 @@ TEST_P(CodecEndToEndTest, SendsAndReceivesMultiplexVideoRotation90) {
class EndToEndTestH264 : public test::CallTest,
public testing::WithParamInterface<std::string> {
public:
EndToEndTestH264() : field_trial_(GetParam()) {}
EndToEndTestH264() : field_trial_(GetParam()) {
RegisterRtpExtension(RtpExtension(RtpExtension::kVideoRotationUri,
kVideoRotationExtensionId));
}
private:
test::ScopedFieldTrials field_trial_;

14
video/end_to_end_tests/extended_reports_tests.cc
View File

@ -43,8 +43,20 @@
#include "test/single_threaded_task_queue.h"
namespace webrtc {
namespace {
enum : int { // The first valid value is 1.
kColorSpaceExtensionId = 1,
kTransportSequenceNumberExtensionId,
};
} // namespace
class ExtendedReportsEndToEndTest : public test::CallTest {};
class ExtendedReportsEndToEndTest : public test::CallTest {
public:
ExtendedReportsEndToEndTest() {
RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId));
}
};
class RtcpXrObserver : public test::EndToEndTest {
public:

13
video/end_to_end_tests/fec_tests.cc
View File

@ -22,10 +22,21 @@
#include "test/rtcp_packet_parser.h"
namespace webrtc {
namespace {
enum : int { // The first valid value is 1.
kTransportSequenceNumberExtensionId = 1,
kVideoRotationExtensionId,
};
} // namespace
class FecEndToEndTest : public test::CallTest {
public:
FecEndToEndTest() = default;
FecEndToEndTest() {
RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId));
RegisterRtpExtension(RtpExtension(RtpExtension::kVideoRotationUri,
kVideoRotationExtensionId));
}
};
TEST_F(FecEndToEndTest, ReceivesUlpfec) {

10
video/end_to_end_tests/frame_encryption_tests.cc
View File

@ -17,10 +17,18 @@
#include "test/gtest.h"
namespace webrtc {
namespace {
enum : int { // The first valid value is 1.
kGenericDescriptorExtensionId = 1,
};
} // namespace
class FrameEncryptionEndToEndTest : public test::CallTest {
public:
FrameEncryptionEndToEndTest() = default;
FrameEncryptionEndToEndTest() {
RegisterRtpExtension(RtpExtension(RtpExtension::kGenericFrameDescriptorUri,
kGenericDescriptorExtensionId));
}
private:
// GenericDescriptor is required for FrameEncryption to work.

14
video/end_to_end_tests/histogram_tests.cc
View File

@ -16,8 +16,22 @@
#include "test/gtest.h"
namespace webrtc {
namespace {
enum : int { // The first valid value is 1.
kTransportSequenceNumberExtensionId = 1,
kVideoContentTypeExtensionId,
};
} // namespace
class HistogramTest : public test::CallTest {
public:
HistogramTest() {
RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId));
RegisterRtpExtension(RtpExtension(RtpExtension::kVideoContentTypeUri,
kVideoContentTypeExtensionId));
}
protected:
void VerifyHistogramStats(bool use_rtx, bool use_fec, bool screenshare);
};

16
video/end_to_end_tests/probing_tests.cc
View File

@ -15,9 +15,21 @@
#include "test/call_test.h"
#include "test/field_trial.h"
#include "test/gtest.h"
namespace webrtc {
class ProbingEndToEndTest : public test::CallTest {};
namespace webrtc {
namespace {
enum : int { // The first valid value is 1.
kTransportSequenceNumberExtensionId = 1,
};
} // namespace
class ProbingEndToEndTest : public test::CallTest {
public:
ProbingEndToEndTest() {
RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId));
}
};
class ProbingTest : public test::EndToEndTest {
public:

11
video/end_to_end_tests/retransmission_tests.cc
View File

@ -21,9 +21,18 @@
#include "test/rtcp_packet_parser.h"
namespace webrtc {
namespace {
enum : int { // The first valid value is 1.
kVideoRotationExtensionId = 1,
};
} // namespace
class RetransmissionEndToEndTest : public test::CallTest {
public:
RetransmissionEndToEndTest() = default;
RetransmissionEndToEndTest() {
RegisterRtpExtension(RtpExtension(RtpExtension::kVideoRotationUri,
kVideoRotationExtensionId));
}
protected:
void DecodesRetransmittedFrame(bool enable_rtx, bool enable_red);

7
video/end_to_end_tests/rtp_rtcp_tests.cc
View File

@ -18,6 +18,11 @@
#include "test/rtcp_packet_parser.h"
namespace webrtc {
namespace {
enum : int { // The first valid value is 1.
kTransportSequenceNumberExtensionId = 1,
};
} // namespace
class RtpRtcpEndToEndTest : public test::CallTest {
protected:
@ -530,7 +535,7 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
flexfec_receive_config.transport_cc = true;
flexfec_receive_config.rtp_header_extensions.emplace_back(
RtpExtension::kTransportSequenceNumberUri,
test::kTransportSequenceNumberExtensionId);
kTransportSequenceNumberExtensionId);
flexfec_receive_configs_.push_back(flexfec_receive_config);
CreateFlexfecStreams();

14
video/end_to_end_tests/stats_tests.cc
View File

@ -24,7 +24,19 @@
#include "test/rtcp_packet_parser.h"
namespace webrtc {
class StatsEndToEndTest : public test::CallTest {};
namespace {
enum : int { // The first valid value is 1.
kVideoContentTypeExtensionId = 1,
};
} // namespace
class StatsEndToEndTest : public test::CallTest {
public:
StatsEndToEndTest() {
RegisterRtpExtension(RtpExtension(RtpExtension::kVideoContentTypeUri,
kVideoContentTypeExtensionId));
}
};
TEST_F(StatsEndToEndTest, GetStats) {
static const int kStartBitrateBps = 3000000;

39
video/end_to_end_tests/transport_feedback_tests.cc
View File

@ -21,12 +21,21 @@
#include "video/end_to_end_tests/multi_stream_tester.h"
namespace webrtc {
namespace {
enum : int { // The first valid value is 1.
kTransportSequenceNumberExtensionId = 1,
};
} // namespace
class TransportFeedbackEndToEndTest : public test::CallTest {};
class TransportFeedbackEndToEndTest : public test::CallTest {
public:
TransportFeedbackEndToEndTest() {
RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId));
}
};
TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
static const int kExtensionId = 5;
class RtpExtensionHeaderObserver : public test::DirectTransport {
public:
RtpExtensionHeaderObserver(
@ -50,7 +59,7 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
retransmit_observed_(false),
started_(false) {
parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
kExtensionId);
kTransportSequenceNumberExtensionId);
}
virtual ~RtpExtensionHeaderObserver() {}
@ -174,8 +183,9 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
VideoEncoderConfig* encoder_config,
test::FrameGeneratorCapturer** frame_generator) override {
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kTransportSequenceNumberUri, kExtensionId));
send_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId));
// Force some padding to be sent. Note that since we do send media
// packets we can not guarantee that a padding only packet is sent.
@ -201,8 +211,9 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
VideoReceiveStream::Config* receive_config) override {
receive_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
receive_config->rtp.extensions.clear();
receive_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kTransportSequenceNumberUri, kExtensionId));
receive_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId));
receive_config->renderer = &fake_renderer_;
}
@ -291,14 +302,14 @@ class TransportFeedbackTester : public test::EndToEndTest {
std::vector<AudioReceiveStream::Config>* receive_configs) override {
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumberUri, kExtensionId));
RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId));
(*receive_configs)[0].rtp.extensions.clear();
(*receive_configs)[0].rtp.extensions = send_config->rtp.extensions;
(*receive_configs)[0].rtp.transport_cc = feedback_enabled_;
}
private:
static const int kExtensionId = 5;
const bool feedback_enabled_;
const size_t num_video_streams_;
const size_t num_audio_streams_;
@ -426,7 +437,6 @@ TEST_F(TransportFeedbackEndToEndTest,
TEST_F(TransportFeedbackEndToEndTest, TransportSeqNumOnAudioAndVideo) {
test::ScopedFieldTrials field_trials("WebRTC-Audio-SendSideBwe/Enabled/");
static constexpr int kExtensionId = 8;
static constexpr size_t kMinPacketsToWaitFor = 50;
class TransportSequenceNumberTest : public test::EndToEndTest {
public:
@ -435,7 +445,7 @@ TEST_F(TransportFeedbackEndToEndTest, TransportSeqNumOnAudioAndVideo) {
video_observed_(false),
audio_observed_(false) {
parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
kExtensionId);
kTransportSequenceNumberExtensionId);
}
size_t GetNumVideoStreams() const override { return 1; }
@ -445,8 +455,9 @@ TEST_F(TransportFeedbackEndToEndTest, TransportSeqNumOnAudioAndVideo) {
AudioSendStream::Config* send_config,
std::vector<AudioReceiveStream::Config>* receive_configs) override {
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kTransportSequenceNumberUri, kExtensionId));
send_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId));
(*receive_configs)[0].rtp.extensions.clear();
(*receive_configs)[0].rtp.extensions = send_config->rtp.extensions;
}

32
video/video_quality_test.cc
View File

@ -47,6 +47,14 @@
namespace webrtc {
namespace {
enum : int { // The first valid value is 1.
kAbsSendTimeExtensionId = 1,
kGenericFrameDescriptorExtensionId,
kTransportSequenceNumberExtensionId,
kVideoContentTypeExtensionId,
kVideoTimingExtensionId,
};
constexpr char kSyncGroup[] = "av_sync";
constexpr int kOpusMinBitrateBps = 6000;
constexpr int kOpusBitrateFbBps = 32000;
@ -710,10 +718,10 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
if (params_.call.send_side_bwe) {
video_send_configs_[video_idx].rtp.extensions.emplace_back(
RtpExtension::kTransportSequenceNumberUri,
test::kTransportSequenceNumberExtensionId);
kTransportSequenceNumberExtensionId);
} else {
video_send_configs_[video_idx].rtp.extensions.emplace_back(
RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId);
RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId);
}
if (params_.call.generic_descriptor) {
@ -724,13 +732,13 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
video_send_configs_[video_idx].rtp.extensions.emplace_back(
RtpExtension::kGenericFrameDescriptorUri,
test::kGenericDescriptorExtensionId);
kGenericFrameDescriptorExtensionId);
}
video_send_configs_[video_idx].rtp.extensions.emplace_back(
RtpExtension::kVideoContentTypeUri, test::kVideoContentTypeExtensionId);
RtpExtension::kVideoContentTypeUri, kVideoContentTypeExtensionId);
video_send_configs_[video_idx].rtp.extensions.emplace_back(
RtpExtension::kVideoTimingUri, test::kVideoTimingExtensionId);
RtpExtension::kVideoTimingUri, kVideoTimingExtensionId);
video_encoder_configs_[video_idx].video_format.name =
params_.video[video_idx].codec;
@ -878,10 +886,10 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
if (params_.call.send_side_bwe) {
GetFlexFecConfig()->rtp_header_extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumberUri,
test::kTransportSequenceNumberExtensionId));
kTransportSequenceNumberExtensionId));
} else {
GetFlexFecConfig()->rtp_header_extensions.push_back(RtpExtension(
RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
GetFlexFecConfig()->rtp_header_extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
}
}
@ -919,10 +927,10 @@ void VideoQualityTest::SetupThumbnails(Transport* send_transport,
if (params_.call.send_side_bwe) {
thumbnail_send_config.rtp.extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumberUri,
test::kTransportSequenceNumberExtensionId));
kTransportSequenceNumberExtensionId));
} else {
thumbnail_send_config.rtp.extensions.push_back(RtpExtension(
RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
thumbnail_send_config.rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
}
VideoEncoderConfig thumbnail_encoder_config;
@ -1354,7 +1362,7 @@ void VideoQualityTest::SetupAudio(Transport* transport) {
if (params_.call.send_side_bwe) {
audio_send_config.rtp.extensions.push_back(
webrtc::RtpExtension(webrtc::RtpExtension::kTransportSequenceNumberUri,
test::kTransportSequenceNumberExtensionId));
kTransportSequenceNumberExtensionId));
audio_send_config.min_bitrate_bps = kOpusMinBitrateBps;
audio_send_config.max_bitrate_bps = kOpusBitrateFbBps;
audio_send_config.send_codec_spec->transport_cc_enabled = true;

75
video/video_send_stream_tests.cc
View File

@ -73,6 +73,15 @@ class VideoSendStreamPeer {
} // namespace test
namespace {
enum : int { // The first valid value is 1.
kAbsSendTimeExtensionId = 1,
kTimestampOffsetExtensionId,
kTransportSequenceNumberExtensionId,
kVideoContentTypeExtensionId,
kVideoRotationExtensionId,
kVideoTimingExtensionId,
};
constexpr int64_t kRtcpIntervalMs = 1000;
enum VideoFormat {
@ -84,6 +93,12 @@ enum VideoFormat {
VideoFrame CreateVideoFrame(int width, int height, uint8_t data);
class VideoSendStreamTest : public test::CallTest {
public:
VideoSendStreamTest() {
RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId));
}
protected:
void TestNackRetransmission(uint32_t retransmit_ssrc,
uint8_t retransmit_payload_type);
@ -163,7 +178,7 @@ TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
public:
AbsoluteSendTimeObserver() : SendTest(kDefaultTimeoutMs) {
EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
kRtpExtensionAbsoluteSendTime, test::kAbsSendTimeExtensionId));
kRtpExtensionAbsoluteSendTime, kAbsSendTimeExtensionId));
}
Action OnSendRtp(const uint8_t* packet, size_t length) override {
@ -193,8 +208,8 @@ TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
send_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
}
void PerformTest() override {
@ -215,7 +230,7 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
Clock::GetRealTimeClock(), kEncodeDelayMs);
}) {
EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
kRtpExtensionTransmissionTimeOffset, test::kTOffsetExtensionId));
kRtpExtensionTransmissionTimeOffset, kTimestampOffsetExtensionId));
}
private:
@ -239,7 +254,7 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kTimestampOffsetUri, test::kTOffsetExtensionId));
RtpExtension::kTimestampOffsetUri, kTimestampOffsetExtensionId));
}
void PerformTest() override {
@ -253,7 +268,7 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
}
TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
static const uint8_t kExtensionId = test::kTransportSequenceNumberExtensionId;
static const uint8_t kExtensionId = kTransportSequenceNumberExtensionId;
class TransportWideSequenceNumberObserver : public test::SendTest {
public:
TransportWideSequenceNumberObserver()
@ -301,7 +316,7 @@ TEST_F(VideoSendStreamTest, SupportsVideoRotation) {
public:
VideoRotationObserver() : SendTest(kDefaultTimeoutMs) {
EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
kRtpExtensionVideoRotation, test::kVideoRotationExtensionId));
kRtpExtensionVideoRotation, kVideoRotationExtensionId));
}
Action OnSendRtp(const uint8_t* packet, size_t length) override {
@ -322,7 +337,7 @@ TEST_F(VideoSendStreamTest, SupportsVideoRotation) {
VideoEncoderConfig* encoder_config) override {
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kVideoRotationUri, test::kVideoRotationExtensionId));
RtpExtension::kVideoRotationUri, kVideoRotationExtensionId));
}
void OnFrameGeneratorCapturerCreated(
@ -344,7 +359,7 @@ TEST_F(VideoSendStreamTest, SupportsVideoContentType) {
VideoContentTypeObserver()
: SendTest(kDefaultTimeoutMs), first_frame_sent_(false) {
EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
kRtpExtensionVideoContentType, test::kVideoContentTypeExtensionId));
kRtpExtensionVideoContentType, kVideoContentTypeExtensionId));
}
Action OnSendRtp(const uint8_t* packet, size_t length) override {
@ -367,9 +382,8 @@ TEST_F(VideoSendStreamTest, SupportsVideoContentType) {
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kVideoContentTypeUri,
test::kVideoContentTypeExtensionId));
send_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kVideoContentTypeUri, kVideoContentTypeExtensionId));
encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen;
}
@ -389,8 +403,8 @@ TEST_F(VideoSendStreamTest, SupportsVideoTimingFrames) {
public:
VideoTimingObserver()
: SendTest(kDefaultTimeoutMs), first_frame_sent_(false) {
EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
kRtpExtensionVideoTiming, test::kVideoTimingExtensionId));
EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(kRtpExtensionVideoTiming,
kVideoTimingExtensionId));
}
Action OnSendRtp(const uint8_t* packet, size_t length) override {
@ -412,8 +426,8 @@ TEST_F(VideoSendStreamTest, SupportsVideoTimingFrames) {
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kVideoTimingUri, test::kVideoTimingExtensionId));
send_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kVideoTimingUri, kVideoTimingExtensionId));
}
void PerformTest() override {
@ -464,7 +478,12 @@ class UlpfecObserver : public test::EndToEndTest {
expect_ulpfec_(expect_ulpfec),
sent_media_(false),
sent_ulpfec_(false),
header_extensions_enabled_(header_extensions_enabled) {}
header_extensions_enabled_(header_extensions_enabled) {
parser_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
kAbsSendTimeExtensionId);
parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
kTransportSequenceNumberExtensionId);
}
// Some of the test cases are expected to time out and thus we are using
// a shorter timeout window than the default here.
@ -564,12 +583,11 @@ class UlpfecObserver : public test::EndToEndTest {
VideoSendStreamTest::kRedPayloadType;
send_config->rtp.ulpfec.ulpfec_payload_type =
VideoSendStreamTest::kUlpfecPayloadType;
EXPECT_FALSE(send_config->rtp.extensions.empty());
if (!header_extensions_enabled_) {
send_config->rtp.extensions.clear();
} else {
send_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
send_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
}
encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
(*receive_configs)[0].rtp.red_payload_type =
@ -687,7 +705,14 @@ class FlexfecObserver : public test::EndToEndTest {
sent_media_(false),
sent_flexfec_(false),
header_extensions_enabled_(header_extensions_enabled),
num_video_streams_(num_video_streams) {}
num_video_streams_(num_video_streams) {
parser_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
kAbsSendTimeExtensionId);
parser_->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
kTimestampOffsetExtensionId);
parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
kTransportSequenceNumberExtensionId);
}
size_t GetNumFlexfecStreams() const override { return 1; }
size_t GetNumVideoStreams() const override { return num_video_streams_; }
@ -751,10 +776,10 @@ class FlexfecObserver : public test::EndToEndTest {
send_config->encoder_settings.encoder_factory = encoder_factory_;
send_config->rtp.payload_name = payload_name_;
if (header_extensions_enabled_) {
send_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
send_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
send_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kTimestampOffsetUri, test::kTOffsetExtensionId));
RtpExtension::kTimestampOffsetUri, kTimestampOffsetExtensionId));
} else {
send_config->rtp.extensions.clear();
}
@ -1628,7 +1653,7 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
static const int kStartBitrateBps = 300000;
static const int kNewMaxBitrateBps = 1234567;
static const uint8_t kExtensionId = test::kTransportSequenceNumberExtensionId;
static const uint8_t kExtensionId = kTransportSequenceNumberExtensionId;
class ChangingNetworkRouteTest : public test::EndToEndTest {
public:
explicit ChangingNetworkRouteTest(