From 39d3a7de02d63894d12e7332322e1d80cd7c0d40 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Niels=20M=C3=B6ller?= Date: Thu, 7 Mar 2019 15:48:50 +0100 Subject: [PATCH] Delete CodecSpecificInfo argument from VideoDecoder::Decode MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bug: webrtc:10379 Change-Id: I079b419604bf4e9c1994fe203d7db131a0ccddb6 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/125920 Commit-Queue: Niels Moller Reviewed-by: Karl Wiberg Reviewed-by: Kári Helgason Reviewed-by: Rasmus Brandt Reviewed-by: Erik Språng Cr-Commit-Position: refs/heads/master@{#27022} --- api/test/mock_video_decoder.h | 3 +-- ...oder_software_fallback_wrapper_unittest.cc | 23 +++++++++---------- api/video_codecs/video_decoder.cc | 13 +++++++++++ api/video_codecs/video_decoder.h | 8 ++++++- ...video_decoder_software_fallback_wrapper.cc | 7 ++---- media/engine/fake_webrtc_video_engine.cc | 1 - media/engine/fake_webrtc_video_engine.h | 1 - .../codecs/h264/h264_decoder_impl.cc | 6 ----- .../codecs/h264/h264_decoder_impl.h | 1 - .../codecs/h264/test/h264_impl_unittest.cc | 9 +++----- .../include/multiplex_decoder_adapter.h | 1 - .../multiplex/multiplex_decoder_adapter.cc | 3 +-- .../test/multiplex_adapter_unittest.cc | 6 ++--- .../codecs/test/videoprocessor.cc | 2 +- .../codecs/vp8/libvpx_vp8_decoder.cc | 1 - .../codecs/vp8/libvpx_vp8_decoder.h | 1 - .../codecs/vp8/test/vp8_impl_unittest.cc | 16 +++++-------- .../codecs/vp9/test/vp9_impl_unittest.cc | 15 ++++-------- modules/video_coding/codecs/vp9/vp9_impl.cc | 1 - modules/video_coding/codecs/vp9/vp9_impl.h | 1 - modules/video_coding/generic_decoder.cc | 2 +- .../utility/simulcast_test_fixture_impl.cc | 10 ++++---- .../video_coding/video_receiver_unittest.cc | 4 ++-- .../objc_video_decoder_factory_tests.mm | 8 ++----- test/fake_decoder.cc | 5 +--- test/fake_decoder.h | 2 -- test/fake_vp8_decoder.cc | 1 - test/fake_vp8_decoder.h | 1 - .../video/quality_analyzing_video_decoder.cc | 5 ++-- .../video/quality_analyzing_video_decoder.h | 1 - test/video_decoder_proxy_factory.h | 4 +--- video/frame_dumping_decoder.cc | 7 +++--- video/frame_dumping_decoder.h | 2 +- video/video_receive_stream.cc | 1 - video/video_receive_stream_unittest.cc | 5 ++-- 35 files changed, 72 insertions(+), 105 deletions(-) diff --git a/api/test/mock_video_decoder.h b/api/test/mock_video_decoder.h index 56ff5463fd..6dee76097a 100644 --- a/api/test/mock_video_decoder.h +++ b/api/test/mock_video_decoder.h @@ -41,10 +41,9 @@ class MockVideoDecoder : public VideoDecoder { MOCK_METHOD2(InitDecode, int32_t(const VideoCodec* codecSettings, int32_t numberOfCores)); - MOCK_METHOD4(Decode, + MOCK_METHOD3(Decode, int32_t(const EncodedImage& inputImage, bool missingFrames, - const CodecSpecificInfo* codecSpecificInfo, int64_t renderTimeMs)); MOCK_METHOD1(RegisterDecodeCompleteCallback, int32_t(DecodedImageCallback* callback)); diff --git a/api/video_codecs/test/video_decoder_software_fallback_wrapper_unittest.cc b/api/video_codecs/test/video_decoder_software_fallback_wrapper_unittest.cc index 06b893c2ad..0e97173d07 100644 --- a/api/video_codecs/test/video_decoder_software_fallback_wrapper_unittest.cc +++ b/api/video_codecs/test/video_decoder_software_fallback_wrapper_unittest.cc @@ -49,7 +49,6 @@ class VideoDecoderSoftwareFallbackWrapperTest : public ::testing::Test { int32_t Decode(const EncodedImage& input_image, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t render_time_ms) override { ++decode_count_; return decode_return_code_; @@ -89,7 +88,7 @@ TEST_F(VideoDecoderSoftwareFallbackWrapperTest, InitializesDecoder) { EncodedImage encoded_image; encoded_image._frameType = kVideoFrameKey; - fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, -1); EXPECT_EQ(1, fake_decoder_->init_decode_count_) << "Initialized decoder should not be reinitialized."; EXPECT_EQ(1, fake_decoder_->decode_count_); @@ -104,7 +103,7 @@ TEST_F(VideoDecoderSoftwareFallbackWrapperTest, EncodedImage encoded_image; encoded_image._frameType = kVideoFrameKey; - fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, -1); EXPECT_EQ(1, fake_decoder_->init_decode_count_) << "Should not have attempted reinitializing the fallback decoder on " "keyframe."; @@ -120,12 +119,12 @@ TEST_F(VideoDecoderSoftwareFallbackWrapperTest, IsSoftwareFallbackSticky) { fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; EncodedImage encoded_image; - fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, -1); EXPECT_EQ(1, fake_decoder_->decode_count_); // Software fallback should be sticky, fake_decoder_ shouldn't be used. encoded_image._frameType = kVideoFrameKey; - fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, -1); EXPECT_EQ(1, fake_decoder_->decode_count_) << "Decoder shouldn't be used after failure."; @@ -139,10 +138,10 @@ TEST_F(VideoDecoderSoftwareFallbackWrapperTest, DoesNotFallbackOnEveryError) { fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_ERROR; EncodedImage encoded_image; EXPECT_EQ(fake_decoder_->decode_return_code_, - fallback_wrapper_->Decode(encoded_image, false, nullptr, -1)); + fallback_wrapper_->Decode(encoded_image, false, -1)); EXPECT_EQ(1, fake_decoder_->decode_count_); - fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, -1); EXPECT_EQ(2, fake_decoder_->decode_count_) << "Decoder should be active even though previous decode failed."; } @@ -153,14 +152,14 @@ TEST_F(VideoDecoderSoftwareFallbackWrapperTest, UsesHwDecoderAfterReinit) { fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; EncodedImage encoded_image; - fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, -1); EXPECT_EQ(1, fake_decoder_->decode_count_); fallback_wrapper_->Release(); fallback_wrapper_->InitDecode(&codec, 2); fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_OK; - fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, -1); EXPECT_EQ(2, fake_decoder_->decode_count_) << "Should not be using fallback after reinit."; } @@ -174,7 +173,7 @@ TEST_F(VideoDecoderSoftwareFallbackWrapperTest, ForwardsReleaseCall) { fallback_wrapper_->InitDecode(&codec, 2); fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; EncodedImage encoded_image; - fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, -1); EXPECT_EQ(2, fake_decoder_->release_count_) << "Decoder should be released during fallback."; fallback_wrapper_->Release(); @@ -212,7 +211,7 @@ TEST_F(VideoDecoderSoftwareFallbackWrapperTest, fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; EncodedImage encoded_image; - fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, -1); // Hard coded expected value since libvpx is the software implementation name // for VP8. Change accordingly if the underlying implementation does. EXPECT_STREQ("libvpx (fallback from: fake-decoder)", @@ -243,7 +242,7 @@ TEST_F(ForcedSoftwareDecoderFallbackTest, UsesForcedFallback) { EncodedImage encoded_image; encoded_image._frameType = kVideoFrameKey; - fallback_wrapper_->Decode(encoded_image, false, nullptr, -1); + fallback_wrapper_->Decode(encoded_image, false, -1); EXPECT_EQ(1, sw_fallback_decoder_->init_decode_count_); EXPECT_EQ(1, sw_fallback_decoder_->decode_count_); diff --git a/api/video_codecs/video_decoder.cc b/api/video_codecs/video_decoder.cc index b5fff32e5f..32725b9850 100644 --- a/api/video_codecs/video_decoder.cc +++ b/api/video_codecs/video_decoder.cc @@ -33,6 +33,19 @@ int32_t DecodedImageCallback::ReceivedDecodedFrame(const uint64_t pictureId) { return -1; } +int32_t VideoDecoder::Decode(const EncodedImage& input_image, + bool missing_frames, + int64_t render_time_ms) { + return Decode(input_image, missing_frames, nullptr, render_time_ms); +} + +int32_t VideoDecoder::Decode(const EncodedImage& input_image, + bool missing_frames, + const CodecSpecificInfo* codec_specific_info, + int64_t render_time_ms) { + return Decode(input_image, missing_frames, render_time_ms); +} + bool VideoDecoder::PrefersLateDecoding() const { return true; } diff --git a/api/video_codecs/video_decoder.h b/api/video_codecs/video_decoder.h index 36cf80fe84..3403987eba 100644 --- a/api/video_codecs/video_decoder.h +++ b/api/video_codecs/video_decoder.h @@ -55,10 +55,16 @@ class RTC_EXPORT VideoDecoder { virtual int32_t InitDecode(const VideoCodec* codec_settings, int32_t number_of_cores) = 0; + virtual int32_t Decode(const EncodedImage& input_image, + bool missing_frames, + int64_t render_time_ms); + + // TODO(bugs.webrtc.org/10379): Deprecated. Delete, and make above method pure + // virtual, as soon as downstream applications are updated. virtual int32_t Decode(const EncodedImage& input_image, bool missing_frames, const CodecSpecificInfo* codec_specific_info, - int64_t render_time_ms) = 0; + int64_t render_time_ms); virtual int32_t RegisterDecodeCompleteCallback( DecodedImageCallback* callback) = 0; diff --git a/api/video_codecs/video_decoder_software_fallback_wrapper.cc b/api/video_codecs/video_decoder_software_fallback_wrapper.cc index 0bbce3e640..9bf1dfd399 100644 --- a/api/video_codecs/video_decoder_software_fallback_wrapper.cc +++ b/api/video_codecs/video_decoder_software_fallback_wrapper.cc @@ -40,7 +40,6 @@ class VideoDecoderSoftwareFallbackWrapper final : public VideoDecoder { int32_t Decode(const EncodedImage& input_image, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t render_time_ms) override; int32_t RegisterDecodeCompleteCallback( @@ -147,7 +146,6 @@ bool VideoDecoderSoftwareFallbackWrapper::InitFallbackDecoder() { int32_t VideoDecoderSoftwareFallbackWrapper::Decode( const EncodedImage& input_image, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t render_time_ms) { TRACE_EVENT0("webrtc", "VideoDecoderSoftwareFallbackWrapper::Decode"); switch (decoder_type_) { @@ -155,8 +153,7 @@ int32_t VideoDecoderSoftwareFallbackWrapper::Decode( return WEBRTC_VIDEO_CODEC_UNINITIALIZED; case DecoderType::kHardware: { int32_t ret = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; - ret = hw_decoder_->Decode(input_image, missing_frames, - codec_specific_info, render_time_ms); + ret = hw_decoder_->Decode(input_image, missing_frames, render_time_ms); if (ret != WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE) { return ret; } @@ -172,7 +169,7 @@ int32_t VideoDecoderSoftwareFallbackWrapper::Decode( } case DecoderType::kFallback: return fallback_decoder_->Decode(input_image, missing_frames, - codec_specific_info, render_time_ms); + render_time_ms); default: RTC_NOTREACHED(); return WEBRTC_VIDEO_CODEC_ERROR; diff --git a/media/engine/fake_webrtc_video_engine.cc b/media/engine/fake_webrtc_video_engine.cc index d4de300e0d..c8be0b0acb 100644 --- a/media/engine/fake_webrtc_video_engine.cc +++ b/media/engine/fake_webrtc_video_engine.cc @@ -57,7 +57,6 @@ int32_t FakeWebRtcVideoDecoder::InitDecode(const webrtc::VideoCodec*, int32_t) { int32_t FakeWebRtcVideoDecoder::Decode(const webrtc::EncodedImage&, bool, - const webrtc::CodecSpecificInfo*, int64_t) { num_frames_received_++; return WEBRTC_VIDEO_CODEC_OK; diff --git a/media/engine/fake_webrtc_video_engine.h b/media/engine/fake_webrtc_video_engine.h index 3ab924aca4..dcd723afbb 100644 --- a/media/engine/fake_webrtc_video_engine.h +++ b/media/engine/fake_webrtc_video_engine.h @@ -46,7 +46,6 @@ class FakeWebRtcVideoDecoder : public webrtc::VideoDecoder { int32_t InitDecode(const webrtc::VideoCodec*, int32_t) override; int32_t Decode(const webrtc::EncodedImage&, bool, - const webrtc::CodecSpecificInfo*, int64_t) override; int32_t RegisterDecodeCompleteCallback( webrtc::DecodedImageCallback*) override; diff --git a/modules/video_coding/codecs/h264/h264_decoder_impl.cc b/modules/video_coding/codecs/h264/h264_decoder_impl.cc index e5d31ed34d..d72ef06067 100644 --- a/modules/video_coding/codecs/h264/h264_decoder_impl.cc +++ b/modules/video_coding/codecs/h264/h264_decoder_impl.cc @@ -228,7 +228,6 @@ int32_t H264DecoderImpl::RegisterDecodeCompleteCallback( int32_t H264DecoderImpl::Decode(const EncodedImage& input_image, bool /*missing_frames*/, - const CodecSpecificInfo* codec_specific_info, int64_t /*render_time_ms*/) { if (!IsInitialized()) { ReportError(); @@ -245,11 +244,6 @@ int32_t H264DecoderImpl::Decode(const EncodedImage& input_image, ReportError(); return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; } - if (codec_specific_info && - codec_specific_info->codecType != kVideoCodecH264) { - ReportError(); - return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; - } // FFmpeg requires padding due to some optimized bitstream readers reading 32 // or 64 bits at once and could read over the end. See avcodec_decode_video2. diff --git a/modules/video_coding/codecs/h264/h264_decoder_impl.h b/modules/video_coding/codecs/h264/h264_decoder_impl.h index a709177946..f9325689c6 100644 --- a/modules/video_coding/codecs/h264/h264_decoder_impl.h +++ b/modules/video_coding/codecs/h264/h264_decoder_impl.h @@ -49,7 +49,6 @@ class H264DecoderImpl : public H264Decoder { // |missing_frames|, |fragmentation| and |render_time_ms| are ignored. int32_t Decode(const EncodedImage& input_image, bool /*missing_frames*/, - const CodecSpecificInfo* codec_specific_info = nullptr, int64_t render_time_ms = -1) override; const char* ImplementationName() const override; diff --git a/modules/video_coding/codecs/h264/test/h264_impl_unittest.cc b/modules/video_coding/codecs/h264/test/h264_impl_unittest.cc index 57c3a9fbf1..12357f593d 100644 --- a/modules/video_coding/codecs/h264/test/h264_impl_unittest.cc +++ b/modules/video_coding/codecs/h264/test/h264_impl_unittest.cc @@ -71,8 +71,7 @@ TEST_F(TestH264Impl, MAYBE_EncodeDecode) { ASSERT_TRUE(WaitForEncodedFrame(&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, 0)); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Decode(encoded_frame, false, 0)); std::unique_ptr decoded_frame; absl::optional decoded_qp; ASSERT_TRUE(WaitForDecodedFrame(&decoded_frame, &decoded_qp)); @@ -98,8 +97,7 @@ TEST_F(TestH264Impl, MAYBE_DecodedQpEqualsEncodedQp) { ASSERT_TRUE(WaitForEncodedFrame(&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, 0)); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Decode(encoded_frame, false, 0)); std::unique_ptr decoded_frame; absl::optional decoded_qp; ASSERT_TRUE(WaitForDecodedFrame(&decoded_frame, &decoded_qp)); @@ -140,8 +138,7 @@ TEST_F(TestH264Impl, MAYBE_DecodedColorSpaceEqualsEncodedColorSpace) { // Add color space to encoded frame. ColorSpace color_space = CreateTestColorSpace(/*with_hdr_metadata=*/false); encoded_frame.SetColorSpace(color_space); - EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, - decoder_->Decode(encoded_frame, false, nullptr, 0)); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Decode(encoded_frame, false, 0)); std::unique_ptr decoded_frame; absl::optional decoded_qp; ASSERT_TRUE(WaitForDecodedFrame(&decoded_frame, &decoded_qp)); diff --git a/modules/video_coding/codecs/multiplex/include/multiplex_decoder_adapter.h b/modules/video_coding/codecs/multiplex/include/multiplex_decoder_adapter.h index 73b67c94d8..8976250fc5 100644 --- a/modules/video_coding/codecs/multiplex/include/multiplex_decoder_adapter.h +++ b/modules/video_coding/codecs/multiplex/include/multiplex_decoder_adapter.h @@ -35,7 +35,6 @@ class MultiplexDecoderAdapter : public VideoDecoder { int32_t number_of_cores) override; int32_t Decode(const EncodedImage& input_image, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t render_time_ms) override; int32_t RegisterDecodeCompleteCallback( DecodedImageCallback* callback) override; diff --git a/modules/video_coding/codecs/multiplex/multiplex_decoder_adapter.cc b/modules/video_coding/codecs/multiplex/multiplex_decoder_adapter.cc index 0facbe4896..d1c8220ce9 100644 --- a/modules/video_coding/codecs/multiplex/multiplex_decoder_adapter.cc +++ b/modules/video_coding/codecs/multiplex/multiplex_decoder_adapter.cc @@ -130,7 +130,6 @@ int32_t MultiplexDecoderAdapter::InitDecode(const VideoCodec* codec_settings, int32_t MultiplexDecoderAdapter::Decode( const EncodedImage& input_image, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t render_time_ms) { MultiplexImage image = MultiplexEncodedImagePacker::Unpack(input_image); @@ -154,7 +153,7 @@ int32_t MultiplexDecoderAdapter::Decode( int32_t rv = 0; for (size_t i = 0; i < image.image_components.size(); i++) { rv = decoders_[image.image_components[i].component_index]->Decode( - image.image_components[i].encoded_image, missing_frames, nullptr, + image.image_components[i].encoded_image, missing_frames, render_time_ms); if (rv != WEBRTC_VIDEO_CODEC_OK) return rv; diff --git a/modules/video_coding/codecs/multiplex/test/multiplex_adapter_unittest.cc b/modules/video_coding/codecs/multiplex/test/multiplex_adapter_unittest.cc index 3aa7c2883a..8b4b837f85 100644 --- a/modules/video_coding/codecs/multiplex/test/multiplex_adapter_unittest.cc +++ b/modules/video_coding/codecs/multiplex/test/multiplex_adapter_unittest.cc @@ -225,8 +225,7 @@ TEST_P(TestMultiplexAdapter, EncodeDecodeI420Frame) { ASSERT_TRUE(WaitForEncodedFrame(&encoded_frame, &codec_specific_info)); EXPECT_EQ(kVideoCodecMultiplex, codec_specific_info.codecType); - EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, - decoder_->Decode(encoded_frame, false, &codec_specific_info, -1)); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Decode(encoded_frame, false, -1)); std::unique_ptr decoded_frame; absl::optional decoded_qp; ASSERT_TRUE(WaitForDecodedFrame(&decoded_frame, &decoded_qp)); @@ -243,8 +242,7 @@ TEST_P(TestMultiplexAdapter, EncodeDecodeI420AFrame) { ASSERT_TRUE(WaitForEncodedFrame(&encoded_frame, &codec_specific_info)); EXPECT_EQ(kVideoCodecMultiplex, codec_specific_info.codecType); - EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, - decoder_->Decode(encoded_frame, false, nullptr, 0)); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Decode(encoded_frame, false, 0)); std::unique_ptr decoded_frame; absl::optional decoded_qp; ASSERT_TRUE(WaitForDecodedFrame(&decoded_frame, &decoded_qp)); diff --git a/modules/video_coding/codecs/test/videoprocessor.cc b/modules/video_coding/codecs/test/videoprocessor.cc index 7458006cb0..a9dacbe779 100644 --- a/modules/video_coding/codecs/test/videoprocessor.cc +++ b/modules/video_coding/codecs/test/videoprocessor.cc @@ -529,7 +529,7 @@ void VideoProcessor::DecodeFrame(const EncodedImage& encoded_image, frame_stat->decode_start_ns = rtc::TimeNanos(); frame_stat->decode_return_code = - decoders_->at(spatial_idx)->Decode(encoded_image, false, nullptr, 0); + decoders_->at(spatial_idx)->Decode(encoded_image, false, 0); } const webrtc::EncodedImage* VideoProcessor::BuildAndStoreSuperframe( diff --git a/modules/video_coding/codecs/vp8/libvpx_vp8_decoder.cc b/modules/video_coding/codecs/vp8/libvpx_vp8_decoder.cc index d7258c9c28..0b26e8b293 100644 --- a/modules/video_coding/codecs/vp8/libvpx_vp8_decoder.cc +++ b/modules/video_coding/codecs/vp8/libvpx_vp8_decoder.cc @@ -153,7 +153,6 @@ int LibvpxVp8Decoder::InitDecode(const VideoCodec* inst, int number_of_cores) { int LibvpxVp8Decoder::Decode(const EncodedImage& input_image, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t /*render_time_ms*/) { if (!inited_) { return WEBRTC_VIDEO_CODEC_UNINITIALIZED; diff --git a/modules/video_coding/codecs/vp8/libvpx_vp8_decoder.h b/modules/video_coding/codecs/vp8/libvpx_vp8_decoder.h index a6ddfefb0b..2fa9a8f49b 100644 --- a/modules/video_coding/codecs/vp8/libvpx_vp8_decoder.h +++ b/modules/video_coding/codecs/vp8/libvpx_vp8_decoder.h @@ -34,7 +34,6 @@ class LibvpxVp8Decoder : public VideoDecoder { int Decode(const EncodedImage& input_image, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t /*render_time_ms*/) override; int RegisterDecodeCompleteCallback(DecodedImageCallback* callback) override; diff --git a/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc b/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc index 05e2f05fd5..f2e826b3c9 100644 --- a/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc +++ b/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc @@ -210,8 +210,7 @@ TEST_F(TestVp8Impl, DecodedQpEqualsEncodedQp) { // First frame should be a key frame. encoded_frame._frameType = kVideoFrameKey; - EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, - decoder_->Decode(encoded_frame, false, nullptr, -1)); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Decode(encoded_frame, false, -1)); std::unique_ptr decoded_frame; absl::optional decoded_qp; ASSERT_TRUE(WaitForDecodedFrame(&decoded_frame, &decoded_qp)); @@ -230,8 +229,7 @@ TEST_F(TestVp8Impl, DecodedColorSpaceEqualsEncodedColorSpace) { // Encoded frame with explicit color space information. ColorSpace color_space = CreateTestColorSpace(/*with_hdr_metadata=*/false); encoded_frame.SetColorSpace(color_space); - EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, - decoder_->Decode(encoded_frame, false, nullptr, -1)); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Decode(encoded_frame, false, -1)); std::unique_ptr decoded_frame; absl::optional decoded_qp; ASSERT_TRUE(WaitForDecodedFrame(&decoded_frame, &decoded_qp)); @@ -325,8 +323,7 @@ TEST_F(TestVp8Impl, MAYBE_AlignedStrideEncodeDecode) { // 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, -1)); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Decode(encoded_frame, false, -1)); std::unique_ptr decoded_frame; absl::optional decoded_qp; @@ -352,16 +349,15 @@ TEST_F(TestVp8Impl, MAYBE_DecodeWithACompleteKeyFrame) { // Setting complete to false -> should return an error. encoded_frame._completeFrame = false; EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERROR, - decoder_->Decode(encoded_frame, false, nullptr, -1)); + decoder_->Decode(encoded_frame, false, -1)); // 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, -1)); + decoder_->Decode(encoded_frame, false, -1)); // Now setting a key frame. encoded_frame._frameType = kVideoFrameKey; - EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, - decoder_->Decode(encoded_frame, false, nullptr, -1)); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Decode(encoded_frame, false, -1)); std::unique_ptr decoded_frame; absl::optional decoded_qp; ASSERT_TRUE(WaitForDecodedFrame(&decoded_frame, &decoded_qp)); diff --git a/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc b/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc index cd29915b9c..c7ae176351 100644 --- a/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc +++ b/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc @@ -128,8 +128,7 @@ TEST_F(TestVp9Impl, EncodeDecode) { ASSERT_TRUE(WaitForEncodedFrame(&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, 0)); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Decode(encoded_frame, false, 0)); std::unique_ptr decoded_frame; absl::optional decoded_qp; ASSERT_TRUE(WaitForDecodedFrame(&decoded_frame, &decoded_qp)); @@ -198,8 +197,7 @@ TEST_F(TestVp9Impl, DecodedColorSpaceEqualsEncodedColorSpace) { ASSERT_TRUE(WaitForEncodedFrame(&encoded_frame, &codec_specific_info)); // Encoded frame without explicit color space information. - EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, - decoder_->Decode(encoded_frame, false, nullptr, 0)); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Decode(encoded_frame, false, 0)); std::unique_ptr decoded_frame; absl::optional decoded_qp; ASSERT_TRUE(WaitForDecodedFrame(&decoded_frame, &decoded_qp)); @@ -212,8 +210,7 @@ TEST_F(TestVp9Impl, DecodedColorSpaceEqualsEncodedColorSpace) { // Encoded frame with explicit color space information. ColorSpace color_space = CreateTestColorSpace(/*with_hdr_metadata=*/true); encoded_frame.SetColorSpace(color_space); - EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, - decoder_->Decode(encoded_frame, false, nullptr, 0)); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Decode(encoded_frame, false, 0)); ASSERT_TRUE(WaitForDecodedFrame(&decoded_frame, &decoded_qp)); ASSERT_TRUE(decoded_frame); ASSERT_TRUE(decoded_frame->color_space()); @@ -228,8 +225,7 @@ TEST_F(TestVp9Impl, DecodedQpEqualsEncodedQp) { ASSERT_TRUE(WaitForEncodedFrame(&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, 0)); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Decode(encoded_frame, false, 0)); std::unique_ptr decoded_frame; absl::optional decoded_qp; ASSERT_TRUE(WaitForDecodedFrame(&decoded_frame, &decoded_qp)); @@ -1431,8 +1427,7 @@ TEST_F(TestVp9ImplProfile2, EncodeDecode) { ASSERT_TRUE(WaitForEncodedFrame(&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, 0)); + EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Decode(encoded_frame, false, 0)); std::unique_ptr decoded_frame; absl::optional decoded_qp; ASSERT_TRUE(WaitForDecodedFrame(&decoded_frame, &decoded_qp)); diff --git a/modules/video_coding/codecs/vp9/vp9_impl.cc b/modules/video_coding/codecs/vp9/vp9_impl.cc index e39e9bbbe1..4b0461a3f4 100644 --- a/modules/video_coding/codecs/vp9/vp9_impl.cc +++ b/modules/video_coding/codecs/vp9/vp9_impl.cc @@ -1507,7 +1507,6 @@ int VP9DecoderImpl::InitDecode(const VideoCodec* inst, int number_of_cores) { int VP9DecoderImpl::Decode(const EncodedImage& input_image, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t /*render_time_ms*/) { if (!inited_) { return WEBRTC_VIDEO_CODEC_UNINITIALIZED; diff --git a/modules/video_coding/codecs/vp9/vp9_impl.h b/modules/video_coding/codecs/vp9/vp9_impl.h index 3fc5398c53..7ca4b55ee0 100644 --- a/modules/video_coding/codecs/vp9/vp9_impl.h +++ b/modules/video_coding/codecs/vp9/vp9_impl.h @@ -184,7 +184,6 @@ class VP9DecoderImpl : public VP9Decoder { int Decode(const EncodedImage& input_image, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t /*render_time_ms*/) override; int RegisterDecodeCompleteCallback(DecodedImageCallback* callback) override; diff --git a/modules/video_coding/generic_decoder.cc b/modules/video_coding/generic_decoder.cc index 6ef4c361be..f6f23da284 100644 --- a/modules/video_coding/generic_decoder.cc +++ b/modules/video_coding/generic_decoder.cc @@ -230,7 +230,7 @@ int32_t VCMGenericDecoder::Decode(const VCMEncodedFrame& frame, int64_t nowMs) { _nextFrameInfoIdx = (_nextFrameInfoIdx + 1) % kDecoderFrameMemoryLength; int32_t ret = decoder_->Decode(frame.EncodedImage(), frame.MissingFrame(), - frame.CodecSpecific(), frame.RenderTimeMs()); + frame.RenderTimeMs()); _callback->OnDecoderImplementationName(decoder_->ImplementationName()); if (ret < WEBRTC_VIDEO_CODEC_OK) { diff --git a/modules/video_coding/utility/simulcast_test_fixture_impl.cc b/modules/video_coding/utility/simulcast_test_fixture_impl.cc index edef45d17a..12220bcb82 100644 --- a/modules/video_coding/utility/simulcast_test_fixture_impl.cc +++ b/modules/video_coding/utility/simulcast_test_fixture_impl.cc @@ -832,9 +832,9 @@ void SimulcastTestFixtureImpl::TestStrideEncodeDecode() { EncodedImage encoded_frame; // Only encoding one frame - so will be a key frame. encoder_callback.GetLastEncodedKeyFrame(&encoded_frame); - EXPECT_EQ(0, decoder_->Decode(encoded_frame, false, NULL, 0)); + EXPECT_EQ(0, decoder_->Decode(encoded_frame, false, 0)); encoder_callback.GetLastEncodedFrame(&encoded_frame); - decoder_->Decode(encoded_frame, false, NULL, 0); + decoder_->Decode(encoded_frame, false, 0); EXPECT_EQ(2, decoder_callback.DecodedFrames()); } @@ -875,7 +875,7 @@ void SimulcastTestFixtureImpl::TestDecodeWidthHeightSet() { EXPECT_EQ(decodedImage.width(), kDefaultWidth / 4); EXPECT_EQ(decodedImage.height(), kDefaultHeight / 4); })); - EXPECT_EQ(0, decoder_->Decode(encoded_frame[0], false, NULL, 0)); + EXPECT_EQ(0, decoder_->Decode(encoded_frame[0], false, 0)); EXPECT_CALL(decoder_callback, Decoded(_, _, _)) .WillOnce(testing::Invoke([](VideoFrame& decodedImage, @@ -884,7 +884,7 @@ void SimulcastTestFixtureImpl::TestDecodeWidthHeightSet() { EXPECT_EQ(decodedImage.width(), kDefaultWidth / 2); EXPECT_EQ(decodedImage.height(), kDefaultHeight / 2); })); - EXPECT_EQ(0, decoder_->Decode(encoded_frame[1], false, NULL, 0)); + EXPECT_EQ(0, decoder_->Decode(encoded_frame[1], false, 0)); EXPECT_CALL(decoder_callback, Decoded(_, _, _)) .WillOnce(testing::Invoke([](VideoFrame& decodedImage, @@ -893,7 +893,7 @@ void SimulcastTestFixtureImpl::TestDecodeWidthHeightSet() { EXPECT_EQ(decodedImage.width(), kDefaultWidth); EXPECT_EQ(decodedImage.height(), kDefaultHeight); })); - EXPECT_EQ(0, decoder_->Decode(encoded_frame[2], false, NULL, 0)); + EXPECT_EQ(0, decoder_->Decode(encoded_frame[2], false, 0)); } } // namespace test diff --git a/modules/video_coding/video_receiver_unittest.cc b/modules/video_coding/video_receiver_unittest.cc index 0d26fc515d..2cf6c36adf 100644 --- a/modules/video_coding/video_receiver_unittest.cc +++ b/modules/video_coding/video_receiver_unittest.cc @@ -75,7 +75,7 @@ class TestVideoReceiver : public ::testing::Test { ++header->header.sequenceNumber; } receiver_.Process(); - EXPECT_CALL(decoder_, Decode(_, _, _, _)).Times(0); + EXPECT_CALL(decoder_, Decode(_, _, _)).Times(0); EXPECT_EQ(VCM_FRAME_NOT_READY, receiver_.Decode(kMaxWaitTimeMs)); } @@ -87,7 +87,7 @@ class TestVideoReceiver : public ::testing::Test { EXPECT_CALL(packet_request_callback_, ResendPackets(_, _)).Times(0); receiver_.Process(); - EXPECT_CALL(decoder_, Decode(_, _, _, _)).Times(1); + EXPECT_CALL(decoder_, Decode(_, _, _)).Times(1); EXPECT_EQ(0, receiver_.Decode(kMaxWaitTimeMs)); } diff --git a/sdk/objc/unittests/objc_video_decoder_factory_tests.mm b/sdk/objc/unittests/objc_video_decoder_factory_tests.mm index 9d2d4848c0..312e78ef60 100644 --- a/sdk/objc/unittests/objc_video_decoder_factory_tests.mm +++ b/sdk/objc/unittests/objc_video_decoder_factory_tests.mm @@ -71,20 +71,16 @@ TEST(ObjCVideoDecoderFactoryTest, DecodeReturnsOKOnSuccess) { std::unique_ptr decoder = GetObjCDecoder(CreateOKDecoderFactory()); webrtc::EncodedImage encoded_image; - webrtc::CodecSpecificInfo info; - info.codecType = webrtc::kVideoCodecH264; - EXPECT_EQ(decoder->Decode(encoded_image, false, &info, 0), WEBRTC_VIDEO_CODEC_OK); + EXPECT_EQ(decoder->Decode(encoded_image, false, 0), WEBRTC_VIDEO_CODEC_OK); } TEST(ObjCVideoDecoderFactoryTest, DecodeReturnsErrorOnFail) { std::unique_ptr decoder = GetObjCDecoder(CreateErrorDecoderFactory()); webrtc::EncodedImage encoded_image; - webrtc::CodecSpecificInfo info; - info.codecType = webrtc::kVideoCodecH264; - EXPECT_EQ(decoder->Decode(encoded_image, false, &info, 0), WEBRTC_VIDEO_CODEC_ERROR); + EXPECT_EQ(decoder->Decode(encoded_image, false, 0), WEBRTC_VIDEO_CODEC_ERROR); } TEST(ObjCVideoDecoderFactoryTest, ReleaseDecodeReturnsOKOnSuccess) { diff --git a/test/fake_decoder.cc b/test/fake_decoder.cc index 70fe085335..10ac8512cc 100644 --- a/test/fake_decoder.cc +++ b/test/fake_decoder.cc @@ -39,7 +39,6 @@ int32_t FakeDecoder::InitDecode(const VideoCodec* config, int32_t FakeDecoder::Decode(const EncodedImage& input, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t render_time_ms) { if (input._encodedWidth > 0 && input._encodedHeight > 0) { width_ = input._encodedWidth; @@ -77,7 +76,6 @@ const char* FakeDecoder::ImplementationName() const { int32_t FakeH264Decoder::Decode(const EncodedImage& input, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t render_time_ms) { uint8_t value = 0; for (size_t i = 0; i < input.size(); ++i) { @@ -93,8 +91,7 @@ int32_t FakeH264Decoder::Decode(const EncodedImage& input, } ++value; } - return FakeDecoder::Decode(input, missing_frames, codec_specific_info, - render_time_ms); + return FakeDecoder::Decode(input, missing_frames, render_time_ms); } } // namespace test diff --git a/test/fake_decoder.h b/test/fake_decoder.h index 1176feb46c..8fe7427377 100644 --- a/test/fake_decoder.h +++ b/test/fake_decoder.h @@ -31,7 +31,6 @@ class FakeDecoder : public VideoDecoder { int32_t Decode(const EncodedImage& input, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t render_time_ms) override; int32_t RegisterDecodeCompleteCallback( @@ -55,7 +54,6 @@ class FakeH264Decoder : public FakeDecoder { int32_t Decode(const EncodedImage& input, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t render_time_ms) override; }; diff --git a/test/fake_vp8_decoder.cc b/test/fake_vp8_decoder.cc index 7a244ca09d..faaa554259 100644 --- a/test/fake_vp8_decoder.cc +++ b/test/fake_vp8_decoder.cc @@ -46,7 +46,6 @@ int32_t FakeVp8Decoder::InitDecode(const VideoCodec* config, int32_t FakeVp8Decoder::Decode(const EncodedImage& input, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t render_time_ms) { constexpr size_t kMinPayLoadHeaderLength = 10; if (input.size() < kMinPayLoadHeaderLength) { diff --git a/test/fake_vp8_decoder.h b/test/fake_vp8_decoder.h index 36ff3b36d2..4f0fa3d8a9 100644 --- a/test/fake_vp8_decoder.h +++ b/test/fake_vp8_decoder.h @@ -31,7 +31,6 @@ class FakeVp8Decoder : public VideoDecoder { int32_t Decode(const EncodedImage& input, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t render_time_ms) override; int32_t RegisterDecodeCompleteCallback( diff --git a/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.cc b/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.cc index e9161437ba..829418944d 100644 --- a/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.cc +++ b/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.cc @@ -53,7 +53,6 @@ int32_t QualityAnalyzingVideoDecoder::InitDecode( int32_t QualityAnalyzingVideoDecoder::Decode( const EncodedImage& input_image, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t render_time_ms) { // Image extractor extracts id from provided EncodedImage and also returns // the image with the original buffer. Buffer can be modified in place, so @@ -95,8 +94,8 @@ int32_t QualityAnalyzingVideoDecoder::Decode( // the map only after |delegate_| Decode method will be invoked. Image will be // removed inside DecodedImageCallback, which can be done on separate thread. analyzer_->OnFrameReceived(out.id, *origin_image); - int32_t result = delegate_->Decode(*origin_image, missing_frames, - codec_specific_info, render_time_ms); + int32_t result = + delegate_->Decode(*origin_image, missing_frames, render_time_ms); if (result != WEBRTC_VIDEO_CODEC_OK) { // If delegate decoder failed, then cleanup data for this image. { diff --git a/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.h b/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.h index a32393774e..c1ebcaa688 100644 --- a/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.h +++ b/test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.h @@ -63,7 +63,6 @@ class QualityAnalyzingVideoDecoder : public VideoDecoder { int32_t number_of_cores) override; int32_t Decode(const EncodedImage& input_image, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t render_time_ms) override; int32_t RegisterDecodeCompleteCallback( DecodedImageCallback* callback) override; diff --git a/test/video_decoder_proxy_factory.h b/test/video_decoder_proxy_factory.h index 250750cb11..b58c399a86 100644 --- a/test/video_decoder_proxy_factory.h +++ b/test/video_decoder_proxy_factory.h @@ -50,10 +50,8 @@ class VideoDecoderProxyFactory final : public VideoDecoderFactory { private: int32_t Decode(const EncodedImage& input_image, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t render_time_ms) override { - return decoder_->Decode(input_image, missing_frames, codec_specific_info, - render_time_ms); + return decoder_->Decode(input_image, missing_frames, render_time_ms); } int32_t InitDecode(const VideoCodec* config, int32_t number_of_cores) override { diff --git a/video/frame_dumping_decoder.cc b/video/frame_dumping_decoder.cc index f42edce9fc..09cf3e9d75 100644 --- a/video/frame_dumping_decoder.cc +++ b/video/frame_dumping_decoder.cc @@ -26,17 +26,16 @@ FrameDumpingDecoder::~FrameDumpingDecoder() = default; int32_t FrameDumpingDecoder::InitDecode(const VideoCodec* codec_settings, int32_t number_of_cores) { + codec_type_ = codec_settings->codecType; return decoder_->InitDecode(codec_settings, number_of_cores); } int32_t FrameDumpingDecoder::Decode( const EncodedImage& input_image, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t render_time_ms) { - int32_t ret = decoder_->Decode(input_image, missing_frames, - codec_specific_info, render_time_ms); - writer_->WriteFrame(input_image, codec_specific_info->codecType); + int32_t ret = decoder_->Decode(input_image, missing_frames, render_time_ms); + writer_->WriteFrame(input_image, codec_type_); return ret; } diff --git a/video/frame_dumping_decoder.h b/video/frame_dumping_decoder.h index 9f3ed89147..5bb22717dd 100644 --- a/video/frame_dumping_decoder.h +++ b/video/frame_dumping_decoder.h @@ -32,7 +32,6 @@ class FrameDumpingDecoder : public VideoDecoder { int32_t number_of_cores) override; int32_t Decode(const EncodedImage& input_image, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t render_time_ms) override; int32_t RegisterDecodeCompleteCallback( DecodedImageCallback* callback) override; @@ -42,6 +41,7 @@ class FrameDumpingDecoder : public VideoDecoder { private: std::unique_ptr decoder_; + VideoCodecType codec_type_ = VideoCodecType::kVideoCodecGeneric; std::unique_ptr writer_; }; diff --git a/video/video_receive_stream.cc b/video/video_receive_stream.cc index 904e0a509d..6c158dd43f 100644 --- a/video/video_receive_stream.cc +++ b/video/video_receive_stream.cc @@ -102,7 +102,6 @@ class NullVideoDecoder : public webrtc::VideoDecoder { int32_t Decode(const webrtc::EncodedImage& input_image, bool missing_frames, - const webrtc::CodecSpecificInfo* codec_specific_info, int64_t render_time_ms) override { RTC_LOG(LS_ERROR) << "The NullVideoDecoder doesn't support decoding."; return WEBRTC_VIDEO_CODEC_OK; diff --git a/video/video_receive_stream_unittest.cc b/video/video_receive_stream_unittest.cc index 642143a967..84b0302373 100644 --- a/video/video_receive_stream_unittest.cc +++ b/video/video_receive_stream_unittest.cc @@ -50,10 +50,9 @@ class MockVideoDecoder : public VideoDecoder { public: MOCK_METHOD2(InitDecode, int32_t(const VideoCodec* config, int32_t number_of_cores)); - MOCK_METHOD4(Decode, + MOCK_METHOD3(Decode, int32_t(const EncodedImage& input, bool missing_frames, - const CodecSpecificInfo* codec_specific_info, int64_t render_time_ms)); MOCK_METHOD1(RegisterDecodeCompleteCallback, int32_t(DecodedImageCallback* callback)); @@ -141,7 +140,7 @@ TEST_F(VideoReceiveStreamTest, CreateFrameFromH264FmtpSpropAndIdr) { })); EXPECT_CALL(mock_h264_video_decoder_, RegisterDecodeCompleteCallback(_)); video_receive_stream_->Start(); - EXPECT_CALL(mock_h264_video_decoder_, Decode(_, false, _, _)); + EXPECT_CALL(mock_h264_video_decoder_, Decode(_, false, _)); RtpPacketReceived parsed_packet; ASSERT_TRUE(parsed_packet.Parse(rtppacket.data(), rtppacket.size())); rtp_stream_receiver_controller_.OnRtpPacket(parsed_packet);