@shopify/react-native-skia 2.4.18 → 2.4.19

package/cpp/jsi2/Promise.h

@@ -1,10 +1,10 @@
 #pragma once
 
 #include <jsi/jsi.h>
+#include <memory>
+#include <string>
 #include <utility>
 #include <vector>
-#include <string>
-#include <memory>
 
 namespace rnwgpu {
 
@@ -12,24 +12,26 @@ namespace jsi = facebook::jsi;
 
 class Promise {
 public:
-  Promise(jsi::Runtime& runtime, jsi::Function&& resolver, jsi::Function&& rejecter);
+  Promise(jsi::Runtime &runtime, jsi::Function &&resolver,
+          jsi::Function &&rejecter);
 
-  void resolve(jsi::Value&& result);
+  void resolve(jsi::Value &&result);
   void reject(std::string error);
 
 public:
-  jsi::Runtime& runtime;
+  jsi::Runtime &runtime;
 
 private:
   jsi::Function _resolver;
   jsi::Function _rejecter;
 
 public:
-  using RunPromise = std::function<void(jsi::Runtime& runtime, std::shared_ptr<Promise> promise)>;
+  using RunPromise = std::function<void(jsi::Runtime &runtime,
+                                        std::shared_ptr<Promise> promise)>;
   /**
    Create a new Promise and runs the given `run` function.
    */
-  static jsi::Value createPromise(jsi::Runtime& runtime, RunPromise run);
+  static jsi::Value createPromise(jsi::Runtime &runtime, RunPromise run);
 };
 
 } // namespace rnwgpu

package/cpp/rnskia/RNDawnContext.h

@@ -175,20 +175,15 @@ public:
   }
 
   // Get the wgpu::Instance for WebGPU bindings
-  wgpu::Instance getWGPUInstance() {
-    return wgpu::Instance(instance->Get());
-  }
+  wgpu::Instance getWGPUInstance() { return wgpu::Instance(instance->Get()); }
 
   // Get the wgpu::Device for WebGPU bindings
-  wgpu::Device getWGPUDevice() {
-    return backendContext.fDevice;
-  }
+  wgpu::Device getWGPUDevice() { return backendContext.fDevice; }
 
   // Create an SkImage from a WebGPU texture
   // The texture must have TextureBinding usage
   sk_sp<SkImage> MakeImageFromTexture(wgpu::Texture texture, int width,
-                                      int height,
-                                      wgpu::TextureFormat format) {
+                                      int height, wgpu::TextureFormat format) {
     if (!texture) {
       return nullptr;
     }

package/cpp/rnskia/RNSkManager.cpp

@@ -77,16 +77,21 @@ void RNSkManager::installBindings() {
   rnwgpu::GPU::installConstructor(*_jsRuntime);
   // Create and expose navigator.gpu using DawnContext's instance
   auto &dawnContext = DawnContext::getInstance();
-  auto gpu = std::make_shared<rnwgpu::GPU>(*_jsRuntime, dawnContext.getWGPUInstance());
-  auto navigatorValue = _jsRuntime->global().getProperty(*_jsRuntime, "navigator");
+  auto gpu =
+      std::make_shared<rnwgpu::GPU>(*_jsRuntime, dawnContext.getWGPUInstance());
+  auto navigatorValue =
+      _jsRuntime->global().getProperty(*_jsRuntime, "navigator");
   if (navigatorValue.isObject()) {
     auto navigator = navigatorValue.asObject(*_jsRuntime);
-    navigator.setProperty(*_jsRuntime, "gpu", rnwgpu::GPU::create(*_jsRuntime, gpu));
+    navigator.setProperty(*_jsRuntime, "gpu",
+                          rnwgpu::GPU::create(*_jsRuntime, gpu));
   } else {
     // Create navigator object if it doesn't exist
     jsi::Object navigator(*_jsRuntime);
-    navigator.setProperty(*_jsRuntime, "gpu", rnwgpu::GPU::create(*_jsRuntime, gpu));
-    _jsRuntime->global().setProperty(*_jsRuntime, "navigator", std::move(navigator));
+    navigator.setProperty(*_jsRuntime, "gpu",
+                          rnwgpu::GPU::create(*_jsRuntime, gpu));
+    _jsRuntime->global().setProperty(*_jsRuntime, "navigator",
+                                     std::move(navigator));
   }
 
   // Install WebGPU constant objects as plain JS objects
@@ -98,8 +103,9 @@ void RNSkManager::installBindings() {
                                    rnwgpu::GPUMapMode::create(*_jsRuntime));
   _jsRuntime->global().setProperty(*_jsRuntime, "GPUShaderStage",
                                    rnwgpu::GPUShaderStage::create(*_jsRuntime));
-  _jsRuntime->global().setProperty(*_jsRuntime, "GPUTextureUsage",
-                                   rnwgpu::GPUTextureUsage::create(*_jsRuntime));
+  _jsRuntime->global().setProperty(
+      *_jsRuntime, "GPUTextureUsage",
+      rnwgpu::GPUTextureUsage::create(*_jsRuntime));
 #endif
 }
 } // namespace RNSkia

