Menggunakan DirectX dengan Warna Tingkat Lanjut pada tampilan rentang dinamis tinggi/standar

Topik ini menunjukkan cara menggunakan DirectX dengan skenario Warna Tingkat Lanjut—termasuk rentang dinamis tinggi (HDR), gamut warna lebar (WCG) dengan manajemen warna sistem otomatis, dan kedalaman bit tinggi. Tampilan komputer pribadi premium (PC) dengan setidaknya salah satu peningkatan di atas menjadi tersebar luas, memberikan keakuratan warna yang jauh lebih tinggi daripada tampilan rentang dinamis standar tradisional (SDR).

Dalam topik ini, Anda akan mendapatkan gambaran umum tentang konsep teknis utama di balik dukungan Windows Advanced Color. Anda akan mempelajari persyaratan dan instruksi untuk merender konten HDR, WCG, dan DirectX berkedalaman bit tinggi ke salah satu layar ini. Jika Anda memiliki aplikasi yang dikelola warna (misalnya, menggunakan profil ICC), maka Anda akan mempelajari bagaimana manajemen warna otomatis memungkinkan akurasi warna yang lebih baik untuk skenario Anda.

Pengantar Warna Tingkat Lanjut di Windows

Advanced Color adalah teknologi payung istilah sistem operasi (OS) untuk tampilan dengan keakuratan warna yang jauh lebih tinggi daripada tampilan standar. Kemampuan dominan yang diperluas dijelaskan di bagian di bawah ini. Kemampuan Warna Tingkat Lanjut pertama kali diperkenalkan untuk tampilan HDR dengan Windows 10, versi 1709 (Pembaruan Fall Creators), dan untuk tampilan SDR yang disediakan secara khusus dengan Windows 11, versi 22H2 (10.0; Rilis Build 22621).

Rentang dinamis tinggi

Rentang dinamis mengacu pada perbedaan antara luminance maksimum dan minimum dalam adegan; ini sering diukur dalam nits (kandela per sentimeter persegi). Adegan dunia nyata, seperti matahari terbenam ini, sering memiliki rentang dinamis luminans 10 urutan besarnya; mata manusia dapat membedakan rentang yang lebih besar setelah beradaptasi.

Sejak Direct3D 9, mesin grafis telah mampu merender adegan mereka secara internal dengan tingkat keakuratan fisik ini. Namun, tampilan rentang dinamis standar yang khas hanya dapat mereproduksi sedikit lebih dari 3 tingkat besaran luminansi, dan oleh karena itu konten yang dirender HDR harus ditonemap (dikompresi) ke dalam rentang terbatas dari tampilan. Tampilan HDR baru, termasuk yang mematuhi standar HDR10 (BT.2100), menembus batasan ini; misalnya, tampilan emisi mandiri berkualitas tinggi dapat mencapai lebih dari 6 urutan besar.

Gamut warna lebar

Gamut warna mengacu pada rentang dan saturasi rona yang dapat direproduksi oleh tampilan. Warna alami yang paling jenuh yang dapat dirasakan mata manusia terdiri dari cahaya murni dan monokromatik seperti yang diproduksi oleh laser. Namun, tampilan konsumen mainstream sering dapat mereproduksi warna hanya dalam gamut sRGB, yang hanya mewakili sekitar 35% dari semua warna yang dapat dirasakan manusia. Diagram di bawah ini adalah representasi dari "lokus spektral" manusia, atau semua warna yang dapat dirasakan (pada tingkat luminasi tertentu), di mana segitiga yang lebih kecil adalah gamut sRGB.

Tampilan PC profesional kelas atas telah lama mendukung gamut warna yang secara signifikan lebih lebar dari sRGB, seperti Adobe RGB dan DCI-P3 yang mencakup sekitar setengah dari warna yang dapat dirasakan manusia. Dan layar gamut lebar ini semakin umum.

Manajemen warna sistem otomatis

Manajemen warna adalah teknologi dan praktik untuk memastikan reproduksi warna yang akurat dan konsisten di seluruh perangkat. Jika Anda seorang pembuat konten digital, sangat penting untuk warna dalam konten visual Anda—seperti foto, gambar produk, atau logo—agar tampak sama di layar Anda seperti halnya di berbagai perangkat digital audiens Anda.

Windows telah menyediakan API dukungan manajemen warna sejak Windows 2000 dengan API Image Color Management (ICM) dan Windows Color System (WCS) yang lebih baru. Namun, API tersebut hanya pembantu untuk aplikasi yang ingin/diharuskan untuk melakukan manajemen warna; sementara sebagian besar aplikasi dan konten digital hanya mengasumsikan ruang warna sRGB standar industri, dan tidak pernah dikelola warna oleh OS. Itu adalah asumsi yang wajar di masa lalu, tetapi tampilan gamut lebar berkualitas tinggi menjadi jauh lebih umum.

Versi baru Windows mendukung manajemen warna sistem otomatis; yang memastikan bahwa semua warna di setiap aplikasi Windows, baik yang sadar warna maupun tidak, muncul secara akurat dan konsisten pada setiap tampilan yang didukung.

Kedalaman presisi/bit

Presisi numerik, atau kedalaman bit, mengacu pada jumlah informasi yang digunakan untuk mengidentifikasi warna secara unik. Kedalaman bit yang lebih tinggi berarti Anda dapat membedakan antara warna yang sangat mirip tanpa artefak seperti pita. Tampilan PC mainstream mendukung 8 bit per saluran warna, sementara mata manusia membutuhkan setidaknya 10-12 bit presisi untuk menghindari distorsi yang dapat dirasakan.

Sebelum Advanced Color, Desktop Window Manager (DWM) membatasi aplikasi berjendela untuk menghasilkan konten hanya pada 8 bit per saluran warna, bahkan jika tampilan mendukung kedalaman bit yang lebih tinggi. Ketika Warna Lanjutan diaktifkan, DWM melakukan komposisinya menggunakan titik mengambang setengah presisi IEEE (FP16), menghilangkan hambatan apa pun, dan memungkinkan presisi penuh tampilan untuk digunakan.

