diff --git a/api/video/encoded_frame.cc b/api/video/encoded_frame.cc index 26a794ec02..d36758d3b1 100644 --- a/api/video/encoded_frame.cc +++ b/api/video/encoded_frame.cc @@ -13,6 +13,10 @@ namespace webrtc { namespace video_coding { +bool EncodedFrame::GetBitstream(uint8_t* destination) const { + return false; +} + bool EncodedFrame::delayed_by_retransmission() const { return 0; } diff --git a/api/video/encoded_frame.h b/api/video/encoded_frame.h index b8462c6c2c..841b13b949 100644 --- a/api/video/encoded_frame.h +++ b/api/video/encoded_frame.h @@ -56,7 +56,9 @@ class EncodedFrame : public webrtc::VCMEncodedFrame { EncodedFrame() = default; virtual ~EncodedFrame() {} - virtual bool GetBitstream(uint8_t* destination) const = 0; + // TODO(nisse): Deprecated and unused. Delete method and default + // implementation as soon as downstream overrides are deleted. + virtual bool GetBitstream(uint8_t* destination) const; // When this frame was received. virtual int64_t ReceivedTime() const = 0; diff --git a/modules/video_coding/frame_buffer2_unittest.cc b/modules/video_coding/frame_buffer2_unittest.cc index e10f785279..ca7af09d5f 100644 --- a/modules/video_coding/frame_buffer2_unittest.cc +++ b/modules/video_coding/frame_buffer2_unittest.cc @@ -88,8 +88,6 @@ class VCMJitterEstimatorMock : public VCMJitterEstimator { class FrameObjectFake : public EncodedFrame { public: - bool GetBitstream(uint8_t* destination) const override { return true; } - int64_t ReceivedTime() const override { return 0; } int64_t RenderTime() const override { return _renderTimeMs; } diff --git a/modules/video_coding/frame_object.cc b/modules/video_coding/frame_object.cc index 0172c55493..f0c744988f 100644 --- a/modules/video_coding/frame_object.cc +++ b/modules/video_coding/frame_object.cc @@ -49,7 +49,7 @@ RtpFrameObject::RtpFrameObject(PacketBuffer* packet_buffer, SetPlayoutDelay(first_packet->video_header.playout_delay); AllocateBitstreamBuffer(frame_size); - bool bitstream_copied = GetBitstream(_buffer); + bool bitstream_copied = packet_buffer_->GetBitstream(*this, _buffer); RTC_DCHECK(bitstream_copied); _encodedWidth = first_packet->width; _encodedHeight = first_packet->height; @@ -122,15 +122,6 @@ VideoCodecType RtpFrameObject::codec_type() const { return codec_type_; } -void RtpFrameObject::SetBitstream(rtc::ArrayView bitstream) { - AllocateBitstreamBuffer(bitstream.size()); - memcpy(_buffer, bitstream.data(), _length); -} - -bool RtpFrameObject::GetBitstream(uint8_t* destination) const { - return packet_buffer_->GetBitstream(*this, destination); -} - int64_t RtpFrameObject::ReceivedTime() const { return received_time_; } diff --git a/modules/video_coding/frame_object.h b/modules/video_coding/frame_object.h index efded47427..a65a4b4dd8 100644 --- a/modules/video_coding/frame_object.h +++ b/modules/video_coding/frame_object.h @@ -37,8 +37,6 @@ class RtpFrameObject : public EncodedFrame { int times_nacked() const; enum FrameType frame_type() const; VideoCodecType codec_type() const; - void SetBitstream(rtc::ArrayView bitstream); - bool GetBitstream(uint8_t* destination) const override; int64_t ReceivedTime() const override; int64_t RenderTime() const override; bool delayed_by_retransmission() const override; diff --git a/modules/video_coding/video_packet_buffer_unittest.cc b/modules/video_coding/video_packet_buffer_unittest.cc index 13e64eebab..8e0918ce45 100644 --- a/modules/video_coding/video_packet_buffer_unittest.cc +++ b/modules/video_coding/video_packet_buffer_unittest.cc @@ -434,8 +434,8 @@ TEST_F(TestPacketBuffer, GetBitstream) { memcpy(such, such_data, sizeof(such_data)); memcpy(data, data_data, sizeof(data_data)); - uint8_t result[sizeof(many_data) + sizeof(bitstream_data) + - sizeof(such_data) + sizeof(data_data)]; + const size_t result_length = sizeof(many_data) + sizeof(bitstream_data) + + sizeof(such_data) + sizeof(data_data); const uint16_t seq_num = Rand(); @@ -450,14 +450,14 @@ TEST_F(TestPacketBuffer, GetBitstream) { ASSERT_EQ(1UL, frames_from_callback_.size()); CheckFrame(seq_num); - EXPECT_EQ(frames_from_callback_[seq_num]->size(), sizeof(result)); - EXPECT_TRUE(frames_from_callback_[seq_num]->GetBitstream(result)); - EXPECT_EQ(memcmp(result, "many bitstream, such data", sizeof(result)), 0); + EXPECT_EQ(frames_from_callback_[seq_num]->size(), result_length); + EXPECT_EQ(memcmp(frames_from_callback_[seq_num]->Buffer(), + "many bitstream, such data", result_length), + 0); } TEST_F(TestPacketBuffer, GetBitstreamOneFrameOnePacket) { uint8_t bitstream_data[] = "All the bitstream data for this frame!"; - uint8_t result[sizeof(bitstream_data)]; uint8_t* data = new uint8_t[sizeof(bitstream_data)]; memcpy(data, bitstream_data, sizeof(bitstream_data)); @@ -467,14 +467,14 @@ TEST_F(TestPacketBuffer, GetBitstreamOneFrameOnePacket) { ASSERT_EQ(1UL, frames_from_callback_.size()); CheckFrame(0); EXPECT_EQ(frames_from_callback_[0]->size(), sizeof(bitstream_data)); - EXPECT_TRUE(frames_from_callback_[0]->GetBitstream(result)); - EXPECT_EQ(memcmp(result, data, sizeof(bitstream_data)), 0); + EXPECT_EQ( + memcmp(frames_from_callback_[0]->Buffer(), data, sizeof(bitstream_data)), + 0); } TEST_F(TestPacketBuffer, GetBitstreamOneFrameFullBuffer) { uint8_t* data_arr[kStartSize]; uint8_t expected[kStartSize]; - uint8_t result[kStartSize]; for (uint8_t i = 0; i < kStartSize; ++i) { data_arr[i] = new uint8_t[1]; @@ -491,8 +491,8 @@ TEST_F(TestPacketBuffer, GetBitstreamOneFrameFullBuffer) { ASSERT_EQ(1UL, frames_from_callback_.size()); CheckFrame(0); EXPECT_EQ(frames_from_callback_[0]->size(), static_cast(kStartSize)); - EXPECT_TRUE(frames_from_callback_[0]->GetBitstream(result)); - EXPECT_EQ(memcmp(result, expected, kStartSize), 0); + EXPECT_EQ(memcmp(frames_from_callback_[0]->Buffer(), expected, kStartSize), + 0); } TEST_F(TestPacketBuffer, InsertPacketAfterOldFrameObjectIsRemoved) { @@ -601,7 +601,6 @@ TEST_P(TestPacketBufferH264Parameterized, DontRemoveMissingPacketOnClearTo) { TEST_P(TestPacketBufferH264Parameterized, GetBitstreamOneFrameFullBuffer) { uint8_t* data_arr[kStartSize]; uint8_t expected[kStartSize]; - uint8_t result[kStartSize]; for (uint8_t i = 0; i < kStartSize; ++i) { data_arr[i] = new uint8_t[1]; @@ -620,8 +619,8 @@ TEST_P(TestPacketBufferH264Parameterized, GetBitstreamOneFrameFullBuffer) { ASSERT_EQ(1UL, frames_from_callback_.size()); CheckFrame(0); EXPECT_EQ(frames_from_callback_[0]->size(), static_cast(kStartSize)); - EXPECT_TRUE(frames_from_callback_[0]->GetBitstream(result)); - EXPECT_EQ(memcmp(result, expected, kStartSize), 0); + EXPECT_EQ(memcmp(frames_from_callback_[0]->Buffer(), expected, kStartSize), + 0); } TEST_P(TestPacketBufferH264Parameterized, GetBitstreamBufferPadding) { @@ -630,10 +629,6 @@ TEST_P(TestPacketBufferH264Parameterized, GetBitstreamBufferPadding) { uint8_t* data = new uint8_t[sizeof(data_data)]; memcpy(data, data_data, sizeof(data_data)); - // EncodedImage::kBufferPaddingBytesH264 is unknown at compile time. - std::unique_ptr result( - new uint8_t[sizeof(data_data) + EncodedImage::kBufferPaddingBytesH264]); - VCMPacket packet; auto& h264_header = packet.video_header.video_type_header.emplace(); @@ -654,8 +649,9 @@ TEST_P(TestPacketBufferH264Parameterized, GetBitstreamBufferPadding) { sizeof(data_data)); EXPECT_EQ(frames_from_callback_[seq_num]->EncodedImage()._size, sizeof(data_data) + EncodedImage::kBufferPaddingBytesH264); - EXPECT_TRUE(frames_from_callback_[seq_num]->GetBitstream(result.get())); - EXPECT_EQ(memcmp(result.get(), data, sizeof(data_data)), 0); + EXPECT_EQ( + memcmp(frames_from_callback_[seq_num]->Buffer(), data, sizeof(data_data)), + 0); } TEST_F(TestPacketBuffer, FreeSlotsOnFrameDestruction) { @@ -697,16 +693,6 @@ TEST_F(TestPacketBuffer, Clear) { CheckFrame(seq_num + kStartSize); } -TEST_F(TestPacketBuffer, InvalidateFrameByClearing) { - const uint16_t seq_num = Rand(); - - EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast)); - ASSERT_EQ(1UL, frames_from_callback_.size()); - - packet_buffer_->Clear(); - EXPECT_FALSE(frames_from_callback_.begin()->second->GetBitstream(nullptr)); -} - TEST_F(TestPacketBuffer, FramesAfterClear) { Insert(9025, kDeltaFrame, kFirst, kLast); Insert(9024, kKeyFrame, kFirst, kLast); diff --git a/test/fuzzers/frame_buffer2_fuzzer.cc b/test/fuzzers/frame_buffer2_fuzzer.cc index a5591041ff..6f7c6f6852 100644 --- a/test/fuzzers/frame_buffer2_fuzzer.cc +++ b/test/fuzzers/frame_buffer2_fuzzer.cc @@ -56,7 +56,6 @@ class FuzzyFrameObject : public video_coding::EncodedFrame { FuzzyFrameObject() {} ~FuzzyFrameObject() {} - bool GetBitstream(uint8_t* destination) const override { return false; } int64_t ReceivedTime() const override { return 0; } int64_t RenderTime() const override { return _renderTimeMs; } }; diff --git a/video/rtp_video_stream_receiver_unittest.cc b/video/rtp_video_stream_receiver_unittest.cc index 10c5e7eebc..53c1eb3b70 100644 --- a/video/rtp_video_stream_receiver_unittest.cc +++ b/video/rtp_video_stream_receiver_unittest.cc @@ -80,9 +80,8 @@ class MockOnCompleteFrameCallback DoOnCompleteFrameFailLength(frame.get()); return; } - std::vector actual_data(frame->size()); - frame->GetBitstream(actual_data.data()); - if (memcmp(buffer_.Data(), actual_data.data(), buffer_.Length()) != 0) { + if (frame->Length() != buffer_.Length() || + memcmp(buffer_.Data(), frame->Buffer(), buffer_.Length()) != 0) { DoOnCompleteFrameFailBitstream(frame.get()); return; }