package/cpp/rnskia/RNSkVideo.h

@@ -17,12 +17,15 @@ public:
   virtual sk_sp<SkImage> nextImage(double *timeStamp = nullptr) = 0;
   virtual double duration() = 0;
   virtual double framerate() = 0;
+  virtual double currentTime() = 0;
   virtual void seek(double timestamp) = 0;
   virtual float getRotationInDegrees() = 0;
   virtual SkISize getSize() = 0;
   virtual void play() = 0;
   virtual void pause() = 0;
   virtual void setVolume(float volume) = 0;
+  virtual void setLooping(bool looping) = 0;
+  virtual bool isPlaying() = 0;
 };
 
 } // namespace RNSkia

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -41,8 +41,7 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
         }
         std::string msg =
             message.length ? std::string(message.data, message.length) : "";
-        fprintf(stderr, "GPU Device Lost (%s): %s\n", lostReason,
-                             msg.c_str());
+        fprintf(stderr, "GPU Device Lost (%s): %s\n", lostReason, msg.c_str());
         if (auto deviceHost = deviceLostBinding->lock()) {
           deviceHost->notifyDeviceLost(reason, std::move(msg));
         }
@@ -103,36 +102,36 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
                 return;
               }
 
-              device.SetLoggingCallback([creationRuntime](
-                                            wgpu::LoggingType type,
-                                            wgpu::StringView msg) {
-                if (creationRuntime == nullptr) {
-                  return;
-                }
-                const char *logLevel = "";
-                switch (type) {
-                case wgpu::LoggingType::Warning:
-                  logLevel = "Warning";
-                  fprintf(stderr, "WebGPU Warning: %.*s\n",
-                          static_cast<int>(msg.length), msg.data);
-                  break;
-                case wgpu::LoggingType::Error:
-                  logLevel = "Error";
-                  fprintf(stderr, "WebGPU Error: %.*s\n",
-                          static_cast<int>(msg.length), msg.data);
-                  break;
-                case wgpu::LoggingType::Verbose:
-                  logLevel = "Verbose";
-                  break;
-                case wgpu::LoggingType::Info:
-                  logLevel = "Info";
-                  break;
-                default:
-                  logLevel = "Unknown";
-                  fprintf(stderr, "%s: %.*s\n", logLevel,
-                          static_cast<int>(msg.length), msg.data);
-                }
-              });
+              device.SetLoggingCallback(
+                  [creationRuntime](wgpu::LoggingType type,
+                                    wgpu::StringView msg) {
+                    if (creationRuntime == nullptr) {
+                      return;
+                    }
+                    const char *logLevel = "";
+                    switch (type) {
+                    case wgpu::LoggingType::Warning:
+                      logLevel = "Warning";
+                      fprintf(stderr, "WebGPU Warning: %.*s\n",
+                              static_cast<int>(msg.length), msg.data);
+                      break;
+                    case wgpu::LoggingType::Error:
+                      logLevel = "Error";
+                      fprintf(stderr, "WebGPU Error: %.*s\n",
+                              static_cast<int>(msg.length), msg.data);
+                      break;
+                    case wgpu::LoggingType::Verbose:
+                      logLevel = "Verbose";
+                      break;
+                    case wgpu::LoggingType::Info:
+                      logLevel = "Info";
+                      break;
+                    default:
+                      logLevel = "Unknown";
+                      fprintf(stderr, "%s: %.*s\n", logLevel,
+                              static_cast<int>(msg.length), msg.data);
+                    }
+                  });
 
               auto deviceHost = std::make_shared<GPUDevice>(std::move(device),
                                                             asyncRunner, label);

