CameraX video yakalama mimarisi

Yakalama sistemi genellikle video ve ses akışlarını kaydeder, sıkıştırır, iki akışı birleştirir ve ardından elde edilen akışı diske yazar.

video ve ses yakalama sistemi için kavramsal diyagram
Şekil 1. Video ve ses yakalama sistemi için kavramsal diyagram.

CameraX'te video kaydı için çözüm, VideoCapture kullanım alanıdır:

CameraX'in video yakalama kullanım alanını nasıl işlediğini gösteren kavramsal şema
Şekil 2. CameraX'in VideoCapture kullanım alanını nasıl işlediğini gösteren kavramsal şema.

Şekil 2'de gösterildiği gibi, CameraX video yakalama birkaç üst düzey mimari bileşen içerir:

  • Video kaynağı için SurfaceProvider.
  • Ses kaynağı için AudioSource.
  • Video/ses kodlamak ve sıkıştırmak için iki kodlayıcı
  • İki akışı birleştirmek için bir medya birleştirici.
  • Sonucu yazmak için bir dosya kaydedici.

VideoCapture API, karmaşık yakalama motorunu soyutlar ve uygulamalara çok daha basit ve anlaşılır bir API sunar.

VideoCapture API'ye genel bakış

VideoCapture, tek başına veya diğer kullanım alanlarıyla birleştirildiğinde iyi çalışan bir CameraX kullanım alanıdır. Desteklenen belirli kombinasyonlar, kamera donanım özelliklerine bağlıdır ancak Preview ve VideoCapture, tüm cihazlarda geçerli bir kullanım alanı kombinasyonudur.

VideoCapture API, uygulamalarla iletişim kuran aşağıdaki nesnelerden oluşur:

  • VideoCapture, üst düzey kullanım alanı sınıfıdır. VideoCapture, CameraSelector ve diğer CameraX UseCase'leri ile bir LifecycleOwner öğesine bağlanır. Bu kavramlar ve kullanımları hakkında daha fazla bilgi için CameraX Mimarisi başlıklı makaleyi inceleyin.
  • Recorder, VideoCapture ile sıkı bağlantılı bir VideoOutput uygulamasıdır. Recorder, video ve ses yakalama işlemini gerçekleştirmek için kullanılır. Uygulama, Recorder üzerinden kayıt oluşturur.
  • PendingRecording, ses kaydını etkinleştirme ve etkinlik işleyici ayarlama gibi seçenekler sunarak kaydı yapılandırır. PendingRecording oluşturmak için Recorder kullanmanız gerekir. PendingRecording hiçbir şey kaydetmez.
  • Recording, asıl kaydı gerçekleştirir. Recording oluşturmak için PendingRecording kullanmanız gerekir.

Şekil 3'te bu nesneler arasındaki ilişkiler gösterilmektedir:

Video yakalama kullanım alanında gerçekleşen etkileşimleri gösteren diyagram
Şekil 3. VideoCapture kullanım alanında gerçekleşen etkileşimleri gösteren diyagram.

Açıklama:

  1. QualitySelector ile Recorder oluşturun.
  2. Recorder öğesini OutputOptions seçeneklerinden biriyle yapılandırın.
  3. Gerekirse withAudioEnabled() ile sesi etkinleştirin.
  4. Kayda başlamak için start() numarasını VideoRecordEvent dinleyiciyle arayın.
  5. Kaydı kontrol etmek için Recording üzerinde pause()/resume()/stop() tuşlarını kullanın.
  6. Etkinlik işleyicinizde VideoRecordEvents öğesine yanıt verin.

Ayrıntılı API listesi, kaynak kodundaki current.txt dosyasında yer alır.

VideoCapture API'yi kullanma

CameraX VideoCapture kullanım alanını uygulamanıza entegre etmek için aşağıdakileri yapın:

  1. VideoCapture bağlayın.
  2. Kaydı hazırlama ve yapılandırma
  3. Çalışma zamanı kaydını başlatma ve kontrol etme

