Captura de pantalla a archivo MP4¶

using System;
using System.IO;
using System.Threading.Tasks;
using VisioForge.Core;
using VisioForge.Core.Types;
using VisioForge.Core.Types.X.Output;
using VisioForge.Core.Types.X.Sources;
using VisioForge.Core.VideoCaptureX;

class Program
{
    static async Task Main(string[] args)
    {
        // Inicializar SDK
        await VisioForgeX.InitSDKAsync();

        var videoCapture = new VideoCaptureCoreX();

        try
        {
            // Configurar captura de pantalla Direct3D 11 con WGC
            var screenSource = new ScreenCaptureD3D11SourceSettings
            {
                FrameRate = new VideoFrameRate(25, 1),
                CaptureCursor = true,
                MonitorIndex = 0  // Monitor principal (-1 también selecciona el principal)
            };

            videoCapture.Video_Source = screenSource;
            videoCapture.Video_Play = false;
            videoCapture.Audio_Play = false;
            videoCapture.Audio_Record = false;

            // Configurar salida MP4 (H.264 + AAC, codificadores auto-seleccionados)
            string outputPath = Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.MyVideos),
                $"screen_{DateTime.Now:yyyyMMdd_HHmmss}.mp4");

            var mp4Output = new MP4Output(outputPath);
            videoCapture.Outputs_Add(mp4Output, autostart: true);

            // Iniciar grabación
            await videoCapture.StartAsync();
            Console.WriteLine($"Grabando en: {outputPath}");
            Console.WriteLine("Presione ENTER para detener...");
            Console.ReadLine();

            // Detener y guardar
            await videoCapture.StopAsync();
            Console.WriteLine("Grabación guardada.");
        }
        finally
        {
            await videoCapture.DisposeAsync();
            VisioForgeX.DestroySDK();
        }
    }
}

// Enumerar dispositivos de salida WASAPI2 para captura de loopback
var audioOutputs = await DeviceEnumerator.Shared.AudioOutputsAsync(
    AudioOutputDeviceAPI.WASAPI2);

if (audioOutputs.Length > 0)
{
    var loopbackSource = new LoopbackAudioCaptureDeviceSourceSettings(audioOutputs[0]);
    videoCapture.Audio_Source = loopbackSource;
    videoCapture.Audio_Record = true;
}

// NVIDIA NVENC H.264
var mp4Output = new MP4Output(
    outputPath,
    new NVENCH264EncoderSettings());

// Intel Quick Sync Video H.264
var mp4Output = new MP4Output(
    outputPath,
    new QSVH264EncoderSettings());

// AMD AMF H.264
var mp4Output = new MP4Output(
    outputPath,
    new AMFH264EncoderSettings());

using System;
using System.IO;
using System.Threading.Tasks;
using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.Sinks;
using VisioForge.Core.MediaBlocks.Special;
using VisioForge.Core.Types;
using VisioForge.Core.Types.X.Sources;

class Program
{
    static async Task Main(string[] args)
    {
        await VisioForgeX.InitSDKAsync();

        var pipeline = new MediaBlocksPipeline();

        try
        {
            // Fuente de captura de pantalla
            var screenSettings = new ScreenCaptureD3D11SourceSettings
            {
                FrameRate = new VideoFrameRate(25, 1),
                CaptureCursor = true
            };
            var screenSource = new ScreenSourceBlock(screenSettings);

            // Salida MP4
            string outputPath = Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.MyVideos),
                $"screen_mb_{DateTime.Now:yyyyMMdd_HHmmss}.mp4");
            var mp4Sink = new MP4OutputBlock(outputPath);

            // Conectar fuente a salida
            pipeline.Connect(screenSource.Output, mp4Sink.CreateNewInput(MediaBlockPadMediaType.Video));

            // Iniciar pipeline
            await pipeline.StartAsync();
            Console.WriteLine($"Grabando en: {outputPath}");
            Console.WriteLine("Presione ENTER para detener...");
            Console.ReadLine();

            await pipeline.StopAsync();
            Console.WriteLine("Grabación guardada.");
        }
        finally
        {
            await pipeline.DisposeAsync();
            VisioForgeX.DestroySDK();
        }
    }
}

var screenSource = new ScreenCaptureD3D11SourceSettings
{
    API = D3D11ScreenCaptureAPI.DXGI  // Forzar Desktop Duplication en lugar de WGC
};

using System;
using System.IO;
using System.Windows.Forms;
using VisioForge.Core.VideoCapture;
using VisioForge.Core.Types;
using VisioForge.Core.Types.Output;
using VisioForge.Core.Types.VideoCapture;

namespace screen_capture_mp4
{
    public partial class Form1 : Form
    {
        // Componente principal de VideoCapture que maneja todas las operaciones de grabación
        private VideoCaptureCore videoCapture1;

        public Form1()
        {
            InitializeComponent();
        }