Arsitektur sistem Warna Tingkat Lanjut Windows

Info di bagian ini bersifat opsional untuk membangun aplikasi Warna Tingkat Lanjut; tetapi sangat membantu untuk memahami cara kerja teknologi untuk mengoptimalkan penyajian dan perilaku aplikasi Anda.

Di bagian ini, kita akan menggunakan diagram yang disederhanakan untuk menjelaskan komponen tumpukan grafis Windows yang relevan:

Windows yang ada: tampilan 8-bit / sRGB

Selama beberapa dekade, tampilan konsumen dan tumpukan grafis Windows didasarkan sekitar 8 bit per saluran (24 bit per piksel) konten sRGB. Aplikasi yang menggunakan API grafis seperti DirectX dapat melakukan penyajian internal menggunakan kedalaman bit tinggi dan ruang warna yang diperluas; namun, OS hanya mendukung bilangan bulat 8-bit dengan sRGB implisit dan tidak ada manajemen warna sistem:

Itu berarti bahwa data warna tambahan yang dirender oleh aplikasi akan hilang saat ditampilkan; dan bahwa aplikasi harus melakukan manajemen warna itu sendiri untuk memastikan reproduksi yang akurat pada layar.

Windows 10, versi 1703: HDR ditampilkan dengan Warna Tingkat Lanjut

Windows 10, versi 1703 memperkenalkan versi pertama kemampuan Warna Tingkat Lanjut untuk tampilan HDR. Itu membutuhkan beberapa kemajuan signifikan dalam tumpukan grafis OS:

• Dukungan sinyal tampilan HDR
• Komposisi sistem menggunakan ruang warna kanonis dengan bit-depth tinggi
• Manajemen warna sistem otomatis

Setiap kemajuan tercakup dalam sub-bagian di bawah ini. Hasil akhirnya adalah bahwa data warna aplikasi yang diperluas sekarang dipertahankan dengan benar oleh sistem operasi, dan direproduksi secara akurat pada layar HDR.

Dukungan sinyal tampilan HDR

Sinyal HDR melalui konektor tampilan seperti DisplayPort dan HDMI terutama menggunakan presisi 10-bit per saluran (atau lebih besar) dan ruang warna BT.2100 ST.2084. Kernel tampilan, driver tampilan, dan perangkat keras GPU yang mendasar semuanya perlu mendukung pendeteksian, pemilihan, dan pengoperasian mode sinyal ini.

Komposisi sistem menggunakan ruang warna kanonis dengan kedalaman bit tinggi

Ruang warna BT.2100 ST.2084 adalah standar yang efisien untuk mengodekan warna HDR, tetapi tidak cocok untuk banyak operasi penyajian dan komposisi (campuran). Kami juga ingin membuktikan OS di masa depan untuk mendukung teknologi dan ruang warna jauh di luar BT.2100, yang mencakup kurang dari 2/3 warna yang terlihat manusia. Terakhir, jika memungkinkan, kita ingin meminimalkan konsumsi sumber daya GPU untuk meningkatkan daya dan performa.

Saat dalam mode HDR, Desktop Window Manager (DWM) menggunakan ruang warna komposisi kanonis (CCCS) yang didefinisikan sebagai:

• ruang warna scRGB (BT.709/sRGB utama dengan gamma linier)
• Presisi setengah IEEE (kedalaman bit FP16)

Itu memberikan keseimbangan yang baik antara semua tujuan di atas. CCCS memungkinkan nilai warna di luar rentang numerik [0, 1]; mengingat rentang nilai FP16 yang valid, dapat mewakili hingga tingkat berlipat ganda lebih banyak warna daripada rentang visual manusia yang bersifat alami, termasuk nilai cahaya lebih dari 5 juta nits. FP16 memiliki presisi yang sangat baik untuk operasi campuran gamma linier, tetapi hanya menggunakan setengah dari konsumsi memori GPU dan bandwidth dari presisi tunggal tradisional (FP32) tanpa kehilangan kualitas yang terlihat.

Manajemen warna sistem otomatis

Windows adalah lingkungan multitugas tempat pengguna dapat menjalankan sejumlah aplikasi SDR dan HDR secara bersamaan dengan jendela yang tumpang tindih. Oleh karena itu, sangat penting bahwa semua jenis konten terlihat benar dan pada kualitas maksimum saat output ke tampilan; misalnya, aplikasi produktivitas sRGB (SDR) dengan jendela video BT.2100 ST.2084 (HDR) yang diputar di atasnya.

Saat dalam mode HDR, Windows melakukan operasi manajemen warna dalam dua tahap:

1. DWM mengonversi setiap aplikasi dari ruang warna aslinya menjadi CCCS sebelum memadukan.
2. Kernel tampilan mengonversi framebuffer OS dari CCCS ke ruang warna format kawat (BT.2100 ST.2084).
   • Secara opsional, kernel tampilan bekerja dengan driver tampilan untuk melakukan kalibrasi warna tampilan tambahan; untuk informasi selengkapnya, lihat Alur kalibrasi warna tampilan perangkat keras Windows.

Windows 11, versi 22H2: Tampilan SDR dengan Warna Tingkat Lanjut

Meskipun prevalensi tampilan HDR berkembang pesat, tampilan SDR akan tetap penting selama bertahun-tahun ke depan. Dukungan HDR di Windows 10, versi 1703 meletakkan sebagian besar dasar yang diperlukan untuk meningkatkan tampilan SDR juga. Windows 11, versi 22H2 memperluas kemampuan manajemen Warna Tingkat Lanjut dan warna otomatis ke tampilan SDR tertentu yang memenuhi syarat. Diagram blok grafis untuk tampilan SDR Warna Tingkat Lanjut terlihat sangat mirip dengan HDR:

Dukungan sinyal tampilan SDR dengan kedalaman bit tinggi

Sinyal yang mendasar untuk tampilan SDR tidak berubah, meskipun rilis Windows 11 versi 22H2 mendukung 10 bit per saluran dan lebih besar, tergantung pada kemampuan tampilan.