package/cpp/rnwgpu/api/GPUAdapter.h

@@ -15,8 +15,8 @@
 
 #include "GPUAdapterInfo.h"
 #include "GPUDevice.h"
-#include "descriptors/GPUDeviceDescriptor.h"
 #include "GPUSupportedLimits.h"
+#include "descriptors/GPUDeviceDescriptor.h"
 
 namespace rnwgpu {
 

package/cpp/rnwgpu/api/GPUBuffer.cpp

@@ -12,14 +12,14 @@ GPUBuffer::getMappedRange(std::optional<size_t> o, std::optional<size_t> size) {
   auto offset = o.value_or(0);
   uint64_t s = size.has_value() ? size.value() : (_instance.GetSize() - offset);
 
-  //uint64_t start = offset;
-  //uint64_t end = offset + s;
-  // for (auto& mapping : mappings_) {
-  //     if (mapping.Intersects(start, end)) {
-  //         Errors::OperationError(env).ThrowAsJavaScriptException();
-  //         return {};
-  //     }
-  // }
+  // uint64_t start = offset;
+  // uint64_t end = offset + s;
+  //  for (auto& mapping : mappings_) {
+  //      if (mapping.Intersects(start, end)) {
+  //          Errors::OperationError(env).ThrowAsJavaScriptException();
+  //          return {};
+  //      }
+  //  }
 
   auto *ptr =
       (_instance.GetUsage() & wgpu::BufferUsage::MapWrite)

package/cpp/rnwgpu/api/GPUCommandEncoder.h

@@ -11,15 +11,15 @@
 
 #include "GPUBuffer.h"
 #include "GPUCommandBuffer.h"
-#include "descriptors/GPUCommandBufferDescriptor.h"
-#include "descriptors/GPUComputePassDescriptor.h"
 #include "GPUComputePassEncoder.h"
 #include "GPUExtent3D.h"
+#include "GPUQuerySet.h"
+#include "GPURenderPassEncoder.h"
+#include "descriptors/GPUCommandBufferDescriptor.h"
+#include "descriptors/GPUComputePassDescriptor.h"
 #include "descriptors/GPUImageCopyBuffer.h"
 #include "descriptors/GPUImageCopyTexture.h"
-#include "GPUQuerySet.h"
 #include "descriptors/GPURenderPassDescriptor.h"
-#include "GPURenderPassEncoder.h"
 
 namespace rnwgpu {
 

package/cpp/rnwgpu/api/GPUDevice.h

@@ -17,34 +17,34 @@
 #include "webgpu/webgpu_cpp.h"
 
 #include "GPUBindGroup.h"
-#include "descriptors/GPUBindGroupDescriptor.h"
 #include "GPUBindGroupLayout.h"
-#include "descriptors/GPUBindGroupLayoutDescriptor.h"
 #include "GPUBuffer.h"
-#include "descriptors/GPUBufferDescriptor.h"
 #include "GPUCommandEncoder.h"
-#include "descriptors/GPUCommandEncoderDescriptor.h"
 #include "GPUComputePipeline.h"
-#include "descriptors/GPUComputePipelineDescriptor.h"
 #include "GPUDeviceLostInfo.h"
 #include "GPUError.h"
 #include "GPUExternalTexture.h"
-#include "descriptors/GPUExternalTextureDescriptor.h"
 #include "GPUPipelineLayout.h"
-#include "descriptors/GPUPipelineLayoutDescriptor.h"
 #include "GPUQuerySet.h"
-#include "descriptors/GPUQuerySetDescriptor.h"
 #include "GPUQueue.h"
 #include "GPURenderBundleEncoder.h"
-#include "descriptors/GPURenderBundleEncoderDescriptor.h"
 #include "GPURenderPipeline.h"
-#include "descriptors/GPURenderPipelineDescriptor.h"
 #include "GPUSampler.h"
-#include "descriptors/GPUSamplerDescriptor.h"
 #include "GPUShaderModule.h"
-#include "descriptors/GPUShaderModuleDescriptor.h"
 #include "GPUSupportedLimits.h"
 #include "GPUTexture.h"
+#include "descriptors/GPUBindGroupDescriptor.h"
+#include "descriptors/GPUBindGroupLayoutDescriptor.h"
+#include "descriptors/GPUBufferDescriptor.h"
+#include "descriptors/GPUCommandEncoderDescriptor.h"
+#include "descriptors/GPUComputePipelineDescriptor.h"
+#include "descriptors/GPUExternalTextureDescriptor.h"
+#include "descriptors/GPUPipelineLayoutDescriptor.h"
+#include "descriptors/GPUQuerySetDescriptor.h"
+#include "descriptors/GPURenderBundleEncoderDescriptor.h"
+#include "descriptors/GPURenderPipelineDescriptor.h"
+#include "descriptors/GPUSamplerDescriptor.h"
+#include "descriptors/GPUShaderModuleDescriptor.h"
 #include "descriptors/GPUTextureDescriptor.h"
 
 namespace rnwgpu {

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -103,50 +103,51 @@ void GPUQueue::copyExternalImageToTexture(
     std::shared_ptr<GPUImageCopyExternalImage> source,
     std::shared_ptr<GPUImageCopyTextureTagged> destination,
     std::shared_ptr<GPUExtent3D> size) {
-//  wgpu::TexelCopyTextureInfo dst{};
-//  wgpu::TexelCopyBufferLayout layout{};
-//  wgpu::Extent3D sz{};
-//  Convertor conv;
-//  uint32_t bytesPerPixel =
-//      source->source->getSize() /
-//      (source->source->getWidth() * source->source->getHeight());
-//  auto dataLayout = std::make_shared<GPUImageDataLayout>(GPUImageDataLayout{
-//      std::optional<double>{0.0},
-//      std::optional<double>{
-//          static_cast<double>(bytesPerPixel * source->source->getWidth())},
-//      std::optional<double>{static_cast<double>(source->source->getHeight())}});
-//  if (!conv(dst.aspect, destination->aspect) ||
-//      !conv(dst.mipLevel, destination->mipLevel) ||
-//      !conv(dst.origin, destination->origin) ||
-//      !conv(dst.texture, destination->texture) ||
-//      !conv(layout, dataLayout) || //
-//      !conv(sz, size)) {
-//    throw std::runtime_error("Invalid input for GPUQueue::writeTexture()");
-//  }
-//
-//  if (source->flipY) {
-//    // Calculate the row size and total size
-//    uint32_t rowSize = bytesPerPixel * source->source->getWidth();
-//    uint32_t totalSize = source->source->getSize();
-//
-//    // Create a new buffer for the flipped data
-//    std::vector<uint8_t> flippedData(totalSize);
-//
-//    // Flip the data vertically
-//    for (uint32_t row = 0; row < source->source->getHeight(); ++row) {
-//      std::memcpy(flippedData.data() +
-//                      (source->source->getHeight() - 1 - row) * rowSize,
-//                  static_cast<const uint8_t *>(source->source->getData()) +
-//                      row * rowSize,
-//                  rowSize);
-//    }
-//    // Use the flipped data for writing to texture
-//    _instance.WriteTexture(&dst, flippedData.data(), totalSize, &layout, &sz);
-//  } else {
-//
-//    _instance.WriteTexture(&dst, source->source->getData(),
-//                           source->source->getSize(), &layout, &sz);
-//  }
+  //  wgpu::TexelCopyTextureInfo dst{};
+  //  wgpu::TexelCopyBufferLayout layout{};
+  //  wgpu::Extent3D sz{};
+  //  Convertor conv;
+  //  uint32_t bytesPerPixel =
+  //      source->source->getSize() /
+  //      (source->source->getWidth() * source->source->getHeight());
+  //  auto dataLayout = std::make_shared<GPUImageDataLayout>(GPUImageDataLayout{
+  //      std::optional<double>{0.0},
+  //      std::optional<double>{
+  //          static_cast<double>(bytesPerPixel * source->source->getWidth())},
+  //      std::optional<double>{static_cast<double>(source->source->getHeight())}});
+  //  if (!conv(dst.aspect, destination->aspect) ||
+  //      !conv(dst.mipLevel, destination->mipLevel) ||
+  //      !conv(dst.origin, destination->origin) ||
+  //      !conv(dst.texture, destination->texture) ||
+  //      !conv(layout, dataLayout) || //
+  //      !conv(sz, size)) {
+  //    throw std::runtime_error("Invalid input for GPUQueue::writeTexture()");
+  //  }
+  //
+  //  if (source->flipY) {
+  //    // Calculate the row size and total size
+  //    uint32_t rowSize = bytesPerPixel * source->source->getWidth();
+  //    uint32_t totalSize = source->source->getSize();
+  //
+  //    // Create a new buffer for the flipped data
+  //    std::vector<uint8_t> flippedData(totalSize);
+  //
+  //    // Flip the data vertically
+  //    for (uint32_t row = 0; row < source->source->getHeight(); ++row) {
+  //      std::memcpy(flippedData.data() +
+  //                      (source->source->getHeight() - 1 - row) * rowSize,
+  //                  static_cast<const uint8_t *>(source->source->getData()) +
+  //                      row * rowSize,
+  //                  rowSize);
+  //    }
+  //    // Use the flipped data for writing to texture
+  //    _instance.WriteTexture(&dst, flippedData.data(), totalSize, &layout,
+  //    &sz);
+  //  } else {
+  //
+  //    _instance.WriteTexture(&dst, source->source->getData(),
+  //                           source->source->getSize(), &layout, &sz);
+  //  }
 }
 
 void GPUQueue::writeTexture(std::shared_ptr<GPUImageCopyTexture> destination,

package/cpp/rnwgpu/api/GPUQueue.h

@@ -13,7 +13,6 @@
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "rnwgpu/ArrayBuffer.h"
 #include "GPUBuffer.h"
 #include "GPUCommandBuffer.h"
 #include "GPUExtent3D.h"
@@ -21,6 +20,7 @@
 #include "descriptors/GPUImageCopyTexture.h"
 #include "descriptors/GPUImageCopyTextureTagged.h"
 #include "descriptors/GPUImageDataLayout.h"
+#include "rnwgpu/ArrayBuffer.h"
 
 namespace rnwgpu {
 

package/cpp/rnwgpu/api/GPURenderBundleEncoder.h

@@ -15,8 +15,8 @@
 #include "GPUBindGroup.h"
 #include "GPUBuffer.h"
 #include "GPURenderBundle.h"
-#include "descriptors/GPURenderBundleDescriptor.h"
 #include "GPURenderPipeline.h"
+#include "descriptors/GPURenderBundleDescriptor.h"
 
 namespace rnwgpu {
 

package/cpp/rnwgpu/api/GPURenderPassEncoder.h

@@ -14,9 +14,9 @@
 
 #include "GPUBindGroup.h"
 #include "GPUBuffer.h"
-#include "descriptors/GPUColor.h"
 #include "GPURenderBundle.h"
 #include "GPURenderPipeline.h"
+#include "descriptors/GPUColor.h"
 
 namespace rnwgpu {
 

package/cpp/rnwgpu/api/descriptors/GPUBindGroupEntry.h

@@ -6,10 +6,10 @@
 #include "webgpu/webgpu_cpp.h"
 
 #include "GPUBufferBinding.h"
+#include "jsi2/JSIConverter.h"
 #include "rnwgpu/api/GPUExternalTexture.h"
 #include "rnwgpu/api/GPUSampler.h"
 #include "rnwgpu/api/GPUTextureView.h"
-#include "jsi2/JSIConverter.h"
 
 namespace jsi = facebook::jsi;
 

package/cpp/rnwgpu/api/descriptors/GPUComputePipelineDescriptor.h

@@ -7,8 +7,8 @@
 
 #include "jsi2/JSIConverter.h"
 
-#include "rnwgpu/api/GPUPipelineLayout.h"
 #include "GPUProgrammableStage.h"
+#include "rnwgpu/api/GPUPipelineLayout.h"
 
 namespace jsi = facebook::jsi;
 

package/cpp/rnwgpu/api/descriptors/GPUImageCopyExternalImage.h

@@ -17,7 +17,7 @@ namespace jsi = facebook::jsi;
 namespace rnwgpu {
 
 struct GPUImageCopyExternalImage {
-  //std::shared_ptr<ImageBitmap> source; // GPUImageCopyExternalImageSource
+  // std::shared_ptr<ImageBitmap> source; // GPUImageCopyExternalImageSource
   std::optional<std::shared_ptr<GPUOrigin2D>> origin; // GPUOrigin2DStrict
   std::optional<bool> flipY;                          // boolean
 };
@@ -33,11 +33,12 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyExternalImage>> {
     auto result = std::make_unique<rnwgpu::GPUImageCopyExternalImage>();
     if (!outOfBounds && arg.isObject()) {
       auto obj = arg.getObject(runtime);
-//      if (obj.hasProperty(runtime, "source")) {
-//        auto prop = obj.getProperty(runtime, "source");
-//        result->source = JSIConverter<std::shared_ptr<ImageBitmap>>::fromJSI(
-//            runtime, prop, false);
-//      }
+      //      if (obj.hasProperty(runtime, "source")) {
+      //        auto prop = obj.getProperty(runtime, "source");
+      //        result->source =
+      //        JSIConverter<std::shared_ptr<ImageBitmap>>::fromJSI(
+      //            runtime, prop, false);
+      //      }
       if (obj.hasProperty(runtime, "origin")) {
         auto prop = obj.getProperty(runtime, "origin");
         result->origin = JSIConverter<std::shared_ptr<GPUOrigin2D>>::fromJSI(

package/cpp/rnwgpu/api/descriptors/GPURenderPassDescriptor.h

@@ -9,10 +9,10 @@
 
 #include "jsi2/JSIConverter.h"
 
-#include "rnwgpu/api/GPUQuerySet.h"
 #include "GPURenderPassColorAttachment.h"
 #include "GPURenderPassDepthStencilAttachment.h"
 #include "GPURenderPassTimestampWrites.h"
+#include "rnwgpu/api/GPUQuerySet.h"
 
 namespace jsi = facebook::jsi;
 

package/cpp/rnwgpu/api/descriptors/GPURenderPipelineDescriptor.h

@@ -10,9 +10,9 @@
 #include "GPUDepthStencilState.h"
 #include "GPUFragmentState.h"
 #include "GPUMultisampleState.h"
-#include "rnwgpu/api/GPUPipelineLayout.h"
 #include "GPUPrimitiveState.h"
 #include "GPUVertexState.h"
+#include "rnwgpu/api/GPUPipelineLayout.h"
 
 namespace jsi = facebook::jsi;
 

package/cpp/rnwgpu/api/descriptors/GPUVertexState.h

@@ -10,8 +10,8 @@
 
 #include "jsi2/JSIConverter.h"
 
-#include "rnwgpu/api/GPUShaderModule.h"
 #include "GPUVertexBufferLayout.h"
+#include "rnwgpu/api/GPUShaderModule.h"
 
 namespace jsi = facebook::jsi;
 

package/cpp/rnwgpu/async/AsyncRunner.cpp

@@ -10,7 +10,8 @@ namespace rnwgpu::async {
 
 // Static member definitions
 std::mutex AsyncRunner::_runnersMutex;
-std::unordered_map<jsi::Runtime *, std::shared_ptr<AsyncRunner>> AsyncRunner::_runners;
+std::unordered_map<jsi::Runtime *, std::shared_ptr<AsyncRunner>>
+    AsyncRunner::_runners;
 
 AsyncRunner::AsyncRunner(wgpu::Instance instance,
                          std::shared_ptr<AsyncDispatcher> dispatcher)

package/cpp/rnwgpu/async/AsyncRunner.h

@@ -43,7 +43,8 @@ public:
 
 private:
   static std::mutex _runnersMutex;
-  static std::unordered_map<jsi::Runtime *, std::shared_ptr<AsyncRunner>> _runners;
+  static std::unordered_map<jsi::Runtime *, std::shared_ptr<AsyncRunner>>
+      _runners;
 
   wgpu::Instance _instance;
   std::shared_ptr<AsyncDispatcher> _dispatcher;