हमारा सुझाव है कि 27 मार्च, 2025 से AOSP को बनाने और उसमें योगदान देने के लिए, aosp-main के बजाय android-latest-release का इस्तेमाल करें. ज़्यादा जानकारी के लिए, AOSP में हुए बदलाव लेख पढ़ें.

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

Android में नए पिक्सल फ़ॉर्मैट जोड़ना

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

इस पेज पर, AOSP कोड में ज़रूरी बदलावों और AOSP पर नए पिक्सल फ़ॉर्मैट जोड़ने की प्रोसेस के बारे में बताया गया है.

नया पिक्सल फ़ॉर्मैट जोड़ने से पहले, सोर्स डाउनलोड करें और पैच अपलोड करें. इसके बारे में पैच सबमिट करना लेख में बताया गया है.

AIDL में नया पिक्सल फ़ॉर्मैट जोड़ना

नए पिक्सल फ़ॉर्मैट के लिए सहायता जोड़ने के लिए, AIDL में मौजूद दोनों PixelFormat.aidl फ़ाइलों में बदलाव करना ज़रूरी है. AIDL के सोर्स कोड के लिए, hardware/interfaces/graphics/common/aidl/ देखें.

AIDL में नया पिक्सल फ़ॉर्मैट जोड़ने के लिए, यह तरीका अपनाएं:

मौजूदा कोड कन्वेंशन का पालन करके, PixelFormat.aidl में मौजूद PixelFormat enum के आखिर में, नए पिक्सल फ़ॉर्मैट को नई एंट्री के तौर पर जोड़ें. साथ ही, अपनी एंट्री के लिए हेक्स वैल्यू को पिछली एंट्री से एक ज़्यादा पर सेट करें. कोड में किए गए बदलावों को पिछली एंट्री से मैच करें. 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-android-latest-release: 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
```
ऊपर दी गई कमांड चलाने से, सही फ़ाइल अपडेट हो जाती है, ताकि उसे सामान्य तरीके से बनाया जा सके.

ध्यान दें: इस फ़ाइल में मैन्युअल तरीके से बदलाव करने की कोशिश न करें.

AHB में नया पिक्सल फ़ॉर्मैट जोड़ना

नए पिक्सल फ़ॉर्मैट के लिए सहायता जोड़ने के लिए, hardware_buffer.h और AHardwareBuffer.cpp में बदलाव करने होंगे. AHB के सोर्स कोड के लिए, frameworks/native/libs/nativewindow देखें.

AHB में नया पिक्सल फ़ॉर्मैट जोड़ने के लिए, यह तरीका अपनाएं:

hardware_buffer.h में, नए पिक्सल फ़ॉर्मैट को AHardwareBuffer_Format enum के आखिर में नई एंट्री के तौर पर जोड़ें. मौजूदा कोड के नियमों का पालन करें.
RGBA_8888 पिक्सल फ़ॉर्मैट के उदाहरण का इस्तेमाल करके, नई पिक्सल फ़ॉर्मैट एंट्री को इस तरह जोड़ें:
```
/**
 * Corresponding formats:
 *   Vulkan: VK_FORMAT_R8G8B8A8_UNORM
 *   OpenGL ES: GL_RGBA8
 */
AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM = 1,
```
ध्यान दें कि AHB में नए पिक्सल फ़ॉर्मैट को एक नाम दिया जाता है. यह नाम AHARDWAREBUFFER_FORMAT_ से शुरू होना चाहिए. इसके बाद, चैनल के छोटे नाम और बिट डेप्थ होने चाहिए. आखिर में, एन्कोडिंग होनी चाहिए. इस enum एंट्री की हेक्स वैल्यू, PixelFormat.aidl में दी गई हेक्स वैल्यू के बराबर होनी चाहिए.

पिक्सेल फ़ॉर्मैट में, Vulkan या OpenGL ES फ़ॉर्मैट में से कोई एक या दोनों होने चाहिए. जहां ज़रूरी हो वहां उससे जुड़े फ़ॉर्मैट की जानकारी दें. अगर कोई भी जुड़ा हुआ फ़ॉर्मैट मौजूद नहीं है, तो N/A तय करें.
अगर पिक्सल फ़ॉर्मैट, OpenGL ES फ़ॉर्मैट से जुड़ा है, तो उसे CTS में वैकल्पिक टेस्टिंग के लिए जोड़ें. इसके लिए, नए GL फ़ॉर्मैट को AHardwareBufferGLTest.cpp में जोड़ें. इसके लिए, AHBFormatAsString(int32_t format) में FORMAT_CASE(...) और GL_FORMAT_CASE(...) का इस्तेमाल करें. इसे यहां दिखाया गया है:
```
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;
    }
}
```
HardwareBuffer एसडीके में नया पिक्सल फ़ॉर्मैट जोड़ें. इसके लिए, HardwareBuffer.java में जाकर, @IntDef में नई एंट्री जोड़ें. उदाहरण के लिए, RGBA_8888 फ़ॉर्मैट के लिए एंट्री इस तरह दिखती है:
```
@Retention(RetentionPolicy.SOURCE)
@IntDef(prefix = { "RGB", "BLOB", "YCBCR_", "D_", "DS_", "S_" }, value = {
  ...
  RGBA_8888,
})
```
अगर कॉम्पोनेंट की वैल्यू पर हस्ताक्षर नहीं किया गया है, तो वैरिएबल के नाम में वैल्यू साफ़ तौर पर बताएं. उदाहरण के लिए, बिना हस्ताक्षर वाले पूर्णांक वाले 16-बिट के सिर्फ़ लाल चैनल के फ़ॉर्मैट के लिए वैरिएबल का नाम R_16UI होना चाहिए. साथ ही, बिना हस्ताक्षर वाले पूर्णांक वाले 16-बिट के हरे चैनल के फ़ॉर्मैट के साथ इसी फ़ॉर्मैट के लिए वैरिएबल का नाम RG_16UI16UI होना चाहिए.
HardwareBuffer.java में static int के तौर पर नया पिक्सल फ़ॉर्मैट जोड़ें. इसके लिए, @Format के आखिर में नया सार्वजनिक सदस्य वैरिएबल जोड़ें:
```
@Format
...
/** Format: 8 bits each red, green, blue, alpha */
public static final int RGBA_8888 = 0x1;
```
इस enum एंट्री की हेक्स वैल्यू, PixelFormat.aidl और hardware_buffer.h की हेक्स वैल्यू के बराबर होनी चाहिए. मौजूदा नियमों का पालन करें.
कोड में किए गए इन बदलावों के साथ बिल्ड करने पर, बिल्ड से जुड़ी गड़बड़ी जनरेट होती है:
```
android_developer:~/android/aosp-android-latest-release: 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
```
ऊपर दी गई कमांड चलाने से, सही फ़ाइल अपडेट हो जाती है, ताकि उसे सामान्य तरीके से बनाया जा सके.

ध्यान दें: इस फ़ाइल में मैन्युअल तरीके से बदलाव करने की कोशिश न करें.
Java टेस्ट में नया पिक्सल फ़ॉर्मैट जोड़ें. इसके लिए, HardwareBufferTest.java में paramsForTestCreateOptionalFormats() के आखिर में नया पिक्सल फ़ॉर्मैट जोड़ें. इसे इस तरह दिखाया गया है:
```
private static Object[] paramsForTestCreateOptionalFormats() {
  return new Integer[]{
      HardwareBuffer.RGBA_8888
  };
```

Window System के इंटिग्रेशन में नया पिक्सल फ़ॉर्मैट जोड़ना

ग्राफ़िक्स एपीआई में फ़्रेमबफ़र के फ़ॉर्मैट के तौर पर नए पिक्सल फ़ॉर्मैट का इस्तेमाल करने के लिए, इसे ग्राफ़िक्स एपीआई से जुड़े सही विंडो सिस्टम इंटिग्रेशन (डब्ल्यूएसआई) में जोड़ें. Vulkan API का इस्तेमाल करने वाले ऐप्लिकेशन या सिस्टम प्रोसेस के लिए, Vulkan Swapchain को अपडेट करें. OpenGL ES API का इस्तेमाल करने वाले किसी ऐप्लिकेशन या सिस्टम प्रोसेस के लिए, EGL API अपडेट करें.

नए पिक्सल फ़ॉर्मैट के लिए Vulkan WSI में बदलाव

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

अगर पिक्सल फ़ॉर्मैट को काम करने के लिए Vulkan एक्सटेंशन की ज़रूरत है, तो Vulkan एक्सटेंशन के लिए क्वेरी करें. उदाहरण के लिए, साइड एक्सटेंशन के लिए 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 में Vulkan Conformance Tests को अपडेट करें. इसके लिए, मौजूदा सोर्स से ज़रूरी बदलावों का पता लगाएं या जानकारी पाने के लिए, Android की सहायता टीम से संपर्क करें.

नए पिक्सल फ़ॉर्मैट के लिए EGL में बदलाव

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

getNativePixelFormat() फ़ंक्शन में, if-else ट्री में बदलाव करके, नए पिक्सल फ़ॉर्मैट के लिए AIDL enum दिखाएं.
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,
  ...
};
```

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

बदलावों की सूचियां बनाने और उन्हें सही टीम के साथ शेयर करने के लिए, योगदान देने वालों के लिए दिए गए निर्देशों का पालन करें.