साल 2026 से, हम दूसरी और चौथी तिमाही में AOSP के लिए सोर्स कोड पब्लिश करेंगे. ऐसा इसलिए किया जाएगा, ताकि हम अपने ट्रंक स्टेबल डेवलपमेंट मॉडल के साथ काम कर सकें और यह पक्का कर सकें कि प्लैटफ़ॉर्म, पूरे सिस्टम के लिए स्थिर बना रहे. AOSP बनाने और उसमें योगदान देने के लिए, android-latest-release का इस्तेमाल करें. android-latest-release मेनिफ़ेस्ट ब्रांच, हमेशा AOSP पर पुश की गई सबसे नई रिलीज़ का रेफ़रंस देगी. ज़्यादा जानकारी के लिए, AOSP में हुए बदलाव देखें.

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

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

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

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

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

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

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

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

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

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

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

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

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

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

उम्मीद है कि पिक्सल फ़ॉर्मैट में, Vulkan या OpenGL ES से जुड़ा एक या दोनों फ़ॉर्मैट मौजूद होंगे. जहां ज़रूरी हो वहां, उससे जुड़े फ़ॉर्मैट की जानकारी दें. अगर उससे जुड़ा कोई फ़ॉर्मैट मौजूद नहीं है, तो N/A की जानकारी दें.
अगर पिक्सल फ़ॉर्मैट में OpenGL ES से जुड़ा कोई फ़ॉर्मैट है, तो उसे सीटीएस के तहत, वैकल्पिक टेस्टिंग में जोड़ें. इसके लिए, AHardwareBufferGLTest.cpp में मौजूद AHBFormatAsString(int32_t format) में, नए फ़ॉर्मैट के लिए FORMAT_CASE(...) और GL_FORMAT_CASE(...) के साथ नया 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 जोड़ें. इसके लिए, HAL_PIXEL_FORMAT कॉन्स्टैंट के बजाय, PixelFormat:: enum का इस्तेमाल करें. एआईडीएल में नया पिक्सल फ़ॉर्मैट जोड़ना में दिए गए 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");
```
सही टेस्ट में नया पिक्सल फ़ॉर्मैट जोड़ें. ऐसा करने के लिए, PrintAhbFormat() में मौजूद AHardwareBufferTest.cpp के आखिर में नया पिक्सल फ़ॉर्मैट जोड़ें. मौजूदा कोड के नियमों का पालन करें. यह इस तरह दिखेगा:
```
void PrintAhbFormat(std::ostream& os, uint64_t format) {
    switch (format) {
        ...
        FORMAT_CASE(R8G8B8A8_UNORM);
        default: os << "unknown"; break;
    }
}
```
HardwareBuffer.java में मौजूद HardwareBuffer एसडीके में, नया पिक्सल फ़ॉर्मैट जोड़ें: इसके लिए, @IntDef में नई एंट्री जोड़ें. उदाहरण के लिए, RGBA_8888 फ़ॉर्मैट की एंट्री इस तरह दिखती है:
```
@Retention(RetentionPolicy.SOURCE)
@IntDef(prefix = { "RGB", "BLOB", "YCBCR_", "D_", "DS_", "S_" }, value = {
  ...
  RGBA_8888,
})
```
अगर कॉम्पोनेंट की वैल्यू, अनसाइंड नॉर्मलाइज़ नहीं की गई हैं, तो वैरिएबल के नाम में वैल्यू साफ़ तौर पर बताएं. उदाहरण के लिए, सिर्फ़ अनसाइंड इंटिजर 16-बिट रेड चैनल वाले फ़ॉर्मैट के लिए, वैरिएबल का नाम R_16UI होना चाहिए. वहीं, अनसाइंड इंटिजर 16-बिट ग्रीन चैनल वाले फ़ॉर्मैट के साथ, इसी फ़ॉर्मैट के लिए वैरिएबल का नाम RG_16UI16UI होना चाहिए.
नए पिक्सल फ़ॉर्मैट को static int के तौर पर HardwareBuffer.java, जोड़ें. इसके लिए, @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 टेस्ट में, नया पिक्सल फ़ॉर्मैट जोड़ें. इसके लिए, paramsForTestCreateOptionalFormats() में मौजूद HardwareBufferTest.java के आखिर में, नया पिक्सल फ़ॉर्मैट जोड़ें. यह इस तरह दिखेगा:
```
private static Object[] paramsForTestCreateOptionalFormats() {
  return new Integer[]{
      HardwareBuffer.RGBA_8888
  };
```

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

किसी ग्राफ़िक एपीआई में फ़्रेमबफ़र के फ़ॉर्मैट के तौर पर, नए पिक्सल फ़ॉर्मैट का इस्तेमाल करने के लिए, उसे संबंधित ग्राफ़िक एपीआई के लिए, सही विंडो सिस्टम इंटिग्रेशन (डब्ल्यूएसआई) में जोड़ें. Vulkan API का इस्तेमाल करने वाले किसी ऐप्लिकेशन या सिस्टम प्रोसेस के लिए, Vulkan स्वैपचेन को अपडेट करें. 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 में इंस्टेंस या डिवाइस एक्सटेंशन दिखाने के लिए ज़रूरी इन्फ़्रास्ट्रक्चर को मैनेज करता है. शुरुआती बदलाव की सूची में, Vulkan लोडर से एक्सटेंशन को सही तरीके से सेटअप करना ज़रूरी नहीं है.

इसके बाद, फ़ॉर्मैट और कलरस्पेस के पेयर की गिनती करें:

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 में किए जाने वाले बदलाव

EGL को इस तरह अपडेट करें:

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

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

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