Aşağıdaki bölümlerde, uçtan uca kayıt oturumu elde etmek için her adımda neler yapabileceğiniz açıklanmaktadır.

VideoCapture'ı bağlama

VideoCapture kullanım alanını bağlamak için aşağıdakileri yapın:

  1. Recorder nesnesi oluşturun.
  2. VideoCapture nesnesi oluşturun.
  3. Lifecycle ile bağlayın.

CameraX VideoCapture API, oluşturucu tasarım kalıbını kullanır. Uygulamalar, Recorder oluşturmak için Recorder.Builder kullanır. Recorder için video çözünürlüğünü QualitySelector nesnesi üzerinden de yapılandırabilirsiniz.

CameraX Recorder, video çözünürlükleri için önceden tanımlanmış aşağıdaki Qualities değerlerini destekler:

  • 4K ultra HD video boyutu (2160p) için Quality.UHD
  • Quality.QHD, CameraX'te kullanıma sunulan Quad HD video boyutu (1440p) için 1.7.0-alpha02
  • Full HD video boyutu (1080p) için Quality.FHD
  • HD video boyutu (720p) için Quality.HD
  • SD video boyutu (480p) için Quality.SD

CameraX'in, uygulama tarafından yetkilendirildiğinde başka çözünürlükler de seçebileceğini unutmayın.

Her seçimin tam video boyutu, kameranın ve kodlayıcının özelliklerine bağlıdır. Daha fazla bilgi için CamcorderProfile ile ilgili belgelere bakın.

Uygulamalar, bir QualitySelector oluşturarak çözünürlüğü yapılandırabilir. Aşağıdaki yöntemlerden birini kullanarak QualitySelector oluşturabilirsiniz:

  • fromOrderedList() kullanarak tercih edilen birkaç çözünürlük sağlayın ve tercih edilen çözünürlüklerin hiçbiri desteklenmiyorsa kullanılacak bir yedek strateji ekleyin.

    CameraX, seçilen kameranın özelliklerine göre en iyi yedek eşleşmeye karar verebilir. Daha fazla bilgi için QualitySelector FallbackStrategy specification sayfasına bakın. Örneğin, aşağıdaki kod, kayıt için desteklenen en yüksek çözünürlüğü ister ve istenen çözünürlüklerden hiçbiri desteklenemiyorsa CameraX'e Quality.SD çözünürlüğüne en yakın çözünürlüğü seçme yetkisi verir:

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

  • Önce kamera özelliklerini sorgulayın ve QualitySelector::from() kullanarak desteklenen çözünürlükler arasından seçim yapın:

    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.QHD, 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.QHD -> "QHD"
        Quality.FHD -> "FHD"
        Quality.HD -> "HD"
        Quality.SD -> "SD"
        else -> throw IllegalArgumentException()
    }
}

    QualitySelector.getSupportedQualities() tarafından döndürülen özelliğin, VideoCapture kullanım alanı veya VideoCapture ve Preview kullanım alanlarının kombinasyonu için çalışacağı garanti edilir. ImageCapture veya ImageAnalysis kullanım alanıyla birlikte bağlandığında, gerekli kombinasyon istenen kamerada desteklenmiyorsa CameraX bağlama işlemini yine de gerçekleştiremeyebilir.

QualitySelector elde ettikten sonra uygulama, VideoCapture nesnesi oluşturup bağlama işlemini gerçekleştirebilir. Bu bağlamanın diğer kullanım alanlarıyla aynı olduğunu unutmayın:

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() işlevinin bir Camera nesnesi döndürdüğünü unutmayın. Yakınlaştırma ve pozlama gibi kamera çıkışını kontrol etme hakkında daha fazla bilgi için bu kılavuzu inceleyin.

Recorder, sistem için en uygun biçimi seçer. En yaygın video codec'i, MPEG-4 kapsayıcı biçimine sahip H.264 AVC'dir.

Kaydı yapılandırma ve oluşturma

Uygulama, Recorder üzerinden video ve ses yakalama işlemini gerçekleştirmek için kayıt nesneleri oluşturabilir. Uygulamalar, aşağıdaki işlemleri yaparak kayıt oluşturur:

  1. OutputOptions'i prepareRecording() ile yapılandırın.
  2. (İsteğe bağlı) Ses kaydını etkinleştirin.
  3. Bir VideoRecordEvent dinleyicisi kaydetmek ve video yakalamaya başlamak için start() kullanın.

start() işlevini çağırdığınızda Recorder, bir Recording nesnesi döndürür. Uygulamanız, yakalama işlemini tamamlamak veya duraklatma ya da devam ettirme gibi diğer işlemleri gerçekleştirmek için bu Recording nesnesini kullanabilir.

Recorder, tek seferde bir Recording nesnesini destekler. Önceki Recording nesnesinde Recording.stop() veya Recording.close() yöntemini çağırdıktan sonra yeni bir kayıt başlatabilirsiniz.

Bu adımları daha ayrıntılı olarak inceleyelim. İlk olarak uygulama, Recorder.prepareRecording() ile bir kaydedici için OutputOptions yapılandırır. Recorder, aşağıdaki OutputOptions türlerini destekler:

  • FileDescriptorOutputOptions, FileDescriptor içine yakalamak için kullanılır.
  • FileOutputOptions, File içine kaydetmek için kullanılır.
  • MediaStoreOutputOptions, MediaStore içine yakalamak için kullanılır.

Tüm OutputOptions türleri, setFileSizeLimit() ile maksimum dosya boyutu belirlemenize olanak tanır. Diğer seçenekler, FileDescriptorOutputOptions için ParcelFileDescriptor gibi her bir çıkış türüne özeldir.

prepareRecording(), ilgili Recording nesnesini oluşturmak için kullanılan bir ara nesne olan PendingRecording nesnesini döndürür. PendingRecording, çoğu durumda görünmez olması gereken ve uygulama tarafından nadiren önbelleğe alınan geçici bir sınıftır.

Uygulamalar, kaydı daha ayrıntılı şekilde yapılandırabilir. Örneğin:

  • withAudioEnabled() ile sesi etkinleştirin.
  • start(Executor, Consumer<VideoRecordEvent>) ile video kaydı etkinliklerini almak için bir dinleyici kaydedin.
  • PendingRecording.asPersistentRecording() ile, bağlı olduğu VideoCapture başka bir kameraya yeniden bağlandığında kaydın kesintisiz olarak devam etmesine izin verin.

Kaydı başlatmak için PendingRecording.start() numaralı telefonu arayın. CameraX, PendingRecording öğesini Recording öğesine dönüştürür, kayıt isteğini sıraya alır ve yeni oluşturulan Recording nesnesini uygulamaya döndürür. İlgili kamera cihazında kayıt başladığında CameraX bir VideoRecordEvent.EVENT_TYPE_START etkinliği gönderir.

Aşağıdaki örnekte, video ve sesin MediaStore dosyasına nasıl kaydedileceği gösterilmektedir:

// 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)

Kamera önizlemesi varsayılan olarak ön kamerada yansıtılırken VideoCapture tarafından kaydedilen videolar varsayılan olarak yansıtılmaz. CameraX 1.3 ile artık video kayıtlarını yansıtarak ön kamera önizlemesi ile kaydedilen videonun eşleşmesini sağlayabilirsiniz.

Üç MirrorMode seçeneği vardır: MIRROR_MODE_OFF, MIRROR_MODE_ON ve MIRROR_MODE_ON_FRONT_ONLY. Kamera önizlemesiyle uyumlu olması için Google, MIROR_MODE_ON_FRONT_ONLY modunu kullanmanızı önerir. Bu modda, yansıtma arka kamera için etkinleştirilmez ancak ön kamera için etkinleştirilir. MirrorMode hakkında daha fazla bilgi için MirrorMode constants başlıklı makaleyi inceleyin.

