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

Update more VideoEncoder implementations to drop CodecSpecificInfo input

Browse Source 
Followup to https://webrtc-review.googlesource.com/c/src/+/125900.

Bug: webrtc:10379
Change-Id: If81c50c862bbcfd65a3cf7000c8327ebafe519c3
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/126002
Commit-Queue: Niels Moller <nisse@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27016}
This commit is contained in:
Niels Möller 2019-03-07 12:40:01 +01:00 committed by Commit Bot
parent 6318f13295
commit b859b326ba
21 changed files with 32 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
api/test/mock_video_encoder.h
View File

@ -37,9 +37,8 @@ class MockVideoEncoder : public VideoEncoder {
int32_t(const VideoCodec* codecSettings,
int32_t numberOfCores,
size_t maxPayloadSize));
MOCK_METHOD3(Encode,
MOCK_METHOD2(Encode,
int32_t(const VideoFrame& inputImage,
const CodecSpecificInfo* codecSpecificInfo,
const std::vector<VideoFrameType>* frame_types));
MOCK_METHOD1(RegisterEncodeCompleteCallback,
int32_t(EncodedImageCallback* callback));

1
api/video_codecs/test/video_encoder_software_fallback_wrapper_unittest.cc
View File

@ -94,7 +94,6 @@ class VideoEncoderSoftwareFallbackWrapperTest : public ::testing::Test {
return init_encode_return_code_;
}
int32_t Encode(const VideoFrame& frame,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) override {
++encode_count_;
if (encode_complete_callback_ &&

3
media/engine/encoder_simulcast_proxy_unittest.cc
View File

@ -44,10 +44,9 @@ class MockEncoder : public VideoEncoder {
MOCK_METHOD0(Release, int32_t());
MOCK_METHOD3(
MOCK_METHOD2(
Encode,
int32_t(const VideoFrame& inputImage,
const CodecSpecificInfo* codecSpecificInfo,
const std::vector<VideoFrameType>* frame_types) /* override */);
MOCK_CONST_METHOD0(GetEncoderInfo, VideoEncoder::EncoderInfo(void));

1
media/engine/fake_webrtc_video_engine.cc
View File

@ -150,7 +150,6 @@ int32_t FakeWebRtcVideoEncoder::InitEncode(
int32_t FakeWebRtcVideoEncoder::Encode(
const webrtc::VideoFrame& inputImage,
const webrtc::CodecSpecificInfo* codecSpecificInfo,
const std::vector<webrtc::VideoFrameType>* frame_types) {
rtc::CritScope lock(&crit_);
++num_frames_encoded_;

1
media/engine/fake_webrtc_video_engine.h
View File

@ -90,7 +90,6 @@ class FakeWebRtcVideoEncoder : public webrtc::VideoEncoder {
size_t maxPayloadSize) override;
int32_t Encode(
const webrtc::VideoFrame& inputImage,
const webrtc::CodecSpecificInfo* codecSpecificInfo,
const std::vector<webrtc::VideoFrameType>* frame_types) override;
int32_t RegisterEncodeCompleteCallback(
webrtc::EncodedImageCallback* callback) override;

31
media/engine/simulcast_encoder_adapter_unittest.cc
View File

@ -194,10 +194,9 @@ class MockVideoEncoder : public VideoEncoder {
return init_encode_return_value_;
}
MOCK_METHOD3(
MOCK_METHOD2(
Encode,
int32_t(const VideoFrame& inputImage,
const CodecSpecificInfo* codecSpecificInfo,
const std::vector<VideoFrameType>* frame_types) /* override */);
int32_t RegisterEncodeCompleteCallback(
@ -567,11 +566,11 @@ TEST_F(TestSimulcastEncoderAdapterFake, ReusesEncodersInOrder) {
std::vector<MockVideoEncoder*> original_encoders =
helper_->factory()->encoders();
ASSERT_EQ(3u, original_encoders.size());
EXPECT_CALL(*original_encoders[0], Encode(_, _, _))
EXPECT_CALL(*original_encoders[0], Encode(_, _))
.WillOnce(Return(WEBRTC_VIDEO_CODEC_OK));
EXPECT_CALL(*original_encoders[1], Encode(_, _, _))
EXPECT_CALL(*original_encoders[1], Encode(_, _))
.WillOnce(Return(WEBRTC_VIDEO_CODEC_OK));
EXPECT_CALL(*original_encoders[2], Encode(_, _, _))
EXPECT_CALL(*original_encoders[2], Encode(_, _))
.WillOnce(Return(WEBRTC_VIDEO_CODEC_OK));
frame_types.resize(3, kVideoFrameKey);
EXPECT_EQ(0, adapter_->Encode(input_frame, &frame_types));
@ -593,10 +592,10 @@ TEST_F(TestSimulcastEncoderAdapterFake, ReusesEncodersInOrder) {
std::vector<MockVideoEncoder*> new_encoders = helper_->factory()->encoders();
ASSERT_EQ(2u, new_encoders.size());
ASSERT_EQ(original_encoders[0], new_encoders[0]);
EXPECT_CALL(*original_encoders[0], Encode(_, _, _))
EXPECT_CALL(*original_encoders[0], Encode(_, _))
.WillOnce(Return(WEBRTC_VIDEO_CODEC_OK));
ASSERT_EQ(original_encoders[1], new_encoders[1]);
EXPECT_CALL(*original_encoders[1], Encode(_, _, _))
EXPECT_CALL(*original_encoders[1], Encode(_, _))
.WillOnce(Return(WEBRTC_VIDEO_CODEC_OK));
frame_types.resize(2, kVideoFrameKey);
EXPECT_EQ(0, adapter_->Encode(input_frame, &frame_types));
@ -616,7 +615,7 @@ TEST_F(TestSimulcastEncoderAdapterFake, ReusesEncodersInOrder) {
new_encoders = helper_->factory()->encoders();
ASSERT_EQ(1u, new_encoders.size());
ASSERT_EQ(original_encoders[0], new_encoders[0]);
EXPECT_CALL(*original_encoders[0], Encode(_, _, _))
EXPECT_CALL(*original_encoders[0], Encode(_, _))
.WillOnce(Return(WEBRTC_VIDEO_CODEC_OK));
frame_types.resize(1, kVideoFrameKey);
EXPECT_EQ(0, adapter_->Encode(input_frame, &frame_types));
@ -635,12 +634,12 @@ TEST_F(TestSimulcastEncoderAdapterFake, ReusesEncodersInOrder) {
ASSERT_EQ(3u, new_encoders.size());
// The first encoder is reused.
ASSERT_EQ(original_encoders[0], new_encoders[0]);
EXPECT_CALL(*original_encoders[0], Encode(_, _, _))
EXPECT_CALL(*original_encoders[0], Encode(_, _))
.WillOnce(Return(WEBRTC_VIDEO_CODEC_OK));
// The second and third encoders are new.
EXPECT_CALL(*new_encoders[1], Encode(_, _, _))
EXPECT_CALL(*new_encoders[1], Encode(_, _))
.WillOnce(Return(WEBRTC_VIDEO_CODEC_OK));
EXPECT_CALL(*new_encoders[2], Encode(_, _, _))
EXPECT_CALL(*new_encoders[2], Encode(_, _))
.WillOnce(Return(WEBRTC_VIDEO_CODEC_OK));
frame_types.resize(3, kVideoFrameKey);
EXPECT_EQ(0, adapter_->Encode(input_frame, &frame_types));
@ -889,7 +888,7 @@ TEST_F(TestSimulcastEncoderAdapterFake,
// Expect calls with the given video frame verbatim, since it's a texture
// frame and can't otherwise be modified/resized.
for (MockVideoEncoder* encoder : helper_->factory()->encoders())
EXPECT_CALL(*encoder, Encode(::testing::Ref(input_frame), _, _)).Times(1);
EXPECT_CALL(*encoder, Encode(::testing::Ref(input_frame), _)).Times(1);
std::vector<VideoFrameType> frame_types(3, kVideoFrameKey);
EXPECT_EQ(0, adapter_->Encode(input_frame, &frame_types));
}
@ -903,7 +902,7 @@ TEST_F(TestSimulcastEncoderAdapterFake, TestFailureReturnCodesFromEncodeCalls) {
adapter_->RegisterEncodeCompleteCallback(this);
ASSERT_EQ(3u, helper_->factory()->encoders().size());
// Tell the 2nd encoder to request software fallback.
EXPECT_CALL(*helper_->factory()->encoders()[1], Encode(_, _, _))
EXPECT_CALL(*helper_->factory()->encoders()[1], Encode(_, _))
.WillOnce(Return(WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE));
// Send a fake frame and assert the return is software fallback.
@ -1026,10 +1025,10 @@ TEST_F(TestSimulcastEncoderAdapterFake, ActivatesCorrectStreamsInInitEncode) {
helper_->factory()->encoders();
ASSERT_EQ(3u, original_encoders.size());
// Only first encoder will be active and called.
EXPECT_CALL(*original_encoders[0], Encode(_, _, _))
EXPECT_CALL(*original_encoders[0], Encode(_, _))
.WillOnce(Return(WEBRTC_VIDEO_CODEC_OK));
EXPECT_CALL(*original_encoders[1], Encode(_, _, _)).Times(0);
EXPECT_CALL(*original_encoders[2], Encode(_, _, _)).Times(0);
EXPECT_CALL(*original_encoders[1], Encode(_, _)).Times(0);
EXPECT_CALL(*original_encoders[2], Encode(_, _)).Times(0);
std::vector<VideoFrameType> frame_types;
frame_types.resize(3, kVideoFrameKey);

1
modules/video_coding/codecs/h264/h264_encoder_impl.cc
View File

@ -383,7 +383,6 @@ int32_t H264EncoderImpl::SetRateAllocation(
int32_t H264EncoderImpl::Encode(
const VideoFrame& input_frame,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) {
if (encoders_.empty()) {
ReportError();

1
modules/video_coding/codecs/h264/h264_encoder_impl.h
View File

@ -67,7 +67,6 @@ class H264EncoderImpl : public H264Encoder {
// The result of encoding - an EncodedImage and RTPFragmentationHeader - are
// passed to the encode complete callback.
int32_t Encode(const VideoFrame& frame,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) override;
EncoderInfo GetEncoderInfo() const override;

8
modules/video_coding/codecs/test/videoprocessor_unittest.cc
View File

@ -105,13 +105,13 @@ TEST_F(VideoProcessorTest, ProcessFrames_FixedFramerate) {
.WillRepeatedly(Return(I420Buffer::Create(kWidth, kHeight)));
EXPECT_CALL(
encoder_mock_,
Encode(Property(&VideoFrame::timestamp, 1 * 90000 / kFramerateFps), _, _))
Encode(Property(&VideoFrame::timestamp, 1 * 90000 / kFramerateFps), _))
.Times(1);
q_.SendTask([this] { video_processor_->ProcessFrame(); });
EXPECT_CALL(
encoder_mock_,
Encode(Property(&VideoFrame::timestamp, 2 * 90000 / kFramerateFps), _, _))
Encode(Property(&VideoFrame::timestamp, 2 * 90000 / kFramerateFps), _))
.Times(1);
q_.SendTask([this] { video_processor_->ProcessFrame(); });
@ -131,7 +131,7 @@ TEST_F(VideoProcessorTest, ProcessFrames_VariableFramerate) {
EXPECT_CALL(frame_reader_mock_, ReadFrame())
.WillRepeatedly(Return(I420Buffer::Create(kWidth, kHeight)));
EXPECT_CALL(encoder_mock_,
Encode(Property(&VideoFrame::timestamp, kStartTimestamp), _, _))
Encode(Property(&VideoFrame::timestamp, kStartTimestamp), _))
.Times(1);
q_.SendTask([this] { video_processor_->ProcessFrame(); });
@ -145,7 +145,7 @@ TEST_F(VideoProcessorTest, ProcessFrames_VariableFramerate) {
EXPECT_CALL(encoder_mock_,
Encode(Property(&VideoFrame::timestamp,
kStartTimestamp + 90000 / kNewFramerateFps),
_, _))
_))
.Times(1);
q_.SendTask([this] { video_processor_->ProcessFrame(); });

1
modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
View File

@ -736,7 +736,6 @@ size_t LibvpxVp8Encoder::SteadyStateSize(int sid, int tid) {
}
int LibvpxVp8Encoder::Encode(const VideoFrame& frame,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) {
RTC_DCHECK_EQ(frame.width(), codec_.width);
RTC_DCHECK_EQ(frame.height(), codec_.height);

1
modules/video_coding/codecs/vp8/libvpx_vp8_encoder.h
View File

@ -46,7 +46,6 @@ class LibvpxVp8Encoder : public VideoEncoder {
size_t max_payload_size) override;
int Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) override;
int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;

2
modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
View File

@ -485,7 +485,7 @@ TEST_F(TestVp8Impl, KeepsTimestampOnReencode) {
.WillRepeatedly(Return(vpx_codec_err_t::VPX_CODEC_OK));
auto delta_frame = std::vector<VideoFrameType>{kVideoFrameDelta};
encoder.Encode(*NextInputFrame(), nullptr, &delta_frame);
encoder.Encode(*NextInputFrame(), &delta_frame);
}
TEST_F(TestVp8Impl, GetEncoderInfoFpsAllocationNoLayers) {

1
modules/video_coding/codecs/vp9/vp9_impl.cc
View File

@ -713,7 +713,6 @@ uint32_t VP9EncoderImpl::MaxIntraTarget(uint32_t optimal_buffer_size) {
}
int VP9EncoderImpl::Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) {
if (!inited_) {
return WEBRTC_VIDEO_CODEC_UNINITIALIZED;

1
modules/video_coding/codecs/vp9/vp9_impl.h
View File

@ -44,7 +44,6 @@ class VP9EncoderImpl : public VP9Encoder {
size_t max_payload_size) override;
int Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) override;
int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;

1
test/configurable_frame_size_encoder.cc
View File

@ -45,7 +45,6 @@ int32_t ConfigurableFrameSizeEncoder::InitEncode(
int32_t ConfigurableFrameSizeEncoder::Encode(
const VideoFrame& inputImage,
const CodecSpecificInfo* codecSpecificInfo,
const std::vector<VideoFrameType>* frame_types) {
EncodedImage encodedImage(buffer_.get(), current_frame_size_,
max_frame_size_);

1
test/configurable_frame_size_encoder.h
View File

@ -38,7 +38,6 @@ class ConfigurableFrameSizeEncoder : public VideoEncoder {
size_t max_payload_size) override;
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) override;
int32_t RegisterEncodeCompleteCallback(

21
test/fake_encoder.cc
View File

@ -81,7 +81,6 @@ int32_t FakeEncoder::InitEncode(const VideoCodec* config,
}
int32_t FakeEncoder::Encode(const VideoFrame& input_image,
const CodecSpecificInfo* /*codec_specific_info*/,
const std::vector<VideoFrameType>* frame_types) {
unsigned char max_framerate;
unsigned char num_simulcast_streams;
@ -355,13 +354,12 @@ void DelayedEncoder::SetDelay(int delay_ms) {
}
int32_t DelayedEncoder::Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
SleepMs(delay_ms_);
return FakeEncoder::Encode(input_image, codec_specific_info, frame_types);
return FakeEncoder::Encode(input_image, frame_types);
}
MultithreadedFakeH264Encoder::MultithreadedFakeH264Encoder(Clock* clock)
@ -389,32 +387,24 @@ class MultithreadedFakeH264Encoder::EncodeTask : public rtc::QueuedTask {
public:
EncodeTask(MultithreadedFakeH264Encoder* encoder,
const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types)
: encoder_(encoder),
input_image_(input_image),
codec_specific_info_(),
frame_types_(*frame_types) {
if (codec_specific_info)
codec_specific_info_ = *codec_specific_info;
}
frame_types_(*frame_types) {}
private:
bool Run() override {
encoder_->EncodeCallback(input_image_, &codec_specific_info_,
&frame_types_);
encoder_->EncodeCallback(input_image_, &frame_types_);
return true;
}
MultithreadedFakeH264Encoder* const encoder_;
VideoFrame input_image_;
CodecSpecificInfo codec_specific_info_;
std::vector<VideoFrameType> frame_types_;
};
int32_t MultithreadedFakeH264Encoder::Encode(
const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
@ -426,16 +416,15 @@ int32_t MultithreadedFakeH264Encoder::Encode(
}
queue->PostTask(std::unique_ptr<rtc::QueuedTask>(
new EncodeTask(this, input_image, codec_specific_info, frame_types)));
new EncodeTask(this, input_image, frame_types)));
return WEBRTC_VIDEO_CODEC_OK;
}
int32_t MultithreadedFakeH264Encoder::EncodeCallback(
const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) {
return FakeH264Encoder::Encode(input_image, codec_specific_info, frame_types);
return FakeH264Encoder::Encode(input_image, frame_types);
}
int32_t MultithreadedFakeH264Encoder::Release() {

4
test/fake_encoder.h
View File

@ -45,7 +45,6 @@ class FakeEncoder : public VideoEncoder {
int32_t number_of_cores,
size_t max_payload_size) override;
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) override;
int32_t RegisterEncodeCompleteCallback(
EncodedImageCallback* callback) override;
@ -125,7 +124,6 @@ class DelayedEncoder : public test::FakeEncoder {
void SetDelay(int delay_ms);
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) override;
private:
@ -147,11 +145,9 @@ class MultithreadedFakeH264Encoder : public test::FakeH264Encoder {
size_t max_payload_size) override;
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) override;
int32_t EncodeCallback(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types);
int32_t Release() override;

12
video/end_to_end_tests/network_state_tests.cc
View File

@ -268,7 +268,6 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
}
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) override {
{
rtc::CritScope lock(&test_crit_);
@ -282,8 +281,7 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
encoded_frames_.Set();
}
}
return test::FakeEncoder::Encode(input_image, codec_specific_info,
frame_types);
return test::FakeEncoder::Encode(input_image, frame_types);
}
private:
@ -364,11 +362,9 @@ TEST_F(NetworkStateEndToEndTest, NewVideoSendStreamsRespectVideoNetworkDown) {
return 0;
}
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) override {
ADD_FAILURE() << "Unexpected frame encode.";
return test::FakeEncoder::Encode(input_image, codec_specific_info,
frame_types);
return test::FakeEncoder::Encode(input_image, frame_types);
}
};
@ -389,11 +385,9 @@ TEST_F(NetworkStateEndToEndTest, NewVideoSendStreamsIgnoreAudioNetworkDown) {
}
}
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) override {
encoded_frame_ = true;
return test::FakeEncoder::Encode(input_image, codec_specific_info,
frame_types);
return test::FakeEncoder::Encode(input_image, frame_types);
}
private:

4
video/video_send_stream_tests.cc
View File

@ -1983,7 +1983,6 @@ TEST_F(VideoSendStreamTest,
}
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) override {
ADD_FAILURE()
<< "Unexpected Encode call since the send stream is not started";
@ -2317,7 +2316,6 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
}
int32_t Encode(const VideoFrame& inputImage,
const CodecSpecificInfo* codecSpecificInfo,
const std::vector<VideoFrameType>* frame_types) override {
EXPECT_TRUE(IsReadyForEncode());
@ -2536,7 +2534,6 @@ class VideoCodecConfigObserver : public test::SendTest,
}
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) override {
// Silently skip the encode, FakeEncoder::Encode doesn't produce VP8.
return 0;
@ -3002,7 +2999,6 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
private:
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codecSpecificInfo,
const std::vector<VideoFrameType>* frame_types) override {
CodecSpecificInfo specifics;
specifics.codecType = kVideoCodecGeneric;

6
video/video_stream_encoder_unittest.cc
View File

@ -618,7 +618,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
rtc::CritScope lock(&local_crit_sect_);
last_frame_types_ = frame_type;
}
FakeEncoder::Encode(input_image, nullptr, &frame_type);
FakeEncoder::Encode(input_image, &frame_type);
}
void InjectEncodedImage(const EncodedImage& image) {
@ -639,7 +639,6 @@ class VideoStreamEncoderTest : public ::testing::Test {
private:
int32_t Encode(const VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) override {
bool block_encode;
{
@ -664,8 +663,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
last_update_rect_ = input_image.update_rect();
last_frame_types_ = *frame_types;
}
int32_t result =
FakeEncoder::Encode(input_image, codec_specific_info, frame_types);
int32_t result = FakeEncoder::Encode(input_image, frame_types);
if (block_encode)
EXPECT_TRUE(continue_encode_event_.Wait(kDefaultTimeoutMs));
return result;