Komposisi sistem menggunakan ruang warna dengan kedalaman bit tinggi dan standar

Fungsionalitas DWM Advanced Color termasuk perpaduan dalam CCCS hampir sepenuhnya tidak berubah dari tampilan HDR. Perbedaan utamanya adalah DWM menggunakan luminansi berbasis tampilan dengan layar SDR, dan luminansi berbasis adegan dengan layar HDR. Ini mengubah cara konten yang dirender Warna Tingkat Lanjut Anda ditafsirkan oleh OS:

Jenis tampilan	Perilaku kecerahan	Bagaimana 1.0f ditafsirkan
SDR	Tampilan yang dirujuk	Sebagai tingkat putih acuan pada tampilan
HDR	Adegan yang dirujuk	Sebagai 80 nits (referensi nominal putih)

Manajemen warna sistem otomatis

Kemampuan manajemen warna sistem OS juga sebagian besar tidak berubah dari tampilan HDR. Perbedaan utamanya adalah bahwa kernel tampilan mengonversi ke ruang warna yang dirujuk oleh tampilan seperti yang didefinisikan oleh data colorimetry dan kalibrasi tampilan, alih-alih ruang warna standar BT.2100 ST.2084 untuk tampilan HDR.

Pengaturan tampilan diperlukan

Data yang akurat dari profil ICC MHC diperlukan untuk menentukan operasi manajemen warna output kernel tampilan. Oleh karena itu, hanya tampilan SDR yang telah disediakan secara khusus oleh produsen atau penyedia kalibrasi tampilan dengan profil yang valid yang memenuhi syarat untuk manajemen warna otomatis. Lihat Perilaku profil ICC dengan Warna Tingkat Lanjut untuk informasi lebih lanjut.

Persyaratan sistem dan dukungan sistem operasi

Windows 10, versi 1709 pertama kali mengirimkan dukungan Warna Tingkat Lanjut untuk tampilan HDR. Rilis Windows 11 versi 22H2 menambahkan dukungan Warna Tingkat Lanjut untuk tampilan SDR yang memiliki data provisi yang akurat.

Topik ini mengasumsikan bahwa aplikasi Anda menargetkan Windows 10, versi 2004 (atau yang lebih baru) untuk tampilan HDR, dan Rilis Windows 11 versi 22H2 (atau yang lebih baru) untuk tampilan SDR.

Tampilan

Tampilan rentang dinamis tinggi harus menerapkan HDR10, atau BT.2100 ST.2084, standar. Kualitas tampilan HDR dapat sangat bervariasi, dan kami sangat menyarankan tampilan yang disertifikasi, seperti VESA DisplayHDR. Dimulai dengan rilis Windows 11, versi 22H2, Windows menampilkan status sertifikasi layar yang dikenali di aplikasi Pengaturan.

Tampilan rentang dinamis standar harus memiliki data provisi warna yang akurat untuk dukungan Warna Tingkat Lanjut. Dalam rilis Windows 11 versi 22H2, satu-satunya metode yang didukung untuk mengambil alih data ini adalah melalui profil ICC MHC; selain itu, pengguna atau produsen tampilan harus mengaktifkan manajemen warna otomatis. Untuk informasi selengkapnya, lihat Perilaku profil ICC dengan Warna Tingkat Lanjut.

Prosesor grafis (GPU)

Untuk fungsionalitas Warna Tingkat Lanjut penuh pada tampilan SDR dan HDR, GPU terbaru diperlukan:

• AMD Radeon RX seri 400 (Polaris), atau yang lebih baru
• Seri NVIDIA GeForce 10 (Pascal), atau yang lebih baru
• Intel Core generasi ke-10 yang dipilih (Ice Lake), atau yang lebih baru*

Persyaratan perangkat keras tambahan mungkin berlaku, tergantung pada skenario, termasuk akselerasi codec perangkat keras (HEVC 10 bit, VP9 10 bit, dll.) dan dukungan PlayReady (SL3000). Hubungi vendor GPU Anda untuk informasi yang lebih spesifik.

Driver grafis (WDDM)

Driver grafis terbaru yang tersedia sangat disarankan, baik dari Windows Update atau dari vendor GPU atau situs web produsen PC. Topik ini bergantung pada fungsionalitas driver dari WDDM 2.7 (Windows 10, versi 2004) untuk tampilan HDR, dan WDDM 3.0 (Windows 11, versi 21H2) untuk tampilan SDR.

API penyajian yang didukung

Windows 10 mendukung berbagai API dan kerangka kerja penyajian. Dukungan warna tingkat lanjut pada dasarnya bergantung pada aplikasi Anda yang dapat melakukan presentasi modern menggunakan DXGI atau API Lapisan Visual.

• Infrastruktur Grafis DirectX (DXGI)
• Lapisan Visual (Windows.UI.Composition)

Oleh karena itu, API penyajian apa pun yang dapat menghasilkan salah satu metode presentasi tersebut dapat mendukung Warna Tingkat Lanjut. Itu termasuk (tetapi tidak terbatas pada) di bawah ini.

• Direct3D 11
• Direct3D 12
• Direct2D
• Win2D
  • Memerlukan penggunaan API CanvasSwapChain atau CanvasSwapChainPanel tingkat bawah.
• Windows.UI.Input.Inking
  • Mendukung penyajian tinta kering kustom menggunakan DirectX.
• XAML
  • Mendukung pemutaran video HDR menggunakan MediaPlayerElement.
  • Mendukung dekode gambar JPEG XR menggunakan elemen Gambar .
  • Mendukung interop DirectX menggunakan SwapChainPanel.

Menangani kemampuan tampilan dinamis

Windows 10 mendukung berbagai tampilan berkemampuan Advanced Color, dari panel terintegrasi yang hemat daya hingga monitor game kelas atas dan TV. Pengguna Windows mengharapkan bahwa aplikasi Anda akan menangani semua variasi tersebut dengan mulus, termasuk tampilan SDR yang ada di mana-mana.

