Inizia con la Risoluzione Super Video AI (VSR)

Video Super Resolution (VSR) è una tecnologia di campionamento video basata su intelligenza artificiale che migliora intelligentemente i flussi video a bassa risoluzione di scene con persone, ripristinando nitidezza e dettagli che altrimenti andrebbero persi a causa di restrizioni di banda, scarse condizioni di rete, compressione o contenuti di origine di bassa qualità.

L'aggiunta di funzionalità VSR all'app consente scenari inclusi i seguenti:

• Miglioramento della qualità video rispetto alle connessioni di rete scarse
• Ottimizzazione della larghezza di banda per ridurre i costi della rete CDN
• Scenari a larghezza di banda elevata, ad esempio videochiamate di gruppo con più partecipanti
• Miglioramento della qualità dei video sui social media nella modifica, nel caricamento o nella visualizzazione

La funzionalità VSR è disponibile su Copilot+ PCs con una NPU e sui dispositivi che soddisfano le specifiche della CPU consigliate. Per ulteriori informazioni, vedere Sviluppare applicazioni di intelligenza artificiale per PC Copilot+ e la tabella dell'hardware supportato.

Hardware supportato

Queste API VSR utilizzano modelli di Machine Learning (ML) e sono progettate specificamente per scenari come app di videochiamata e conferenza, nonché per video brevi e social che includono volti umani parlanti.

VsR supporta attualmente la risoluzione, il formato e gli intervalli FPS seguenti:

Specifiche CPU consigliate

Il modello VSR viene distribuito come parte del SDK per app di Windows, quindi non è disponibile alcun passaggio di consenso separato per il download o la prima esecuzione nei dispositivi CPU. VSR funzionerà su qualsiasi CPU su cui funzionano anche le altre API di intelligenza artificiale di Windows, ma la qualità del ridimensionamento in tempo reale e la frequenza dei fotogrammi dipendono dalla CPU host.

Per ottenere prestazioni ottimali della CPU, scegli dispositivi target che soddisfano tutte le seguenti specifiche consigliate:

• 4 o più core fisici
• 3 GHz o un clock di base superiore
• 32 MB o più cache L3

Si tratta di raccomandazioni, non minimi rigidi: l'API tenterà comunque di ridimensionare su dispositivi con specifiche inferiori. Le applicazioni destinate a un'ampia gamma di CPU devono verificare la CPU in fase di esecuzione e, se il dispositivo non raggiunge il livello consigliato, ripiegare su una pipeline senza VSR oppure mostrare all'utente un avviso sul compromesso in termini di qualità.

Controllare il livello di supporto della CPU

L'esempio C# seguente usa Windows Management Instrumentation (WMI) per eseguire una query sulla classe Win32_Processor e restituisce true quando il dispositivo soddisfa le specifiche consigliate. L'esempio usa il pacchetto NuGet System.Management pubblicato da Microsoft, ovvero il wrapper .NET standard per WMI, per effettuare chiamate a WMI da C#.

using System;
using System.Management;

private static bool MeetsRecommendedCpuSpecs()
{
    const int RecommendedCores      = 4;
    const int RecommendedClockMhz   = 3000;
    const int RecommendedL3CacheKb  = 32 * 1024; // 32 MB

    int totalCores   = 0;
    int maxClockMhz  = 0;
    int maxL3CacheKb = 0;

    using var searcher = new ManagementObjectSearcher(
        "SELECT NumberOfCores, MaxClockSpeed, L3CacheSize FROM Win32_Processor");

    foreach (ManagementObject processor in searcher.Get())
    {
        totalCores   += Convert.ToInt32(processor["NumberOfCores"]);
        maxClockMhz   = Math.Max(maxClockMhz,   Convert.ToInt32(processor["MaxClockSpeed"]));
        maxL3CacheKb  = Math.Max(maxL3CacheKb,  Convert.ToInt32(processor["L3CacheSize"]));
    }

    return totalCores   >= RecommendedCores
        && maxClockMhz  >= RecommendedClockMhz
        && maxL3CacheKb >= RecommendedL3CacheKb;
}

Usare il risultato come criterio per le scelte dell'esperienza utente, ad esempio mostrando un avviso sul compromesso in termini di qualità, impostando per default una risoluzione di output inferiore oppure saltando del tutto VSR sui dispositivi che non soddisfano le raccomandazioni.

Note sul controllo WMI

• Memorizzare nella cache il risultato. La prima query WMI richiede circa 50-200 ms a causa dell'inizializzazione di COM. Le query successive sono veloci, ma il modello più pulito consiste nell'eseguire MeetsRecommendedCpuSpecs una sola volta all'avvio e memorizzare nella cache il valore booleano per la durata del processo. L'hardware della CPU non cambia in fase di esecuzione.
• MaxClockSpeed è la frequenza di base nominale, non la frequenza boost. Una CPU da 2,5 GHz che raggiunge 4,5 GHz in modalità turbo riporterà 2500 e non supererà il controllo dei 3 GHz. È una scelta intenzionale: per carichi di lavoro IA in streaming come VSR, il throughput sostenuto conta più della frequenza di boost di picco, quindi la frequenza di base è l’indicatore giusto.
• Alternativa per i controlli secondari in millisecondi. Se è necessario evitare la dipendenza da System.Management o l'overhead di WMI è inaccettabile (ad esempio, in un percorso critico di avvio), gli stessi dati sono disponibili tramite API native di Windows: GetLogicalProcessorInformationEx restituisce il numero di core e le dimensioni della cache, e la frequenza di clock nominale è disponibile in HKLM\HARDWARE\DESCRIPTION\System\CentralProcessor\0 (valore ~MHz). Questi restituiscono in un tempo inferiore al millisecondo, ma richiedono più codice.

