FAQ du Video Fingerprinting SDK¶

// Environnement de développement
VFPAnalyzer.SetLicenseKey("TRIAL");

// Environnement de production
VFPAnalyzer.SetLicenseKey(Environment.GetEnvironmentVariable("VFP_LICENSE_KEY"));

public class LicenseManager
{
    private const string EncryptedLicense = "YOUR_ENCRYPTED_LICENSE";

    public static void Initialize()
    {
        // Déchiffrer la licence à l'exécution
        string licenseKey = DecryptLicense(EncryptedLicense);
        VFPAnalyzer.SetLicenseKey(licenseKey);
    }

    private static string DecryptLicense(string encrypted)
    {
        // Implémenter votre logique de déchiffrement
        // Ne jamais stocker de licences en clair dans des applis distribuées
        return Decrypt(encrypted);
    }
}

// Calcul approximatif de l'utilisation mémoire
long EstimateMemoryUsage(int width, int height, int durationSeconds)
{
    // Mémoire de base pour le décodeur et les tampons
    long baseMemory = 100 * 1024 * 1024; // 100 Mo

    // Mémoire des tampons d'image (3 à 5 images mises en tampon typiquement)
    long frameSize = width * height * 3; // RGB
    long frameBuffers = frameSize * 5;

    // Données d'empreinte (environ 1 Ko par seconde)
    long fingerprintSize = durationSeconds * 1024;

    return baseMemory + frameBuffers + fingerprintSize;
}

// Exemple : vidéo 1080p, 10 minutes
// Mémoire ≈ 100 Mo + (1920*1080*3*5) + (600*1Ko) ≈ 131 Mo

public class ParallelProcessor
{
    private readonly SemaphoreSlim _semaphore;

    public ParallelProcessor(int maxConcurrency = 4)
    {
        // Limiter selon les cœurs CPU et la mémoire disponible
        _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)
            {
                // Réduire la résolution pour le traitement parallèle
                CustomResolution = new Size(640, 480)
            };

            var fp = await VFPAnalyzer.GetComparingFingerprintForVideoFileAsync(source);
            // Traiter l'empreinte...
        }
        finally
        {
            _semaphore.Release();
        }
    }
}

public enum MatchingThreshold
{
    Identical = 5,        // Même fichier, encodage différent
    NearDuplicate = 15,   // Différences de qualité mineures
    Similar = 30,         // Même contenu, quelques modifications
    Related = 50,         // Modifications significatives (filigranes, etc.)
    PossiblyRelated = 100 // Transformations lourdes
}

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

// Rechercher un clip de 30 secondes dans un film de 2 heures
var searchFp = await VFPAnalyzer.GetSearchFingerprintForVideoFileAsync(
    new VFPFingerprintSource("clip.mp4")
);

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

// VFPAnalyzer.SearchAsync nécessite la forme complète à 5 arguments ; le résultat est List<TimeSpan>,
// chaque entrée correspond au temps de début de la correspondance dans mainFp.
var results = await VFPAnalyzer.SearchAsync(
    mainFp,
    searchFp,
    searchFp.Duration,
    maxDifference: 25,
    allowMultipleFragments: true);

foreach (var matchStart in results)
{
    Console.WriteLine($"Correspondance trouvée commençant à {matchStart}");
}

// Pour les vidéos avec letterboxing/pillarboxing
// IgnoredAreas est `{ get; private set; }` de List<Rect> — alimenter via .Add(...).
// Le constructeur de Rect est (left, top, right, bottom), pas (x, y, width, height).
var source = new VFPFingerprintSource(videoPath);
source.IgnoredAreas.Add(new Rect(0, 0, 1920, 140));      // Letterbox haut
source.IgnoredAreas.Add(new Rect(0, 940, 1920, 1080));   // Letterbox bas

// Ou restreindre la zone d'analyse à une fenêtre de rognage fixe via CustomCropSize.
// (Aucune propriété AutoCropBlackBars n'existe — définissez CustomCropSize manuellement
// si vous souhaitez supprimer les barres letterbox avant l'empreinte.)
var croppedSource = new VFPFingerprintSource(videoPath)
{
    CustomCropSize = new Rect(0, 140, 1920, 940)         // Utiliser uniquement l'image centrale 1920x800
};

