Guide d'utilisation du bloc Overlay Manager¶

public class OverlayManagerBlock : MediaBlock, IMediaBlockInternals

public static bool IsAvailable()

public void Video_Overlay_Add(IOverlayManagerElement overlay)

public void Video_Overlay_Remove(IOverlayManagerElement overlay)

public void Video_Overlay_RemoveAt(int index)

public void Video_Overlay_Clear()

public void Video_Overlay_Update(IOverlayManagerElement overlay)

public class OverlayManagerText : IOverlayManagerElement

var text = new OverlayManagerText("Bonjour le monde !", 100, 100);
text.Color = SKColors.White;
text.Font.Size = 48;
text.Font.Name = "Arial";
text.Shadow = new OverlayManagerShadowSettings(true, depth: 5, direction: 45);
overlayManager.Video_Overlay_Add(text);

public class OverlayManagerImage : IOverlayManagerElement, IDisposable

// Depuis un fichier
new OverlayManagerImage(string filename, int x, int y, double alpha = 1.0)

// Depuis un bitmap SkiaSharp
new OverlayManagerImage(SKBitmap image, int x, int y, double alpha = 1.0)

// Depuis System.Drawing.Bitmap (Windows uniquement)
new OverlayManagerImage(System.Drawing.Bitmap image, int x, int y, double alpha = 1.0)

var image = new OverlayManagerImage("logo.png", 10, 10);
image.StretchMode = OverlayManagerImageStretchMode.Letterbox;
image.Width = 200;
image.Height = 100;
overlayManager.Video_Overlay_Add(image);

public class OverlayManagerGIF : IOverlayManagerElement, IDisposable

var gif = new OverlayManagerGIF("animation.gif", new SKPoint(150, 150));
overlayManager.Video_Overlay_Add(gif);

public class OverlayManagerImageSequence : IOverlayManagerElement, IDisposable

// Basique : position uniquement
new OverlayManagerImageSequence(IEnumerable<ImageSequenceItem> items, int x, int y)

// Complet : position, taille et mode d'étirement
new OverlayManagerImageSequence(
    IEnumerable<ImageSequenceItem> items,
    int x, int y,
    int width, int height,
    OverlayManagerImageStretchMode stretchMode = None)

// Ajouter dynamiquement une image pendant la lecture
void AddFrame(string filename, TimeSpan duration)

// Démarrer l'animation de position/taille
void StartAnimation(int targetX, int targetY, int targetWidth, int targetHeight,
    TimeSpan startTime, TimeSpan duration, OverlayManagerPanEasing easing = Linear)

// Obtenir la position/taille interpolée à l'instant donné
(int X, int Y, int Width, int Height) GetCurrentRect(TimeSpan currentTime)

// Effets de fondu
void StartFadeIn(TimeSpan startTime, TimeSpan duration, OverlayManagerPanEasing easing = Linear)
void StartFadeOut(TimeSpan startTime, TimeSpan duration, OverlayManagerPanEasing easing = Linear)
double GetCurrentOpacity(TimeSpan currentTime)

// Définir les images avec des durées par image
var items = new List<ImageSequenceItem>
{
    new ImageSequenceItem("slide1.png", TimeSpan.FromSeconds(3)),
    new ImageSequenceItem("slide2.png", TimeSpan.FromSeconds(2)),
    new ImageSequenceItem("slide3.png", TimeSpan.FromSeconds(4))
};

// Créer la séquence à la position (100, 100), mise à l'échelle à 320x240
var sequence = new OverlayManagerImageSequence(items, 100, 100, 320, 240)
{
    Loop = true,
    Opacity = 0.9,
    ZIndex = 5,
    Name = "SlideShow"
};

overlayManager.Video_Overlay_Add(sequence);

// Animer la séquence du coin supérieur gauche au centre sur 3 secondes
sequence.StartAnimation(
    targetX: 400, targetY: 200,
    targetWidth: 640, targetHeight: 480,
    startTime: TimeSpan.FromSeconds(2),
    duration: TimeSpan.FromSeconds(3),
    easing: OverlayManagerPanEasing.EaseInOut);

// Fondu entrant sur les 1,5 premières secondes
sequence.StartFadeIn(
    startTime: TimeSpan.Zero,
    duration: TimeSpan.FromSeconds(1.5),
    easing: OverlayManagerPanEasing.EaseOut);

// Ajouter une nouvelle image à une séquence en cours d'exécution
sequence.AddFrame("slide4.png", TimeSpan.FromSeconds(2.5));

