Architektur der CameraX-Videoaufnahme

Ein Aufnahmesystem zeichnet in der Regel Video- und Audiostreams auf, komprimiert sie, führt die beiden Streams zusammen und schreibt den resultierenden Stream dann auf die Festplatte.

Konzeptionelles Diagramm für ein Video- und Audioaufnahmesystem
Abbildung 1. Konzeptionelles Diagramm für ein Video- und Audioaufnahmesystem.

In CameraX ist der Anwendungsfall VideoCapture die Lösung für die Videoaufnahme:

Konzeptionelles Diagramm, das zeigt, wie CameraX den Anwendungsfall der Videoaufnahme verarbeitet
Abbildung 2: Konzeptionelles Diagramm, das zeigt, wie CameraX den Anwendungsfall VideoCapture verarbeitet.

Wie in Abbildung 2 dargestellt, umfasst die Videoaufnahme mit CameraX einige übergeordnete Architekturkomponenten:

  • SurfaceProvider für die Videoquelle.
  • AudioSource für die Audioquelle.
  • Zwei Encoder zum Codieren und Komprimieren von Video- und Audioinhalten.
  • Ein Media-Muxer, um die beiden Streams zu muxen.
  • Einen Dateispeicher, um das Ergebnis zu speichern.

Die VideoCapture API abstrahiert die komplexe Erfassungs-Engine und bietet Anwendungen eine viel einfachere und unkompliziertere API.

VideoCapture API – Übersicht

VideoCapture ist ein CameraX-Anwendungsfall, der allein oder in Kombination mit anderen Anwendungsfällen gut funktioniert. Die unterstützten Kombinationen hängen von den Hardwarefunktionen der Kamera ab. Preview und VideoCapture ist jedoch auf allen Geräten eine gültige Kombination für Anwendungsfälle.

Die VideoCapture API besteht aus den folgenden Objekten, die mit Anwendungen kommunizieren:

  • VideoCapture ist die Anwendungsfallklasse auf oberster Ebene. VideoCapture wird mit einem CameraSelector und anderen CameraX-UseCases an einen LifecycleOwner gebunden. Weitere Informationen zu diesen Konzepten und Verwendungen finden Sie unter CameraX-Architektur.
  • Ein Recorder ist eine Implementierung von VideoOutput, die eng mit VideoCapture gekoppelt ist. Recorder wird für die Video- und Audioaufnahme verwendet. Eine Anwendung erstellt Aufzeichnungen aus einem Recorder.
  • Mit einem PendingRecording wird eine Aufzeichnung konfiguriert. Dabei stehen Optionen wie das Aktivieren von Audio und das Festlegen eines Event-Listeners zur Verfügung. Sie müssen einen Recorder verwenden, um einen PendingRecording zu erstellen. Ein PendingRecording zeichnet nichts auf.
  • Ein Recording führt die eigentliche Aufzeichnung durch. Sie müssen einen PendingRecording verwenden, um einen Recording zu erstellen.

Abbildung 3 zeigt die Beziehungen zwischen diesen Objekten:

Diagramm, das die Interaktionen zeigt, die in einem Anwendungsfall für die Videoaufnahme auftreten
Abbildung 3: Diagramm, das die Interaktionen zeigt, die in einem VideoCapture-Anwendungsfall auftreten.

Legende:

  1. Erstellen Sie einen Recorder mit QualitySelector.
  2. Konfigurieren Sie den Recorder mit einem der OutputOptions.
  3. Aktivieren Sie bei Bedarf Audio mit withAudioEnabled().
  4. Rufe start() mit einem VideoRecordEvent-Listener auf, um mit der Aufzeichnung zu beginnen.
  5. Verwenden Sie pause()/resume()/stop() auf der Recording, um die Aufnahme zu steuern.
  6. Reagieren Sie in Ihrem Event-Listener auf VideoRecordEvents.

Die detaillierte API-Liste finden Sie in der Datei „current.txt“ im Quellcode.

