CameraX वीडियो कैप्चर करने का आर्किटेक्चर

कैप्चर करने वाला सिस्टम, आम तौर पर वीडियो और ऑडियो स्ट्रीम रिकॉर्ड करता है, उन्हें कंप्रेस करता है, और दोनों स्ट्रीम को मिक्स करता है. इसके बाद, वह इस स्ट्रीम को डिस्क में सेव करता है.

वीडियो और ऑडियो कैप्चर करने वाले सिस्टम का कॉन्सेप्ट डायग्राम
पहली इमेज. वीडियो और ऑडियो कैप्चर करने वाले सिस्टम का कॉन्सेप्चुअल डायग्राम.

CameraX में, वीडियो कैप्चर करने के लिए VideoCapture इस्तेमाल के उदाहरण का इस्तेमाल किया जाता है:

कॉन्सेप्ट डायग्राम, जिसमें दिखाया गया है कि CameraX, वीडियो कैप्चर करने के इस्तेमाल के उदाहरण को कैसे मैनेज करता है
दूसरी इमेज. कॉन्सेप्ट डायग्राम, जिसमें दिखाया गया है कि CameraX, VideoCapture के इस्तेमाल के उदाहरण को कैसे मैनेज करता है.

जैसा कि इमेज 2 में दिखाया गया है, CameraX वीडियो कैप्चर में कुछ हाई-लेवल आर्किटेक्चरल कॉम्पोनेंट शामिल हैं:

  • वीडियो सोर्स के लिए SurfaceProvider.
  • ऑडियो सोर्स के लिए AudioSource.
  • वीडियो/ऑडियो को एन्कोड और कंप्रेस करने के लिए दो एन्कोडर.
  • दोनों स्ट्रीम को मक्स करने के लिए, एक मीडिया मक्सर.
  • नतीजे को सेव करने के लिए, फ़ाइल सेवर.

VideoCapture API, जटिल कैप्चरिंग इंजन को ऐब्स्ट्रैक्ट करता है और ऐप्लिकेशन को ज़्यादा आसान और सीधा एपीआई उपलब्ध कराता है.

VideoCapture API के बारे में खास जानकारी

VideoCapture, CameraX का इस्तेमाल करने का एक उदाहरण है. यह अपने-आप या इस्तेमाल करने के अन्य उदाहरणों के साथ मिलकर, अच्छी तरह से काम करता है. इस्तेमाल किए जा सकने वाले कॉम्बिनेशन, कैमरे के हार्डवेयर की क्षमताओं पर निर्भर करते हैं. हालांकि, Preview और VideoCapture का कॉम्बिनेशन सभी डिवाइसों पर इस्तेमाल किया जा सकता है.

VideoCapture API में ये ऑब्जेक्ट शामिल होते हैं, जो ऐप्लिकेशन के साथ कम्यूनिकेट करते हैं:

  • VideoCapture, इस्तेमाल के उदाहरण की टॉप-लेवल क्लास है. VideoCapture, CameraSelector और CameraX के अन्य UseCases के साथ LifecycleOwner से बाइंड होता है. इन कॉन्सेप्ट और इस्तेमाल के बारे में ज़्यादा जानने के लिए, CameraX आर्किटेक्चर देखें.
  • Recorder, VideoOutput का एक ऐसा इंप्लिमेंटेशन है जो VideoCapture से जुड़ा होता है. Recorder का इस्तेमाल, वीडियो और ऑडियो कैप्चर करने के लिए किया जाता है. कोई ऐप्लिकेशन, Recorder से रिकॉर्डिंग बनाता है.
  • PendingRecording रिकॉर्डिंग को कॉन्फ़िगर करता है. इसमें ऑडियो चालू करने और इवेंट लिसनर सेट करने जैसे विकल्प मिलते हैं. PendingRecording बनाने के लिए, आपको Recorder का इस्तेमाल करना होगा. PendingRecording कुछ भी रिकॉर्ड नहीं करता.
  • Recording, असल रिकॉर्डिंग करता है. Recording बनाने के लिए, आपको PendingRecording का इस्तेमाल करना होगा.

तीसरी इमेज में, इन ऑब्जेक्ट के बीच के संबंध दिखाए गए हैं:

वीडियो कैप्चर करने के इस्तेमाल के उदाहरण में होने वाले इंटरैक्शन को दिखाने वाला डायग्राम
तीसरी इमेज. डायग्राम में, VideoCapture के इस्तेमाल के उदाहरण में होने वाले इंटरैक्शन दिखाए गए हैं.

