Gestion des couleurs

Android 8.1 et versions ultérieures incluent la prise en charge de la gestion des couleurs qui peut être utilisée pour offrir une expérience cohérente sur toutes les technologies d'affichage. Les applications fonctionnant sur Android peuvent accéder à toutes les capacités d'un écran à large gamme pour tirer le meilleur parti d'un périphérique d'affichage.

Les versions précédentes d'Android n'incluaient pas de prise en charge de la gestion des couleurs et reposaient plutôt sur la compatibilité du contenu et des écrans (un objectif souvent soutenu par l'industrie de la télévision). Cependant, les technologies d'affichage récentes permettent des affichages à gamme beaucoup plus large qui n'affichent pas le contenu existant comme prévu. Avec Android 8.1 et versions ultérieures, les appareils qui utilisent un écran à large gamme (par exemple, une diode électroluminescente organique à matrice active ou AMOLED, certains écrans LCD) peuvent voir le contenu à large gamme des applications.

Déterminer la prise en charge des appareils

Les appareils dotés d'écrans larges couleurs exécutant Android 8.1 ou version ultérieure doivent prendre en charge la gestion des couleurs (larges couleurs). Avant d'activer cette fonctionnalité, assurez-vous que l'appareil répond aux exigences suivantes :

  • L'affichage de l'appareil répond aux exigences matérielles, qui incluent un affichage bien caractérisé prenant en charge l'espace colorimétrique Display-P3. Si l'écran ne répond pas à cette exigence, n'activez pas la gestion des couleurs. Pour réduire l’impact du CPU et du GPU, la prise en charge des formats sRGB et HDR10 étendus dans le pipeline d’affichage est souhaitable.
  • L'appareil prend en charge un processus d'étalonnage en usine qui génère des données d'étalonnage (stockées sur l'appareil) pour ajuster les variations de fabrication du comportement d'affichage. Au minimum, les données d'étalonnage doivent permettre à l'écran d'afficher avec précision le contenu sRGB et les points blancs D65 et D73.

Si ces conditions sont remplies, vous pouvez activer la fonction de gestion des couleurs pour le périphérique.

Implémenter la gestion des couleurs

Pour implémenter la gestion des couleurs, mettez d'abord à jour le pilote Hardware Composer 2 (HWC2) pour comprendre les modes de couleur et appliquer ces modes au matériel. Plus précisément, le compositeur HWC2 doit signaler les modes de couleur Display-P3 et sRGB à l'aide de HWCDisplay::GetColorModes .

Ensuite, activez les extensions OpenGL nécessaires et la prise en charge de la bibliothèque pour traduire les espaces colorimétriques OpenGL en espaces de données HAL. Les extensions OpenGL requises incluent :

  • EGL_EXT_pixel_format_float . Permet aux applications de créer des EGLSurfaces présentables avec des composants de couleur flottante 16 bits. Priorité : élevée (attendez-vous à ce qu'il s'agisse du format de pixel par défaut pour les applications prenant en charge les couleurs larges). Nécessite l’assistance du pilote.
  • EGL_KHR_gl_colorspace . Pour les applications qui souhaitent utiliser les framebuffers par défaut au format sRGB pour obtenir plus facilement un rendu sRGB sur les appareils d'affichage, cette extension permet de créer des EGLSurfaces qui seront restituées en sRGB par les contextes OpenGL prenant en charge cette fonctionnalité. Nécessite la prise en charge du pilote pour le comportement sRGB.

Android fournit également les extensions facultatives suivantes :

  • EGL_EXT_colorspace_scrgb_linear . Cette extension fournit une nouvelle option d'espace colorimétrique, scRGB, que les applications peuvent choisir lors de la création d'une EGLSurface. L'espace colorimétrique scRGB définit un espace d'affichage linéaire avec les mêmes points blancs et couleurs primaires que sRGB (et est donc rétrocompatible avec sRGB). Cela ne devrait pas nécessiter la prise en charge du pilote et peut être implémenté dans le wrapper Android EGL. Pour être utile, cette extension nécessite la prise en charge de la virgule flottante 16 bits (FP16).
  • EGL_EXT_gl_colorspace_display_p3 et EGL_EXT_gl_colorspace_display_p3_linear . Pour les applications qui souhaitent utiliser les framebuffers par défaut du format Display-P3 pour obtenir plus facilement un rendu sRGB sur les appareils d'affichage, cette extension permet de créer des EGLSurfaces qui seront rendues dans Display-P3 par des contextes OpenGL prenant en charge cette fonctionnalité. Cela peut être implémenté dans le wrapper de pilote EGL.
  • VK_EXT_swapchain_colorspace (Vulkan). Permet aux applications d'étiqueter les chaînes d'échange avec l'espace colorimétrique qu'elles utilisent. Comprend un certain nombre d'espaces colorimétriques courants tels que DCI-P3, Display-P3, AdobeRGB et BT2020.

Personnalisation

Vous pouvez personnaliser la fonctionnalité de gestion des couleurs en incluant la prise en charge d'une variété de normes de couleur telles que DCI-P3, AdobeRGB, Rec709 et Rec2020. Les autres personnalisations incluent :

  • Prise en charge matérielle pour la conversion des couleurs dans le pipeline d'affichage. Permet la prise en charge de plusieurs transformations de couleurs dans le matériel.
  • Prise en charge de la transformation de couleur indépendante sur plusieurs calques (par exemple, certains calques peuvent être sRVB et d'autres sRVB étendu, chacun avec son propre pipeline de couleurs). Lorsque plusieurs espaces colorimétriques sont visibles, certains espaces colorimétriques doivent être convertis en espace colorimétrique de l’écran. Idéalement, cette transformation est mieux assurée par le moteur d'affichage (sinon Android doit effectuer la composition GPU).

Essai

Pour tester la gestion des couleurs, utilisez les ressources suivantes dans opengl/tests :

  • gl2_basic est une simple démo OpenGL qui demande un espace colorimétrique Display-P3.
  • EGL_test teste la prise en charge des extensions et des configurations nécessaires (10:10:10:2 et FP16).
  • test_wide_color crée une surface de la même manière que SurfaceFlinger (par exemple, configuration, espace colorimétrique et format de pixel).

Implémentation de référence

Pour une implémentation de référence, reportez-vous à frameworks/native . Pour les en-têtes, reportez-vous à :