// Pour la détection de vidéo en miroir
public async Task<bool> CheckMirroredMatch(string video1, string video2)
{
    var fp1 = await GenerateFingerprint(video1);
    var fp2 = await GenerateFingerprint(video2);

    // Vérifier l'orientation normale
    int normalDiff = VFPAnalyzer.Compare(fp1, fp2);
    if (normalDiff < 30) return true;

    // VFPSearch.SearchMirror compare fp1 contre la version horizontalement
    // mise en miroir de fp2 en un seul appel (pas besoin de regénérer l'empreinte).
    var mirrorResult = VFPSearch.SearchMirror(fp1, fp2);
    return mirrorResult != null && mirrorResult.Difference < 30;
}

// Utiliser des instances GPU pour une meilleure performance
// Recommandé : g4dn.xlarge ou p3.2xlarge

// Utiliser des VM NCv3-series ou NVv4-series
// Activer l'accélération GPU dans les instances de conteneur

// Utiliser N1 avec des GPU NVIDIA Tesla
// Ou la série de machines A2 pour les meilleures performances

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);
            // Stocker l'empreinte en base de données

            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($"Erreur : {error}");
            },
            progressDelegate: (progress) => {
                ProgressChanged?.Invoke(this, progress);
            }
        );
    }
}

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

// Exemple SQL Server
public class FingerprintRepository
{
    public async Task SaveFingerprint(VFPFingerPrint fp, string videoId)
    {
        // Option 1 : stocker comme binaire
        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);
    }
}

// Exemple MongoDB
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)
{
    // Empreintes de recherche (pire cas)
    long bytesPerMinute = 60 * 1024; // 60 Ko
    long fingerprintSize = (long)(bytesPerMinute * avgDurationMinutes);

    // Ajouter 20 % de surcharge pour les métadonnées
    long totalPerVideo = (long)(fingerprintSize * 1.2);

    // Stockage total nécessaire
    return videoCount * totalPerVideo;
}

// Exemple : 10 000 vidéos, 30 minutes de moyenne
// Stockage ≈ 10 000 * (60 Ko * 30 * 1,2) = ~21 Go

public class HybridStorage
{
    // Métadonnées en base de données pour des requêtes rapides
    private readonly SqlConnection _db;

    // Données d'empreinte dans le stockage objet
    private readonly IS3Client _s3;

    public async Task SaveFingerprint(VFPFingerPrint fp, VideoMetadata metadata)
    {
        // Enregistrer l'empreinte vers S3
        string s3Key = $"fingerprints/{metadata.VideoId}.vfp";
        await _s3.PutObjectAsync(s3Key, fp.Save());

        // Enregistrer les métadonnées en base
        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();

        // Vérifier la taille du fichier
        var fileInfo = new FileInfo(videoPath);
        metrics.FileSize = fileInfo.Length;

        // Surveiller la mémoire avant
        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($"Progression : {progress}%, Mémoire : {currentMemory / 1024 / 1024} Mo");
                }
            }
        );

        sw.Stop();

        metrics.ProcessingTime = sw.Elapsed;
        metrics.MemoryUsed = GC.GetTotalMemory(false) - memoryBefore;
        metrics.ProcessingSpeed = fileInfo.Length / sw.Elapsed.TotalSeconds;

        Console.WriteLine($"Rapport de performance :");
        Console.WriteLine($"  Taille du fichier : {metrics.FileSize / 1024 / 1024} Mo");
        Console.WriteLine($"  Temps de traitement : {metrics.ProcessingTime}");
        Console.WriteLine($"  Mémoire utilisée : {metrics.MemoryUsed / 1024 / 1024} Mo");
        Console.WriteLine($"  Vitesse : {metrics.ProcessingSpeed / 1024 / 1024} Mo/s");

        return metrics;
    }
}