एचडीआर वीडियो रिकॉर्ड करना

ध्यान दें: इस पेज पर Camera2 पैकेज के बारे में बताया गया है. अगर आपके ऐप्लिकेशन को Camera2 की खास और लो-लेवल सुविधाओं की ज़रूरत नहीं है, तो हमारा सुझाव है कि आप CameraX का इस्तेमाल करें. CameraX और Camera2, दोनों ही Android 5.0 (एपीआई लेवल 21) और इसके बाद के वर्शन पर काम करते हैं.

Camera2 एपीआई, हाई डाइनैमिक रेंज (एचडीआर) वीडियो कैप्चर करने की सुविधा देते हैं. इससे आपको अपने कैमरे का इस्तेमाल करके, एचडीआर वीडियो कॉन्टेंट की झलक देखने और उसे रिकॉर्ड करने की सुविधा मिलती है. स्टैंडर्ड डाइनैमिक रेंज (एसडीआर) की तुलना में, एचडीआर में रंगों की ज़्यादा रेंज मिलती है. साथ ही, यह ल्यूमिनेंस कॉम्पोनेंट की डाइनैमिक रेंज को बढ़ाता है. यह रेंज, मौजूदा 100 सीडी/एम2 से 1,000 सीडी/एम2 तक बढ़ जाती है. इससे वीडियो की क्वालिटी, असली वीडियो से काफ़ी हद तक मेल खाती है. इसमें ज़्यादा गहरे रंग, ज़्यादा चमकदार हाइलाइट, और ज़्यादा गहरे शेड होते हैं.

देखें कि एचडीआर वीडियो, सूर्यास्त को ज़्यादा वाइब्रेंट तरीके से कैसे कैप्चर करता है.

एसडीआर वीडियो क्वालिटी में कैप्चर किया गया सूर्यास्त एचडीआर वीडियो क्वालिटी में कैप्चर किया गया सूर्यास्त
पहली इमेज. एसडीआर (ऊपर) और एचडीआर (नीचे) वीडियो क्वालिटी की तुलना.

डिवाइस से जुड़ी ज़रूरी शर्तें

सभी Android डिवाइसों पर एचडीआर वीडियो कैप्चर करने की सुविधा काम नहीं करती. अपने ऐप्लिकेशन में एचडीआर वीडियो कैप्चर करने से पहले, यह पता करें कि आपका डिवाइस इन ज़रूरी शर्तों को पूरा करता है या नहीं:

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

एचडीआर कैप्चर आर्किटेक्चर

यहां दिए गए डायग्राम में, एचडीआर कैप्चर आर्किटेक्चर के मुख्य कॉम्पोनेंट दिखाए गए हैं.

एचडीआर कैप्चर आर्किटेक्चर का डायग्राम.
दूसरी इमेज. एचडीआर कैप्चर आर्किटेक्चर का डायग्राम.

जब कोई कैमरा डिवाइस एचडीआर में फ़्रेम कैप्चर करता है, तो Camera2 फ़्रेमवर्क एक बफ़र तय करता है. इसमें प्रोसेस किए गए कैमरा सेंसर आउटपुट को सेव किया जाता है. अगर एचडीआर प्रोफ़ाइल के लिए ज़रूरी हो, तो यह उससे जुड़ा एचडीआर मेटाडेटा भी अटैच करता है. इसके बाद, Camera2 फ़्रेमवर्क, CaptureRequest में रेफ़र किए गए आउटपुट सरफ़ेस के लिए, भरे हुए बफ़र को सूची में जोड़ता है. जैसे, डिसप्ले या वीडियो एन्कोडर, जैसा कि डायग्राम में दिखाया गया है.

यह देखना कि एचडीआर की सुविधा काम करती है या नहीं

अपने ऐप्लिकेशन में एचडीआर वीडियो कैप्चर करने से पहले, यह पता करें कि डिवाइस पर आपकी चुनी गई एचडीआर प्रोफ़ाइल काम करती है या नहीं.

CameraCharacteristics इंस्टेंस पाने के लिए, CameraManager getCameraCharacteristics() तरीके का इस्तेमाल करें. इससे, अपने डिवाइस की एचडीआर क्षमताओं के बारे में क्वेरी की जा सकती है.

यहां दिए गए तरीके से यह पता लगाया जा सकता है कि कोई डिवाइस HLG10 के साथ काम करता है या नहीं. HLG10, एचडीआर का बेसलाइन स्टैंडर्ड है. डिवाइस बनाने वाली कंपनियों को 10-बिट आउटपुट वाले कैमरों पर यह सुविधा देनी होगी.

  1. सबसे पहले, देखें कि डिवाइस पर 10-बिट प्रोफ़ाइलें (HLG10 के लिए बिट-डेप्थ) काम करती हैं या नहीं:

    private fun isTenBitProfileSupported(cameraId: String): Boolean {
        val cameraCharacteristics = cameraManager.getCameraCharacteristics(cameraId)
        val availableCapabilities = cameraCharacteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES)
            ?: return false
        for (capability in availableCapabilities) {
            if (capability == CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT) {
                return true
            }
        }
        return false
    }

  2. इसके बाद, देखें कि डिवाइस पर HLG10 (या कोई अन्य काम करने वाली प्रोफ़ाइल) काम करती है या नहीं:

    @RequiresApi(api = 33)
    private fun isHLGSupported(cameraId: String): Boolean {
        if (isTenBitProfileSupported(cameraId)) {
            val cameraCharacteristics = cameraManager.getCameraCharacteristics(cameraId)
            val availableProfiles = cameraCharacteristics
                .get(CameraCharacteristics.REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES)
                ?.getSupportedProfiles()
    
            // Checks for the chosen profile, in this case HLG10.
            return availableProfiles?.contains(DynamicRangeProfiles.HLG10) ?: false
        }
        return false
    }

अगर डिवाइस पर एचडीआर की सुविधा काम करती है, तो isHLGSupported() हमेशा true दिखाता है. ज़्यादा जानकारी के लिए, CameraCharacteristics रेफ़रंस दस्तावेज़ देखें.

एचडीआर कैप्चर सेट अप करना

यह पक्का करने के बाद कि आपका डिवाइस एचडीआर के साथ काम करता है, अपने ऐप्लिकेशन को कैमरे से रॉ एचडीआर वीडियो स्ट्रीम कैप्चर करने के लिए सेट अप करें. डिवाइस पर काम करने वाली एचडीआर प्रोफ़ाइल के साथ स्ट्रीम का OutputConfiguration उपलब्ध कराने के लिए, setDynamicRangeProfile() का इस्तेमाल करें. इसके बाद, इसे बनाने पर CameraCaptureSession को पास किया जाता है. एचडीआर प्रोफ़ाइल के साथ काम करने वाले डिवाइसों की सूची देखें.

यहां दिए गए कोड सैंपल में, setupSessionDynamicRangeProfile() सबसे पहले यह जांच करता है कि डिवाइस पर Android 13 चल रहा है या नहीं. इसके बाद, यह डिवाइस पर काम करने वाली एचडीआर प्रोफ़ाइल के साथ CameraCaptureSession को OutputConfiguration के तौर पर सेट अप करता है:

  /**
   * Creates a [CameraCaptureSession] with a dynamic range profile.
   */
  private fun setupSessionWithDynamicRangeProfile(
      dynamicRange: Long,
      device: CameraDevice,
      targets: List<Surface>,
      handler: Handler? = null,
      stateCallback: CameraCaptureSession.StateCallback
  ): Boolean {
      if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.TIRAMISU) {
          val outputConfigs = mutableListOf<OutputConfiguration>()
          for (target in targets) {
              val outputConfig = OutputConfiguration(target)
              //sets the dynamic range profile, for example DynamicRangeProfiles.HLG10
              outputConfig.setDynamicRangeProfile(dynamicRange)
              outputConfigs.add(outputConfig)
          }
          device.createCaptureSessionByOutputConfigurations(
              outputConfigs, stateCallback, handler
          )
          return true
      } else {
          device.createCaptureSession(targets, stateCallback, handler)
          return false
      }
  }

जब आपका कैमरा ऐप्लिकेशन कैमरे को शुरू करता है, तो वह रिकॉर्डिंग की झलक देखने के लिए, बार-बार CaptureRequest भेजता है:

session.setRepeatingRequest(previewRequest, null, cameraHandler)

वीडियो रिकॉर्डिंग शुरू करने के लिए भी:

// Start recording repeating requests, which stops the ongoing preview
//  repeating requests without having to explicitly call
//  `session.stopRepeating`.
session.setRepeatingRequest(
    recordRequest,
    object : CameraCaptureSession.CaptureCallback() {
        override fun onCaptureCompleted(
            session: CameraCaptureSession,
            request: CaptureRequest,
            result: TotalCaptureResult
        ) {
            if (currentlyRecording) {
                encoder.frameAvailable()
            }
        }
    },
    cameraHandler
)

एचडीआर कैमरे से किसी और डिवाइस पर स्ट्रीम किए गए वीडियो को कोड में बदलना