लेजेंड:

  1. QualitySelector की मदद से, Recorder बनाएं.
  2. Recorder को इनमें से किसी एक OutputOptions के साथ कॉन्फ़िगर करें.
  3. अगर ज़रूरी हो, तो withAudioEnabled() का इस्तेमाल करके ऑडियो चालू करें.
  4. रिकॉर्डिंग शुरू करने के लिए, VideoRecordEvent लिसनर के साथ start() को कॉल करें.
  5. रिकॉर्डिंग को कंट्रोल करने के लिए, Recording पर pause()/resume()/stop() का इस्तेमाल करें.
  6. अपने इवेंट लिसनर में VideoRecordEvents का जवाब दें.

एपीआई की पूरी सूची, सोर्स कोड में current.txt में मौजूद है.

VideoCapture API का इस्तेमाल करना

अपने ऐप्लिकेशन में CameraX VideoCapture इस्तेमाल के उदाहरण को इंटिग्रेट करने के लिए, यह तरीका अपनाएं:

  1. VideoCapture को बाइंड करें.
  2. रिकॉर्डिंग की तैयारी करना और उसे कॉन्फ़िगर करना.
  3. रनटाइम रिकॉर्डिंग शुरू और कंट्रोल करें.

यहां दिए गए सेक्शन में बताया गया है कि रिकॉर्डिंग सेशन को शुरू से आखिर तक पूरा करने के लिए, हर चरण में क्या किया जा सकता है.

वीडियो कैप्चर को बाइंड करें

VideoCapture इस्तेमाल के उदाहरण को बाइंड करने के लिए, यह तरीका अपनाएं:

  1. Recorder ऑब्जेक्ट बनाएं.
  2. VideoCapture ऑब्जेक्ट बनाएं.
  3. Lifecycle से बाइंड करें.

CameraX VideoCapture API, बिल्डर डिज़ाइन पैटर्न का इस्तेमाल करता है. ऐप्लिकेशन, Recorder बनाने के लिए Recorder.Builder का इस्तेमाल करते हैं. QualitySelector ऑब्जेक्ट की मदद से, Recorder के लिए वीडियो रिज़ॉल्यूशन को भी कॉन्फ़िगर किया जा सकता है.

CameraX Recorder, वीडियो रिज़ॉल्यूशन के लिए पहले से तय किए गए इन Qualities के साथ काम करता है:

  • 4K अल्ट्रा एचडी वीडियो साइज़ (2160 पिक्सल) के लिए Quality.UHD
  • Quality.QHD, क्वाड एचडी वीडियो साइज़ (1440 पिक्सल) के लिए, CameraX में लॉन्च किया गया 1.7.0-alpha02
  • फ़ुल एचडी वीडियो साइज़ (1080 पिक्सल) के लिए Quality.FHD
  • एचडी वीडियो साइज़ (720 पिक्सल) के लिए Quality.HD
  • एसडी वीडियो साइज़ (480 पिक्सल) के लिए Quality.SD

ध्यान दें कि ऐप्लिकेशन से अनुमति मिलने पर, CameraX अन्य रिज़ॉल्यूशन भी चुन सकता है.

हर विकल्प के लिए वीडियो का सटीक साइज़, कैमरे और एन्कोडर की क्षमताओं पर निर्भर करता है. ज़्यादा जानकारी के लिए, CamcorderProfile का दस्तावेज़ देखें.

