# Frequently Asked Questions

// Development environment
VFPAnalyzer.SetLicenseKey("TRIAL");

// Production environment
VFPAnalyzer.SetLicenseKey(Environment.GetEnvironmentVariable("VFP_LICENSE_KEY"));

public class LicenseManager
{
    private const string EncryptedLicense = "YOUR_ENCRYPTED_LICENSE";
    
    public static void Initialize()
    {
        // Decrypt license at runtime
        string licenseKey = DecryptLicense(EncryptedLicense);
        VFPAnalyzer.SetLicenseKey(licenseKey);
    }
    
    private static string DecryptLicense(string encrypted)
    {
        // Implement your decryption logic
        // Never store plain text licenses in distributed apps
        return Decrypt(encrypted);
    }
}

// Approximate memory usage calculation
long EstimateMemoryUsage(int width, int height, int durationSeconds)
{
    // Base memory for decoder and buffers
    long baseMemory = 100 * 1024 * 1024; // 100 MB
    
    // Frame buffer memory (3-5 frames typically buffered)
    long frameSize = width * height * 3; // RGB
    long frameBuffers = frameSize * 5;
    
    // Fingerprint data (approximately 1KB per second)
    long fingerprintSize = durationSeconds * 1024;
    
    return baseMemory + frameBuffers + fingerprintSize;
}

// Example: 1080p video, 10 minutes
// Memory ≈ 100MB + (1920*1080*3*5) + (600*1KB) ≈ 131MB

public class ParallelProcessor
{
    private readonly SemaphoreSlim _semaphore;
    
    public ParallelProcessor(int maxConcurrency = 4)
    {
        // Limit based on CPU cores and available memory
        _semaphore = new SemaphoreSlim(maxConcurrency);
    }
    
    public async Task ProcessMultipleVideos(string[] videoPaths)
    {
        var tasks = videoPaths.Select(ProcessVideoAsync);
        await Task.WhenAll(tasks);
    }
    
    private async Task ProcessVideoAsync(string videoPath)
    {
        await _semaphore.WaitAsync();
        try
        {
            var source = new VFPFingerprintSource(videoPath)
            {
                // Reduce resolution for parallel processing
                CustomResolution = new Size(640, 480)
            };
            
            var fp = await VFPAnalyzer.GetComparingFingerprintForVideoFileAsync(source);
            // Process fingerprint...
        }
        finally
        {
            _semaphore.Release();
        }
    }
}

var source = new VFPFingerprintSource(videoPath)
{
    UseHardwareAcceleration = true,
    HardwareDevice = "cuda" // or "qsv", "d3d11va"
};

// Process 30-second segments for live streams
var source = new VFPFingerprintSource(streamUrl)
{
    StartTime = TimeSpan.FromSeconds(segmentIndex * 30),
    StopTime = TimeSpan.FromSeconds((segmentIndex + 1) * 30),
    CustomResolution = new Size(480, 360) // Lower resolution
};

var source = new VFPFingerprintSource(videoPath)
{
    FrameRate = 5 // Process 5 fps instead of full framerate
};

public enum MatchingThreshold
{
    Identical = 5,        // Same file, different encoding
    NearDuplicate = 15,   // Minor quality differences
    Similar = 30,         // Same content, some modifications
    Related = 50,         // Significant modifications (watermarks, etc.)
    PossiblyRelated = 100 // Heavy transformations
}

public bool IsMatch(int difference, MatchingThreshold threshold)
{
    return difference <= (int)threshold;
}

// Search for a 30-second clip in a 2-hour movie
var searchFp = await VFPAnalyzer.GetSearchFingerprintForVideoFileAsync(
    new VFPFingerprintSource("clip.mp4")
);

var mainFp = await VFPAnalyzer.GetSearchFingerprintForVideoFileAsync(
    new VFPFingerprintSource("movie.mp4")
);

var results = VFPAnalyzer.Search(mainFp, searchFp, searchFp.Duration);

foreach (var result in results)
{
    Console.WriteLine($"Found match at {result.Position} with score {result.Score}");
}

// For videos with letterboxing/pillarboxing
var source = new VFPFingerprintSource(videoPath)
{
    // Ignore black bars
    IgnoredAreas = new List<Rectangle>
    {
        new Rectangle(0, 0, 1920, 140),    // Top letterbox
        new Rectangle(0, 940, 1920, 140)   // Bottom letterbox
    }
};

// Or use smart cropping
var source = new VFPFingerprintSource(videoPath)
{
    AutoCropBlackBars = true
};

