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.

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

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:

Legende:

1. Erstellen Sie einen Recorder mit QualitySelector.
2. Konfigurieren Sie den Recorder mit einem der OutputOptions.
3. Aktivieren Sie Audio bei Bedarf mit withAudioEnabled().
4. Rufe start() mit einem VideoRecordEvent-Listener an, um mit der Aufnahme 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 den 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-Video (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, wenn 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. Mit dem 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 {
      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()
      }
  }
  
  

  Die von QualitySelector.getSupportedQualities() zurückgegebene Funktion funktioniert garantiert entweder für den Anwendungsfall VideoCapture oder für die Kombination der Anwendungsfälle VideoCapture und Preview. Bei der Bindung mit dem Anwendungsfall ImageCapture oder ImageAnalysis kann die Bindung in CameraX fehlschlagen, wenn die erforderliche Kombination auf der angeforderten Kamera nicht unterstützt wird.

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 eine Recorder kann die Anwendung Aufnahmeobjekte erstellen, um Video- und Audioaufnahmen zu machen. Anwendungen erstellen Aufzeichnungen so:

1. Konfigurieren Sie OutputOptions mit dem 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 zu beenden oder andere Aktionen auszuführen, z. B. das 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 einem 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.
• Registriere einen Listener, um Videoaufzeichnungsereignisse mit start(Executor, Consumer<VideoRecordEvent>) zu empfangen.
• Mit PendingRecording.asPersistentRecording() kannst du eine Aufnahme kontinuierlich aufzeichnen lassen, während die VideoCapture-Instanz, an die sie angehängt ist, an eine andere Kamera gebunden wird.

Rufe PendingRecording.start() an, um die Aufnahme zu starten. 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);

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

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 HDR-Videos 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:

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

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 sie von der Kamera unterstützt wird:

val videoCapabilities = Recorder.getVideoCapabilities(cameraInfo)
val videoCapture = VideoCapture.Builder(recorder)
    .setVideoStabilizationEnabled(videoCapabilities.isStabilizationSupported)
    .build()

VideoCapabilities videoCapabilities = Recorder.getVideoCapabilities(cameraInfo);
VideoCapture<Recorder> videoCapture = new VideoCapture.Builder<>(recorder)
    .setVideoStabilizationEnabled(videoCapabilities.isStabilizationSupported())
    .build();

Aktive Aufzeichnung steuern

Sie können eine laufende Recording mit den folgenden Methoden pausieren, fortsetzen und beenden:

• pause, um die aktuelle Aufnahme zu pausieren.
• resume(), um eine pausierte aktive 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 verwendet, um Statistiken wie die aktuelle Dateigröße und die aufgezeichnete Zeitspanne aufzuzeichnen.
• 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 Ihre App einen EVENT_TYPE_FINALIZE erhält, der auf eine erfolgreiche Aufzeichnungssitzung hinweist, können Sie ü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-Visualisierungen 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:

when (event) {
    is VideoRecordEvent.Status -> {
        val audioStats = event.recordingStats.audioStats
        if (audioStats.hasAudio()) {
            val amplitude = audioStats.audioAmplitude
            updateAudioWaveform(amplitude)
        }
    }
    // ...
}

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 Highspeed-Videoaufnahmen, z. B. mit 120, 240 oder 480 fps, was zwei unterschiedliche 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 eingebunden“, 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 du die Hochgeschwindigkeitsaufzeichnung konfigurierst, frage die Hochgeschwindigkeitsfunktionen mit Recorder.getHighSpeedVideoCapabilities(CameraInfo) ab:

val highSpeedCapabilities = Recorder.getHighSpeedVideoCapabilities(cameraInfo)
if (highSpeedCapabilities == null) {
    // Camera does not support high-speed video capture
    return
}
val supportedQualities = highSpeedCapabilities.getSupportedQualities(DynamicRange.SDR)

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 die Anwendungsfälle VideoCapture und Preview 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. Frage die unterstützten Frameratenbereiche mit CameraInfo.getSupportedFrameRateRanges(SessionConfig) ab und lege 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:

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
)

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

Sie können 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:

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

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:

• Codelab „Erste Schritte mit CameraX“
• Offizielle CameraX-Beispiel-App
• Aktuelle Liste der CameraX Video Capture API
• CameraX-Versionshinweise
• CameraX-Quellcode
• High-Speed-Aufnahmen und Zeitlupenvideos mit CameraX 1.5