Notatka
Dostęp do tej strony wymaga autoryzacji. Może spróbować zalogować się lub zmienić katalogi.
Dostęp do tej strony wymaga autoryzacji. Możesz spróbować zmienić katalogi.
Usługa Video Super Resolution (VSR) używa modelu uczenia maszynowego do skalowania strumieni wideo o niskiej rozdzielczości przedstawiających osoby, przywracając ostrość i szczegóły, które w przeciwnym razie zostaną utracone z powodu ograniczeń przepustowości, słabych warunków sieciowych, kompresji lub zawartości źródłowej niższej jakości.
Galeria deweloperów sztucznej inteligencji udostępnia interaktywny przykład, który pozwala porównać ulepszone wideo, sprawdzić źródło i wyeksportować przykład jako projekt Visual Studio.
Dodawanie możliwości usługi VSR do aplikacji umożliwia scenariusze, w tym następujące:
- Poprawa jakości wideo za pośrednictwem słabych połączeń sieciowych
- Optymalizacja przepustowości w celu zmniejszenia kosztów usługi CDN
- Scenariusze o wysokiej przepustowości, takie jak połączenia wideo grupowe z wieloma uczestnikami
- Poprawianie jakości wideo w mediach społecznościowych podczas edytowania, przekazywania lub wyświetlania
Funkcja VSR jest dostępna na Copilot+ PCs z układem NPU, urządzeniach z obsługiwanym układem GPU i urządzeniach opartych na CPU. Obsługa GPU rozszerza usługę VSR na ponad 400 milionów urządzeń z obsługiwanymi procesorami GPU. Aby uzyskać najlepszą wydajność procesora, wybieraj urządzenia spełniające zalecane specyfikacje procesora CPU. Aby uzyskać więcej informacji, zobacz Tworzenie aplikacji AI dla komputerów Copilot+ PC oraz tabelę obsługiwanego sprzętu.
Wymagania wstępne i dostępność interfejsu API
Skorzystaj z obsługiwanego urządzenia Windows 11 i postępuj zgodnie ze wskazówkami dotyczącymi konfigurowania interfejsów API AI systemu Windows dla wymagań wstępnych dotyczących systemu operacyjnego, środowiska uruchomieniowego i wdrożenia. Aplikacja używa modelu wdrożenia zestawu SDK dla wymaganych zasobów środowiska uruchomieniowego i modelu; VideoScaler nie akceptuje nazw plików modelu dostarczonych przez aplikację.
Important
Przeciążenie opcji tworzenia, jawne opcje scenariusza/urządzenia/jakości i właściwości koloru wejściowego należą do powierzchni API eksperymentalnej wersji kontraktu 2. Nie są obecne we wszystkich starszych ani stabilnych wersjach Zestaw SDK do aplikacji systemu Windows. Zapoznaj się z dokumentacją interfejsu API i informacjami o wersji dla wybranego pakietu SDK, aby sprawdzić, jakie składowe udostępnia, oraz minimalną wersję i kompilację systemu Windows, których wymaga. Obecność interfejsu API w źródłach programistycznych nie ustanawia jej dostępności w opublikowanym zestawie SDK.
Modele i obsługa urządzeń
W poniższej tabeli opisano każdy model i jego obsługę urządzeń. FaceFocused / Talking Head jest scenariuszem domyślnym FaceFocused; Gaming SR odpowiada Gaming. Automatyczna kolejność urządzeń zawiera listę kolejności awaryjnej inicjalizacji dla kwalifikujących się urządzeń.
| Model | Description | Automatyczne zamawianie urządzenia | Inne żądania dotyczące urządzeń |
|---|---|---|---|
| FaceFocused /Mówiąca głowa | Ulepsza szczegóły twarzy przechwytywane podczas rozmów wideo, co zwiększa czytelność, a jednocześnie zapewnia wydajność w czasie rzeczywistym. | NPU, GPU, CPU | Obsługa NPU/GPU/CPU po wybraniu, jeśli jest dostępna |
| Tekst wyostrzony | Poprawia wyrazistość przechwyconego przez aparat tekstu i drobnych krawędzi, zwłaszcza na większych ekranach, na których artefakty kompresji i skalowania są bardziej zauważalne. | GPU, CPU | NPU nieobsługiwane |
| SR w grach | Zwiększa strumienie gier o niższej rozdzielczości na urządzeniu użytkownika, poprawiając postrzegane szczegóły przy jednoczesnym umożliwieniu mniejszej przepustowości przesyłania strumieniowego. | Tylko procesor GPU | Brak obsługi CPU/NPU |
| Stabilizacja | Zmniejsza niepożądany ruch kamery, aby uzyskać bardziej stabilny obraz wideo w czasie rzeczywistym, dzięki czemu zdalna współpraca i demonstracje są łatwiejsze do śledzenia, gdy kamera jest trzymana w ręku lub się porusza. | Tylko CPU | Nieobsługiwane GPU/NPU |
Obsługiwany sprzęt
| Sprzęt | Status | Details |
|---|---|---|
| NPU (Copilot+ PC) | ✅ Dostępne | Zobacz przewodnik dla deweloperów Copilot+ PCs. |
| CPU | ✅ Dostępne | Najlepiej na urządzeniach spełniających zalecane specyfikacje procesora CPU. Usługa VSR nadal będzie próbować działać na urządzeniach o niższej specyfikacji, ale jakość i szybkość klatek w czasie rzeczywistym mogą cierpieć. |
| procesor GPU | ✅ Dostępne | Obsługiwane procesory GPU można wybrać automatycznie, jeśli spełniają warunki. Żądania jawne Gpu wymagają eksperymentalnej wersji kontraktu 2; dostępność zależy od scenariusza i sprzętu. Zobacz Wybieranie urządzenia wykonawczego, scenariusza i jakości. |
Note
Wybór sprzętu jest domyślnie automatyczny. Przeciążenie bezparametrowe VideoScaler.CreateAsync() używa FaceFocused z automatycznym wyborem urządzenia i jakości.
Automatic zezwala na inicjalizację awaryjną; nie gwarantuje wykonania na NPU ani obejścia brakujących wymagań wstępnych. Jawne żądanie urządzenia używa tego urządzenia lub kończy się niepowodzeniem. Zobacz Obsługiwany sprzęt, aby uzyskać widok między interfejsami API.
Poniższe wskazówki dotyczące rozdzielczości i szybkości klatek dotyczą usługi VSR skupionej na twarzy. Formaty ramek zależą od metody przetwarzania.
| Attribute | Obsługiwana zawartość |
|---|---|
| Rozdzielczość danych wejściowych | 240p – 1440p |
| Rozdzielczość danych wyjściowych | 480p – 1440p (4K do przetwarzania wideo w trybie offline) |
| Zakres klatek na sekundę (FPS) | 15 kl./s – 60 kl./s |
| Format pikseli wejściowych | RGB/BGR (ScaleImageBuffer), NV12 (Scale) |
| Format pikseli wyjściowych | RGB/BGR (ScaleImageBuffer), NV12 lub obsługiwane BGRA/BGRX (Scale) |
Zalecane specyfikacje procesora CPU
Użyj modelu wdrażania zestawu SDK dla zasobów środowiska uruchomieniowego oraz zasobów modelu. Na urządzeniach z procesorem CPU rzeczywista wydajność zależy od urządzenia, scenariusza i dostępnych modeli.
Aby zapewnić optymalną wydajność procesora CPU, wybierz urządzenia docelowe spełniające wszystkie poniższe zalecane parametry:
- 4 lub więcej rdzeni fizycznych
- Zegar podstawowy 3 GHz lub wyższy
- 32 MB lub więcej pamięci podręcznej L3
Są to zalecenia, a nie twarde minimum — interfejs API nadal będzie próbował skalować na urządzeniach o niższej specyfikacji. Aplikacje przeznaczone do działania na szerokiej gamie procesorów powinny sprawdzać procesor w czasie wykonywania i, jeśli urządzenie nie spełnia zalecanego minimum, przełączyć się na potok przetwarzania bez VSR lub wyświetlić użytkownikowi komunikat o kompromisie jakościowym.
Note
GetReadyState() jest opcjonalnym sprawdzaniem możliwości, a nie przygotowaniem modelu lub urządzenia. Nie ładuje modeli, nie inicjuje żądanego urządzenia ani nie gwarantuje, że tworzenie lub przetwarzanie ramek powiedzie się. Test procesora CPU jest zaleceniem wydajności, a nie testem kwalifikacji dla interfejsu API; użyj go, aby ukierunkować wybory dotyczące UX i oddzielnie obsługiwać błędy tworzenia i przetwarzania.
Sprawdź poziom wsparcia CPU
Poniższy przykład w języku C# używa Instrumentacji zarządzania Windows (WMI) do wykonywania zapytań do klasy Win32_Processor i zwraca true, gdy urządzenie spełnia zalecane wymagania. W przykładzie użyto opublikowanego przez firmę Microsoft pakietu NuGet System.Management — standardowej nakładki platformy .NET dla WMI — do wywoływania WMI z poziomu języka 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;
}
Użyj tego wyniku, aby sterować wyborami UX — na przykład wyświetlić wskazówkę o kompromisie między jakością a wydajnością, domyślnie ustawić niższą rozdzielczość wyjściową lub całkowicie pominąć VSR na urządzeniach, które nie spełniają zaleceń.
Uwagi dotyczące sprawdzania WMI
- Buforuj wynik. Pierwsze zapytanie WMI trwa około 50–200 ms z powodu inicjalizacji COM. Kolejne zapytania są szybkie, ale najczystszym wzorcem jest uruchamianie
MeetsRecommendedCpuSpecsraz podczas uruchamiania i buforowanie wartości logicznej przez cały okres istnienia procesu. Sprzęt CPU nie zmienia się w czasie działania. -
MaxClockSpeedjest zegarem bazowym, a nie taktowaniem boost. Procesor o taktowaniu 2,5 GHz, który w trybie turbo osiąga 4,5 GHz, zgłosi2500i nie przejdzie testu 3 GHz. Jest to celowe — ciągła przepływność ma większe znaczenie niż szczytowy wzrost obciążeń przesyłania strumieniowego sztucznej inteligencji, takich jak VSR, więc zegar podstawowy jest odpowiednim sygnałem. - Alternatywa dla kontroli podseksekundowych. Jeśli chcesz uniknąć zależności
System.Managementlub koszt usługi WMI jest niedopuszczalny (na przykład na gorącej ścieżce uruchamiania), te same dane są dostępne za pośrednictwem natywnych interfejsów API Windows:GetLogicalProcessorInformationExzwraca liczby rdzeni i rozmiary pamięci podręcznej, a szacowana szybkość zegara jest widoczna naHKLM\HARDWARE\DESCRIPTION\System\CentralProcessor\0(~MHzwartość). Są one zwracane w czasie poniżej milisekund, ale wymagają więcej kodu.
Tworzenie sesji usługi VideoScaler
Utwórz moduł skalowania raz dla strumienia, przed pętlą ramki i użyj go ponownie podczas przetwarzania tego strumienia. W poniższym przykładzie użyto przeciążenia bez parametrów do przetwarzania ukierunkowanego na twarz z automatycznym wyborem urządzenia i jakości.
GetReadyState() i EnsureReadyAsync() pozostają obsługiwane jako opcjonalne kontrole możliwości, ale żadna z nich nie jest warunkiem wstępnym utworzenia. Nie pobierają modeli ani nie przygotowują żądanego urządzenia. Jeśli używasz polecenia EnsureReadyAsync(), obsłuż jego wynik i wyjątki.
Obsługuj błędy tworzenia nawet po pomyślnym zakończeniu sprawdzania gotowości. Ograniczenia dostępu, niedostępny sprzęt lub błędy konfiguracji środowiska uruchomieniowego/dostawcy mogą uniemożliwić utworzenie.
using Microsoft.Windows.AI.Video;
private VideoScaler? _videoScaler;
protected override async Task LoadModelAsync(SampleNavigationParameters sampleParams)
{
try
{
_videoScaler = await VideoScaler.CreateAsync();
}
catch (Exception ex)
{
ShowException(ex, "Failed to create the video scaler.");
}
finally
{
sampleParams.NotifyCompletion();
}
}
Wybieranie urządzenia wykonawczego, scenariusza i jakości
Poniższe opcjonalne mechanizmy wymagają zestawu SDK, który udostępnia powierzchnię API eksperymentalnego kontraktu w wersji 2. Przeciążenie tworzenia bez parametrów i istniejące wartości domyślne opcji ramki są niezmienione; nie udostępnia nowych członków w starszych ani stabilnych wersjach zestawu SDK. Zobacz Wymagania wstępne i dostępność interfejsu API.
Opcje tworzenia
Wywołaj metodę VideoScaler.CreateAsync(VideoScalerCreationOptions) , aby skonfigurować sesję podczas jej tworzenia. Wszystkie właściwości są opcjonalne, a opcje tworzenia o wartości null używają wartości domyślnych.
| Property | Values | Domyślnie | Description |
|---|---|---|---|
ExecutionDevice |
Automatic, Npu, Gpu, Cpu |
Automatic |
Wybiera urządzenie wykonywania. Wybór automatyczny zezwala na mechanizm awaryjny inicjalizacji; jawne żądanie używa tego urządzenia lub kończy się niepowodzeniem. |
Scenario |
FaceFocused, TextFocused, Gaming, Stabilization |
FaceFocused |
Wybór jednego scenariusza przetwarzania. Zobacz Modele i obsługa urządzeń. |
QualityPreference |
Automatic, FavorPerformance, FavorQuality |
Automatic |
Określa, czy faworyzować szybkość, czy jakość wizualizacji. |
Note
Preferencje dotyczące jakości nie gwarantują określonego modelu, wyniku ani szybkości klatek. Obsługiwane opcje sprzętu i modelu zależą od scenariusza i wydania zestawu SDK; sama wartość wyliczeniowa nie określa kwalifikowalności urządzenia.
Każda instancja przetwarza jeden scenariusz; scenariusze nie są łączone w niejawny łańcuch efektów. Zmiana obiektu creation-options nie powoduje ponownej konfiguracji wystąpienia. Utwórz nowe wystąpienie dla innego scenariusza, urządzenia lub żądania jakości.
Stabilizacja działa wyłącznie na CPU i wymaga przetwarzania pełnej klatki o wymiarach co najmniej 32 pikseli na bok. Użyj jednego uporządkowanego strumienia na wystąpienie, ponieważ stabilizacja zachowuje historię ramek i utwórz nowe wystąpienie dla niezależnego strumienia. Może zmienić rozmiar na żądane wymiary wyjściowe; zmiana rozmiaru powoduje zresetowanie jego historii.
Opcje kolorów poszczególnych ramek
VideoScalerOptions dodaje właściwości opisujące kodowanie kolorów ramek wejściowych NV12.
| Property | Values | Domyślnie | Description |
|---|---|---|---|
InputColorRange |
Full, Limited |
Full |
Zakres kwantyzacji danych wejściowych NV12. |
InputColorMatrix |
Bt601, Bt709 |
Bt601 |
Macierz konwersji YUV-to-RGB danych wejściowych NV12. |
Brak opcji ramki oznacza przetwarzanie pełnej ramki z ustawieniami domyślnymi BT.601 z pełnym zakresem. Ustaw właściwości koloru tak, aby odpowiadały rzeczywistemu źródłu NV12; dane RGB/BGR ImageBuffer mają pełny zakres.
Wyjście NV12 dziedziczy zadeklarowany zakres wejściowy i macierz, podczas gdy dane wyjściowe z rodziny RGB mają pełny zakres. Te opcje nie wybierają niezależnie koloru wyjściowego, funkcji transferu HDR ani konwersji gamy. Niepowodzenie wymaganej konwersji nie generuje prawidłowych danych wyjściowych o odmiennej semantyce kolorów.
Example
W poniższym przykładzie tworzony jest skaler skoncentrowany na twarzy z automatycznym wyborem urządzenia i jakości, a następnie przetwarza jedną ramkę BT.709 o ograniczonym zakresie. Utwórz skaler przed pętlą przetwarzania ramek, ponownie użyj opcji ramki, dopóki kodowanie wejściowe pozostaje takie samo, i sprawdź wynik każdej ramki.
using Microsoft.Windows.AI.Video;
try
{
using var scaler = await VideoScaler.CreateAsync(new VideoScalerCreationOptions
{
Scenario = VideoScalerScenario.FaceFocused,
ExecutionDevice = VideoScalerExecutionDevice.Automatic,
QualityPreference = VideoScalerQualityPreference.Automatic
});
var frameOptions = new VideoScalerOptions
{
InputColorRange = VideoColorRange.Limited,
InputColorMatrix = VideoColorMatrix.Bt709
};
var result = scaler.Scale(inputD3dSurface, outputD3dSurface, frameOptions);
if (result.Status != VideoScalerStatus.Success)
{
System.Diagnostics.Debug.WriteLine($"Frame failed: {result.Status}");
return;
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine($"VideoScaler failed: {ex.Message}");
}
Przetwarzanie ramek i obsługa błędów
Scale i ScaleImageBuffer przetwarzają ramki synchronicznie; tworzenie asynchroniczne nie powoduje asynchronicznego przetwarzania ramek. Preferuj Scale , gdy ramki znajdują się już w teksturach D3D11 bez konwertowania ich na pośrednie ImageBuffer. Nie gwarantuje to przetwarzania bez kopiowania ani tego samego kosztu transferu na każdym urządzeniu.
Zażądaj końcowej rozdzielczości wyjściowej wymaganej przez aplikację; nie potrzebujesz pośredniego obrazu 2x. Używaj prawidłowych wymiarów, formatów, kroków wierszy i pojemności buforu oraz zachowaj zarówno zasoby wejściowe, jak i wyjściowe, dopóki wywołanie się nie zakończy. Wiersze z dopełnieniem są obsługiwane w przypadku poprawnego opisania.
W przypadku przetwarzania powierzchni użyj różnych zasobów tekstur wejściowych i wyjściowych. Wymiary NV12 muszą być parzyste, a powierzchnie wyjściowe muszą być zapisywalne. Łańcuchy mip, tablice tekstur i wieloprzykładowe nie są obsługiwane; Dane wyjściowe BGRA są nieprzezroczyste, a nieużywany bajt BGRX jest również ustawiony na 255.
VideoScalerOptions.RegionsOfInterest zawiera prostokąty współrzędnych wejściowych o dodatnich rozmiarach, które mieszczą się całkowicie wewnątrz ramki wejściowej. Pusta kolekcja oznacza przetwarzanie w pełnej ramce; Nieprawidłowe regiony są odrzucane, a nie przycinane. Stabilizacja obsługuje tylko przetwarzanie w pełnej ramce.
Każde wywołanie dla każdej klatki zwraca wartość VideoScalerResult. Przed użyciem danych wyjściowych sprawdź Status.
| Status | Meaning |
|---|---|
Success |
Przetwarzanie zostało zakończone pomyślnie. |
InvalidInputFormat |
Format danych wejściowych lub surface nie są akceptowane. |
InvalidOutputFormat |
Format wyjściowy lub powierzchnia nie są akceptowane. |
InvalidPlaneSize |
Wymiary, układ, krok lub pojemność są nieprawidłowe. |
InvalidFrameData |
Brakuje danych ramki lub są one nieprawidłowe, w tym nieprawidłowe regiony zainteresowania. |
ModelNotAvailable |
Implementacja przetwarzania jest niedostępna. |
OutOfMemory |
Pamięć jest niewystarczająca. |
Failure |
Wystąpił inny błąd przetwarzania. |
Wywołania związane z ramkami mogą również zgłaszać wyjątki interfejsu API, argumentów lub cyklu życia obiektu, więc należy obsługiwać wyjątki, a także zwracane stany. Nie używaj danych wyjściowych ramki, które zakończyły się niepowodzeniem jako prawidłowych danych; zdecyduj, czy należy ponowić próbę, czy upuścić ramkę. Wcześniejszy sukces nie gwarantuje późniejszego powodzenia, a niepowodzenie ramki nie powoduje automatycznego przełączenia wystąpienia na inne urządzenie.
Usuń lub zamknij moduł skalowania po zakończeniu strumienia, gdy wywołania przetwarzania zostaną zwrócone. Wywołania po Close() lub przewidywanym Dispose() są odrzucane.
Skalowanie VideoFrame
W poniższym przykładzie kodu użyto metody VideoScaler.Scale w celu skalowania danych obrazów w górę zawartych w obiekcie VideoFrame . VideoFrame można pobrać z kamery przy użyciu klasy MediaFrameReader. Aby uzyskać więcej informacji, zobacz Przetwarzanie ramek multimedialnych za pomocą elementu MediaFrameReader. Możesz również użyć kontrolki CameraPreview zestawu narzędzi WinUI Community Toolkit, aby pobrać obiekty VideoFrame z kamery.
Następnie element Direct3DSurface jest uzyskiwany z wejściowej ramki wideo, a kolejny element Direct3DSurface tworzony jest dla wyniku skalowania w górę. W tym przykładzie szerokość i wysokość wejściowe są podwajane, aby zademonstrować skalowanie 2x; wybierz wymiary wejściowe, które utrzymują rozdzielczość wyjściową w obsługiwanych limitach rozdzielczości. Funkcja VideoScaler.Scale jest wywoływana w celu skalowania w górę ramki. W tym przykładzie kontrolka Obraz w interfejsie użytkownika aplikacji jest aktualizowana za pomocą powiększonej ramki.
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
{
int outputWidth = checked(width * 2);
int outputHeight = checked(height * 2);
using var inputVideoFrame = inputD3dSurface == null
? VideoFrame.CreateAsDirect3D11SurfaceBacked(
Windows.Graphics.DirectX.DirectXPixelFormat.NV12,
width,
height)
: null;
if (inputVideoFrame != null)
{
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 != outputWidth || _outputHeight != outputHeight)
{
_outputD3dSurface?.Dispose();
// DXGI_FORMAT_B8G8R8A8_UNORM = 87
_outputD3dSurface = Direct3DExtensions.CreateDirect3DSurface(87, outputWidth, outputHeight);
_outputWidth = outputWidth;
_outputHeight = outputHeight;
}
// 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;
}
});
}
Skalowanie obiektu SoftwareBitmap przy użyciu bufora obrazu
Poniższy przykład przetwarza SoftwareBitmap z użyciem ScaleImageBuffer, podwajając szerokość i wysokość danych wejściowych. Krok wyjściowy i pojemność buforu używają tych większych wymiarów. Metody pomocnicze konwertują mapę bitową na BGR8 ImageBuffer i konwertują dane wyjściowe na BGRA8 na potrzeby wyświetlania. Jeśli ramki znajdują się już w teksturach D3D11, lepiej użyć Scale, zamiast konwertować je na bufor pośredni.
Przykładowy kod w tym artykule jest oparty na składniku VSR w przykładach interfejsu API Windows AI.
public SoftwareBitmap ScaleVideoFrame(SoftwareBitmap inputFrame)
{
ImageBuffer inputImageBuffer = SoftwareBitmapExtensions.ConvertToBgr8ImageBuffer(inputFrame);
int outputWidth = checked(inputFrame.PixelWidth * 2);
int outputHeight = checked(inputFrame.PixelHeight * 2);
int outputStride = checked(outputWidth * 3);
uint size = checked((uint)outputStride * (uint)outputHeight);
IBuffer outputBuffer = new global::Windows.Storage.Streams.Buffer(size);
outputBuffer.Length = size;
ImageBuffer outputImageBuffer = ImageBuffer.CreateForBuffer(
outputBuffer,
ImageBufferPixelFormat.Bgr8,
outputWidth,
outputHeight,
outputStride);
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);
}
Metody rozszerzenia mapy bitowej oprogramowania
Poniższe metody pomocnicze konwertują mapę SoftwareBit między formatami BGRA8 i BGR8 , aby odpowiadały wymaganiom wejściowym i wyjściowym skalara wideo.
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;
}
Odpowiedzialne używanie sztucznej inteligencji
Przestrzegaliśmy podstawowych zasad i praktyk opisanych w standardach odpowiedzialnej sztucznej inteligencji firmy Microsoft, aby upewnić się, że te interfejsy API są wiarygodne, bezpieczne i tworzone odpowiedzialnie. Aby uzyskać wskazówki dotyczące dodawania ulepszeń wideo opartych na modelu do aplikacji, zobacz Odpowiedzialne tworzenie generatywnej sztucznej inteligencji na platformie Windows.
FaceFocused Domyślny scenariusz jest przeznaczony dla połączeń wideo, konferencji i filmów społecznościowych i krótkich, które zawierają ludzkie twarze mówiące. W następujących scenariuszach nie zalecamy używania superrozdzielczości w przypadku filmów wideo:
- Jeśli film zawiera potencjalnie wrażliwą zawartość i rozbudowy, może wprowadzać mylące szczegóły lub zmienić tożsamość lub cechy twarzy, takie jak nagrania osób, symbole kulturowe lub symbole religijne.
- Gdy wierny, niezmieniony film ma kluczowe znaczenie, na przykład w obrazowaniu medycznym, jako dowód prawny lub kryminalistyczny albo przy weryfikacji tożsamości.