Greffons temps réel

Les greffons temps réel doivent utiliser la classe PLUGIN_CLASS_MEMBERS pour définir le jeu de base des membres dans leurs en-têtes. Tous les greffons temps réel doivent définir un membre

     int is_realtime()

qui retourne 1. Ceci entraîne l'appel d'un certain nombre de méthodes lors de la lecture live et permet au greffon d'être utilisable sur la timeline.

Les greffons temps réel doivent surcharger un membre appelé

     process_buffer

Cette fonction prend différents paramètres selon que le greffon gère de l'audio ou de la vidéo. Le mieux est d'examiner comment est réalisé un greffon existant pour voir comment c'est appliqué.

La fonctionnalité principale de la fonction process_buffer est de fournir un tampon où placer la sortie, de définir la position de départ pour la sortie et de définir le débit requis en sortie. Pour de l'audio, il y a aussi un paramètre qui définit le nombre d'échantillons.

La position de départ dans le tampon de sortie est l'échantillon de numéro le moins élevé sur la timeline si la lecture a lieu vers l'avant et l'échantillon de numéro le plus élevé si la lecture a lieu en arrière. Le sens de la lecture est déterminé par une des requêtes du greffon, décrite ci-dessous.

Les paramètres de taille et de position sont tous relatifs à la fréquence des images et au taux d'échantillonnage passés à process_buffer. C'est le débit des données requis et il peut être différent du débit du projet.

la fonction process_realtime doit commencer par l'appel de load_configuration. LOAD_CONFIGURATION_MACRO retourne 1 si la configuration a été modifiée.

Après avoir déterminé la configuration du greffon, le média d'entrée doit être chargé pour le traitement. Appelez

     read_frame(VFrame *buffer,
     		int channel,
     		int64_t start_position,
     		double frame_rate)

ou

     read_samples(double *buffer,
     		int channel,
     		int sample_rate,
     		int64_t start_position,
     		int64_t len)

pour demander des données d'entrée à l'objet qui vient juste avant ce greffon. La fonction read a besoin d'un tampon pour y enregistrer les données d'entrée. Il peut être créé de manière temporaire dans le greffon, ou le tampon de sortie fourni à process_buffer peut être utilisé si vous n'avez pas besoin de tampon temporaire.

Il a aussi besoin d'un ensemble de paramètres de position pour déterminer quand vous désirez lire les données. La position de départ, le débit et la longueur passés à une fonction read n'ont pas besoin d'être les mêmes que les valeurs reçues par la fonction process_buffer. De cette manière, le greffon peut lire des données à un débit différent du débit auquel il envoie les données vers la sortie.

Le paramètre channel n'a de signification que pour les greffons multicanaux. Ils leur faut lire les donnée pour chaque piste dans la valeur get_total_buffers() et traiter toutes les pistes. Les greffons monocanal doivent passer la valeur 0 pour channel.

Des membres supplémentaires sont implémentés pour maintenir la configuration des greffons temps réel. Certains d'entres-eux sont nécessaires aussi dans le cas des greffons non temps réel.

      void read_data(KeyFrame *keyframe);

Charge des données depuis une image-clé dans la configuration du greffon. Il y a, dans la structure de l'image-clé, une chaîne XML. Elle est analysée plus facilement en créant un objet de type FileXML. Voir dans un greffon existant comment la fonction read_data est implémentée.

read_data charge les données depuis l'objet XML et range les valeurs dans l'objet de configuration du greffon. Comme les objets de configuration varient d'un greffon à l'autre, ces fonctions ne peuvent pas être automatisées.

      void save_data(KeyFrame *keyframe);

Enregistre les données depuis la configuration du greffon dans une image-clé. À l'intérieur de l'image-clé, vous mettrez une chaîne XML qui est normalement créée par un objet FileXM. Voir dans un greffon existant comment la fonction save_data est implémentée.

save_data enregistre les données venant de l'objet de configuration du greffon dans l'objet XML.

      int load_defaults();

Une autre façon pour un greffon d'obtenir des paramètres d'un fichier de valeurs par défaut. Les routines load_defaults et save_defaults utilisent un objet de valeurs par défaut pour analyser les fichiers des valeurs par défaut. L'objet des valeurs par défaut est créé dans load_defaults et détruit dans le destructeur du greffon. Voir dans un greffon existant comment l'objet des valeurs par défaut est utilisé.

      int save_defaults();

Enregistre la configuration dans l'objet des valeurs par défaut.