// Ajouter une superposition de séquence d'images
var element = overlayManager.Video_Overlay_AddImageSequence(
    items, x: 100, y: 100, width: 320, height: 240,
    loop: true, name: "SlideShow");

// Mettre à jour la position
overlayManager.Video_Overlay_UpdateImageSequencePosition(
    "SlideShow", x: 200, y: 150, width: 400, height: 300);

// Animer position/taille
overlayManager.Video_Overlay_AnimateImageSequence(
    "SlideShow", targetX: 500, targetY: 300, targetWidth: 640, targetHeight: 480,
    startTime: currentPosition, duration: TimeSpan.FromSeconds(2),
    easing: OverlayManagerPanEasing.EaseInOut);

// Effets de fondu
overlayManager.Video_Overlay_ImageSequenceFadeIn(
    "SlideShow", startTime: currentPosition, duration: TimeSpan.FromSeconds(1));
overlayManager.Video_Overlay_ImageSequenceFadeOut(
    "SlideShow", startTime: currentPosition, duration: TimeSpan.FromSeconds(1));

public class ImageSequenceItem

// Constructeurs
new ImageSequenceItem()
new ImageSequenceItem(string filename, TimeSpan duration)

public class OverlayManagerDateTime : IOverlayManagerElement

var dateTime = new OverlayManagerDateTime();
dateTime.Format = "yyyy-MM-dd HH:mm:ss";
dateTime.X = 10;
dateTime.Y = 30;
overlayManager.Video_Overlay_Add(dateTime);

public class OverlayManagerScrollingText : IOverlayManagerElement

// Créer un texte défilant de style téléscripteur de nouvelles
var scrollingText = new OverlayManagerScrollingText(
    "Dernières nouvelles : VisioForge Media Framework prend désormais en charge les superpositions de texte défilant !",
    x: 0,
    y: 50,
    speed: 3,
    direction: ScrollDirection.RightToLeft);

scrollingText.Font.Size = 24;
scrollingText.Color = SKColors.Yellow;
scrollingText.BackgroundTransparent = false;
scrollingText.BackgroundColor = SKColors.DarkBlue;

// Définir la largeur par défaut pour correspondre à votre résolution vidéo
// Elle est utilisée lorsque Width n'est pas explicitement défini
scrollingText.DefaultWidth = 1920; // Largeur Full HD

// Ou définir Width directement pour une largeur de zone de défilement spécifique
// scrollingText.Width = 1920;

// Ajouter un gestionnaire d'événement pour quand le texte boucle
scrollingText.TextRestarted += (sender, e) => {
    Console.WriteLine("Le texte défilant a redémarré");
};

overlayManager.Video_Overlay_Add(scrollingText);

// Pour réinitialiser la position de défilement
scrollingText.Reset();

// Pour mettre à jour après modification du texte ou de la police
scrollingText.Text = "Texte de nouvelles mis à jour...";
scrollingText.Update();

public class OverlayManagerVideo : IOverlayManagerElement, IDisposable

// Créer une superposition de fichier vidéo
var videoOverlay = new OverlayManagerVideo(
    source: "intro.mp4",
    x: 100,
    y: 100,
    width: 640,
    height: 360)
{
    Loop = true,
    Opacity = 0.9,
    StretchMode = OverlayManagerImageStretchMode.Letterbox,
    ZIndex = 5
};

// Activer optionnellement la sortie audio
var audioOutputs = await AudioRendererBlock.GetDevicesAsync(AudioOutputDeviceAPI.DirectSound);
videoOverlay.AudioOutput = audioOutputs[0];
videoOverlay.AudioOutput_Volume = 0.5;

// Initialiser et ajouter au gestionnaire de superpositions
if (videoOverlay.Initialize(autoStart: true))
{
    overlayManager.Video_Overlay_Add(videoOverlay);
}

// Contrôler la lecture à l'exécution
videoOverlay.Pause();
videoOverlay.Seek(TimeSpan.FromSeconds(10));
videoOverlay.Play();

// Changer la source dynamiquement
videoOverlay.UpdateSource("outro.mp4");

// Nettoyer une fois terminé
videoOverlay.Stop();
videoOverlay.Dispose();

