# Video Fingerprinting SDK C++ Code Samples

// vfp_generate.cpp - Generate fingerprints from video files
#include <VisioForge_VFP.h>

int main(int argc, char* argv[]) {
    if (argc < 3) {
        std::cerr << "Usage: vfp_generate <input_video> <output_fingerprint>" << std::endl;
        return 1;
    }
    
    // Set license
    VFPSetLicenseKey(L"TRIAL");
    
    // Generate fingerprint
    VFP_SearchFingerprintGenerateSettings settings;
    settings.Mode = VFP_Mode::Search;
    settings.FrameStep = 10;
    
    auto result = VFPSearchFingerprintGenerate(
        argv[1],  // Input video
        argv[2],  // Output fingerprint
        &settings,
        nullptr   // Progress callback
    );
    
    return result == VFP_ErrorCode::Ok ? 0 : 1;
}

// vfp_compare.cpp - Compare two video fingerprints
#include <VisioForge_VFP.h>

int main(int argc, char* argv[]) {
    if (argc < 3) {
        std::cerr << "Usage: vfp_compare <fingerprint1> <fingerprint2>" << std::endl;
        return 1;
    }
    
    VFPSetLicenseKey(L"TRIAL");
    
    VFP_CompareResult result;
    auto status = VFPCompareFingerprints(
        argv[1],
        argv[2],
        &result
    );
    
    if (status == VFP_ErrorCode::Ok) {
        std::cout << "Similarity: " << result.Similarity << "%" << std::endl;
        std::cout << "Match: " << (result.IsMatch ? "Yes" : "No") << std::endl;
    }
    
    return status == VFP_ErrorCode::Ok ? 0 : 1;
}

// vfp_search.cpp - Search for video fragments
#include <VisioForge_VFP.h>

int main(int argc, char* argv[]) {
    if (argc < 3) {
        std::cerr << "Usage: vfp_search <source_fingerprint> <target_fingerprint>" << std::endl;
        return 1;
    }
    
    VFPSetLicenseKey(L"TRIAL");
    
    VFP_SearchResult* results = nullptr;
    int count = 0;
    
    auto status = VFPSearchFingerprint(
        argv[1],  // Source (fragment)
        argv[2],  // Target (full video)
        &results,
        &count
    );
    
    if (status == VFP_ErrorCode::Ok) {
        std::cout << "Found " << count << " matches" << std::endl;
        for (int i = 0; i < count; i++) {
            std::cout << "Match " << i << ": Position " 
                     << results[i].Position << "ms, Similarity " 
                     << results[i].Similarity << "%" << std::endl;
        }
        VFPFreeSearchResults(results);
    }
    
    return status == VFP_ErrorCode::Ok ? 0 : 1;
}

# Open the Visual Studio solution
samples/cpp/VFPSamples.sln

# Or build from command line
msbuild VFPSamples.sln /p:Configuration=Release /p:Platform=x64

cd samples/cpp
mkdir build && cd build
cmake ..
make

#include <thread>
#include <vector>
#include <queue>
#include <mutex>

class FingerprintProcessor {
private:
    std::queue<std::string> videoQueue;
    std::mutex queueMutex;
    
public:
    void ProcessVideos(const std::vector<std::string>& videos) {
        const int numThreads = std::thread::hardware_concurrency();
        std::vector<std::thread> workers;
        
        // Fill queue
        for (const auto& video : videos) {
            videoQueue.push(video);
        }
        
        // Start worker threads
        for (int i = 0; i < numThreads; i++) {
            workers.emplace_back(&FingerprintProcessor::Worker, this);
        }
        
        // Wait for completion
        for (auto& worker : workers) {
            worker.join();
        }
    }
    
private:
    void Worker() {
        while (true) {
            std::string video;
            {
                std::lock_guard<std::mutex> lock(queueMutex);
                if (videoQueue.empty()) break;
                video = videoQueue.front();
                videoQueue.pop();
            }
            
            ProcessVideo(video);
        }
    }
    
    void ProcessVideo(const std::string& video) {
        VFP_SearchFingerprintGenerateSettings settings;
        settings.Mode = VFP_Mode::Search;
        
        std::string output = video + ".vfp";
        VFPSearchFingerprintGenerate(
            video.c_str(),
            output.c_str(),
            &settings,
            nullptr
        );
    }
};

// Example using SQLite for fingerprint storage
#include <sqlite3.h>

class FingerprintDatabase {
private:
    sqlite3* db;
    
public:
    void StoreFingerprint(const std::string& videoPath, 
                         const std::vector<uint8_t>& fingerprint) {
        const char* sql = "INSERT INTO fingerprints (path, data) VALUES (?, ?)";
        sqlite3_stmt* stmt;
        sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr);
        
        sqlite3_bind_text(stmt, 1, videoPath.c_str(), -1, SQLITE_STATIC);
        sqlite3_bind_blob(stmt, 2, fingerprint.data(), 
                         fingerprint.size(), SQLITE_STATIC);
        
        sqlite3_step(stmt);
        sqlite3_finalize(stmt);
    }
    
    std::vector<uint8_t> LoadFingerprint(const std::string& videoPath) {
        const char* sql = "SELECT data FROM fingerprints WHERE path = ?";
        sqlite3_stmt* stmt;
        sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr);
        
        sqlite3_bind_text(stmt, 1, videoPath.c_str(), -1, SQLITE_STATIC);
        
        std::vector<uint8_t> fingerprint;
        if (sqlite3_step(stmt) == SQLITE_ROW) {
            const void* data = sqlite3_column_blob(stmt, 0);
            int size = sqlite3_column_bytes(stmt, 0);
            
            fingerprint.resize(size);
            memcpy(fingerprint.data(), data, size);
        }
        
        sqlite3_finalize(stmt);
        return fingerprint;
    }
};