chore: import upstream snapshot with attribution

plugins/plugin-vision/native/doctr.cpp/src/doctr_det.cpp

@@ -0,0 +1,112 @@
+// doctr_det.cpp — detection forward pass (db_mobilenet_v3_large + DBNet head).
+//
+// This file pins the detection API and high-level graph structure. Builds that
+// do not link a complete ggml dependency tree refuse initialization through the
+// explicit nullptr path below. The matching CMakeLists.txt vendors `ggml` as a
+// git submodule; keeping this file compilable-in-isolation lets the plugin
+// build while the native model runtime remains unavailable.
+
+#include "doctr.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <vector>
+
+#if defined(DOCTR_HAVE_GGML)
+#  include "ggml.h"
+#  include "ggml-backend.h"
+#endif
+
+struct doctr_det_ctx {
+    std::string gguf_path;
+
+    // Hyperparameters from GGUF metadata.
+    int   input_h     = 1024;
+    int   input_w     = 1024;
+    float mean[3]     = {0.798f, 0.785f, 0.772f};   // doCTR defaults
+    float std_[3]     = {0.264f, 0.275f, 0.286f};
+
+#if defined(DOCTR_HAVE_GGML)
+    struct ggml_context  * gctx   = nullptr;
+    ggml_backend_t         backend = nullptr;
+    // The compute graph + parameter tensors get built lazily on the first
+    // run, so the model file can be opened and validated without paying for
+    // the graph allocation cost.
+    struct ggml_cgraph   * graph  = nullptr;
+#endif
+};
+
+extern "C" doctr_det_ctx * doctr_det_init(const char * gguf_path) {
+    if (!gguf_path) return nullptr;
+
+    auto * ctx = new (std::nothrow) doctr_det_ctx();
+    if (!ctx) return nullptr;
+    ctx->gguf_path = gguf_path;
+
+#if defined(DOCTR_HAVE_GGML)
+    // 1. Open GGUF, validate `doctr.det.variant == db_mobilenet_v3_large`.
+    // 2. Read mean/std/input_{h,w} metadata into ctx.
+    // 3. Pick backend (Metal on darwin, CUDA when available, CPU else).
+    // 4. Load conv/bn/linear parameter tensors into ctx->gctx.
+    //
+    // The runtime loader is intentionally unavailable until it mirrors the
+    // tensor naming implemented by the conversion harness in `scripts/convert.py`.
+    // See README.md for the conversion pipeline.
+    fprintf(stderr,
+            "[doctr_det] init called for %s — GGML path not yet wired; weights must be built first.\n",
+            gguf_path);
+    delete ctx;
+    return nullptr;
+#else
+    // Build without ggml linked: refuse to initialize at all so the caller's
+    // JS layer can throw a clear "GGUF not ready" error.
+    fprintf(stderr,
+            "[doctr_det] built without DOCTR_HAVE_GGML — weights cannot load.\n");
+    delete ctx;
+    return nullptr;
+#endif
+}
+
+extern "C" int doctr_det_run(doctr_det_ctx * ctx,
+                             const float * rgb_chw,
+                             int h, int w,
+                             float * out_prob,
+                             int * out_h, int * out_w) {
+    if (!ctx || !rgb_chw || !out_prob || !out_h || !out_w) {
+        return DOCTR_ERR_SHAPE;
+    }
+    if (h != ctx->input_h || w != ctx->input_w) {
+        return DOCTR_ERR_SHAPE;
+    }
+#if defined(DOCTR_HAVE_GGML)
+    // Forward pass:
+    //   1. apply mean/std normalization in-place to a scratch tensor
+    //   2. run db_mobilenet_v3_large backbone (12 inverted-residual blocks,
+    //      hidden-state dims [16,24,40,80,112,160])
+    //   3. FPN-like neck producing a single (B, 256, H/4, W/4) feature map
+    //   4. DBNet head: 3x3 conv → conv-transpose ×2 → 1x1 conv → sigmoid
+    //
+    // Output: (1, 1, H/4, W/4) probability map copied into out_prob.
+    *out_h = h / 4;
+    *out_w = w / 4;
+    std::memset(out_prob, 0, sizeof(float) * (*out_h) * (*out_w));
+    return DOCTR_ERR_BACKEND;
+#else
+    (void)out_prob;
+    *out_h = 0;
+    *out_w = 0;
+    return DOCTR_ERR_BACKEND;
+#endif
+}
+
+extern "C" void doctr_det_free(doctr_det_ctx * ctx) {
+    if (!ctx) return;
+#if defined(DOCTR_HAVE_GGML)
+    if (ctx->graph)   { /* ggml_graph_free handled by gctx */ }
+    if (ctx->gctx)    { ggml_free(ctx->gctx); }
+    if (ctx->backend) { ggml_backend_free(ctx->backend); }
+#endif
+    delete ctx;
+}

