Move MediaPipe initialisation to filter init.

We used to initialise MediaPipe at worker start, which prevented
us from handling errors.  We now do it at filter init, and stop
the stream with an error message if initialisation fails.

static/background-blur-worker.js

@@ -2,17 +2,15 @@
 
 let imageSegmenter;
 
-async function loadImageSegmenter() {
+async function loadImageSegmenter(model) {
     let module = await import('/third-party/tasks-vision/vision_bundle.mjs');
-
     let vision = await module.FilesetResolver.forVisionTasks(
         "/third-party/tasks-vision/wasm"
     );
 
-    imageSegmenter =
+    return await module.ImageSegmenter.createFromOptions(vision, {
-        await module.ImageSegmenter.createFromOptions(vision, {
             baseOptions: {
-                modelAssetPath: '/third-party/tasks-vision/models/selfie_segmenter.tflite',
+                modelAssetPath: model,
             },
             outputCategoryMask: true,
             outputConfidenceMasks: false,
@@ -20,19 +18,24 @@ async function loadImageSegmenter() {
         });
 }
 
-loadImageSegmenter();
+onmessage = async e => {
-
+    let data = e.data;
-onmessage = e => {
+    if(imageSegmenter == null) {
-    let bitmap = e.data.bitmap;
+        try {
-    if(!(bitmap instanceof ImageBitmap)) {
+            imageSegmenter = await loadImageSegmenter(data.model);
-        postMessage(new Error('Bad type for worker data'));
+            if(imageSegmenter == null)
+                throw new Error("loadImageSegmenter returned null");
+        } catch(e) {
+            postMessage(e);
+            return;
+        }
+        postMessage(null);
         return;
     }
 
-    if(!imageSegmenter) {
+    let bitmap = e.data.bitmap;
-        // not ready yet
+    if(!(bitmap instanceof ImageBitmap)) {
-        bitmap.close();
+        postMessage(new Error('Bad type for worker data'));
-        postMessage(null);
         return;
     }
 

static/galene.js

@@ -1188,6 +1188,30 @@ async function setFilter(c) {
     c.userdata.filter = filter;
 }
 
+/**
+ * Sends a message to a worker, then waits for a reply.
+ *
+ * @param {Worker} worker
+ * @param {any} message
+ * @param {any[]} [transfer]
+ */
+async function workerSendReceive(worker, message, transfer) {
+    let p = new Promise((resolve, reject) => {
+        worker.onmessage = e => {
+            if(e && e.data) {
+                if(e.data instanceof Error)
+                    reject(e.data);
+                else
+                    resolve(e.data);
+            } else {
+                resolve(null);
+            }
+        };
+    });
+    worker.postMessage(message, transfer);
+    return await p
+}
+
 /**
  * @type {Object.<string,filterDefinition>}
  */
@@ -1242,6 +1266,9 @@ let filters = {
             if(this.userdata.worker)
                 throw new Error("Worker already running (this shouldn't happen)")
             this.userdata.worker = new Worker('/background-blur-worker.js');
+            await workerSendReceive(this.userdata.worker, {
+                model: '/third-party/tasks-vision/models/selfie_segmenter.tflite',
+            });
         },
         cleanup: async function() {
             if(this.userdata.worker.onmessage) {
@@ -1253,23 +1280,10 @@ let filters = {
         draw: async function(src, ctx) {
             let bitmap = await createImageBitmap(src);
             try {
-                let p = new Promise((resolve, reject) => {
+                let result = await workerSendReceive(this.userdata.worker, {
-                    this.userdata.worker.onmessage = e => {
-                        if(e && e.data) {
-                            if(e.data instanceof Error)
-                                reject(e.data);
-                            else
-                                resolve(e.data);
-                        } else {
-                            resolve(null);
-                        }
-                    };
-                });
-                this.userdata.worker.postMessage({
                     bitmap: bitmap,
                     timestamp: performance.now(),
                 }, [bitmap]);
-                let result = await p;
 
                 if(!result)
                     return false;