Partager via

Présentation du renderscript

  • Article

Ce guide présente Renderscript et explique comment utiliser les API Renderscript intrinsèques dans une application Xamarin.Android qui cible le niveau d’API 17 ou supérieur.

Vue d’ensemble

Renderscript est une infrastructure de programmation créée par Google pour améliorer les performances des applications Android qui nécessitent des ressources de calcul étendues. Il s’agit d’une API de faible niveau et hautes performances basée sur C99. Étant donné qu’il s’agit d’une API de bas niveau qui s’exécutera sur des processeurs, des GPU ou des DSP, Renderscript convient parfaitement aux applications Android qui peuvent avoir besoin d’effectuer l’une des opérations suivantes :

  • Graphismes
  • Traitement des images
  • Chiffrement
  • Traitement des signaux
  • Routines mathématiques

Renderscript utilise clang et compile les scripts dans le code d’octet LLVM qui est regroupé dans l’APK. Lorsque l’application est exécutée pour la première fois, le code d’octet LLVM est compilé en code d’ordinateur pour les processeurs sur l’appareil. Cette architecture permet à une application Android d’exploiter les avantages du code machine sans que les développeurs eux-mêmes n’ont à l’écrire pour chaque processeur sur l’appareil eux-mêmes.

Il existe deux composants à une routine Renderscript :

  1. Runtime Renderscript : il s’agit des API natives responsables de l’exécution du renderscript. Cela inclut tous les renderscripts écrits pour l’application.

  2. Wrappers managés à partir d’Android Framework : classes managées qui permettent à une application Android de contrôler et d’interagir avec le runtime renderscript et les scripts. Outre les classes fournies par l’infrastructure pour contrôler le runtime Renderscript, la chaîne d’outils Android examine le code source Renderscript et génère des classes wrapper managées à utiliser par l’application Android.

Le diagramme suivant illustre la relation entre ces composants :

Diagram illustrating how the Android Framework interacts with the Renderscript Runtime

Il existe trois concepts importants pour l’utilisation de Renderscripts dans une application Android :

  1. Contexte : API managée fournie par le Kit de développement logiciel (SDK) Android qui alloue des ressources à Renderscript et permet à l’application Android de passer et de recevoir des données à partir du renderscript.

  2. Noyau de calcul : également appelé noyau racine ou noyau, il s’agit d’une routine qui effectue le travail. Le noyau est très similaire à une fonction C ; il s’agit d’une routine parallélisable qui sera exécutée sur toutes les données en mémoire allouée.

  3. Mémoire allouée : les données sont transmises à un noyau et à partir d’un noyau via une allocation. Un noyau peut avoir une entrée et/ou une allocation de sortie.

L’espace de noms Android.Renderscripts contient les classes permettant d’interagir avec le runtime Renderscript. En particulier, la Renderscript classe gère le cycle de vie et les ressources du moteur Renderscript. L’application Android doit initialiser une ou plusieurs applications Android.Renderscripts.Allocation Objets. Une allocation est une API managée qui est responsable de l’allocation et de l’accès à la mémoire partagée entre l’application Android et le runtime Renderscript. En règle générale, une allocation est créée pour l’entrée, et éventuellement une autre allocation est créée pour contenir la sortie du noyau. Le moteur d’exécution Renderscript et les classes de wrapper managées associées gèrent l’accès à la mémoire détenue par les allocations, il n’est pas nécessaire qu’un développeur d’applications Android effectue un travail supplémentaire.

Une allocation contient un ou plusieurs Android.Renderscripts.Elements. Les éléments sont un type spécialisé qui décrit les données dans chaque allocation. Les types d’éléments de l’allocation de sortie doivent correspondre aux types de l’élément d’entrée. Lors de l’exécution, un renderscript effectue une itération sur chaque élément de l’allocation d’entrée en parallèle et écrit les résultats dans l’allocation de sortie. Il existe deux types d’éléments :

  • type simple : conceptuellement, il s’agit de la même chose qu’un type de données C, float ou un char.

  • type complexe : ce type est similaire à un C struct.

Le moteur Renderscript effectue un case activée d’exécution pour s’assurer que les éléments de chaque allocation sont compatibles avec ce qui est requis par le noyau. Si le type de données des éléments dans l’allocation ne correspond pas au type de données attendu par le noyau, une exception est levée.

Tous les noyaux Renderscript sont encapsulés par un type qui est un descendant du ClasseAndroid.Renderscripts.Script . La Script classe est utilisée pour définir des paramètres pour un Renderscript, définir le code de rendu approprié Allocationset exécuter le renderscript. Il existe deux Script sous-classes dans le Kit de développement logiciel (SDK) Android :

  • Android.Renderscripts.ScriptIntrinsic : certaines des tâches Renderscript les plus courantes sont regroupées dans le Kit de développement logiciel (SDK) Android et sont accessibles par une sous-classe de la classe ScriptIntrinsic . Il n’est pas nécessaire qu’un développeur prenne des mesures supplémentaires pour utiliser ces scripts dans leur application, car ils sont déjà fournis.

  • ScriptC_XXXXX – Également appelés scripts utilisateur, il s’agit de scripts écrits par les développeurs et empaquetés dans l’APK. Au moment de la compilation, la chaîne d’outils Android génère des classes wrapper managées qui permettent aux scripts d’être utilisés dans l’application Android. Le nom de ces classes générées est le nom du fichier Renderscript, préfixé par ScriptC_. L’écriture et l’incorporation de scripts utilisateur ne sont pas officiellement prises en charge par Xamarin.Android et au-delà de l’étendue de ce guide.