Windows 10 menyediakan kontrol atas kemampuan HDR dan Warna Tingkat Lanjut kepada pengguna. Aplikasi Anda harus mendeteksi konfigurasi tampilan saat ini, dan merespons secara dinamis setiap perubahan kemampuan. Itu bisa terjadi karena banyak alasan, misalnya, karena pengguna mengaktifkan atau menonaktifkan fitur, atau memindahkan aplikasi di antara tampilan yang berbeda, atau status daya sistem berubah.

Opsi 1: AdvancedColorInfo

Pertama, dapatkan instans AdvancedColorInfo dari DisplayInformation::GetAdvancedColorInfo.

Untuk memeriksa jenis Warna Tingkat Lanjut apa yang saat ini aktif, gunakan properti AdvancedColorInfo::CurrentAdvancedColorKind. Itu adalah properti terpenting untuk diperiksa, dan Anda harus mengonfigurasi alur render dan presentasi Anda sebagai respons terhadap jenis aktif:

Jenis warna tingkat lanjut	Menampilkan kemampuan
SDR	Tampilan SDR tanpa kemampuan Warna Tingkat Lanjut
WCG	Tampilan SDR dengan kedalaman bit tinggi dan manajemen warna otomatis
HDR	Layar HDR dengan semua kemampuan Warna Tingkat Lanjut

Untuk memeriksa jenis Warna Tingkat Lanjut apa yang didukung, tetapi belum tentu aktif, panggil AdvancedColorInfo::IsAdvancedColorKindAvailable. Anda dapat menggunakan informasi tersebut, misalnya, untuk meminta pengguna menavigasi ke aplikasi Pengaturan Windows sehingga mereka dapat mengaktifkan HDR atau manajemen warna otomatis.

Anggota AdvancedColorInfo lainnya memberikan informasi kuantitatif tentang volume warna fisik panel (luminance dan chrominance), sesuai dengan metadata HDR statis SMPTE ST.2086. Meskipun ST.2086 awalnya dirancang untuk tampilan HDR, info tersebut berguna, dan tersedia untuk tampilan HDR dan SDR. Anda harus menggunakan informasi tersebut untuk mengonfigurasi pemetaan nada aplikasi dan pemetaan gamut.

Untuk menangani perubahan dalam kemampuan Advanced Color, daftar untuk event DisplayInformation::AdvancedColorInfoChanged. Peristiwa tersebut dimunculkan jika ada parameter kemampuan Warna Tingkat Lanjut tampilan berubah karena alasan apa pun.

Tangani peristiwa tersebut dengan mendapatkan instans baru AdvancedColorInfo, dan dengan memeriksa nilai mana yang telah berubah.

IDXGIOutput6

Jika Anda menulis aplikasi desktop Win32, dan menggunakan DirectX untuk merender, gunakan DXGI_OUTPUT_DESC1 untuk mendapatkan kemampuan tampilan. Dapatkan instans struktur tersebut melalui IDXGIOutput6::GetDesc1.

Untuk memeriksa jenis Warna Tingkat Lanjut yang saat ini aktif, gunakan properti ColorSpace , yang berjenis DXGI_COLOR_SPACE_TYPE, dan berisi salah satu nilai berikut:

DXGI_COLOR_SPACE_TYPE	Kemampuan tampilan
DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709	Tampilan SDR tanpa kemampuan Warna Tingkat Lanjut
DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020	Layar HDR dengan semua kemampuan Warna Tingkat Lanjut

Sebagian besar anggota lain DXGI_OUTPUT_DESC1 memberikan informasi kuantitatif tentang volume warna fisik panel (luminance dan krominasi), sesuai dengan metadata HDR statis SMPTE ST.2086. Meskipun ST.2086 awalnya dirancang untuk tampilan HDR, info tersebut berguna dan tersedia untuk tampilan HDR dan SDR. Anda harus menggunakan informasi tersebut untuk mengonfigurasi pemetaan nada aplikasi dan pemetaan gamut.

Aplikasi desktop Win32 tidak memiliki mekanisme asli untuk merespons perubahan kemampuan Warna Tingkat Lanjut. Sebagai gantinya, jika aplikasi Anda menggunakan perulangan render, maka Anda harus mengkueri IDXGIFactory1::IsCurrent dengan setiap bingkai. Jika melaporkan FALSE, maka Anda harus mendapatkan DXGI_OUTPUT_DESC1 baru, dan memeriksa nilai mana yang telah berubah.

Selain itu, pompa pesan Win32 Anda harus menangani pesan WM_SIZE , yang menunjukkan bahwa aplikasi Anda mungkin telah berpindah di antara tampilan yang berbeda.

Contoh kode berikut berasal dari aplikasi sampel Direct3D 12 HDR di GitHub.

// Retrieve the current default adapter.
ComPtr<IDXGIAdapter1> dxgiAdapter;
ThrowIfFailed(m_dxgiFactory->EnumAdapters1(0, &dxgiAdapter));

// Iterate through the DXGI outputs associated with the DXGI adapter,
// and find the output whose bounds have the greatest overlap with the
// app window (i.e. the output for which the intersection area is the
// greatest).

UINT i = 0;
ComPtr<IDXGIOutput> currentOutput;
ComPtr<IDXGIOutput> bestOutput;
float bestIntersectArea = -1;

while (dxgiAdapter->EnumOutputs(i, &currentOutput) != DXGI_ERROR_NOT_FOUND)
{
    // Get the retangle bounds of the app window
    int ax1 = m_windowBounds.left;
    int ay1 = m_windowBounds.top;
    int ax2 = m_windowBounds.right;
    int ay2 = m_windowBounds.bottom;

    // Get the rectangle bounds of current output
    DXGI_OUTPUT_DESC desc;
    ThrowIfFailed(currentOutput->GetDesc(&desc));
    RECT r = desc.DesktopCoordinates;
    int bx1 = r.left;
    int by1 = r.top;
    int bx2 = r.right;
    int by2 = r.bottom;

    // Compute the intersection
    int intersectArea = ComputeIntersectionArea(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2);
    if (intersectArea > bestIntersectArea)
    {
        bestOutput = currentOutput;
        bestIntersectArea = static_cast<float>(intersectArea);
    }

    i++;
}

