chore: Extract make owning buffer (software-mansion#604)

## Description

Adding constructors to `OwningArrayBuffer` that accept data via pointer
or vector.

### Introduces a breaking change?

- [ ] Yes
- [x] No

### Type of change

- [ ] Bug fix (change which fixes an issue)
- [ ] New feature (change which adds functionality)
- [ ] Documentation update (improves or adds clarity to existing
documentation)
- [x] Other (chores, tests, code style improvements etc.)

### Tested on

- [ ] iOS
- [x] Android

### Testing instructions

<!-- Provide step-by-step instructions on how to test your changes.
Include setup details if necessary. -->

### Screenshots

<!-- Add screenshots here, if applicable -->

### Related issues

Closes software-mansion#584

### Checklist

- [x] I have performed a self-review of my code
- [x] I have commented my code, particularly in hard-to-understand areas
- [ ] I have updated the documentation accordingly
- [x] My changes generate no new warnings

### Additional notes

<!-- Include any additional information, assumptions, or context that
reviewers might need to understand this PR. -->

Author: a-szymanska

packages/react-native-executorch/common/rnexecutorch/jsi/OwningArrayBuffer.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <jsi/jsi.h>
+#include <vector>
 
 namespace rnexecutorch {
 
@@ -19,8 +20,24 @@ using namespace facebook;
  */
 class OwningArrayBuffer : public jsi::MutableBuffer {
 public:
-  OwningArrayBuffer(const size_t size) : size_(size) {
-    data_ = new uint8_t[size];
+  /**
+   * @param size Size of the buffer in bytes.
+   */
+  OwningArrayBuffer(size_t size) : size_(size) {
+    data_ = new uint8_t[size_];
+  }
+  /**
+   * @param data Pointer to the source data.
+   * @param size Size of the data in bytes.
+   */
+  OwningArrayBuffer(const auto &data, size_t size) : size_(size) {
+    data_ = new uint8_t[size_];
+    std::memcpy(data_, data, size_);
+  }
+  template <typename T>
+  OwningArrayBuffer(const std::vector<T> &vec) : size_(vec.size() * sizeof(T)) {
+    data_ = new uint8_t[size_];
+    std::memcpy(data_, vec.data(), size_);
   }
   ~OwningArrayBuffer() override { delete[] data_; }
 

packages/react-native-executorch/common/rnexecutorch/models/BaseModel.cpp

@@ -126,8 +126,8 @@ BaseModel::forwardJS(std::vector<JSTensorViewIn> tensorViewVec) {
     auto &outputTensor = outputs[i].toTensor();
     std::vector<int32_t> sizes = getTensorShape(outputTensor);
     size_t bufferSize = outputTensor.numel() * outputTensor.element_size();
-    auto buffer = std::make_shared<OwningArrayBuffer>(bufferSize);
-    std::memcpy(buffer->data(), outputTensor.const_data_ptr(), bufferSize);
+    auto buffer = std::make_shared<OwningArrayBuffer>(
+        outputTensor.const_data_ptr(), bufferSize);
     auto jsTensor = JSTensorViewOut(sizes, outputTensor.scalar_type(), buffer);
     output.emplace_back(jsTensor);
   }

packages/react-native-executorch/common/rnexecutorch/models/embeddings/BaseEmbeddings.cpp

@@ -11,17 +11,9 @@ BaseEmbeddings::BaseEmbeddings(const std::string &modelSource,
 std::shared_ptr<OwningArrayBuffer>
 BaseEmbeddings::postprocess(const Result<std::vector<EValue>> &forwardResult) {
   auto forwardResultTensor = forwardResult->at(0).toTensor();
-  auto dataPtr = forwardResultTensor.mutable_data_ptr();
-  auto outputNumel = forwardResultTensor.numel();
-
-  std::span<float> modelOutput(static_cast<float *>(dataPtr), outputNumel);
-
-  auto createBuffer = [](const auto &data, size_t size) {
-    auto buffer = std::make_shared<OwningArrayBuffer>(size);
-    std::memcpy(buffer->data(), data, size);
-    return buffer;
-  };
-  return createBuffer(modelOutput.data(), modelOutput.size_bytes());
+  auto buffer = std::make_shared<OwningArrayBuffer>(
+      forwardResultTensor.const_data_ptr(), forwardResultTensor.nbytes());
+  return buffer;
 }
 
 } // namespace rnexecutorch::models::embeddings

packages/react-native-executorch/common/rnexecutorch/models/image_segmentation/ImageSegmentation.cpp

@@ -62,11 +62,9 @@ std::shared_ptr<jsi::Object> ImageSegmentation::postprocess(
   std::vector<std::shared_ptr<OwningArrayBuffer>> resultClasses;
   resultClasses.reserve(numClasses);
   for (std::size_t cl = 0; cl < numClasses; ++cl) {
-    auto classBuffer =
-        std::make_shared<OwningArrayBuffer>(numModelPixels * sizeof(float));
+    auto classBuffer = std::make_shared<OwningArrayBuffer>(
+        &resultData[cl * numModelPixels], numModelPixels * sizeof(float));
     resultClasses.push_back(classBuffer);
-    std::memcpy(classBuffer->data(), &resultData[cl * numModelPixels],
-                numModelPixels * sizeof(float));
   }
 
   // Apply softmax per each pixel across all classes
@@ -112,18 +110,14 @@ std::shared_ptr<jsi::Object> ImageSegmentation::postprocess(
     cv::Mat argmaxMat(modelImageSize, CV_32SC1, argmax->data());
     cv::resize(argmaxMat, argmaxMat, originalSize, 0, 0,
                cv::InterpolationFlags::INTER_NEAREST);
-    argmax = std::make_shared<OwningArrayBuffer>(originalSize.area() *
-                                                 sizeof(int32_t));
-    std::memcpy(argmax->data(), argmaxMat.data,
-                originalSize.area() * sizeof(int32_t));
+    argmax = std::make_shared<OwningArrayBuffer>(
+        argmaxMat.data, originalSize.area() * sizeof(int32_t));
 
     for (auto &[label, arrayBuffer] : *buffersToReturn) {
       cv::Mat classMat(modelImageSize, CV_32FC1, arrayBuffer->data());
       cv::resize(classMat, classMat, originalSize);
-      arrayBuffer = std::make_shared<OwningArrayBuffer>(originalSize.area() *
-                                                        sizeof(float));
-      std::memcpy(arrayBuffer->data(), classMat.data,
-                  originalSize.area() * sizeof(float));
+      arrayBuffer = std::make_shared<OwningArrayBuffer>(
+          classMat.data, originalSize.area() * sizeof(float));
     }
   }
   return populateDictionary(argmax, buffersToReturn);

packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/SpeechToText.cpp

@@ -31,14 +31,14 @@ void SpeechToText::unload() noexcept {
 std::shared_ptr<OwningArrayBuffer>
 SpeechToText::encode(std::span<float> waveform) const {
   std::vector<float> encoderOutput = this->asr->encode(waveform);
-  return this->makeOwningBuffer(encoderOutput);
+  return std::make_shared<OwningArrayBuffer>(encoderOutput);
 }
 
 std::shared_ptr<OwningArrayBuffer>
 SpeechToText::decode(std::span<int32_t> tokens,
                      std::span<float> encoderOutput) const {
   std::vector<float> decoderOutput = this->asr->decode(tokens, encoderOutput);
-  return this->makeOwningBuffer(decoderOutput);
+  return std::make_shared<OwningArrayBuffer>(decoderOutput);
 }
 
 std::string SpeechToText::transcribe(std::span<float> waveform,
@@ -68,15 +68,6 @@ size_t SpeechToText::getMemoryLowerBound() const noexcept {
          this->decoder->getMemoryLowerBound();
 }
 
-std::shared_ptr<OwningArrayBuffer>
-SpeechToText::makeOwningBuffer(std::span<const float> vectorView) const {
-  auto owningArrayBuffer =
-      std::make_shared<OwningArrayBuffer>(vectorView.size_bytes());
-  std::memcpy(owningArrayBuffer->data(), vectorView.data(),
-              vectorView.size_bytes());
-  return owningArrayBuffer;
-}
-
 void SpeechToText::stream(std::shared_ptr<jsi::Function> callback,
                           std::string languageOption) {
   if (this->isStreaming) {

packages/react-native-executorch/common/rnexecutorch/models/speech_to_text/SpeechToText.h

@@ -34,9 +34,6 @@ class SpeechToText {
   std::unique_ptr<TokenizerModule> tokenizer;
   std::unique_ptr<asr::ASR> asr;
 
-  std::shared_ptr<OwningArrayBuffer>
-  makeOwningBuffer(std::span<const float> vectorView) const;
-
   // Stream
   std::shared_ptr<react::CallInvoker> callInvoker;
   std::unique_ptr<stream::OnlineASRProcessor> processor;