@nativescript/canvas 2.0.0-webgpu.2 → 2.0.0-webgpu.21

package/platforms/ios/src/cpp/CanvasJSIModule.cpp

@@ -145,6 +145,7 @@ void CanvasJSIModule::install(v8::Isolate *isolate) {
         Path2D::Init(canvasMod, isolate);
         ImageDataImpl::Init(canvasMod, isolate);
         ImageAssetImpl::Init(canvasMod, isolate);
+        ImageBitmapImpl::Init(canvasMod, isolate);
         CanvasGradient::Init(canvasMod, isolate);
         CanvasPattern::Init(canvasMod, isolate);
         MatrixImpl::Init(canvasMod, isolate);
@@ -285,7 +286,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
 
     if (image->IsNullOrUndefined()) {
         v8::Local<v8::Value> ret[2] = {ConvertToV8String(isolate, "Failed to load image"),
-                                       v8::Undefined(isolate)};
+                                       v8::Null(isolate)};
 
         cb.As<v8::Function>()->Call(context, context->Global(), 2, ret);
         return;
@@ -295,7 +296,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
 
         v8::Local<v8::Value> ret[2] = {ConvertToV8String(isolate,
                                                          "Failed to execute 'createImageBitmap' : The crop rect width is 0"),
-                                       v8::Undefined(isolate)};
+                                       v8::Null(isolate)};
 
         cb.As<v8::Function>()->Call(context, context->Global(), 2, ret);
 
@@ -304,7 +305,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
     if (len >= 5 && (sh->IsNumber() && sh->IsNumber() == 0)) {
         v8::Local<v8::Value> ret[2] = {ConvertToV8String(isolate,
                                                          "Failed to execute 'createImageBitmap' : The crop rect height is 0"),
-                                       v8::Undefined(isolate)};
+                                       v8::Null(isolate)};
 
         cb.As<v8::Function>()->Call(context, context->Global(), 2, ret);
         return;
@@ -338,16 +339,18 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
 #ifdef __ANDROID__
                 ALooper_addFd(jsi_callback->looper_,
                               jsi_callback->fd_[0],
-                              ALOOPER_POLL_CALLBACK,
+                              0,
                               ALOOPER_EVENT_INPUT,
                               [](int fd, int events,
                                  void *data) {
+                                    if(data == nullptr){
+                                        return 1;
+                                    }
                                   auto cb = static_cast<JSICallback *>(data);
                                   bool done;
                                   read(fd, &done,
                                        sizeof(bool));
 
-
                                   v8::Isolate *isolate = cb->isolate_;
                                   v8::Locker locker(isolate);
                                   v8::Isolate::Scope isolate_scope(isolate);
@@ -372,23 +375,23 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                       args[1] = v8::Null(isolate);
                                   }
 
-
                                   callback->Call(context, context->Global(), 2, args);
 
                                   delete static_cast<JSICallback *>(data);
                                   return 0;
                               }, jsi_callback);
 
-                ALooper_wake(jsi_callback->looper_);
-
                 if (isArrayBuffer) {
+                    // converting to Uint8Array
                     auto arrayBuffer = imageObject.As<v8::ArrayBuffer>();
-                    auto store = arrayBuffer->GetBackingStore();
+                    auto size = arrayBuffer->ByteLength();
+                    imageObject = v8::Uint8Array::New(arrayBuffer, 0, size);
+                /*  auto store = arrayBuffer->GetBackingStore();
                     auto dataBuffer = (uint8_t *) store->Data();
-                    v8::Global<v8::ArrayBuffer> ab(isolate, arrayBuffer);
+
                     std::thread thread(
-                            [&dataBuffer, jsi_callback, &options, store, shared_asset](
-                                    v8::Global<v8::ArrayBuffer> ab, size_t size) {
+                            [&dataBuffer, jsi_callback, &options, store, shared_asset, size](
+                                    v8::Global<v8::ArrayBuffer> ab) {
 
 
                                 auto done = canvas_native_image_bitmap_create_from_encoded_bytes_with_output(
@@ -401,23 +404,24 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                         options.resizeHeight,
                                         shared_asset);
 
-                                canvas_native_image_asset_release(shared_asset);
-
                                 write(jsi_callback->fd_[1],
                                       &done,
                                       sizeof(bool));
 
+                                //  canvas_native_image_asset_release(shared_asset);
 
-                            }, std::move(ab), arrayBuffer->ByteLength());
+
+                            });
 
                     thread.detach();
                     return;
+
+                    */
                 }
 
 
                 auto ta = imageObject.As<v8::ArrayBufferView>();
 
