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

Delete method EncodedFrame::GetBitstream, part 1

Browse Source 
Only caller was the RtpFrameObject constructor, so it's
not needed in the interface.

To be able to delete downstream overrides, add a temporary
default implementation. Method will be completely deleted in part 2.

Bug: webrtc:9378
Change-Id: I9083b6284313b6ebce854c6f2cec4617953331d9
Reviewed-on: https://webrtc-review.googlesource.com/c/112128
Reviewed-by: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Åsa Persson <asapersson@webrtc.org>
Reviewed-by: Philip Eliasson <philipel@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#25822}
This commit is contained in:
Niels Möller
2018-11-28 15:14:54 +01:00
committed by Commit Bot
parent 0cc11b4b94
commit 648a7cefe1
8 changed files with 26 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
modules/video_coding/frame_buffer2_unittest.cc
View File

@ -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; }

11
modules/video_coding/frame_object.cc
View File

@ -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<const uint8_t> 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_;
}

2
modules/video_coding/frame_object.h
View File

@ -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<const uint8_t> bitstream);
bool GetBitstream(uint8_t* destination) const override;
int64_t ReceivedTime() const override;
int64_t RenderTime() const override;
bool delayed_by_retransmission() const override;

46
modules/video_coding/video_packet_buffer_unittest.cc
View File

@ -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<size_t>(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<size_t>(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<uint8_t[]> result(
new uint8_t[sizeof(data_data) + EncodedImage::kBufferPaddingBytesH264]);
VCMPacket packet;
auto& h264_header =
packet.video_header.video_type_header.emplace<RTPVideoHeaderH264>();
@ -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);