वाइड कलर कॉन्टेंट की मदद से ग्राफ़िक को बेहतर बनाएं

Android 8.0 (एपीआई लेवल 26) के साथ, रंग को मैनेज करने की सुविधा जोड़ी गई color स्पेस इसके अलावा साथ काम करने वाले डिसप्ले वाले डिवाइसों पर ग्राफ़िक रेंडर करने के लिए, स्टैंडर्ड आरजीबी (sRGB). इस सहायता की मदद से, आपका ऐप्लिकेशन PNG, JPEG, और WebP फ़ाइलों से लोड की गई, एम्बेड की गई वाइड कलर प्रोफ़ाइलों का इस्तेमाल करके बिटमैप रेंडर कर सकता है Java या नेटिव कोड के ज़रिए कॉपी करें. OpenGL या Vulkan का इस्तेमाल करने वाले ऐप्लिकेशन में, कई रंगों में उपलब्ध कॉन्टेंट सीधे तौर पर जनरेट किया जा सकता है (Display P3 और scRGB के तौर पर डालें. यह क्षमता यह ऐसे ऐप्लिकेशन बनाने के लिए फ़ायदेमंद है जिनमें इमेज और वीडियो जैसे हाई फ़िडेलिटी वाले रंग इस्तेमाल करने की ज़रूरत हो ऐप्लिकेशन में बदलाव करने में मदद मिलती है.

वाइड कलर गैमट मोड को समझना

चौड़ी रंग प्रोफ़ाइल हैं आईसीसी प्रोफ़ाइल, जैसे Adobe आरजीबी, Pro Photo RGB, और DCI-P3, जो कि sRGB से ज़्यादा रंगों की रेंज दिखा सकता है. वाइड रंगों वाली प्रोफ़ाइलों का इस्तेमाल करने वाली स्क्रीन ज़्यादा गहरे रंग (लाल, हरे, और नीले) के साथ-साथ ज़्यादा बेहतर सेकंडरी रंगों में इमेज दिखा सकता है रंग (जैसे कि मैजेंटा, सायन, और येलो).

Android 8.0 (एपीआई लेवल 26) या इसके बाद के वर्शन वाले Android डिवाइसों पर, आपका ऐप्लिकेशन ये काम कर सकता है: किसी गतिविधि के लिए वाइड कलर गामट कलर मोड चालू करें. इससे सिस्टम, एम्बेड की गई वाइड कलर प्रोफ़ाइल वाली बिटमैप इमेज को सही तरीके से प्रोसेस करें. कॉन्टेंट बनाने ColorSpace.Named क्लास, आम तौर पर इस्तेमाल किए जाने वाले डेटा की आंशिक सूची को शामिल करती है कलर स्पेस, जो Android पर काम करते हैं.

ध्यान दें: वाइड कलर गैमट मोड चालू होने पर, विंडो स्क्रीन कंपोज़िशन के लिए ज़्यादा मेमोरी और जीपीयू प्रोसेसिंग का इस्तेमाल करती है. वाइड कलर गैमट को चालू करने से पहले मोड का इस्तेमाल करना चाहिए, तो आपको यह सोचना चाहिए कि क्या वह गतिविधि वाकई में फ़ायदेमंद साबित हो रही है. उदाहरण के लिए, ऐसी गतिविधि जिससे फ़ुलस्क्रीन में फ़ोटो दिखाई जा रही हैं, ऐसे में वाइड कलर गैमट मोड का इस्तेमाल करना सही रहता है, लेकिन अगर किसी गतिविधि में छोटे थंबनेल दिखाए गए हैं, तो यह ज़रूरी नहीं है.

वाइड कलर गैमट मोड चालू करें

गतिविधि को दिखाने का अनुरोध करने के लिए, colorMode एट्रिब्यूट का इस्तेमाल करें . वाइड कलर गैमट मोड में, विंडो रेंडर हो सकती है का इस्तेमाल करें. अगर डिवाइस पर वाइड कलर सुविधा काम नहीं करती है गैमट रेंडरिंग, इस एट्रिब्यूट का कोई असर नहीं पड़ता. अगर आपके ऐप्लिकेशन को यह तय करना है कि डिसप्ले में ज़्यादा रंगों का इस्तेमाल किया जा सकता है. isWideColorGamut() तरीका. आपके पास कॉल करने का विकल्प भी है isScreenWideColorGamut(), जिससे true का नतीजा मिलता है सिर्फ़ तब, जब डिसप्ले में वाइड कलर गैमट उपलब्ध हो और डिवाइस पर वाइड कलर गैमट काम करता हो कलर रेंडरिंग.

डिसप्ले में अलग-अलग रंगों का इस्तेमाल किया जा सकता है, लेकिन रंगों को मैनेज नहीं किया जा सकता. ऐसे मामले में, सिस्टम, किसी ऐप्लिकेशन को वाइड कलर गैमट मोड इस्तेमाल करने की अनुमति नहीं देगा. जब किसी डिसप्ले को रंग से मैनेज नहीं किया जाता —जैसा कि Android के 8.0 से पहले के सभी वर्शन में होता था—यह सिस्टम, ऐप्लिकेशन की मदद से, डिसप्ले के गैमट में दिखाए गए रंग.

अपनी गतिविधि में कई रंगों का इस्तेमाल करने की सुविधा चालू करने के लिए, colorMode को सेट करें अपनी AndroidManifest.xml फ़ाइल में, wideColorGamut एट्रिब्यूट की वैल्यू सबमिट करें. आपने लोगों तक पहुंचाया मुफ़्त में ऐसा हर उस गतिविधि के लिए करना होगा जिसके लिए आपको वाइड कलर मोड चालू करना है.

android:colorMode="wideColorGamut"

आप setColorMode(int) मेथड और पासिंग इन COLOR_MODE_WIDE_COLOR_GAMUT.

अलग-अलग रंगों में उपलब्ध कॉन्टेंट रेंडर करें

वाइड कलर गामट कॉन्टेंट रेंडर करने के लिए, आपके ऐप्लिकेशन को वाइड कलर बिटमैप लोड करना होगा. ऐसी कलर प्रोफ़ाइल जिसमें sRGB से ज़्यादा बड़ा कलर स्पेस हो. सामान्य वाइड कलर प्रोफ़ाइलों में ये शामिल हैं Adobe RGB, DCI-P3, और Display P3.

आपका ऐप्लिकेशन, कॉल करके बिटमैप के कलर स्पेस के बारे में क्वेरी कर सकता है getColorSpace(). यह पता लगाने के लिए कि सिस्टम करने के लिए एक विशिष्ट रंग स्थान है, तो आप isWideGamut() तरीका.

Color क्लास की मदद से, रंग को चार कॉम्पोनेंट के साथ दिखाया जा सकता है को पूर्णांक का इस्तेमाल करने वाले सबसे आम प्रतिनिधित्व के बजाय, 64-बिट लंबी वैल्यू में पैक किया जाता है वैल्यू. लंबे मानों का इस्तेमाल करके, आप रंग ज़्यादा सटीक होता है. अगर आपको लंबी वैल्यू के तौर पर कोई कलर बनाना या उसे कोड में बदलना है, तो Color क्लास में pack() तरीकों में से एक.

यह जांच करके कि आपके ऐप्लिकेशन ने वाइड कलर गैमट मोड का अनुरोध सही तरीके से किया है या नहीं, इसकी जांच की जा सकती है getColorMode() तरीका रिटर्न करता है COLOR_MODE_WIDE_COLOR_GAMUT (इस तरीके में, हालांकि, क्या वाकई वाइड कलर गैमट मोड लागू किया गया है).

नेटिव कोड में वाइड कलर गैमट सहायता का इस्तेमाल करें

इस सेक्शन में, वाइड कलर गैमट मोड को चालू करने का तरीका बताया गया है OpenGL और अगर आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल करता है, तो Vulkan एपीआई.

OpenGL

OpenGL में वाइड कलर गैमट मोड का इस्तेमाल करने के लिए, आपके ऐप्लिकेशन में EGL 1.4 लाइब्रेरी शामिल होनी चाहिए इनमें से कोई एक एक्सटेंशन:

• EGL_EXT_gl_colorspace_display_p3
• EGL_EXT_gl_colorspace_scrgb
• EGL_EXT_gl_colorspace_scrgb_linear

सुविधा चालू करने के लिए, पहले आपको इसके ज़रिए जीएल कॉन्टेक्स्ट बनाना होगा eglChooseConfig, तीनों में से किसी एक के साथ एट्रिब्यूट में चौड़े रंग के लिए कलर बफ़र फ़ॉर्मैट. वाइड के लिए कलर बफ़र फ़ॉर्मैट रंग, RGBA वैल्यू के इनमें से एक सेट का होना चाहिए:

• 8, 8, 8, 8
• 10, 10, 10, 2 से
• FP16, FP16, FP16, FP16

इसके बाद, अपना साइज़ बनाते समय P3 कलर स्पेस एक्सटेंशन का अनुरोध करें टारगेट रेंडर करें, जैसा कि नीचे दिए गए कोड स्निपेट में दिखाया गया है:

std::vector<EGLint> attributes;
attributes.push_back(EGL_GL_COLORSPACE_KHR);
attributes.push_back(EGL_GL_COLORSPACE_DISPLAY_P3_EXT);
attributes.push_back(EGL_NONE);
engine->surface_ = eglCreateWindowSurface(
    engine->display_, config, engine->app->window, attributes.data());

वल्कन

वाइड कलर गैमट के लिए Vulkan की सुविधा यहां दी गई है: VK_EXT_swapchain_colorspace एक्सटेंशन.

अपने Vulkan कोड में बड़े पैमाने पर कलर इस्तेमाल करने की सुविधा चालू करने से पहले, देख लें कि एक्सटेंशन इनके माध्यम से समर्थित है vkEnumerateInstanceExtensionProperties. अगर एक्सटेंशन उपलब्ध है, तो आपको इसे ऐसी कोई भी स्वैपचेन इमेज बनाने से पहले vkCreateInstance तो एक्सटेंशन से तय किए गए अतिरिक्त कलर स्पेस का इस्तेमाल करें.

स्वैपचेन बनाने से पहले, आपको अपनी पसंद का कलर स्पेस चुनना होगा. इसके बाद, और उसके लिए एक मान्य कलर फ़ॉर्मैट चुनें. कलर स्पेस.

Android डिवाइसों पर, Vulkan में इन कलर स्पेस के साथ वाइड कलर गैमट काम करता है और VkSurfaceFormatKHR रंग फ़ॉर्मैट:

• Vulkan वाइड कलर गैमट कलर स्पेस:
  • VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT
  • VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT
• वाइड कलर गैमट के साथ काम करने वाले Vulkan कलर फ़ॉर्मैट:
  • VK_FORMAT_R16G16B16A16_SFLOAT
  • VK_FORMAT_A2R10G10B10_UNORM_PACK32
  • VK_FORMAT_R8G8B8A8_UNORM

नीचे दिए गए कोड स्निपेट में, यह पता करने का तरीका बताया गया है कि डिवाइस, Display P3 के साथ काम करता है या नहीं कलर स्पेस:

uint32_t formatCount = 0;
vkGetPhysicalDeviceSurfaceFormatsKHR(
       vkPhysicalDev,
       vkSurface,
       &formatCount,
       nullptr);
VkSurfaceFormatKHR *formats = new VkSurfaceFormatKHR[formatCount];
vkGetPhysicalDeviceSurfaceFormatsKHR(
       vkPhysicalDev,
       vkSurface,
       &formatCount,
       formats);

uint32_t displayP3Index = formatCount;
for (uint32_t idx = 0; idx < formatCount; idx++) {
 if (formats[idx].format == requiredSwapChainFmt &&
     formats[idx].colorSpace==VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT)
 {
   displayP3Index = idx;
   break;
 }
}
if (displayP3Index == formatCount) {
    // Display P3 is not supported on the platform
    // choose other format
}

नीचे दिया गया कोड स्निपेट यह बताता है कि Vulkan swapchain के लिए, किस तरह अनुरोध किया जा सकता है. VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT:

uint32_t queueFamily = 0;
VkSwapchainCreateInfoKHR swapchainCreate {
   .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
   .pNext = nullptr,
   .surface = AndroidVkSurface_,
   .minImageCount = surfaceCapabilities.minImageCount,
   .imageFormat = requiredSwapChainFmt,
   .imageColorSpace = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT,
   .imageExtent = surfaceCapabilities.currentExtent,
   .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
   .preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,
   .imageArrayLayers = 1,
   .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE,
   .queueFamilyIndexCount = 1,
   .pQueueFamilyIndices = &queueFamily,
   .presentMode = VK_PRESENT_MODE_FIFO_KHR,
   .oldSwapchain = VK_NULL_HANDLE,
   .clipped = VK_FALSE,
};
VkRresult status = vkCreateSwapchainKHR(
                       vkDevice,
                       &swapchainCreate,
                       nullptr,
                       &vkSwapchain);
if (status != VK_SUCCESS) {
    // Display P3 is not supported
    return false;
}