Add AMD support via ort alternative to trt

src/nodes/embedder_node.hpp

@@ -1,9 +1,8 @@
 #pragma once
-#include "arcface_embedder.hpp"
 #include "config.hpp"
-#include "ort_provider.hpp"
-#include "trt_arcface_embedder.hpp"
+#include "inference/face_embedder.hpp"
 
+#include <algorithm>
 #include <memory>
 #include <stdexcept>
 #include <string>
@@ -12,31 +11,25 @@
 // KPN node: runs ArcFace on every 112×112 crop in an AlignedSceneFrame,
 // producing one L2-normalised 512-dim embedding per face.
 //
-// Backend selection:
-//   --arcface-engine <path>   → TrtArcFaceEmbedder (raw TensorRT, no ORT)
-//   otherwise                 → ArcFaceEmbedder (ONNX Runtime, picks best EP)
+// The inference backend (ONNX Runtime or raw TensorRT) is selected at compile
+// time; this node talks only to IFaceEmbedder via make_face_embedder(cfg).
 //
 // All crops in one frame are batched into a single forward pass (capped at
-// embed_batch_size). The backends serialise themselves; we only call them
-// from the single embedder thread.
+// embed_batch_size). The backend serialises itself; we only call it from the
+// single embedder thread.
 
 struct EmbedderFunc {
     static constexpr std::string_view label() { return "embedder"; }
 
-    explicit EmbedderFunc(const Config& cfg, OrtProvider provider)
-        : batch_size_(std::max(1, cfg.embed_batch_size))
+    explicit EmbedderFunc(const Config& cfg)
+        : embedder_(make_face_embedder(cfg))
+        , batch_size_(std::max(1, cfg.embed_batch_size))
     {
-        if (!cfg.arcface_engine.empty()) {
-            trt_ = std::make_unique<TrtArcFaceEmbedder>(cfg.arcface_engine);
-            if (trt_->max_batch() < static_cast<int>(batch_size_))
-                throw std::runtime_error(
-                    "embed_batch_size " + std::to_string(batch_size_) +
-                    " exceeds engine max_batch " + std::to_string(trt_->max_batch()) +
-                    " — rebuild engine with EMBED_BATCH=" + std::to_string(batch_size_));
-        } else {
-            ort_ = std::make_unique<ArcFaceEmbedder>(
-                cfg.arcface_model, provider, cfg.trt, cfg.embed_batch_size);
-        }
+        if (embedder_->max_batch() < static_cast<int>(batch_size_))
+            throw std::runtime_error(
+                "embed_batch_size " + std::to_string(batch_size_) +
+                " exceeds backend max_batch " + std::to_string(embedder_->max_batch()) +
+                " — rebuild the engine with EMBED_BATCH=" + std::to_string(batch_size_));
     }
 
     EmbeddedSceneFrame operator()(AlignedSceneFrame af) {
@@ -49,7 +42,7 @@ struct EmbedderFunc {
         for (size_t i = 0; i < crops.size(); i += batch_size_) {
             const size_t end = std::min(i + batch_size_, crops.size());
             std::vector<cv::Mat> chunk_crops(crops.begin() + i, crops.begin() + end);
-            auto chunk = trt_ ? trt_->embed(chunk_crops) : ort_->embed(chunk_crops);
+            auto chunk = embedder_->embed(chunk_crops);
             embeddings.insert(embeddings.end(), chunk.begin(), chunk.end());
         }
 
@@ -60,7 +53,6 @@ struct EmbedderFunc {
     }
 
 private:
-    std::unique_ptr<ArcFaceEmbedder>    ort_;
-    std::unique_ptr<TrtArcFaceEmbedder> trt_;
-    size_t                              batch_size_;
+    std::unique_ptr<IFaceEmbedder> embedder_;
+    size_t batch_size_;
 };