De ces deux types, seuls les StringIntrinsic deux types sont pris en charge par Xamarin.Android. Ce guide explique comment utiliser des scripts intrinsèques dans une application Xamarin.Android.

Spécifications

Ce guide concerne les applications Xamarin.Android qui ciblent le niveau d’API 17 ou supérieur. L’utilisation de scripts utilisateur n’est pas abordée dans ce guide.

La bibliothèque de support Xamarin.Android V8 rétroporte les API Renderscript instrinsic pour les applications qui ciblent des versions antérieures du Kit de développement logiciel (SDK) Android. L’ajout de ce package à un projet Xamarin.Android doit permettre aux applications qui ciblent des versions antérieures du Kit de développement logiciel (SDK) Android de tirer parti des scripts intrinsèques.

Utilisation de renderscripts intrinsèques dans Xamarin.Android

Les scripts intrinsèques constituent un excellent moyen d’effectuer des tâches informatiques intensives avec une quantité minimale de code supplémentaire. Ils ont été réglés manuellement pour offrir des performances optimales sur une grande section croisée d’appareils. Il n’est pas rare qu’un script intrinsèque s’exécute 10 fois plus rapidement que le code managé et 2 à 3 fois après une implémentation C personnalisée. La plupart des scénarios de traitement classiques sont couverts par les scripts intrinsèques. Cette liste des scripts intrinsèques décrit les scripts actuels dans Xamarin.Android :

Consultez la documentation de l’API pour plus d’informations sur chacun des scripts intrinsèques.

Les étapes de base pour l’utilisation de Renderscript dans une application Android sont décrites ci-dessous.

Créer un contexte Renderscript – The Renderscriptla classe est un wrapper managé autour du contexte Renderscript et contrôle l’initialisation, la gestion des ressources et les propre. L’objet Renderscript est créé à l’aide de la RenderScript.Create méthode de fabrique, qui prend un contexte Android (tel qu’une activité) en tant que paramètre. La ligne de code suivante montre comment initialiser le contexte Renderscript :

Android.Renderscripts.RenderScript renderScript = RenderScript.Create(this);

Créer des allocations : selon le script intrinsèque, il peut être nécessaire de créer un ou deux Allocations. .Android.Renderscripts.Allocation la classe a plusieurs méthodes de fabrique pour faciliter l’instanciation d’une allocation pour une intrinsèque. Par exemple, l’extrait de code suivant montre comment créer l’allocation pour les bitmaps.

Android.Graphics.Bitmap originalBitmap;
Android.Renderscripts.Allocation inputAllocation = Allocation.CreateFromBitmap(renderScript,
                                                     originalBitmap,
                                                     Allocation.MipmapControl.MipmapFull,
                                                     AllocationUsage.Script);

Souvent, il sera nécessaire de créer un Allocation pour contenir les données de sortie d’un script. Cet extrait de code suivant montre comment utiliser l’assistance Allocation.CreateTyped pour instancier une seconde Allocation que le même type que l’original :

Android.Renderscripts.Allocation outputAllocation = Allocation.CreateTyped(renderScript, inputAllocation.Type);

Instancier le wrapper de script : chacune des classes wrapper de script intrinsèque doit avoir des méthodes d’assistance (généralement appelées Create)pour instancier un objet wrapper pour ce script. L’extrait de code suivant est un exemple d’instanciation d’un ScriptIntrinsicBlur objet flou. La Element.U8_4 méthode d’assistance crée un élément qui décrit un type de données qui est de 4 champs de valeurs entières non signées 8 bits, adaptées à la conservation des données d’un Bitmap objet :

Android.Renderscripts.ScriptIntrinsicBlur blurScript = ScriptIntrinsicBlur.Create(renderScript, Element.U8_4(renderScript));

Affecter des allocations, définir des paramètres et exécuter un script : la Script classe fournit une ForEach méthode pour exécuter réellement le renderscript. Cette méthode effectue une itération sur chacune Element dans la Allocation conservation des données d’entrée. Dans certains cas, il peut être nécessaire de fournir une Allocation sortie qui contient la sortie. ForEach remplace le contenu de l’allocation de sortie. Pour suivre les extraits de code des étapes précédentes, cet exemple montre comment affecter une allocation d’entrée, définir un paramètre, puis exécuter le script (copie des résultats dans l’allocation de sortie) :

blurScript.SetInput(inputAllocation);
blurScript.SetRadius(25);  // Set a pamaeter
blurScript.ForEach(outputAllocation);

Vous souhaiterez peut-être case activée l’image floue avec la recette Renderscript. Il s’agit d’un exemple complet d’utilisation d’un script intrinsèque dans Xamarin.Android.

Résumé

Ce guide a introduit Renderscript et comment l’utiliser dans une application Xamarin.Android. Il a brièvement abordé ce que Renderscript est et comment il fonctionne dans une application Android. Il a décrit certains des composants clés dans Renderscript et la différence entre les scripts utilisateur et les scripts instrinsiques. Enfin, ce guide a abordé les étapes d’utilisation d’un script intrinsèque dans une application Xamarin.Android.