इस पेज का अनुवाद Cloud Translation API से किया गया है.

एंड्रॉइड में नए पिक्सेल प्रारूप जोड़ें

एंड्रॉइड में जोड़े गए सभी नए पिक्सेल प्रारूप एंड्रॉइड इंटरफेस डेफिनिशन लैंग्वेज (एआईडीएल) और एंड्रॉइड हार्डवेयर बफर (एएचबी) में शामिल होने चाहिए। एआईडीएल और एएचबी में सख्त स्थिरता और मानकीकरण आवश्यकताएं हैं जिनके लिए कार्यक्षमता का विस्तार करते समय सावधानीपूर्वक प्रक्रिया की आवश्यकता होती है। सभी नए पिक्सेल प्रारूप AOSP में आने चाहिए और सभी अपडेट की व्यक्तिगत रूप से AIDL और AHB विशेषज्ञों द्वारा पुष्टि की जानी चाहिए। प्लेटफ़ॉर्म पर किसी भी नए पिक्सेल प्रारूप को मानकीकृत करने में सावधानीपूर्वक पुष्टि की यह प्रक्रिया एक महत्वपूर्ण कारक है।

यह पृष्ठ आवश्यक AOSP कोड परिवर्तनों और AOSP पर नए पिक्सेल प्रारूप जोड़ने के लिए आवश्यक प्रक्रिया की रूपरेखा देता है।

नया पिक्सेल प्रारूप जोड़ने से पहले, स्रोत डाउनलोड करें और सबमिटिंग पैच में बताए अनुसार पैच अपलोड करें।

एआईडीएल में एक नया पिक्सेल प्रारूप जोड़ें

नए पिक्सेल प्रारूप के लिए समर्थन जोड़ने के लिए AIDL के भीतर स्थित दोनों PixelFormat.aidl फ़ाइलों में परिवर्तन की आवश्यकता होती है। एआईडीएल स्रोत कोड के लिए hardware/interfaces/graphics/common/aidl/ देखें।

एआईडीएल में एक नया पिक्सेल फॉर्मल जोड़ने के लिए, इन चरणों का पालन करें:

मौजूदा कोड कन्वेंशन का पालन करके और अपनी प्रविष्टि के लिए हेक्स मान को पिछली प्रविष्टि से एक अधिक सेट करके PixelFormat.aidl में PixelFormat एनम के अंत में एक नई प्रविष्टि के रूप में नया पिक्सेल प्रारूप जोड़ें। अपने कोड परिवर्तनों का पिछली प्रविष्टियों से मिलान करें। RGBA_8888 पिक्सेल प्रारूप प्रविष्टि के लिए निम्नलिखित उदाहरण देखें:
```
/**
 * 32-bit format that has 8-bit R, G, B, and A components, in that order,
 * from the lowest memory address to the highest memory address.
 *
 * The component values are unsigned normalized to the range [0, 1], whose
 * interpretation is defined by the dataspace.
 */
RGBA_8888 = 0x1,
```
जब आप PixelFormat.aidl में परिवर्तन करने के बाद कोड बनाते हैं तो निम्न त्रुटि संदेश दिखाई देता है:
```
android_developer:~/android/aosp-main: m
...
###############################################################################
# ERROR: AIDL API change detected                                             #
###############################################################################
Above AIDL file(s) has changed. Run `m android.hardware.graphics.common-update-api` to reflect the changes
to the current version so that it is reviewed by
android-aidl-api-council@google.com
And then you need to change dependency on android.hardware.graphics.common-V(n)-* to android.hardware.graphics.common-V(n+1)-* to use
new APIs.
```
इस त्रुटि को साफ़ करने के लिए, aidl_api निर्देशिका में PixelFormat.aidl बदलने के लिए, त्रुटि संदेश में निर्दिष्ट अनुसार निम्न आदेश चलाएँ:
```
m android.hardware.graphics.common-update-api
```
उपरोक्त कमांड को चलाने से सामान्य रूप से निर्माण करने में सक्षम होने के लिए सही फ़ाइल अपडेट हो जाती है।
नोट: इस फ़ाइल को मैन्युअल रूप से संपादित करने का प्रयास न करें।

एएचबी में एक नया पिक्सेल प्रारूप जोड़ें

नए पिक्सेल प्रारूप के लिए समर्थन जोड़ने के लिए hardware_buffer.h और AHardwareBuffer.cpp में परिवर्तन की आवश्यकता होती है। एएचबी स्रोत कोड के लिए frameworks/native/libs/nativewindow देखें।

एएचबी में एक नया पिक्सेल फॉर्मल जोड़ने के लिए, इन चरणों का पालन करें:

hardware_buffer.h में, नए पिक्सेल प्रारूप को AHardwareBuffer_Format एनम के अंत में एक नई प्रविष्टि के रूप में जोड़ें। मौजूदा कोड परंपराओं का पालन करें.
RGBA_8888 पिक्सेल प्रारूप उदाहरण का उपयोग करके, नई पिक्सेल प्रारूप प्रविष्टि निम्नानुसार जोड़ें:
```
/**
 * Corresponding formats:
 *   Vulkan: VK_FORMAT_R8G8B8A8_UNORM
 *   OpenGL ES: GL_RGBA8
 */
AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM = 1,
```
ध्यान दें कि नए पिक्सेल प्रारूप को AHB में एक नाम दिया गया है, जो AHARDWAREBUFFER_FORMAT_ से शुरू होना चाहिए, इसके बाद चैनल संक्षिप्ताक्षर और बिट गहराई, और एन्कोडिंग के साथ समाप्त होना चाहिए। इस एनम प्रविष्टि का हेक्स मान PixelFormat.aidl के समान होना चाहिए।
पिक्सेल प्रारूप में संबंधित वल्कन या ओपनजीएल ईएस प्रारूप में से एक या दोनों होने की उम्मीद है। जहां उपयुक्त हो, संबंधित प्रारूप निर्दिष्ट करें। यदि कोई संबद्ध प्रारूप मौजूद नहीं है, तो N/A निर्दिष्ट करें।
सीटीएस के तहत वैकल्पिक परीक्षण में पिक्सेल प्रारूप जोड़ें, यदि इसमें संबद्ध ओपनजीएल ईएस प्रारूप है। ऐसा करने के लिए, नए प्रारूप के लिए FORMAT_CASE(...) और GL_FORMAT_CASE(...) के साथ AHBFormatAsString(int32_t format) में AHardwareBufferGLTest.cpp में नया GL प्रारूप जोड़ें, जो इस प्रकार दिखाया गया है:
```
const char* AHBFormatAsString(int32_t format) {
  switch (format) {
      ...
      FORMAT_CASE(R8G8B8A8_UNORM);
      ...
      GL_FORMAT_CASE(GL_RGB8);
  }
  return "";
}
```

इसके बाद, AHardwareBufferGLTest.cpp में एक नया परीक्षण जोड़ें, जो इस प्रकार दिखाया गया है:

class RGBA8Test : public AHardwareBufferGLTest {};

// Verify that if we can allocate an RGBA8 AHB we can render to it.
TEST_P(RGBA8Test, Write) {
    AHardwareBuffer_Desc desc = GetParam();
    desc.usage = AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER;
    if (!SetUpBuffer(desc)) {
        return;
    }

    ASSERT_NO_FATAL_FAILURE(SetUpFramebuffer(desc.width, desc.height, 0, kBufferAsRenderbuffer));
    ASSERT_NO_FATAL_FAILURE(
        SetUpProgram(kVertexShader, kColorFragmentShader, kPyramidPositions, 0.5f));

    glDrawArrays(GL_TRIANGLES, 0, kPyramidVertexCount);
    ASSERT_EQ(GLenum{GL_NO_ERROR}, glGetError());
}

INSTANTIATE_TEST_CASE_P(
    SingleLayer, RGBA8Test,
    ::testing::Values(
        AHardwareBuffer_Desc{57, 33, 1, AHARDWAREBUFFER_FORMAT_R16G16_UINT, 0, 0, 0, 0}),
    &GetTestName);

AHardwareBuffer_Desc मानों का कम से कम एक सेट निर्दिष्ट करें। यदि आवश्यक हो तो और मान जोड़ें.