-
                 auto array = ta->Buffer();
                 auto offset = ta->ByteOffset();
                 auto size = ta->ByteLength();
@@ -440,12 +444,12 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                     options.resizeHeight,
                                     shared_asset);
 
-                            canvas_native_image_asset_release(shared_asset);
-
                             write(jsi_callback->fd_[1],
                                   &done,
                                   sizeof(bool));
 
+                            //  canvas_native_image_asset_release(shared_asset);
+
 
                         }, std::move(ab));
                 thread.detach();
@@ -464,9 +468,74 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                     auto dataBuffer = (uint8_t *) store->Data();
                     v8::Global<v8::ArrayBuffer> ab(isolate, arrayBuffer);
 
+                    auto size = arrayBuffer->ByteLength();
+
+
+                    auto thread_queue = new NSOperationQueueWrapper(false);
+
+
+                    thread_queue->addOperation([&dataBuffer, jsi_callback, &options, store, shared_asset, current_queue, &ab, size]() {
+
+                        auto done = canvas_native_image_bitmap_create_from_encoded_bytes_with_output(
+                                                                                                     dataBuffer, size,
+                                                                                                     options.flipY,
+                                                                                                     options.premultiplyAlpha,
+                                                                                                     options.colorSpaceConversion,
+                                                                                                     options.resizeQuality,
+                                                                                                     options.resizeWidth,
+                                                                                                     options.resizeHeight,
+                                                                                                     shared_asset);
+
+
+
+                        auto main_task = [jsi_callback, current_queue, done, shared_asset]() {
+
+                            v8::Isolate *isolate = jsi_callback->isolate_;
+                            v8::Locker locker(isolate);
+                            v8::Isolate::Scope isolate_scope(isolate);
+                            v8::HandleScope handle_scope(isolate);
+                            v8::Local<v8::Function> callback = jsi_callback->callback_->Get(isolate);
+                            v8::Local<v8::External> cbData = jsi_callback->data_->Get(
+                                                                                      isolate).As<v8::External>();
+                            v8::Local<v8::Context> context = callback->GetCreationContextChecked();
+                            v8::Context::Scope context_scope(context);
+
+                            auto ret = ImageBitmapImpl::NewInstance(isolate, cbData);
+
+                            v8::Local<v8::Value> args[2];
+
+                            if (done) {
+                                args[0] = v8::Null(isolate);
+                                args[1] = ret;
+
+                            } else {
+                                args[0] = v8::Exception::Error(
+                                                               ConvertToV8String(isolate, "Failed to load image"));
+                                args[1] = v8::Null(isolate);
+                            }
+
+
+                            callback->Call(context, context->Global(), 2, args);
+
+                            delete jsi_callback;
+                            delete current_queue;
+
+                            canvas_native_image_asset_release(shared_asset);
+
+                        };
+                        current_queue->addOperation(main_task);
+
+                    });
+
+
+
+
+
+
+                    /*
                     std::thread thread(
-                            [&dataBuffer, jsi_callback, &options, store, shared_asset, current_queue](
-                                    v8::Global<v8::ArrayBuffer> ab, size_t size
+                            [&dataBuffer, jsi_callback, &options, store, &shared_asset, current_queue, size](
+                                    v8::Global<v8::ArrayBuffer> ab
                             ) {
 
                                 auto done = canvas_native_image_bitmap_create_from_encoded_bytes_with_output(
@@ -479,10 +548,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                         options.resizeHeight,
                                         shared_asset);
 
-                                canvas_native_image_asset_release(shared_asset);
-
-
-                                auto main_task = [jsi_callback, current_queue, done]() {
+                                auto main_task = [jsi_callback, current_queue, done, shared_asset]() {
 
 
                                     v8::Isolate *isolate = jsi_callback->isolate_;
@@ -516,12 +582,17 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                     delete jsi_callback;
                                     delete current_queue;
 
+                                    canvas_native_image_asset_release(shared_asset);
+
                                 };
                                 current_queue->addOperation(main_task);
 
-                            }, std::move(ab), arrayBuffer->ByteLength());
+                            }, std::move(ab));
+
+                   thread.detach();
 
-                    thread.detach();
+
+                    */
 
                     return;
                 }
