कैप्चर करने वाला सिस्टम, आम तौर पर वीडियो और ऑडियो स्ट्रीम रिकॉर्ड करता है, उन्हें कंप्रेस करता है, और दोनों स्ट्रीम को मिक्स करता है. इसके बाद, वह इस स्ट्रीम को डिस्क में सेव करता है.
CameraX में, वीडियो कैप्चर करने के लिए
VideoCapture
इस्तेमाल के उदाहरण का इस्तेमाल किया जाता है:
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का इस्तेमाल करना होगा.
तीसरी इमेज में, इन ऑब्जेक्ट के बीच के संबंध दिखाए गए हैं:
लेजेंड:
QualitySelectorकी मदद से,Recorderबनाएं.Recorderको इनमें से किसी एकOutputOptionsके साथ कॉन्फ़िगर करें.- अगर ज़रूरी हो, तो
withAudioEnabled()का इस्तेमाल करके ऑडियो चालू करें. - रिकॉर्डिंग शुरू करने के लिए,
VideoRecordEventलिसनर के साथstart()को कॉल करें. - रिकॉर्डिंग को कंट्रोल करने के लिए,
Recordingपरpause()/resume()/stop()का इस्तेमाल करें. - अपने इवेंट लिसनर में
VideoRecordEventsका जवाब दें.
एपीआई की पूरी सूची, सोर्स कोड में current.txt में मौजूद है.
VideoCapture API का इस्तेमाल करना
अपने ऐप्लिकेशन में CameraX VideoCapture इस्तेमाल के उदाहरण को इंटिग्रेट करने के लिए, यह तरीका अपनाएं:
VideoCaptureको बाइंड करें.- रिकॉर्डिंग की तैयारी करना और उसे कॉन्फ़िगर करना.
- रनटाइम रिकॉर्डिंग शुरू और कंट्रोल करें.
यहां दिए गए सेक्शन में बताया गया है कि रिकॉर्डिंग सेशन को शुरू से आखिर तक पूरा करने के लिए, हर चरण में क्या किया जा सकता है.
वीडियो कैप्चर को बाइंड करें
VideoCapture इस्तेमाल के उदाहरण को बाइंड करने के लिए, यह तरीका अपनाएं:
Recorderऑब्जेक्ट बनाएं.VideoCaptureऑब्जेक्ट बनाएं.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 से, ऐप्लिकेशन वीडियो और ऑडियो कैप्चर करने के लिए रिकॉर्डिंग ऑब्जेक्ट बना सकता है. ऐप्लिकेशन, रिकॉर्डिंग बनाने के लिए
ये काम करते हैं:
OutputOptionsकोprepareRecording()के साथ कॉन्फ़िगर करें.- (ज़रूरी नहीं) ऑडियो रिकॉर्डिंग की सुविधा चालू करें.
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.
एचडीआर वीडियो रिकॉर्डिंग की सुविधा इस्तेमाल करने के लिए, यह तरीका अपनाएं:
VideoCapabilities.getSupportedDynamicRanges()का इस्तेमाल करके, कैमरे के साथ काम करने वाली डाइनैमिक रेंज के बारे में क्वेरी करें.- ज़रूरी नहीं: अगर आपने कस्टम
QualitySelectorकॉन्फ़िगर किया है, तोgetSupportedQualities(DynamicRange)का इस्तेमाल करके देखें कि उस डाइनैमिक रेंज के लिए कौनसी क्वालिटी काम करती हैं. 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 में वीडियो स्टेबलाइज़ेशन की सुविधा काम करती है. इससे वीडियो रिकॉर्डिंग के दौरान, हाथ से रिकॉर्ड करने पर होने वाले शेक और जिटर को कम किया जा सकता है.
वीडियो स्टेबलाइज़ेशन की सुविधा चालू करने के लिए, यह तरीका अपनाएं:
- देखें कि कैमरा डिवाइस,
VideoCapabilities.isStabilizationSupported()का इस्तेमाल करके स्टेबलाइज़ेशन की सुविधा के साथ काम करता है या नहीं. 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 के इस्तेमाल के उदाहरणों को जोड़ें. सेशन को कॉन्फ़िगर करने के लिए, यह तरीका अपनाएं:
VideoCaptureऔरPreviewके इस्तेमाल का उदाहरण बनाएं.VideoCaptureइस्तेमाल के उदाहरण के साथHighSpeedVideoSessionConfig.Builderको शुरू करें औरPreviewको अटैच करें.CameraInfo.getSupportedFrameRateRanges(SessionConfig)का इस्तेमाल करके, फ़्रेम रेट की रेंज के बारे में क्वेरी करें और चुनी गई रेंज सेट करें.- हाई-फ़्रेम-रेट वाले वीडियो या स्लो-मोशन वीडियो में से कोई एक चुनें:
- हाई-फ़्रेम-रेट वाला वीडियो बनाने के लिए,
setSlowMotionEnabled(false)(डिफ़ॉल्ट) को चुनें. - स्लो-मोशन वीडियो बनाने के लिए, जो तुरंत चलाया जा सके,
setSlowMotionEnabled(true)को कॉल करें.
- हाई-फ़्रेम-रेट वाला वीडियो बनाने के लिए,
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 के बारे में ज़्यादा जानने के लिए, यहां दिए गए अन्य संसाधन देखें:
- CameraX कोडलैब का इस्तेमाल शुरू करना
- CameraX का आधिकारिक सैंपल ऐप्लिकेशन
- CameraX Video Capture API की नई सूची
- CameraX के रिलीज़ नोट
- CameraX का सोर्स कोड
- CameraX 1.5 की मदद से, हाई-स्पीड कैप्चर और स्लो-मोशन वीडियो रिकॉर्ड करने की सुविधा