Écrire des étiquettes audio avec le Media Blocks SDK¶

using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Outputs;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.Types;
using VisioForge.Core.Types.X.AudioEncoders;
using VisioForge.Core.Types.X.Sources;

// Créer les métadonnées audio
var audioTags = new MediaFileTags
{
    // Métadonnées de base
    Title = "Bohemian Rhapsody",
    Performers = new[] { "Queen" },
    Album = "A Night at the Opera",
    Year = 1975,

    // Informations de piste
    Track = 11,
    TrackCount = 12,
    Disc = 1,
    DiscCount = 1,

    // Genre et catégorisation
    Genres = new[] { "Progressive Rock", "Opera Rock" },

    // Métadonnées étendues
    Composers = new[] { "Freddie Mercury" },
    Conductor = "Roy Thomas Baker",
    Comment = "6-minute epic masterpiece",
    Copyright = "© 1975 Queen Productions Ltd.",

    // Métadonnées techniques
    BeatsPerMinute = 72,
    Grouping = "Epic Songs",

    // Paroles (pour les formats compatibles)
    Lyrics = @"Is this the real life?
Is this just fantasy?
Caught in a landslide
No escape from reality..."
};

public async Task CreateMP3WithTags()
{
    // Configurer les paramètres de l'encodeur MP3
    var mp3Settings = new MP3EncoderSettings
    {
        Bitrate = 320,                              // Kbit/s
        RateControl = MP3EncoderRateControl.CBR    // CBR / ABR / VBR
    };

    // Créer les étiquettes de métadonnées
    var tags = new MediaFileTags
    {
        Title = "Summer Vibes",
        Performers = new[] { "Indie Artist" },
        Album = "Seasonal Collection",
        Year = 2025,
        Track = 3,
        TrackCount = 10,
        Genres = new[] { "Indie Pop", "Electronic" },
        Comment = "Recorded in home studio",
        Copyright = "© 2025 Independent Label"
    };

    // Créer le bloc de sortie MP3 avec les étiquettes
    var mp3Output = new MP3OutputBlock("output.mp3", mp3Settings, tags);

    // Alternative : définir les étiquettes après la création via la propriété Tags
    // var mp3Output = new MP3OutputBlock("output.mp3", mp3Settings);
    // mp3Output.Tags = tags;

    // Construire le pipeline
    var pipeline = new MediaBlocksPipeline();

    // Ajouter une source audio (microphone, fichier, etc.)
    var audioSource = new SystemAudioSourceBlock();

    // Connecter la source directement à la sortie MP3
    pipeline.Connect(audioSource.Output, mp3Output.Input);

    // Démarrer l'enregistrement avec les métadonnées
    await pipeline.StartAsync();

    // L'enregistrement écrit les étiquettes ID3 dans le fichier MP3
    await Task.Delay(TimeSpan.FromSeconds(30));

    await pipeline.StopAsync();
}

public async Task CreateOGGWithTags()
{
    // Configurer les paramètres de l'encodeur Vorbis.
    // Quality est un int dans la plage [-1..10] (par défaut 4). Utilisé lorsque RateControl = Quality.
    var vorbisSettings = new VorbisEncoderSettings
    {
        Quality = 8,
        RateControl = VorbisEncoderRateControl.Quality
    };

    // Créer les métadonnées
    var tags = new MediaFileTags
    {
        Title = "Acoustic Session",
        Performers = new[] { "Folk Artist", "Guest Vocalist" },
        AlbumArtists = new[] { "Folk Artist" },
        Album = "Live Sessions",
        Year = 2025,
        Track = 1,
        Genres = new[] { "Folk", "Acoustic" },
        Composers = new[] { "Folk Artist", "Traditional" },
        Comment = "Recorded live at Studio A",
        Conductor = "Sound Engineer",
        Grouping = "Live Recordings",
        Lyrics = @"In the quiet of the morning
When the world begins to wake
There's a song within the silence..."
    };

    // Créer le bloc de sortie OGG avec les Vorbis Comments
    var oggOutput = new OGGVorbisOutputBlock("output.ogg", vorbisSettings, tags);

    // Construire et exécuter le pipeline
    var pipeline = new MediaBlocksPipeline();

    // Utiliser UniversalSourceBlock pour décoder n'importe quel format de fichier en audio brut
    var sourceSettings = await UniversalSourceSettings.CreateAsync(new Uri("input.wav"));
    var fileSource = new UniversalSourceBlock(sourceSettings);

    pipeline.Connect(fileSource.AudioOutput, oggOutput.Input);

    await pipeline.StartAsync();
    await pipeline.WaitForStopAsync();   // Attendre l'EOS
}

public async Task CreateM4AWithTags()
{
    // Créer les métadonnées de podcast
    var tags = new MediaFileTags
    {
        Title = "Episode 42: The Future of AI",
        Performers = new[] { "Tech Podcast Host" },
        Album = "Weekly Tech Talk",
        Year = 2025,
        Track = 42,
        Genres = new[] { "Technology", "Podcast" },
        Comment = "Special guest interview with AI researcher",
        Copyright = "© 2025 Tech Media Network",
        Subtitle = "Exploring artificial intelligence trends",
        Grouping = "Season 3"
    };

    // Option A : la plus simple — encodeur AAC par défaut choisi en interne
    var m4aOutput = new M4AOutputBlock("podcast_episode_42.m4a", tags);

    // Option B : choisir un encodeur AAC spécifique et des paramètres de puits
    // var sinkSettings = new MP4SinkSettings("podcast_episode_42.m4a");
    // var aacSettings = new AVENCAACEncoderSettings { Bitrate = 256 }; // 256 Kbit/s
    // var m4aOutput = new M4AOutputBlock(sinkSettings, aacSettings, tags);

    // Configuration du pipeline pour l'enregistrement du podcast
    var pipeline = new MediaBlocksPipeline();
    var micSource = new SystemAudioSourceBlock();

    pipeline.Connect(micSource.Output, m4aOutput.Input);

    await pipeline.StartAsync();
}

public async Task CreateWMVWithTags()
{
    // Créer les métadonnées de présentation
    var tags = new MediaFileTags
    {
        Title = "Q4 Business Review",
        Performers = new[] { "CEO", "CFO", "VP Sales" },
        Album = "Corporate Presentations 2025",
        Year = 2025,
        Genres = new[] { "Business", "Corporate" },
        Comment = "Quarterly financial review and outlook",
        Copyright = "© 2025 Business Corp. Confidential",
        Conductor = "Meeting Organizer",
        Grouping = "Executive Presentations"
    };

    // Forme la plus simple — encodeurs par défaut, juste nom de fichier + étiquettes.
    // WMVOutputBlock utilisera les paramètres d'encodeur WMV/WMA par défaut en interne.
    var wmvOutput = new WMVOutputBlock("presentation.wmv", tags);

    // Alternative : passer des objets de paramètres explicites puits/vidéo/audio
    // var asfSettings = new ASFSinkSettings("presentation.wmv");
    // var wmvSettings = WMVEncoderBlock.GetDefaultSettings();
    // var wmaSettings = WMAEncoderBlock.GetDefaultSettings();
    // var wmvOutput = new WMVOutputBlock(asfSettings, wmvSettings, wmaSettings, tags);

    // Configuration pour l'enregistrement vidéo + audio
    var pipeline = new MediaBlocksPipeline();

    // Source vidéo — choisir le premier périphérique disponible
    var videoDevice = (await DeviceEnumerator.Shared.VideoSourcesAsync())[0];
    var videoSource = new SystemVideoSourceBlock(new VideoCaptureDeviceSourceSettings(videoDevice));

    // Source audio
    var audioSource = new SystemAudioSourceBlock();

    // Créer des pads d'entrée dynamiques sur la sortie WMV
    var videoPad = wmvOutput.CreateNewInput(MediaBlockPadMediaType.Video);
    var audioPad = wmvOutput.CreateNewInput(MediaBlockPadMediaType.Audio);

    pipeline.Connect(videoSource.Output, videoPad);
    pipeline.Connect(audioSource.Output, audioPad);

    await pipeline.StartAsync();
}

public class AudioRecorderWithTags
{
    public async Task RecordAudioWithMetadata()
    {
        // Métadonnées riches partagées entre tous les fichiers de sortie
        var sessionTags = new MediaFileTags
        {
            Title = "Studio Session #1",
            Performers = new[] { "John Doe", "Jane Smith" },
            Album = "Demo Recordings",
            Year = 2025,
            Track = 1,
            Genres = new[] { "Rock", "Alternative" },
            Composers = new[] { "John Doe" },
            Comment = "First studio recording session",
            Copyright = "© 2025 Demo Productions",
            BeatsPerMinute = 120,
            Grouping = "Demo Sessions"
        };

        // Sortie MP3 (CBR 320 Kbit/s + étiquettes ID3)
        var mp3Output = new MP3OutputBlock(
            "session1.mp3",
            new MP3EncoderSettings { Bitrate = 320, RateControl = MP3EncoderRateControl.CBR },
            sessionTags);

        // Sortie OGG Vorbis (qualité maximale + Vorbis Comments)
        var oggOutput = new OGGVorbisOutputBlock(
            "session1.ogg",
            new VorbisEncoderSettings { Quality = 10, RateControl = VorbisEncoderRateControl.Quality },
            sessionTags);

        // Sortie M4A (AAC par défaut + atoms MP4)
        var m4aOutput = new M4AOutputBlock("session1.m4a", sessionTags);

        // Pipeline avec une source audio unique répartie vers les trois fichiers
        var pipeline = new MediaBlocksPipeline();
        var audioSource = new SystemAudioSourceBlock();

        // La connexion du même pad source à plusieurs puits insère automatiquement un tee
        pipeline.Connect(audioSource.Output, mp3Output.Input);
        pipeline.Connect(audioSource.Output, oggOutput.Input);
        pipeline.Connect(audioSource.Output, m4aOutput.Input);

        Console.WriteLine("Starting recording with metadata...");
        await pipeline.StartAsync();

        await Task.Delay(TimeSpan.FromMinutes(3));

        Console.WriteLine("Stopping recording...");
        await pipeline.StopAsync();

        Console.WriteLine("Recording complete — files written with metadata:");
        Console.WriteLine("- session1.mp3 (ID3 tags)");
        Console.WriteLine("- session1.ogg (Vorbis comments)");
        Console.WriteLine("- session1.m4a (MP4 metadata)");
    }
}

var tags = new MediaFileTags
{
    Title = "Album Title Track",
    Performers = new[] { "Artist Name" },
    Album = "Album Name"
};

// Attacher la pochette d'album (Windows — System.Drawing)
#if NET_WINDOWS
if (File.Exists("album_cover.jpg"))
{
    var albumArt = new System.Drawing.Bitmap("album_cover.jpg");
    tags.Pictures = new[] { albumArt };
    tags.Pictures_Descriptions = new[] { "Front Cover" };
}
#endif

var mp3Output = new MP3OutputBlock(
    "track.mp3",
    new MP3EncoderSettings { Bitrate = 320, RateControl = MP3EncoderRateControl.CBR },
    tags);

var mp3Settings = new MP3EncoderSettings { Bitrate = 320, RateControl = MP3EncoderRateControl.CBR };
var mp3Output = new MP3OutputBlock("output.mp3", mp3Settings);

// Affecter les étiquettes via la propriété Tags avant StartAsync
mp3Output.Tags = new MediaFileTags
{
    Title = "Live Recording",
    Performers = new[] { "Artist" }
};

// Ajuster les champs jusqu'au démarrage
mp3Output.Tags.Comment = $"Recorded on {DateTime.Now:yyyy-MM-dd}";
mp3Output.Tags.Year = (uint)DateTime.Now.Year;

await pipeline.StartAsync();

public class AlbumRecorder
{
    private readonly MediaFileTags _baseAlbumTags;
    private readonly MP3EncoderSettings _mp3Settings =
        new MP3EncoderSettings { Bitrate = 320, RateControl = MP3EncoderRateControl.CBR };

    public AlbumRecorder()
    {
        _baseAlbumTags = new MediaFileTags
        {
            Album = "My Album",
            AlbumArtists = new[] { "Main Artist" },
            Year = 2025,
            Genres = new[] { "Pop", "Electronic" },
            TrackCount = 12,
            Copyright = "© 2025 Record Label"
        };
    }

    public MP3OutputBlock CreateTrackOutput(int trackNumber, string title, string[] performers)
    {
        var trackTags = new MediaFileTags
        {
            // Hériter des métadonnées au niveau album
            Album = _baseAlbumTags.Album,
            AlbumArtists = _baseAlbumTags.AlbumArtists,
            Year = _baseAlbumTags.Year,
            Genres = _baseAlbumTags.Genres,
            TrackCount = _baseAlbumTags.TrackCount,
            Copyright = _baseAlbumTags.Copyright,

            // Métadonnées propres à la piste
            Track = (uint)trackNumber,
            Title = title,
            Performers = performers
        };

        return new MP3OutputBlock($"track_{trackNumber:D2}.mp3", _mp3Settings, trackTags);
    }
}

// MP3 : ID3v2 prend en charge des métadonnées étendues
var mp3Tags = new MediaFileTags
{
    Title = "Song Title",
    Subtitle = "Song Subtitle",     // Trame ID3v2 TIT3
    Lyrics = "Full lyrics text",    // Trame USLT
    BeatsPerMinute = 128            // Trame TBPM
};

// OGG : les Vorbis Comments sont flexibles et gèrent nativement les champs multi-valeurs
var oggTags = new MediaFileTags
{
    Composers = new[] { "Composer 1", "Composer 2" },
    Performers = new[] { "Artist 1", "Artist 2" }
};

// M4A : métadonnées compatibles iTunes
var m4aTagsForPodcast = new MediaFileTags
{
    Title = "Episode Title",
    Album = "Podcast Series Name",  // Affiché comme « Album » dans iTunes
    Performers = new[] { "Host Name" }, // Affiché comme « Artist »
    Genres = new[] { "Podcast" },
    Comment = "Episode description"
};

var pipeline = new MediaBlocksPipeline();

pipeline.OnError += (sender, e) =>
{
    Console.WriteLine($"Pipeline error: {e.Message}");
};

// Continuer la configuration du pipeline...