// For mirrored video detection
public async Task<bool> CheckMirroredMatch(string video1, string video2)
{
    var fp1 = await GenerateFingerprint(video1);
    var fp2 = await GenerateFingerprint(video2);
    
    // Check normal orientation
    int normalDiff = VFPAnalyzer.Compare(fp1, fp2);
    if (normalDiff < 30) return true;
    
    // Check mirrored version
    var fp2Mirrored = await GenerateFingerprint(video2, mirror: true);
    int mirroredDiff = VFPAnalyzer.Compare(fp1, fp2Mirrored);
    
    return mirroredDiff < 30;
}

### Q: What about audio-only files?

**A:** The Video Fingerprinting SDK requires video content.

## Platform Compatibility

### Q: Which platforms are supported?

**A:** Full platform support matrix:

| Platform | Architecture | .NET Version | Status |
|----------|-------------|-------------|---------|
| Windows 10/11 | x86, x64, ARM64 | .NET Framework 4.6.1+, .NET 6+ | ✅ Full Support |
| Windows Server 2016+ | x64 | .NET Framework 4.6.1+, .NET 6+ | ✅ Full Support |
| Ubuntu 20.04+ | x64, ARM64 | .NET 6+ | ✅ Full Support |
| Debian 11+ | x64, ARM64 | .NET 6+ | ✅ Full Support |
| RHEL/CentOS 8+ | x64 | .NET 6+ | ✅ Full Support |
| macOS 12+ | x64, ARM64 | .NET 6+ | ✅ Full Support |
| Docker/Kubernetes | Linux-based | .NET 6+ | ✅ Full Support |

### Q: Can I use the SDK in Docker containers?

**A:** Yes! Here's a sample Dockerfile:

