Function sam3_propagate_single

sam3.cpp:11175–11457

}

static sam3_prop_output sam3_propagate_single(
    sam3_tracker& tracker, sam3_state& state, const sam3_model& model,
    const sam3_masklet& masklet,
    const std::vector<sam3_memory_slot>& mem_bank,
    const std::vector<std::pair<int, struct ggml_tensor*>>& ptr_bank) {
    sam3_prop_output output = {};
    const auto& hp = model.hparams;
    const int D = hp.neck_dim, MD = hp.mem_out_dim;
    const int H = sam3_eff_feat_size(state, hp);
    const int N = H * H;

    auto sel = sam3_select_memory_frames(mem_bank, hp.num_maskmem);
    if (sel.empty()) return output;

    // ── Build prompt and prompt_pos via sam3_build_prompt_and_pos ─────────
    // EdgeTAM with perceiver: each slot has 512 tokens (not H*H).
    // Standard SAM2/SAM3: each slot has H*H tokens.
    const bool use_perceiver = hp.has_perceiver != 0;
    const int N_per_slot = use_perceiver ? (hp.perceiver_n_latents_1d + hp.perceiver_n_latents_2d) : N;

    int n_sel = (int)sel.size();
    std::vector<std::vector<float>> slot_feats(n_sel), slot_pes(n_sel);
    std::vector<int> spatial_tpos(n_sel, 1);  // default t_pos=1 for non-cond
    for (int s = 0; s < n_sel; ++s) {
        slot_feats[s].resize(MD * N_per_slot);
        ggml_backend_tensor_get(mem_bank[sel[s]].spatial_feats,
                                slot_feats[s].data(), 0, MD * N_per_slot * sizeof(float));
        slot_pes[s].resize(MD * N_per_slot);
        if (mem_bank[sel[s]].spatial_pe) {
            ggml_backend_tensor_get(mem_bank[sel[s]].spatial_pe,
                                    slot_pes[s].data(), 0, MD * N_per_slot * sizeof(float));
        } else {
            sam3_ensure_tracker_pe_caches(tracker, hp, H);
            if (use_perceiver) {
                // For perceiver: zeros for 1D tokens, sinusoidal for 2D tokens
                const int N_1d = hp.perceiver_n_latents_1d;
                const int N_2d = hp.perceiver_n_latents_2d;
                memset(slot_pes[s].data(), 0, MD * N_1d * sizeof(float));
                auto pe_2d = sam3_sinusoidal_pe_2d(16, 16, MD);
                memcpy(slot_pes[s].data() + MD * N_1d, pe_2d.data(), MD * N_2d * sizeof(float));
            } else {
                slot_pes[s] = tracker.cached_sinpe_64;
            }
        }
        spatial_tpos[s] = mem_bank[sel[s]].is_cond_frame ? 0 : (n_sel - s);
    }

    int P = std::min((int)ptr_bank.size(), hp.max_obj_ptrs);
    std::vector<std::vector<float>> obj_ptrs(P);
    std::vector<int> ptr_tpos(P);
    int cur_frame = tracker.frame_index;
    for (int p = 0; p < P; ++p) {
        obj_ptrs[p].resize(D);
        ggml_backend_tensor_get(ptr_bank[p].second, obj_ptrs[p].data(), 0, D * sizeof(float));
        // Use actual frame distance (matches Python: abs(frame_idx - t))
        ptr_tpos[p] = std::abs(cur_frame - ptr_bank[p].first);
        if (ptr_tpos[p] < 1) ptr_tpos[p] = 1;  // minimum distance of 1
    }