mirror of
https://github.com/mollyim/webrtc.git
synced 2025-05-20 00:57:49 +01:00
82fad3d513
As the rate allocation has been moved into entirely into SimulcastRateAllocator, and the listeners are thus no longer needed, this class doesn't fill any other purpose than to determine if ScreenshareLayers or TemporalLayers should be created for a given simulcast stream. This can however be done just from looking at the VideoCodec instance, so changing this into a static factory method. Due to dependencies from upstream projects, keep the class name and field in VideoCodec around for now. Bug: webrtc:9012 Change-Id: I028fe6b2a19e0d16b35956cc2df01dcf5bfa7979 Reviewed-on: https://webrtc-review.googlesource.com/63264 Commit-Queue: Erik Språng <sprang@webrtc.org> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Reviewed-by: Stefan Holmer <stefan@webrtc.org> Cr-Commit-Position: refs/heads/master@{#22529}
428 lines
18 KiB
C++
428 lines
18 KiB
C++
/*
|
|
* Copyright (c) 2012 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 <stdio.h>
|
|
|
|
#include <memory>
|
|
|
|
#include "api/optional.h"
|
|
#include "api/video/i420_buffer.h"
|
|
#include "common_video/libyuv/include/webrtc_libyuv.h"
|
|
#include "modules/video_coding/codecs/test/video_codec_unittest.h"
|
|
#include "modules/video_coding/codecs/vp8/include/vp8.h"
|
|
#include "modules/video_coding/codecs/vp8/temporal_layers.h"
|
|
#include "modules/video_coding/utility/vp8_header_parser.h"
|
|
#include "test/frame_utils.h"
|
|
#include "test/gtest.h"
|
|
#include "test/testsupport/fileutils.h"
|
|
#include "test/video_codec_settings.h"
|
|
|
|
namespace webrtc {
|
|
|
|
namespace {
|
|
constexpr uint32_t kInitialTimestampRtp = 123;
|
|
constexpr int64_t kTestNtpTimeMs = 456;
|
|
constexpr int64_t kInitialTimestampMs = 789;
|
|
constexpr uint32_t kTimestampIncrement = 3000;
|
|
constexpr int kNumCores = 1;
|
|
constexpr size_t kMaxPayloadSize = 1440;
|
|
constexpr int kDefaultMinPixelsPerFrame = 320 * 180;
|
|
constexpr int kWidth = 172;
|
|
constexpr int kHeight = 144;
|
|
|
|
void Calc16ByteAlignedStride(int width, int* stride_y, int* stride_uv) {
|
|
*stride_y = 16 * ((width + 15) / 16);
|
|
*stride_uv = 16 * ((width + 31) / 32);
|
|
}
|
|
} // namespace
|
|
|
|
class TestVp8Impl : public VideoCodecUnitTest {
|
|
protected:
|
|
std::unique_ptr<VideoEncoder> CreateEncoder() override {
|
|
return VP8Encoder::Create();
|
|
}
|
|
|
|
std::unique_ptr<VideoDecoder> CreateDecoder() override {
|
|
return VP8Decoder::Create();
|
|
}
|
|
|
|
VideoCodec codec_settings() override {
|
|
VideoCodec codec_settings;
|
|
webrtc::test::CodecSettings(kVideoCodecVP8, &codec_settings);
|
|
codec_settings.VP8()->denoisingOn = true;
|
|
codec_settings.VP8()->frameDroppingOn = false;
|
|
codec_settings.VP8()->automaticResizeOn = false;
|
|
codec_settings.VP8()->complexity = kComplexityNormal;
|
|
return codec_settings;
|
|
}
|
|
|
|
void SetupInputFrame() {
|
|
// Using a QCIF image (aligned stride (u,v planes) > width).
|
|
// Processing only one frame.
|
|
FILE* file = fopen(test::ResourcePath("paris_qcif", "yuv").c_str(), "rb");
|
|
ASSERT_TRUE(file != nullptr);
|
|
rtc::scoped_refptr<I420BufferInterface> compact_buffer(
|
|
test::ReadI420Buffer(kWidth, kHeight, file));
|
|
ASSERT_TRUE(compact_buffer);
|
|
|
|
// Setting aligned stride values.
|
|
int stride_uv;
|
|
int stride_y;
|
|
Calc16ByteAlignedStride(kWidth, &stride_y, &stride_uv);
|
|
EXPECT_EQ(stride_y, 176);
|
|
EXPECT_EQ(stride_uv, 96);
|
|
rtc::scoped_refptr<I420Buffer> stride_buffer(
|
|
I420Buffer::Create(kWidth, kHeight, stride_y, stride_uv, stride_uv));
|
|
|
|
// No scaling in our case, just a copy, to add stride to the image.
|
|
stride_buffer->ScaleFrom(*compact_buffer);
|
|
|
|
input_frame_.reset(new VideoFrame(stride_buffer, kInitialTimestampRtp,
|
|
kInitialTimestampMs, kVideoRotation_0));
|
|
fclose(file);
|
|
}
|
|
|
|
void EncodeAndWaitForFrame(EncodedImage* encoded_frame,
|
|
CodecSpecificInfo* codec_specific_info) {
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
|
|
encoder_->Encode(*input_frame_, nullptr, nullptr));
|
|
ASSERT_TRUE(WaitForEncodedFrame(encoded_frame, codec_specific_info));
|
|
VerifyQpParser(*encoded_frame);
|
|
EXPECT_STREQ("libvpx", codec_specific_info->codec_name);
|
|
EXPECT_EQ(kVideoCodecVP8, codec_specific_info->codecType);
|
|
EXPECT_EQ(0u, codec_specific_info->codecSpecific.VP8.simulcastIdx);
|
|
}
|
|
|
|
void EncodeAndExpectFrameWith(int16_t picture_id,
|
|
int tl0_pic_idx,
|
|
uint8_t temporal_idx) {
|
|
EncodedImage encoded_frame;
|
|
CodecSpecificInfo codec_specific_info;
|
|
EncodeAndWaitForFrame(&encoded_frame, &codec_specific_info);
|
|
EXPECT_EQ(picture_id % (1 << 15),
|
|
codec_specific_info.codecSpecific.VP8.pictureId);
|
|
EXPECT_EQ(tl0_pic_idx % (1 << 8),
|
|
codec_specific_info.codecSpecific.VP8.tl0PicIdx);
|
|
EXPECT_EQ(temporal_idx, codec_specific_info.codecSpecific.VP8.temporalIdx);
|
|
}
|
|
|
|
void VerifyQpParser(const EncodedImage& encoded_frame) const {
|
|
int qp;
|
|
EXPECT_GT(encoded_frame._length, 0u);
|
|
ASSERT_TRUE(vp8::GetQp(encoded_frame._buffer, encoded_frame._length, &qp));
|
|
EXPECT_EQ(encoded_frame.qp_, qp) << "Encoder QP != parsed bitstream QP.";
|
|
}
|
|
};
|
|
|
|
TEST_F(TestVp8Impl, SetRateAllocation) {
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, encoder_->Release());
|
|
|
|
const int kBitrateBps = 300000;
|
|
BitrateAllocation bitrate_allocation;
|
|
bitrate_allocation.SetBitrate(0, 0, kBitrateBps);
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_UNINITIALIZED,
|
|
encoder_->SetRateAllocation(bitrate_allocation,
|
|
codec_settings_.maxFramerate));
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
|
|
encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
|
|
encoder_->SetRateAllocation(bitrate_allocation,
|
|
codec_settings_.maxFramerate));
|
|
}
|
|
|
|
TEST_F(TestVp8Impl, EncodeFrameAndRelease) {
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, encoder_->Release());
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
|
|
encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
|
|
|
|
EncodedImage encoded_frame;
|
|
CodecSpecificInfo codec_specific_info;
|
|
EncodeAndWaitForFrame(&encoded_frame, &codec_specific_info);
|
|
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, encoder_->Release());
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_UNINITIALIZED,
|
|
encoder_->Encode(*input_frame_, nullptr, nullptr));
|
|
}
|
|
|
|
TEST_F(TestVp8Impl, InitDecode) {
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Release());
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
|
|
decoder_->InitDecode(&codec_settings_, kNumCores));
|
|
}
|
|
|
|
TEST_F(TestVp8Impl, OnEncodedImageReportsInfo) {
|
|
SetupInputFrame();
|
|
EncodedImage encoded_frame;
|
|
CodecSpecificInfo codec_specific_info;
|
|
EncodeAndWaitForFrame(&encoded_frame, &codec_specific_info);
|
|
|
|
EXPECT_EQ(kInitialTimestampRtp, encoded_frame._timeStamp);
|
|
EXPECT_EQ(kInitialTimestampMs, encoded_frame.capture_time_ms_);
|
|
EXPECT_EQ(kWidth, static_cast<int>(encoded_frame._encodedWidth));
|
|
EXPECT_EQ(kHeight, static_cast<int>(encoded_frame._encodedHeight));
|
|
}
|
|
|
|
// We only test the encoder here, since the decoded frame rotation is set based
|
|
// on the CVO RTP header extension in VCMDecodedFrameCallback::Decoded.
|
|
// TODO(brandtr): Consider passing through the rotation flag through the decoder
|
|
// in the same way as done in the encoder.
|
|
TEST_F(TestVp8Impl, EncodedRotationEqualsInputRotation) {
|
|
input_frame_->set_rotation(kVideoRotation_0);
|
|
|
|
EncodedImage encoded_frame;
|
|
CodecSpecificInfo codec_specific_info;
|
|
EncodeAndWaitForFrame(&encoded_frame, &codec_specific_info);
|
|
EXPECT_EQ(kVideoRotation_0, encoded_frame.rotation_);
|
|
|
|
input_frame_->set_rotation(kVideoRotation_90);
|
|
EncodeAndWaitForFrame(&encoded_frame, &codec_specific_info);
|
|
EXPECT_EQ(kVideoRotation_90, encoded_frame.rotation_);
|
|
}
|
|
|
|
TEST_F(TestVp8Impl, DecodedQpEqualsEncodedQp) {
|
|
EncodedImage encoded_frame;
|
|
CodecSpecificInfo codec_specific_info;
|
|
EncodeAndWaitForFrame(&encoded_frame, &codec_specific_info);
|
|
|
|
// First frame should be a key frame.
|
|
encoded_frame._frameType = kVideoFrameKey;
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
|
|
decoder_->Decode(encoded_frame, false, nullptr));
|
|
std::unique_ptr<VideoFrame> decoded_frame;
|
|
rtc::Optional<uint8_t> decoded_qp;
|
|
ASSERT_TRUE(WaitForDecodedFrame(&decoded_frame, &decoded_qp));
|
|
ASSERT_TRUE(decoded_frame);
|
|
ASSERT_TRUE(decoded_qp);
|
|
EXPECT_GT(I420PSNR(input_frame_.get(), decoded_frame.get()), 36);
|
|
EXPECT_EQ(encoded_frame.qp_, *decoded_qp);
|
|
}
|
|
|
|
TEST_F(TestVp8Impl, ChecksSimulcastSettings) {
|
|
codec_settings_.numberOfSimulcastStreams = 2;
|
|
// Reslutions are not scaled by 2, temporal layers do not match.
|
|
codec_settings_.simulcastStream[0] = {kWidth, kHeight, 2, 4000,
|
|
3000, 2000, 80};
|
|
codec_settings_.simulcastStream[1] = {kWidth, kHeight, 3, 4000,
|
|
3000, 2000, 80};
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERR_SIMULCAST_PARAMETERS_NOT_SUPPORTED,
|
|
encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
|
|
codec_settings_.numberOfSimulcastStreams = 3;
|
|
// Reslutions are not scaled by 2.
|
|
codec_settings_.simulcastStream[0] = {kWidth / 2, kHeight / 2, 1, 4000,
|
|
3000, 2000, 80};
|
|
codec_settings_.simulcastStream[1] = {kWidth / 2, kHeight / 2, 1, 4000,
|
|
3000, 2000, 80};
|
|
codec_settings_.simulcastStream[2] = {kWidth, kHeight, 1, 4000,
|
|
3000, 2000, 80};
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERR_SIMULCAST_PARAMETERS_NOT_SUPPORTED,
|
|
encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
|
|
// Reslutions are not scaled by 2.
|
|
codec_settings_.simulcastStream[0] = {kWidth, kHeight, 1, 4000,
|
|
3000, 2000, 80};
|
|
codec_settings_.simulcastStream[1] = {kWidth, kHeight, 1, 4000,
|
|
3000, 2000, 80};
|
|
codec_settings_.simulcastStream[2] = {kWidth, kHeight, 1, 4000,
|
|
3000, 2000, 80};
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERR_SIMULCAST_PARAMETERS_NOT_SUPPORTED,
|
|
encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
|
|
// Temporal layers do not match.
|
|
codec_settings_.simulcastStream[0] = {kWidth / 4, kHeight / 4, 1, 4000,
|
|
3000, 2000, 80};
|
|
codec_settings_.simulcastStream[1] = {kWidth / 2, kHeight / 2, 2, 4000,
|
|
3000, 2000, 80};
|
|
codec_settings_.simulcastStream[2] = {kWidth, kHeight, 3, 4000,
|
|
3000, 2000, 80};
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERR_SIMULCAST_PARAMETERS_NOT_SUPPORTED,
|
|
encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
|
|
// Resolutions do not match codec config.
|
|
codec_settings_.simulcastStream[0] = {
|
|
kWidth / 4 + 1, kHeight / 4 + 1, 1, 4000, 3000, 2000, 80};
|
|
codec_settings_.simulcastStream[1] = {
|
|
kWidth / 2 + 2, kHeight / 2 + 2, 1, 4000, 3000, 2000, 80};
|
|
codec_settings_.simulcastStream[2] = {kWidth + 4, kHeight + 4, 1, 4000,
|
|
3000, 2000, 80};
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERR_SIMULCAST_PARAMETERS_NOT_SUPPORTED,
|
|
encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
|
|
// Everything fine: scaling by 2, top resolution matches video, temporal
|
|
// settings are the same for all layers.
|
|
codec_settings_.simulcastStream[0] = {kWidth / 4, kHeight / 4, 1, 4000,
|
|
3000, 2000, 80};
|
|
codec_settings_.simulcastStream[1] = {kWidth / 2, kHeight / 2, 1, 4000,
|
|
3000, 2000, 80};
|
|
codec_settings_.simulcastStream[2] = {kWidth, kHeight, 1, 4000,
|
|
3000, 2000, 80};
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
|
|
encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
|
|
}
|
|
|
|
#if defined(WEBRTC_ANDROID)
|
|
#define MAYBE_AlignedStrideEncodeDecode DISABLED_AlignedStrideEncodeDecode
|
|
#else
|
|
#define MAYBE_AlignedStrideEncodeDecode AlignedStrideEncodeDecode
|
|
#endif
|
|
TEST_F(TestVp8Impl, MAYBE_AlignedStrideEncodeDecode) {
|
|
SetupInputFrame();
|
|
EncodedImage encoded_frame;
|
|
CodecSpecificInfo codec_specific_info;
|
|
EncodeAndWaitForFrame(&encoded_frame, &codec_specific_info);
|
|
|
|
// First frame should be a key frame.
|
|
encoded_frame._frameType = kVideoFrameKey;
|
|
encoded_frame.ntp_time_ms_ = kTestNtpTimeMs;
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
|
|
decoder_->Decode(encoded_frame, false, nullptr));
|
|
|
|
std::unique_ptr<VideoFrame> decoded_frame;
|
|
rtc::Optional<uint8_t> decoded_qp;
|
|
ASSERT_TRUE(WaitForDecodedFrame(&decoded_frame, &decoded_qp));
|
|
ASSERT_TRUE(decoded_frame);
|
|
// Compute PSNR on all planes (faster than SSIM).
|
|
EXPECT_GT(I420PSNR(input_frame_.get(), decoded_frame.get()), 36);
|
|
EXPECT_EQ(kInitialTimestampRtp, decoded_frame->timestamp());
|
|
EXPECT_EQ(kTestNtpTimeMs, decoded_frame->ntp_time_ms());
|
|
}
|
|
|
|
#if defined(WEBRTC_ANDROID)
|
|
#define MAYBE_DecodeWithACompleteKeyFrame DISABLED_DecodeWithACompleteKeyFrame
|
|
#else
|
|
#define MAYBE_DecodeWithACompleteKeyFrame DecodeWithACompleteKeyFrame
|
|
#endif
|
|
TEST_F(TestVp8Impl, MAYBE_DecodeWithACompleteKeyFrame) {
|
|
EncodedImage encoded_frame;
|
|
CodecSpecificInfo codec_specific_info;
|
|
EncodeAndWaitForFrame(&encoded_frame, &codec_specific_info);
|
|
|
|
// Setting complete to false -> should return an error.
|
|
encoded_frame._completeFrame = false;
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERROR,
|
|
decoder_->Decode(encoded_frame, false, nullptr));
|
|
// Setting complete back to true. Forcing a delta frame.
|
|
encoded_frame._frameType = kVideoFrameDelta;
|
|
encoded_frame._completeFrame = true;
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERROR,
|
|
decoder_->Decode(encoded_frame, false, nullptr));
|
|
// Now setting a key frame.
|
|
encoded_frame._frameType = kVideoFrameKey;
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
|
|
decoder_->Decode(encoded_frame, false, nullptr));
|
|
std::unique_ptr<VideoFrame> decoded_frame;
|
|
rtc::Optional<uint8_t> decoded_qp;
|
|
ASSERT_TRUE(WaitForDecodedFrame(&decoded_frame, &decoded_qp));
|
|
ASSERT_TRUE(decoded_frame);
|
|
EXPECT_GT(I420PSNR(input_frame_.get(), decoded_frame.get()), 36);
|
|
}
|
|
|
|
TEST_F(TestVp8Impl, EncoderWith2TemporalLayersRetainsRtpStateAfterRelease) {
|
|
codec_settings_.VP8()->numberOfTemporalLayers = 2;
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
|
|
encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
|
|
|
|
// Temporal layer 0.
|
|
EncodedImage encoded_frame;
|
|
CodecSpecificInfo codec_specific_info;
|
|
EncodeAndWaitForFrame(&encoded_frame, &codec_specific_info);
|
|
|
|
EXPECT_EQ(0, codec_specific_info.codecSpecific.VP8.temporalIdx);
|
|
const int16_t picture_id = codec_specific_info.codecSpecific.VP8.pictureId;
|
|
const int tl0_pic_idx = codec_specific_info.codecSpecific.VP8.tl0PicIdx;
|
|
// Temporal layer 1.
|
|
input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
|
|
|
|
EncodeAndExpectFrameWith(picture_id + 1, tl0_pic_idx + 0, 1);
|
|
// Temporal layer 0.
|
|
input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
|
|
EncodeAndExpectFrameWith(picture_id + 2, tl0_pic_idx + 1, 0);
|
|
// Temporal layer 1.
|
|
input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
|
|
EncodeAndExpectFrameWith(picture_id + 3, tl0_pic_idx + 1, 1);
|
|
|
|
// Reinit.
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, encoder_->Release());
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
|
|
encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
|
|
|
|
// Temporal layer 0.
|
|
input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
|
|
EncodeAndExpectFrameWith(picture_id + 4, tl0_pic_idx + 2, 0);
|
|
// Temporal layer 1.
|
|
input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
|
|
EncodeAndExpectFrameWith(picture_id + 5, tl0_pic_idx + 2, 1);
|
|
// Temporal layer 0.
|
|
input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
|
|
EncodeAndExpectFrameWith(picture_id + 6, tl0_pic_idx + 3, 0);
|
|
// Temporal layer 1.
|
|
input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
|
|
EncodeAndExpectFrameWith(picture_id + 7, tl0_pic_idx + 3, 1);
|
|
}
|
|
|
|
TEST_F(TestVp8Impl, EncoderWith3TemporalLayersRetainsRtpStateAfterRelease) {
|
|
codec_settings_.VP8()->numberOfTemporalLayers = 3;
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
|
|
encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
|
|
|
|
EncodedImage encoded_frame;
|
|
CodecSpecificInfo codec_specific_info;
|
|
EncodeAndWaitForFrame(&encoded_frame, &codec_specific_info);
|
|
|
|
// Temporal layer 0.
|
|
EXPECT_EQ(0, codec_specific_info.codecSpecific.VP8.temporalIdx);
|
|
const int16_t picture_id = codec_specific_info.codecSpecific.VP8.pictureId;
|
|
const int tl0_pic_idx = codec_specific_info.codecSpecific.VP8.tl0PicIdx;
|
|
// Temporal layer 2.
|
|
input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
|
|
EncodeAndExpectFrameWith(picture_id + 1, tl0_pic_idx + 0, 2);
|
|
// Temporal layer 1.
|
|
input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
|
|
EncodeAndExpectFrameWith(picture_id + 2, tl0_pic_idx + 0, 1);
|
|
// Temporal layer 2.
|
|
input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
|
|
EncodeAndExpectFrameWith(picture_id + 3, tl0_pic_idx + 0, 2);
|
|
|
|
// Reinit.
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, encoder_->Release());
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
|
|
encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
|
|
|
|
// Temporal layer 0.
|
|
input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
|
|
EncodeAndExpectFrameWith(picture_id + 4, tl0_pic_idx + 1, 0);
|
|
// Temporal layer 2.
|
|
input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
|
|
EncodeAndExpectFrameWith(picture_id + 5, tl0_pic_idx + 1, 2);
|
|
// Temporal layer 1.
|
|
input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
|
|
EncodeAndExpectFrameWith(picture_id + 6, tl0_pic_idx + 1, 1);
|
|
// Temporal layer 2.
|
|
input_frame_->set_timestamp(input_frame_->timestamp() + kTimestampIncrement);
|
|
EncodeAndExpectFrameWith(picture_id + 7, tl0_pic_idx + 1, 2);
|
|
}
|
|
|
|
TEST_F(TestVp8Impl, ScalingDisabledIfAutomaticResizeOff) {
|
|
codec_settings_.VP8()->frameDroppingOn = true;
|
|
codec_settings_.VP8()->automaticResizeOn = false;
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
|
|
encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
|
|
|
|
VideoEncoder::ScalingSettings settings = encoder_->GetScalingSettings();
|
|
EXPECT_FALSE(settings.thresholds.has_value());
|
|
}
|
|
|
|
TEST_F(TestVp8Impl, ScalingEnabledIfAutomaticResizeOn) {
|
|
codec_settings_.VP8()->frameDroppingOn = true;
|
|
codec_settings_.VP8()->automaticResizeOn = true;
|
|
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
|
|
encoder_->InitEncode(&codec_settings_, kNumCores, kMaxPayloadSize));
|
|
|
|
VideoEncoder::ScalingSettings settings = encoder_->GetScalingSettings();
|
|
EXPECT_TRUE(settings.thresholds.has_value());
|
|
EXPECT_EQ(kDefaultMinPixelsPerFrame, settings.min_pixels_per_frame);
|
|
}
|
|
|
|
} // namespace webrtc
|