@@ -553,9 +624,8 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                     options.resizeHeight,
                                     shared_asset);
 
-                            canvas_native_image_asset_release(shared_asset);
 
-                            auto main_task = [jsi_callback, current_queue, done]() {
+                            auto main_task = [jsi_callback, current_queue, done, shared_asset]() {
 
 
                                 v8::Isolate *isolate = jsi_callback->isolate_;
@@ -587,6 +657,8 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                 delete jsi_callback;
                                 delete current_queue;
 
+                                canvas_native_image_asset_release(shared_asset);
+
                             };
                             current_queue->addOperation(main_task);
 
@@ -617,7 +689,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
 #ifdef __ANDROID__
                 ALooper_addFd(jsi_callback->looper_,
                               jsi_callback->fd_[0],
-                              ALOOPER_POLL_CALLBACK,
+                              0,
                               ALOOPER_EVENT_INPUT,
                               [](int fd, int events,
                                  void *data) {
@@ -655,11 +727,13 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                   return 0;
                               }, jsi_callback);
 
-                ALooper_wake(jsi_callback->looper_);
-
                 auto bufferValue = args[0];
 
                 if (isArrayBuffer) {
+                    auto arrayBuffer = bufferValue.As<v8::ArrayBuffer>();
+                    auto size = arrayBuffer->ByteLength();
+                    imageObject = v8::Uint8Array::New(arrayBuffer, 0, size);
+                    /*
                     auto arrayBuffer = bufferValue.As<v8::ArrayBuffer>();
                     auto dataBuffer = (uint8_t *) arrayBuffer->GetBackingStore()->Data();
                     v8::Global<v8::ArrayBuffer> ab(isolate, arrayBuffer);
@@ -686,13 +760,12 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                         options.resizeWidth,
                                         options.resizeHeight, shared_asset);
 
-                                canvas_native_image_asset_release(shared_asset);
-
-
                                 write(jsi_callback->fd_[1],
                                       &done,
                                       sizeof(bool));
 
+                                canvas_native_image_asset_release(shared_asset);
+
                             },
                             (float) sx_or_options->NumberValue(context).ToChecked(),
                             (float) sy->NumberValue(context).ToChecked(),
@@ -703,6 +776,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                     thread.detach();
 
                     return;
+                    */
                 }
 
                 auto ta = bufferValue.As<v8::ArrayBufferView>();
@@ -736,13 +810,13 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                     options.resizeWidth,
                                     options.resizeHeight, shared_asset);
 
-                            canvas_native_image_asset_release(shared_asset);
-
 
                             write(jsi_callback->fd_[1],
                                   &done,
                                   sizeof(bool));
 
+                            canvas_native_image_asset_release(shared_asset);
+
                         },
                         (float) sx_or_options->NumberValue(context).ToChecked(),
                         (float) sy->NumberValue(context).ToChecked(),
@@ -786,10 +860,8 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                         options.resizeWidth,
                                         options.resizeHeight, shared_asset);
 
-                                canvas_native_image_asset_release(shared_asset);
-
 
-                                auto main_task = [jsi_callback, current_queue, done]() {
+                                auto main_task = [jsi_callback, current_queue, done,shared_asset]() {
 
 
                                     v8::Isolate *isolate = jsi_callback->isolate_;
@@ -823,6 +895,8 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                     delete jsi_callback;
                                     delete current_queue;
 
+                                    canvas_native_image_asset_release(shared_asset);
+
                                 };
                                 current_queue->addOperation(main_task);
 
@@ -871,9 +945,8 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                     options.resizeWidth,
                                     options.resizeHeight, shared_asset);
 
-                            canvas_native_image_asset_release(shared_asset);
 
-                            auto main_task = [jsi_callback, current_queue, done]() {
+                            auto main_task = [jsi_callback, current_queue, done, shared_asset]() {
 
 
                                 v8::Isolate *isolate = jsi_callback->isolate_;
@@ -905,6 +978,8 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                 delete jsi_callback;
                                 delete current_queue;
 
+                                canvas_native_image_asset_release(shared_asset);
+
                             };
                             current_queue->addOperation(main_task);
 
@@ -927,7 +1002,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
         }
     }
 
