Blocs de décodeurs vidéo — VisioForge Media Blocks SDK .Net¶

var pipeline = new MediaBlocksPipeline();

// Créer le bloc décodeur H264
var h264Decoder = new H264DecoderBlock();

// Exemple : créer une source fichier basique, un démultiplexeur et un moteur de rendu
var basicFileSource = new BasicFileSourceBlock("test_h264.mp4");

// Obtenir les informations multimédias avec MediaInfoReaderX
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_h264.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // En supposant VideoView1

// Connecter les blocs
pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), h264Decoder.Input);
pipeline.Connect(h264Decoder.Output, videoRenderer.Input);

// Démarrer le pipeline
await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

// Créer le bloc décodeur JPEG
var jpegDecoder = new JPEGDecoderBlock();

// Exemple : créer une source HTTP pour une caméra MJPEG et un moteur de rendu vidéo
var httpSettings = new HTTPSourceSettings(new Uri("http://your-mjpeg-camera/stream"));
var httpSource = new HTTPSourceBlock(httpSettings);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1); // En supposant VideoView1

// Connecter les blocs
pipeline.Connect(httpSource.Output, jpegDecoder.Input);
pipeline.Connect(jpegDecoder.Output, videoRenderer.Input);

// Démarrer le pipeline
await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

// Créer le bloc décodeur H.264 NVIDIA
var nvH264Decoder = new NVH264DecoderBlock();

// Exemple : créer une source fichier basique, un démultiplexeur et un moteur de rendu
var basicFileSource = new BasicFileSourceBlock("test_h264.mp4");

var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_h264.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// Connecter les blocs
pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), nvH264Decoder.Input);
pipeline.Connect(nvH264Decoder.Output, videoRenderer.Input);

// Démarrer le pipeline
await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

// Créer le bloc décodeur H.265 NVIDIA
var nvH265Decoder = new NVH265DecoderBlock();

// Exemple : créer une source fichier basique, un démultiplexeur et un moteur de rendu
var basicFileSource = new BasicFileSourceBlock("test_h265.mp4");

var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_h265.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// Connecter les blocs
pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), nvH265Decoder.Input);
pipeline.Connect(nvH265Decoder.Output, videoRenderer.Input);

// Démarrer le pipeline
await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

// Créer le bloc décodeur JPEG NVIDIA
var nvJpegDecoder = new NVJPEGDecoderBlock();

// Exemple : créer une source fichier basique pour un fichier MJPEG, un démultiplexeur et un moteur de rendu
// Assurez-vous que « test.mjpg » contient un flux Motion JPEG.
var basicFileSource = new BasicFileSourceBlock("test.mjpg");

var reader = new MediaInfoReaderX();
await reader.OpenAsync("test.mjpg");
var mediaInfo = reader.Info;
if (mediaInfo == null || mediaInfo.VideoStreams.Count == 0 || !mediaInfo.VideoStreams[0].Codec.Contains("jpeg"))
{
    Console.WriteLine("Échec de l'obtention des infos MJPEG ou ce n'est pas un fichier MJPEG.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// Connecter les blocs
pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), nvJpegDecoder.Input);
pipeline.Connect(nvJpegDecoder.Output, videoRenderer.Input);

// Démarrer le pipeline
await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

// Créer le bloc décodeur MPEG-1 NVIDIA
var nvMpeg1Decoder = new NVMPEG1DecoderBlock();

// Exemple : créer une source fichier basique, un démultiplexeur et un moteur de rendu
var basicFileSource = new BasicFileSourceBlock("test_mpeg1.mpg");

var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_mpeg1.mpg");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// Connecter les blocs
pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), nvMpeg1Decoder.Input);
pipeline.Connect(nvMpeg1Decoder.Output, videoRenderer.Input);

// Démarrer le pipeline
await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

// Créer le bloc décodeur MPEG-2 NVIDIA
var nvMpeg2Decoder = new NVMPEG2DecoderBlock();

// Exemple : créer une source fichier basique, un démultiplexeur et un moteur de rendu
var basicFileSource = new BasicFileSourceBlock("test_mpeg2.mpg");

var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_mpeg2.mpg");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// Connecter les blocs
pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), nvMpeg2Decoder.Input);
pipeline.Connect(nvMpeg2Decoder.Output, videoRenderer.Input);

// Démarrer le pipeline
await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

// Créer le bloc décodeur MPEG-4 NVIDIA
var nvMpeg4Decoder = new NVMPEG4DecoderBlock();

// Exemple : créer une source fichier basique, un démultiplexeur et un moteur de rendu
var basicFileSource = new BasicFileSourceBlock("test_mpeg4.avi");

var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_mpeg4.avi");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// Connecter les blocs
pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), nvMpeg4Decoder.Input);
pipeline.Connect(nvMpeg4Decoder.Output, videoRenderer.Input);

