Diese Seite wurde von der Cloud Translation API übersetzt.

HDR-Videoaufnahme

Hinweis:Diese Seite bezieht sich auf das Paket Camera2. Sofern Ihre App keine bestimmten Low-Level-Funktionen von Camera2 erfordert, empfehlen wir die Verwendung von CameraX. CameraX und Camera2 unterstützen Android 5.0 (API-Level 21) und höher.

Die Camera2 APIs unterstützen die Videoaufnahme in HDR (High Dynamic Range), sodass Sie HDR-Videos mit Ihrer Kamera in der Vorschau ansehen und aufnehmen können. Im Vergleich zu Standard Dynamic Range (SDR) bietet HDR einen größeren Farbbereich und vergrößert den dynamischen Bereich der Leuchtdichtekomponente (von aktuellen 100 cd/m2 auf 1.000 cd/m2). Das Ergebnis ist eine Videoqualität, die der Realität besser entspricht – mit satteren Farben, helleren Spitzlichtern und dunkleren Schatten.

Sieh dir an, wie du mit HDR-Videos einen Sonnenuntergang mit brillanteren Details einfangen kannst.

**Abbildung 1.** Vergleich der Videoqualität von SDR (oben) und HDR (unten)

Gerätevoraussetzungen

Nicht alle Android-Geräte unterstützen die Aufnahme von HDR-Videos. Bevor du ein HDR-Video in deiner App aufnimmst, prüfe, ob dein Gerät die folgenden Voraussetzungen erfüllt:

Ist auf Android 13 (API-Level 33) ausgerichtet.
Das Smartphone verfügt über einen 10-Bit-fähigen Kamerasensor oder höher. Weitere Informationen zum HDR-Support findest du unter HDR-Support prüfen.

Da nicht alle Geräte die Voraussetzungen erfüllen, kannst du beim Einrichten der HDR-Videoaufnahme in deiner App einen separaten Codepfad hinzufügen. Dadurch kann deine App auf inkompatiblen Geräten auf SDR zurückgreifen. Erwägen Sie auch, eine UI-Option für SDR hinzuzufügen. Der Nutzer kann dann je nach Videoaufnahme zwischen SDR und HDR wechseln.

Architektur von HDR-Aufnahmen

Das folgende Diagramm zeigt die Hauptkomponenten der HDR-Erfassungsarchitektur.

**Abbildung 2.** Diagramm der HDR-Erfassungsarchitektur

Wenn ein Kameragerät einen Frame in HDR erfasst, weist das Framework Camera2 einen Zwischenspeicher zu, in dem die verarbeitete Ausgabe des Kamerasensors gespeichert wird. Außerdem werden die entsprechenden HDR-Metadaten angehängt, falls diese für das HDR-Profil erforderlich sind. Das Camera2-Framework stellt dann den ausgefüllten Zwischenspeicher für die Ausgabeoberfläche, auf die in CaptureRequest verwiesen wird, in die Warteschlange, z. B. einen Display- oder Videoencoder, wie im Diagramm dargestellt.

HDR-Unterstützung prüfen

Bevor Sie ein HDR-Video in Ihrer App aufnehmen, prüfen Sie, ob das Gerät das gewünschte HDR-Profil unterstützt.

Verwenden Sie die Methode CameraManager getCameraCharacteristics(), um eine CameraCharacteristics-Instanz zu erhalten, die Sie nach den HDR-Funktionen Ihres Geräts abfragen können.

Mit den folgenden Schritten wird geprüft, ob ein Gerät HLG10 unterstützt. HLG10 ist der grundlegende HDR-Standard, den Gerätehersteller bei Kameras mit 10-Bit-Ausgabe unterstützen müssen.

Prüfe zuerst, ob das Gerät 10-Bit-Profile (die Bittiefe für HLG10) unterstützt:

Kotlin

private fun isTenBitProfileSupported(cameraId: String): Boolean {
  val cameraCharacteristics = cameraManager.getCameraCharacteristics(cameraId)
  val availableCapabilities = cameraCharacteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES)
  for (capability in availableCapabilities!!) {
      if (capability == CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT) {
          return true
      }
  }
  return false
}

Prüfe als Nächstes, ob das Gerät HLG10 oder ein anderes unterstütztes Profil unterstützt:

Kotlin

@RequiresApi(api = 33)
private fun isHLGSupported(cameraId: String): Boolean {
if (isTenBitProfileSupported(cameraId)) {
  Val cameraCharacteristics = cameraManager.getCameraCharacteristics(cameraId)
  val availableProfiles = cameraCharacteristics
  .get(CameraCharacteristics.REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES)!!
  .getSupportedProfiles()

  // Checks for the desired profile, in this case HLG10
  return availableProfiles.contains(DynamicRangeProfiles.HLG10)
}
return false;
}

Wenn das Gerät HDR unterstützt, gibt isHLGSupported() immer true zurück. Weitere Informationen finden Sie in der Referenzdokumentation zu CameraCharacteristics.

HDR-Aufnahme einrichten

Nachdem du sichergestellt hast, dass dein Gerät HDR unterstützt, richte deine App so ein, dass ein HDR-Rohvideostream von der Kamera aufgenommen wird. Verwende setDynamicRangeProfile(), um dem OutputConfiguration-Profil des Streams ein geräteunterstütztes HDR-Profil bereitzustellen, das dann bei der Erstellung an CameraCaptureSession übergeben wird. Hier finden Sie eine Liste der unterstützten HDR-Profile.

Im folgenden Codebeispiel prüft setupSessionDynamicRangeProfile() zuerst, ob auf dem Gerät Android 13 ausgeführt wird. Dann richtet sie CameraCaptureSession mit dem vom Gerät unterstützten HDR-Profil als OutputConfiguration ein:

Kotlin

  /**
  * Creates a [CameraCaptureSession] with a dynamic range profile.
  */
  private fun setupSessionWithDynamicRangeProfile(
          dynamicRange: Long,
          device: CameraDevice,
          targets: List,
          handler: Handler? = null,
          stateCallback: CameraCaptureSession.StateCallback
  ): Boolean {
      if (android.os.Build.VERSION.SDK_INT >=
              android.os.Build.VERSION_CODES.TIRAMISU) {
          val outputConfigs = mutableListOf()
              for (target in targets) {
                  val outputConfig = OutputConfiguration(target)
                  //sets the dynamic range profile, for example DynamicRangeProfiles.HLG10
                  outputConfig.setDynamicRangeProfile(dynamicRange)
                  outputConfigs.add(outputConfig)
              }
          device.createCaptureSessionByOutputConfigurations(
                  outputConfigs, stateCallback, handler)
          return true
      } else {
          device.createCaptureSession(targets, stateCallback, handler)
          return false
      }
  }

}

Wenn die Kamera-App die Kamera initialisiert, sendet sie ein sich wiederholendes CaptureRequest, um sich eine Vorschau der Aufnahme anzusehen:

Kotlin

session.setRepeatingRequest(previewRequest, null, cameraHandler)

So starten Sie die Videoaufnahme:

Kotlin

// Start recording repeating requests, which stops the ongoing preview
//  repeating requests without having to explicitly call
//  `session.stopRepeating`
session.setRepeatingRequest(recordRequest,
        object : CameraCaptureSession.CaptureCallback() {
    override fun onCaptureCompleted(session: CameraCaptureSession,
            request: CaptureRequest, result: TotalCaptureResult) {
        if (currentlyRecording) {
            encoder.frameAvailable()
        }
    }
}, cameraHandler)

HDR-Kamerastream codieren

Verwenden Sie MediaCodec, um den HDR-Kamerastream zu codieren und die Datei auf das Laufwerk zu schreiben.

Rufen Sie zuerst das OutputSurface ab, das einem Zwischenspeicher zugeordnet ist, in dem Videorohdaten gespeichert werden. Verwenden Sie für MediaCodec createInputSurface().

Zum Initialisieren von MediaCodec muss eine App eine MediaFormat mit einem angegebenen Codec-Profil, Farbraum, Farbbereich und einer Übertragungsfunktion erstellen:

Kotlin

val mimeType = when {
    dynamicRange == DynamicRangeProfiles.STANDARD -> MediaFormat.MIMETYPE_VIDEO_AVC
    dynamicRange < DynamicRangeProfiles.PUBLIC_MAX ->
            MediaFormat.MIMETYPE_VIDEO_HEVC
    else -> throw IllegalArgumentException("Unknown dynamic range format")
}

val codecProfile = when {
    dynamicRange == DynamicRangeProfiles.HLG10 ->
            MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10
    dynamicRange == DynamicRangeProfiles.HDR10 ->
            MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10HDR10
    dynamicRange == DynamicRangeProfiles.HDR10_PLUS ->
            MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10HDR10Plus
    else -> -1
}
// Failing to correctly set color transfer causes quality issues
// for example, washout and color clipping
val transferFunction = when (codecProfile) {
    MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10 ->
            MediaFormat.COLOR_TRANSFER_HLG
    MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10HDR10 ->
            MediaFormat.COLOR_TRANSFER_ST2084
    MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10HDR10Plus ->
            MediaFormat.COLOR_TRANSFER_ST2084
    else -> MediaFormat.COLOR_TRANSFER_SDR_VIDEO
}

val format = MediaFormat.createVideoFormat(mimeType, width, height)

// Set some properties.  Failing to specify some of these can cause the MediaCodec
// configure() call to throw an exception.
format.setInteger(MediaFormat.KEY_COLOR_FORMAT,
        MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface)
format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate)
format.setInteger(MediaFormat.KEY_FRAME_RATE, frameRate)
format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, IFRAME_INTERVAL)

if (codecProfile != -1) {
    format.setInteger(MediaFormat.KEY_PROFILE, codecProfile)
    format.setInteger(MediaFormat.KEY_COLOR_STANDARD,
            MediaFormat.COLOR_STANDARD_BT2020)
    format.setInteger(MediaFormat.KEY_COLOR_RANGE, MediaFormat.COLOR_RANGE_LIMITED)
    format.setInteger(MediaFormat.KEY_COLOR_TRANSFER, transferFunction)
    format.setFeatureEnabled(MediaCodecInfo.CodecCapabilities.FEATURE_HdrEditing,
            true)
}

mediaCodec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)

Weitere Informationen zur Implementierung findest du in der Camera2Video-Beispiel-App EncoderWrapper.kt.

HDR-Formate

Ab Android 13 müssen Kameras mit 10-Bit-Ausgabefunktionen HLG10 für HDR-Aufnahmen und -Wiedergabe unterstützen. Mit der HDR-Erfassungsarchitektur können Gerätehersteller außerdem jedes HDR-Format ihrer Wahl aktivieren.

In der folgenden Tabelle sind die verfügbaren HDR-Formate und ihre Funktionen für die HDR-Videoaufnahme zusammengefasst.

Formatieren	Übertragungsfunktion (TF)	Metadaten	Codec	Bittiefe
HLG10	HLG	Nein	Logo: HEVC	10-Bit
HDR10	PQ	Statisch	Logo: HEVC	10-Bit
HDR10+	PQ	Dynamisch	Logo: HEVC	10-Bit
Dolby Vision 8.4	HLG	Dynamisch	Logo: HEVC	10-Bit

Ressourcen

Eine funktionierende Anwendung mit HDR-Videoaufnahmefunktion finden Sie im Camera2Video-Beispiel auf GitHub.