AHardwareBuffer.cpp में, भीतर पाए गए स्थिर अभिकथनों का अंत ढूंढें:
```
// ----------------------------------------------------------------------------
// Validate hardware_buffer.h and PixelFormat.aidl agree
// ----------------------------------------------------------------------------
```
नए पिक्सेल प्रारूप के लिए एक नया static_assert जोड़ें, PixelFormat:: enum का उपयोग करें न कि HAL_PIXEL_FORMAT स्थिरांक के साथ। AIDL में एक नया पिक्सेल प्रारूप जोड़ें से RGBA_8888 पिक्सेल प्रारूप के लिए उसी उदाहरण का उपयोग करते हुए, नए पिक्सेल प्रारूप प्रविष्टि को निम्नानुसार जोड़ें:
```
static_assert(static_cast(aidl::android::hardware::graphics::common::PixelFormat::RGBA_8888) ==
  AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM,
"HAL and AHardwareBuffer pixel format don't match");
```
AHardwareBufferTest.cpp में PrintAhbFormat() के अंत में नया पिक्सेल प्रारूप जोड़कर, उचित परीक्षणों में नया पिक्सेल प्रारूप जोड़ें। मौजूदा कोड परिपाटी का पालन करें, जैसा कि नीचे दिखाया गया है:
```
void PrintAhbFormat(std::ostream& os, uint64_t format) {
    switch (format) {
        ...
        FORMAT_CASE(R8G8B8A8_UNORM);
        default: os << "unknown"; break;
    }
}
```
@IntDef में एक नई प्रविष्टि जोड़कर, HardwareBuffer.java में HardwareBuffer एसडीके में नया पिक्सेल प्रारूप जोड़ें। उदाहरण के लिए, RGBA_8888 प्रारूप की प्रविष्टि इस प्रकार दिखाई गई है:
```
@Retention(RetentionPolicy.SOURCE)
@IntDef(prefix = { "RGB", "BLOB", "YCBCR_", "D_", "DS_", "S_" }, value = {
  ...
  RGBA_8888,
})
```
यदि घटक मान अहस्ताक्षरित सामान्यीकृत नहीं हैं, तो चर नाम में मान को स्पष्ट रूप से इंगित करें। उदाहरण के लिए, केवल अहस्ताक्षरित पूर्णांक 16-बिट लाल चैनल प्रारूप के लिए चर नाम R_16UI होना चाहिए, और अतिरिक्त अहस्ताक्षरित पूर्णांक 16-बिट हरे चैनल प्रारूप के साथ समान प्रारूप RG_16UI16UI होना चाहिए।
@Format के अंत में एक नया सार्वजनिक सदस्य चर जोड़कर, HardwareBuffer.java में एक static int के रूप में नया पिक्सेल प्रारूप जोड़ें:
```
@Format
...
/** Format: 8 bits each red, green, blue, alpha */
public static final int RGBA_8888 = 0x1;
```
इस एनम प्रविष्टि का हेक्स मान PixelFormat.aidl और hardware_buffer.h के समान होना चाहिए। मौजूदा परंपराओं का पालन करें.
इन कोड परिवर्तनों के साथ निर्माण करने का प्रयास एक निर्माण त्रुटि उत्पन्न करता है:
```
android_developer:~/android/aosp-main: m
...
******************************
You have tried to change the API from what has been previously approved.

To make these errors go away, you have two choices:
   1. You can add '@hide' javadoc comments (and remove @SystemApi/@TestApi/etc)
      to the new methods, etc. shown in the above diff.

   2. You can update current.txt and/or removed.txt by executing the following command:
         m api-stubs-docs-non-updatable-update-current-api

      To submit the revised current.txt to the main Android repository,
      you will need approval.
******************************
...
```
इस त्रुटि को साफ़ करने के लिए, current.txt बदलने के लिए, त्रुटि संदेश में निर्दिष्ट अनुसार निम्न आदेश चलाएँ:
```
m api-stubs-docs-non-updatable-update-current-api
```
उपरोक्त कमांड को चलाने से सामान्य रूप से निर्माण करने में सक्षम होने के लिए सही फ़ाइल अपडेट हो जाती है।
नोट: इस फ़ाइल को मैन्युअल रूप से संपादित करने का प्रयास न करें।
HardwareBufferTest.java में paramsForTestCreateOptionalFormats() के अंत में नए पिक्सेल प्रारूप को जोड़कर, जावा परीक्षणों में नया पिक्सेल प्रारूप जोड़ें, जो निम्नानुसार दिखाया गया है:
```
private static Object[] paramsForTestCreateOptionalFormats() {
  return new Integer[]{
      HardwareBuffer.RGBA_8888
  };
```

विंडो सिस्टम एकीकरण में एक नया पिक्सेल प्रारूप जोड़ें

ग्राफ़िक्स एपीआई में फ़्रेमबफ़र के प्रारूप के रूप में नए पिक्सेल प्रारूप का उपयोग करने के लिए, इसे प्रासंगिक ग्राफ़िक्स एपीआई के लिए उपयुक्त विंडो सिस्टम इंटीग्रेशन (डब्ल्यूएसआई) में जोड़ें। वल्कन एपीआई का उपयोग करने वाले ऐप या सिस्टम प्रक्रिया के लिए, वल्कन स्वैपचेन को अपडेट करें। ओपनजीएल ईएस एपीआई का उपयोग करने वाले ऐप या सिस्टम प्रक्रिया के लिए, ईजीएल एपीआई को अपडेट करें।

नए पिक्सेल प्रारूपों के लिए वल्कन WSI परिवर्तन

वल्कन WSI को इस प्रकार अद्यतन करें:

swapchain.cpp में GetNativePixelFormat(VkFormat format) फ़ंक्शन में एक नया केस जोड़ें:

android::PixelFormat GetNativePixelFormat(VkFormat format) {
  ...
  switch (format) {
      ...
      case VK_FORMAT_R8G8B8A8_UNORM:
          native_format = PixelFormat::RGBA_8888;
          break;
      ...
      default:
          ALOGV("unsupported swapchain format %d", format);
          break;
  }
  return native_format;
}

यदि पिक्सेल प्रारूप को कार्य करने के लिए वल्कन एक्सटेंशन की आवश्यकता है तो वल्कन एक्सटेंशन को क्वेरी करें। उदाहरण के लिए साइड एक्सटेंशन के लिए, instance_data उपयोग करें, जो इस प्रकार दिखाया गया है:
```
bool colorspace_ext = instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace);
```
डिवाइस साइड एक्सटेंशन के लिए, निम्नलिखित का उपयोग करें:
```
bool rgba10x6_formats_ext = false;
uint32_t exts_count;
const auto& driver = GetData(pdev).driver;
driver.EnumerateDeviceExtensionProperties(pdev, nullptr, &exts_count,
                                          nullptr);
std::vector props(exts_count);
driver.EnumerateDeviceExtensionProperties(pdev, nullptr, &exts_count,
                                          props.data());
for (uint32_t i = 0; i < exts_count; i++) {
    VkExtensionProperties prop = props[i];
    if (strcmp(prop.extensionName,
               VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME) == 0) {
        rgba10x6_formats_ext = true;
    }
}
```
Google किसी इंस्टेंस या डिवाइस एक्सटेंशन को swapchain.cpp पर प्रदर्शित करने के लिए आवश्यक बुनियादी ढांचे को संभालता है। प्रारंभिक परिवर्तन सूची में वल्कन लोडर से एक्सटेंशन को सही ढंग से सेटअप करने की आवश्यकता नहीं है।

इसके बाद, प्रारूप और रंगस्थान जोड़े की गणना करें:

desc.format = AHARDWAREBUFFER_FORMAT_R10G10B10A10_UNORM;
if (AHardwareBuffer_isSupported(&desc) && rgba10x6_formats_ext) {
  all_formats.emplace_back(
      VkSurfaceFormatKHR{VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
                         VK_COLOR_SPACE_SRGB_NONLINEAR_KHR});
  if (colorspace_ext) {
    all_formats.emplace_back(
        VkSurfaceFormatKHR{VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
                           VK_COLOR_SPACE_PASS_THROUGH_EXT});
    all_formats.emplace_back(
        VkSurfaceFormatKHR{VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
                           VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT});
}

आपको संगत प्रारूप और कलरस्पेस युग्मों का ज्ञान होना चाहिए।

external/deqp पर स्थित dEQP-VK में नया प्रारूप जोड़ें।
मौजूदा स्रोत से आवश्यक परिवर्तनों का अनुमान लगाकर या जानकारी के लिए अपने एंड्रॉइड समर्थन तक पहुंच कर vktApiExternalMemoryTests.cpp और vktExternalMemoryUtil.cpp में वल्कन अनुरूपता परीक्षण अपडेट करें।

नए पिक्सेल प्रारूपों के लिए ईजीएल परिवर्तन

ईजीएल को इस प्रकार अपडेट करें:

getNativePixelFormat() फ़ंक्शन में, नए पिक्सेल प्रारूप के लिए AIDL एनम वापस करने के लिए if-else ट्री को संशोधित करें। RGBA_8888 पिक्सेल प्रारूप के लिए उदाहरण का उपयोग करना:
```
if (a == 0) {
  ...
} else {
  if (componentType == EGL_COLOR_COMPONENT_TYPE_FIXED_EXT) {
      if (colorDepth > 24) {
          ...
      } else {
          *format = PixelFormat::RGBA_8888;
      }
  } else {
    ...
  }
}
```
dEQP में नया प्रारूप जोड़ने के लिए, androidFormats enum में एक नई प्रविष्टि जोड़ें, जो इस प्रकार दिखाई गई है:
```
static const GLenum androidFormats[] =
{
  ...
  GL_RGBA8,
  ...
};
```

अपना अपडेट सबमिट करें

योगदानकर्ताओं के लिए अपनी परिवर्तन सूचियों को स्पिन करने और उन्हें उचित टीम के साथ साझा करने के लिए फ़ॉलो करें।