ऐप्लिकेशन, QualitySelector बनाकर रिज़ॉल्यूशन को कॉन्फ़िगर कर सकते हैं. इनमें से किसी एक तरीके का इस्तेमाल करके, QualitySelector बनाया जा सकता है:

  • fromOrderedList का इस्तेमाल करके, कुछ पसंदीदा रिज़ॉल्यूशन उपलब्ध कराएं. साथ ही, फ़ॉलबैक रणनीति शामिल करें, ताकि पसंदीदा रिज़ॉल्यूशन में से किसी के भी काम न करने पर, उसका इस्तेमाल किया जा सके.

    CameraX, चुने गए कैमरे की क्षमता के आधार पर, सबसे सही फ़ॉलबैक मैच तय कर सकता है. ज़्यादा जानकारी के लिए, QualitySelector का FallbackStrategy specification देखें. उदाहरण के लिए, यहां दिया गया कोड, रिकॉर्डिंग के लिए सबसे ज़्यादा रिज़ॉल्यूशन का अनुरोध करता है. अगर अनुरोध किए गए रिज़ॉल्यूशन में से कोई भी रिज़ॉल्यूशन काम नहीं करता है, तो CameraX को Quality.SD रिज़ॉल्यूशन के सबसे करीब वाला रिज़ॉल्यूशन चुनने की अनुमति दें:

    val qualitySelector = QualitySelector.fromOrderedList(
             listOf(Quality.UHD, Quality.QHD, Quality.FHD, Quality.HD, Quality.SD),
             FallbackStrategy.lowerQualityOrHigherThan(Quality.SD))
    
  • सबसे पहले, कैमरे की क्षमताओं के बारे में क्वेरी करें. इसके बाद, QualitySelector.from का इस्तेमाल करके, काम करने वाले रिज़ॉल्यूशन में से कोई एक चुनें:

    val cameraInfo = cameraProvider.availableCameraInfos.filter {
        it.cameraCharacteristics.get(CameraCharacteristics.LENS_FACING) ==
            CameraMetadata.LENS_FACING_BACK
    }
    
    // Filter to SDR resolutions supported by both the camera sensor and Recorder
    // encoder so the UI picker only displays valid options.
    val supportedQualities =
        Recorder.getVideoCapabilities(cameraInfo[0]).getSupportedQualities(DynamicRange.SDR)
    val filteredQualities = arrayListOf (Quality.UHD, Quality.QHD, Quality.FHD, Quality.HD, Quality.SD)
                           .filter { supportedQualities.contains(it) }
    
    viewBinding.simpleQualityListView.apply {
        adapter = ArrayAdapter(context,
                               android.R.layout.simple_list_item_1,
                               filteredQualities.map { it.qualityToString() })
    
        setOnItemClickListener { _, _, position, _ ->
            // QualitySelector is configured at Recorder build time, so selecting
            // a new resolution requires building a new Recorder instance.
            val qualitySelector = QualitySelector.from(filteredQualities[position])
    
            val recorder = Recorder.Builder()
                .setQualitySelector(qualitySelector).build()
    
             // ...
        }
    }
    
    fun Quality.qualityToString() : String {
        return when (this) {
            Quality.UHD -> "UHD"
            Quality.QHD -> "QHD"
            Quality.FHD -> "FHD"
            Quality.HD -> "HD"
            Quality.SD -> "SD"
            else -> throw IllegalArgumentException()
        }
    }
    
    

    VideoCapabilities.getSupportedQualities से मिला हर Quality (DynamicRange.SDR के लिए Recorder.getVideoCapabilities से), VideoCapture के इस्तेमाल के उदाहरण के लिए अकेले या Preview के इस्तेमाल के उदाहरण के साथ काम करता है. अगर आपने ImageCapture या ImageAnalysis को भी बाइंड किया है, तो हो सकता है कि CameraX बाइंड न हो पाए. ऐसा तब होता है, जब कैमरा उस कॉम्बिनेशन के साथ काम न करता हो.

QualitySelector मिलने के बाद, ऐप्लिकेशन VideoCapture ऑब्जेक्ट बना सकता है और बाइंडिंग कर सकता है. ध्यान दें कि यह बाइंडिंग, इस्तेमाल के अन्य उदाहरणों की तरह ही है:

val recorder = Recorder.Builder()
    .setExecutor(cameraExecutor).setQualitySelector(qualitySelector)
    .build()
val videoCapture = VideoCapture.withOutput(recorder)

try {
    // Bind use cases to camera.
    cameraProvider.bindToLifecycle(
        this, CameraSelector.DEFAULT_BACK_CAMERA, preview, videoCapture
    )
} catch (exc: Exception) {
    Log.e(TAG, "Use case binding failed", exc)
}

ध्यान दें कि bindToLifecycle(), Camera ऑब्जेक्ट दिखाता है. ज़ूम और एक्सपोज़र जैसी कैमरा सेटिंग को कंट्रोल करने के बारे में ज़्यादा जानने के लिए, यह गाइड देखें.

Recorder, सिस्टम के लिए सबसे सही फ़ॉर्मैट चुनता है. सबसे आम वीडियो कोडेक, MPEG-4 कंटेनर फ़ॉर्मैट वाला H.264 AVC है.

रिकॉर्डिंग को कॉन्फ़िगर करना और बनाना

Recorder से, ऐप्लिकेशन वीडियो और ऑडियो कैप्चर करने के लिए रिकॉर्डिंग ऑब्जेक्ट बना सकता है. ऐप्लिकेशन, रिकॉर्डिंग बनाने के लिए ये काम करते हैं:

  1. OutputOptions को prepareRecording() के साथ कॉन्फ़िगर करें.
  2. (ज़रूरी नहीं) ऑडियो रिकॉर्डिंग की सुविधा चालू करें.
  3. VideoRecordEvent लिसनर को रजिस्टर करने के लिए, start() का इस्तेमाल करें और वीडियो कैप्चर करना शुरू करें.

