Nota: Esta página hace referencia al paquete Camera2. A menos que tu app requiera funciones específicas de bajo nivel de Camera2, te recomendamos que uses CameraX. CameraX y Camera2 admiten Android 5.0 (nivel de API 21) y versiones posteriores.
Las APIs de Camera2 admiten la captura de video de alto rango dinámico (HDR), que te permite obtener una vista previa y grabar contenido de video en HDR con la cámara. En comparación con el rango dinámico estándar (SDR), HDR ofrece un rango de colores más amplio y aumenta el rango dinámico del componente de luminancia (de los 100 cd/m2 actuales a miles de cd/m2). Esto da como resultado una calidad de video que se ajusta más a la vida real, con colores más nítidos, reflejos más brillantes y sombras más oscuras.
Mira cómo el video HDR captura un atardecer con detalles más vibrantes.
Requisitos previos del dispositivo
No todos los dispositivos Android admiten la captura de video en HDR. Antes de capturar videos HDR en tu app, determina si tu dispositivo cumple con los siguientes requisitos previos:
- Se orienta a Android 13 (nivel de API 33).
- Tiene un sensor de cámara compatible con 10 bits o más. Para obtener más información sobre la compatibilidad con HDR, consulta Cómo verificar la compatibilidad con HDR.
Como no todos los dispositivos cumplen con los requisitos previos, puedes agregar una ruta de código independiente cuando configures la captura de video HDR en tu app. Esto permite que tu app recurra a SDR en dispositivos incompatibles. Además, considera agregar una opción de IU para SDR. Luego, el usuario puede alternar entre SDR y HDR según sus necesidades de grabación de video.
Arquitectura de captura de HDR
En el siguiente diagrama, se muestran los componentes principales de la arquitectura de captura HDR.
Cuando un dispositivo de cámara captura un fotograma en HDR, el framework de Camera2 asigna un búfer que almacena el resultado procesado del sensor de la cámara. También adjunta los metadatos HDR respectivos si el perfil HDR lo requiere. Luego, el framework de Camera2 pone en cola el búfer propagado para la plataforma de salida a la que se hace referencia en CaptureRequest, como una pantalla o un codificador de video, como se muestra en el diagrama.
Cómo verificar la compatibilidad con HDR
Antes de capturar video HDR en tu app, determina si el dispositivo admite el perfil de HDR que elegiste.
Usa el método getCameraCharacteristics() de CameraManager para obtener una instancia de CameraCharacteristics, que puedes consultar para conocer las capacidades de HDR de tu dispositivo.
En los siguientes pasos, se verifica si un dispositivo admite HLG10. HLG10 es el estándar de HDR de referencia que los fabricantes de dispositivos deben admitir en las cámaras con salida de 10 bits.
Primero, verifica si el dispositivo admite perfiles de 10 bits (la profundidad de bits para HLG10):
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 }A continuación, verifica si el dispositivo admite HLG10 (u otro perfil compatible):
@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 chosen profile, in this case HLG10 return availableProfiles.contains(DynamicRangeProfiles.HLG10) } return false; }
Si el dispositivo admite HDR, isHLGSupported() siempre devuelve true. Para obtener más
información, consulta la documentación de referencia de
CameraCharacteristics.
Cómo configurar la captura en HDR
Después de asegurarte de que tu dispositivo admita HDR, configura tu app para capturar una transmisión de video HDR sin procesar desde la cámara. Usa setDynamicRangeProfile() para proporcionar el OutputConfiguration de la transmisión con un perfil HDR compatible con el dispositivo, que luego se pasa a CameraCaptureSession cuando se crea. Consulta la
lista de perfiles HDR compatibles.
En la siguiente muestra de código, setupSessionDynamicRangeProfile() primero verifica que el dispositivo ejecute Android 13. Luego, configura el CameraCaptureSession con el perfil de HDR compatible con el dispositivo como un OutputConfiguration:
/**
* Creates a [CameraCaptureSession] with a dynamic range profile.
*/
private fun setupSessionWithDynamicRangeProfile(
dynamicRange: Long,
device: CameraDevice,
targets: List<Surface>,
handler: Handler? = null,
stateCallback: CameraCaptureSession.StateCallback
): Boolean {
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.TIRAMISU) {
val outputConfigs = mutableListOf<OutputConfiguration>()
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
}
}
Cuando la app de la cámara inicializa la cámara, envía un CaptureRequest repetido para obtener una vista previa de la grabación:
session.setRepeatingRequest(previewRequest, null, cameraHandler)
Y también para iniciar la grabación de video:
// 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)
Codifica la transmisión de la cámara HDR
Para codificar la transmisión de la cámara HDR y escribir el archivo en el disco, usa MediaCodec.
Primero, obtén el resultado Surface, que se asigna a un búfer que almacena datos de video sin procesar. Para MediaCodec, usa
createInputSurface().
Para inicializar MediaCodec, una app debe crear un MediaFormat con un perfil de códec, un espacio de color, un rango de color y una función de transferencia especificados:
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)
Para obtener más detalles sobre la implementación, consulta EncoderWrapper.kt de la app de ejemplo de Camera2Video.
Formatos HDR
A partir de Android 13, los dispositivos de cámara con capacidades de salida de 10 bits deben admitir HLG10 para la captura y la reproducción de HDR. Además, los fabricantes de dispositivos pueden habilitar cualquier formato HDR que elijan con la arquitectura de captura HDR.
En la siguiente tabla, se resumen los formatos HDR disponibles y sus capacidades para la captura de video HDR.
| Formato | Función de transferencia (TF) | Metadatos | Códec | Profundidad de bits |
|---|---|---|---|---|
| HLG10 | HLG | No | HEVC | 10 bits |
| HDR10 | PQ | Estática | HEVC | 10 bits |
| HDR10+ | PQ | Dinámico | HEVC | 10 bits |
| Dolby Vision 8.4 | HLG | Dinámico | HEVC | 10 bits |
Recursos
Para obtener una app de trabajo con la funcionalidad de captura de video HDR, consulta la muestra de Camera2Video en GitHub.