Acquisizione video HDR

Nota: questa pagina si riferisce al pacchetto Camera2. A meno che la tua app non richieda funzionalità specifiche di basso livello di Camera2, ti consigliamo di usare CameraX. Sia CameraX che Camera2 supportano Android 5.0 (livello API 21) e versioni successive.

Il supporto delle API Camera2 L'acquisizione video HDR (High Dynamic Range), che consente di visualizzare in anteprima e Registrare contenuti video HDR utilizzando la fotocamera. Rispetto agli annunci dinamici standard Range (SDR), l'HDR offre una gamma più ampia di colori e aumenta la della componente di luminanza (dagli attuali 100 cd/m2 a 1000s di cd/m2). Ciò si traduce in una qualità video che rispecchia meglio la vita reale, con colori più intensi, alte luci più luminose e ombre più scure.

Scopri come i video HDR catturano un tramonto con dettagli più intensi.

di Gemini Advanced.

Prerequisiti del dispositivo

Non tutti i dispositivi Android supportano l'acquisizione di video HDR. Prima di acquisire video HDR nell'app, verifica se il dispositivo soddisfa i seguenti prerequisiti:

• Ha come target Android 13 (livello API 33).
• Dispone di un sensore della fotocamera con risoluzione minima di 10 bit o superiore. Per ulteriori informazioni su HDR Per l'assistenza, vedi Verificare il supporto HDR.

Poiché non tutti i dispositivi soddisfano i prerequisiti, puoi aggiungere un codice separato quando configuri l'acquisizione video HDR nell'app. In questo modo la tua app può ricorrere a SDR sui dispositivi non compatibili. Valuta anche l'aggiunta di un'opzione di UI per SDR. L'utente può quindi attivare/disattivare tra SDR e HDR per le loro esigenze di registrazione video.

Architettura di acquisizione HDR

Il seguente diagramma mostra i componenti principali dell'architettura di acquisizione HDR.

Quando un dispositivo con una fotocamera acquisisce un fotogramma in HDR, il framework Camera2 assegna un buffer che memorizza l'uscita elaborata del sensore della videocamera. Inoltre, allega i rispettivi metadati HDR, se richiesto dal profilo HDR. Il framework Camera2 accoda quindi il buffer popolato per la superficie di output a cui viene fatto riferimento in CaptureRequest, ad esempio una visualizzazione come mostrato in figura.

Verificare il supporto HDR

Prima di acquisire video HDR nell'app, determina se il dispositivo supporta il profilo HDR desiderato.

Utilizza il metodo CameraManager getCameraCharacteristics() per ottenere un CameraCharacteristics su cui puoi eseguire query per verificare le funzionalità HDR del tuo dispositivo.

I passaggi seguenti consentono di verificare se un dispositivo supporta HLG10. HLG10 è lo standard HDR di base che i produttori di dispositivi devono supportare sulle videocamere con output a 10 bit.

1. Per prima cosa, verifica se il dispositivo supporta profili a 10 bit (la profondità in bit per 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. Verifica quindi se il dispositivo supporta HLG10 (o un altro profilo supportato):

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

Se il dispositivo supporta HDR, isHLGSupported() restituisce sempre true. Per ulteriori informazioni, consulta CameraCharacteristics documentazione di riferimento.

Configura l'acquisizione HDR

Dopo aver verificato che il dispositivo supporti l'HDR, configura l'app per l'acquisizione uno stream video HDR RAW dalla fotocamera. Utilizza setDynamicRangeProfile() per fornire il OutputConfiguration dello stream con un profilo HDR supportato dal dispositivo, che viene poi passato al CameraCaptureSession al momento della creazione. Consulta l'elenco dei profili HDR supportati.

Nel seguente esempio di codice, setupSessionDynamicRangeProfile() esegue prima un controllo che sul dispositivo è installato Android 13. Quindi configura CameraCaptureSession con l'app supportata dal dispositivo Profilo HDR come 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
      }
  }

}
  
  

Quando l'app Fotocamera inizializza la fotocamera, invia un si ripete CaptureRequest per visualizzare l'anteprima della registrazione:

session.setRepeatingRequest(previewRequest, null, cameraHandler)

E anche per avviare la registrazione 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 lo stream della videocamera HDR

Per codificare lo stream della videocamera HDR e scrivere il file su disco: utilizza MediaCodec.

Innanzitutto, richiedi OutputSurface, che viene mappato a un buffer che memorizza i dati video non elaborati. Per MediaCodec, utilizza createInputSurface().

Per inizializzare MediaCodec, un'app deve creare un oggetto MediaFormat con un valore specifico profilo codec, spazio colore, gamma di colori e funzione di trasferimento:

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)

Per ulteriori dettagli sull'implementazione, consulta la sezione di esempio dell'app Camera2Video EncoderWrapper.kt

Formati HDR

A partire da Android 13, i dispositivi con fotocamera con funzionalità di output a 10 bit deve supportare HLG10 per l'acquisizione HDR riproduzione. Inoltre, i produttori possono abilitare qualsiasi formato HDR a loro scelta utilizzando l'architettura di acquisizione HDR.

La seguente tabella riassume i formati HDR disponibili e le loro funzionalità per l'acquisizione video HDR.

Risorse

Per un'app funzionante con funzionalità di acquisizione video HDR, consulta le Esempio di Camera2Video su GitHub.