plugins/plugin-vision/native/doctr.cpp/src/doctr_rec.cpp

@@ -0,0 +1,103 @@
+// doctr_rec.cpp — recognition forward pass (crnn_mobilenet_v3_small + BiLSTM).
+//
+// Same scaffolding rationale as doctr_det.cpp: API + graph structure are
+// pinned; the ggml-backed loader/forward is gated behind DOCTR_HAVE_GGML and
+// will be wired once the GGUF weight files exist.
+
+#include "doctr.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <vector>
+
+#if defined(DOCTR_HAVE_GGML)
+#  include "ggml.h"
+#  include "ggml-backend.h"
+#endif
+
+struct doctr_rec_ctx {
+    std::string gguf_path;
+    std::string charset;        // utf-8, newline separated
+    int charset_size = 0;       // number of glyph entries (charset_size+1 logits)
+
+    int input_h = 32;
+    int input_w = 128;          // dynamic; this is the maximum
+    float mean[3] = {0.694f, 0.695f, 0.693f};
+    float std_[3] = {0.299f, 0.296f, 0.301f};
+
+#if defined(DOCTR_HAVE_GGML)
+    struct ggml_context  * gctx    = nullptr;
+    ggml_backend_t         backend = nullptr;
+    struct ggml_cgraph   * graph   = nullptr;
+#endif
+};
+
+extern "C" doctr_rec_ctx * doctr_rec_init(const char * gguf_path) {
+    if (!gguf_path) return nullptr;
+    auto * ctx = new (std::nothrow) doctr_rec_ctx();
+    if (!ctx) return nullptr;
+    ctx->gguf_path = gguf_path;
+
+#if defined(DOCTR_HAVE_GGML)
+    // 1. Open GGUF, validate `doctr.rec.variant == crnn_mobilenet_v3_small`.
+    // 2. Read mean/std/input_h/input_w and charset KV.
+    // 3. Pick backend.
+    // 4. Load conv/bn/linear + LSTM gate weights.
+    fprintf(stderr,
+            "[doctr_rec] init called for %s — GGML path not yet wired; weights must be built first.\n",
+            gguf_path);
+    delete ctx;
+    return nullptr;
+#else
+    fprintf(stderr,
+            "[doctr_rec] built without DOCTR_HAVE_GGML — weights cannot load.\n");
+    delete ctx;
+    return nullptr;
+#endif
+}
+
+extern "C" int doctr_rec_run(doctr_rec_ctx * ctx,
+                             const float * rgb_chw,
+                             int h, int w,
+                             float * out_logits,
+                             int * out_T, int * out_C) {
+    if (!ctx || !rgb_chw || !out_logits || !out_T || !out_C) {
+        return DOCTR_ERR_SHAPE;
+    }
+    if (h != ctx->input_h) return DOCTR_ERR_SHAPE;
+    if (w <= 0 || w > ctx->input_w) return DOCTR_ERR_SHAPE;
+
+#if defined(DOCTR_HAVE_GGML)
+    // Forward pass:
+    //   1. normalize input with mean/std
+    //   2. mobilenetv3-small backbone — outputs (1, 256, 1, w/8)
+    //   3. squeeze height -> (1, 256, w/8)
+    //   4. BiLSTM 128 hidden × 2 layers
+    //   5. linear projection to (charset_size + 1)
+    //
+    // Output: (T, C) row-major float32 logits.
+    *out_T = w / 8;
+    *out_C = ctx->charset_size + 1;
+    std::memset(out_logits, 0, sizeof(float) * (*out_T) * (*out_C));
+    return DOCTR_ERR_BACKEND;
+#else
+    *out_T = 0;
+    *out_C = 0;
+    return DOCTR_ERR_BACKEND;
+#endif
+}
+
+extern "C" const char * doctr_rec_charset(doctr_rec_ctx * ctx) {
+    return ctx ? ctx->charset.c_str() : nullptr;
+}
+
+extern "C" void doctr_rec_free(doctr_rec_ctx * ctx) {
+    if (!ctx) return;
+#if defined(DOCTR_HAVE_GGML)
+    if (ctx->gctx)    { ggml_free(ctx->gctx); }
+    if (ctx->backend) { ggml_backend_free(ctx->backend); }
+#endif
+    delete ctx;
+}