Edit
kc3-lang/harfbuzz/src/hb-wasm-shape.cc
Behdad Esfahbod
- src/hb-wasm-shape.cc
-
/* * Copyright © 2011 Google, Inc. * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. * * Google Author(s): Behdad Esfahbod */ #undef HB_DEBUG_WASM #define HB_DEBUG_WASM 1 #include "hb-shaper-impl.hh" #ifdef HAVE_WASM /* Compile wasm-micro-runtime with: * * $ cmake -DWAMR_BUILD_MULTI_MODULE=1 -DWAMR_BUILD_REF_TYPES=1 -DWAMR_BUILD_FAST_JIT=1 * $ make * * If you manage to build a wasm shared module successfully and want to use it, * do the following: * * - Add -DWAMR_BUILD_MULTI_MODULE=1 to your cmake build for wasm-micro-runtime, * * - Remove the #define HB_WASM_NO_MODULES line below, * * - Install your shared module with name ending in .wasm in * $(prefix)/$(libdir)/harfbuzz/wasm/ * * - Build your font's wasm code importing the shared modules with the desired * name. This can be done eg.: __attribute__((import_module("graphite2"))) * before each symbol in the shared-module's headers. * * - Try shaping your font and hope for the best... * * I haven't been able to get this to work since emcc's support for shared libraries * requires support from the host that seems to be missing from wasm-micro-runtime? */ #include "hb-wasm-api.hh" #include "hb-wasm-api-list.hh" #ifndef HB_WASM_NO_MODULES #define HB_WASM_NO_MODULES #endif #ifndef HB_WASM_NO_MODULES static bool HB_UNUSED _hb_wasm_module_reader (const char *module_name, uint8_t **p_buffer, uint32_t *p_size) { char path[sizeof (HB_WASM_MODULE_DIR) + 64] = HB_WASM_MODULE_DIR "/"; strncat (path, module_name, sizeof (path) - sizeof (HB_WASM_MODULE_DIR) - 16); strncat (path, ".wasm", 6); auto *blob = hb_blob_create_from_file (path); unsigned length; auto *data = hb_blob_get_data (blob, &length); *p_buffer = (uint8_t *) hb_malloc (length); if (length && !p_buffer) return false; memcpy (*p_buffer, data, length); *p_size = length; hb_blob_destroy (blob); return true; } static void HB_UNUSED _hb_wasm_module_destroyer (uint8_t *buffer, uint32_t size) { hb_free (buffer); } #endif /* * shaper face data */ #define HB_WASM_TAG_WASM HB_TAG('W','a','s','m') struct hb_wasm_shape_plan_t { wasm_module_inst_t module_inst; wasm_exec_env_t exec_env; ptr_d(void, wasm_shape_plan); }; struct hb_wasm_face_data_t { hb_blob_t *wasm_blob; wasm_module_t wasm_module; mutable hb_atomic_ptr_t<hb_wasm_shape_plan_t> plan; }; static bool _hb_wasm_init () { /* XXX * * Umm. Make this threadsafe. How?! * It's clunky that we can't allocate a static mutex. * So we have to first allocate one on the heap atomically... * * Do we also need to lock around module creation? * * Also, wasm-micro-runtime uses a singleton instance. So if * another library or client uses it, all bets are off. :-( * If nothing else, around HB_REF2OBJ(). */ static bool initialized; if (initialized) return true; RuntimeInitArgs init_args; hb_memset (&init_args, 0, sizeof (RuntimeInitArgs)); init_args.mem_alloc_type = Alloc_With_Allocator; init_args.mem_alloc_option.allocator.malloc_func = (void *) hb_malloc; init_args.mem_alloc_option.allocator.realloc_func = (void *) hb_realloc; init_args.mem_alloc_option.allocator.free_func = (void *) hb_free; // Native symbols need below registration phase init_args.n_native_symbols = ARRAY_LENGTH (_hb_wasm_native_symbols); init_args.native_module_name = "env"; init_args.native_symbols = _hb_wasm_native_symbols; if (unlikely (!wasm_runtime_full_init (&init_args))) { DEBUG_MSG (WASM, nullptr, "Init runtime environment failed."); return false; } #ifndef HB_WASM_NO_MODULES wasm_runtime_set_module_reader (_hb_wasm_module_reader, _hb_wasm_module_destroyer); #endif initialized = true; return true; } hb_wasm_face_data_t * _hb_wasm_shaper_face_data_create (hb_face_t *face) { char error[128]; hb_wasm_face_data_t *data = nullptr; hb_blob_t *wasm_blob = nullptr; wasm_module_t wasm_module = nullptr; wasm_blob = hb_face_reference_table (face, HB_WASM_TAG_WASM); unsigned length = hb_blob_get_length (wasm_blob); if (!length) goto fail; if (!_hb_wasm_init ()) goto fail; wasm_module = wasm_runtime_load ((uint8_t *) hb_blob_get_data_writable (wasm_blob, nullptr), length, error, sizeof (error)); if (unlikely (!wasm_module)) { DEBUG_MSG (WASM, nullptr, "Load wasm module failed: %s", error); goto fail; } data = (hb_wasm_face_data_t *) hb_calloc (1, sizeof (hb_wasm_face_data_t)); if (unlikely (!data)) goto fail; data->wasm_blob = wasm_blob; data->wasm_module = wasm_module; return data; fail: if (wasm_module) wasm_runtime_unload (wasm_module); hb_blob_destroy (wasm_blob); hb_free (data); return nullptr; } static hb_wasm_shape_plan_t * acquire_shape_plan (hb_face_t *face, const hb_wasm_face_data_t *face_data) { char error[128]; /* Fetch cached one if available. */ hb_wasm_shape_plan_t *plan = face_data->plan.get_acquire (); if (likely (plan && face_data->plan.cmpexch (plan, nullptr))) return plan; plan = (hb_wasm_shape_plan_t *) hb_calloc (1, sizeof (hb_wasm_shape_plan_t)); wasm_module_inst_t module_inst = nullptr; wasm_exec_env_t exec_env = nullptr; wasm_function_inst_t func = nullptr; constexpr uint32_t stack_size = 32 * 1024, heap_size = 2 * 1024 * 1024; module_inst = plan->module_inst = wasm_runtime_instantiate (face_data->wasm_module, stack_size, heap_size, error, sizeof (error)); if (unlikely (!module_inst)) { DEBUG_MSG (WASM, face_data, "Create wasm module instance failed: %s", error); goto fail; } exec_env = plan->exec_env = wasm_runtime_create_exec_env (module_inst, stack_size); if (unlikely (!exec_env)) { DEBUG_MSG (WASM, face_data, "Create wasm execution environment failed."); goto fail; } func = wasm_runtime_lookup_function (module_inst, "shape_plan_create"); if (func) { wasm_val_t results[1]; wasm_val_t arguments[1]; HB_OBJ2REF (face); if (unlikely (!faceref)) { DEBUG_MSG (WASM, face_data, "Failed to register face object."); goto fail; } results[0].kind = WASM_I32; arguments[0].kind = WASM_I32; arguments[0].of.i32 = faceref; bool ret = wasm_runtime_call_wasm_a (exec_env, func, ARRAY_LENGTH (results), results, ARRAY_LENGTH (arguments), arguments); if (unlikely (!ret)) { DEBUG_MSG (WASM, module_inst, "Calling shape_plan_create() failed: %s", wasm_runtime_get_exception (module_inst)); goto fail; } plan->wasm_shape_planptr = results[0].of.i32; } return plan; fail: if (exec_env) wasm_runtime_destroy_exec_env (exec_env); if (module_inst) wasm_runtime_deinstantiate (module_inst); hb_free (plan); return nullptr; } static void release_shape_plan (const hb_wasm_face_data_t *face_data, hb_wasm_shape_plan_t *plan, bool cache = false) { if (cache && face_data->plan.cmpexch (nullptr, plan)) return; auto *module_inst = plan->module_inst; auto *exec_env = plan->exec_env; /* Is there even any point to having a shape_plan_destroy function * and calling it? */ if (plan->wasm_shape_planptr) { auto *func = wasm_runtime_lookup_function (module_inst, "shape_plan_destroy"); if (func) { wasm_val_t arguments[1]; arguments[0].kind = WASM_I32; arguments[0].of.i32 = plan->wasm_shape_planptr; bool ret = wasm_runtime_call_wasm_a (exec_env, func, 0, nullptr, ARRAY_LENGTH (arguments), arguments); if (unlikely (!ret)) { DEBUG_MSG (WASM, module_inst, "Calling shape_plan_destroy() failed: %s", wasm_runtime_get_exception (module_inst)); } } } wasm_runtime_destroy_exec_env (exec_env); wasm_runtime_deinstantiate (module_inst); hb_free (plan); } void _hb_wasm_shaper_face_data_destroy (hb_wasm_face_data_t *data) { if (data->plan.get_relaxed ()) release_shape_plan (data, data->plan); wasm_runtime_unload (data->wasm_module); hb_blob_destroy (data->wasm_blob); hb_free (data); } /* * shaper font data */ struct hb_wasm_font_data_t {}; hb_wasm_font_data_t * _hb_wasm_shaper_font_data_create (hb_font_t *font HB_UNUSED) { return (hb_wasm_font_data_t *) HB_SHAPER_DATA_SUCCEEDED; } void _hb_wasm_shaper_font_data_destroy (hb_wasm_font_data_t *data HB_UNUSED) { } /* * shaper */ hb_bool_t _hb_wasm_shape (hb_shape_plan_t *shape_plan, hb_font_t *font, hb_buffer_t *buffer, const hb_feature_t *features, unsigned int num_features) { if (unlikely (buffer->in_error ())) return false; bool ret = true; hb_face_t *face = font->face; const hb_wasm_face_data_t *face_data = face->data.wasm; bool retried = false; if (0) { retry: DEBUG_MSG (WASM, font, "Retrying..."); } wasm_function_inst_t func = nullptr; hb_wasm_shape_plan_t *plan = acquire_shape_plan (face, face_data); if (unlikely (!plan)) { DEBUG_MSG (WASM, face_data, "Acquiring shape-plan failed."); return false; } auto *module_inst = plan->module_inst; auto *exec_env = plan->exec_env; HB_OBJ2REF (font); HB_OBJ2REF (buffer); if (unlikely (!fontref || !bufferref)) { DEBUG_MSG (WASM, module_inst, "Failed to register objects."); goto fail; } func = wasm_runtime_lookup_function (module_inst, "shape"); if (unlikely (!func)) { DEBUG_MSG (WASM, module_inst, "Shape function not found."); goto fail; } wasm_val_t results[1]; wasm_val_t arguments[5]; results[0].kind = WASM_I32; arguments[0].kind = WASM_I32; arguments[0].of.i32 = plan->wasm_shape_planptr; arguments[1].kind = WASM_I32; arguments[1].of.i32 = fontref; arguments[2].kind = WASM_I32; arguments[2].of.i32 = bufferref; arguments[3].kind = WASM_I32; arguments[3].of.i32 = num_features ? wasm_runtime_module_dup_data (module_inst, (const char *) features, num_features * sizeof (features[0])) : 0; arguments[4].kind = WASM_I32; arguments[4].of.i32 = num_features; ret = wasm_runtime_call_wasm_a (exec_env, func, ARRAY_LENGTH (results), results, ARRAY_LENGTH (arguments), arguments); if (num_features) wasm_runtime_module_free (module_inst, arguments[2].of.i32); if (unlikely (!ret || !results[0].of.i32)) { DEBUG_MSG (WASM, module_inst, "Calling shape() failed: %s", wasm_runtime_get_exception (module_inst)); if (!buffer->ensure_unicode ()) { DEBUG_MSG (WASM, font, "Shape failed but buffer is not in Unicode; failing..."); goto fail; } if (retried) { DEBUG_MSG (WASM, font, "Giving up..."); goto fail; } buffer->successful = true; retried = true; release_shape_plan (face_data, plan); plan = nullptr; goto retry; } /* TODO Regularize clusters according to direction & cluster level, * such that client doesn't crash with unmet expectations. */ if (!results[0].of.i32) { fail: ret = false; } release_shape_plan (face_data, plan, ret); if (ret) { buffer->clear_glyph_flags (); buffer->unsafe_to_break (); } return ret; } #endif