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

Vp9Test: Always expect StreamLayersConfig to be present.

Browse Source 
The scalability mode should now be supported for all test configurations.

Bug: none
Change-Id: I79aeb56b35d62265c94edefdbcb10c6835bc2750
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/280200
Reviewed-by: Sergey Silkin <ssilkin@webrtc.org>
Commit-Queue: Åsa Persson <asapersson@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#38482}
This commit is contained in:
Åsa Persson
2022-10-25 17:09:01 +02:00
committed by WebRTC LUCI CQ
parent b4c96d6476
commit 86cfcc5eef
1 changed files with 28 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
video/video_send_stream_tests.cc
View File

@ -3039,9 +3039,9 @@ class Vp9HeaderObserver : public test::SendTest {
EXPECT_EQ(kVp9PayloadType, rtp_packet.PayloadType()); EXPECT_EQ(kVp9PayloadType, rtp_packet.PayloadType());
rtc::ArrayView<const uint8_t> rtp_payload = rtp_packet.payload(); rtc::ArrayView<const uint8_t> rtp_payload = rtp_packet.payload();
bool new_packet = packets_sent_ == 0 || bool new_packet = !last_packet_sequence_number_.has_value() ||
IsNewerSequenceNumber(rtp_packet.SequenceNumber(), IsNewerSequenceNumber(rtp_packet.SequenceNumber(),
last_packet_sequence_number_); *last_packet_sequence_number_);
if (!rtp_payload.empty() && new_packet) { if (!rtp_payload.empty() && new_packet) {
RTPVideoHeader video_header; RTPVideoHeader video_header;
EXPECT_NE( EXPECT_NE(
@ -3056,7 +3056,6 @@ class Vp9HeaderObserver : public test::SendTest {
// Verify configuration specific settings. // Verify configuration specific settings.
InspectHeader(vp9_header); InspectHeader(vp9_header);
++packets_sent_;
if (rtp_packet.Marker()) { if (rtp_packet.Marker()) {
MutexLock lock(&mutex_); MutexLock lock(&mutex_);
++frames_sent_; ++frames_sent_;
@ -3278,20 +3277,12 @@ class Vp9HeaderObserver : public test::SendTest {
vp9.num_spatial_layers); vp9.num_spatial_layers);
EXPECT_TRUE(vp9.spatial_layer_resolution_present); // Y:1 EXPECT_TRUE(vp9.spatial_layer_resolution_present); // Y:1
absl::optional<ScalableVideoController::StreamLayersConfig> info; ScalableVideoController::StreamLayersConfig config = GetScalabilityConfig();
absl::optional<ScalabilityMode> scalability_mode = for (int i = config.num_spatial_layers - 1; i >= 0; --i) {
ScalabilityModeFromString(params_.scalability_mode); double ratio = static_cast<double>(config.scaling_factor_num[i]) /
if (scalability_mode) { config.scaling_factor_den[i];
info = ScalabilityStructureConfig(*scalability_mode);
}
double default_ratio = 1.0;
for (int i = static_cast<int>(vp9.num_spatial_layers) - 1; i >= 0; --i) {
double ratio = info ? (static_cast<double>(info->scaling_factor_num[i]) /
info->scaling_factor_den[i])
: default_ratio;
EXPECT_EQ(expected_width_ * ratio, vp9.width[i]); // WIDTH EXPECT_EQ(expected_width_ * ratio, vp9.width[i]); // WIDTH
EXPECT_EQ(expected_height_ * ratio, vp9.height[i]); // HEIGHT EXPECT_EQ(expected_height_ * ratio, vp9.height[i]); // HEIGHT
default_ratio /= 2.0;
} }
} }
@ -3301,15 +3292,15 @@ class Vp9HeaderObserver : public test::SendTest {
absl::get<RTPVideoHeaderVP9>(video.video_type_header); absl::get<RTPVideoHeaderVP9>(video.video_type_header);
const bool new_temporal_unit = const bool new_temporal_unit =
packets_sent_ == 0 || !last_packet_timestamp_.has_value() ||
IsNewerTimestamp(rtp_packet.Timestamp(), last_packet_timestamp_); IsNewerTimestamp(rtp_packet.Timestamp(), *last_packet_timestamp_);
const bool new_frame = const bool new_frame =
new_temporal_unit || last_vp9_.spatial_idx != vp9_header.spatial_idx; new_temporal_unit || last_vp9_.spatial_idx != vp9_header.spatial_idx;
EXPECT_EQ(new_frame, video.is_first_packet_in_frame); EXPECT_EQ(new_frame, video.is_first_packet_in_frame);
if (!new_temporal_unit) { if (!new_temporal_unit) {
EXPECT_FALSE(last_packet_marker_); EXPECT_FALSE(last_packet_marker_);
EXPECT_EQ(last_packet_timestamp_, rtp_packet.Timestamp()); EXPECT_EQ(*last_packet_timestamp_, rtp_packet.Timestamp());
EXPECT_EQ(last_vp9_.picture_id, vp9_header.picture_id); EXPECT_EQ(last_vp9_.picture_id, vp9_header.picture_id);
EXPECT_EQ(last_vp9_.tl0_pic_idx, vp9_header.tl0_pic_idx); EXPECT_EQ(last_vp9_.tl0_pic_idx, vp9_header.tl0_pic_idx);
VerifySpatialIdxWithinFrame(vp9_header); VerifySpatialIdxWithinFrame(vp9_header);
@ -3328,16 +3319,26 @@ class Vp9HeaderObserver : public test::SendTest {
VerifyTl0Idx(vp9_header); VerifyTl0Idx(vp9_header);
} }
ScalableVideoController::StreamLayersConfig GetScalabilityConfig() const {
absl::optional<ScalabilityMode> scalability_mode =
ScalabilityModeFromString(params_.scalability_mode);
EXPECT_TRUE(scalability_mode.has_value());
absl::optional<ScalableVideoController::StreamLayersConfig> config =
ScalabilityStructureConfig(*scalability_mode);
EXPECT_TRUE(config.has_value());
EXPECT_EQ(config->num_spatial_layers, params_.num_spatial_layers);
return *config;
}
test::FunctionVideoEncoderFactory encoder_factory_; test::FunctionVideoEncoderFactory encoder_factory_;
const Vp9TestParams params_; const Vp9TestParams params_;
VideoCodecVP9 vp9_settings_; VideoCodecVP9 vp9_settings_;
webrtc::VideoEncoderConfig encoder_config_; webrtc::VideoEncoderConfig encoder_config_;
bool last_packet_marker_ = false; bool last_packet_marker_ = false;
uint16_t last_packet_sequence_number_ = 0; absl::optional<uint16_t> last_packet_sequence_number_;
uint32_t last_packet_timestamp_ = 0; absl::optional<uint32_t> last_packet_timestamp_;
RTPVideoHeaderVP9 last_vp9_; RTPVideoHeaderVP9 last_vp9_;
std::map<int, int> last_temporal_idx_by_spatial_idx_; std::map<int, int> last_temporal_idx_by_spatial_idx_;
size_t packets_sent_ = 0;
Mutex mutex_; Mutex mutex_;
size_t frames_sent_ = 0; size_t frames_sent_ = 0;
int expected_width_ = 0; int expected_width_ = 0;
@ -3348,8 +3349,8 @@ class Vp9Test : public VideoSendStreamTest,
public ::testing::WithParamInterface<ParameterizationType> { public ::testing::WithParamInterface<ParameterizationType> {
public: public:
Vp9Test() Vp9Test()
: params_(::testing::get<0>(GetParam())), : params_(::testing::get<Vp9TestParams>(GetParam())),
use_scalability_mode_identifier_(::testing::get<1>(GetParam())) {} use_scalability_mode_identifier_(::testing::get<bool>(GetParam())) {}
protected: protected:
const Vp9TestParams params_; const Vp9TestParams params_;
@ -3462,17 +3463,12 @@ void VideoSendStreamTest::TestVp9NonFlexMode(
} }
int GetRequiredDivisibility() const { int GetRequiredDivisibility() const {
absl::optional<ScalabilityMode> scalability_mode = ScalableVideoController::StreamLayersConfig config =
ScalabilityModeFromString(params_.scalability_mode); GetScalabilityConfig();
EXPECT_TRUE(scalability_mode);
absl::optional<ScalableVideoController::StreamLayersConfig> config =
ScalabilityStructureConfig(*scalability_mode);
EXPECT_TRUE(config);
int required_divisibility = 1; int required_divisibility = 1;
for (size_t sl_idx = 0; sl_idx < params_.num_spatial_layers; ++sl_idx) { for (int sl_idx = 0; sl_idx < config.num_spatial_layers; ++sl_idx) {
required_divisibility = cricket::LeastCommonMultiple( required_divisibility = cricket::LeastCommonMultiple(
required_divisibility, config->scaling_factor_den[sl_idx]); required_divisibility, config.scaling_factor_den[sl_idx]);
} }
return required_divisibility; return required_divisibility;
} }