Creare una sessione di VideoScaler

L'esempio seguente illustra come creare una sessione vsr. Prima di tutto, ottenere un'istanza di ExecutionProviderCatalog e chiamare EnsureAndRegisterCertifiedAsync per caricare i modelli disponibili. Chiamare GetReadyState nella classe VideoScaler per determinare se il ridimensionatore video è pronto per elaborare i fotogrammi. In caso contrario, chiamare EnsureReadyAsync per inizializzare il scaler video.

using Microsoft.Windows.AI;
using Microsoft.Windows.AI.MachineLearning;
using Microsoft.Windows.AI.Video;

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.NotSupportedOnCurrentSystem)
        {
            // VSR cannot run on this device. Fall back to a non-VSR pipeline
            // (for example, a bilinear or bicubic upscaler) or hide the feature.
            ShowException(null, "Video Super Resolution is not supported on this device.");
            return;
        }
        if (readyState == AIFeatureReadyState.NotReady)
        {
            var operation = await VideoScaler.EnsureReadyAsync();

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

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

    sampleParams.NotifyCompletion();
}

Ridimensionare un videoframe

Nell'esempio di codice seguente viene usato il metodo VideoScaler.Scale per ottenere dati di immagini di alto livello contenuti in un oggetto VideoFrame . È possibile ottenere VideoFrame da una fotocamera usando la classe MediaFrameReader . Per altre informazioni, vedere Elaborare fotogrammi multimediali con MediaFrameReader. Puoi anche usare il controllo CameraPreview di WinUI Community Toolkit per ottenere oggetti VideoFrame dalla fotocamera.

Successivamente, viene ottenuto un oggetto Direct3DSurface dal fotogramma video di input e viene creato un altro oggetto Direct3DSurface per l'output dell'upscaling. VideoScaler.Scale viene chiamato per aumentare il frame. In questo esempio, un controllo Image nell'interfaccia utente dell'app viene aggiornato con il fotogramma ad alta risoluzione.

 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!.Scale(inputD3dSurface, _outputD3dSurface, new VideoScalerOptions());

            if (result.Status == VideoScalerStatus.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;
        }
    });
}

Ridimensionare un softwareBitmap usando ImageBuffer

L'esempio di codice seguente illustra l'uso della classe VideoScaler per eseguire l'analisi di softwareBitmap. Questo esempio non rappresenta un utilizzo tipico delle API vsr. È meno efficiente rispetto all'uso di Direct3D. È tuttavia possibile usare questo esempio per sperimentare con le API VSR senza configurare una pipeline di streaming video o fotocamera. Poiché il ridimensionatore video richiede un BGR8 quando si usa imageBuffer, alcuni metodi helper sono necessari per convertire il formato pixel del softwareBitmap fornito.

Il codice di esempio in questo articolo si basa sul componente VSR degli esempi dell'API windows per intelligenza artificiale

    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 = _videoScaler!.ScaleImageBuffer(inputImageBuffer, outputImageBuffer, new VideoScalerOptions());
        if (result.Status != VideoScalerStatus.Success)
        {
            throw new Exception($"Failed to scale video frame: {result.Status}");
        }

        return SoftwareBitmapExtensions.ConvertBgr8ImageBufferToBgra8SoftwareBitmap(outputImageBuffer);
    }

Metodi di estensione del software bitmap

I metodi helper seguenti convertono un softwareBitmap tra formati BGRA8 e BGR8 in modo che corrispondano ai requisiti di input e output del scalare video.

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;
    }

Intelligenza artificiale responsabile

Sono stati seguiti i principi e le procedure di base descritti negli standard di intelligenza artificiale responsabile Microsoft per garantire che queste API siano affidabili, sicure e create in modo responsabile. Per altri dettagli sull'implementazione delle funzionalità di intelligenza artificiale nell'app, vedere Sviluppo di intelligenza artificiale generativa responsabile in Windows.

Queste API VSR, che utilizzano modelli di Machine Learning (ML), sono state progettate specificamente per scenari come videochiamate e conferenze, oltre a video social e video brevi che mostrano volti umani che parlano. Pertanto, non è consigliabile usare queste API per i video negli scenari seguenti:

• Dove il video contiene contenuti potenzialmente sensibili e l'upscaling potrebbero introdurre dettagli fuorvianti o alterare identità o caratteristiche facciali, ad esempio filmati di individui, simboli culturali o simboli religiosi.
• Quando un video fedele e inalterato è fondamentale, ad esempio per l'imaging medico, l'evidenza legale o forense o la verifica dell'identità.

Vedere anche

• AI Dev Gallery
• Esempi di API windows per intelligenza artificiale