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

Do not use internal source in H.264 bitstream rewriting tests.

Browse Source 
Bug: None
Change-Id: Ice1ffb4371ade57bd642f5fe86d6432f2c175d71
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/179281
Reviewed-by: Niels Moller <nisse@webrtc.org>
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Commit-Queue: Mirta Dvornicic <mirtad@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31730}
This commit is contained in:
Mirta Dvornicic
2020-07-14 15:29:23 +02:00
committed by Commit Bot
parent c6801d4522
commit 97910da4e1
1 changed files with 51 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
video/video_stream_encoder_unittest.cc
View File

@ -707,6 +707,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
if (payload_name == "VP9") {
VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings();
vp9_settings.numberOfSpatialLayers = num_spatial_layers;
vp9_settings.automaticResizeOn = num_spatial_layers <= 1;
video_encoder_config.encoder_specific_settings =
new rtc::RefCountedObject<
VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings);
@ -943,12 +944,10 @@ class VideoStreamEncoderTest : public ::testing::Test {
encoded_image_callback_->OnEncodedImage(image, nullptr, nullptr);
}
void InjectEncodedImage(const EncodedImage& image,
const CodecSpecificInfo* codec_specific_info,
const RTPFragmentationHeader* fragmentation) {
void SetEncodedImageData(
rtc::scoped_refptr<EncodedImageBufferInterface> encoded_image_data) {
MutexLock lock(&local_mutex_);
encoded_image_callback_->OnEncodedImage(image, codec_specific_info,
fragmentation);
encoded_image_data_ = encoded_image_data;
}
void ExpectNullFrame() {
@ -1005,6 +1004,27 @@ class VideoStreamEncoderTest : public ::testing::Test {
return result;
}
std::unique_ptr<RTPFragmentationHeader> EncodeHook(
EncodedImage* encoded_image,
CodecSpecificInfo* codec_specific) override {
{
MutexLock lock(&mutex_);
codec_specific->codecType = config_.codecType;
}
MutexLock lock(&local_mutex_);
if (encoded_image_data_) {
encoded_image->SetEncodedData(encoded_image_data_);
if (codec_specific->codecType == kVideoCodecH264) {
auto fragmentation = std::make_unique<RTPFragmentationHeader>();
fragmentation->VerifyAndAllocateFragmentationHeader(1);
fragmentation->fragmentationOffset[0] = 4;
fragmentation->fragmentationLength[0] = encoded_image->size() - 4;
return fragmentation;
}
}
return nullptr;
}
int32_t InitEncode(const VideoCodec* config,
const Settings& settings) override {
int res = FakeEncoder::InitEncode(config, settings);
@ -1073,6 +1093,8 @@ class VideoStreamEncoderTest : public ::testing::Test {
bool quality_scaling_ RTC_GUARDED_BY(local_mutex_) = true;
int requested_resolution_alignment_ RTC_GUARDED_BY(local_mutex_) = 1;
bool is_hardware_accelerated_ RTC_GUARDED_BY(local_mutex_) = false;
rtc::scoped_refptr<EncodedImageBufferInterface> encoded_image_data_
RTC_GUARDED_BY(local_mutex_);
std::unique_ptr<Vp8FrameBufferController> frame_buffer_controller_
RTC_GUARDED_BY(local_mutex_);
absl::optional<bool>
@ -5404,23 +5426,22 @@ TEST_F(VideoStreamEncoderTest, AdjustsTimestampInternalSource) {
}
TEST_F(VideoStreamEncoderTest, DoesNotRewriteH264BitstreamWithOptimalSps) {
// Configure internal source factory and setup test again.
encoder_factory_.SetHasInternalSource(true);
// SPS contains VUI with restrictions on the maximum number of reordered
// pictures, there is no need to rewrite the bitstream to enable faster
// decoding.
ResetEncoder("H264", 1, 1, 1, false);
EncodedImage image(optimal_sps, sizeof(optimal_sps), sizeof(optimal_sps));
image._frameType = VideoFrameType::kVideoFrameKey;
video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
DataRate::BitsPerSec(kTargetBitrateBps),
DataRate::BitsPerSec(kTargetBitrateBps),
DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
video_stream_encoder_->WaitUntilTaskQueueIsIdle();
CodecSpecificInfo codec_specific_info;
codec_specific_info.codecType = kVideoCodecH264;
fake_encoder_.SetEncodedImageData(
EncodedImageBuffer::Create(optimal_sps, sizeof(optimal_sps)));
RTPFragmentationHeader fragmentation;
fragmentation.VerifyAndAllocateFragmentationHeader(1);
fragmentation.fragmentationOffset[0] = 4;
fragmentation.fragmentationLength[0] = sizeof(optimal_sps) - 4;
fake_encoder_.InjectEncodedImage(image, &codec_specific_info, &fragmentation);
EXPECT_TRUE(sink_.WaitForFrame(kDefaultTimeoutMs));
video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
WaitForEncodedFrame(1);
EXPECT_THAT(sink_.GetLastEncodedImageData(),
testing::ElementsAreArray(optimal_sps));
@ -5433,27 +5454,25 @@ TEST_F(VideoStreamEncoderTest, DoesNotRewriteH264BitstreamWithOptimalSps) {
}
TEST_F(VideoStreamEncoderTest, RewritesH264BitstreamWithNonOptimalSps) {
// SPS does not contain VUI, the bitstream is will be rewritten with added
// VUI with restrictions on the maximum number of reordered pictures to
// enable faster decoding.
uint8_t original_sps[] = {0, 0, 0, 1, H264::NaluType::kSps,
0x00, 0x00, 0x03, 0x03, 0xF4,
0x05, 0x03, 0xC7, 0xC0};
// Configure internal source factory and setup test again.
encoder_factory_.SetHasInternalSource(true);
ResetEncoder("H264", 1, 1, 1, false);
EncodedImage image(original_sps, sizeof(original_sps), sizeof(original_sps));
image._frameType = VideoFrameType::kVideoFrameKey;
video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
DataRate::BitsPerSec(kTargetBitrateBps),
DataRate::BitsPerSec(kTargetBitrateBps),
DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
video_stream_encoder_->WaitUntilTaskQueueIsIdle();
CodecSpecificInfo codec_specific_info;
codec_specific_info.codecType = kVideoCodecH264;
fake_encoder_.SetEncodedImageData(
EncodedImageBuffer::Create(original_sps, sizeof(original_sps)));
RTPFragmentationHeader fragmentation;
fragmentation.VerifyAndAllocateFragmentationHeader(1);
fragmentation.fragmentationOffset[0] = 4;
fragmentation.fragmentationLength[0] = sizeof(original_sps) - 4;
fake_encoder_.InjectEncodedImage(image, &codec_specific_info, &fragmentation);
EXPECT_TRUE(sink_.WaitForFrame(kDefaultTimeoutMs));
video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
WaitForEncodedFrame(1);
EXPECT_THAT(sink_.GetLastEncodedImageData(),
testing::ElementsAreArray(optimal_sps));