L'objet de configuration

L'objet de configuration est critique pour les mises à jour de l'interface graphique, le traitement du signal et les paramètres par défaut dans les greffons temps-réel. Remarquez qu'il n'est pas utilisé dans les greffons non temps réel. L'objet de configuration n'hérite de rien et n'a pas de dépendances. Il est constitué simplement d'une classe contenant trois fonctions et les variables spécifiques aux paramètres du greffon.

Habituellement, l'objet de configuration commence par le nom du greffon suivi de Config.

     class MyPluginConfig
     {
     public:
     	MyPluginConfig();

Après le nom de la classe de configuration, nous trouvons les trois fonctions requises et les variables de configuration.

     	int equivalent(MyPluginConfig &that);
     	void copy_from(MyPluginConfig &that);
     	void interpolate(MyPluginConfig &prev,
     		MyPluginConfig &next,
     		int64_t prev_position,
     		int64_t next_position,
     		int64_t current_position);
 
 
 
     	float parameter1;
     	float parameter2;
     	int parameter3;
     };

Maintenant il faut définir les trois fonctions. equivalent est appelée par LOAD_CONFIGURATION_MACRO pour obtenir la valeur de retour. Si equivalent retourne 0, la fonction de load_configuration permet de redessiner l'interface graphique. Si equivalent retourne 1, l'interface graphique n'est pas redessinée.

Ensuite, il y a une copie qui transfère les valeurs de configuration depuis le paramètre vers les variables locales. C'est de nouveau utilisé dans LOAD_CONFIGURATION_MACRO pour enregistrer les configurations dans des espaces temporaires. Une fois que LOAD_CONFIGURATION_MACRO a répliqué la configuration, elle charge une seconde configuration. Elle interpole ensuite les deux configurations pour obtenir la configuration actuelle. Les fonctions d'interpolations réalisent l'interpolation et enregistrent les résultats dans les variables locales.

Normalement, la fonction d'interpolation calcule une fraction précédente et une fraction suivant en en utilisant les paramètres.

     void MyPluginConfig::interpolate(MyPluginConfig &prev,
     		MyPluginConfig &next,
     		int64_t prev_position,
     		int64_t next_position,
     		int64_t current_position)
     {
     	double next_scale = (double)(current_position - prev_position) / (next_position - prev_position);
     	double prev_scale = (double)(next_position - current_position) / (next_position - prev_position);

Ensuite, les échelles sont appliquées à l'objet de configuration précédent et suivant pour obtenir les valeurs actuelles.

      	this->parameter1 = (float)(prev.parameter1 * prev_scale + next.parameter1 * next_scale);
     	this->parameter2 = (float)(prev.parameter2 * prev_scale + next.parameter2 * next_scale);
     	this->parameter3 = (int)(prev.parameter3 * prev_scale + next.parameter3 * next_scale);
     }
 

Vous pouvez aussi copier les valeurs depuis le paramètre de configuration précédent sans interpolation.

Cette utilisation est identique pur des greffons audio ou vidéo. Lors de la lecture vidéo, la fonction d'interpolation est appelée à chaque image, ce qui permet d'obtenir une interpolation lissée. Lors de la lecture audio, la fonction d'interpolation est appelée pour chaque fragment de console et une fois chaque fois que le point d'insertion se déplace. C'est suffisant pour effectuer la mise à jour de l'interface graphique lorsqu'on sélectionne des régions sur la timeline mais ce n'est pas assez précis pour un rendu réellement doux de l'effet.

Pour des rendus réellement doux de l'audio, vous pouvez continuer à utiliser load_configuration pour la mise à jour de l'interface graphique. Cependant, pour le traitement en temps réel, ignorez load_configuration et écrivez votre propre routine d'interpolation qui chargera toutes les images-clés d'un fragment de console et interpolera chaque échantillon. Ceci sera vraiment très lent est difficile à mettre au point, pouvant conduire à des améliorations qui ne seront même pas audibles. Bien sûr, chaque siècle possède son lot de bizarreries.

Une façon plus facile de rendre l'interpolation plus fine est de réduite la taille des fragment de console à 1 échantillon. Ceci devra être rendu et reproduit dans un programme séparé, bien entendu. Le pilote audio de Linux ne sait pas lire des fragments de longueur réduite à un échantillon.