Greffons qui ne sont pas temps réel

Quelques exemples de greffons qui ne sont pas temps réel sont Normaliser pour l'audio et Reframe pour la vidéo.

Comme pour les greffons temps réel, il faut implémenter load_defaults et save_defaults. Pour les greffons qui ne sont pas temps réel, elles ne sont pas utilisées uniquement pour les paramètres par défaut mais aussi pour transférer des valeurs depuis l'interface utilisateur vers le moteur de traitement du signal. Elles n'ont pas besoin d'être une classe de configuration pour les greffons non temps réel.

À l'inverse des greffons temps réel, il ne faut pas utiliser LOAD_CONFIGURATION_MACRO dans l'en-tête du greffon. Il faut, à la place, définir les méthodes suivantes.

Le greffon non temps réel doit contenir un pointeur vers l'objet par défaut.

     Defaults *defaults;

Il doit aussi comporter un pointeur vers une barre d'avancement MainProgressBar.

     MainProgressBar *progress;

Le pointeur d'avancement permet aux greffons qui ne sont pas temps réel d'afficher leur avancement dans la fenêtre principale de Cinelerra.

Le constructeur pour les greffon non temps réel ne peut pas utiliser PLUGIN_CONSTRUCTOR_MACRO mais appeler directement load_defaults.

Le destructeur, de la même manière, doit appeler save_defaults et supprimer les défauts directement à la place de PLUGIN_DESTRUCTOR_MACRO.

      VFrame* new_picon();
 
      char* plugin_title();

Leur usage est le même que dans le cas des greffons temps réel.

      int is_realtime();

Cette fonction doit toujours retourner 0 pour indiquer que le greffon n'est pas un greffon temps réel.

      int get_parameters();

Ici, l'utilisateur doit créer une interface utilisateur graphique, attendre que l'utilisateur clique le bouton Accepter et enregistrer les paramètres dans les variables du greffon. Cette routine doit retourner 0 en cas de succès et 1 en cas d'échec. De cette manière, l'utilisateur peut arrêter l'effet depuis l'interface graphique.

À l'inverse des greffons temps réel, cette interface graphique n'a pas besoin de tourner de manière asynchrone par rapport au greffon. Elle doit bloquer la fonction get_parameters jusqu'à ce que l'utilisateur clique accepter ou Abandonner.

      int load_defaults();

Ceci doit créer un objet de défauts et charger les paramètre depuis l'objet des défauts vers les variables du greffon.

      int save_defaults();

Ceci permet de sauvegarder les variables du greffon dans l'objet des défauts.

     int start_loop();

Si get_parameters a retourné 0 en rasion du succès, celle-ci est appelée une fois pour permettre au greffon de démarrer le traitement. Le greffon doit instancier l'objet d'avancement avec une ligne telle que :

          progress = start_progress("MyPlugin progress...",
          	PluginClient::get_total_len());

L'utilisation de start_progress dépend si le greffon est multicanal ou monocanal. S'il est multicanal, il faudra toujours appeler start_progress. S'il est monocanal, il vous faudra d'abord savoir si la barre d'avancement a déjà été lancée par une autre instance du greffon.

Si la valeur de PluginClient::interactive est de 1, il vous faut démarrer la barre d'avancement. Si elle est de 0, la barre d'avancement a déjà été lancée.

PluginClient définit get_total_len() et get_source_start() pour décrire la plage de la timeline a traiter. Les unités sont soit les échantillons, soit les images dans le débit du projet.

      int process_loop

Ceci est appelé de manière répétitive jusqu'à ce que la plage de la timeline soit traitée. Elle comporte un tampon soit d'images, soit d'échantillons pour la sortie et une référence vers write_length pour enregistrer le nombre d'échantillons traités. Si c'est un greffon audio, l'utilisateur doit appeler get_buffer_size() pour savoir combien d'échantillons peut contenir le tampon de sortie.

Le greffon doit utiliser read_samples ou read_frame pour lire l'entrée. Ces fonctions sont un peu différentes pour un greffon non temps réel que pour un greffon temps réel.

Elle prennent un tampon et une position relative par rapport au début de la timeline, dans le débit de la timeline. Vous devez alors le traiter et mettre la sortie dans le paramètre de tampon de process_loop. write_length doit contenir le nombre d'échantillons créés dans le cas de l'audio.

Enfin, process_loop doit tester PluginClient::interactive et mettre à jour la barre d'avancement si elle est égale à 1.

          progress->update(total_written);

retourne 1 ou 0 si la barre d'avancement a été abandonnée. Si elle est égale à 1, process_loop doit retourner 1 pour indiquer l'abandon. En plus de l'abandon de la barre d'avancement process_loop retourne 1 lorsque la plage entière de la timeline a été traitée.

      int stop_loop();

Ceci est appelé après que process_loop ait traité son dernier tampon.

Si PluginClient::is_interactive est à 1, ceci va appeler stop_progress dans le pointeur de la barre d'avancement et supprimer le pointeur. Ensuite, elle doit supprimer tous les objets qu'elle a créée pour le traitement dans start_loop.