पेश है CameraX 1.5: बेहतरीन वीडियो रिकॉर्डिंग और प्रो-लेवल की इमेज कैप्चर करने की सुविधा

CameraX की टीम को यह बताते हुए खुशी हो रही है कि वर्शन 1.5 लॉन्च कर दिया गया है! इस नए अपडेट का मकसद, आपको प्रोफ़ेशनल लेवल की सुविधाएं उपलब्ध कराना है. साथ ही, कैमरे के सेशन को कॉन्फ़िगर करना पहले से ज़्यादा आसान बनाना है.

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

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

इन सुविधाओं को बेहतर बनाने के लिए, नया SessionConfig API उपलब्ध कराया गया है. इससे कैमरे को सेट अप और फिर से कॉन्फ़िगर करना आसान हो जाता है. चलिए, अब इन शानदार नई सुविधाओं के बारे में ज़्यादा जानें.

बेहतरीन वीडियो रिकॉर्डिंग: तेज़ रफ़्तार और सुविधाओं का कॉम्बिनेशन

CameraX 1.5 में वीडियो से जुड़ी सुविधाओं को काफ़ी हद तक बेहतर बनाया गया है. इससे, वीडियो रिकॉर्डिंग को ज़्यादा क्रिएटिव और बेहतर तरीके से किया जा सकता है.

स्लो मोशन और ज़्यादा फ़्रेम रेट वाला वीडियो

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

अगर आपको VideoCapture एपीआई के बारे में जानकारी है, तो इसे लागू करना आसान है.

1. हाई-स्पीड वीडियो रिकॉर्डिंग की सुविधा की उपलब्धता की जांच करना: नए Recorder.getHighSpeedVideoCapabilities() तरीके का इस्तेमाल करके, यह पता लगाएं कि डिवाइस पर यह सुविधा काम करती है या नहीं.

val cameraInfo = cameraProvider.getCameraInfo(cameraSelector)

val highSpeedCapabilities = Recorder.getHighSpeedVideoCapabilities(cameraInfo)

if (highSpeedCapabilities == null) {
    // This camera device does not support high-speed video.
    return
}

2. इस्तेमाल के उदाहरण को कॉन्फ़िगर और बाइंड करें: videoCapabilities (इसमें वीडियो की क्वालिटी से जुड़ी जानकारी होती है) का इस्तेमाल करके, HighSpeedVideoSessionConfig बनाएं. इसके बाद, आपको cameraInfo.getSupportedFrameRateRanges() की मदद से, काम करने वाले फ़्रेम रेट की रेंज के बारे में क्वेरी करनी होगी और अपनी पसंद की रेंज सेट करनी होगी. स्लो मोशन में वीडियो रिकॉर्ड करने के लिए, setSlowMotionEnabled(true) को लागू करें. ऐसा न करने पर, हाई-फ़्रेम-रेट वाले वीडियो रिकॉर्ड होंगे. आखिरी चरण में, वीडियो रिकॉर्ड करने के लिए सामान्य Recorder.prepareRecording().start() का इस्तेमाल करें.

val preview = Preview.Builder().build()
val quality = highSpeedCapabilities
        .getSupportedQualities(DynamicRange.SDR).first()

val recorder = Recorder.Builder()
      .setQualitySelector(QualitySelector.from(quality)))
      .build()

val videoCapture = VideoCapture.withOutput(recorder)

val frameRateRange = cameraInfo.getSupportedFrameRateRanges(      
       HighSpeedVideoSessionConfig(videoCapture, preview)
).first()

val sessionConfig = HighSpeedVideoSessionConfig(
    videoCapture, 
    preview, 
    frameRateRange = frameRateRange, 
    // Set true for slow-motion playback, or false for high-frame-rate
    isSlowMotionEnabled = true
)

cameraProvider.bindToLifecycle(
     lifecycleOwner, cameraSelector, sessionConfig)

// Start recording slow motion videos. 
val recording = recorder.prepareRecording(context, outputOption)
      .start(executor, {})

यह किन सुविधाओं के साथ काम करती है और इसकी सीमाएं