// Having determined the output (display) upon which the app is primarily being 
// rendered, retrieve the HDR capabilities of that display by checking the color space.
ComPtr<IDXGIOutput6> output6;
ThrowIfFailed(bestOutput.As(&output6));

DXGI_OUTPUT_DESC1 desc1;
ThrowIfFailed(output6->GetDesc1(&desc1));

Menyiapkan rantai pertukaran DirectX Anda

Setelah Anda menentukan bahwa tampilan saat ini mendukung kemampuan Warna Tingkat Lanjut, konfigurasikan rantai pertukaran Anda sebagai berikut.

Gunakan efek model presentasi membalik

Saat membuat swap chain Anda menggunakan salah satu CreateSwapChainFor[Hwnd|Composition|CoreWindow] metode, Anda harus menggunakan model flip DXGI dengan memilih DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL atau DXGI_SWAP_EFFECT_FLIP_DISCARD opsi, yang membuat swap chain Anda memenuhi syarat untuk pemrosesan Advanced Color dari DWM dan berbagai pengoptimalan layar penuh. Untuk informasi selengkapnya, lihat Untuk performa terbaik, gunakan model flip DXGI.

Opsi 1. Gunakan format piksel FP16 dan ruang warna scRGB

Windows 10 mendukung dua kombinasi utama format piksel dan ruang warna untuk Warna Tingkat Lanjut. Pilih salah satu berdasarkan persyaratan spesifik aplikasi Anda.

Sebaiknya aplikasi tujuan umum menggunakan Opsi 1. Ini adalah satu-satunya opsi yang berfungsi untuk semua jenis tampilan Warna Tingkat Lanjut, konten, dan API penyajian. Saat membuat rantai pertukaran Anda, tentukan DXGI_FORMAT_R16G16B16A16_FLOAT di DXGI_SWAP_CHAIN_DESC1 Anda. Secara default, rantai pertukaran yang dibuat dengan format piksel floating point diperlakukan seolah-olah menggunakan ruang warna DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709 . Itu adalah format piksel dan ruang warna yang sama yang digunakan oleh DWM.

Kombinasi itu memberi Anda rentang numerik dan presisi untuk menentukan warna yang mungkin secara fisik, serta melakukan pemrosesan sembarang termasuk pencampuran.

Namun, opsi itu menggunakan 64 bit per piksel, yang menggandakan bandwidth GPU dan konsumsi memori dibandingkan dengan format piksel UINT8 tradisional. Selain itu, scRGB menggunakan nilai numerik yang berada di luar rentang [0, 1] yang dinormalisasi untuk mewakili warna yang berada di luar gamut sRGB dan/atau lebih besar dari 80 nit luminance. Misalnya, scRGB (1.0, 1.0, 1.0) mengodekan D65 putih standar pada 80 nits; tetapi scRGB (12.5, 12.5, 12.5) mengodekan D65 putih yang sama pada 1000 nit yang jauh lebih cerah. Beberapa operasi grafis memerlukan rentang numerik yang dinormalisasi, dan Anda harus mengubah operasi, atau menormalkan ulang nilai warna.

Cara nilai luminance ditafsirkan dengan opsi tersebut berbeda antara tampilan SDR dan HDR; lihat di bawah ini.

Opsi 2: Gunakan format piksel UINT10/RGB10 dan ruang warna HDR10/BT.2100

Opsi 2 adalah pengoptimalan performa yang hanya tersedia jika aplikasi Anda memenuhi semua kondisi berikut:

• Menargetkan tampilan HDR
• Menggunakan Direct3D 12 atau Direct3D 11
• Rantai pertukaran tidak memerlukan perpaduan dengan alfa/transparansi

Jika aplikasi Anda tidak memenuhi semua kondisi tersebut, Maka Anda harus menggunakan Opsi 1.

Tetapi jika aplikasi Anda memenuhi syarat untuk opsi 2, maka itu mungkin memberikan performa yang lebih baik jika aplikasi Anda menggunakan konten yang dikodekan HDR10, seperti pemutar video, atau jika terutama akan digunakan dalam skenario layar penuh, seperti permainan. Saat membuat rantai pertukaran , Anda harus mempertimbangkan untuk menentukan DXGI_FORMAT_R10G10B10A2_UNORM di DXGI_SWAP_CHAIN_DESC1. Secara default, itu diperlakukan sebagai menggunakan ruang warna sRGB; oleh karena itu, Anda harus secara eksplisit memanggil IDXGISwapChain3::SetColorSpace1, dan tetapkan ruang warna Anda sebagai DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020, yang juga dikenal sebagai HDR10/BT.2100.

Opsi ini menggunakan 32 bit per piksel yang sama dengan format piksel SDR UINT8 tradisional. Selain itu, pada GPU tertentu ini menghilangkan beberapa pemrosesan yang diperlukan untuk mengonversi konten ke format kawat HDR10.

Menggunakan rantai pertukaran Warna Tingkat Lanjut saat tampilan dalam mode SDR

Anda dapat menggunakan rantai pertukaran Warna Tingkat Lanjut meskipun tampilan tidak mendukung semua kemampuan Warna Tingkat Lanjut. Dalam kasus tersebut, Desktop Window Manager (DWM) akan menurunkan konversi konten Anda agar sesuai dengan kemampuan layar dengan melakukan pemangkasan numerik. Misalnya, jika Anda merender ke rantai penukaran FP16 scRGB dengan menargetkan tampilan standar, maka semuanya di luar rentang numerik [0, 1] akan diklip.

Perilaku downconversion tersebut juga akan terjadi jika jendela aplikasi Anda melintasi dua atau lebih tampilan dengan kemampuan Warna Tingkat Lanjut yang berbeda. AdvancedColorInfo dan IDXGIOutput6 diabstraksi untuk hanya melaporkan karakteristik tampilan utama (utama didefinisikan sebagai tampilan yang berisi bagian tengah jendela).

Cocokkan referensi aplikasi Anda dengan tingkat putih referensi OS SDR

