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

Migrate test VideoDecoders to new VideoDecoder::Configure

Browse Source 
Bug: webrtc:13045
Change-Id: I3b66270de59b441bf8b92bc10f67f59f05e9995e
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/228436
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#34742}
This commit is contained in:
Danil Chapovalov
2021-08-12 13:26:55 +02:00
committed by WebRTC LUCI CQ
parent 40f7a5bab0
commit d08930d5fb
12 changed files with 44 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
media/engine/fake_webrtc_video_engine.cc
View File

@ -51,8 +51,8 @@ FakeWebRtcVideoDecoder::~FakeWebRtcVideoDecoder() {
} }
} }
int32_t FakeWebRtcVideoDecoder::InitDecode(const webrtc::VideoCodec*, int32_t) { bool FakeWebRtcVideoDecoder::Configure(const Settings& settings) {
return WEBRTC_VIDEO_CODEC_OK; return true;
} }
int32_t FakeWebRtcVideoDecoder::Decode(const webrtc::EncodedImage&, int32_t FakeWebRtcVideoDecoder::Decode(const webrtc::EncodedImage&,

2
media/engine/fake_webrtc_video_engine.h
View File

@ -44,7 +44,7 @@ class FakeWebRtcVideoDecoder : public webrtc::VideoDecoder {
explicit FakeWebRtcVideoDecoder(FakeWebRtcVideoDecoderFactory* factory); explicit FakeWebRtcVideoDecoder(FakeWebRtcVideoDecoderFactory* factory);
~FakeWebRtcVideoDecoder(); ~FakeWebRtcVideoDecoder();
int32_t InitDecode(const webrtc::VideoCodec*, int32_t) override; bool Configure(const Settings& settings) override;
int32_t Decode(const webrtc::EncodedImage&, bool, int64_t) override; int32_t Decode(const webrtc::EncodedImage&, bool, int64_t) override;
int32_t RegisterDecodeCompleteCallback( int32_t RegisterDecodeCompleteCallback(
webrtc::DecodedImageCallback*) override; webrtc::DecodedImageCallback*) override;

5
test/fake_decoder.cc
View File

@ -36,9 +36,8 @@ FakeDecoder::FakeDecoder(TaskQueueFactory* task_queue_factory)
task_queue_factory_(task_queue_factory), task_queue_factory_(task_queue_factory),
decode_delay_ms_(0) {} decode_delay_ms_(0) {}
int32_t FakeDecoder::InitDecode(const VideoCodec* config, bool FakeDecoder::Configure(const Settings& settings) {
int32_t number_of_cores) { return true;
return WEBRTC_VIDEO_CODEC_OK;
} }
int32_t FakeDecoder::Decode(const EncodedImage& input, int32_t FakeDecoder::Decode(const EncodedImage& input,

4
test/fake_decoder.h
View File

@ -15,7 +15,6 @@
#include "api/task_queue/task_queue_factory.h" #include "api/task_queue/task_queue_factory.h"
#include "api/video/encoded_image.h" #include "api/video/encoded_image.h"
#include "api/video_codecs/video_codec.h"
#include "api/video_codecs/video_decoder.h" #include "api/video_codecs/video_decoder.h"
#include "modules/video_coding/include/video_codec_interface.h" #include "modules/video_coding/include/video_codec_interface.h"
#include "rtc_base/task_queue.h" #include "rtc_base/task_queue.h"
@ -31,8 +30,7 @@ class FakeDecoder : public VideoDecoder {
explicit FakeDecoder(TaskQueueFactory* task_queue_factory); explicit FakeDecoder(TaskQueueFactory* task_queue_factory);
virtual ~FakeDecoder() {} virtual ~FakeDecoder() {}
int32_t InitDecode(const VideoCodec* config, bool Configure(const Settings& settings) override;
int32_t number_of_cores) override;
int32_t Decode(const EncodedImage& input, int32_t Decode(const EncodedImage& input,
bool missing_frames, bool missing_frames,

5
test/fake_vp8_decoder.cc
View File

@ -39,9 +39,8 @@ void ParseFakeVp8(const unsigned char* data, int* width, int* height) {
FakeVp8Decoder::FakeVp8Decoder() : callback_(nullptr), width_(0), height_(0) {} FakeVp8Decoder::FakeVp8Decoder() : callback_(nullptr), width_(0), height_(0) {}
int32_t FakeVp8Decoder::InitDecode(const VideoCodec* config, bool FakeVp8Decoder::Configure(const Settings& settings) {
int32_t number_of_cores) { return true;
return WEBRTC_VIDEO_CODEC_OK;
} }
int32_t FakeVp8Decoder::Decode(const EncodedImage& input, int32_t FakeVp8Decoder::Decode(const EncodedImage& input,

4
test/fake_vp8_decoder.h
View File

@ -14,7 +14,6 @@
#include <stdint.h> #include <stdint.h>
#include "api/video/encoded_image.h" #include "api/video/encoded_image.h"
#include "api/video_codecs/video_codec.h"
#include "api/video_codecs/video_decoder.h" #include "api/video_codecs/video_decoder.h"
#include "modules/video_coding/include/video_codec_interface.h" #include "modules/video_coding/include/video_codec_interface.h"
@ -26,8 +25,7 @@ class FakeVp8Decoder : public VideoDecoder {
FakeVp8Decoder(); FakeVp8Decoder();
~FakeVp8Decoder() override {} ~FakeVp8Decoder() override {}
int32_t InitDecode(const VideoCodec* config, bool Configure(const Settings& settings) override;
int32_t number_of_cores) override;
int32_t Decode(const EncodedImage& input, int32_t Decode(const EncodedImage& input,
bool missing_frames, bool missing_frames,

11
test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.cc
View File

@ -40,16 +40,13 @@ QualityAnalyzingVideoDecoder::QualityAnalyzingVideoDecoder(
} }
QualityAnalyzingVideoDecoder::~QualityAnalyzingVideoDecoder() = default; QualityAnalyzingVideoDecoder::~QualityAnalyzingVideoDecoder() = default;
int32_t QualityAnalyzingVideoDecoder::InitDecode( bool QualityAnalyzingVideoDecoder::Configure(const Settings& settings) {
const VideoCodec* codec_settings,
int32_t number_of_cores) {
{ {
MutexLock lock(&mutex_); MutexLock lock(&mutex_);
codec_name_ = codec_name_ = std::string(CodecTypeToPayloadString(settings.codec_type())) +
std::string(CodecTypeToPayloadString(codec_settings->codecType)) + "_" + "_" + delegate_->GetDecoderInfo().implementation_name;
delegate_->GetDecoderInfo().implementation_name;
} }
return delegate_->InitDecode(codec_settings, number_of_cores); return delegate_->Configure(settings);
} }
int32_t QualityAnalyzingVideoDecoder::Decode(const EncodedImage& input_image, int32_t QualityAnalyzingVideoDecoder::Decode(const EncodedImage& input_image,

3
test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.h
View File

@ -56,8 +56,7 @@ class QualityAnalyzingVideoDecoder : public VideoDecoder {
~QualityAnalyzingVideoDecoder() override; ~QualityAnalyzingVideoDecoder() override;
// Methods of VideoDecoder interface. // Methods of VideoDecoder interface.
int32_t InitDecode(const VideoCodec* codec_settings, bool Configure(const Settings& settings) override;
int32_t number_of_cores) override;
int32_t Decode(const EncodedImage& input_image, int32_t Decode(const EncodedImage& input_image,
bool missing_frames, bool missing_frames,
int64_t render_time_ms) override; int64_t render_time_ms) override;

5
test/video_decoder_proxy_factory.h
View File

@ -52,9 +52,8 @@ class VideoDecoderProxyFactory final : public VideoDecoderFactory {
int64_t render_time_ms) override { int64_t render_time_ms) override {
return decoder_->Decode(input_image, missing_frames, render_time_ms); return decoder_->Decode(input_image, missing_frames, render_time_ms);
} }
int32_t InitDecode(const VideoCodec* config, bool Configure(const Settings& settings) override {
int32_t number_of_cores) override { return decoder_->Configure(settings);
return decoder_->InitDecode(config, number_of_cores);
} }
int32_t RegisterDecodeCompleteCallback( int32_t RegisterDecodeCompleteCallback(
DecodedImageCallback* callback) override { DecodedImageCallback* callback) override {

29
video/video_receive_stream2_unittest.cc
View File

@ -54,6 +54,7 @@ using ::testing::Invoke;
using ::testing::IsEmpty; using ::testing::IsEmpty;
using ::testing::Property; using ::testing::Property;
using ::testing::SizeIs; using ::testing::SizeIs;
using ::testing::WithoutArgs;
constexpr int kDefaultTimeOutMs = 50; constexpr int kDefaultTimeOutMs = 50;
@ -137,13 +138,11 @@ TEST_F(VideoReceiveStream2Test, CreateFrameFromH264FmtpSpropAndIdr) {
rtppacket.SetPayloadType(99); rtppacket.SetPayloadType(99);
rtppacket.SetSequenceNumber(1); rtppacket.SetSequenceNumber(1);
rtppacket.SetTimestamp(0); rtppacket.SetTimestamp(0);
rtc::Event init_decode_event_; rtc::Event init_decode_event;
EXPECT_CALL(mock_h264_video_decoder_, InitDecode(_, _)) EXPECT_CALL(mock_h264_video_decoder_, Configure).WillOnce(WithoutArgs([&] {
.WillOnce(Invoke([&init_decode_event_](const VideoCodec* config, init_decode_event.Set();
int32_t number_of_cores) { return true;
init_decode_event_.Set(); }));
return 0;
}));
EXPECT_CALL(mock_h264_video_decoder_, RegisterDecodeCompleteCallback(_)); EXPECT_CALL(mock_h264_video_decoder_, RegisterDecodeCompleteCallback(_));
video_receive_stream_->Start(); video_receive_stream_->Start();
EXPECT_CALL(mock_h264_video_decoder_, Decode(_, false, _)); EXPECT_CALL(mock_h264_video_decoder_, Decode(_, false, _));
@ -152,7 +151,7 @@ TEST_F(VideoReceiveStream2Test, CreateFrameFromH264FmtpSpropAndIdr) {
rtp_stream_receiver_controller_.OnRtpPacket(parsed_packet); rtp_stream_receiver_controller_.OnRtpPacket(parsed_packet);
EXPECT_CALL(mock_h264_video_decoder_, Release()); EXPECT_CALL(mock_h264_video_decoder_, Release());
// Make sure the decoder thread had a chance to run. // Make sure the decoder thread had a chance to run.
init_decode_event_.Wait(kDefaultTimeOutMs); init_decode_event.Wait(kDefaultTimeOutMs);
} }
TEST_F(VideoReceiveStream2Test, PlayoutDelay) { TEST_F(VideoReceiveStream2Test, PlayoutDelay) {
@ -766,13 +765,11 @@ TEST_F(VideoReceiveStream2TestWithLazyDecoderCreation, LazyDecoderCreation) {
&mock_h264_video_decoder_); &mock_h264_video_decoder_);
return h264_decoder_factory.CreateVideoDecoder(format); return h264_decoder_factory.CreateVideoDecoder(format);
})); }));
rtc::Event init_decode_event_; rtc::Event init_decode_event;
EXPECT_CALL(mock_h264_video_decoder_, InitDecode(_, _)) EXPECT_CALL(mock_h264_video_decoder_, Configure).WillOnce(WithoutArgs([&] {
.WillOnce(Invoke([&init_decode_event_](const VideoCodec* config, init_decode_event.Set();
int32_t number_of_cores) { return true;
init_decode_event_.Set(); }));
return 0;
}));
EXPECT_CALL(mock_h264_video_decoder_, RegisterDecodeCompleteCallback(_)); EXPECT_CALL(mock_h264_video_decoder_, RegisterDecodeCompleteCallback(_));
EXPECT_CALL(mock_h264_video_decoder_, Decode(_, false, _)); EXPECT_CALL(mock_h264_video_decoder_, Decode(_, false, _));
RtpPacketReceived parsed_packet; RtpPacketReceived parsed_packet;
@ -781,7 +778,7 @@ TEST_F(VideoReceiveStream2TestWithLazyDecoderCreation, LazyDecoderCreation) {
EXPECT_CALL(mock_h264_video_decoder_, Release()); EXPECT_CALL(mock_h264_video_decoder_, Release());
// Make sure the decoder thread had a chance to run. // Make sure the decoder thread had a chance to run.
init_decode_event_.Wait(kDefaultTimeOutMs); init_decode_event.Wait(kDefaultTimeOutMs);
} }
TEST_F(VideoReceiveStream2TestWithLazyDecoderCreation, TEST_F(VideoReceiveStream2TestWithLazyDecoderCreation,

15
video/video_receive_stream_unittest.cc
View File

@ -45,6 +45,7 @@ using ::testing::ElementsAreArray;
using ::testing::Invoke; using ::testing::Invoke;
using ::testing::IsEmpty; using ::testing::IsEmpty;
using ::testing::SizeIs; using ::testing::SizeIs;
using ::testing::WithoutArgs;
constexpr int kDefaultTimeOutMs = 50; constexpr int kDefaultTimeOutMs = 50;
@ -120,13 +121,11 @@ TEST_F(VideoReceiveStreamTest, CreateFrameFromH264FmtpSpropAndIdr) {
rtppacket.SetPayloadType(99); rtppacket.SetPayloadType(99);
rtppacket.SetSequenceNumber(1); rtppacket.SetSequenceNumber(1);
rtppacket.SetTimestamp(0); rtppacket.SetTimestamp(0);
rtc::Event init_decode_event_; rtc::Event init_decode_event;
EXPECT_CALL(mock_h264_video_decoder_, InitDecode(_, _)) EXPECT_CALL(mock_h264_video_decoder_, Configure).WillOnce(WithoutArgs([&] {
.WillOnce(Invoke([&init_decode_event_](const VideoCodec* config, init_decode_event.Set();
int32_t number_of_cores) { return true;
init_decode_event_.Set(); }));
return 0;
}));
EXPECT_CALL(mock_h264_video_decoder_, RegisterDecodeCompleteCallback(_)); EXPECT_CALL(mock_h264_video_decoder_, RegisterDecodeCompleteCallback(_));
video_receive_stream_->Start(); video_receive_stream_->Start();
EXPECT_CALL(mock_h264_video_decoder_, Decode(_, false, _)); EXPECT_CALL(mock_h264_video_decoder_, Decode(_, false, _));
@ -135,7 +134,7 @@ TEST_F(VideoReceiveStreamTest, CreateFrameFromH264FmtpSpropAndIdr) {
rtp_stream_receiver_controller_.OnRtpPacket(parsed_packet); rtp_stream_receiver_controller_.OnRtpPacket(parsed_packet);
EXPECT_CALL(mock_h264_video_decoder_, Release()); EXPECT_CALL(mock_h264_video_decoder_, Release());
// Make sure the decoder thread had a chance to run. // Make sure the decoder thread had a chance to run.
init_decode_event_.Wait(kDefaultTimeOutMs); init_decode_event.Wait(kDefaultTimeOutMs);
} }
TEST_F(VideoReceiveStreamTest, PlayoutDelay) { TEST_F(VideoReceiveStreamTest, PlayoutDelay) {

17
video/video_stream_decoder_impl_unittest.cc
View File

@ -13,6 +13,7 @@
#include <vector> #include <vector>
#include "api/video/i420_buffer.h" #include "api/video/i420_buffer.h"
#include "api/video_codecs/video_decoder.h"
#include "test/gmock.h" #include "test/gmock.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/time_controller/simulated_time_controller.h" #include "test/time_controller/simulated_time_controller.h"
@ -39,10 +40,9 @@ class MockVideoStreamDecoderCallbacks
class StubVideoDecoder : public VideoDecoder { class StubVideoDecoder : public VideoDecoder {
public: public:
MOCK_METHOD(int32_t, StubVideoDecoder() { ON_CALL(*this, Configure).WillByDefault(Return(true)); }
InitDecode,
(const VideoCodec*, int32_t number_of_cores), MOCK_METHOD(bool, Configure, (const Settings&), (override));
(override));
int32_t Decode(const EncodedImage& input_image, int32_t Decode(const EncodedImage& input_image,
bool missing_frames, bool missing_frames,
@ -81,9 +81,8 @@ class WrappedVideoDecoder : public VideoDecoder {
public: public:
explicit WrappedVideoDecoder(StubVideoDecoder* decoder) : decoder_(decoder) {} explicit WrappedVideoDecoder(StubVideoDecoder* decoder) : decoder_(decoder) {}
int32_t InitDecode(const VideoCodec* codec_settings, bool Configure(const Settings& settings) override {
int32_t number_of_cores) override { return decoder_->Configure(settings);
return decoder_->InitDecode(codec_settings, number_of_cores);
} }
int32_t Decode(const EncodedImage& input_image, int32_t Decode(const EncodedImage& input_image,
bool missing_frames, bool missing_frames,
@ -203,8 +202,8 @@ TEST_F(VideoStreamDecoderImplTest, InsertAndDecodeFrameWithKeyframeRequest) {
TEST_F(VideoStreamDecoderImplTest, FailToInitDecoder) { TEST_F(VideoStreamDecoderImplTest, FailToInitDecoder) {
video_stream_decoder_.OnFrame(FrameBuilder().WithPayloadType(1).Build()); video_stream_decoder_.OnFrame(FrameBuilder().WithPayloadType(1).Build());
ON_CALL(decoder_factory_.Vp8Decoder(), InitDecode) ON_CALL(decoder_factory_.Vp8Decoder(), Configure)
.WillByDefault(Return(WEBRTC_VIDEO_CODEC_ERROR)); .WillByDefault(Return(false));
EXPECT_CALL(callbacks_, OnNonDecodableState); EXPECT_CALL(callbacks_, OnNonDecodableState);
time_controller_.AdvanceTime(TimeDelta::Millis(1)); time_controller_.AdvanceTime(TimeDelta::Millis(1));
} }