तेज़ गति से रिकॉर्डिंग करने के लिए, CameraConstrainedHighSpeedCaptureSession और CamcorderProfile की सुविधा होनी चाहिए. हमेशा क्षमता की जांच करें और सिर्फ़ उन डिवाइसों पर हाई-स्पीड रिकॉर्डिंग की सुविधा चालू करें जिन पर यह सुविधा काम करती है. इससे उपयोगकर्ताओं को खराब अनुभव नहीं मिलेगा. फ़िलहाल, यह सुविधा ज़्यादातर Pixel डिवाइसों के रियर कैमरे और अन्य मैन्युफ़ैक्चरर के चुनिंदा डिवाइसों पर उपलब्ध है.

ज़्यादा जानकारी के लिए, ब्लॉग पोस्ट देखें.

भरोसे के साथ सुविधाओं को जोड़ें: Feature Group API

CameraX 1.5 में Feature Group API उपलब्ध कराया गया है. इससे यह अनुमान लगाने की ज़रूरत नहीं पड़ती कि कोई सुविधा काम करेगी या नहीं. Android 15 में, सुविधाओं को एक साथ इस्तेमाल करने की क्वेरी से जुड़े एपीआई की मदद से, अब एक साथ कई सुविधाएं चालू की जा सकती हैं. इससे कैमरे का सेशन बिना किसी रुकावट के चलता है. फ़िलहाल, फ़ीचर ग्रुप में ये सुविधाएं काम करती हैं: एचडीआर (एचएलजी), 60 फ़्रेम प्रति सेकंड, झलक की स्थिरता, और अल्ट्रा एचडीआर. उदाहरण के लिए, Pixel 10 और Galaxy S25 सीरीज़ पर एचडीआर, 60 एफ़पीएस, और झलक को स्टेबलाइज़ करने की सुविधा को एक साथ चालू किया जा सकता है. आने वाले समय में, इसमें 4K रिकॉर्डिंग और अल्ट्रा-वाइड ज़ूम जैसी सुविधाएं जोड़ी जाएंगी. 

सुविधा ग्रुप एपीआई, दो ज़रूरी कामों में मदद करता है:

इस्तेमाल का पहला उदाहरण: सबसे अच्छी क्वालिटी को प्राथमिकता देना

अगर आपको सुविधाओं के सबसे अच्छे कॉम्बिनेशन का इस्तेमाल करके डेटा कैप्चर करना है, तो प्राथमिकता के हिसाब से सुविधाओं की सूची दी जा सकती है. CameraX, इन सुविधाओं को क्रम से चालू करने की कोशिश करेगा. साथ ही, वह पहले ऐसे कॉम्बिनेशन को चुनेगा जिसे डिवाइस पूरी तरह से सपोर्ट करता है.

val sessionConfig = SessionConfig(
    useCases = listOf(preview, videoCapture),
    preferredFeatureGroup = listOf(
        GroupableFeature.HDR_HLG10,
        GroupableFeature.FPS_60,
        GroupableFeature.PREVIEW_STABILIZATION
    )
).apply {
    // (Optional) Get a callback with the enabled features to update your UI.
    setFeatureSelectionListener { selectedFeatures ->
        updateUiIndicators(selectedFeatures)
    }
}
processCameraProvider.bindToLifecycle(activity, cameraSelector, sessionConfig)

इस उदाहरण में, CameraX इन सुविधाओं को इस क्रम में चालू करने की कोशिश करता है:

1. एचडीआर + 60 FPS + झलक को स्टेबलाइज़ करने की सुविधा
2. एचडीआर + 60 FPS
3. एचडीआर + झलक को स्टेबलाइज़ करने की सुविधा
4. एचडीआर
5. 60 FPS + झलक को स्टेबलाइज़ करने की सुविधा
6. 60 FPS (फ़्रेम प्रति सेकंड)
7. प्रीव्यू स्टैबिलाइज़ेशन
8. कोई नहीं

इस्तेमाल का दूसरा उदाहरण: इस्तेमाल करने वाले लोगों के लिए उपलब्ध सेटिंग का यूज़र इंटरफ़ेस (यूआई) बनाना

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

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

fun disableFeatureIfNotSuported(
   enabledFeatures: Set<GroupableFeature>,     
   featureToCheck:GroupableFeature
) {
 val sessionConfig = SessionConfig(
     useCases = useCases,
     requiredFeatureGroup = enabledFeatures + featureToCheck
 )
 val isSupported = cameraInfo.isFeatureGroupSupported(sessionConfig)

 if (!isSupported) {
     // disable the toggle for featureToCheck
 }
}

ज़्यादा जानकारी के लिए, कृपया सुविधा ग्रुप से जुड़ी ब्लॉग पोस्ट पढ़ें. 

वीडियो को बेहतर बनाने की अन्य सुविधाएं

• एक साथ कई कैमरे इस्तेमाल करने की सुविधा को बेहतर बनाया गया है: CameraX 1.5.1 की मदद से, अब नॉन-कंपोज़िशन मोड में हर SingleCameraConfig के लिए, Preview + ImageCapture + VideoCapture के इस्तेमाल के उदाहरणों को एक साथ बाइंड किया जा सकता है. इसके अलावा, लिखने का मोड (CompositionSettings के साथ इस्तेमाल के उदाहरण) में, अब CameraEffect सेट किया जा सकता है. यह , कंपोज़िशन के फ़ाइनल नतीजे पर लागू होता है.
• डाइनैमिक म्यूटिंग: अब PendingRecording.withAudioEnabled(boolean initialMuted) का इस्तेमाल करके, म्यूट मोड में रिकॉर्डिंग शुरू की जा सकती है. साथ ही, उपयोगकर्ता को Recording.mute(boolean muted) का इस्तेमाल करके, बाद में अनम्यूट करने की अनुमति दी जा सकती है.
• स्टोरेज कम होने की समस्या को बेहतर तरीके से हैंडल करना: CameraX अब VideoRecordEvent.Finalize.ERROR_INSUFFICIENT_STORAGE गड़बड़ी को भरोसेमंद तरीके से भेजता है. इससे आपका ऐप्लिकेशन, स्टोरेज कम होने की स्थितियों को आसानी से हैंडल कर पाता है और उपयोगकर्ता को इसकी सूचना दे पाता है.
• कम रोशनी में वीडियो को बेहतर बनाने की सुविधा: इस सुविधा के साथ काम करने वाले डिवाइसों (जैसे, Pixel 10 सीरीज़) पर, CameraControl.enableLowLightBoostAsync को चालू किया जा सकता है. इससे कम रोशनी वाली जगहों पर, वीडियो की झलक और वीडियो स्ट्रीम की रोशनी अपने-आप बढ़ जाती है.

प्रोफ़ेशनल-ग्रेड इमेज कैप्चर करने की सुविधा

CameraX 1.5 में, ImageCapture के लिए बड़े अपग्रेड किए गए हैं. ये अपग्रेड उन डेवलपर के लिए हैं जिन्हें बेहतरीन क्वालिटी और ज़्यादा से ज़्यादा फ़्लेक्सिबिलिटी चाहिए.

DNG (RAW) फ़ॉर्मैट में फ़ोटो कैप्चर करके, क्रिएटिविटी को बढ़ावा देना

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

val capabilities = ImageCapture.getImageCaptureCapabilities(cameraInfo)
val imageCapture = ImageCapture.Builder().apply {
    if (capabilities.supportedOutputFormats
             .contains(OUTPUT_FORMAT_RAW_JPEG)) {
        // Capture both RAW and JPEG formats.
        setOutputFormat(OUTPUT_FORMAT_RAW_JPEG)
    }
}.build()
// ... bind imageCapture to lifecycle ...


// Provide separate output options for each format.
val outputOptionRaw = /* ... configure for image/x-adobe-dng ... */
val outputOptionJpeg = /* ... configure for image/jpeg ... */
imageCapture.takePicture(
    outputOptionRaw,
    outputOptionJpeg,
    executor,
    object : ImageCapture.OnImageSavedCallback {
        override fun onImageSaved(results: OutputFileResults) {
            // This callback is invoked twice: once for the RAW file
            // and once for the JPEG file.
        }

        override fun onError(exception: ImageCaptureException) {}
    }
)

कैमरा एक्सटेंशन के लिए अल्ट्रा एचडीआर

आपको दोनों दुनिया की सबसे अच्छी चीज़ें मिलेंगी: कैमरा एक्सटेंशन (जैसे, नाइट मोड) की शानदार कंप्यूटेशनल फ़ोटोग्राफ़ी और अल्ट्रा एचडीआर की शानदार रंग और डाइनैमिक रेंज. यह सुविधा अब हाल ही में लॉन्च हुए कई प्रीमियम Android फ़ोन पर काम करती है. जैसे, Pixel 9/10 सीरीज़ और Samsung S24/S25 सीरीज़.

// Support UltraHDR when Extension is enabled. 

val extensionsEnabledCameraSelector = extensionsManager
     .getExtensionEnabledCameraSelector(
        CameraSelector.DEFAULT_BACK_CAMERA, ExtensionMode.NIGHT)

val imageCapabilities = ImageCapture.getImageCaptureCapabilities(
               cameraProvider.getCameraInfo(extensionsEnabledCameraSelector)

val imageCapture = ImageCapture.Builder()
     .apply {
       if (imageCapabilities.supportedOutputFormats
                .contains(OUTPUT_FORMAT_JPEG_ULTRA_HDR) {
           setOutputFormat(OUTPUT_FORMAT_JPEG_ULTRA_HDR)

       }

     }.build()

Core API और इस्तेमाल में आसानी से जुड़े सुधार

कॉन्फ़िगर करने का नया तरीका: SessionConfig

ऊपर दिए गए उदाहरणों में दिखाया गया है कि SessionConfig, CameraX 1.5 में एक नई सुविधा है. यह कॉन्फ़िगरेशन को एक जगह पर रखता है और एपीआई को दो मुख्य तरीकों से आसान बनाता है:

1. मैन्युअल तरीके से unbind() कॉल करने की ज़रूरत नहीं: CameraX एपीआई, लाइफ़साइकल के हिसाब से काम करते हैं. गतिविधि या अन्य LifecycleOwner के खत्म होने पर, यह आपके इस्तेमाल के उदाहरणों को अपने-आप “अनबाइंड” कर देगा. हालांकि, इस्तेमाल के उदाहरणों को अपडेट करने या कैमरे स्विच करने के लिए, आपको फिर से बाइंड करने से पहले unbind() या unbindAll() को कॉल करना होगा. अब CameraX 1.5 के साथ, नया SessionConfig बाइंड करने पर, CameraX आपके लिए सेशन को आसानी से अपडेट कर देता है. इससे, अनबाइंड कॉल की ज़रूरत नहीं पड़ती.
2. डिटरमिनिस्टिक फ़्रेम रेट कंट्रोल: नए SessionConfig एपीआई में, फ़्रेम रेट को मैनेज करने के लिए डिटरमिनिस्टिक तरीका उपलब्ध कराया गया है. पिछले setTargetFrameRate के उलट, जो सिर्फ़ एक हिंट था, यह नया तरीका गारंटी देता है कि कॉन्फ़िगरेशन पूरा होने पर, फ़्रेम रेट की तय की गई रेंज लागू हो जाएगी. सटीक जानकारी पाने के लिए, आपको CameraInfo.getSupportedFrameRateRanges(SessionConfig) का इस्तेमाल करके, इस्तेमाल किए जा सकने वाले फ़्रेम रेट के बारे में क्वेरी करनी होगी. पूरा SessionConfig पास करके, CameraX स्ट्रीम कॉन्फ़िगरेशन के आधार पर, काम करने वाली रेंज का सटीक पता लगा सकता है.

Camera-Compose अब स्टेबल है

हमें पता है कि आपको Jetpack Compose का इस्तेमाल करना कितना पसंद है. इसलिए, हमें यह बताते हुए खुशी हो रही है कि camera-compose लाइब्रेरी अब वर्शन 1.5.1 पर स्टेबल है! इस रिलीज़ में, CameraXViewfinder के इस्तेमाल से जुड़ी गंभीर गड़बड़ियों को ठीक किया गया है. ये गड़बड़ियां, Compose की सुविधाओं, जैसे कि moveableContentOf और Pager के साथ इस्तेमाल करने पर होती थीं. साथ ही, झलक के स्ट्रेच होने की समस्या को भी ठीक किया गया है. हम आने वाले समय में, camera-compose में और सुविधाएं जोड़ते रहेंगे.

ImageAnalysis और CameraControl में सुधार

• टॉर्च की रोशनी को अडजस्ट करने की सुविधा: नए एपीआई की मदद से, डिवाइस की टॉर्च को बेहतर तरीके से कंट्रोल करें. CameraInfo.getMaxTorchStrengthLevel() का इस्तेमाल करके, फ़्लैशलाइट की ज़्यादा से ज़्यादा क्षमता के बारे में क्वेरी की जा सकती है. इसके बाद, CameraControl.setTorchStrengthLevel() का इस्तेमाल करके, अपनी पसंद के मुताबिक लेवल सेट किया जा सकता है.
• ImageAnalysis में NV21 फ़ॉर्मैट के लिए सहायता: अब ImageAnalysis से सीधे NV21 इमेज फ़ॉर्मैट का अनुरोध किया जा सकता है. इससे अन्य लाइब्रेरी और एपीआई के साथ इंटिग्रेशन आसान हो जाता है. ImageAnalysis.Builder.setOutputImageFormat(OUTPUT_IMAGE_FORMAT_NV21) को चालू करके, इस सुविधा का इस्तेमाल किया जा सकता है.

आज ही शुरू करें

आज ही अपनी डिपेंडेंसी को CameraX 1.5 पर अपडेट करें और नई सुविधाओं के बारे में जानें. हमें यह देखने का बेसब्री से इंतज़ार है कि आपने क्या बनाया है.

CameraX 1.5 का इस्तेमाल करने के लिए,  कृपया अपनी libs.versions.toml फ़ाइल में ये डिपेंडेंसी जोड़ें. (हमारा सुझाव है कि आप 1.5.1 का इस्तेमाल करें. इसमें कई अहम गड़बड़ियों को ठीक किया गया है. साथ ही, एक साथ कई कैमरे इस्तेमाल करने की सुविधा को बेहतर बनाया गया है.) 

[versions]

camerax = "1.5.1"


[libraries]

..

androidx-camera-core = { module = "androidx.camera:camera-core", version.ref = "camerax" }

androidx-camera-compose = { module = "androidx.camera:camera-compose", version.ref = "camerax" }

androidx-camera-view = { module = "androidx.camera:camera-view", version.ref = "camerax" }

androidx-camera-lifecycle = { group = "androidx.camera", name = "camera-lifecycle", version.ref = "camerax" }

androidx-camera-camera2 = { module = "androidx.camera:camera-camera2", version.ref = "camerax" }

androidx-camera-extensions = { module = "androidx.camera:camera-extensions", version.ref = "camerax" }

इसके बाद, इन्हें अपने मॉड्यूल build.gradle.kts डिपेंडेंसी में जोड़ें:

dependencies {

  ..

  implementation(libs.androidx.camera.core)
  implementation(libs.androidx.camera.lifecycle)

  implementation(libs.androidx.camera.camera2)

  implementation(libs.androidx.camera.view) // for PreviewView 
  implementation(libs.androidx.camera.compose) // for compose UI

  implementation(libs.androidx.camera.extensions) // For Extensions 

}

क्या आपके पास कोई सवाल है या आपको CameraX की टीम से संपर्क करना है? CameraX डेवलपर के बातचीत के लिए ग्रुप में शामिल हों या गड़बड़ी की रिपोर्ट दर्ज करें:

• CameraX डेवलपर के लिए चर्चा ग्रुप
• गड़बड़ी की शिकायत करना