Yapay Zeka Video Süper Çözünürlüğü (VSR) kullanmaya başlama

Video Süper Çözünürlük (VSR), düşük çözünürlüklü video akışlarını akıllı bir şekilde ölçeklendiren, bant genişliği sınırlamaları, kötü ağ koşulları, sıkıştırma veya düşük kaliteli kaynak içeriği nedeniyle kaybolabilecek keskinliği ve ayrıntıları geri yükleyen yapay zeka tabanlı bir video yükseltme örnekleme teknolojisidir.

Uygulamanıza VSR özellikleri eklemek, aşağıdakiler de dahil olmak üzere senaryoları etkinleştirir:

Düşük ağ bağlantıları üzerinden video kalitesini iyileştirme
CDN maliyetlerini azaltmak için bant genişliği iyileştirmesi
Birden çok katılımcıyla görüntülü grup aramaları gibi yüksek bant genişliğine sahip senaryolar
Düzenleme, karşıya yükleme veya görüntülemede sosyal medya video kalitesini iyileştirme

VSR özelliği şu anda NPU'ya sahip bir Copilot+ bilgisayar gerektirir. Daha fazla bilgi için bkz. Copilot+ bilgisayarlar için yapay zeka uygulamaları geliştirme.

Bu VSR API'leri Machine Learning (ML) modellerini kullanır, görüntülü arama ve konferans uygulamaları gibi senaryolar ve insan yüzlerinin konuşmalarını içeren sosyal ve kısa biçimli videolar için özel olarak tasarlanmıştır

VSR şu anda aşağıdaki çözünürlük, biçim ve FPS aralıklarını destekler:

Özellik	Desteklenen İçerik
Giriş çözünürlüğü	240p – 1440p
Çıkış çözünürlüğü	480p – 1440p
Saniye başına kare (FPS) aralığı	15 fps – 60 fps
Giriş pikseli biçimi	BGR (ImageBuffer API), NV12 (Direct3D API)
Çıkış pikseli biçimi	BGR (ImageBuffer API), BGRA (Direct3D API)

Bir VideoScaler oturumu oluşturun

Aşağıdaki örnekte VSR oturumunun nasıl oluşturulacağı gösterilmektedir. İlk olarak ExecutionProviderCatalog örneğini alın ve kullanılabilir modelleri yüklemek için EnsureAndRegisterCertifiedAsync öğesini çağırın. Video ölçekleyicinin çerçeveleri işlemeye hazır olup olmadığını belirlemek için VideoScalar sınıfında GetReadyState'i çağırın. Aksi takdirde, video ölçeklendiricisini başlatmak için EnsureReadyAsync'i çağırın.


private VideoScaler? _videoScaler;

protected override async Task LoadModelAsync(SampleNavigationParameters sampleParams)
{
    try
    {

        var catalog = ExecutionProviderCatalog.GetDefault();
        await catalog.EnsureAndRegisterCertifiedAsync();

        var readyState = VideoScaler.GetReadyState();
        if (readyState == AIFeatureReadyState.NotReady)
        {
            var operation = await VideoScaler.EnsureReadyAsync();

            if (operation.Status != AIFeatureReadyResultState.Success)
            {
                ShowException(null, "Video Scaler is not available.");
            }
        }

        _videoScaler = await VideoScaler.CreateAsync();
    }
    catch (Exception ex)
    {
        ShowException(ex, "Failed to load model.");
    }

    sampleParams.NotifyCompletion();
}

VideoFrame'i ölçeklendirme

Aşağıdaki kod örneği, VideoFrame nesnesinde bulunan görüntü verilerinin ölçeğini genişletmek için VideoScaler.ScaleFrame yöntemini kullanır. MediaFrameReader sınıfını kullanarak kameradan VideoFrame alabilirsiniz. Daha fazla bilgi için bkz . MediaFrameReader ile medya çerçevelerini işleme. Kameradan VideoFrame nesneleri almak için WinUI Community Toolkit CameraPreview denetimini de kullanabilirsiniz.

