Migrer depuis RenderScript

Les API RenderScript sont obsolètes à partir d'Android 12. Elles continueront de fonctionner, mais nous nous attendons à ce que les fabricants d'appareils et de composants ne fournissent plus d'assistance pour l'accélération matérielle au fil du temps. Pour profiter pleinement de l'accélération du GPU, nous vous recommandons de migrer vos scripts vers Vulkan ou d'utiliser notre kit de remplacement pour abandonner les fonctionnalités intrinsèques.

Suite à l'abandon de RenderScript sur la plate-forme Android, nous supprimons également la compatibilité du plug-in Android Gradle avec RenderScript. À partir de la version 7.2 du plug-in Android Gradle, les API RenderScript sont obsolètes. Elles continueront de fonctionner, mais déclencheront des avertissements et seront complètement supprimées dans les futures versions d'AGP. Ce guide explique comment effectuer la migration depuis RenderScript.

Migrer depuis les fonctionnalités intrinsèques

Bien que les fonctionnalités intrinsèques de RenderScript continueront à fonctionner après l'abandon de RenderScript, il est possible qu'elles ne puissent s'exécuter que sur le processeur et non plus sur le GPU.

Si votre application utilise des fonctionnalités intrinsèques, vous pouvez utiliser la bibliothèque de remplacement autonome. Cette option sera, d'après nos tests, plus rapide que d'utiliser la mise en œuvre existante du processeur RenderScript.

Ce kit comprend les fonctions suivantes :

  • Mélange
  • Floutage
  • Matrice de couleurs
  • Convoluer
  • Histogramme et histogramDot
  • Tableau de conversion (LUT) et LUT 3D
  • Redimensionner
  • YUV vers RVB

Pour en savoir plus et connaître les limites, consultez les fichiers README.md et Toolkit.kt du kit.

Pour télécharger, ajouter et utiliser la bibliothèque, procédez comme suit :

  1. Téléchargez le projet sur GitHub.

  2. Localisez et créez le renderscript-toolkit module.

  3. Ajoutez la bibliothèque à votre projet Android Studio en modifiant le fichier build.gradle de l'application.

  4. Appelez la méthode appropriée dans le kit.

Exemple : Migrer depuis la fonction ScriptIntrinsicBlur

Pour remplacer la fonction ScriptIntrinsicBlur :

  • Pour flouter un bitmap, appelez Toolkit.blur.

    var blurredBitmap = Toolkit.blur(myBitmap, radius)
    
  • Si vous souhaitez flouter une image représentée par un tableau d'octets, spécifiez la largeur, la hauteur et le nombre d'octets par pixel.

    val outArray = Toolkit.blur(inputArray, bytesPerPixel, width, height, radius)
    

Si vous ciblez Android 12 (niveau d'API 31) ou version ultérieure, envisagez d'utiliser la classe RenderEffect au lieu de Toolkit.blur().

Migrer depuis les scripts

Pour profiter pleinement de l'accélération du GPU, nous vous recommandons de migrer les scripts RenderScript vers l'API multiplate-forme Vulkan. Bien que vos scripts continueront de s'exécuter même si vous ne migrez pas, il se peut qu'ils s'exécutent sur le processeur plutôt que sur le GPU, en fonction de la disponibilité des pilotes.

Pour mieux comprendre comment migrer des fonctionnalités, consultez l'application exemple. L'exemple montre comment flouter un bitmap et effectuer une conversion de la matrice de couleurs dans RenderScript, et présente un code équivalent dans Vulkan.

Si votre application doit être compatible avec plusieurs versions, utilisez RenderScript pour les appareils équipés d'Android 9 (niveau d'API 28) ou version antérieure, et Vulkan pour Android 10 (niveau d'API 29) ou version ultérieure.

Vulkan ne fournit pas d'API Kotlin ou Java. Il n'y a donc pas de mappage direct de RenderScript vers Vulkan. Vous devez écrire votre code Vulkan à l'aide du NDK et créer des fonctions JNI pour accéder à ce code à partir de Kotlin ou de Java.

Les sections suivantes traitent des aspects de la migration à partir de RenderScript. L'application exemple met en œuvre pratiquement toutes ces considérations. Pour mieux les comprendre, comparez le code RenderScript et le code équivalent Vulkan.

Initialisation

Au lieu de créer un objet de contexte RenderScript en Kotlin ou en Java, procédez comme suit pour créer un contexte Vulkan avec le NDK.

  1. Créez une instance Vulkan.

  2. Choisissez un appareil physique Vulkan compatible avec une file d'attente de calcul.

  3. Créez un appareil logique Vulkan et obtenez la file d'attente de calcul.

Vous pouvez également configurer les couches de validation Vulkan sur Android pour accélérer le développement de votre application Vulkan.

L'application exemple montre comment initialiser le contexte Vulkan dans VulkanContext.h. Pour en savoir plus, consultez les sections Initialisation et Appareils et files d'attente de la spécification Vulkan.

Allocations

Vous pouvez migrer une allocation RenderScript vers une image de stockage Vulkan ou un tampon de stockage Vulkan. Pour améliorer les performances des images en lecture seule, utilisez une image échantillonnée avec des opérations d'extraction, soit comme un échantillonneur d'image combiné, soit avec des liaisons d'échantillonneur et d'image échantillonnée.

Les ressources Vulkan sont allouées dans Vulkan. Pour éviter les frais de copie de mémoire lors de l'interaction avec d'autres composants Android, envisagez d'utiliser l'extension VK_ANDROID_external_memory_android_hardware_buffer pour importer un AHardwareBuffer Android dans Vulkan. Cette extension est disponible sur tous les appareils Android compatibles avec Vulkan 1.1. Pour en savoir plus, consultez FEATURE_VULKAN_HARDWARE_VERSION.

L'application exemple montre comment créer des ressources Vulkan dans VulkanResources.h. Pour en savoir plus, consultez les sections sur la création des ressources et les descripteurs de ressources de la spécification Vulkan.

Scripts

Vos scripts RenderScript doivent être convertis en nuanceurs de calcul Vulkan. Vous devrez peut-être également adapter votre code en fonction des éléments généraux de script RenderScript.

Écrire un nuanceur de calcul Vulkan

Un nuanceur de calcul Vulkan est généralement écrit en OpenGL Shading Language (GLSL) puis compilé au format Standard Portable Intermediate Representation-V (SPIR-V).

Pour obtenir des informations et des instructions détaillées sur l'intégration de nuanceurs dans votre application, consultez la page Compilateurs de nuanceurs Vulkan sur Android.

Adaptation d'éléments généraux de script

En fonction des caractéristiques des éléments généraux de script, nous vous recommandons d'utiliser des constantes de spécialisation, des constantes Push ou des objets Uniform Buffer pour les éléments généraux qui ne sont pas modifiées dans le nuanceur :

  • Constantes de spécialisation : recommandées pour les éléments généraux de script généralement cohérents entre les différents appels de noyau. Si vous modifiez la valeur des constantes de spécialisation, vous devrez recréer le pipeline de calcul.
  • Constantes Push : recommandées pour les éléments généraux de script fréquemment modifiés, de taille inférieure à maxPushConstantsSize (minimum garanti : 128 octets).
  • Uniform Buffer : recommandé pour les éléments généraux de script fréquemment modifiés, de taille supérieure à la limite des constantes Push.

Pour les éléments généraux modifiés dans le nuanceur, vous pouvez utiliser l'image de stockage Vulkan ou le tampon de stockage Vulkan.

Calculs

Vous devez créer un pipeline de calcul Vulkan pour que le GPU exécute votre nuanceur de calcul.

Créer un pipeline de calcul Vulkan

Le fichier ComputePipeline.h de l'application exemple montre comment créer le pipeline de calcul Vulkan.

Pour utiliser un nuanceur SPIR-V compilé dans Vulkan, créez un pipeline de calcul Vulkan comme suit :

  1. Créez un module de nuanceur avec le nuanceur SPIR-V compilé.
  2. Créez une mise en page de l'ensemble de descripteurs en spécifiant les liaisons de ressources (consultez la section Allocations pour en savoir plus).
  3. Créez un ensemble de descripteurs à partir de la mise en page de l'ensemble de descripteurs.
  4. Créez une mise en page de pipeline à partir de la mise en page de l'ensemble de descripteurs.
  5. Créez un pipeline de calcul avec le module de nuanceur et la mise en page du pipeline.

Pour en savoir plus, consultez la section Pipelines de calcul de la spécification Vulkan.

Démarrer un calcul

Pour démarrer le calcul avec un pipeline de calcul :

  1. Mettez à jour l'ensemble de descripteurs avec les ressources Vulkan.
  2. Créez un tampon de commande Vulkan et enregistrez les commandes suivantes :
    1. Liez le pipeline à l'ensemble de descripteurs.
    2. Distribuez les groupes de travail de calcul.
  3. Envoyez le tampon de commande à la file d'attente de calcul.
  4. Patientez dans la file d'attente ou renvoyez éventuellement une barrière de synchronisation.

Pour enchaîner plusieurs noyaux (par exemple, pour migrer des codes à l'aide de ScriptGroup), enregistrez-les dans un seul tampon de commande et synchronisez-les avec des barrières de mémoire.

L'application exemple présente deux tâches de calcul :

  • Rotation HUE : tâche de calcul simple avec un seul nuanceur de calcul. Consultez ImageProcessor::rotateHue pour obtenir l'exemple de code.
  • Floutage : tâche de calcul plus complexe qui exécute de manière séquentielle deux nuanceurs de calcul. Consultez ImageProcessor::blur pour obtenir l'exemple de code.

Pour en savoir plus sur les tampons de commande ou les barrières de mémoire, consultez les sections de la spécification Vulkan intitulées Tampons de commande et Barrières de mémoire.