VideoCapture API verwenden

So binden Sie den CameraX-Anwendungsfall VideoCapture in Ihre App ein:

  1. VideoCapture binden.
  2. Aufnahme vorbereiten und konfigurieren
  3. Starten und steuern Sie die Laufzeitaufzeichnung.

In den folgenden Abschnitten wird beschrieben, was Sie bei jedem Schritt tun können, um eine vollständige Aufzeichnungssitzung zu erhalten.

VideoCapture binden

So binden Sie den Anwendungsfall VideoCapture:

  1. Erstellen Sie ein Recorder-Objekt.
  2. Erstellen Sie ein VideoCapture-Objekt.
  3. An eine Lifecycle binden.

Die CameraX VideoCapture API folgt dem Builder-Designmuster. Anwendungen verwenden Recorder.Builder, um ein Recorder zu erstellen. Sie können die Videoauflösung für die Recorder auch über ein QualitySelector-Objekt konfigurieren.

CameraX Recorder unterstützt die folgenden vordefinierten Qualities für Videoauflösungen:

  • Quality.UHD für 4K-Ultra-HD-Videos (2160p)
  • Quality.QHD für Quad-HD-Videogröße (1440p), eingeführt in CameraX 1.7.0-alpha02
  • Quality.FHD für Full-HD-Videogröße (1080p)
  • Quality.HD für HD-Videogröße (720p)
  • Quality.SD für SD-Videogröße (480p)

Beachten Sie, dass CameraX auch andere Auflösungen auswählen kann, wenn dies von der App autorisiert wurde.

Die genaue Videogröße der einzelnen Optionen hängt von den Funktionen der Kamera und des Encoders ab. Weitere Informationen finden Sie in der Dokumentation zu CamcorderProfile.

Anwendungen können die Auflösung konfigurieren, indem sie eine QualitySelector erstellen. Sie können einen QualitySelector mit einer der folgenden Methoden erstellen:

  • Geben Sie mit fromOrderedList einige bevorzugte Auflösungen an und fügen Sie eine Fallback-Strategie hinzu, die verwendet werden soll, falls keine der bevorzugten Auflösungen unterstützt wird.

    CameraX kann anhand der Funktionen der ausgewählten Kamera die beste Fallback-Übereinstimmung ermitteln. Weitere Informationen findest du in der FallbackStrategy specification von QualitySelector. Im folgenden Code wird beispielsweise die höchste unterstützte Auflösung für die Aufnahme angefordert. Wenn keine der angeforderten Auflösungen unterstützt wird, wird CameraX autorisiert, eine Auflösung auszuwählen, die der Auflösung „Quality.SD“ am nächsten kommt:

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

  • Frage zuerst die Kamerafunktionen ab und wähle mit QualitySelector.from eine der unterstützten Auflösungen aus:

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

    Jeder Quality, der von VideoCapabilities.getSupportedQualities (aus Recorder.getVideoCapabilities für DynamicRange.SDR) zurückgegeben wird, funktioniert für den Anwendungsfall VideoCapture allein oder in Kombination mit dem Anwendungsfall Preview. Wenn Sie auch ImageCapture oder ImageAnalysis binden, kann die Bindung von CameraX fehlschlagen, wenn die Kamera diese Kombination nicht unterstützt.

Sobald Sie einen QualitySelector haben, kann die Anwendung ein VideoCapture-Objekt erstellen und die Bindung durchführen. Diese Bindung ist dieselbe wie bei anderen Anwendungsfällen:

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

Beachten Sie, dass bindToLifecycle() ein Camera-Objekt zurückgibt. Weitere Informationen zum Steuern der Kameraausgabe, z. B. Zoom und Belichtung, finden Sie in diesem Leitfaden.

Recorder wählt das am besten geeignete Format für das System aus. Der gängigste Video-Codec ist H.264 AVC mit dem Containerformat MPEG-4.

Aufzeichnung konfigurieren und erstellen