Dalam banyak skenario, aplikasi Anda akan ingin merender konten SDR dan HDR; misalnya, merender subtitel atau kontrol transportasi melalui video HDR, atau UI ke dalam adegan game. Penting untuk memahami konsep putih referensi tingkat SDR agar konten SDR Anda tampil benar pada layar HDR. Putih acuan menunjukkan tingkat kecerahan di mana objek putih tersebar (seperti selembar kertas, atau kadang-kadang antarmuka pengguna) muncul dalam konteks adegan HDR. Karena nilai warna HDR memiliki kecerahan yang merujuk pada adegan, nilai warna tertentu harus ditampilkan pada tingkat luminance absolut, dan tidak relatif terhadap nilai panel maksimum yang mungkin. Misalnya, scRGB (1.0, 1.0, 1.0) dan HDR10 (497, 497, 497) keduanya mengode tepat putih D65 pada luminansi 80 nit. Windows memungkinkan pengguna untuk menyesuaikan tingkat putih referensi SDR sesuai dengan preferensi mereka; yang menjadi luminansi di mana Windows akan merender sRGB (1.0, 1.0, 1.0). Pada monitor HDR desktop, tingkat putih referensi SDR biasanya diatur ke sekitar 200 nit.

Aplikasi HDR Anda harus memungkinkan pengguna mengatur tingkat putih referensi yang diinginkan, atau membaca nilai yang dikonfigurasi oleh sistem. Anda harus memetakan nilai warna putih difus di adegan Anda ke tingkat putih referensi SDR. Yang memerlukan perkalian framebuffer aplikasi Anda di ruang gamma linier.

Jika aplikasi Anda selalu merender SDR dan HDR ke permukaan terpisah, dan bergantung pada komposisi OS, maka Windows akan secara otomatis melakukan penyesuaian yang benar untuk meningkatkan konten SDR ke tingkat putih yang diinginkan. Misalnya, jika aplikasi Anda menggunakan XAML, dan merender konten HDR ke SwapChainPanel sendiri.

Namun, jika aplikasi Anda melakukan komposisi konten SDR dan HDR sendiri ke dalam satu permukaan, maka Anda bertanggung jawab untuk melakukan penyesuaian tingkat putih referensi SDR sendiri. Jika tidak, konten SDR mungkin muncul terlalu redup di bawah kondisi tampilan desktop biasa. Pertama, Anda harus mendapatkan tingkat putih referensi SDR saat ini, lalu Anda harus menyesuaikan nilai warna konten SDR apa pun yang Anda render.

Langkah 1. Peroleh tingkat putih referensi SDR saat ini

Anda dapat memperoleh tingkat putih referensi SDR saat ini dengan salah satu cara berikut:

• Di aplikasi desktop. DISPLAYCONFIG_SDR_WHITE_LEVEL dan QueryDisplayConfig.
• Di aplikasi UWP. AdvancedColorInfo.SdrWhiteLevelInNits (menggunakan CoreWindow).

Langkah 2. Menyesuaikan nilai warna konten SDR

Windows mendefinisikan tingkat putih referensi nominal, atau default, pada 80 nits. Oleh karena itu, jika Anda merender sRGB standar (1.0, 1.0, 1.0) putih ke rantai pertukaran FP16, maka akan direproduksi pada luminance 80 nit. Untuk mencocokkan tingkat putih referensi yang ditentukan pengguna yang sebenarnya, Anda harus menyesuaikan konten SDR dari 80 nits ke tingkat yang ditentukan melalui AdvancedColorInfo.SdrWhiteLevelInNits.

Jika Anda merender menggunakan FP16 dan scRGB, atau ruang warna apa pun yang menggunakan gamma linier (1.0), maka Anda cukup mengalikan nilai warna SDR dengan AdvancedColorInfo.SdrWhiteLevelInNits / 80. Jika Anda menggunakan Direct2D, maka ada D2D1_SCENE_REFERRED_SDR_WHITE_LEVEL konstanta yang telah ditentukan sebelumnya, yang memiliki nilai 80.

D2D1_VECTOR_4F inputColor; // Input SDR color value.
D2D1_VECTOR_4F outputColor; // Output color adjusted for SDR white level.
auto acInfo = ...; // Obtain an AdvancedColorInfo.

float sdrAdjust = acInfo->SdrWhiteLevelInNits / D2D1_SCENE_REFERRED_SDR_WHITE_LEVEL;

// Normally in DirectX, color values are manipulated in shaders on GPU textures.
// This example performs scaling on a CPU color value.
outputColor.r = inputColor.r * sdrAdjust; // Assumes linear gamma color values.
outputColor.g = inputColor.g * sdrAdjust;
outputColor.b = inputColor.b * sdrAdjust;
outputColor.a = inputColor.a;

Jika Anda merender menggunakan ruang warna gamma nonlinear seperti HDR10, maka melakukan penyesuaian tingkat putih SDR lebih kompleks. Jika Anda menulis shader piksel Anda sendiri, pertimbangkan untuk mengonversi menjadi gamma linier untuk menerapkan penyesuaian.

Mengadaptasi konten HDR ke kemampuan tampilan menggunakan pemetaan nada

Tampilan HDR dan Warna Tingkat Lanjut sangat bervariasi dalam hal kemampuannya. Misalnya, dalam hal luminansi minimum dan maksimum, serta gamut warna yang dapat mereka reproduksi. Dalam banyak kasus, konten HDR Anda akan berisi warna yang melebihi kemampuan tampilan. Untuk kualitas gambar terbaik, penting bagi Anda untuk melakukan pemetaan nada HDR, pada dasarnya mengompresi rentang warna agar sesuai dengan tampilan sambil menjaga niat visual konten dengan sebaik-baiknya.

Parameter tunggal yang paling penting untuk disesuaikan adalah luminansi maksimal, juga dikenal sebagai MaxCLL (tingkat cahaya konten); pemeta nada yang lebih canggih juga akan menyesuaikan luminansi minimal (MinCLL) dan/atau warna primer.

Langkah 1. Memperoleh informasi tentang kemampuan volume warna tampilan

aplikasi Platform Windows Universal (UWP)