Ardından, giriş video çerçevesinden bir Direct3DSurface elde edilir ve yukarı ölçeklendirmenin çıkışı için başka bir Direct3DSurface oluşturulur. VideoScaler.ScaleFrame , çerçevenin ölçeğini genişletmek için çağrılır. Bu örnekte, uygulamanın kullanıcı arabirimindeki bir Görüntü denetimi, ölçeklendirilen çerçeveyle güncelleştirilir.

 private async Task ProcessFrame(VideoFrame videoFrame)
{
    // Process the frame with super resolution model
    var processedBitmap = await Task.Run(async () =>
    {
        int width = 0;
        int height = 0;
        var inputD3dSurface = videoFrame.Direct3DSurface;
        if (inputD3dSurface != null)
        {
            Debug.Assert(inputD3dSurface.Description.Format == Windows.Graphics.DirectX.DirectXPixelFormat.NV12, "input in NV12 format");
            width = inputD3dSurface.Description.Width;
            height = inputD3dSurface.Description.Height;
        }
        else
        {
            var softwareBitmap = videoFrame.SoftwareBitmap;
            if (softwareBitmap == null)
            {
                return null;
            }

            Debug.Assert(softwareBitmap.BitmapPixelFormat == BitmapPixelFormat.Nv12, "input in NV12 format");

            width = softwareBitmap.PixelWidth;
            height = softwareBitmap.PixelHeight;
        }

        try
        {
            if (inputD3dSurface == null)
            {
                // Create Direct3D11-backed VideoFrame for input
                using var inputVideoFrame = VideoFrame.CreateAsDirect3D11SurfaceBacked(
                    Windows.Graphics.DirectX.DirectXPixelFormat.NV12,
                    width,
                    height);

                if (inputVideoFrame.Direct3DSurface == null)
                {
                    return null;
                }

                // Copy the software bitmap to the Direct3D-backed frame
                await videoFrame.CopyToAsync(inputVideoFrame);

                inputD3dSurface = inputVideoFrame.Direct3DSurface;
            }

            // Create or resize output surface (BGRA8 format for display)
            if (_outputD3dSurface == null || _outputWidth != width || _outputHeight != height)
            {
                _outputD3dSurface?.Dispose();

                // DXGI_FORMAT_B8G8R8A8_UNORM = 87
                _outputD3dSurface = Direct3DExtensions.CreateDirect3DSurface(87, width, height);
                _outputWidth = width;
                _outputHeight = height;
            }

            // Scale the frame using VideoScaler
            var result = _videoScaler!.ScaleFrame(inputD3dSurface, _outputD3dSurface, new VideoScalerOptions());

            if (result.Status == ScaleFrameStatus.Success)
            {
                var outputBitmap = await SoftwareBitmap.CreateCopyFromSurfaceAsync(
                    _outputD3dSurface,
                    BitmapAlphaMode.Premultiplied);

                return outputBitmap;
            }
        }
        catch (Exception ex)
        {
            System.Diagnostics.Debug.WriteLine($"ProcessFrame error: {ex.Message}");
        }

        return null;
    });

    if (processedBitmap == null)
    {
        return;
    }

    DispatcherQueue.TryEnqueue(async () =>
    {
        using (processedBitmap)
        {
            var source = new SoftwareBitmapSource();
            await source.SetBitmapAsync(processedBitmap);
            ProcessedVideoImage.Source = source;
        }
    });
}

ImageBuffer kullanarak SoftwareBitmap'i ölçeklendirme

Aşağıdaki kod örneği, SoftwareBitmap'i ölçeklendirmek için VideoScalar sınıfının kullanımını gösterir. Bu örnek, VSR API'lerinin tipik bir kullanımını temsil etmez. Direct3D kullanmaktan daha az performanslıdır. Ancak bu örneği, kamera veya video akış işlem hattı ayarlamadan VSR API'leriyle denemeler yapmak için kullanabilirsiniz. Video ölçeklendiricisi ImageBuffer kullanırken BGR8 gerektirdiğinden, sağlanan SoftwareBitmap'in piksel biçimini dönüştürmek için bazı yardımcı yöntemler gerekir.

Bu makaledeki örnek kod, Windows AI API örneklerinin VSR bileşenini temel alır

    public SoftwareBitmap ScaleVideoFrame(SoftwareBitmap inputFrame)
    {
        ImageBuffer inputImageBuffer = SoftwareBitmapExtensions.ConvertToBgr8ImageBuffer(inputFrame);
        var size = (uint)(inputFrame.PixelWidth * inputFrame.PixelHeight * 3);
        IBuffer outputBuffer = new global::Windows.Storage.Streams.Buffer(size);
        outputBuffer.Length = size;
        ImageBuffer outputImageBuffer = ImageBuffer.CreateForBuffer(
            outputBuffer,
            ImageBufferPixelFormat.Bgr8,
            inputFrame.PixelWidth,
            inputFrame.PixelHeight,
            inputFrame.PixelWidth * 3);
        var result = Session.ScaleFrame(inputImageBuffer, outputImageBuffer, new VideoScalerOptions());
        if (result.Status != ScaleFrameStatus.Success)
        {
            throw new Exception($"Failed to scale video frame: {result.Status}");
        }

        return SoftwareBitmapExtensions.ConvertBgr8ImageBufferToBgra8SoftwareBitmap(outputImageBuffer);
    }

