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

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

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

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

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

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

• Android 13 (एपीआई लेवल 33) को टारगेट करता हो.
• उसमें 10-बिट या इससे ज़्यादा क्षमता वाला कैमरा सेंसर हो. एचडीआर की सुविधा के बारे में ज़्यादा जानने के लिए, एचडीआर की सुविधा उपलब्ध है या नहीं, यह देखना लेख पढ़ें.

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

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

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

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

देखें कि एचडीआर टेक्नोलॉजी काम करती है या नहीं

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

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

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

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

   Kotlin

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

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

   Kotlin

   @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 desired profile, in this case HLG10
     return availableProfiles.contains(DynamicRangeProfiles.HLG10)
   }
   return false;
   }

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

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

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

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

  /**
  * Creates a [CameraCaptureSession] with a dynamic range profile.
  */
  private fun setupSessionWithDynamicRangeProfile(
      dynamicRange: Long,
      device: CameraDevice,
      targets: List,
      handler: Handler? = null,
      stateCallback: CameraCaptureSession.StateCallback
  ): Boolean {
      if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.TIRAMISU) {
          val outputConfigs = mutableListOf()
          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 का इस्तेमाल करें.

सबसे पहले, OutputSurface पाएं. यह एक ऐसे बफ़र पर मैप करता है जो वीडियो का रॉ डेटा सेव करता है. 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 का इस्तेमाल करना ज़रूरी है. इसके अलावा, डिवाइस बनाने वाली कंपनियां एचडीआर कैप्चर आर्किटेक्चर का इस्तेमाल करके, अपनी पसंद के किसी भी एचडीआर फ़ॉर्मैट को चालू कर सकती हैं.

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

संसाधन

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