mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-13 05:40:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Convert FifoBuffer to new StreamInterface API

Browse source 
Bug: webrtc:14632
Change-Id: Id6d17d0402c5e3a0e24258c7afa38ca34e7ab227
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/283541
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#38640}
This commit is contained in:
Harald Alvestrand 2022-11-16 08:18:35 +00:00 committed by WebRTC LUCI CQ
parent dd4c4068d9
commit 3e0658beec
3 changed files with 78 additions and 64 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
rtc_base/memory/fifo_buffer.cc
View file

@ -49,23 +49,20 @@ StreamState FifoBuffer::GetState() const {
return state_;
}
StreamResult FifoBuffer::Read(void* buffer,
size_t bytes,
size_t* bytes_read,
int* error) {
StreamResult FifoBuffer::Read(rtc::ArrayView<uint8_t> buffer,
size_t& bytes_read,
int& error) {
webrtc::MutexLock lock(&mutex_);
const bool was_writable = data_length_ < buffer_length_;
size_t copy = 0;
StreamResult result = ReadLocked(buffer, bytes, &copy);
StreamResult result = ReadLocked(buffer.data(), buffer.size(), &copy);
if (result == SR_SUCCESS) {
// If read was successful then adjust the read position and number of
// bytes buffered.
read_position_ = (read_position_ + copy) % buffer_length_;
data_length_ -= copy;
if (bytes_read) {
*bytes_read = copy;
}
bytes_read = copy;
// if we were full before, and now we're not, post an event
if (!was_writable && copy > 0) {
@ -75,23 +72,19 @@ StreamResult FifoBuffer::Read(void* buffer,
return result;
}
StreamResult FifoBuffer::Write(const void* buffer,
size_t bytes,
size_t* bytes_written,
int* error) {
StreamResult FifoBuffer::Write(rtc::ArrayView<const uint8_t> buffer,
size_t& bytes_written,
int& error) {
webrtc::MutexLock lock(&mutex_);
const bool was_readable = (data_length_ > 0);
size_t copy = 0;
StreamResult result = WriteLocked(buffer, bytes, &copy);
StreamResult result = WriteLocked(buffer.data(), buffer.size(), &copy);
if (result == SR_SUCCESS) {
// If write was successful then adjust the number of readable bytes.
data_length_ += copy;
if (bytes_written) {
*bytes_written = copy;
}
bytes_written = copy;
// if we didn't have any data to read before, and now we do, post an event
if (!was_readable && copy > 0) {
PostEvent(SE_READ, 0);

14
rtc_base/memory/fifo_buffer.h
View file

@ -37,14 +37,12 @@ class FifoBuffer final : public StreamInterface {
// StreamInterface methods
StreamState GetState() const override;
StreamResult Read(void* buffer,
size_t bytes,
size_t* bytes_read,
int* error) override;
StreamResult Write(const void* buffer,
size_t bytes,
size_t* bytes_written,
int* error) override;
StreamResult Read(rtc::ArrayView<uint8_t> buffer,
size_t& bytes_read,
int& error) override;
StreamResult Write(rtc::ArrayView<const uint8_t> buffer,
size_t& bytes_written,
int& error) override;
void Close() override;
// Seek to a byte offset from the beginning of the stream. Returns false if

101
rtc_base/memory/fifo_buffer_unittest.cc
View file

@ -19,8 +19,8 @@ namespace rtc {
TEST(FifoBufferTest, TestAll) {
rtc::AutoThread main_thread;
const size_t kSize = 16;
const char in[kSize * 2 + 1] = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
char out[kSize * 2];
const uint8_t in[kSize * 2 + 1] = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
uint8_t out[kSize * 2];
void* p;
const void* q;
size_t bytes;
@ -28,49 +28,58 @@ TEST(FifoBufferTest, TestAll) {
// Test assumptions about base state
EXPECT_EQ(SS_OPEN, buf.GetState());
EXPECT_EQ(SR_BLOCK, buf.Read(out, kSize, &bytes, nullptr));
int error;
EXPECT_EQ(SR_BLOCK, buf.Read(rtc::MakeArrayView(out, kSize), bytes, error));
EXPECT_TRUE(nullptr != buf.GetWriteBuffer(&bytes));
EXPECT_EQ(kSize, bytes);
buf.ConsumeWriteBuffer(0);
// Try a full write
EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS, buf.Write(rtc::MakeArrayView(in, kSize), bytes, error));
EXPECT_EQ(kSize, bytes);
// Try a write that should block
EXPECT_EQ(SR_BLOCK, buf.Write(in, kSize, &bytes, nullptr));
EXPECT_EQ(SR_BLOCK, buf.Write(rtc::MakeArrayView(in, kSize), bytes, error));
// Try a full read
EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS, buf.Read(rtc::MakeArrayView(out, kSize), bytes, error));
EXPECT_EQ(kSize, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize));
// Try a read that should block
EXPECT_EQ(SR_BLOCK, buf.Read(out, kSize, &bytes, nullptr));
EXPECT_EQ(SR_BLOCK, buf.Read(rtc::MakeArrayView(out, kSize), bytes, error));
// Try a too-big write
EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize * 2, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS,
buf.Write(rtc::MakeArrayView(in, kSize * 2), bytes, error));
EXPECT_EQ(bytes, kSize);
// Try a too-big read
EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize * 2, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS,
buf.Read(rtc::MakeArrayView(out, kSize * 2), bytes, error));
EXPECT_EQ(kSize, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize));
// Try some small writes and reads
EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS,
buf.Write(rtc::MakeArrayView(in, kSize / 2), bytes, error));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS,
buf.Read(rtc::MakeArrayView(out, kSize / 2), bytes, error));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize / 2));
EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS,
buf.Write(rtc::MakeArrayView(in, kSize / 2), bytes, error));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS,
buf.Write(rtc::MakeArrayView(in, kSize / 2), bytes, error));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS,
buf.Read(rtc::MakeArrayView(out, kSize / 2), bytes, error));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize / 2));
EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS,
buf.Read(rtc::MakeArrayView(out, kSize / 2), bytes, error));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize / 2));
@ -82,22 +91,29 @@ TEST(FifoBufferTest, TestAll) {
// XXXXWWWWWWWWXXXX 4567012345670123
// RRRRXXXXXXXXRRRR ....01234567....
// ....RRRRRRRR.... ................
EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize * 3 / 4, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS,
buf.Write(rtc::MakeArrayView(in, kSize * 3 / 4), bytes, error));
EXPECT_EQ(kSize * 3 / 4, bytes);
EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS,
buf.Read(rtc::MakeArrayView(out, kSize / 2), bytes, error));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize / 2));
EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS,
buf.Write(rtc::MakeArrayView(in, kSize / 2), bytes, error));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 4, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS,
buf.Read(rtc::MakeArrayView(out, kSize / 4), bytes, error));
EXPECT_EQ(kSize / 4, bytes);
EXPECT_EQ(0, memcmp(in + kSize / 2, out, kSize / 4));
EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS,
buf.Write(rtc::MakeArrayView(in, kSize / 2), bytes, error));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS,
buf.Read(rtc::MakeArrayView(out, kSize / 2), bytes, error));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize / 2));
EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS,
buf.Read(rtc::MakeArrayView(out, kSize / 2), bytes, error));
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize / 2));
@ -106,16 +122,16 @@ TEST(FifoBufferTest, TestAll) {
buf.ConsumeWriteBuffer(0);
// Try using GetReadData to do a full read
EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS, buf.Write(rtc::MakeArrayView(in, kSize), bytes, error));
q = buf.GetReadData(&bytes);
EXPECT_TRUE(nullptr != q);
EXPECT_EQ(kSize, bytes);
EXPECT_EQ(0, memcmp(q, in, kSize));
buf.ConsumeReadData(kSize);
EXPECT_EQ(SR_BLOCK, buf.Read(out, kSize, &bytes, nullptr));
EXPECT_EQ(SR_BLOCK, buf.Read(rtc::MakeArrayView(out, kSize), bytes, error));
// Try using GetReadData to do some small reads
EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS, buf.Write(rtc::MakeArrayView(in, kSize), bytes, error));
q = buf.GetReadData(&bytes);
EXPECT_TRUE(nullptr != q);
EXPECT_EQ(kSize, bytes);
@ -126,7 +142,7 @@ TEST(FifoBufferTest, TestAll) {
EXPECT_EQ(kSize / 2, bytes);
EXPECT_EQ(0, memcmp(q, in + kSize / 2, kSize / 2));
buf.ConsumeReadData(kSize / 2);
EXPECT_EQ(SR_BLOCK, buf.Read(out, kSize, &bytes, nullptr));
EXPECT_EQ(SR_BLOCK, buf.Read(rtc::MakeArrayView(out, kSize), bytes, error));
// Try using GetReadData in a wraparound case
// WWWWWWWWWWWWWWWW 0123456789ABCDEF
@ -134,9 +150,11 @@ TEST(FifoBufferTest, TestAll) {
// WWWWWWWW....XXXX 01234567....CDEF
// ............RRRR 01234567........
// RRRRRRRR........ ................
EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize * 3 / 4, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS, buf.Write(rtc::MakeArrayView(in, kSize), bytes, error));
EXPECT_EQ(SR_SUCCESS,
buf.Read(rtc::MakeArrayView(out, kSize * 3 / 4), bytes, error));
EXPECT_EQ(SR_SUCCESS,
buf.Write(rtc::MakeArrayView(in, kSize / 2), bytes, error));
q = buf.GetReadData(&bytes);
EXPECT_TRUE(nullptr != q);
EXPECT_EQ(kSize / 4, bytes);
@ -158,7 +176,7 @@ TEST(FifoBufferTest, TestAll) {
EXPECT_EQ(kSize, bytes);
memcpy(p, in, kSize);
buf.ConsumeWriteBuffer(kSize);
EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS, buf.Read(rtc::MakeArrayView(out, kSize), bytes, error));
EXPECT_EQ(kSize, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize));
@ -173,7 +191,7 @@ TEST(FifoBufferTest, TestAll) {
EXPECT_EQ(kSize / 2, bytes);
memcpy(p, in + kSize / 2, kSize / 2);
buf.ConsumeWriteBuffer(kSize / 2);
EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS, buf.Read(rtc::MakeArrayView(out, kSize), bytes, error));
EXPECT_EQ(kSize, bytes);
EXPECT_EQ(0, memcmp(in, out, kSize));
@ -183,8 +201,10 @@ TEST(FifoBufferTest, TestAll) {
// ........XXXXWWWW ........89AB0123
// WWWW....XXXXXXXX 4567....89AB0123
// RRRR....RRRRRRRR ................
EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize * 3 / 4, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS,
buf.Write(rtc::MakeArrayView(in, kSize * 3 / 4), bytes, error));
EXPECT_EQ(SR_SUCCESS,
buf.Read(rtc::MakeArrayView(out, kSize / 2), bytes, error));
p = buf.GetWriteBuffer(&bytes);
EXPECT_TRUE(nullptr != p);
EXPECT_EQ(kSize / 4, bytes);
@ -195,22 +215,25 @@ TEST(FifoBufferTest, TestAll) {
EXPECT_EQ(kSize / 2, bytes);
memcpy(p, in + kSize / 4, kSize / 4);
buf.ConsumeWriteBuffer(kSize / 4);
EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize * 3 / 4, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS,
buf.Read(rtc::MakeArrayView(out, kSize * 3 / 4), bytes, error));
EXPECT_EQ(kSize * 3 / 4, bytes);
EXPECT_EQ(0, memcmp(in + kSize / 2, out, kSize / 4));
EXPECT_EQ(0, memcmp(in, out + kSize / 4, kSize / 4));
// Check that the stream is now empty
EXPECT_EQ(SR_BLOCK, buf.Read(out, kSize, &bytes, nullptr));
EXPECT_EQ(SR_BLOCK, buf.Read(rtc::MakeArrayView(out, kSize), bytes, error));
// Write to the stream, close it, read the remaining bytes
EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS,
buf.Write(rtc::MakeArrayView(in, kSize / 2), bytes, error));
buf.Close();
EXPECT_EQ(SS_CLOSED, buf.GetState());
EXPECT_EQ(SR_EOS, buf.Write(in, kSize / 2, &bytes, nullptr));
EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
EXPECT_EQ(SR_EOS, buf.Write(rtc::MakeArrayView(in, kSize / 2), bytes, error));
EXPECT_EQ(SR_SUCCESS,
buf.Read(rtc::MakeArrayView(out, kSize / 2), bytes, error));
EXPECT_EQ(0, memcmp(in, out, kSize / 2));
EXPECT_EQ(SR_EOS, buf.Read(out, kSize / 2, &bytes, nullptr));
EXPECT_EQ(SR_EOS, buf.Read(rtc::MakeArrayView(out, kSize / 2), bytes, error));
}
TEST(FifoBufferTest, FullBufferCheck) {