Gunakan AdvancedColorInfo untuk mendapatkan volume warna tampilan.

Aplikasi DirectX Win32 (desktop)

Gunakan DXGI_OUTPUT_DESC1 untuk mendapatkan volume warna tampilan.

Langkah 2. Mendapatkan informasi volume warna konten

Tergantung dari mana konten HDR Anda berasal, ada beberapa cara potensial untuk menentukan luminasi dan informasi gamut warnanya. File video dan gambar HDR tertentu berisi metadata SMPTE ST.2086. Jika konten Anda dirender secara dinamis, maka Anda mungkin dapat mengekstrak informasi adegan dari tahap penyajian internal—misalnya, sumber cahaya paling terang dalam adegan.

Solusi yang lebih umum secara keseluruhan tetapi menghabiskan sumber daya komputasi adalah menjalankan histogram atau analisis lain pada bingkai yang sudah dirender. Aplikasi sampel penyajian gambar warna tingkat lanjut Direct2D di GitHub menunjukkan cara melakukannya menggunakan Direct2D; cuplikan kode yang paling relevan disertakan di bawah ini:

// Perform histogram pipeline setup; this should occur as part of image resource creation.
// Histogram results in no visual output but is used to calculate HDR metadata for the image.
void D2DAdvancedColorImagesRenderer::CreateHistogramResources()
{
    auto context = m_deviceResources->GetD2DDeviceContext();

    // We need to preprocess the image data before running the histogram.
    // 1. Spatial downscale to reduce the amount of processing needed.
    DX::ThrowIfFailed(
        context->CreateEffect(CLSID_D2D1Scale, &m_histogramPrescale)
        );

    DX::ThrowIfFailed(
        m_histogramPrescale->SetValue(D2D1_SCALE_PROP_SCALE, D2D1::Vector2F(0.5f, 0.5f))
        );

    // The right place to compute HDR metadata is after color management to the
    // image's native colorspace but before any tonemapping or adjustments for the display.
    m_histogramPrescale->SetInputEffect(0, m_colorManagementEffect.Get());

    // 2. Convert scRGB data into luminance (nits).
    // 3. Normalize color values. Histogram operates on [0-1] numeric range,
    //    while FP16 can go up to 65504 (5+ million nits).
    // Both steps are performed in the same color matrix.
    ComPtr<ID2D1Effect> histogramMatrix;
    DX::ThrowIfFailed(
        context->CreateEffect(CLSID_D2D1ColorMatrix, &histogramMatrix)
        );

    histogramMatrix->SetInputEffect(0, m_histogramPrescale.Get());

    float scale = sc_histMaxNits / sc_nominalRefWhite;

    D2D1_MATRIX_5X4_F rgbtoYnorm = D2D1::Matrix5x4F(
        0.2126f / scale, 0, 0, 0,
        0.7152f / scale, 0, 0, 0,
        0.0722f / scale, 0, 0, 0,
        0              , 0, 0, 1,
        0              , 0, 0, 0);
    // 1st column: [R] output, contains normalized Y (CIEXYZ).
    // 2nd column: [G] output, unused.
    // 3rd column: [B] output, unused.
    // 4th column: [A] output, alpha passthrough.
    // We explicitly calculate Y; this deviates from the CEA 861.3 definition of MaxCLL
    // which approximates luminance with max(R, G, B).

    DX::ThrowIfFailed(histogramMatrix->SetValue(D2D1_COLORMATRIX_PROP_COLOR_MATRIX, rgbtoYnorm));

    // 4. Apply a gamma to allocate more histogram bins to lower luminance levels.
    ComPtr<ID2D1Effect> histogramGamma;
    DX::ThrowIfFailed(
        context->CreateEffect(CLSID_D2D1GammaTransfer, &histogramGamma)
        );

    histogramGamma->SetInputEffect(0, histogramMatrix.Get());

    // Gamma function offers an acceptable tradeoff between simplicity and efficient bin allocation.
    // A more sophisticated pipeline would use a more perceptually linear function than gamma.
    DX::ThrowIfFailed(histogramGamma->SetValue(D2D1_GAMMATRANSFER_PROP_RED_EXPONENT, sc_histGamma));
    // All other channels are passthrough.
    DX::ThrowIfFailed(histogramGamma->SetValue(D2D1_GAMMATRANSFER_PROP_GREEN_DISABLE, TRUE));
    DX::ThrowIfFailed(histogramGamma->SetValue(D2D1_GAMMATRANSFER_PROP_BLUE_DISABLE, TRUE));
    DX::ThrowIfFailed(histogramGamma->SetValue(D2D1_GAMMATRANSFER_PROP_ALPHA_DISABLE, TRUE));

    // 5. Finally, the histogram itself.
    HRESULT hr = context->CreateEffect(CLSID_D2D1Histogram, &m_histogramEffect);
    
    if (hr == D2DERR_INSUFFICIENT_DEVICE_CAPABILITIES)
    {
        // The GPU doesn't support compute shaders and we can't run histogram on it.
        m_isComputeSupported = false;
    }
    else
    {
        DX::ThrowIfFailed(hr);
        m_isComputeSupported = true;

        DX::ThrowIfFailed(m_histogramEffect->SetValue(D2D1_HISTOGRAM_PROP_NUM_BINS, sc_histNumBins));

        m_histogramEffect->SetInputEffect(0, histogramGamma.Get());
    }
}

