Add Uint8Array subtype on Value

Author: nick-thompson

runtime/elem/Value.h

@@ -29,6 +29,7 @@ namespace js
     using Object = std::map<String, Value>;
     using Array = std::vector<Value>;
     using Float32Array = std::vector<float>;
+    using Uint8Array = std::vector<uint8_t>;
     using Function = std::function<Value(Array)>;
 
     //==============================================================================
@@ -52,6 +53,7 @@ namespace js
         Value (String const& v)         : var(v) {}
         Value (Array const& v)          : var(v) {}
         Value (Float32Array const& v)   : var(v) {}
+        Value (Uint8Array const& v)     : var(v) {}
         Value (Object const& v)         : var(v) {}
         Value (Function const& v)       : var(v) {}
 
@@ -81,6 +83,7 @@ namespace js
         bool isString()         const { return std::holds_alternative<String>(var); }
         bool isArray()          const { return std::holds_alternative<Array>(var); }
         bool isFloat32Array()   const { return std::holds_alternative<Float32Array>(var); }
+        bool isUint8Array()     const { return std::holds_alternative<Uint8Array>(var); }
         bool isObject()         const { return std::holds_alternative<Object>(var); }
         bool isFunction()       const { return std::holds_alternative<Function>(var); }
 
@@ -94,11 +97,13 @@ namespace js
         // Object value getters
         Array const& getArray()                 const { return std::get<Array>(var); }
         Float32Array const& getFloat32Array()   const { return std::get<Float32Array>(var); }
+        Uint8Array const& getUint8Array()       const { return std::get<Uint8Array>(var); }
         Object const& getObject()               const { return std::get<Object>(var); }
         Function const& getFunction()           const { return std::get<Function>(var); }
 
         Array& getArray()                   { return std::get<Array>(var); }
         Float32Array& getFloat32Array()     { return std::get<Float32Array>(var); }
+        Uint8Array& getUint8Array()         { return std::get<Uint8Array>(var); }
         Object& getObject()                 { return std::get<Object>(var); }
         Function& getFunction()             { return std::get<Function>(var); }
 
@@ -160,6 +165,24 @@ namespace js
                 auto s = ss.str();
                 return s.substr(0, s.size() - 2) + "]";
             }
+            if (isUint8Array())
+            {
+                auto& ab = getUint8Array();
+                std::stringstream ss;
+                ss << "[";
+
+                for (size_t i = 0; i < std::min((size_t) 3, ab.size()); ++i)
+                    ss << std::to_string(ab[i]) << ", ";
+
+                if (ab.size() > 3)
+                {
+                    ss << "...]";
+                    return ss.str();
+                }
+
+                auto s = ss.str();
+                return s.substr(0, s.size() - 2) + "]";
+            }
             if (isObject())
             {
                 std::stringstream ss;
@@ -191,6 +214,7 @@ namespace js
             Object,
             Array,
             Float32Array,
+            Uint8Array,
             Function>;
 
         VarType var;

wasm/Main.cpp

@@ -281,6 +281,16 @@ class ElementaryAudioProcessor
             // mapping from emscripten::val to a simple std::vector.
             return elem::js::Value(convertJSArrayToNumberVector<float>(v));
         }
+        if (v.instanceof(val::global("ArrayBuffer"))) {
+            // For raw ArrayBuffer, we need to create a Uint8Array view first
+            auto uint8View = val::global("Uint8Array").new_(v);
+            return elem::js::Value(elem::js::Uint8Array(convertJSArrayToNumberVector<uint8_t>(uint8View)));
+        }
+        if (v.instanceof(val::global("Uint8Array"))) {
+            // This conversion function is part of the emscripten namespace for
+            // mapping from emscripten::val to a simple std::vector.
+            return elem::js::Value(elem::js::Uint8Array(convertJSArrayToNumberVector<uint8_t>(v)));
+        }
 
         if (v.isArray())
         {
@@ -361,6 +371,21 @@ class ElementaryAudioProcessor
             return ret;
         }
 
+        if (v.isUint8Array())
+        {
+            auto& va = v.getUint8Array();
+
+            // Create a Uint8Array directly
+            auto uint8Array = val::global("Uint8Array").new_(va.size());
+
+            for (size_t i = 0; i < va.size(); ++i)
+            {
+                uint8Array.set(i, val(va[i]));
+            }
+
+            return uint8Array;
+        }
+
         if (v.isObject())
         {
             auto& vo = v.getObject();