```dockerfile
FROM mcr.microsoft.com/dotnet/runtime:6.0 AS base
WORKDIR /app

# Install GStreamer and dependencies
RUN apt-get update && apt-get install -y \
    libgstreamer1.0-0 \
    gstreamer1.0-plugins-base \
    gstreamer1.0-plugins-good \
    gstreamer1.0-plugins-bad \
    gstreamer1.0-plugins-ugly \
    gstreamer1.0-libav \
    && rm -rf /var/lib/apt/lists/*

FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["YourProject.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet build -c Release -o /app/build

FROM build AS publish
RUN dotnet publish -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "YourProject.dll"]

// Use GPU instances for better performance
// Recommended: g4dn.xlarge or p3.2xlarge

// Use NCv3-series or NVv4-series VMs
// Enable GPU acceleration in container instances

// Use N1 with NVIDIA Tesla GPUs
// Or A2 machine series for best performance

public class VideoFingerprintService
{
    private readonly ILogger<VideoFingerprintService> _logger;
    
    public VideoFingerprintService(ILogger<VideoFingerprintService> logger)
    {
        _logger = logger;
        VFPAnalyzer.SetLicenseKey(Environment.GetEnvironmentVariable("VFP_LICENSE"));
    }
    
    public async Task<IActionResult> ProcessUpload(IFormFile file)
    {
        var tempPath = Path.GetTempFileName();
        try
        {
            using (var stream = new FileStream(tempPath, FileMode.Create))
            {
                await file.CopyToAsync(stream);
            }
            
            var fingerprint = await GenerateFingerprint(tempPath);
            // Store fingerprint in database
            
            return Ok(new { Success = true, FingerprintId = fingerprint.Id });
        }
        finally
        {
            File.Delete(tempPath);
        }
    }
}

public class ProgressTracker
{
    public event EventHandler<int> ProgressChanged;
    
    public async Task<VFPFingerPrint> ProcessWithProgress(string videoPath)
    {
        var source = new VFPFingerprintSource(videoPath);
        
        return await VFPAnalyzer.GetComparingFingerprintForVideoFileAsync(
            source,
            errorDelegate: (error) => {
                Console.WriteLine($"Error: {error}");
            },
            progressDelegate: (progress) => {
                ProgressChanged?.Invoke(this, progress);
            }
        );
    }
}

// Usage in WPF/WinForms
tracker.ProgressChanged += (s, progress) => {
    Dispatcher.Invoke(() => {
        progressBar.Value = progress;
        labelStatus.Text = $"Processing: {progress}%";
    });
};

// SQL Server example
public class FingerprintRepository
{
    public async Task SaveFingerprint(VFPFingerPrint fp, string videoId)
    {
        // Option 1: Store as binary
        byte[] data = fp.Save();
        
        using var connection = new SqlConnection(connectionString);
        await connection.ExecuteAsync(
            @"INSERT INTO Fingerprints (VideoId, Data, Duration, Width, Height, Created)
              VALUES (@VideoId, @Data, @Duration, @Width, @Height, @Created)",
            new {
                VideoId = videoId,
                Data = data,
                Duration = fp.Duration.TotalSeconds,
                Width = fp.Width,
                Height = fp.Height,
                Created = DateTime.UtcNow
            });
    }
    
    public async Task<VFPFingerPrint> LoadFingerprint(string videoId)
    {
        using var connection = new SqlConnection(connectionString);
        var data = await connection.QuerySingleAsync<byte[]>(
            "SELECT Data FROM Fingerprints WHERE VideoId = @VideoId",
            new { VideoId = videoId });
        
        return VFPFingerPrint.Load(data);
    }
}

// MongoDB example
public class MongoFingerprintRepository
{
    private readonly IMongoCollection<FingerprintDocument> _collection;
    
    public async Task SaveFingerprint(VFPFingerPrint fp, string videoId)
    {
        var document = new FingerprintDocument
        {
            VideoId = videoId,
            Data = Convert.ToBase64String(fp.Save()),
            Metadata = new FingerprintMetadata
            {
                Duration = fp.Duration,
                Width = fp.Width,
                Height = fp.Height,
                FrameRate = fp.FrameRate
            }
        };
        
        await _collection.InsertOneAsync(document);
    }
}

public long EstimateStorageNeeded(int videoCount, double avgDurationMinutes)
{
    // Search fingerprints (worst case)
    long bytesPerMinute = 60 * 1024; // 60 KB
    long fingerprintSize = (long)(bytesPerMinute * avgDurationMinutes);
    
    // Add 20% overhead for metadata
    long totalPerVideo = (long)(fingerprintSize * 1.2);
    
    // Total storage needed
    return videoCount * totalPerVideo;
}

// Example: 10,000 videos, 30 minutes average
// Storage ≈ 10,000 * (60KB * 30 * 1.2) = ~21 GB

public class HybridStorage
{
    // Metadata in database for fast queries
    private readonly SqlConnection _db;
    
    // Fingerprint data in object storage
    private readonly IS3Client _s3;
    
    public async Task SaveFingerprint(VFPFingerPrint fp, VideoMetadata metadata)
    {
        // Save fingerprint to S3
        string s3Key = $"fingerprints/{metadata.VideoId}.vfp";
        await _s3.PutObjectAsync(s3Key, fp.Save());
        
        // Save metadata to database
        await _db.ExecuteAsync(
            @"INSERT INTO Videos (Id, Title, Duration, S3Key)
              VALUES (@Id, @Title, @Duration, @S3Key)",
            new {
                metadata.Id,
                metadata.Title,
                metadata.Duration,
                S3Key = s3Key
            });
    }
}

public class PerformanceMonitor
{
    public async Task<FingerprintMetrics> ProcessWithMetrics(string videoPath)
    {
        var metrics = new FingerprintMetrics();
        var sw = Stopwatch.StartNew();
        
        // Check file size
        var fileInfo = new FileInfo(videoPath);
        metrics.FileSize = fileInfo.Length;
        
        // Monitor memory before
        long memoryBefore = GC.GetTotalMemory(false);
        
        var source = new VFPFingerprintSource(videoPath);
        var fingerprint = await VFPAnalyzer.GetComparingFingerprintForVideoFileAsync(
            source,
            progressDelegate: (progress) => {
                if (progress % 10 == 0)
                {
                    long currentMemory = GC.GetTotalMemory(false);
                    Console.WriteLine($"Progress: {progress}%, Memory: {currentMemory / 1024 / 1024} MB");
                }
            }
        );
        
        sw.Stop();
        
        metrics.ProcessingTime = sw.Elapsed;
        metrics.MemoryUsed = GC.GetTotalMemory(false) - memoryBefore;
        metrics.ProcessingSpeed = fileInfo.Length / sw.Elapsed.TotalSeconds;
        
        Console.WriteLine($"Performance Report:");
        Console.WriteLine($"  File Size: {metrics.FileSize / 1024 / 1024} MB");
        Console.WriteLine($"  Processing Time: {metrics.ProcessingTime}");
        Console.WriteLine($"  Memory Used: {metrics.MemoryUsed / 1024 / 1024} MB");
        Console.WriteLine($"  Speed: {metrics.ProcessingSpeed / 1024 / 1024} MB/s");
        
        return metrics;
    }
}