        /// <summary>
        /// Inicia la grabación de pantalla con audio del dispositivo predeterminado
        /// </summary>
        private async void btStartWithAudio_Click(object sender, EventArgs e)
        {
            // Configurar captura de pantalla para grabar toda la pantalla
            // ScreenCaptureSourceSettings permite control fino de la región de captura y parámetros
            videoCapture1.Screen_Capture_Source = new ScreenCaptureSourceSettings() { 
                FullScreen = true  // Captura toda la pantalla en lugar de una región específica
            };

            // Configurar captura de audio seleccionando el primer dispositivo de entrada de audio disponible
            // Audio_CaptureDevices() retorna todos los micrófonos y entradas de audio conectados
            // Seleccionamos el primer dispositivo (índice 0) en la colección
            videoCapture1.Audio_CaptureDevice = new AudioCaptureSource(
                videoCapture1.Audio_CaptureDevices()[0].Name);

            // Deshabilitar monitoreo/reproducción de audio durante la grabación para prevenir retroalimentación
            // Esto significa que no escucharemos el audio capturado mientras grabamos
            videoCapture1.Audio_PlayAudio = false;

            // Habilitar grabación de audio para incluir sonido en el archivo de salida
            videoCapture1.Audio_RecordAudio = true;

            // Establecer la ubicación del archivo de salida en la carpeta Videos del usuario
            // Environment.GetFolderPath asegura que la ruta funcione en diferentes sistemas Windows
            videoCapture1.Output_Filename = Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.MyVideos), 
                "output.mp4");

            // Usar formato contenedor MP4 con codecs de video H.264 y audio AAC (formato estándar)
            // MP4Output puede configurarse más con parámetros de codificación personalizados si es necesario
            videoCapture1.Output_Format = new MP4Output();

            // Establecer el modo de captura a grabación de pantalla
            // Otros modos incluyen captura de cámara, procesamiento de archivo de video, etc.
            videoCapture1.Mode = VideoCaptureMode.ScreenCapture;

            // Comenzar el proceso de captura de forma asíncrona
            // Usando patrón async/await para prevenir congelamiento de UI durante la operación
            await videoCapture1.StartAsync();
        }

        /// <summary>
        /// Inicia la grabación de pantalla sin audio (solo video)
        /// </summary>
        private async void btStartWithoutAudio_Click(object sender, EventArgs e)
        {
            // Configurar captura de pantalla para grabación a pantalla completa
            // Misma ScreenCaptureSourceSettings que en la grabación con audio
            videoCapture1.Screen_Capture_Source = new ScreenCaptureSourceSettings() { 
                FullScreen = true 
            };

            // Deshabilitar tanto reproducción como grabación de audio en una sola línea
            // Esto crea un archivo MP4 solo de video sin pista de audio
            videoCapture1.Audio_PlayAudio = videoCapture1.Audio_RecordAudio = false;

            // Establecer ruta de archivo de salida al directorio Videos del usuario con extensión MP4
            videoCapture1.Output_Filename = Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.MyVideos), 
                "output.mp4");

            // Configurar salida como MP4 (codec de video H.264)
            videoCapture1.Output_Format = new MP4Output();

            // Establecer modo a captura de pantalla
            videoCapture1.Mode = VideoCaptureMode.ScreenCapture;

            // Iniciar grabación de pantalla de forma asíncrona
            await videoCapture1.StartAsync();
        }

        /// <summary>
        /// Detiene el proceso de grabación actual de forma segura
        /// </summary>
        private async void btStop_Click(object sender, EventArgs e)
        {
            // Detener la grabación de forma asíncrona
            // Esto finaliza correctamente el archivo MP4 y libera recursos
            // Usar async asegura que la UI permanezca receptiva durante la finalización del archivo
            await videoCapture1.StopAsync();
        }

        /// <summary>
        /// Inicializa el componente VideoCapture cuando el formulario se carga
        /// </summary>
        private void Form1_Load(object sender, EventArgs e)
        {
            // Inicializar el componente de captura de video y conectarlo a un control de vista previa de video
            // VideoView1 debe ser un control en tu formulario que implemente la interfaz IVideoView
            // Esto permite vista previa en vivo de la captura cuando se desee
            videoCapture1 = new VideoCaptureCore(VideoView1 as IVideoView);
        }
    }
}

// Seleccionar un dispositivo de loopback (ej. "Stereo Mix") para captura de audio del sistema
var devices = videoCapture1.Audio_CaptureDevices();
var loopbackDevice = devices.FirstOrDefault(d => d.Name.Contains("Stereo Mix"));

if (loopbackDevice != null)
{
    videoCapture1.Audio_CaptureDevice = new AudioCaptureSource(loopbackDevice.Name);
}
else
{
    // Alternativa: usar el primer dispositivo de audio disponible
    videoCapture1.Audio_CaptureDevice = new AudioCaptureSource(devices[0].Name);
}

// Habilitar grabación, deshabilitar reproducción para prevenir retroalimentación
videoCapture1.Audio_RecordAudio = true;
videoCapture1.Audio_PlayAudio = false;

videoCapture1.Audio_PlayAudio = false;
videoCapture1.Audio_RecordAudio = false;

videoCapture1.Screen_Capture_Source = new ScreenCaptureSourceSettings()
{
    FullScreen = false,
    Left = 100,
    Top = 100,
    Right = 1380,
    Bottom = 820
};

videoCapture1.Screen_Capture_Source = new ScreenCaptureSourceSettings()
{
    FullScreen = true,
    DisplayIndex = 1  // Grabar el monitor secundario
};

var mp4Output = new MP4Output();
mp4Output.Video.Bitrate = 5000;                          // Mayor calidad (kbps)
mp4Output.Video.Profile = H264Profile.ProfileMain;       // Mejor compresión que Baseline
mp4Output.Video.RateControl = H264RateControl.VBR;       // Bitrate variable
videoCapture1.Output_Format = mp4Output;

videoCapture1.Screen_Capture_Source = new ScreenCaptureSourceSettings()
{
    FullScreen = true,
    GrabMouseCursor = true,
    MouseHighlight = true,
    MouseHighlightColor = System.Drawing.Color.Yellow,
    MouseHighlightRadius = 40,
    MouseHighlightOpacity = 0.4
};