एचडीआर कैमरे से स्ट्रीम किए गए वीडियो को कोड में बदलने और फ़ाइल को डिस्क में सेव करने के लिए, MediaCodec का इस्तेमाल करें.

सबसे पहले, आउटपुट Surface पाएं. यह आउटपुट, रॉ वीडियो डेटा को सेव करने वाले बफ़र से मैप होता है. MediaCodec के लिए, createInputSurface() का इस्तेमाल करें.

MediaCodec को शुरू करने के लिए, ऐप्लिकेशन को एक MediaFormat बनाना होगा. इसके लिए, उसे कोडेक प्रोफ़ाइल, कलर स्पेस, कलर रेंज, और ट्रांसफ़र फ़ंक्शन की जानकारी देनी होगी:

val mimeType = when {
    dynamicRange == DynamicRangeProfiles.STANDARD -> MediaFormat.MIMETYPE_VIDEO_AVC
    dynamicRange < DynamicRangeProfiles.PUBLIC_MAX ->
        MediaFormat.MIMETYPE_VIDEO_HEVC
    else -> throw IllegalArgumentException("Unknown dynamic range format")
}

val codecProfile = when {
    dynamicRange == DynamicRangeProfiles.HLG10 ->
        MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10
    dynamicRange == DynamicRangeProfiles.HDR10 ->
        MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10HDR10
    dynamicRange == DynamicRangeProfiles.HDR10_PLUS ->
        MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10HDR10Plus
    else -> -1
}
// Failing to correctly set color transfer causes quality issues
// for example, washout and color clipping.
val transferFunction = when (codecProfile) {
    MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10 ->
        MediaFormat.COLOR_TRANSFER_HLG
    MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10HDR10 ->
        MediaFormat.COLOR_TRANSFER_ST2084
    MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10HDR10Plus ->
        MediaFormat.COLOR_TRANSFER_ST2084
    else -> MediaFormat.COLOR_TRANSFER_SDR_VIDEO
}

val format = MediaFormat.createVideoFormat(mimeType, width, height)

// Set some properties.  Failing to specify some of these can cause the MediaCodec
// configure() call to throw an exception.
format.setInteger(
    MediaFormat.KEY_COLOR_FORMAT,
    MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface
)
format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate)
format.setInteger(MediaFormat.KEY_FRAME_RATE, frameRate)
format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, IFRAME_INTERVAL)

if (codecProfile != -1) {
    format.setInteger(MediaFormat.KEY_PROFILE, codecProfile)
    format.setInteger(
        MediaFormat.KEY_COLOR_STANDARD,
        MediaFormat.COLOR_STANDARD_BT2020
    )
    format.setInteger(MediaFormat.KEY_COLOR_RANGE, MediaFormat.COLOR_RANGE_LIMITED)
    format.setInteger(MediaFormat.KEY_COLOR_TRANSFER, transferFunction)
    format.setFeatureEnabled(
        MediaCodecInfo.CodecCapabilities.FEATURE_HdrEditing,
        true
    )
}

mediaCodec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)

इसे लागू करने के बारे में ज़्यादा जानकारी के लिए, Camera2Video के सैंपल के तौर पर मिले ऐप्लिकेशन का EncoderWrapper.kt देखें.

एचडीआर फ़ॉर्मैट

Android 13 से, 10-बिट आउटपुट वाले कैमरा डिवाइसों में एचडीआर कैप्चर और वीडियो चलाने के लिए, HLG10 की सुविधा होनी चाहिए. इसके अलावा, डिवाइस बनाने वाली कंपनियां एचडीआर कैप्चर आर्किटेक्चर का इस्तेमाल करके, अपनी पसंद के किसी भी एचडीआर फ़ॉर्मैट को चालू कर सकती हैं.

यहां दी गई टेबल में, उपलब्ध एचडीआर फ़ॉर्मैट और एचडीआर वीडियो कैप्चर करने की उनकी क्षमताओं के बारे में बताया गया है.

फ़ॉर्मैट ट्रांसफ़र फ़ंक्शन (टीएफ़) मेटाडेटा कोडेक बिट डेप्थ
HLG10 HLG नहीं HEVC 10-बिट
एचडीआर10 PQ स्थिर HEVC 10-बिट
HDR10+ PQ डाइनैमिक HEVC 10-बिट
Dolby Vision 8.4 HLG डाइनैमिक HEVC 10-बिट

संसाधन

एचडीआर वीडियो कैप्चर करने की सुविधा वाले ऐप्लिकेशन के लिए, GitHub पर Camera2Video सैंपल देखें.