Yazılım bitmap genişletme metotları

Aşağıdaki yardımcı yöntemler, bir SoftwareBitmap'iBGRA8 ve BGR8 biçimleri arasında video skaler'in giriş ve çıkış gereksinimlerine uyacak şekilde dönüştürür.

public static ImageBuffer ConvertToBgr8ImageBuffer(SoftwareBitmap input)
    {
        var bgraBitmap = input;
        if (input.BitmapPixelFormat != BitmapPixelFormat.Bgra8)
        {
            bgraBitmap = SoftwareBitmap.Convert(input, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
        }

        int width = bgraBitmap.PixelWidth;
        int height = bgraBitmap.PixelHeight;

        byte[] bgraBuffer = new byte[width * height * 4];
        bgraBitmap.CopyToBuffer(bgraBuffer.AsBuffer());

        byte[] bgrBuffer = new byte[width * height * 3];
        for (int i = 0, j = 0; i < bgraBuffer.Length; i += 4, j += 3)
        {
            bgrBuffer[j] = bgraBuffer[i];
            bgrBuffer[j + 1] = bgraBuffer[i + 1];
            bgrBuffer[j + 2] = bgraBuffer[i + 2];
        }

        return ImageBuffer.CreateForBuffer(
            bgrBuffer.AsBuffer(),
            ImageBufferPixelFormat.Bgr8,
            width,
            height,
            width * 3);
    }

    public static SoftwareBitmap ConvertBgr8ImageBufferToBgra8SoftwareBitmap(ImageBuffer bgrImageBuffer)
    {
        if (bgrImageBuffer.PixelFormat != ImageBufferPixelFormat.Bgr8)
        {
            throw new ArgumentException("Input ImageBuffer must be in Bgr8 format");
        }

        int width = bgrImageBuffer.PixelWidth;
        int height = bgrImageBuffer.PixelHeight;

        // Get BGR data from ImageBuffer
        byte[] bgrBuffer = new byte[width * height * 3];
        bgrImageBuffer.CopyToByteArray(bgrBuffer);

        // Create BGRA buffer (4 bytes per pixel)
        byte[] bgraBuffer = new byte[width * height * 4];

        for (int i = 0, j = 0; i < bgrBuffer.Length; i += 3, j += 4)
        {
            bgraBuffer[j] = bgrBuffer[i];     // B
            bgraBuffer[j + 1] = bgrBuffer[i + 1]; // G
            bgraBuffer[j + 2] = bgrBuffer[i + 2]; // R
            bgraBuffer[j + 3] = 255;              // A (full opacity)
        }

        // Create SoftwareBitmap and copy data
        var softwareBitmap = new SoftwareBitmap(
            BitmapPixelFormat.Bgra8,
            width,
            height,
            BitmapAlphaMode.Premultiplied);

        softwareBitmap.CopyFromBuffer(bgraBuffer.AsBuffer());

        return softwareBitmap;
    }

Sorumluluk sahibi yapay zeka

Bu API'lerin güvenilir, güvenli ve sorumlu bir şekilde oluşturulduğundan emin olmak için Microsoft Sorumlu Yapay Zeka Standartları'nda açıklanan temel ilkeleri ve uygulamaları izledik. Uygulamanızda yapay zeka özelliklerini uygulama hakkında daha fazla ayrıntı için bkz. Windows'ta Sorumlu Üretken Yapay Zeka Geliştirme.

Bu VSR API'leri, özellikle görüntülü arama ve konferans uygulamaları gibi senaryolar ile insan yüzlerinin konuştuğu sosyal ve kısa biçimli videolar için tasarlanmış Machine Learning (ML) modellerini kullanır. Bu nedenle, aşağıdaki senaryolarda görüntüler için bu API'lerin kullanılmasını önermeyiz:

Görüntülerin hassas olabilecek içerik içerdiği yerlerde ve bayraklar, haritalar, küreler, kültürel simgeler veya dini simgeler gibi yanlış açıklamalar tartışmalı olabilir.
Tıbbi tavsiye veya tanılama, yasal içerik veya finansal belgeler gibi doğru açıklamalar kritik olduğunda.

Ayrıca bakınız

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2026-01-21