start() फ़ंक्शन को कॉल करने पर, Recorder एक Recording ऑब्जेक्ट दिखाता है. आपका ऐप्लिकेशन, इस Recording ऑब्जेक्ट का इस्तेमाल करके, कैप्चर करने की प्रोसेस को पूरा कर सकता है. इसके अलावा, वह अन्य कार्रवाइयां भी कर सकता है. जैसे, प्रोसेस को रोकना या फिर से शुरू करना.

एक Recorder में एक बार में एक ही Recording ऑब्जेक्ट इस्तेमाल किया जा सकता है. Recording ऑब्जेक्ट पर Recording.stop() या Recording.close() को कॉल करने के बाद, नई रिकॉर्डिंग शुरू की जा सकती है.

आइए, इन चरणों के बारे में ज़्यादा जानकारी पाएं. सबसे पहले, ऐप्लिकेशन Recorder.prepareRecording() के साथ रिकॉर्डर के लिए OutputOptions को कॉन्फ़िगर करता है. Recorder में, इस तरह के OutputOptions इस्तेमाल किए जा सकते हैं:

  • FileDescriptorOutputOptions, ताकि इसे FileDescriptor में कैप्चर किया जा सके.
  • FileOutputOptions, ताकि File में कैप्चर किया जा सके.
  • MediaStoreOutputOptions, ताकि इसे MediaStore में कैप्चर किया जा सके.

सभी OutputOptions टाइप की मदद से, setFileSizeLimit() के साथ फ़ाइल का ज़्यादा से ज़्यादा साइज़ सेट किया जा सकता है. अन्य विकल्प, अलग-अलग आउटपुट टाइप के हिसाब से होते हैं. जैसे, FileDescriptorOutputOptions के लिए ParcelFileDescriptor.

prepareRecording(), PendingRecording ऑब्जेक्ट दिखाता है. यह एक इंटरमीडिएट ऑब्जेक्ट है, जिसका इस्तेमाल उससे जुड़े Recording ऑब्जेक्ट को बनाने के लिए किया जाता है. PendingRecording एक ऐसा पास है जो कुछ समय के लिए ही मान्य होता है. ज़्यादातर मामलों में, यह नहीं दिखना चाहिए. साथ ही, ऐप्लिकेशन इसे शायद ही कभी कैश मेमोरी में सेव करता है.

ऐप्लिकेशन, रिकॉर्डिंग को और कॉन्फ़िगर कर सकते हैं. जैसे:

  • withAudioEnabled() की मदद से ऑडियो चालू करें.
  • start(Executor, Consumer<VideoRecordEvent>) की मदद से, वीडियो रिकॉर्डिंग इवेंट पाने के लिए, लिसनर को रजिस्टर करें.
  • PendingRecording.asPersistentRecording() की मदद से, रिकॉर्डिंग को लगातार रिकॉर्ड करने की सुविधा दें. ऐसा तब करें, जब VideoCapture को किसी दूसरे कैमरे से फिर से जोड़ा गया हो.

रिकॉर्डिंग शुरू करने के लिए, PendingRecording.start() पर कॉल करें. CameraX, PendingRecording को Recording में बदल देता है. साथ ही, रिकॉर्डिंग के अनुरोध को सूची में जोड़ता है और नए बनाए गए Recording ऑब्जेक्ट को ऐप्लिकेशन में दिखाता है. संबंधित कैमरा डिवाइस पर रिकॉर्डिंग शुरू होने के बाद, CameraX एक VideoRecordEvent.EVENT_TYPE_START इवेंट भेजता है.

यहां दिए गए उदाहरण में, वीडियो और ऑडियो को MediaStore फ़ाइल में रिकॉर्ड करने का तरीका बताया गया है:

// Create MediaStoreOutputOptions for our recorder.
val name = "CameraX-recording-" +
    SimpleDateFormat(FILENAME_FORMAT, Locale.US)
        .format(System.currentTimeMillis()) + ".mp4"
val contentValues = ContentValues().apply {
    put(MediaStore.Video.Media.DISPLAY_NAME, name)
}
val mediaStoreOutput = MediaStoreOutputOptions.Builder(
    this.contentResolver,
    MediaStore.Video.Media.EXTERNAL_CONTENT_URI
)
    .setContentValues(contentValues)
    .build()

// 2. Configure Recorder and Start recording to the mediaStoreOutput.
val recording = videoCapture.output
    .prepareRecording(context, mediaStoreOutput)
    .withAudioEnabled()
    .start(ContextCompat.getMainExecutor(this), captureListener)

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