Über ein Recorder kann die Anwendung Aufnahmeobjekte erstellen, um Video- und Audioaufnahmen zu machen. Anwendungen erstellen Aufzeichnungen so:

  1. Konfigurieren Sie OutputOptions mit prepareRecording().
  2. Optional: Aktiviere die Audioaufnahme.
  3. Verwende start(), um einen VideoRecordEvent-Listener zu registrieren und mit der Videoaufnahme zu beginnen.

Recorder gibt ein Recording-Objekt zurück, wenn Sie die Funktion start() aufrufen. Ihre Anwendung kann dieses Recording-Objekt verwenden, um die Aufnahme abzuschließen oder andere Aktionen auszuführen, z. B. Pausieren oder Fortsetzen.

Ein Recorder unterstützt jeweils ein Recording-Objekt. Sie können eine neue Aufnahme starten, nachdem Sie Recording.stop() oder Recording.close() für das vorherige Recording-Objekt aufgerufen haben.

Sehen wir uns die Schritte genauer an. Zuerst konfiguriert die Anwendung den OutputOptions für einen Recorder mit Recorder.prepareRecording(). Ein Recorder unterstützt die folgenden Typen von OutputOptions:

  • FileDescriptorOutputOptions zum Erfassen in einer FileDescriptor.
  • FileOutputOptions zum Erfassen in einer File.
  • MediaStoreOutputOptions zum Erfassen in einer MediaStore.

Bei allen OutputOptions-Typen können Sie mit setFileSizeLimit() eine maximale Dateigröße festlegen. Andere Optionen sind spezifisch für den jeweiligen Ausgabetyp, z. B. ParcelFileDescriptor für FileDescriptorOutputOptions.

prepareRecording() gibt ein PendingRecording-Objekt zurück. Dies ist ein Zwischenobjekt, das zum Erstellen des entsprechenden Recording-Objekts verwendet wird. PendingRecording ist eine temporäre Klasse, die in den meisten Fällen unsichtbar sein sollte und selten von der App im Cache gespeichert wird.

Anwendungen können die Aufzeichnung weiter konfigurieren, z. B.:

  • Audio mit withAudioEnabled() aktivieren.
  • Registrieren Sie einen Listener, um Videoaufzeichnungsereignisse mit start(Executor, Consumer<VideoRecordEvent>) zu empfangen.
  • Mit PendingRecording.asPersistentRecording() können Sie eine Aufnahme kontinuierlich aufzeichnen lassen, während die VideoCapture-Instanz, an die sie angehängt ist, an eine andere Kamera gebunden wird.

Wenn Sie die Aufnahme starten möchten, rufen Sie PendingRecording.start() an. CameraX wandelt die PendingRecording in eine Recording um, stellt die Aufnahmeanfrage in die Warteschlange und gibt das neu erstellte Recording-Objekt an die Anwendung zurück. Sobald die Aufnahme auf dem entsprechenden Kameragerät beginnt, sendet CameraX ein VideoRecordEvent.EVENT_TYPE_START-Ereignis.

Im folgenden Beispiel wird gezeigt, wie Sie Video und Audio in einer MediaStore-Datei aufzeichnen:

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

Die Kameravorschau wird standardmäßig auf der Frontkamera gespiegelt, mit VideoCapture aufgenommene Videos werden jedoch standardmäßig nicht gespiegelt. Mit CameraX 1.3 ist es jetzt möglich, Videoaufnahmen zu spiegeln, sodass die Vorschau der Frontkamera und das aufgezeichnete Video übereinstimmen.

Es gibt drei MirrorMode-Optionen: MIRROR_MODE_OFF, MIRROR_MODE_ON und MIRROR_MODE_ON_FRONT_ONLY. Für die Ausrichtung an der Kameravorschau empfiehlt Google die Verwendung von MIROR_MODE_ON_FRONT_ONLY. Das bedeutet, dass die Spiegelung für die Rückkamera nicht aktiviert ist, aber für die Frontkamera. Weitere Informationen zu MirrorMode finden Sie unter MirrorMode constants.

Dieses Code-Snippet zeigt, wie VideoCapture.Builder.setMirrorMode() mit MIRROR_MODE_ON_FRONT_ONLY aufgerufen wird. Weitere Informationen finden Sie unter setMirrorMode().

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

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

useCases.add(videoCapture)

Dynamikumfang (HDR-Video)

CameraX unterstützt die 10-Bit-HDR-Videoaufnahme (High Dynamic Range), z. B. HLG10, HDR10, HDR10+ oder Dolby Vision, mit DynamicRange.

So nimmst du ein HDR-Video auf:

  1. Frage die von der Kamera unterstützten Dynamikbereiche mit VideoCapabilities.getSupportedDynamicRanges() ab.
  2. Optional: Wenn Sie einen benutzerdefinierten QualitySelector konfigurieren, prüfen Sie mit getSupportedQualities(DynamicRange), welche Qualitäten für diesen Dynamikbereich unterstützt werden.
  3. Konfigurieren Sie VideoCapture.Builder mit setDynamicRange().

Im folgenden Beispiel wird die HLG-10-Bit-HDR-Aufnahme aktiviert, wenn die Kamera dies unterstützt:

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

Videostabilisierung

CameraX unterstützt die Videostabilisierung, um Verwacklungen und Jitter bei der Videoaufnahme zu reduzieren.

So aktivieren Sie die Videostabilisierung:

  1. Prüfe mit VideoCapabilities.isStabilizationSupported(), ob das Kameragerät die Stabilisierung unterstützt.
  2. Aktivieren Sie sie auf VideoCapture.Builder mit setVideoStabilizationEnabled(true).

Im folgenden Beispiel wird die Stabilisierung aktiviert, wenn die Kamera sie unterstützt:

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

Aktive Aufnahme steuern

Sie können einen laufenden Recording mit den folgenden Methoden pausieren, fortsetzen und beenden:

  • pause, um die aktuelle Aufnahme zu pausieren.
  • resume(), um eine pausierte Aufnahme fortzusetzen.
  • stop(), um die Aufnahme zu beenden und alle zugehörigen Aufnahmeobjekte zu löschen.
  • mute(), um die aktuelle Aufnahme stummzuschalten oder die Stummschaltung aufzuheben.

Sie können stop() aufrufen, um eine Recording zu beenden, unabhängig davon, ob die Aufzeichnung pausiert oder aktiv ist.

Wenn Sie eine EventListener bei PendingRecording.start() registriert haben, kommuniziert die Recording über eine VideoRecordEvent.

  • VideoRecordEvent.EVENT_TYPE_STATUS wird für die Aufzeichnung von Statistiken wie der aktuellen Dateigröße und der aufgezeichneten Zeitspanne verwendet.
  • VideoRecordEvent.EVENT_TYPE_FINALIZE wird für das Aufzeichnungsergebnis verwendet und enthält Informationen wie den URI der endgültigen Datei sowie alle zugehörigen Fehler.

Sobald deine App eine EVENT_TYPE_FINALIZE erhält, die auf eine erfolgreiche Aufzeichnungssitzung hinweist, kannst du über den in OutputOptions angegebenen Speicherort auf das aufgezeichnete Video zugreifen.

Audioamplitude und ‑status in Echtzeit

Während der Aufzeichnung liefern VideoRecordEvent.Status-Ereignisse Echtzeit-Audiostatistiken über AudioStats:

  • AudioStats.getAudioAmplitude() gibt die aktuelle Audio-Spitzenamplitude zurück, die zwischen 0.0 und 1.0 liegt. Sie können diesen Wert verwenden, um UI-Anzeigen oder Audiowellenform-Visualisierer zu steuern.
  • AudioStats.getAudioState() gibt den aktuellen Status des Audiostreams an, z. B. AUDIO_STATE_ACTIVE, AUDIO_STATE_MUTED oder AUDIO_STATE_SOURCE_SILENCED.

Im folgenden Beispiel wird die Audioamplitude aus einem Statusereignis gelesen:

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

Highspeed- und Zeitlupenvideos

CameraX unterstützt die Videoaufzeichnung mit hoher Geschwindigkeit, z. B. 120, 240 oder 480 fps, was zwei verschiedene Anwendungsfälle ermöglicht:

  • Video mit hoher Framerate (Zeitlupe vom Player verarbeitet): CameraX nimmt Frames mit der hohen Framerate (z. B. 120 fps) auf und speichert sie. Der Videoplayer steuert die Wiedergabegeschwindigkeit, sodass Nutzer zwischen normaler Geschwindigkeit und Zeitlupe wechseln oder eine Einzelbildanalyse durchführen können.
  • Sofort abspielbares Zeitlupenvideo: CameraX verarbeitet den Hochgeschwindigkeitsstream und gibt eine Standard-Videodatei mit 30 fps und angepassten Frame-Zeitstempeln aus. Der Zeitlupeneffekt ist „fest integriert“, sodass das Video in jedem Standard-Videoplayer automatisch in Zeitlupe abgespielt wird, ohne dass eine spezielle Player-Unterstützung erforderlich ist. Beispiel: Eine Aufnahme mit 120 fps, die mit 30 fps wiedergegeben wird, ergibt ein Zeitlupenvideo mit 1/4-facher Geschwindigkeit.

Highspeed-Funktionen prüfen

Für die Videoaufnahme mit hoher Geschwindigkeit ist Hardwareunterstützung und entsprechende CamcorderProfile-Definitionen von Geräteherstellern erforderlich, z. B. CamcorderProfile.QUALITY_HIGH_SPEED_1080P oder QUALITY_HIGH_SPEED_720P.

Bevor Sie die Hochgeschwindigkeitsaufzeichnung konfigurieren, fragen Sie die Hochgeschwindigkeitsfunktionen mit Recorder.getHighSpeedVideoCapabilities(CameraInfo) ab:

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 konfigurieren

Wenn Sie die Hochgeschwindigkeitserfassung verwenden möchten, kombinieren Sie Ihre VideoCapture- und Preview-Anwendungsfälle in einer HighSpeedVideoSessionConfig. Führen Sie die folgenden Schritte aus, um die Sitzung zu konfigurieren:

  1. Erstellen Sie einen VideoCapture-Anwendungsfall und einen Preview-Anwendungsfall.
  2. Initialisieren Sie HighSpeedVideoSessionConfig.Builder mit dem Anwendungsfall VideoCapture und hängen Sie die Preview an.
  3. Fragen Sie die unterstützten Frameratenbereiche mit CameraInfo.getSupportedFrameRateRanges(SessionConfig) ab und legen Sie den ausgewählten Bereich fest.
  4. Wähle zwischen einem Video mit hoher Framerate oder einem sofort abspielbaren Zeitlupenvideo:
    • Wenn Sie ein Video mit hoher Framerate erstellen möchten, behalten Sie setSlowMotionEnabled(false) (Standard) bei.
    • Wenn du ein abspielbereites Zeitlupenvideo erstellen möchtest, rufe setSlowMotionEnabled(true) auf.
  5. Binden Sie die Sitzungskonfiguration mit cameraProvider.bindToLifecycle().

Im folgenden Beispiel wird eine wiedergabebereite Zeitlupensitzung konfiguriert und gebunden:

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

Du kannst auch die in CameraX 1.7.0-alpha02 eingeführte Kotlin DSL verwenden, um Highspeed-Sitzungen prägnant zu konfigurieren:

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

Zeitraffer- oder Zeitlupenvideos aufnehmen

Nachdem du die HighSpeedVideoSessionConfig gebunden hast, kannst du die Aufnahme mit VideoCapture wie bei Standard-Videoaufnahmen starten:

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

Zusätzliche Ressourcen

Weitere Informationen zu CameraX findest du in den folgenden Ressourcen: