Skip to content

Video Fingerprinting SDK for C++

Overview

The Video Fingerprinting SDK for C++ provides a native implementation with direct access to high-performance video analysis and fingerprinting capabilities. This SDK is ideal for applications requiring:

  • Maximum performance and minimal overhead
  • Direct integration with native applications
  • Custom memory management
  • Real-time processing pipelines
  • Embedded systems deployment

Key Features

Performance Advantages

  • Native Performance - Direct memory access and optimized algorithms
  • Zero Overhead - No managed runtime or garbage collection
  • SIMD Optimization - Leverages CPU vectorization capabilities
  • Parallel Processing - Multi-threaded fingerprint generation
  • Custom Memory Management - Fine-grained control over memory allocation

Platform Support

  • Windows - Visual Studio 2019+ (x64)
  • Linux - GCC 9+ or Clang 10+
  • macOS - Xcode 12+ (Intel and Apple Silicon)

Documentation

Getting Started

Core Concepts

Code Examples

Basic Fingerprint Generation

#include <VFPAnalyzer.h>

// Create analyzer instance
auto analyzer = std::make_unique<VFPAnalyzer>();

// Configure analysis parameters
VFPAnalyzerSettings settings;
settings.Mode = VFPAnalyzerMode::Search;
settings.FrameStep = 10;

// Set license key
analyzer->SetLicenseKey("your-license-key");

// Process video file
analyzer->StartAsync("input_video.mp4", "output.vfp", settings);

Comparing Two Videos

#include <VFPCompare.h>

// Create comparison instance
auto compare = std::make_unique<VFPCompare>();

// Set license
compare->SetLicenseKey("your-license-key");

// Load fingerprints
compare->LoadFingerprint("video1.vfp");
compare->LoadFingerprint("video2.vfp");

// Perform comparison
auto result = compare->Compare();

// Check similarity
std::cout << "Similarity: " << result.Similarity << "%" << std::endl;
if (result.IsMatch) {
    std::cout << "Videos match!" << std::endl;
}

Integration Patterns

Memory-Efficient Processing

// Process large video collections with minimal memory
class VideoProcessor {
public:
    void ProcessBatch(const std::vector<std::string>& videos) {
        VFPAnalyzer analyzer;
        analyzer.SetLicenseKey(m_licenseKey);

        for (const auto& video : videos) {
            // Process and immediately store/transmit fingerprint
            analyzer.StartAsync(video, 
                [this](const std::string& fingerprint) {
                    // Store in database or send to server
                    StoreFingerprint(fingerprint);
                });
        }
    }
};

Real-Time Stream Analysis

// Analyze live video streams
class StreamAnalyzer {
public:
    void AnalyzeStream(const std::string& streamUrl) {
        VFPAnalyzer analyzer;
        VFPAnalyzerSettings settings;
        settings.Mode = VFPAnalyzerMode::RealTime;
        settings.BufferSize = 30; // 30 second buffer

        analyzer.SetLicenseKey(m_licenseKey);
        analyzer.StartStreamAnalysis(streamUrl, settings,
            [](const VFPSegment& segment) {
                // Process detected segments in real-time
                ProcessSegment(segment);
            });
    }
};

Support and Resources

Documentation

Sample Code

  • Complete Examples - Working code samples
  • Command-line tools in SDK package /samples/cpp/

Community and Support

License Registration

Register the SDK in your C++ application:

// In your initialization code
VFPAnalyzer analyzer;
analyzer.SetLicenseKey("your-license-key");

// Or globally for all instances
VFPLicense::SetGlobalKey("your-license-key");

Next Steps

  1. Install and Setup - Get started with the C++ SDK
  2. Review the API - Understand available classes and methods
  3. Explore Examples - See working code