Diese Seite wurde von der Cloud Translation API übersetzt.

HDR-Videoaufnahme

Hinweis:Diese Seite bezieht sich auf das Camera2-Paket. Sofern für Ihre App keine spezifischen Low-Level-Funktionen von Camera2 erforderlich sind, empfehlen wir die Verwendung von CameraX. Sowohl CameraX als auch Camera2 unterstützen Android 5.0 (API-Level 21) und höher.

Unterstützung für Camera2 APIs HDR-Videoaufzeichnung (High Dynamic Range), mit der Sie eine Vorschau HDR-Videos mit der Kamera aufnehmen. Im Vergleich zu standardmäßigen dynamischen Creatives Range (SDR), HDR bietet einen größeren Farbraum und erhöht die Dynamik Bereich der Leuchtdichtekomponente (von den aktuellen 100 cd/m2 bis zu 1.000 cd/m2) Die Videoqualität entspricht eher dem realen Leben, kräftigere Farben, hellere Spitzlichter und dunklere Schatten.

Sieh dir an, wie HDR-Videos einen Sonnenuntergang mit leuchtenden Details aufnehmen.

</ph> **Abbildung 1**: Vergleich der Videoqualität von SDR (oben) und HDR (unten).

Erforderliche Geräte

HDR-Videoaufnahmen werden nicht von allen Android-Geräten unterstützt. Prüfen Sie vor dem Aufnehmen von HDR-Videos in Ihrer App, ob Ihr Gerät die die folgenden Voraussetzungen erfüllen:

Ausrichtung auf Android 13 (API-Level 33).
Der Kamerasensor muss mindestens 10 Bit lang sein. Weitere Informationen zu HDR Informationen zur Unterstützung finden Sie unter HDR-Unterstützung prüfen.

Da nicht alle Geräte die Voraussetzungen erfüllen, können Sie einen separaten Code hinzufügen wenn du die HDR-Videoaufnahme in deiner App einrichtest. Dadurch kann deine App auf inkompatiblen Geräten auf SDR zurückgreifen. Du kannst auch eine UI-Option für SDR hinzufügen. Der Nutzer kann dann zwischen SDR und HDR wählen.

Architektur bei HDR-Aufnahmen

Das folgende Diagramm zeigt die Hauptkomponenten der Architektur für HDR-Aufnahmen.

</ph> **Abbildung 2**: Architekturdiagramm für HDR-Aufnahme

Wenn ein Kameragerät einen Frame in HDR aufnimmt, weist das Camera2-Framework einen Zwischenspeicher, in dem die verarbeitete Kamerasensorausgabe gespeichert wird. Außerdem werden die entsprechenden HDR-Metadaten angehängt, wenn dies für das HDR-Profil erforderlich ist. Das Camera2-Framework stellt dann den gefüllten Zwischenspeicher für die Ausgabeoberfläche in die Warteschlange auf die im CaptureRequest verwiesen wird, etwa ein Display- oder wie in der Abbildung dargestellt.

HDR-Unterstützung prüfen

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

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

Mit den folgenden Schritten kannst du prüfen, ob ein Gerät HLG10 unterstützt. HLG10 ist der grundlegende HDR-Standard, den Gerätehersteller unterstützen müssen bei Kameras mit 10-Bit-Ausgang.

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

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 CameraCharacteristics in der Referenzdokumentation.

HDR-Aufnahme einrichten

Stelle sicher, dass dein Gerät HDR unterstützt, und richte deine App für Aufnahmen ein einen unbearbeiteten HDR-Videostream von der Kamera. Verwende setDynamicRangeProfile(), um die OutputConfiguration des Streams anzugeben. mit einem geräteunterstützten HDR-Profil, das dann an CameraCaptureSession bei der Erstellung. Hier findest du eine Liste der unterstützten HDR-Profile.

Im folgenden Codebeispiel prüft setupSessionDynamicRangeProfile() zuerst ob auf dem Gerät Android 13 installiert ist. Dann wird das CameraCaptureSession mit den geräteunterstützten HDR-Profil als OutputConfiguration:

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, wird wiederholt CaptureRequest um eine Vorschau der Aufzeichnung anzusehen:

Kotlin

session.setRepeatingRequest(previewRequest, null, cameraHandler)

Und um die Videoaufzeichnung zu starten:

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

So codieren Sie den HDR-Kamerastream und schreiben die Datei auf die Festplatte: Verwenden Sie MediaCodec.

Holen Sie sich zuerst das OutputSurface, die einem Zwischenspeicher zugeordnet ist, in dem Videorohdaten gespeichert werden. Für MediaCodec, Verwenden Sie createInputSurface().

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

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 finden Sie in der EncoderWrapper.kt

HDR-Formate

Ab Android 13 werden Kameras mit 10-Bit-Ausgabefunktionen muss HLG10 für HDR-Aufnahmen unterstützen und playback: Außerdem können Gerätehersteller jedes HDR-Format ihrer Wahl aktivieren. mit der HDR-Aufnahmearchitektur.

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

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

Ressourcen

Eine funktionierende App mit HDR-Videoaufnahmefunktion finden Sie in der Videobeispiel für Kamera2 auf GitHub.