Use rtc::Buffer for memory storage of EncodedImageBuffer

The goal is to be able to write the rtc::Buffer by another utility
(like rtc::ByteBufferWriter) and pass it into EncodedImageBuffer
without memcpy.

Bug: webrtc:42223344
Change-Id: Ieda55e77a36636e8cdff6ad6b7d078de0aeafec0
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/364243
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#43179}

api/video/BUILD.gn

@@ -158,6 +158,7 @@ rtc_library("encoded_image") {
     "..:refcountedbase",
     "..:rtp_packet_info",
     "..:scoped_refptr",
+    "../../rtc_base:buffer",
     "../../rtc_base:checks",
     "../../rtc_base:refcount",
     "../../rtc_base/system:rtc_export",

api/video/DEPS

@@ -5,6 +5,7 @@ specific_include_rules = {
     "+modules/video_coding/include/video_coding_defines.h",
   ],
   "encoded_image\.h" : [
+    "+rtc_base/buffer.h",
     "+rtc_base/ref_count.h",
   ],
 

api/video/encoded_image.cc

@@ -19,52 +19,47 @@
 #include "api/make_ref_counted.h"
 #include "api/scoped_refptr.h"
 #include "api/units/timestamp.h"
+#include "rtc_base/buffer.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
 
-EncodedImageBuffer::EncodedImageBuffer(size_t size) : size_(size) {
-  buffer_ = static_cast<uint8_t*>(malloc(size));
-}
+EncodedImageBuffer::EncodedImageBuffer(size_t size) : buffer_(size) {}
 
 EncodedImageBuffer::EncodedImageBuffer(const uint8_t* data, size_t size)
-    : EncodedImageBuffer(size) {
-  std::copy_n(data, size, buffer_);
-}
+    : buffer_(data, size) {}
 
-EncodedImageBuffer::~EncodedImageBuffer() {
-  free(buffer_);
-}
+EncodedImageBuffer::EncodedImageBuffer(rtc::Buffer buffer)
+    : buffer_(std::move(buffer)) {}
 
 // static
-rtc::scoped_refptr<EncodedImageBuffer> EncodedImageBuffer::Create(size_t size) {
-  return rtc::make_ref_counted<EncodedImageBuffer>(size);
+scoped_refptr<EncodedImageBuffer> EncodedImageBuffer::Create(size_t size) {
+  return make_ref_counted<EncodedImageBuffer>(size);
 }
 // static
-rtc::scoped_refptr<EncodedImageBuffer> EncodedImageBuffer::Create(
+scoped_refptr<EncodedImageBuffer> EncodedImageBuffer::Create(
     const uint8_t* data,
     size_t size) {
-  return rtc::make_ref_counted<EncodedImageBuffer>(data, size);
+  return make_ref_counted<EncodedImageBuffer>(data, size);
+}
+// static
+scoped_refptr<EncodedImageBuffer> EncodedImageBuffer::Create(
+    rtc::Buffer buffer) {
+  return make_ref_counted<EncodedImageBuffer>(std::move(buffer));
 }
 
 const uint8_t* EncodedImageBuffer::data() const {
-  return buffer_;
+  return buffer_.data();
 }
 uint8_t* EncodedImageBuffer::data() {
-  return buffer_;
+  return buffer_.data();
 }
 size_t EncodedImageBuffer::size() const {
-  return size_;
+  return buffer_.size();
 }
 
 void EncodedImageBuffer::Realloc(size_t size) {
-  // Calling realloc with size == 0 is equivalent to free, and returns nullptr.
-  // Which is confusing on systems where malloc(0) doesn't return a nullptr.
-  // More specifically, it breaks expectations of
-  // VCMSessionInfo::UpdateDataPointers.
-  RTC_DCHECK(size > 0);
-  buffer_ = static_cast<uint8_t*>(realloc(buffer_, size));
-  size_ = size;
+  buffer_.SetSize(size);
 }
 
 EncodedImage::EncodedImage() = default;

api/video/encoded_image.h

@@ -28,6 +28,7 @@
 #include "api/video/video_frame_type.h"
 #include "api/video/video_rotation.h"
 #include "api/video/video_timing.h"
+#include "rtc_base/buffer.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/system/rtc_export.h"
 
@@ -51,10 +52,11 @@ class EncodedImageBufferInterface : public RefCountInterface {
 // Basic implementation of EncodedImageBufferInterface.
 class RTC_EXPORT EncodedImageBuffer : public EncodedImageBufferInterface {
  public:
-  static rtc::scoped_refptr<EncodedImageBuffer> Create() { return Create(0); }
-  static rtc::scoped_refptr<EncodedImageBuffer> Create(size_t size);
-  static rtc::scoped_refptr<EncodedImageBuffer> Create(const uint8_t* data,
-                                                       size_t size);
+  static scoped_refptr<EncodedImageBuffer> Create() { return Create(0); }
+  static scoped_refptr<EncodedImageBuffer> Create(size_t size);
+  static scoped_refptr<EncodedImageBuffer> Create(const uint8_t* data,
+                                                  size_t size);
+  static scoped_refptr<EncodedImageBuffer> Create(rtc::Buffer buffer);
 
   const uint8_t* data() const override;
   uint8_t* data() override;
@@ -64,10 +66,9 @@ class RTC_EXPORT EncodedImageBuffer : public EncodedImageBufferInterface {
  protected:
   explicit EncodedImageBuffer(size_t size);
   EncodedImageBuffer(const uint8_t* data, size_t size);
-  ~EncodedImageBuffer();
+  explicit EncodedImageBuffer(rtc::Buffer buffer);
 
-  size_t size_;
-  uint8_t* buffer_;
+  rtc::Buffer buffer_;
 };
 
 // TODO(bug.webrtc.org/9378): This is a legacy api class, which is slowly being

sdk/objc/unittests/RTCEncodedImage_xctest.mm

@@ -18,7 +18,7 @@
 @implementation RTCEncodedImageTests
 
 - (void)testInitializedWithNativeEncodedImage {
-  const auto encoded_data = webrtc::EncodedImageBuffer::Create();
+  const auto encoded_data = webrtc::EncodedImageBuffer::Create(1);
   webrtc::EncodedImage encoded_image;
   encoded_image.SetEncodedData(encoded_data);
 
@@ -41,7 +41,7 @@
 - (void)testRetainsNativeEncodedImage {
   RTC_OBJC_TYPE(RTCEncodedImage) * encodedImage;
   {
-    const auto encoded_data = webrtc::EncodedImageBuffer::Create();
+    const auto encoded_data = webrtc::EncodedImageBuffer::Create(1);
     webrtc::EncodedImage encoded_image;
     encoded_image.SetEncodedData(encoded_data);
     encodedImage =