MirrorMode के तीन विकल्प हैं: MIRROR_MODE_OFF, MIRROR_MODE_ON, और MIRROR_MODE_ON_FRONT_ONLY. कैमरे की झलक के साथ अलाइन करने के लिए, Google आपको MIROR_MODE_ON_FRONT_ONLY का इस्तेमाल करने का सुझाव देता है. इसका मतलब है कि रियर कैमरे के लिए मिरर मोड चालू नहीं है, लेकिन फ़्रंट कैमरे के लिए चालू है. MirrorMode के बारे में ज़्यादा जानने के लिए, MirrorMode constants देखें.

इस कोड स्निपेट में, MIRROR_MODE_ON_FRONT_ONLY का इस्तेमाल करके VideoCapture.Builder.setMirrorMode() को कॉल करने का तरीका बताया गया है. ज़्यादा जानकारी के लिए, setMirrorMode() देखें.

val recorder = Recorder.Builder().build()

val videoCapture = VideoCapture.Builder(recorder)
    .setMirrorMode(MIRROR_MODE_ON_FRONT_ONLY)
    .build()

useCases.add(videoCapture)

डाइनैमिक रेंज (एचडीआर वीडियो)

CameraX, 10-बिट हाई डाइनैमिक रेंज (एचडीआर) वीडियो रिकॉर्डिंग की सुविधा देता है. जैसे, DynamicRange का इस्तेमाल करके HLG10, HDR10, HDR10+ या Dolby Vision.

एचडीआर वीडियो रिकॉर्डिंग की सुविधा इस्तेमाल करने के लिए, यह तरीका अपनाएं:

  1. VideoCapabilities.getSupportedDynamicRanges() का इस्तेमाल करके, कैमरे के साथ काम करने वाली डाइनैमिक रेंज के बारे में क्वेरी करें.
  2. ज़रूरी नहीं: अगर आपने कस्टम QualitySelector कॉन्फ़िगर किया है, तो getSupportedQualities(DynamicRange) का इस्तेमाल करके देखें कि उस डाइनैमिक रेंज के लिए कौनसी क्वालिटी काम करती हैं.
  3. setDynamicRange() की मदद से, VideoCapture.Builder को कॉन्फ़िगर करें.

यहां दिए गए उदाहरण में, कैमरे के साथ काम करने पर HLG 10-बिट एचडीआर रिकॉर्डिंग चालू करने का तरीका बताया गया है:

Kotlin

val videoCapabilities = Recorder.getVideoCapabilities(cameraInfo)
val supportedHdrRanges = videoCapabilities.supportedDynamicRanges
    .filter { it != DynamicRange.SDR }

val recorder = Recorder.Builder().build()
val videoCapture = VideoCapture.Builder(recorder)
    .apply {
        if (supportedHdrRanges.contains(DynamicRange.HLG_10_BIT)) {
            setDynamicRange(DynamicRange.HLG_10_BIT)
        }
    }
    .build()

Java

VideoCapabilities videoCapabilities = Recorder.getVideoCapabilities(cameraInfo);
Set<DynamicRange> supportedRanges = videoCapabilities.getSupportedDynamicRanges();

Recorder recorder = new Recorder.Builder().build();
VideoCapture.Builder<Recorder> builder = new VideoCapture.Builder<>(recorder);
if (supportedRanges.contains(DynamicRange.HLG_10_BIT)) {
    builder.setDynamicRange(DynamicRange.HLG_10_BIT);
}
VideoCapture<Recorder> videoCapture = builder.build();

वीडियो स्टेबलाइज़ेशन

CameraX में वीडियो स्टेबलाइज़ेशन की सुविधा काम करती है. इससे वीडियो रिकॉर्डिंग के दौरान, हाथ से रिकॉर्ड करने पर होने वाले शेक और जिटर को कम किया जा सकता है.

वीडियो स्टेबलाइज़ेशन की सुविधा चालू करने के लिए, यह तरीका अपनाएं:

  1. देखें कि कैमरा डिवाइस, VideoCapabilities.isStabilizationSupported() का इस्तेमाल करके स्टेबलाइज़ेशन की सुविधा के साथ काम करता है या नहीं.
  2. setVideoStabilizationEnabled(true) का इस्तेमाल करके, इसे VideoCapture.Builder पर चालू करें.

यहां दिए गए उदाहरण में, कैमरे में वीडियो स्टेबलाइज़ेशन की सुविधा होने पर, उसे चालू किया गया है:

Kotlin

val videoCapabilities = Recorder.getVideoCapabilities(cameraInfo)
val videoCapture = VideoCapture.Builder(recorder)
    .setVideoStabilizationEnabled(videoCapabilities.isStabilizationSupported)
    .build()

Java

VideoCapabilities videoCapabilities = Recorder.getVideoCapabilities(cameraInfo);
VideoCapture<Recorder> videoCapture = new VideoCapture.Builder<>(recorder)
    .setVideoStabilizationEnabled(videoCapabilities.isStabilizationSupported())
    .build();

चल रही रिकॉर्डिंग को कंट्रोल करना

इन तरीकों का इस्तेमाल करके, चल रहे Recording को रोका जा सकता है, फिर से शुरू किया जा सकता है, और बंद किया जा सकता है:

  • pause पर टैप करें.
  • resume() रुकी हुई रिकॉर्डिंग को फिर से शुरू करने के लिए.
  • stop() रिकॉर्डिंग पूरी करने और उससे जुड़े सभी ऑब्जेक्ट को फ़्लश करने के लिए.
  • mute() मौजूदा रिकॉर्डिंग को म्यूट या अनम्यूट करने के लिए.

ध्यान दें कि stop() को कॉल करके Recording को खत्म किया जा सकता है. इससे कोई फ़र्क़ नहीं पड़ता कि रिकॉर्डिंग रोकी गई है या चालू है.

अगर आपने PendingRecording.start() के साथ EventListener रजिस्टर किया है, तो Recording, VideoRecordEvent का इस्तेमाल करके कम्यूनिकेट करता है.

  • VideoRecordEvent.EVENT_TYPE_STATUS का इस्तेमाल, रिकॉर्डिंग के आंकड़े रिकॉर्ड करने के लिए किया जाता है. जैसे, मौजूदा फ़ाइल का साइज़ और रिकॉर्ड की गई समयावधि.
  • VideoRecordEvent.EVENT_TYPE_FINALIZE का इस्तेमाल, रिकॉर्डिंग के नतीजे के लिए किया जाता है. इसमें फ़ाइनल फ़ाइल के यूआरआई के साथ-साथ, उससे जुड़ी गड़बड़ियों की जानकारी भी शामिल होती है.

जब आपके ऐप्लिकेशन को EVENT_TYPE_FINALIZE मिलता है, तो इसका मतलब है कि रिकॉर्डिंग सेशन पूरा हो गया है. इसके बाद, OutputOptions में बताई गई जगह से, कैप्चर किए गए वीडियो को ऐक्सेस किया जा सकता है.

रीयल-टाइम में ऑडियो का ऐंप्लीट्यूड और स्थिति

रिकॉर्डिंग के दौरान, VideoRecordEvent.Status इवेंट AudioStats के ज़रिए रीयल-टाइम में ऑडियो के आंकड़े उपलब्ध कराते हैं:

  • AudioStats.getAudioAmplitude(), मौजूदा ऑडियो का पीक ऐम्प्लिट्यूड दिखाता है. यह 0.0 से 1.0 के बीच होता है. इस वैल्यू का इस्तेमाल, यूज़र इंटरफ़ेस (यूआई) मीटर या ऑडियो वेवफ़ॉर्म विज़ुअलाइज़र को चलाने के लिए किया जा सकता है.
  • AudioStats.getAudioState() से ऑडियो स्ट्रीम की मौजूदा स्थिति का पता चलता है. जैसे, AUDIO_STATE_ACTIVE, AUDIO_STATE_MUTED या AUDIO_STATE_SOURCE_SILENCED.

इस उदाहरण में, स्टेटस इवेंट से ऑडियो एम्प्लिट्यूड को रीड किया गया है:

Kotlin

when (event) {
    is VideoRecordEvent.Status -> {
        val audioStats = event.recordingStats.audioStats
        if (audioStats.hasAudio()) {
            val amplitude = audioStats.audioAmplitude
            updateAudioWaveform(amplitude)
        }
    }
    // ...
}

Java

if (event instanceof VideoRecordEvent.Status) {
    VideoRecordEvent.Status status = (VideoRecordEvent.Status) event;
    AudioStats audioStats = status.getRecordingStats().getAudioStats();
    if (audioStats.hasAudio()) {
        double amplitude = audioStats.getAudioAmplitude();
        updateAudioWaveform(amplitude);
    }
}

हाई-स्पीड और स्लो-मोशन वीडियो