// Uses a histogram to compute a modified version of MaxCLL (ST.2086 max content light level).
// Performs Begin/EndDraw on the D2D context.
void D2DAdvancedColorImagesRenderer::ComputeHdrMetadata()
{
    // Initialize with a sentinel value.
    m_maxCLL = -1.0f;

    // MaxCLL is not meaningful for SDR or WCG images.
    if ((!m_isComputeSupported) ||
        (m_imageInfo.imageKind != AdvancedColorKind::HighDynamicRange))
    {
        return;
    }

    // MaxCLL is nominally calculated for the single brightest pixel in a frame.
    // But we take a slightly more conservative definition that takes the 99.99th percentile
    // to account for extreme outliers in the image.
    float maxCLLPercent = 0.9999f;

    auto ctx = m_deviceResources->GetD2DDeviceContext();

    ctx->BeginDraw();

    ctx->DrawImage(m_histogramEffect.Get());

    // We ignore D2DERR_RECREATE_TARGET here. This error indicates that the device
    // is lost. It will be handled during the next call to Present.
    HRESULT hr = ctx->EndDraw();
    if (hr != D2DERR_RECREATE_TARGET)
    {
        DX::ThrowIfFailed(hr);
    }

    float *histogramData = new float[sc_histNumBins];
    DX::ThrowIfFailed(
        m_histogramEffect->GetValue(D2D1_HISTOGRAM_PROP_HISTOGRAM_OUTPUT,
            reinterpret_cast<BYTE*>(histogramData),
            sc_histNumBins * sizeof(float)
            )
        );

    unsigned int maxCLLbin = 0;
    float runningSum = 0.0f; // Cumulative sum of values in histogram is 1.0.
    for (int i = sc_histNumBins - 1; i >= 0; i--)
    {
        runningSum += histogramData[i];
        maxCLLbin = i;

        if (runningSum >= 1.0f - maxCLLPercent)
        {
            break;
        }
    }

    float binNorm = static_cast<float>(maxCLLbin) / static_cast<float>(sc_histNumBins);
    m_maxCLL = powf(binNorm, 1 / sc_histGamma) * sc_histMaxNits;

    // Some drivers have a bug where histogram will always return 0. Treat this as unknown.
    m_maxCLL = (m_maxCLL == 0.0f) ? -1.0f : m_maxCLL;
}

Langkah 3. Lakukan operasi tonemapping HDR

Tonemapping pada dasarnya merupakan proses yang mengurangi kualitas, dan dapat dioptimalkan untuk sejumlah metrik persepsi atau objektif, sehingga tidak ada satu algoritma standar yang berlaku. Windows menyediakan efek tonemapper HDR bawaan sebagai bagian dari Direct2D serta dalam alur pemutaran video HDR Media Foundation. Beberapa algoritma lain yang umum digunakan termasuk ACES Filmic, Reinhard, dan ITU-R BT.2390-3 EETF (fungsi transfer listrik-listrik).

Operator reinhard tonemapper yang disederhanakan ditampilkan dalam contoh kode berikutnya ini.

// This example uses C++. A typical DirectX implementation would port this to HLSL.
D2D1_VECTOR_4F simpleReinhardTonemapper(
    float inputMax, // Content's maximum luminance in scRGB values, e.g. 1.0 = 80 nits.
    float outputMax, // Display's maximum luminance in scRGB values, e.g. 1.0 = 80 nits.
    D2D1_VECTOR_4F input // scRGB color.
)
{
    D2D1_VECTOR_4F output = input;

    // Vanilla Reinhard normalizes color values to [0, 1].
    // This modification scales to the luminance range of the display.
    output.r /= inputMax;
    output.g /= inputMax;
    output.b /= inputMax;

    output.r = output.r / (1 + output.r);
    output.g = output.g / (1 + output.g);
    output.b = output.b / (1 + output.b);

    output.r *= outputMax;
    output.g *= outputMax;
    output.b *= outputMax;

    return output;
}

Menangkap konten layar HDR dan WCG

API yang mendukung penentuan format piksel, seperti yang ada di namespace Windows.Graphics.Capture, dan metode IDXGIOutput5::DuplicateOutput1, menyediakan kemampuan untuk mengambil konten HDR dan WCG tanpa kehilangan informasi piksel. Perhatikan bahwa setelah memperoleh bingkai konten, diperlukan pemrosesan tambahan. Misalnya, pemetaan nada HDR-ke-SDR (misalnya, salinan cuplikan layar SDR untuk berbagi internet) dan penyimpanan konten dengan format yang tepat (misalnya, JPEG XR).

Perubahan pada manajemen warna warisan dan perilaku profil ICC

Manajemen warna dan warna otomatis tingkat lanjut memastikan warna tampilan yang konsisten dan akurat secara warna untuk semua aplikasi, warisan, dan modern. Namun, beberapa aplikasi dapat melakukan manajemen warna eksplisit mereka sendiri menggunakan profil warna International Color Consortium (ICC).

Ketika Warna Lanjutan diaktifkan pada tampilan SDR atau HDR, perilaku profil ICC tampilan berubah dengan cara yang tidak kompatibel secara mundur. Jika aplikasi Anda menggunakan profil ICC tampilan, Windows menawarkan alat bantu kompatibilitas untuk memastikan aplikasi Anda terus mendapatkan kinerja yang benar.

Info selengkapnya tentang perubahan perilaku profil ICC dan bagaimana Anda dapat menyesuaikan aplikasi untuk memaksimalkan kompatibilitas dengan Warna Lanjutan, lihat perilaku profil ICC dengan Warna Tingkat Lanjut.

Sumber Daya Tambahan:

• Di GitHub, Menggunakan HDR Rendering dengan DirectX Tool Kit untuk DirectX 11 / DirectX 12. Panduan cara menambahkan dukungan HDR ke aplikasi DirectX menggunakan DirectX Tool Kit (DirectXTK).
• Aplikasi contoh perenderan gambar warna canggih Direct2D. Aplikasi sampel UWP SDK yang mengimplementasikan penampil gambar HDR dan WCG sadar Warna Tingkat Lanjut menggunakan Direct2D. Menunjukkan berbagai praktik terbaik untuk aplikasi UWP, termasuk merespons perubahan kemampuan tampilan dan menyesuaikan tingkat putih SDR.
• Aplikasi sampel desktop HDR Direct3D 12. Sampel SDK desktop yang mengimplementasikan adegan HDR Direct3D 12 dasar.
• Aplikasi sampel UWP HDR Direct3D 12. UWP setara dengan sampel di atas.
• SimpleHDR_PC. Aplikasi sampel PC Xbox ATG SimpleHDR (aplikasi sampel desktop) yang mengimplementasikan adegan HDR Direct3D 11 dasar.