// Créer une petite vidéo PiP dans le coin
var pipVideo = new OverlayManagerVideo(
    source: "camera_feed.mp4",
    x: 20,
    y: 20,
    width: 240,
    height: 135)
{
    Loop = true,
    Opacity = 0.9,
    StretchMode = OverlayManagerImageStretchMode.Letterbox,
    ZIndex = 100,
    Shadow = new OverlayManagerShadowSettings
    {
        Enabled = true,
        Color = SKColors.DarkGray,
        Opacity = 0.7,
        BlurRadius = 8,
        Depth = 3,
        Direction = 45
    }
};

if (pipVideo.Initialize(autoStart: true))
{
    overlayManager.Video_Overlay_Add(pipVideo);
}

// Superposer un flux réseau
var streamOverlay = new OverlayManagerVideo(
    source: "rtsp://192.168.1.21:554/Streaming/Channels/101",
    x: 400,
    y: 50,
    width: 320,
    height: 240)
{
    Loop = false,
    StretchMode = OverlayManagerImageStretchMode.Letterbox,
    ZIndex = 10
};

if (streamOverlay.Initialize(autoStart: true))
{
    overlayManager.Video_Overlay_Add(streamOverlay);
}

public class OverlayManagerDecklinkVideo : IOverlayManagerElement

// Obtenir les périphériques Decklink
var devices = await DecklinkVideoSourceBlock.GetDevicesAsync();
var decklinkSettings = new DecklinkVideoSourceSettings(devices[0]);
decklinkSettings.Mode = DecklinkMode.HD1080p2997;

// Créer la superposition Decklink
var decklinkOverlay = new OverlayManagerDecklinkVideo(
    decklinkSettings,
    x: 10,
    y: 10,
    width: 640,
    height: 360);

// Initialiser et ajouter au gestionnaire de superpositions
if (decklinkOverlay.Initialize(autoStart: true))
{
    overlayManager.Video_Overlay_Add(decklinkOverlay);
}

// Nettoyer une fois terminé
decklinkOverlay.Stop();
decklinkOverlay.Dispose();

public class OverlayManagerNDIVideo : IOverlayManagerElement

// Découvrir les sources NDI sur le réseau
var ndiSources = await DeviceEnumerator.Shared.NDISourcesAsync();
var ndiSettings = await NDISourceSettings.CreateAsync(
    null,
    ndiSources[0].Name,
    ndiSources[0].URL);

// Créer la superposition NDI
var ndiOverlay = new OverlayManagerNDIVideo(
    ndiSettings,
    x: 10,
    y: 10,
    width: 640,
    height: 360);

// Initialiser et ajouter au gestionnaire de superpositions
if (ndiOverlay.Initialize(autoStart: true))
{
    overlayManager.Video_Overlay_Add(ndiOverlay);
}

// Nettoyer une fois terminé
ndiOverlay.Stop();
ndiOverlay.Dispose();

public class OverlayManagerWPFControl : IOverlayManagerElement, IDisposable

public OverlayManagerWPFControl Video_Overlay_AddWPFControl(
    Func<FrameworkElement> elementFactory,
    int x, int y, int width, int height,
    int refreshRate = 15,
    string name = null)

// Ajouter une superposition de texte avec cycle de couleurs via la méthode utilitaire
var wpfOverlay = overlayManager.Video_Overlay_AddWPFControl(
    elementFactory: () =>
    {
        var border = new Border
        {
            Width = 350,
            Height = 60,
            Background = new SolidColorBrush(Color.FromArgb(160, 0, 0, 0)),
            CornerRadius = new CornerRadius(8),
            Padding = new Thickness(15, 5, 15, 5)
        };

        var text = new TextBlock
        {
            Text = "VisioForge Media Framework",
            FontSize = 28,
            FontWeight = FontWeights.Bold,
            VerticalAlignment = VerticalAlignment.Center,
            HorizontalAlignment = HorizontalAlignment.Center
        };

        var brush = new SolidColorBrush(Colors.Red);
        text.Foreground = brush;
        border.Child = text;

        // Animer la couleur du texte
        var colorAnim = new ColorAnimationUsingKeyFrames
        {
            Duration = TimeSpan.FromSeconds(5),
            RepeatBehavior = RepeatBehavior.Forever
        };
        colorAnim.KeyFrames.Add(new LinearColorKeyFrame(Colors.Red, KeyTime.FromPercent(0.0)));
        colorAnim.KeyFrames.Add(new LinearColorKeyFrame(Colors.Gold, KeyTime.FromPercent(0.25)));
        colorAnim.KeyFrames.Add(new LinearColorKeyFrame(Colors.Cyan, KeyTime.FromPercent(0.5)));
        colorAnim.KeyFrames.Add(new LinearColorKeyFrame(Colors.Magenta, KeyTime.FromPercent(0.75)));
        colorAnim.KeyFrames.Add(new LinearColorKeyFrame(Colors.Red, KeyTime.FromPercent(1.0)));
        brush.BeginAnimation(SolidColorBrush.ColorProperty, colorAnim);

        return border;
    },
    x: 50, y: 300, width: 350, height: 60,
    refreshRate: 30, name: "ColorText");

if (wpfOverlay == null)
{
    // Échec de l'initialisation
}

// Créer manuellement une superposition d'horloge analogique WPF
var clockOverlay = new OverlayManagerWPFControl(
    elementFactory: () =>
    {
        var canvas = new Canvas { Width = 200, Height = 200 };

        // Cadran de l'horloge
        var face = new Ellipse
        {
            Width = 180, Height = 180,
            Stroke = Brushes.White, StrokeThickness = 3
        };
        Canvas.SetLeft(face, 10);
        Canvas.SetTop(face, 10);
        canvas.Children.Add(face);

        // Aiguille des secondes avec animation de rotation
        var secondHand = new Line
        {
            X1 = 100, Y1 = 100, X2 = 100, Y2 = 25,
            Stroke = Brushes.Red, StrokeThickness = 1
        };
        var secondRotate = new RotateTransform(DateTime.Now.Second * 6, 100, 100);
        secondHand.RenderTransform = secondRotate;
        canvas.Children.Add(secondHand);

        var anim = new DoubleAnimation
        {
            From = DateTime.Now.Second * 6,
            To = DateTime.Now.Second * 6 + 360,
            Duration = TimeSpan.FromSeconds(60),
            RepeatBehavior = RepeatBehavior.Forever
        };
        secondRotate.BeginAnimation(RotateTransform.AngleProperty, anim);

        return canvas;
    },
    x: 20, y: 20, width: 200, height: 200, refreshRate: 30);

if (clockOverlay.Initialize())
{
    overlayManager.Video_Overlay_Add(clockOverlay);
}

// Mettre à jour le contrôle WPF à l'exécution (thread-safe)
clockOverlay.InvokeOnUIThread(() =>
{
    // Sûr de modifier les éléments WPF ici
});

// Nettoyer
clockOverlay.Dispose();

public class OverlayManagerWebView2Video : IOverlayManagerElement, IDisposable

// Afficher une page web comme superposition vidéo
var webOverlay = new OverlayManagerWebView2Video(
    location: "https://example.com/dashboard",
    x: 50,
    y: 50,
    width: 640,
    height: 480)
{
    Opacity = 0.9,
    StretchMode = OverlayManagerImageStretchMode.Letterbox,
    ZIndex = 5
};

// Initialiser et ajouter au gestionnaire de superpositions
if (webOverlay.Initialize(autoStart: true))
{
    overlayManager.Video_Overlay_Add(webOverlay);
}
else
{
    webOverlay.Dispose();
}

// Superposer une page web et injecter du JavaScript pour la personnaliser
var tickerOverlay = new OverlayManagerWebView2Video(
    location: "https://example.com/ticker",
    x: 0,
    y: 680,
    width: 1920,
    height: 40)
{
    // JavaScript exécuté après chaque navigation terminée
    JavaScript = "document.body.style.background = 'transparent';",
    Opacity = 0.8,
    ZIndex = 10,
    Shadow = new OverlayManagerShadowSettings
    {
        Enabled = true,
        Color = SKColors.Black,
        Opacity = 0.5,
        BlurRadius = 5,
        Depth = 5,
        Direction = 45
    }
};

if (tickerOverlay.Initialize(autoStart: true))
{
    overlayManager.Video_Overlay_Add(tickerOverlay);
}

// Modifier la page affichée à l'exécution
webOverlay.UpdateLocation("https://example.com/new-page");

// Contrôler le rendu
webOverlay.Pause();
webOverlay.Play();

// Nettoyer une fois terminé
webOverlay.Stop();
webOverlay.Dispose();

public class OverlayManagerLine : IOverlayManagerElement

public class OverlayManagerRectangle : IOverlayManagerElement

public class OverlayManagerCircle : IOverlayManagerElement

public class OverlayManagerTriangle : IOverlayManagerElement

public class OverlayManagerStar : IOverlayManagerElement

public class OverlayManagerSVG : IOverlayManagerElement, IDisposable

public class OverlayManagerCallback : IOverlayManagerElement

public event EventHandler<OverlayManagerCallbackEventArgs> OnDraw;

var callback = new OverlayManagerCallback();
callback.OnDraw += (sender, e) => {
    var ctx = e.Context;
    ctx.SetSourceRGB(1, 0, 0);
    ctx.Arc(200, 200, 50, 0, 2 * Math.PI);
    ctx.Fill();
};
overlayManager.Video_Overlay_Add(callback);

public class OverlayManagerGroup : IOverlayManagerElement, IDisposable

// Créer un groupe pour les superpositions qui doivent démarrer simultanément
var group = new OverlayManagerGroup("SyncGroup");

// Ajouter une superposition de fichier vidéo
var videoOverlay = new OverlayManagerVideo(
    source: "intro.mp4",
    x: 10, y: 10, width: 640, height: 360)
{
    Loop = true,
    ZIndex = 10
};
group.Add(videoOverlay);

// Ajouter une superposition de capture Decklink
var decklinkSettings = new DecklinkVideoSourceSettings(deviceNumber);
decklinkSettings.Mode = DecklinkMode.HD1080p2997;

var decklinkOverlay = new OverlayManagerDecklinkVideo(
    settings: decklinkSettings,
    x: 660, y: 10, width: 640, height: 360)
{
    ZIndex = 11
};

// Initialiser Decklink manuellement (le groupe ne gère qu'OverlayManagerVideo)
decklinkOverlay.Initialize(autoStart: false);
group.Add(decklinkOverlay);

// Vous pouvez aussi mélanger des superpositions non-vidéo
var label = new OverlayManagerText("Caméra 1", 10, 380);
label.Font.Size = 14;
label.Color = SKColors.White;
group.Add(label);

// Ajouter le groupe au gestionnaire de superpositions
overlayManager.Video_Overlay_Add(group);

// Démarrer toutes les superpositions OverlayManagerVideo du groupe
group.Play();
// Decklink doit être démarré séparément (group.Play() ne gère qu'OverlayManagerVideo)
decklinkOverlay.Play();

// Plus tard, mettre en pause/arrêter tout en même temps
group.Pause();
group.Stop();

// Nettoyer
group.Dispose();

public class OverlayManagerZoom : IOverlayManagerElement

// Créer un zoom 1,5x centré sur la trame
var zoom = new OverlayManagerZoom
{
    ZoomFactor = 1.5,
    CenterX = 0.5,
    CenterY = 0.5,
    Name = "VideoZoom"
};
zoom.ZIndex = -1000; // Traiter avant les autres superpositions
overlayManager.Video_Overlay_Add(zoom);

// Animer le zoom au fil du temps
zoom.ZoomFactor = 2.0; // Mise à jour dynamique

public class OverlayManagerPan : IOverlayManagerElement

// Panoramique de la vidéo de 100 pixels à droite et 50 pixels vers le bas
var pan = new OverlayManagerPan
{
    OffsetX = 100,
    OffsetY = 50,
    Name = "VideoPan"
};
pan.ZIndex = -1000; // Traiter avant les autres superpositions
overlayManager.Video_Overlay_Add(pan);

public class OverlayManagerFade : IOverlayManagerElement

// Fondu entrant de la vidéo sur 2 secondes à partir de la position de lecture
var fade = new OverlayManagerFade
{
    FadeMode = OverlayManagerFadeMode.FadeIn,
    StartTime = TimeSpan.Zero,
    Duration = TimeSpan.FromSeconds(2),
    Name = "VideoFade"
};
overlayManager.Video_Overlay_Add(fade);

public class OverlayManagerSqueezeback : IOverlayManagerElement

// Créer un squeezeback avec la vidéo dans le coin inférieur droit
var squeezeback = new OverlayManagerSqueezeback
{
    BackgroundImageFilename = "frame.png", // PNG avec centre transparent
    VideoRect = new Rect(960, 540, 1920, 1080), // Quadrant inférieur droit
    Name = "Squeezeback"
};
squeezeback.ZIndex = -2000; // Traiter en premier
overlayManager.Video_Overlay_Add(squeezeback);

// Obtenir la position de lecture courante
var position = await pipeline.Position_GetAsync();

// Animer la vidéo de son VideoRect courant vers un coin sur 2 secondes.
// AnimateVideo n'a pas de startRect — la position de début est implicite (le VideoRect courant de l'élément),
// donc configurez-le au préalable si vous avez besoin d'un point de départ spécifique.
var squeezeback = overlayManager.Video_Overlay_GetByName("Squeezeback") as OverlayManagerSqueezeback;
squeezeback.VideoRect = new Rect(0, 0, 1920, 1080); // Point de départ plein écran
squeezeback.AnimateVideo(
    targetRect: new Rect(1280, 720, 1920, 1080), // Coin inférieur droit
    startTime: position,
    duration: TimeSpan.FromSeconds(2),
    easing: OverlayManagerPanEasing.EaseInOut
);

var position = await pipeline.Position_GetAsync();

// Fondu sortant de la vidéo sur 1,5 secondes
squeezeback.StartVideoFadeOut(position, TimeSpan.FromSeconds(1.5));

// Plus tard, fondu entrant
squeezeback.StartVideoFadeIn(position, TimeSpan.FromSeconds(1.5));

// Fondu de l'image d'arrière-plan indépendamment
squeezeback.StartBackgroundFadeOut(position, TimeSpan.FromSeconds(1));

// Ajouter un squeezeback
var element = overlayManager.Video_Overlay_AddSqueezeback(
    backgroundImageFilename: "frame.png",
    videoRect: new Rect(960, 540, 1920, 1080),
    backgroundRect: null,  // Trame complète
    name: "Squeezeback"
);

// Mettre à jour la position vidéo
overlayManager.Video_Overlay_Squeezeback_UpdateVideoPosition("Squeezeback", newRect);

// Animer la vidéo (pas de startRect — le départ est le VideoRect courant de l'élément).
overlayManager.Video_Overlay_Squeezeback_AnimateVideo(
    "Squeezeback", targetRect, startTime, duration, easing);

// Contrôles de fondu
overlayManager.Video_Overlay_Squeezeback_VideoFadeIn("Squeezeback", startTime, duration);
overlayManager.Video_Overlay_Squeezeback_VideoFadeOut("Squeezeback", startTime, duration);

// Ordre des couches
overlayManager.Video_Overlay_Squeezeback_SetVideoOnTop("Squeezeback");
overlayManager.Video_Overlay_Squeezeback_SetBackgroundOnTop("Squeezeback");

public class OverlayManagerShadowSettings

var text = new OverlayManagerText("Info", 100, 100);
text.Background = new OverlayManagerBackgroundRectangle {
    Color = SKColors.Black.WithAlpha(128),
    Fill = true,
    Margin = new Rect(5, 3, 5, 3)   // Margin est un VisioForge.Core.Types.Rect (Left/Top/Right/Bottom)
};

public class FontSettings

// Créer le pipeline et les blocs
var pipeline = new MediaBlocksPipeline();
var fileSource = new UniversalSourceBlock(await UniversalSourceSettings.CreateAsync(videoUri));
var overlayManager = new OverlayManagerBlock();
var videoRenderer = new VideoRendererBlock(pipeline, videoView);

// Connecter le pipeline
pipeline.Connect(fileSource.VideoOutput, overlayManager.Input);
pipeline.Connect(overlayManager.Output, videoRenderer.Input);

// Ajouter un filigrane logo
var logo = new OverlayManagerImage("logo.png", 10, 10);
logo.Opacity = 0.5;
logo.ZIndex = 10; // Au-dessus
overlayManager.Video_Overlay_Add(logo);

// Ajouter un horodatage — positionner contre la hauteur de sortie connue (définie lors de la configuration du bloc gestionnaire de superpositions)
const int frameHeight = 720;
var timestamp = new OverlayManagerDateTime();
timestamp.X = 10;
timestamp.Y = frameHeight - 30;
timestamp.Font.Size = 16;
timestamp.Color = SKColors.White;
timestamp.Shadow = new OverlayManagerShadowSettings(true);
overlayManager.Video_Overlay_Add(timestamp);

// Ajouter un titre animé (apparaît après 5 secondes)
var title = new OverlayManagerText("Bienvenue !", 100, 100);
title.Font.Size = 72;
title.Color = SKColors.Yellow;
title.StartTime = TimeSpan.FromSeconds(5);
title.EndTime = TimeSpan.FromSeconds(10);
title.Rotation = -10; // Légère inclinaison
title.Background = new OverlayManagerBackgroundRectangle {
    Color = SKColors.DarkBlue,
    Fill = true
};
overlayManager.Video_Overlay_Add(title);

// Démarrer la lecture
await pipeline.StartAsync();

// Mettre à jour les superpositions dynamiquement
title.Text = "Texte mis à jour !";
overlayManager.Video_Overlay_Update(title);