CameraX, 120, 240 या 480 एफ़पीएस जैसी हाई-स्पीड वीडियो रिकॉर्डिंग की सुविधा देता है. इससे दो अलग-अलग तरह के इस्तेमाल के उदाहरण मिलते हैं:

  • ज़्यादा फ़्रेम रेट वाला वीडियो (प्लेयर से मैनेज किया जाने वाला स्लो मोशन): CameraX, ज़्यादा फ़्रेम रेट (उदाहरण के लिए, 120 एफ़पीएस) पर फ़्रेम कैप्चर और सेव करता है. वीडियो प्लेयर, वीडियो चलाने की स्पीड को कंट्रोल करता है. इससे उपयोगकर्ता, सामान्य स्पीड और स्लो मोशन के बीच टॉगल कर सकते हैं या फ़्रेम-दर-फ़्रेम विश्लेषण कर सकते हैं.
  • चलाने के लिए तैयार स्लो-मोशन वीडियो: CameraX, हाई-स्पीड स्ट्रीम को प्रोसेस करता है और अडजस्ट किए गए फ़्रेम टाइमस्टैंप के साथ स्टैंडर्ड 30 एफ़पीएस वाली वीडियो फ़ाइल आउटपुट करता है. स्लो-मोशन इफ़ेक्ट, वीडियो में "पहले से मौजूद" होता है. इसलिए, वीडियो किसी भी स्टैंडर्ड वीडियो प्‍लेयर में अपने-आप स्लो मोशन में चलता है. इसके लिए, किसी खास वीडियो प्‍लेयर की ज़रूरत नहीं होती. उदाहरण के लिए, 120 एफ़पीएस पर कैप्चर किए गए वीडियो को 30 एफ़पीएस पर चलाने से, 1/4x स्लो-मोशन वीडियो बनता है.

हाई-स्पीड की सुविधाएं देखें

हाई-स्पीड वीडियो कैप्चर करने के लिए, हार्डवेयर सपोर्ट और डिवाइस बनाने वाली कंपनियों की ओर से दी गई CamcorderProfile परिभाषाओं की ज़रूरत होती है. जैसे, CamcorderProfile.QUALITY_HIGH_SPEED_1080P या QUALITY_HIGH_SPEED_720P.

हाई-स्पीड रिकॉर्डिंग को कॉन्फ़िगर करने से पहले, Recorder.getHighSpeedVideoCapabilities(CameraInfo) का इस्तेमाल करके हाई-स्पीड रिकॉर्डिंग की सुविधाओं के बारे में क्वेरी करें:

Kotlin

val highSpeedCapabilities = Recorder.getHighSpeedVideoCapabilities(cameraInfo)
if (highSpeedCapabilities == null) {
    // Camera does not support high-speed video capture
    return
}
val supportedQualities = highSpeedCapabilities.getSupportedQualities(DynamicRange.SDR)

Java

VideoCapabilities highSpeedCapabilities = Recorder.getHighSpeedVideoCapabilities(cameraInfo);
if (highSpeedCapabilities == null) {
    // Camera does not support high-speed video capture
    return;
}
List<Quality> supportedQualities = highSpeedCapabilities.getSupportedQualities(DynamicRange.SDR);

HighSpeedVideoSessionConfig को कॉन्फ़िगर करना

हाई-स्पीड कैप्चर का इस्तेमाल करने के लिए, HighSpeedVideoSessionConfig में VideoCapture और Preview के इस्तेमाल के उदाहरणों को जोड़ें. सेशन को कॉन्फ़िगर करने के लिए, यह तरीका अपनाएं:

  1. VideoCapture और Preview के इस्तेमाल का उदाहरण बनाएं.
  2. VideoCapture इस्तेमाल के उदाहरण के साथ HighSpeedVideoSessionConfig.Builder को शुरू करें और Preview को अटैच करें.
  3. CameraInfo.getSupportedFrameRateRanges(SessionConfig) का इस्तेमाल करके, फ़्रेम रेट की रेंज के बारे में क्वेरी करें और चुनी गई रेंज सेट करें.
  4. हाई-फ़्रेम-रेट वाले वीडियो या स्लो-मोशन वीडियो में से कोई एक चुनें:
    • हाई-फ़्रेम-रेट वाला वीडियो बनाने के लिए, setSlowMotionEnabled(false) (डिफ़ॉल्ट) को चुनें.
    • स्लो-मोशन वीडियो बनाने के लिए, जो तुरंत चलाया जा सके, setSlowMotionEnabled(true) को कॉल करें.
  5. cameraProvider.bindToLifecycle() का इस्तेमाल करके, सेशन कॉन्फ़िगरेशन को बाइंड करें.

यहां दिए गए उदाहरण में, स्लो-मोशन सेशन को कॉन्फ़िगर और बाइंड किया गया है. यह सेशन, वीडियो चलाने के लिए तैयार है:

Kotlin

val preview = Preview.Builder().build()
val recorder = Recorder.Builder()
    .setQualitySelector(QualitySelector.from(supportedQualities.first()))
    .build()
val videoCapture = VideoCapture.withOutput(recorder)

// Build HighSpeedVideoSessionConfig
val sessionConfigBuilder = HighSpeedVideoSessionConfig.Builder(videoCapture)
    .setPreview(preview)
    // Enable automatic slow-motion playback at 30 fps
    .setSlowMotionEnabled(true)

// Query and set a supported high-speed frame rate range (such as 120 or 240 fps).
// The set is non-empty because getHighSpeedVideoCapabilities() returned non-null earlier.
val supportedFpsRanges = cameraInfo.getSupportedFrameRateRanges(sessionConfigBuilder.build())
sessionConfigBuilder.setFrameRateRange(supportedFpsRanges.first())

val sessionConfig = sessionConfigBuilder.build()

// Bind session config to lifecycle
cameraProvider.bindToLifecycle(
    lifecycleOwner,
    CameraSelector.DEFAULT_BACK_CAMERA,
    sessionConfig
)

Java

Preview preview = new Preview.Builder().build();
Recorder recorder = new Recorder.Builder()
    .setQualitySelector(QualitySelector.from(supportedQualities.get(0)))
    .build();
VideoCapture<Recorder> videoCapture = VideoCapture.withOutput(recorder);

HighSpeedVideoSessionConfig.Builder sessionConfigBuilder =
    new HighSpeedVideoSessionConfig.Builder(videoCapture)
        .setPreview(preview)
        .setSlowMotionEnabled(true);

// The set is non-empty because getHighSpeedVideoCapabilities() returned non-null earlier.
Set<Range<Integer>> supportedFpsRanges =
    cameraInfo.getSupportedFrameRateRanges(sessionConfigBuilder.build());
sessionConfigBuilder.setFrameRateRange(supportedFpsRanges.iterator().next());

HighSpeedVideoSessionConfig sessionConfig = sessionConfigBuilder.build();

cameraProvider.bindToLifecycle(
    lifecycleOwner,
    CameraSelector.DEFAULT_BACK_CAMERA,
    sessionConfig
);

हाई-स्पीड सेशन को आसानी से कॉन्फ़िगर करने के लिए, CameraX 1.7.0-alpha02 में पेश किए गए Kotlin DSL का भी इस्तेमाल किया जा सकता है:

val sessionConfig = highSpeedVideoSessionConfig(videoCapture) {
    this.preview = preview
    isSlowMotionEnabled = true
    frameRateRange = supportedFpsRanges.first()
}
cameraProvider.bindToLifecycle(
    lifecycleOwner,
    CameraSelector.DEFAULT_BACK_CAMERA,
    sessionConfig
)

हाई-स्पीड या स्लो-मोशन वीडियो रिकॉर्ड करना

HighSpeedVideoSessionConfig को बाइंड करने के बाद, VideoCapture का इस्तेमाल करके रिकॉर्डिंग शुरू करें. यह प्रोसेस, स्टैंडर्ड वीडियो रिकॉर्डिंग की तरह ही है:

Kotlin

val recording = videoCapture.output
    .prepareRecording(context, mediaStoreOutput)
    .withAudioEnabled()
    .start(ContextCompat.getMainExecutor(context)) { event ->
        when (event) {
            is VideoRecordEvent.Start -> Log.d(TAG, "Recording started")
            is VideoRecordEvent.Finalize -> {
                if (!event.hasError()) {
                    Log.d(TAG, "Video saved: ${event.outputResults.outputUri}")
                }
            }
        }
    }

Java

Recording recording = videoCapture.getOutput()
    .prepareRecording(context, mediaStoreOutput)
    .withAudioEnabled()
    .start(ContextCompat.getMainExecutor(context), event -> {
        if (event instanceof VideoRecordEvent.Start) {
            Log.d(TAG, "Recording started");
        } else if (event instanceof VideoRecordEvent.Finalize) {
            VideoRecordEvent.Finalize finalize = (VideoRecordEvent.Finalize) event;
            if (!finalize.hasError()) {
                Log.d(TAG, "Video saved: " + finalize.getOutputResults().getOutputUri());
            }
        }
    });

अन्य संसाधन

CameraX के बारे में ज़्यादा जानने के लिए, यहां दिए गए अन्य संसाधन देखें: