@neoanaloglabkk/lensfun-wasm 0.1.1

package/native/src/lensfun_wasm_bridge.cpp

@@ -0,0 +1,487 @@
+#include "lensfun.h"
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <algorithm>
+#include <sstream>
+#include <string>
+
+#if defined(__EMSCRIPTEN__)
+#include <emscripten/emscripten.h>
+#define LFW_EXPORT EMSCRIPTEN_KEEPALIVE
+#else
+#define LFW_EXPORT
+#endif
+
+namespace
+{
+lfDatabase *g_db = nullptr;
+
+void append_json_escaped(std::ostringstream &out, const char *value)
+{
+    out << '"';
+    if (value)
+    {
+        for (const char *p = value; *p; ++p)
+        {
+            const unsigned char c = static_cast<unsigned char>(*p);
+            switch (c)
+            {
+            case '\\':
+                out << "\\\\";
+                break;
+            case '"':
+                out << "\\\"";
+                break;
+            case '\n':
+                out << "\\n";
+                break;
+            case '\r':
+                out << "\\r";
+                break;
+            case '\t':
+                out << "\\t";
+                break;
+            default:
+                if (c < 0x20)
+                {
+                    out << "\\u00";
+                    const char hex[] = "0123456789abcdef";
+                    out << hex[(c >> 4) & 0x0F] << hex[c & 0x0F];
+                }
+                else
+                {
+                    out << *p;
+                }
+                break;
+            }
+        }
+    }
+    out << '"';
+}
+
+char *dup_cstr(const std::string &s)
+{
+    auto *buf = static_cast<char *>(malloc(s.size() + 1));
+    if (!buf)
+    {
+        return nullptr;
+    }
+    memcpy(buf, s.data(), s.size());
+    buf[s.size()] = '\0';
+    return buf;
+}
+
+const lfLens *resolve_lens(uint32_t lens_handle)
+{
+    if (!g_db || lens_handle == 0)
+    {
+        return nullptr;
+    }
+
+    const auto *target = reinterpret_cast<const lfLens *>(static_cast<uintptr_t>(lens_handle));
+    const lfLens *const *all_lenses = lf_db_get_lenses(g_db);
+    if (!all_lenses)
+    {
+        return nullptr;
+    }
+
+    for (size_t i = 0; all_lenses[i] != nullptr; ++i)
+    {
+        if (all_lenses[i] == target)
+        {
+            return target;
+        }
+    }
+
+    return nullptr;
+}
+
+int grid_points(int size, int step)
+{
+    if (size <= 0 || step <= 0)
+    {
+        return 0;
+    }
+    return ((size - 1) / step) + 1;
+}
+
+float sample_coord(int index, int step, int bound)
+{
+    const int value = index * step;
+    const int clamped = std::min(value, std::max(bound - 1, 0));
+    return static_cast<float>(clamped);
+}
+} // namespace
+
+extern "C" {
+
+LFW_EXPORT int32_t lfw_init(const char *db_dir)
+{
+    if (g_db)
+    {
+        lf_db_destroy(g_db);
+        g_db = nullptr;
+    }
+
+    g_db = lf_db_create();
+    if (!g_db)
+    {
+        return -1;
+    }
+
+    const char *path = db_dir ? db_dir : "/lensfun-db";
+    const lfError err = lf_db_load_path(g_db, path);
+    return static_cast<int32_t>(err);
+}
+
+LFW_EXPORT void lfw_dispose(void)
+{
+    if (g_db)
+    {
+        lf_db_destroy(g_db);
+        g_db = nullptr;
+    }
+}
+
+LFW_EXPORT char *lfw_find_lenses_json(
+    const char *camera_maker,
+    const char *camera_model,
+    const char *lens_maker,
+    const char *lens_model,
+    int32_t search_flags)
+{
+    if (!g_db)
+    {
+        return dup_cstr("[]");
+    }
+
+    const lfCamera *camera = nullptr;
+    const lfCamera **cameras_to_free = nullptr;
+    if (camera_maker || camera_model)
+    {
+        cameras_to_free = lf_db_find_cameras(g_db, camera_maker, camera_model);
+        if (cameras_to_free)
+        {
+            camera = cameras_to_free[0];
+        }
+    }
+
+    const lfLens **lenses = lf_db_find_lenses(g_db, camera, lens_maker, lens_model, search_flags);
+
+    std::ostringstream out;
+    out << '[';
+    bool first = true;
+    if (lenses)
+    {
+        for (size_t i = 0; lenses[i] != nullptr; ++i)
+        {
+            const lfLens *lens = lenses[i];
+            if (!first)
+            {
+                out << ',';
+            }
+            first = false;
+
+            const uint32_t handle = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(lens));
+            out << "{\"handle\":" << handle << ",\"maker\":";
+            append_json_escaped(out, lens->Maker ? lf_mlstr_get(lens->Maker) : "");
+            out << ",\"model\":";
+            append_json_escaped(out, lens->Model ? lf_mlstr_get(lens->Model) : "");
+            out << ",\"score\":" << lens->Score;
+            out << ",\"minFocal\":" << lens->MinFocal;
+            out << ",\"maxFocal\":" << lens->MaxFocal;
+            out << ",\"minAperture\":" << lens->MinAperture;
+            out << ",\"maxAperture\":" << lens->MaxAperture;
+            out << ",\"cropFactor\":" << lens->CropFactor;
+            out << '}';
+        }
+        lf_free(lenses);
+    }
+
+    if (cameras_to_free)
+    {
+        lf_free(cameras_to_free);
+    }
+
+    out << ']';
+    return dup_cstr(out.str());
+}
+
+LFW_EXPORT char *lfw_find_cameras_json(const char *maker, const char *model, int32_t search_flags)
+{
+    (void)search_flags;
+
+    if (!g_db)
+    {
+        return dup_cstr("[]");
+    }
+
+    const lfCamera **cameras = lf_db_find_cameras_ext(g_db, maker, model, search_flags);
+
+    std::ostringstream out;
+    out << '[';
+    bool first = true;
+
+    if (cameras)
+    {
+        for (size_t i = 0; cameras[i] != nullptr; ++i)
+        {
+            const lfCamera *camera = cameras[i];
+            if (!first)
+            {
+                out << ',';
+            }
+            first = false;
+
+            out << "{\"maker\":";
+            append_json_escaped(out, camera->Maker ? lf_mlstr_get(camera->Maker) : "");
+            out << ",\"model\":";
+            append_json_escaped(out, camera->Model ? lf_mlstr_get(camera->Model) : "");
+            out << ",\"variant\":";
+            append_json_escaped(out, camera->Variant ? lf_mlstr_get(camera->Variant) : "");
+            out << ",\"mount\":";
+            append_json_escaped(out, camera->Mount ? camera->Mount : "");
+            out << ",\"cropFactor\":" << camera->CropFactor;
+            out << ",\"score\":" << camera->Score;
+            out << '}';
+        }
+
+        lf_free(cameras);
+    }
+
+    out << ']';
+    return dup_cstr(out.str());
+}
+
+LFW_EXPORT int32_t lfw_available_mods(uint32_t lens_handle, float crop)
+{
+    const lfLens *lens = resolve_lens(lens_handle);
+    if (!lens)
+    {
+        return 0;
+    }
+
+    return lf_lens_available_modifications(const_cast<lfLens *>(lens), crop);
+}
+
+LFW_EXPORT int32_t lfw_build_geometry_map(
+    uint32_t lens_handle,
+    float focal,
+    float crop,
+    int32_t width,
+    int32_t height,
+    int32_t reverse,
+    int32_t step,
+    float *out_xy,
+    int32_t out_len)
+{
+    const lfLens *lens = resolve_lens(lens_handle);
+    if (!lens || !out_xy || width <= 0 || height <= 0 || step <= 0)
+    {
+        return -1;
+    }
+
+    const int gx = grid_points(width, step);
+    const int gy = grid_points(height, step);
+    const int needed = gx * gy * 2;
+    if (out_len < needed)
+    {
+        return -2;
+    }
+
+    lfModifier *modifier = lf_modifier_create(
+        lens,
+        focal,
+        crop,
+        width,
+        height,
+        LF_PF_F32,
+        reverse != 0);
+
+    if (!modifier)
+    {
+        return -3;
+    }
+
+    lf_modifier_enable_distortion_correction(modifier);
+
+    int cursor = 0;
+    float result[2] = {0.0f, 0.0f};
+    for (int y = 0; y < gy; ++y)
+    {
+        const float py = sample_coord(y, step, height);
+        for (int x = 0; x < gx; ++x)
+        {
+            const float px = sample_coord(x, step, width);
+            if (!lf_modifier_apply_geometry_distortion(modifier, px, py, 1, 1, result))
+            {
+                lf_modifier_destroy(modifier);
+                return -4;
+            }
+            out_xy[cursor++] = result[0];
+            out_xy[cursor++] = result[1];
+        }
+    }
+
+    lf_modifier_destroy(modifier);
+    return 0;
+}
+
+LFW_EXPORT int32_t lfw_build_tca_map(
+    uint32_t lens_handle,
+    float focal,
+    float crop,
+    int32_t width,
+    int32_t height,
+    int32_t reverse,
+    int32_t step,
+    float *out_rgbxy,
+    int32_t out_len)
+{
+    const lfLens *lens = resolve_lens(lens_handle);
+    if (!lens || !out_rgbxy || width <= 0 || height <= 0 || step <= 0)
+    {
+        return -1;
+    }
+
+    const int gx = grid_points(width, step);
+    const int gy = grid_points(height, step);
+    const int needed = gx * gy * 6;
+    if (out_len < needed)
+    {
+        return -2;
+    }
+
+    lfModifier *modifier = lf_modifier_create(
+        lens,
+        focal,
+        crop,
+        width,
+        height,
+        LF_PF_F32,
+        reverse != 0);
+
+    if (!modifier)
+    {
+        return -3;
+    }
+
+    lf_modifier_enable_tca_correction(modifier);
+
+    int cursor = 0;
+    float result[6] = {0};
+    for (int y = 0; y < gy; ++y)
+    {
+        const float py = sample_coord(y, step, height);
+        for (int x = 0; x < gx; ++x)
+        {
+            const float px = sample_coord(x, step, width);
+            if (!lf_modifier_apply_subpixel_distortion(modifier, px, py, 1, 1, result))
+            {
+                lf_modifier_destroy(modifier);
+                return -4;
+            }
+            for (int k = 0; k < 6; ++k)
+            {
+                out_rgbxy[cursor++] = result[k];
+            }
+        }
+    }
+
+    lf_modifier_destroy(modifier);
+    return 0;
+}
+
+LFW_EXPORT int32_t lfw_build_vignetting_map(
+    uint32_t lens_handle,
+    float focal,
+    float crop,
+    float aperture,
+    float distance,
+    int32_t width,
+    int32_t height,
+    int32_t reverse,
+    int32_t step,
+    float *out_rgb_gain,
+    int32_t out_len)
+{
+    const lfLens *lens = resolve_lens(lens_handle);
+    if (!lens || !out_rgb_gain || width <= 0 || height <= 0 || step <= 0)
+    {
+        return -1;
+    }
+
+    const int gx = grid_points(width, step);
+    const int gy = grid_points(height, step);
+    const int needed = gx * gy * 3;
+    if (out_len < needed)
+    {
+        return -2;
+    }
+
+    lfModifier *modifier = lf_modifier_create(
+        lens,
+        focal,
+        crop,
+        width,
+        height,
+        LF_PF_F32,
+        reverse != 0);
+
+    if (!modifier)
+    {
+        return -3;
+    }
+
+    if (!lf_modifier_enable_vignetting_correction(modifier, aperture, distance))
+    {
+        lf_modifier_destroy(modifier);
+        return -4;
+    }
+
+    int cursor = 0;
+    float pixel[3] = {1.0f, 1.0f, 1.0f};
+    for (int y = 0; y < gy; ++y)
+    {
+        const float py = sample_coord(y, step, height);
+        for (int x = 0; x < gx; ++x)
+        {
+            const float px = sample_coord(x, step, width);
+            pixel[0] = 1.0f;
+            pixel[1] = 1.0f;
+            pixel[2] = 1.0f;
+
+            if (!lf_modifier_apply_color_modification(
+                    modifier,
+                    pixel,
+                    px,
+                    py,
+                    1,
+                    1,
+                    LF_CR_3(RED, GREEN, BLUE),
+                    0))
+            {
+                lf_modifier_destroy(modifier);
+                return -5;
+            }
+
+            out_rgb_gain[cursor++] = pixel[0];
+            out_rgb_gain[cursor++] = pixel[1];
+            out_rgb_gain[cursor++] = pixel[2];
+        }
+    }
+
+    lf_modifier_destroy(modifier);
+    return 0;
+}
+
+LFW_EXPORT void lfw_free(void *p)
+{
+    free(p);
+}
+
+} // extern "C"

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@neoanaloglabkk/lensfun-wasm",
+  "version": "0.1.1",
+  "description": "Lensfun compiled to WebAssembly with a high-level JS API for browser frontends.",
+  "license": "LGPL-3.0-or-later",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lexluthor0304/LensfunWasm.git"
+  },
+  "type": "module",
+  "main": "./dist/umd/index.iife.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "files": [
+    "dist",
+    "native",
+    "scripts",
+    "UPSTREAM.md",
+    "NOTICE.md",
+    "THIRD_PARTY_LICENSES.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/umd/index.iife.js"
+    },
+    "./core": {
+      "default": "./dist/assets/lensfun-core.js"
+    },
+    "./core-wasm": {
+      "default": "./dist/assets/lensfun-core.wasm"
+    },
+    "./core-data": {
+      "default": "./dist/assets/lensfun-core.data"
+    }
+  },
+  "scripts": {
+    "build:wasm": "bash scripts/build-wasm.sh",
+    "build:js": "tsup",
+    "build:types": "tsc --emitDeclarationOnly",
+    "build": "npm run build:wasm && npm run build:js && npm run build:types",
+    "test": "vitest run",
+    "check": "npm run build:js && npm run build:types && npm run test",
+    "pack:dry-run": "npm pack --dry-run",
+    "release:verify-tag": "node scripts/verify-release-tag.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "tsup": "^8.3.0",
+    "typescript": "^5.8.2",
+    "vitest": "^2.1.9"
+  }
+}

