Use ArrayBufferView input and return Blob

Author: alexchuber

CMakeLists.txt

@@ -36,8 +36,9 @@ FetchContent_Declare(ios-cmake
     GIT_REPOSITORY https://github.com/leetal/ios-cmake.git
     GIT_TAG 4.5.0)
 FetchContent_Declare(JsRuntimeHost
-    GIT_REPOSITORY https://github.com/BabylonJS/JsRuntimeHost.git
-    GIT_TAG ef57990dc5533990b2bb194978a12f8c8d83565c)
+    # TODO: Update with latest upstream once https://github.com/BabylonJS/JsRuntimeHost/pull/120 is in
+    GIT_REPOSITORY https://github.com/alexchuber/JsRuntimeHost.git
+    GIT_TAG 2bf8034be4348bb573cb005671184bf9fdaf9ae3)
 FetchContent_Declare(SPIRV-Cross
     GIT_REPOSITORY https://github.com/BabylonJS/SPIRV-Cross.git
     GIT_TAG 6abfcf066d171e9ade7604d91381ebebe4209edc)

Install/Install.cmake

@@ -187,3 +187,8 @@ if(TARGET XMLHttpRequest)
     install_targets(XMLHttpRequest)
     install_include_for_targets(XMLHttpRequest)
 endif()
+
+if(TARGET Blob)
+    install_targets(Blob)
+    install_include_for_targets(Blob)
+endif()

Plugins/NativeEncoding/CMakeLists.txt

@@ -12,7 +12,8 @@ target_link_libraries(NativeEncoding
     PUBLIC napi
     PRIVATE GraphicsDevice
     PRIVATE GraphicsDeviceContext
-    PRIVATE JsRuntimeInternal)
+    PRIVATE JsRuntimeInternal
+    PRIVATE Blob)
 
 set_property(TARGET NativeEncoding PROPERTY FOLDER Plugins)
 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SOURCES})

Plugins/NativeEncoding/Source/NativeEncoding.cpp

@@ -2,6 +2,7 @@
 #include <Babylon/JsRuntime.h>
 #include <Babylon/JsRuntimeScheduler.h>
 #include <Babylon/Graphics/DeviceContext.h>
+#include <Babylon/Polyfills/Blob.h>
 
 #include <napi/napi.h>
 
@@ -15,7 +16,7 @@ namespace Babylon::Plugins
 {
     namespace
     {
-        std::shared_ptr<std::vector<uint8_t>> EncodePNG(const std::vector<uint8_t>& pixelData, uint32_t width, uint32_t height, bool invertY)
+        std::unique_ptr<std::vector<std::byte>> EncodePNG(const std::vector<uint8_t>& pixelData, uint32_t width, uint32_t height, bool invertY)
         {
             auto memoryBlock{bx::MemoryBlock(&Graphics::DeviceContext::GetDefaultAllocator())};
             auto writer{bx::MemoryWriter(&memoryBlock)};
@@ -35,28 +36,22 @@ namespace Babylon::Plugins
                 throw std::runtime_error("Failed to encode PNG image: output is empty");
             }
 
-            auto result{std::make_shared<std::vector<uint8_t>>(byteLength)};
+            auto result{std::make_unique<std::vector<std::byte>>(byteLength)};
             std::memcpy(result->data(), memoryBlock.more(0), byteLength);
 
             return result;
         }
 
         Napi::Value EncodeImageAsync(const Napi::CallbackInfo& info)
         {
-            auto buffer{info[0].As<Napi::Uint8Array>()};
+            auto buffer{info[0].As<Napi::TypedArray>()}; // ArrayBufferView
             auto width{info[1].As<Napi::Number>().Uint32Value()};
             auto height{info[2].As<Napi::Number>().Uint32Value()};
-            auto mimeType{info[3].As<Napi::String>().Utf8Value()};
-            auto invertY{info[4].As<Napi::Boolean>().Value()};
+            //auto mimeType{info[3].As<Napi::String>().Utf8Value()}; // Discard for now, only PNG is supported
+            auto invertY{info.Length() > 4 && info[4].ToBoolean().Value()};
 
             auto env{info.Env()};
             auto deferred{Napi::Promise::Deferred::New(env)};
-            
-            if (mimeType != "image/png")
-            {
-                deferred.Reject(Napi::Error::New(env, "Unsupported mime type: " + mimeType + ". Only image/png is currently supported.").Value());
-                return deferred.Promise();
-            }
 
             if (buffer.ByteLength() != width * height * 4)
             {
@@ -65,14 +60,15 @@ namespace Babylon::Plugins
             }
 
             auto runtimeScheduler{std::make_shared<JsRuntimeScheduler>(JsRuntime::GetFromJavaScript(env))};
-            auto pixelData{std::vector<uint8_t>(buffer.Data(), buffer.Data() + buffer.ByteLength())};
+            auto start = static_cast<uint8_t*>(buffer.ArrayBuffer().Data()) + buffer.ByteOffset();
+            auto pixelData{std::vector<uint8_t>(start, start + buffer.ByteLength())};
 
             arcana::make_task(arcana::threadpool_scheduler, arcana::cancellation_source::none(),
                 [pixelData{std::move(pixelData)}, width, height, invertY]() {
                     return EncodePNG(pixelData, width, height, invertY);
                 })
                 .then(*runtimeScheduler, arcana::cancellation_source::none(),
-                    [runtimeScheduler, deferred, env](const arcana::expected<std::shared_ptr<std::vector<uint8_t>>, std::exception_ptr>& result) {
+                    [runtimeScheduler, deferred, env](const arcana::expected<std::unique_ptr<std::vector<std::byte>>, std::exception_ptr>& result) {
                         // TODO: Crash risk on JS teardown - this async work isn't tied to any JS object lifetime,
                         // unlike other plugins that cancel / clean up pending work in their destructors.
                         if (result.has_error())
@@ -81,10 +77,9 @@ namespace Babylon::Plugins
                             return;
                         }
 
-                        auto& imageData = result.value();
-                        auto arrayBuffer{Napi::ArrayBuffer::New(env, imageData->data(), imageData->size(), [imageData](Napi::Env, void*) {})};
-                        
-                        deferred.Resolve(arrayBuffer);
+                        auto blob{Babylon::Polyfills::Blob::CreateInstance(env, std::move(*result.value()), "image/png")};
+
+                        deferred.Resolve(blob);
                     });
 
             return deferred.Promise();