// Démarrer le pipeline
await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

// Créer le bloc décodeur VP8 NVIDIA
var nvVp8Decoder = new NVVP8DecoderBlock();

// Exemple : créer une source fichier basique, un démultiplexeur et un moteur de rendu
var basicFileSource = new BasicFileSourceBlock("test_vp8.webm");

var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_vp8.webm");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// Connecter les blocs
pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), nvVp8Decoder.Input);
pipeline.Connect(nvVp8Decoder.Output, videoRenderer.Input);

// Démarrer le pipeline
await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

// Créer le bloc décodeur VP9 NVIDIA
var nvVp9Decoder = new NVVP9DecoderBlock();

// Exemple : créer une source fichier basique, un démultiplexeur et un moteur de rendu
var basicFileSource = new BasicFileSourceBlock("test_vp9.webm");

var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_vp9.webm");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);

var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

// Connecter les blocs
pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), nvVp9Decoder.Input);
pipeline.Connect(nvVp9Decoder.Output, videoRenderer.Input);

// Démarrer le pipeline
await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();
var vaapiH264Decoder = new VAAPIH264DecoderBlock();
var basicFileSource = new BasicFileSourceBlock("test_h264.mp4");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_h264.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), vaapiH264Decoder.Input);
pipeline.Connect(vaapiH264Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();
var vaapiHevcDecoder = new VAAPIHEVCDecoderBlock();
var basicFileSource = new BasicFileSourceBlock("test_hevc.mp4");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_hevc.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), vaapiHevcDecoder.Input);
pipeline.Connect(vaapiHevcDecoder.Output, videoRenderer.Input);

await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();
var vaapiJpegDecoder = new VAAPIJPEGDecoderBlock();
var httpSettings = new HTTPSourceSettings(new Uri("http://your-mjpeg-camera/stream"));
var httpSource = new HTTPSourceBlock(httpSettings);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(httpSource.Output, vaapiJpegDecoder.Input);
pipeline.Connect(vaapiJpegDecoder.Output, videoRenderer.Input);

