Escribir Etiquetas de Audio con SDK de Media Blocks¶

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;

// Crear metadatos de audio
var audioTags = new MediaFileTags
{
    // Metadatos básicos
    Title = "Bohemian Rhapsody",
    Performers = new[] { "Queen" },
    Album = "A Night at the Opera",
    Year = 1975,

    // Información de pista
    Track = 11,
    TrackCount = 12,
    Disc = 1,
    DiscCount = 1,

    // Género y categorización
    Genres = new[] { "Progressive Rock", "Opera Rock" },

    // Metadatos extendidos
    Composers = new[] { "Freddie Mercury" },
    Conductor = "Roy Thomas Baker",
    Comment = "Obra maestra épica de 6 minutos",
    Copyright = "© 1975 Queen Productions Ltd.",

    // Metadatos técnicos
    BeatsPerMinute = 72,
    Grouping = "Epic Songs",

    // Letras (para formatos compatibles)
    Lyrics = @"Is this the real life?
Is this just fantasy?
Caught in a landslide
No escape from reality..."
};

public async Task CreateMP3WithTags()
{
    // Configurar los ajustes del codificador MP3
    var mp3Settings = new MP3EncoderSettings
    {
        Bitrate = 320,                              // Kbit/s
        RateControl = MP3EncoderRateControl.CBR    // CBR / ABR / VBR
    };

    // Crear etiquetas de metadatos
    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 = "Grabado en estudio casero",
        Copyright = "© 2025 Independent Label"
    };

    // Crear bloque de salida MP3 con etiquetas
    var mp3Output = new MP3OutputBlock("output.mp3", mp3Settings, tags);

    // Alternativa: asignar etiquetas tras la creación vía la propiedad Tags
    // var mp3Output = new MP3OutputBlock("output.mp3", mp3Settings);
    // mp3Output.Tags = tags;

    // Construir el pipeline
    var pipeline = new MediaBlocksPipeline();

    // Añadir una fuente de audio (micrófono, archivo, etc.)
    var audioSource = new SystemAudioSourceBlock();

    // Conectar la fuente directamente a la salida MP3
    pipeline.Connect(audioSource.Output, mp3Output.Input);

    // Iniciar la grabación con metadatos
    await pipeline.StartAsync();

    // La grabación escribe las etiquetas ID3 en el archivo MP3
    await Task.Delay(TimeSpan.FromSeconds(30));

    await pipeline.StopAsync();
}

public async Task CreateOGGWithTags()
{
    // Configurar los ajustes del codificador Vorbis.
    // Quality es un int en el rango [-1..10] (por defecto 4). Se usa cuando RateControl = Quality.
    var vorbisSettings = new VorbisEncoderSettings
    {
        Quality = 8,
        RateControl = VorbisEncoderRateControl.Quality
    };

    // Crear metadatos
    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 = "Grabado en directo en el Estudio 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..."
    };

    // Crear bloque de salida OGG con comentarios Vorbis
    var oggOutput = new OGGVorbisOutputBlock("output.ogg", vorbisSettings, tags);

    // Construir y ejecutar el pipeline
    var pipeline = new MediaBlocksPipeline();

    // Usar UniversalSourceBlock para decodificar cualquier archivo a audio crudo
    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();   // Esperar EOS
}

public async Task CreateM4AWithTags()
{
    // Crear metadatos de un podcast
    var tags = new MediaFileTags
    {
        Title = "Episodio 42: El Futuro de la IA",
        Performers = new[] { "Tech Podcast Host" },
        Album = "Weekly Tech Talk",
        Year = 2025,
        Track = 42,
        Genres = new[] { "Technology", "Podcast" },
        Comment = "Entrevista especial con un investigador de IA",
        Copyright = "© 2025 Tech Media Network",
        Subtitle = "Explorando tendencias de inteligencia artificial",
        Grouping = "Season 3"
    };

    // Opción A: más simple — codificador AAC por defecto elegido internamente
    var m4aOutput = new M4AOutputBlock("podcast_episode_42.m4a", tags);

    // Opción B: elegir un codificador AAC específico y ajustes de sink
    // var sinkSettings = new MP4SinkSettings("podcast_episode_42.m4a");
    // var aacSettings = new AVENCAACEncoderSettings { Bitrate = 256 }; // 256 Kbit/s
    // var m4aOutput = new M4AOutputBlock(sinkSettings, aacSettings, tags);

    // Configurar el pipeline para grabación de podcast
    var pipeline = new MediaBlocksPipeline();
    var micSource = new SystemAudioSourceBlock();

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

    await pipeline.StartAsync();
}

public async Task CreateWMVWithTags()
{
    // Crear metadatos de presentación
    var tags = new MediaFileTags
    {
        Title = "Revisión de Negocio Q4",
        Performers = new[] { "CEO", "CFO", "VP Sales" },
        Album = "Corporate Presentations 2025",
        Year = 2025,
        Genres = new[] { "Business", "Corporate" },
        Comment = "Revisión financiera trimestral y perspectivas",
        Copyright = "© 2025 Business Corp. Confidential",
        Conductor = "Meeting Organizer",
        Grouping = "Executive Presentations"
    };

    // Forma más simple — codificadores por defecto, sólo filename + tags.
    // WMVOutputBlock usa internamente los ajustes por defecto de WMV/WMA.
    var wmvOutput = new WMVOutputBlock("presentation.wmv", tags);

    // Alternativa: pasar objetos explícitos de sink/video/audio
    // var asfSettings = new ASFSinkSettings("presentation.wmv");
    // var wmvSettings = WMVEncoderBlock.GetDefaultSettings();
    // var wmaSettings = WMAEncoderBlock.GetDefaultSettings();
    // var wmvOutput = new WMVOutputBlock(asfSettings, wmvSettings, wmaSettings, tags);

    // Configurar grabación de vídeo + audio
    var pipeline = new MediaBlocksPipeline();

    // Fuente de vídeo — elegir el primer dispositivo disponible
    var videoDevice = (await DeviceEnumerator.Shared.VideoSourcesAsync())[0];
    var videoSource = new SystemVideoSourceBlock(new VideoCaptureDeviceSourceSettings(videoDevice));

    // Fuente de audio
    var audioSource = new SystemAudioSourceBlock();

    // Crear pads de entrada dinámicos en la salida 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()
    {
        // Metadatos compartidos entre todos los archivos de salida
        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 = "Primera sesión de grabación de estudio",
            Copyright = "© 2025 Demo Productions",
            BeatsPerMinute = 120,
            Grouping = "Demo Sessions"
        };

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

        // Salida OGG Vorbis (máxima calidad + Vorbis Comments)
        var oggOutput = new OGGVorbisOutputBlock(
            "session1.ogg",
            new VorbisEncoderSettings { Quality = 10, RateControl = VorbisEncoderRateControl.Quality },
            sessionTags);

        // Salida M4A (AAC por defecto + átomos MP4)
        var m4aOutput = new M4AOutputBlock("session1.m4a", sessionTags);

        // Pipeline con una única fuente de audio distribuida a los tres archivos
        var pipeline = new MediaBlocksPipeline();
        var audioSource = new SystemAudioSourceBlock();

        // Conectar la misma salida de fuente a varios sinks inserta un tee automáticamente
        pipeline.Connect(audioSource.Output, mp3Output.Input);
        pipeline.Connect(audioSource.Output, oggOutput.Input);
        pipeline.Connect(audioSource.Output, m4aOutput.Input);

        Console.WriteLine("Iniciando grabación con metadatos...");
        await pipeline.StartAsync();

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

        Console.WriteLine("Deteniendo grabación...");
        await pipeline.StopAsync();

        Console.WriteLine("Grabación completada — archivos escritos con metadatos:");
        Console.WriteLine("- session1.mp3 (etiquetas ID3)");
        Console.WriteLine("- session1.ogg (Vorbis comments)");
        Console.WriteLine("- session1.m4a (metadatos MP4)");
    }
}

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

// Adjuntar carátula (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);

// Asignar etiquetas a través de la propiedad Tags antes de StartAsync
mp3Output.Tags = new MediaFileTags
{
    Title = "Live Recording",
    Performers = new[] { "Artist" }
};

// Ajustar campos hasta el momento del inicio
mp3Output.Tags.Comment = $"Grabado el {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
        {
            // Heredar metadatos de nivel álbum
            Album = _baseAlbumTags.Album,
            AlbumArtists = _baseAlbumTags.AlbumArtists,
            Year = _baseAlbumTags.Year,
            Genres = _baseAlbumTags.Genres,
            TrackCount = _baseAlbumTags.TrackCount,
            Copyright = _baseAlbumTags.Copyright,

            // Metadatos específicos de pista
            Track = (uint)trackNumber,
            Title = title,
            Performers = performers
        };

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

// MP3: ID3v2 admite metadatos extensos
var mp3Tags = new MediaFileTags
{
    Title = "Song Title",
    Subtitle = "Song Subtitle",     // frame TIT3 de ID3v2
    Lyrics = "Full lyrics text",    // frame USLT
    BeatsPerMinute = 128            // frame TBPM
};

// OGG: los comentarios Vorbis son flexibles y admiten campos multi-valor nativamente
var oggTags = new MediaFileTags
{
    Composers = new[] { "Composer 1", "Composer 2" },
    Performers = new[] { "Artist 1", "Artist 2" }
};

// M4A: metadatos compatibles con iTunes
var m4aTagsForPodcast = new MediaFileTags
{
    Title = "Episode Title",
    Album = "Podcast Series Name",  // Aparece como "Album" en iTunes
    Performers = new[] { "Host Name" }, // Aparece como "Artist"
    Genres = new[] { "Podcast" },
    Comment = "Episode description"
};

var pipeline = new MediaBlocksPipeline();

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

// Continuar con la configuración del pipeline...