-    auto type = GetNativeType(image);
+    auto type = ObjectWrapperImpl::GetNativeType(image);
 
     if (len == 1 || len == 2) {
         if (len == 2) {
@@ -1080,11 +1155,15 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
 #ifdef __ANDROID__
     ALooper_addFd(jsi_callback->looper_,
                   jsi_callback->fd_[0],
-                  ALOOPER_POLL_CALLBACK,
+                  0,
                   ALOOPER_EVENT_INPUT,
                   [](int fd, int events,
                      void *data) {
 
+                        if(data == 0){
+                            return 0;
+                        }
+
                       auto cb = static_cast<JSIReadFileCallback *>(data);
                       bool done;
                       read(fd, &done,
@@ -1154,7 +1233,6 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
                                   }
                                   return 0;
                               }
-                              LogToConsole(ConvertFromV8String(isolate, stackV8Str));
 
                           }
                       }
@@ -1165,15 +1243,13 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
                       return 0;
                   }, jsi_callback);
 
-    ALooper_wake(jsi_callback->looper_);
-
     std::thread thread(
             [jsi_callback](const std::string &file) {
                 bool done = false;
                 auto ret = canvas_native_helper_read_file(file.c_str());
 
                 if (!canvas_native_helper_read_file_has_error(ret)) {
-                    auto buf = canvas_native_helper_read_file_get_data(ret);
+                    auto buf = canvas_native_helper_read_file_take_data(ret);
 
                     jsi_callback->SetData(buf);
 

package/platforms/ios/src/cpp/Helpers.h

@@ -8,6 +8,8 @@
 #include "Common.h"
 #include "OneByteStringResource.h"
 #include "v8-fast-api-calls.h"
+#include "AsyncCallback.h"
+#include "PromiseCallback.h"
 //#ifdef __APPLE__
 //#ifdef __OBJC__
 //#include <Foundation/Foundation.h>
@@ -17,19 +19,6 @@
 //#endif
 //#endif
 
-
-struct AsyncCallback {
-    v8::Isolate *isolate;
-    v8::Global<v8::Function> callback;
-    void *data;
-};
-
-struct PromiseCallback {
-    v8::Isolate *isolate;
-    v8::Global<v8::Promise::Resolver> callback;
-    void *data;
-};
-
 static const char *LOG_TAG = "JS";
 static int m_maxLogcatObjectSize = 4096;
 
@@ -81,89 +70,6 @@ static void LogToConsole(const std::string &message) {
 #endif
 }
 
-enum class NativeMask {
-    Type = 1
-};
-
-enum class NativeType {
-    None,
-    CanvasGradient,
-    CanvasPattern,
-    ImageData,
-    ImageAsset,
-    CanvasRenderingContext2D,
-    WebGLRenderingContextBase,
-    Path2D,
-    Matrix,
-    ImageBitmap,
-    TextMetrics,
-
-    WebGLQuery,
-    WebGLProgram,
-    WebGLShader,
-    WebGLBuffer,
-    WebGLFramebuffer,
-    WebGLRenderbuffer,
-    WebGLTexture,
-    WebGLActiveInfo,
-    OES_fbo_render_mipmap,
-    EXT_blend_minmax,
-    EXT_color_buffer_half_float,
-    EXT_disjoint_timer_query,
-    EXT_sRGB,
-    EXT_shader_texture_lod,
-    EXT_texture_filter_anisotropic,
-    OES_element_index_uint,
-    OES_standard_derivatives,
-    OES_texture_float,
-    OES_texture_float_linear,
-    OES_texture_half_float_linear,
-    OES_texture_half_float,
-    WEBGL_color_buffer_float,
-    OES_vertex_array_object,
-    WebGLVertexArrayObject,
-    WEBGL_compressed_texture_atc,
-    WEBGL_compressed_texture_etc1,
-    WEBGL_compressed_texture_s3tc,
-    WEBGL_compressed_texture_s3tc_srgb,
-    WEBGL_compressed_texture_etc,
-    WEBGL_compressed_texture_pvrtc,
-    WEBGL_lose_context,
-    ANGLE_instanced_arrays,
-    WEBGL_depth_texture,
-    WEBGL_draw_buffers,
-    WebGLShaderPrecisionFormat,
-    WebGLUniformLocation,
-    WebGLSampler,
-    WebGLTransformFeedback,
-    WebGLSync,
-
-    GPUAdapter,
-    GPUSupportedLimits,
-    GPUDevice,
-    GPUQueue,
-    GPUBuffer,
-    GPUInstance,
-    GPUCanvasContext,
-    GPUTexture,
-    GPUAdapterInfo,
-    GPUCommandEncoder,
-    GPUComputePass,
-    GPUQuerySet,
-    GPUShaderModule,
-    GPUPipelineLayout,
-    GPURenderPipeline,
-    GPUBindGroupLayout,
-    GPUTextureView,
-    GPURenderPassEncoder,
-    GPUCommandBuffer,
-    GPUBindGroup,
-    GPUComputePipeline,
-    GPUSampler,
-    GPURenderBundleEncoder,
-    GPURenderBundle
-};
-
 inline static v8::Local<v8::String>
 ConvertToV8OneByteString(v8::Isolate *isolate, std::string string) {
     auto value = new OneByteStringResource(std::move(string));
@@ -207,74 +113,6 @@ ConvertFromV8String(v8::Isolate *isolate, const v8::Local<v8::Value> &value) {
 }
 
 
-static void SetPrivateValue(v8::Isolate *isolate, const v8::Local<v8::Object> &obj,
-                            const v8::Local<v8::String> &propName,
-                            const v8::Local<v8::Value> &value) {
-    v8::Local<v8::Context> context;
-    auto succcess = obj->GetCreationContext().ToLocal(&context);
-    v8::Local<v8::Private> privateKey = v8::Private::ForApi(isolate, propName);
-    obj->SetPrivate(context, privateKey, value);
-}
-
-static v8::Local<v8::Value>
-GetPrivateValue(v8::Isolate *isolate, const v8::Local<v8::Object> &obj,
-                const v8::Local<v8::String> &propName) {
-    v8::Local<v8::Context> context;
-    auto succcess = obj->GetCreationContext().ToLocal(&context);
-    v8::Local<v8::Private> privateKey = v8::Private::ForApi(isolate, propName);
-
-    v8::Maybe<bool> hasPrivate = obj->HasPrivate(context, privateKey);
-
-    if (!hasPrivate.FromMaybe(false)) {
-        return {};
-    }
-
-    v8::Local<v8::Value> result;
-
-    succcess = obj->GetPrivate(context, privateKey).ToLocal(&result);
-
-    return result;
-}
-
-static void SetNativeType(const v8::Local<v8::Object> &obj, NativeType type) {
-    auto value = (int32_t) type;
-    obj->SetAlignedPointerInInternalField(1, new int32_t(value));
-}
-
-inline static NativeType GetNativeType(const v8::Local<v8::Value> &obj) {
-    if (!obj.IsEmpty() && !obj->IsNullOrUndefined() && obj->IsObject() &&
-        obj.As<v8::Object>()->InternalFieldCount() > 1) {
-        auto info = obj.As<v8::Object>()->GetAlignedPointerFromInternalField(1);
-
-        if (info != nullptr) {
-            auto value = *static_cast<int32_t *>(info);
-            auto ret = value;
-            if (ret >= (int) NativeType::CanvasGradient &&
-                ret <= (int) NativeType::GPURenderBundle) {
-                return (NativeType) ret;
-            }
-        }
-    }
-
-    return NativeType::None;
-}
-
-
-//template<class T>
-//static inline void Finalizer(const v8::WeakCallbackInfo<T> &data) {
-//    auto *pThis = data.GetParameter();
-//    pThis->weakHandle_.Reset();
-//    delete pThis;
-//}
-
-//static inline void BindFinalizer(v8::Isolate *isolate, v8::Global<v8::Object> &weakHandle, const v8::Local<v8::Object> &object) {
-//    v8::HandleScope scopedHandle(isolate);
-//    weakHandle.Reset(isolate, object);
-//    weakHandle.SetWeak(this, Finalizer, v8::WeakCallbackType::kParameter);
-//}
-
-
-
 static void SetFastMethod(v8::Isolate *isolate,
                           v8::Local<v8::Template> that,
                           const char *name,