partial_circular_buffer.cc 6.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183
  1. // Copyright 2013 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/webrtc_logging/common/partial_circular_buffer.h"
  5. #include <algorithm>
  6. #include <cstring>
  7. #include "base/check_op.h"
  8. namespace webrtc_logging {
  9. PartialCircularBuffer::PartialCircularBuffer(void* buffer, uint32_t buffer_size)
  10. : buffer_data_(reinterpret_cast<BufferData*>(buffer)),
  11. memory_buffer_size_(buffer_size),
  12. data_size_(0),
  13. position_(0),
  14. total_read_(0) {
  15. uint32_t header_size =
  16. buffer_data_->data - reinterpret_cast<uint8_t*>(buffer_data_.get());
  17. data_size_ = memory_buffer_size_ - header_size;
  18. DCHECK(buffer_data_);
  19. DCHECK_GE(memory_buffer_size_, header_size);
  20. DCHECK_LE(buffer_data_->total_written, data_size_);
  21. DCHECK_LT(buffer_data_->wrap_position, data_size_);
  22. DCHECK_LT(buffer_data_->end_position, data_size_);
  23. }
  24. PartialCircularBuffer::PartialCircularBuffer(void* buffer,
  25. uint32_t buffer_size,
  26. uint32_t wrap_position,
  27. bool append)
  28. : buffer_data_(reinterpret_cast<BufferData*>(buffer)),
  29. memory_buffer_size_(buffer_size),
  30. data_size_(0),
  31. position_(0),
  32. total_read_(0) {
  33. uint32_t header_size =
  34. buffer_data_->data - reinterpret_cast<uint8_t*>(buffer_data_.get());
  35. data_size_ = memory_buffer_size_ - header_size;
  36. DCHECK(buffer_data_);
  37. DCHECK_GE(memory_buffer_size_, header_size);
  38. if (append) {
  39. DCHECK_LT(buffer_data_->wrap_position, data_size_);
  40. position_ = buffer_data_->end_position;
  41. } else {
  42. DCHECK_LT(wrap_position, data_size_);
  43. buffer_data_->total_written = 0;
  44. buffer_data_->wrap_position = wrap_position;
  45. buffer_data_->end_position = 0;
  46. }
  47. }
  48. uint32_t PartialCircularBuffer::Read(void* buffer, uint32_t buffer_size) {
  49. DCHECK(buffer_data_);
  50. if (total_read_ >= buffer_data_->total_written)
  51. return 0;
  52. uint8_t* buffer_uint8 = reinterpret_cast<uint8_t*>(buffer);
  53. uint32_t read = 0;
  54. // Read from beginning part.
  55. if (position_ < buffer_data_->wrap_position) {
  56. uint32_t to_wrap_pos = buffer_data_->wrap_position - position_;
  57. uint32_t to_eow = buffer_data_->total_written - total_read_;
  58. uint32_t to_read = std::min({buffer_size, to_wrap_pos, to_eow});
  59. memcpy(buffer_uint8, buffer_data_->data + position_, to_read);
  60. position_ += to_read;
  61. total_read_ += to_read;
  62. read += to_read;
  63. if (position_ == buffer_data_->wrap_position &&
  64. buffer_data_->total_written == data_size_) {
  65. // We've read all the beginning part, set the position to the middle part.
  66. // (The second condition above checks if the wrapping part is filled, i.e.
  67. // writing has wrapped.)
  68. position_ = buffer_data_->end_position;
  69. }
  70. if (read >= buffer_size) {
  71. DCHECK_EQ(read, buffer_size);
  72. return read;
  73. }
  74. if (read >= to_eow) {
  75. DCHECK_EQ(read, to_eow);
  76. DCHECK_EQ(total_read_, buffer_data_->total_written);
  77. return read;
  78. }
  79. }
  80. // Read from middle part.
  81. DCHECK_GE(position_, buffer_data_->wrap_position);
  82. if (position_ >= buffer_data_->end_position) {
  83. uint32_t remaining_buffer_size = buffer_size - read;
  84. uint32_t to_eof = data_size_ - position_;
  85. uint32_t to_eow = buffer_data_->total_written - total_read_;
  86. uint32_t to_read = std::min({remaining_buffer_size, to_eof, to_eow});
  87. memcpy(buffer_uint8 + read, buffer_data_->data + position_, to_read);
  88. position_ += to_read;
  89. total_read_ += to_read;
  90. read += to_read;
  91. if (position_ == data_size_) {
  92. // We've read all the middle part, set position to the end part.
  93. position_ = buffer_data_->wrap_position;
  94. }
  95. if (read >= buffer_size) {
  96. DCHECK_EQ(read, buffer_size);
  97. return read;
  98. }
  99. if (total_read_ >= buffer_data_->total_written) {
  100. DCHECK_EQ(total_read_, buffer_data_->total_written);
  101. return read;
  102. }
  103. }
  104. // Read from end part.
  105. DCHECK_GE(position_, buffer_data_->wrap_position);
  106. DCHECK_LT(position_, buffer_data_->end_position);
  107. uint32_t remaining_buffer_size = buffer_size - read;
  108. uint32_t to_eob = buffer_data_->end_position - position_;
  109. uint32_t to_eow = buffer_data_->total_written - total_read_;
  110. uint32_t to_read = std::min({remaining_buffer_size, to_eob, to_eow});
  111. memcpy(buffer_uint8 + read, buffer_data_->data + position_, to_read);
  112. position_ += to_read;
  113. total_read_ += to_read;
  114. read += to_read;
  115. DCHECK_LE(read, buffer_size);
  116. DCHECK_LE(total_read_, buffer_data_->total_written);
  117. return read;
  118. }
  119. void PartialCircularBuffer::Write(const void* buffer, uint32_t buffer_size) {
  120. DCHECK(buffer_data_);
  121. const uint8_t* input = static_cast<const uint8_t*>(buffer);
  122. uint32_t wrap_position = buffer_data_->wrap_position;
  123. uint32_t cycle_size = data_size_ - wrap_position;
  124. // First write the non-wrapping part.
  125. if (position_ < wrap_position) {
  126. uint32_t space_left = wrap_position - position_;
  127. uint32_t write_size = std::min(buffer_size, space_left);
  128. DoWrite(input, write_size);
  129. input += write_size;
  130. buffer_size -= write_size;
  131. }
  132. // Skip the part that would overlap.
  133. if (buffer_size > cycle_size) {
  134. uint32_t skip = buffer_size - cycle_size;
  135. input += skip;
  136. buffer_size -= skip;
  137. position_ = wrap_position + (position_ - wrap_position + skip) % cycle_size;
  138. }
  139. // Finally write the wrapping part.
  140. DoWrite(input, buffer_size);
  141. }
  142. void PartialCircularBuffer::DoWrite(const uint8_t* input, uint32_t input_size) {
  143. DCHECK_LT(position_, data_size_);
  144. buffer_data_->total_written =
  145. std::min(buffer_data_->total_written + input_size, data_size_);
  146. // Write() skips any overlapping part, so this loop will run at most twice.
  147. while (input_size > 0) {
  148. uint32_t space_left = data_size_ - position_;
  149. uint32_t write_size = std::min(input_size, space_left);
  150. memcpy(buffer_data_->data + position_, input, write_size);
  151. input += write_size;
  152. input_size -= write_size;
  153. position_ += write_size;
  154. if (position_ >= data_size_) {
  155. DCHECK_EQ(position_, data_size_);
  156. position_ = buffer_data_->wrap_position;
  157. }
  158. }
  159. buffer_data_->end_position = position_;
  160. }
  161. } // namespace webrtc_logging