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

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

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

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

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

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

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

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

Videoकैप्चर एपीआई की खास जानकारी

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

Video Capture API में ये ऑब्जेक्ट शामिल होते हैं, जो एक-दूसरे से बातचीत करते हैं ऐप्स के साथ:

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

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

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

लेजेंड:

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

एपीआई की ज़्यादा जानकारी वाली सूची, सोर्स कोड के अंदर मौजूदा.txt में मौजूद है.

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

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

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

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

Videoकैप्चर बाइंड करें

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

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

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

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

  • 4K अल्ट्रा एचडी वीडियो (2160 पिक्सल) के लिए Quality.UHD
  • फ़ुल एचडी वीडियो साइज़ (1080 पिक्सल) के लिए Quality.FHD
  • एचडी वीडियो साइज़ (720 पिक्सल) के लिए Quality.HD
  • एसडी वीडियो (480p) के लिए Quality.SD

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

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

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

  • fromOrderedList() का इस्तेमाल करके अपनी समस्या को हल करने के लिए कुछ और इस्तेमाल करने के लिए फ़ॉलबैक रणनीति शामिल होगी. पसंदीदा रिज़ॉल्यूशन काम करता है.

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

    val qualitySelector = QualitySelector.fromOrderedList(
         listOf(Quality.UHD, Quality.FHD, Quality.HD, Quality.SD),
         FallbackStrategy.lowerQualityOrHigherThan(Quality.SD))

  • कैमरे की क्षमताओं के बारे में क्वेरी करें और उसके लिए उपलब्ध विकल्पों में से किसी एक को चुनें QualitySelector::from() का इस्तेमाल करके रिज़ॉल्यूशन:

    val cameraInfo = cameraProvider.availableCameraInfos.filter {
    Camera2CameraInfo
    .from(it)
    .getCameraCharacteristic(CameraCharacteristics.LENS\_FACING) == CameraMetadata.LENS_FACING_BACK
}

val supportedQualities = QualitySelector.getSupportedQualities(cameraInfo[0])
val filteredQualities = arrayListOf (Quality.UHD, Quality.FHD, Quality.HD, Quality.SD)
                       .filter { supportedQualities.contains(it) }

// Use a simple ListView with the id of simple_quality_list_view
viewBinding.simpleQualityListView.apply {
    adapter = ArrayAdapter(context,
                           android.R.layout.simple_list_item_1,
                           filteredQualities.map { it.qualityToString() })

    // Set up the user interaction to manually show or hide the system UI.
    setOnItemClickListener { _, _, position, _ ->
        // Inside View.OnClickListener,
        // convert Quality.* constant to QualitySelector
        val qualitySelector = QualitySelector.from(filteredQualities[position])

        // Create a new Recorder/VideoCapture for the new quality
        // and bind to lifecycle
        val recorder = Recorder.Builder()
            .setQualitySelector(qualitySelector).build()

         // ...
    }
}

// A helper function to translate Quality to a string
fun Quality.qualityToString() : String {
    return when (this) {
        Quality.UHD -> "UHD"
        Quality.FHD -> "FHD"
        Quality.HD -> "HD"
        Quality.SD -> "SD"
        else -> throw IllegalArgumentException()
    }
}

    ध्यान दें कि यहां से लौटाए गए फ़ंक्शन की क्षमता QualitySelector.getSupportedQualities() VideoCapture के इस्तेमाल के उदाहरण या इसके लिए, 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, सिस्टम के हिसाब से सबसे सही फ़ॉर्मैट चुनता है. सबसे ज़्यादा सामान्य वीडियो कोडेक है H.264 AVC) कंटेनर फ़ॉर्मैट MPEG-4.

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

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

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

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

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

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

  • स्क्रीनशॉट में कैप्चर करने के लिए FileDescriptorOutputOptions FileDescriptor.
  • File में कैप्चर करने के लिए FileOutputOptions.
  • स्क्रीनशॉट में कैप्चर करने के लिए MediaStoreOutputOptions MediaStore.

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

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

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

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

रिकॉर्डिंग शुरू करने के लिए, 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)

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

मिररमोड के तीन विकल्प हैं: MIRROR_Mode_OFF, MIRROR_mode_ON, और MIRROR_Mode_ON_FRONT_ONLY. के साथ अलाइन करने के लिए कैमरा प्रीव्यू, Google MIROR_Mode_ON_FRONT_ONLY का इस्तेमाल करने का सुझाव देता है, जिसका मतलब है वह पीछे के कैमरे के लिए डुप्लीकेट वर्शन बनाने की सुविधा चालू नहीं है, लेकिन सामने के हिस्से के लिए यह सुविधा चालू है कैमरा. मिररमोड के बारे में ज़्यादा जानकारी के लिए, यहां देखें MirrorMode constants.

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

Kotlin

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

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

useCases.add(videoCapture);

Java

Recorder.Builder builder = new Recorder.Builder();
if (mVideoQuality != QUALITY_AUTO) {
    builder.setQualitySelector(
        QualitySelector.from(mVideoQuality));
}
  VideoCapture<Recorder> videoCapture = new VideoCapture.Builder<>(builder.build())
      .setMirrorMode(MIRROR_MODE_ON_FRONT_ONLY)
      .build();
    useCases.add(videoCapture);

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

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

  • pause ताकि मौजूदा चालू रिकॉर्डिंग को रोका जा सके.
  • resume() ताकि रोकी गई हो चुकी रिकॉर्डिंग को फिर से शुरू किया जा सके.
  • stop() का इस्तेमाल करना होगा.
  • mute() का उपयोग करें.

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

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

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

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

अन्य संसाधन

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