Capture vidéo HDR

Remarque:Cette page fait référence au package Camera2. Nous vous recommandons d'utiliser CameraX, sauf si votre application nécessite des fonctionnalités spécifiques de base de Camera2. CameraX et Camera2 sont compatibles avec Android 5.0 (niveau d'API 21) ou version ultérieure.

Compatibilité des API Camera2 La capture vidéo HDR (High Dynamic Range) vous permet de prévisualiser et enregistrer des contenus vidéo HDR à l'aide de votre caméra. Par rapport aux créations dynamiques standards SDR, le HDR offre une gamme de couleurs plus étendue et augmente l'intensité de la composante de luminance (de 100 cd/m2 actuellement à des milliers de cd/m2). Vous obtenez ainsi une qualité vidéo plus proche de la réalité, avec des couleurs plus riches, des tons clairs plus lumineux et des ombres plus sombres.

Découvrez comment la vidéo HDR capture un coucher de soleil avec plus de détails.

</ph> <ph type="x-smartling-placeholder">

Conditions préalables pour l'appareil

Tous les appareils Android ne sont pas compatibles avec la capture vidéo HDR. Avant d'enregistrer une vidéo HDR dans votre application, déterminez si votre appareil respecte les les conditions préalables suivantes:

• Cible Android 13 (niveau d'API 33).
• possède un capteur photo de 10 bits ou plus. Pour en savoir plus sur la technologie HDR, Consultez Vérifier la compatibilité HDR.

Étant donné que tous les appareils ne remplissent pas les conditions préalables, vous pouvez ajouter un code distinct lors de la configuration de la capture vidéo HDR dans votre application. Cela permet à votre application de revenir au format SDR sur les appareils non compatibles. Envisagez également d'ajouter une option d'UI pour la SDR. L'utilisateur peut ensuite activer ou désactiver entre les SDR et HDR pour leurs besoins d'enregistrement vidéo.

Architecture de capture HDR

Le schéma suivant illustre les principaux composants de l'architecture de capture HDR.

Lorsqu'un appareil photo capture une image en HDR, le framework Camera2 attribue qui stocke la sortie traitée du capteur de l'appareil photo. Si le profil HDR l'exige, les métadonnées HDR correspondantes sont également jointes. Le framework Camera2 met ensuite en file d'attente le tampon rempli pour la surface de sortie. référencées dans le CaptureRequest, comme un affichage ou vidéo, comme illustré dans le schéma.

Vérifier la compatibilité HDR

Avant d'enregistrer une vidéo HDR dans votre application, déterminez si l'appareil est compatible le profil HDR souhaité.

Utilisez la méthode CameraManager getCameraCharacteristics() pour obtenir une CameraCharacteristics que vous pouvez interroger pour connaître les fonctionnalités HDR de votre appareil.

Les étapes suivantes permettent de vérifier si un appareil est compatible avec le protocole HLG10. HLG10 est la norme HDR de référence que les fabricants d'appareils doivent prendre en charge. sur les caméras dotées d'une sortie 10 bits.

1. Tout d'abord, vérifiez si l'appareil est compatible avec les profils 10 bits (profondeur de bits pour 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
   }
   

2. Vérifiez ensuite si l'appareil est compatible avec le protocole HLG10 (ou un autre profil compatible):

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

Si l'appareil est compatible avec la technologie HDR, isHLGSupported() renvoie toujours true. Pour en savoir plus, consultez les CameraCharacteristics documentation de référence.

Configurer la capture HDR

Après vous être assuré que votre appareil est compatible avec la technologie HDR, configurez votre application pour effectuer des captures un flux vidéo HDR brut provenant de la caméra. Utilisez setDynamicRangeProfile() pour indiquer l'attribut OutputConfiguration de la diffusion. avec un profil HDR compatible avec l'appareil, qui est ensuite transmis à la CameraCaptureSession lors de leur création. Consultez la liste des profils HDR compatibles.

Dans l'exemple de code suivant, setupSessionDynamicRangeProfile() vérifie d'abord que l'appareil est sous Android 13. Il configure ensuite CameraCaptureSession avec les paramètres Profil HDR en tant que OutputConfiguration:

  /**
  * 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
      }
  }

}
  
  

Lorsque l'application d'appareil photo initialise la caméra, elle envoie une répétitive CaptureRequest pour prévisualiser l'enregistrement:

session.setRepeatingRequest(previewRequest, null, cameraHandler)

Pour lancer l'enregistrement vidéo:

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

Encoder le flux de l'appareil photo HDR

Pour encoder le flux de l'appareil photo HDR et écrire le fichier sur le disque, utilisez MediaCodec.

Tout d'abord, obtenez OutputSurface. qui correspond à un tampon qui stocke des données vidéo brutes. Pour MediaCodec, utilisez createInputSurface().

Pour initialiser MediaCodec, une application doit créer un MediaFormat par un profil de codec, espace colorimétrique, plage de couleurs et fonction de transfert:

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)

Pour en savoir plus sur l'implémentation, consultez l'exemple d'application Camera2Video EncoderWrapper.kt

Formats HDR

À partir d'Android 13, les appareils photo avec des capacités de sortie 10 bits doit être compatible avec le protocole HLG10 pour la capture HDR. lecture. De plus, les fabricants d'appareils peuvent activer le format HDR de leur choix. à l'aide de l'architecture de capture HDR.

Le tableau suivant récapitule les formats HDR disponibles et leurs capacités. pour la capture vidéo HDR.

Ressources

Pour une application fonctionnelle dotée de la fonctionnalité de capture vidéo HDR, consultez la Exemple de Camera2Video sur GitHub.