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 type="x-smartling-placeholder">
<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.
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 }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:
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
}
}
}
Lorsque l'application d'appareil photo initialise la caméra, elle envoie une
répétitive
CaptureRequest
pour prévisualiser l'enregistrement:
Kotlin
session.setRepeatingRequest(previewRequest, null, cameraHandler)
Pour lancer l'enregistrement vidéo:
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)
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:
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)
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.
| Format | Fonction de transfert (TF) | Métadonnées | Codec | Profondeur de bit |
|---|---|---|---|---|
| HLG10 | HLG | Non | HEVC | 10 bits |
| HDR10 | PQ | Statique | HEVC | 10 bits |
| HDR10+ | PQ | Dynamique | HEVC | 10 bits |
| Dolby Vision 8.4 | HLG | Dynamique | HEVC | 10 bits |
Ressources
Pour une application fonctionnelle dotée de la fonctionnalité de capture vidéo HDR, consultez la Exemple de Camera2Video sur GitHub.