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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   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 देखें.

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

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

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

संसाधन

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