Bu kod snippet'i, MIRROR_MODE_ON_FRONT_ONLY kullanarak VideoCapture.Builder.setMirrorMode() yönteminin nasıl çağrılacağını gösterir. Daha fazla bilgi için setMirrorMode() başlıklı makaleyi inceleyin.

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);

Dinamik aralık (HDR video)

CameraX, DynamicRange kullanarak HLG10, HDR10, HDR10+ veya Dolby Vision gibi 10 bit yüksek dinamik aralıklı (HDR) video kaydını destekler.

HDR video kaydını kullanmak için aşağıdaki adımları uygulayın:

  1. VideoCapabilities.getSupportedDynamicRanges() kullanarak kameranın desteklenen dinamik aralıklarını sorgulayın.
  2. İsteğe bağlı: Özel bir QualitySelector yapılandırırsanız getSupportedQualities(DynamicRange) kullanarak bu dinamik aralık için hangi kalitelerin desteklendiğini kontrol edin.
  3. VideoCapture.Builder'i setDynamicRange() ile yapılandırın.

Aşağıdaki örnekte, kamera desteklediğinde HLG 10 bit HDR kayıt etkinleştirilir:

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();

Videoda titreşim engelleme

CameraX, video kaydı sırasında elde tutmadan kaynaklanan sallanmayı ve titremeyi azaltmak için video sabitlemeyi destekler.

Video sabitlemeyi etkinleştirmek için aşağıdaki adımları uygulayın:

  1. Kamera cihazının VideoCapabilities.isStabilizationSupported() kullanarak sabitlemeyi destekleyip desteklemediğini kontrol edin.
  2. setVideoStabilizationEnabled(true) kullanarak VideoCapture.Builder üzerinde etkinleştirin.

Aşağıdaki örnekte, kamera desteklediğinde sabitleme etkinleştirilir:

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();

Etkin bir kaydı kontrol etme

Devam eden bir Recording işlemini aşağıdaki yöntemleri kullanarak duraklatabilir, devam ettirebilir ve durdurabilirsiniz:

  • pause Mevcut etkin kaydı duraklatmak için kullanılır.
  • Duraklatılmış etkin bir kaydı devam ettirmek için resume().
  • stop() kaydı tamamlamak ve ilişkili tüm kayıt nesnelerini temizlemek için kullanılır.
  • Mevcut kaydın sesini kapatmak veya açmak için mute().

Kaydın duraklatılmış veya etkin kayıt durumunda olup olmadığına bakılmaksızın Recording işlemini sonlandırmak için stop() yöntemini çağırabileceğinizi unutmayın.

PendingRecording.start() ile bir EventListener kaydettiyseniz Recording, VideoRecordEvent kullanarak iletişim kurar.

  • VideoRecordEvent.EVENT_TYPE_STATUS, mevcut dosya boyutu ve kaydedilen zaman aralığı gibi istatistikleri kaydetmek için kullanılır.
  • VideoRecordEvent.EVENT_TYPE_FINALIZE, kayıt sonucunu belirtmek için kullanılır ve nihai dosyanın URI'si ile ilgili hatalar gibi bilgileri içerir.

Uygulamanız kayıt oturumunun başarılı olduğunu belirten bir EVENT_TYPE_FINALIZE aldığında, kaydedilen videoya OutputOptions içinde belirtilen konumdan erişebilirsiniz.

Anlık ses genliği ve durumu

Kayıt sırasında VideoRecordEvent.Status etkinlikleri, AudioStats aracılığıyla anlık ses istatistikleri sağlar:

  • AudioStats.getAudioAmplitude(), 0.0 ile 1.0 arasında değişen mevcut ses tepe genliğini döndürür. Bu değeri, kullanıcı arayüzü ölçüm araçlarını veya ses dalga formu görselleştiricilerini yönlendirmek için kullanabilirsiniz.
  • AudioStats.getAudioState(), ses akışının mevcut durumunu (ör. AUDIO_STATE_ACTIVE, AUDIO_STATE_MUTED veya AUDIO_STATE_SOURCE_SILENCED) gösterir.

Aşağıdaki örnekte, bir durum etkinliğinden ses genliği okunur:

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);
    }
}

Yüksek hızlı ve ağır çekim video

CameraX, 120, 240 veya 480 fps gibi yüksek hızlı video kaydını destekler. Bu sayede iki farklı kullanım alanı sunar:

  • Yüksek kare hızlı video (oynatıcı tarafından işlenen ağır çekim): CameraX, kareleri yüksek kare hızında (ör. 120 fps) yakalar ve kaydeder. Video oynatıcı, oynatma hızını kontrol ederek kullanıcıların normal hız ile ağır çekim arasında geçiş yapmasına veya kare kare analiz yapmasına olanak tanır.
  • Oynatılmaya hazır ağır çekim video: CameraX, yüksek hızlı akışı işler ve ayarlanmış kare zaman damgalarına sahip standart bir 30 fps video dosyası oluşturur. Ağır çekim efekti "yerleşik" olduğundan video, özel oynatıcı desteği olmadan herhangi bir standart oynatıcıda otomatik olarak ağır çekimde oynatılır. Örneğin, 120 fps'lik bir çekim 30 fps'de oynatıldığında 1/4 kat ağır çekim video elde edilir.

Yüksek hız özelliklerini kontrol etme

Yüksek hızlı video çekimi için donanım desteği ve cihaz üreticilerinin ilgili CamcorderProfile tanımları (ör. CamcorderProfile.QUALITY_HIGH_SPEED_1080P veya QUALITY_HIGH_SPEED_720P) gerekir.

Yüksek hızlı kaydı yapılandırmadan önce Recorder.getHighSpeedVideoCapabilities(CameraInfo) kullanarak yüksek hız özelliklerini sorgulayın:

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'i yapılandırma

Yüksek hızlı yakalama özelliğini kullanmak için VideoCapture ve Preview kullanım alanlarınızı bir HighSpeedVideoSessionConfig içinde birleştirin. Oturumu yapılandırmak için aşağıdaki adımları uygulayın:

  1. VideoCapture kullanım alanı ve Preview kullanım alanı oluşturun.
  2. VideoCapture kullanım alanıyla HighSpeedVideoSessionConfig.Builder'ı ilk kullanıma hazırlayın ve Preview'ı ekleyin.
  3. CameraInfo.getSupportedFrameRateRanges(SessionConfig) kullanarak desteklenen kare hızı aralıklarını sorgulayın ve seçilen aralığı ayarlayın.
  4. Yüksek kare hızlı video veya oynatılmaya hazır ağır çekim video arasında seçim yapın:
    • Yüksek kare hızlı video oluşturmak için setSlowMotionEnabled(false) (varsayılan) seçeneğini bırakın.
    • Oynatılmaya hazır bir ağır çekim video oluşturmak için setSlowMotionEnabled(true) yöntemini çağırın.
  5. cameraProvider.bindToLifecycle() kullanarak oturum yapılandırmasını bağlayın.

Aşağıdaki örnekte, oynatılmaya hazır bir ağır çekim oturumu yapılandırılıp bağlanmaktadır:

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
);

Yüksek hızlı oturumları kısa ve öz bir şekilde yapılandırmak için CameraX 1.7.0-alpha02 sürümünde kullanıma sunulan Kotlin DSL'yi de kullanabilirsiniz:

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

Yüksek hızlı veya ağır çekim video kaydetme

HighSpeedVideoSessionConfig cihazını bağladıktan sonra standart video kayıtlarında olduğu gibi VideoCapture kullanarak kayda başlayın:

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());
            }
        }
    });

Ek kaynaklar

CameraX hakkında daha fazla bilgi edinmek için aşağıdaki ek kaynaklara göz atın: