CameraX 1.5 लॉन्च किया गया: वीडियो रिकॉर्ड करने की शानदार सुविधा और प्रोफ़ेशनल क्वालिटी की इमेज कैप्चर करने की सुविधा

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

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

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

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

वीडियो रिकॉर्ड करने की शानदार सुविधा: हाई-स्पीड और फ़ीचर कॉम्बिनेशन

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

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

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

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

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 डिवाइसों के रियर कैमरे और अन्य कंपनियों के चुनिंदा मॉडल पर उपलब्ध है.

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

फ़ीचर कॉम्बिनेशन का आसानी से इस्तेमाल करना: फ़ीचर ग्रुप एपीआई

CameraX 1.5 में फ़ीचर ग्रुप एपीआई लॉन्च किया गया है. इससे, यह अनुमान लगाने की ज़रूरत नहीं पड़ती कि कौनसी सुविधाएं एक साथ काम कर सकती हैं. Android 15 के फ़ीचर कॉम्बिनेशन क्वेरी एपीआई के आधार पर, अब एक साथ कई सुविधाएं चालू की जा सकती हैं. इससे, कैमरे का सेशन स्थिर रहता है. फ़िलहाल, फ़ीचर ग्रुप में ये सुविधाएं उपलब्ध हैं: एचडीआर (HLG), 60 fps (फ़्रेम प्रति सेकंड), प्रीव्यू स्टेबलाइज़ेशन, और अल्ट्रा एचडीआर. उदाहरण के लिए, Pixel 10 और Galaxy S25 सीरीज़ पर, एचडीआर, 60 fps (फ़्रेम प्रति सेकंड), और प्रीव्यू स्टेबलाइज़ेशन को एक साथ चालू किया जा सकता है. आने वाले समय में, 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 के लिए, प्रीव्यू + 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 (RAW) कैप्चर की सुविधा देता है. इससे, आपको कैमरे के सेंसर से सीधे तौर पर, बिना प्रोसेस किए और कंप्रेस किए गए इमेज डेटा का ऐक्सेस मिलता है. इससे, प्रोफ़ेशनल क्वालिटी की एडिटिंग और कलर ग्रेडिंग की जा सकती है. एपीआई की मदद से, सिर्फ़ 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()

मुख्य एपीआई और डिवाइस का बेहतर तरीके से इस्तेमाल

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

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

1. अब unbind() कॉल मैन्युअल तरीके से करने की ज़रूरत नहीं है: CameraX API, लाइफ़साइकल के बारे में जानकारी रखते हैं. जब गतिविधि या अन्य 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() का इस्तेमाल करके, अपनी पसंद का लेवल सेट किया जा सकता है.
• NV21 की सुविधा ImageAnalysis: अब 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 के डेवलपर का चर्चा ग्रुप
• गड़बड़ी की रिपोर्ट सबमिट करना