await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();
var vaapiVc1Decoder = new VAAPIVC1DecoderBlock();
var basicFileSource = new BasicFileSourceBlock("test_vc1.wmv");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_vc1.wmv");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), vaapiVc1Decoder.Input);
pipeline.Connect(vaapiVc1Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

// Créer le bloc décodeur AV1 D3D11
var d3d11Av1Decoder = new D3D11AV1DecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_av1.mkv");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_av1.mkv");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), d3d11Av1Decoder.Input);
pipeline.Connect(d3d11Av1Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

// Créer le bloc décodeur H.264 D3D11
var d3d11H264Decoder = new D3D11H264DecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_h264.mp4");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_h264.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), d3d11H264Decoder.Input);
pipeline.Connect(d3d11H264Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

// Créer le bloc décodeur H.265 D3D11
var d3d11H265Decoder = new D3D11H265DecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_h265.mp4");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_h265.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), d3d11H265Decoder.Input);
pipeline.Connect(d3d11H265Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

// Créer le bloc décodeur MPEG-2 D3D11
var d3d11Mpeg2Decoder = new D3D11MPEG2DecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_mpeg2.mpg");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_mpeg2.mpg");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), d3d11Mpeg2Decoder.Input);
pipeline.Connect(d3d11Mpeg2Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

// Créer le bloc décodeur VP8 D3D11
var d3d11Vp8Decoder = new D3D11VP8DecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_vp8.webm");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_vp8.webm");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), d3d11Vp8Decoder.Input);
pipeline.Connect(d3d11Vp8Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

// Créer le bloc décodeur VP9 D3D11
var d3d11Vp9Decoder = new D3D11VP9DecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_vp9.webm");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_vp9.webm");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), d3d11Vp9Decoder.Input);
pipeline.Connect(d3d11Vp9Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();

// Sélection automatique (recommandé)
var hevcDecoder = new HEVCDecoderBlock();

// Sélection explicite du backend :
// FFmpeg (CPU, logiciel)
var hevcDecoder = new HEVCDecoderBlock(new FFMPEGHEVCDecoderSettings());

// NVIDIA NVDEC (GPU)
var hevcDecoder = new HEVCDecoderBlock(new NVHEVCDecoderSettings());

// Intel Quick Sync
var hevcDecoder = new HEVCDecoderBlock(new QSVHEVCDecoderSettings());

// AMD AMF
var hevcDecoder = new HEVCDecoderBlock(new AMFHEVCDecoderSettings());

// D3D11/DXVA (Windows uniquement)
var hevcDecoder = new HEVCDecoderBlock(new D3D11HEVCDecoderSettings());

// VAAPI (Linux uniquement)
var hevcDecoder = new HEVCDecoderBlock(new VAAPIHEVCDecoderSettings());

var pipeline = new MediaBlocksPipeline();

// Sélection automatique du meilleur décodeur HEVC disponible
var hevcDecoder = new HEVCDecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_hevc.mp4");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_hevc.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), hevcDecoder.Input);
pipeline.Connect(hevcDecoder.Output, videoRenderer.Input);

await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

// Sélection automatique du meilleur décodeur AV1 disponible
var av1Decoder = new AV1DecoderBlock();

// Ou spécifier explicitement un décodeur :
// var av1Decoder = new AV1DecoderBlock(new AV1DecoderSettings { DecoderType = AV1DecoderType.Dav1d });

var basicFileSource = new BasicFileSourceBlock("test_av1.mp4");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_av1.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), av1Decoder.Input);
pipeline.Connect(av1Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

// Créer le bloc décodeur NVAV1 (nécessite un GPU NVIDIA avec prise en charge AV1 NVDEC)
var nvav1Decoder = new NVAV1DecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_av1.mp4");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_av1.mp4");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), nvav1Decoder.Input);
pipeline.Connect(nvav1Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();

// Sélection automatique (recommandé)
var vp8Decoder = new VP8DecoderBlock();

// Sélection explicite du backend :
// VPX (logiciel, large compatibilité)
var vp8Decoder = new VP8DecoderBlock(new VPXVP8DecoderSettings());

// FFmpeg (logiciel)
var vp8Decoder = new VP8DecoderBlock(new FFMPEGVP8DecoderSettings());

// NVIDIA NVDEC (matériel)
var vp8Decoder = new VP8DecoderBlock(new NVVP8DecoderSettings());

// VAAPI (Linux uniquement, matériel)
var vp8Decoder = new VP8DecoderBlock(new VAAPIVP8DecoderSettings());

// D3D11/DXVA (Windows uniquement, matériel)
var vp8Decoder = new VP8DecoderBlock(new D3D11VP8DecoderSettings());

var pipeline = new MediaBlocksPipeline();

// Sélection automatique du meilleur décodeur VP8 disponible
var vp8Decoder = new VP8DecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_vp8.webm");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_vp8.webm");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), vp8Decoder.Input);
pipeline.Connect(vp8Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();

// Sélection automatique (recommandé)
var vp9Decoder = new VP9DecoderBlock();

// Sélection explicite du backend :
// VPX (logiciel, large compatibilité)
var vp9Decoder = new VP9DecoderBlock(new VPXVP9DecoderSettings());

// FFmpeg (logiciel)
var vp9Decoder = new VP9DecoderBlock(new FFMPEGVP9DecoderSettings());

// NVIDIA NVDEC (matériel)
var vp9Decoder = new VP9DecoderBlock(new NVVP9DecoderSettings());

// VAAPI (Linux uniquement, matériel)
var vp9Decoder = new VP9DecoderBlock(new VAAPIVP9DecoderSettings());

// D3D11/DXVA (Windows uniquement, matériel)
var vp9Decoder = new VP9DecoderBlock(new D3D11VP9DecoderSettings());

var pipeline = new MediaBlocksPipeline();

// Sélection automatique du meilleur décodeur VP9 disponible
var vp9Decoder = new VP9DecoderBlock();

var basicFileSource = new BasicFileSourceBlock("test_vp9.webm");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_vp9.webm");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), vp9Decoder.Input);
pipeline.Connect(vp9Decoder.Output, videoRenderer.Input);

await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

var vp8AlphaDecoder = new VP8AlphaDecodeBinBlock();

var basicFileSource = new BasicFileSourceBlock("test_vp8_alpha.webm");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_vp8_alpha.webm");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), vp8AlphaDecoder.Input);
pipeline.Connect(vp8AlphaDecoder.Output, videoRenderer.Input);

await pipeline.StartAsync();

var pipeline = new MediaBlocksPipeline();

var vp9AlphaDecoder = new VP9AlphaDecodeBinBlock();

var basicFileSource = new BasicFileSourceBlock("test_vp9_alpha.webm");
var reader = new MediaInfoReaderX();
await reader.OpenAsync("test_vp9_alpha.webm");
var mediaInfo = reader.Info;
if (mediaInfo == null)
{
    Console.WriteLine("Échec de l'obtention des informations multimédias.");
    return;
}
var universalDemux = new UniversalDemuxBlock(mediaInfo, renderVideo: true, renderAudio: false);
var videoRenderer = new VideoRendererBlock(pipeline, VideoView1);

pipeline.Connect(basicFileSource.Output, universalDemux.Input);
pipeline.Connect(universalDemux.GetVideoOutput(), vp9AlphaDecoder.Input);
pipeline.Connect(vp9AlphaDecoder.Output, videoRenderer.Input);

await pipeline.StartAsync();