package/scripts/build-wasm.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+BUILD_DIR="${ROOT_DIR}/wasm-build"
+DIST_ASSETS_DIR="${ROOT_DIR}/dist/assets"
+
+if ! command -v emcc >/dev/null 2>&1; then
+  cat >&2 <<'MSG'
+[build-wasm] emcc not found.
+Install and activate Emscripten first, for example:
+  git clone https://github.com/emscripten-core/emsdk.git
+  cd emsdk
+  ./emsdk install latest
+  ./emsdk activate latest
+  source ./emsdk_env.sh
+MSG
+  exit 1
+fi
+
+rm -rf "${BUILD_DIR}"
+mkdir -p "${BUILD_DIR}" "${DIST_ASSETS_DIR}"
+
+emcmake cmake -S "${ROOT_DIR}/native" -B "${BUILD_DIR}" -DCMAKE_BUILD_TYPE=Release
+cmake --build "${BUILD_DIR}" --target lensfun-core -j
+
+cp "${BUILD_DIR}/lensfun-core.js" "${DIST_ASSETS_DIR}/lensfun-core.js"
+cp "${BUILD_DIR}/lensfun-core.wasm" "${DIST_ASSETS_DIR}/lensfun-core.wasm"
+cp "${BUILD_DIR}/lensfun-core.data" "${DIST_ASSETS_DIR}/lensfun-core.data"
+
+echo "[build-wasm] built assets in ${DIST_ASSETS_DIR}"

package/scripts/sync-upstream.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+SUBMODULE_DIR="${ROOT_DIR}/third_party/lensfun"
+
+if [[ ! -d "${SUBMODULE_DIR}" ]]; then
+  echo "[sync-upstream] lensfun submodule not found at ${SUBMODULE_DIR}" >&2
+  exit 1
+fi
+
+pushd "${SUBMODULE_DIR}" >/dev/null
+
+git fetch origin
+TARGET="${1:-origin/master}"
+git checkout "${TARGET}"
+
+NEW_COMMIT="$(git rev-parse HEAD)"
+NEW_SUBJECT="$(git log -1 --format=%s)"
+
+popd >/dev/null
+
+echo "[sync-upstream] lensfun updated to ${NEW_COMMIT}"
+echo "[sync-upstream] ${NEW_SUBJECT}"
+echo "[sync-upstream] run tests and update UPSTREAM.md before committing"

package/scripts/verify-release-tag.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+const root = process.cwd();
+const packageJsonPath = path.join(root, 'package.json');
+
+if (!fs.existsSync(packageJsonPath)) {
+  console.error('[release] package.json not found in current directory');
+  process.exit(1);
+}
+
+const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+const version = pkg.version;
+const tagArg = process.argv[2] || process.env.GITHUB_REF_NAME || '';
+
+if (!version || typeof version !== 'string') {
+  console.error('[release] package.json version is missing or invalid');
+  process.exit(1);
+}
+
+if (!tagArg) {
+  console.error('[release] missing tag argument. Usage: node scripts/verify-release-tag.mjs vX.Y.Z');
+  process.exit(1);
+}
+
+if (!tagArg.startsWith('v')) {
+  console.error(`[release] invalid tag "${tagArg}". Tag must start with "v".`);
+  process.exit(1);
+}
+
+const tagVersion = tagArg.slice(1);
+
+if (tagVersion !== version) {
+  console.error(`[release] tag/version mismatch: tag=${tagArg}, package.json=${version}`);
+  process.exit(1);
+}
+
+console.log(`[release] tag/version check passed: ${tagArg} == ${version}`);