motion draw_vectors using VFrame draw_pixel brush
[goodguy/history.git] / cinelerra-5.1 / cinelerra / pluginserver.h
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21
22 #ifndef PLUGINSERVER_H
23 #define PLUGINSERVER_H
24
25 // inherited by plugins
26
27
28 #include <stdio.h>
29 #include <stdint.h>
30 #include <string.h>
31 #include <unistd.h>
32
33 #include "arraylist.h"
34 #include "attachmentpoint.inc"
35 #include "edl.inc"
36 #include "floatauto.inc"
37 #include "floatautos.inc"
38 #include "garbage.h"
39 #include "keyframe.inc"
40 #include "ladspa.h"
41 #include "mainprogress.inc"
42 #include "maxbuffers.h"
43 #include "menueffects.inc"
44 #include "module.inc"
45 #include "mwindow.inc"
46 #include "plugin.inc"
47 #include "pluginaclientlad.inc"
48 #include "pluginfclient.inc"
49 #include "pluginclient.inc"
50 #include "pluginserver.inc"
51 #include "preferences.inc"
52 #include "samples.inc"
53 #include "theme.inc"
54 #include "thread.h"
55 #include "track.inc"
56 #include "vframe.inc"
57 #include "videodevice.inc"
58 #include "virtualnode.inc"
59
60 #include <dlfcn.h>
61
62 class PluginObj : public Garbage {
63         void *dlobj;
64 public:
65
66         void *load(const char *dlp) { return dlobj = dlopen(dlp, RTLD_NOW); }
67         void *load(const char *plugin_dir, const char *path);
68         void unload(void *obj) { dlclose(obj); }
69         void *load_sym(const char *sym) { return dlsym(dlobj, sym); }
70         const char *load_error() { return dlerror(); }
71         void *obj() { return dlobj; }
72
73         PluginObj() : Garbage("PluginObj:Garbage") { dlobj = 0; }
74         ~PluginObj() { if( dlobj ) unload(dlobj); }
75 };
76
77 class PluginServer
78 {
79         PluginObj *plugin_obj;
80         int load_obj();
81         const char *load_error();
82         void *get_sym(const char *sym);
83
84         int reset_parameters();
85         void init();
86         int cleanup_plugin();
87
88 // Base class created by client
89         PluginClient *client;
90 // If no path, this is going to be set to a function which
91 // instantiates the plugin.
92         PluginClient* (*new_plugin)(PluginServer*);
93
94 // LAD support
95         int lad_index;
96         LADSPA_Descriptor_Function lad_descriptor_function;
97         const LADSPA_Descriptor *lad_descriptor;
98
99         int use_opengl;
100 // FFMPEG support
101         const char *ff_name;
102 // Driver for opengl calls.
103         VideoDevice *vdevice;
104 public:
105         PluginServer();
106         PluginServer(MWindow *mwindow, const char *path, int type);
107         PluginServer(PluginServer &);
108         virtual ~PluginServer();
109
110         friend class PluginAClientLAD;
111         friend class PluginAClientConfig;
112         friend class PluginAClientWindow;
113
114         friend class PluginFClient;
115         friend class PluginFAClient;
116         friend class PluginFVClient;
117         friend class PluginFClientConfig;
118         friend class PluginFClientWindow;
119
120 // open a plugin and wait for commands
121 // Get information for plugindb if master.
122 #define PLUGINSERVER_IS_LAD 2
123 #define PLUGINSERVER_NOT_RECOGNIZED 1
124 #define PLUGINSERVER_OK 0
125         int open_plugin(int master, Preferences *preferences,
126                         EDL *edl, Plugin *plugin);
127 // close the plugin
128         int close_plugin();
129         void get_plugin_png_name(char *png_name);
130         int get_plugin_png_path(char *png_path, const char *plugin_icons);
131         int get_plugin_png_path(char *png_path);
132         void dump(FILE *fp=stdout);
133 // Release any objects which are required after playback stops.
134         void render_stop();
135 // Write entry into plugin table
136         void write_table(FILE *fp, const char *path, int idx, int64_t mtime);
137         static int scan_table(char *text, int &type, char *path, char *title, int64_t &mtime);
138         int read_table(char *text);
139 // queries
140         void set_title(const char *string);
141 // Generate title for display
142         void generate_display_title(char *string);
143 // Get keyframes for configuration.  Position is always relative to EDL rate.
144         KeyFrame* get_prev_keyframe(int64_t position);
145         KeyFrame* get_next_keyframe(int64_t position);
146 // get camera and projector positions
147         void get_camera(float *x, float *y, float *z,
148                         int64_t position, int direction);
149         void get_projector(float *x, float *y, float *z,
150                         int64_t position, int direction);
151 // Get interpolation used by EDL
152         int get_interpolation_type();
153 // Get or create keyframe for writing, depending on whether auto keyframes
154 // is enabled.  Called by PluginClient::send_configure_change
155         KeyFrame* get_keyframe();
156 // Apply new settings from the plugin GUI.  Called by PluginClient::send_configure_change
157 // Used in keyframe spanning mode.
158         void apply_keyframe(KeyFrame *src);
159
160 // Create new theme object.  Used by theme plugins.
161         Theme* new_theme();
162 // Get theme being used by Cinelerra currently.  Used by all plugins.
163         Theme* get_theme();
164 // Get picon png vframe image
165         VFrame *get_picon();
166         VFrame *get_plugin_images();
167
168         int is_unknown();
169         int is_executable();
170         int is_builtin();
171 // ffmpeg
172         int is_ffmpeg();
173         PluginClient *new_ffmpeg_plugin();
174 // ladspa
175         void set_lad_index(int i);
176         int get_lad_index();
177         int is_ladspa();
178 // lv2
179         int is_lv2();
180         PluginClient *new_lv2_plugin();
181 // =============================== for realtime plugins
182 // save configuration of plugin
183         void save_data(KeyFrame *keyframe);
184 // Update EDL and playback engines to reflect changes
185         void sync_parameters();
186 // set for realtime processor usage
187         int set_realtime_sched();
188         int get_gui_status();
189 // Raise the GUI
190         void raise_window();
191 // cause the plugin to show the GUI
192 // Called by MWindow::show_plugin
193         void show_gui();
194         void hide_gui();
195 // Update GUI with keyframe settings
196         void update_gui();
197         void update_title();
198         void client_side_close();
199 // Set to 1 before every process call if the user supports OpenGL buffers.
200 // Also provides the driver location.
201         void set_use_opengl(int value, VideoDevice *vdevice);
202 // Plugin must call this before performing OpenGL operations.
203         int get_use_opengl();
204
205 // Called from plugin client
206 // Returns 1 if a GUI is open so OpenGL routines can determine if
207 // they can run.
208         int gui_open();
209 // Called by plugin client to request synchronous routine.
210         void run_opengl(PluginClient *plugin_client);
211
212 // set the string that appears on the plugin title
213         int set_string(char *string);
214 // give the buffers and sizes and prepare processing realtime data
215         int init_realtime(int realtime_sched,
216                 int total_in_buffers,
217                 int buffer_size);
218 // process the data in the buffers
219 // input - the current edit's data
220 // output - the previous edit's data and the destination of the transition output
221 // current_position - Position from start of the transition and
222 //     relative to the transition.
223 // total_len - total len for transition
224         void process_transition(VFrame *input,
225                 VFrame *output,
226                 int64_t current_position,
227                 int64_t total_len);
228         void process_transition(Samples *input,
229                 Samples *output,
230                 int64_t current_position,
231                 int64_t fragment_size,
232                 int64_t total_len);
233
234 // Process using pull method.
235 // current_position - start of region if forward, end of region if reverse
236 //     relative to requested rate
237 // fragment_size - amount of data to put in buffer relative to requested rate
238 // sample_rate - sample rate of requested output
239 // frame_rate - frame rate of requested output
240 // total_len - length of plugin in track units relative to the EDL rate
241 // Units are kept relative to the EDL rate so plugins don't need to convert rates
242 // to get the keyframes.
243         void process_buffer(VFrame **frame,
244                 int64_t current_position,
245                 double frame_rate,
246                 int64_t total_len,
247                 int direction);
248         void process_buffer(Samples **buffer,
249                 int64_t current_position,
250                 int64_t fragment_size,
251                 int64_t sample_rate,
252                 int64_t total_len,
253                 int direction);
254
255 // Called by rendering client to cause the GUI to display something with the data.
256         void send_render_gui(void *data);
257         void send_render_gui(void *data, int size);
258 // Called by MWindow to cause GUI to display
259         void render_gui(void *data);
260         void render_gui(void *data, int size);
261
262 // Send the boundary autos of the next fragment
263         int set_automation(FloatAutos *autos, FloatAuto **start_auto, FloatAuto **end_auto, int reverse);
264
265
266
267 // set the fragment position of a buffer before rendering
268         int arm_buffer(int buffer_number,
269                                 int64_t in_fragment_position,
270                                 int64_t out_fragment_position,
271                                 int double_buffer_in,
272                                 int double_buffer_out);
273 // Detach all the shared buffers.
274         int detach_buffers();
275
276         int send_buffer_info();
277
278
279 // ============================ for non realtime plugins
280 // start processing data in plugin
281         int start_loop(int64_t start, int64_t end, int64_t buffer_size, int total_buffers);
282 // Do one iteration of a nonrealtime plugin and return if finished
283         int process_loop(VFrame **buffers, int64_t &write_length);
284         int process_loop(Samples **buffers, int64_t &write_length);
285         int stop_loop();
286
287
288 // Called by client to read data in non-realtime effect
289         int read_frame(VFrame *buffer,
290                 int channel,
291                 int64_t start_position);
292         int read_samples(Samples *buffer,
293                 int channel,
294                 int64_t start_position,
295                 int64_t len);
296
297
298 // Called by client to read data in realtime effect.
299 // Returns -1 if error or 0 if success.
300         int read_frame(VFrame *buffer,
301                 int channel,
302                 int64_t start_position,
303                 double frame_rate,
304 // Set to 1 if the reader can use OpenGL objects.
305                 int use_opengl = 0);
306         int read_samples(Samples *buffer,
307                 int channel,
308                 int64_t sample_rate,
309                 int64_t start_position,
310                 int64_t len);
311
312 // For non realtime, prompt user for parameters, waits for plugin to finish and returns a result
313         int get_parameters(int64_t start, int64_t end, int channels);
314         int get_samplerate();      // get samplerate produced by plugin
315         double get_framerate();     // get framerate produced by plugin
316         int get_project_samplerate();            // get samplerate of project data before processing
317         double get_project_framerate();         // get framerate of project data before processing
318         void set_path(const char *path);        // required first
319         char *get_path();
320         int get_synthesis();
321         void get_defaults_path(char *path);
322         void save_defaults();
323 // Used by PluginArray and MenuEffects to get user parameters and progress bar.
324 // Set pointer to mwindow for opening GUI and reconfiguring EDL.
325         void set_mwindow(MWindow *mwindow);
326 // Used in VirtualConsole
327 // Set pointer to AttachmentPoint to render GUI.
328         void set_attachmentpoint(AttachmentPoint *attachmentpoint);
329 // Set pointer to a default keyframe when there is no plugin
330         void set_keyframe(KeyFrame *keyframe);
331 // Set pointer to menueffect window
332         void set_prompt(MenuEffectPrompt *prompt);
333         int set_interactive();             // make this the master plugin for progress bars
334         int set_error();         // flag to send plugin an error on next request
335         MainProgressBar* start_progress(char *string, int64_t length);
336
337 // add track to the list of affected tracks for a non realtime plugin
338         void append_module(Module *module);
339 // add node for realtime plugin
340         void append_node(VirtualNode *node);
341 // reset node table after virtual console reconfiguration
342         void reset_nodes();
343
344         int64_t get_written_samples();   // after samples are written, get the number written
345         int64_t get_written_frames();   // after frames are written, get the number written
346
347 // client origin
348         int plugin_type;
349
350 // buffers
351         int64_t out_buffer_size;   // size of a send buffer to the plugin
352         int64_t in_buffer_size;    // size of a receive buffer from the plugin
353         int total_in_buffers;
354         int total_out_buffers;
355
356 // number of double buffers for each channel
357         ArrayList<int> ring_buffers_in;
358         ArrayList<int> ring_buffers_out;
359 // Parameters for automation.  Setting autos to 0 disables automation.
360         FloatAuto **start_auto, **end_auto;
361         FloatAutos *autos;
362         int reverse;
363
364 // size of each buffer
365         ArrayList<int64_t> realtime_in_size;
366         ArrayList<int64_t> realtime_out_size;
367
368 // When arming buffers need to know the offsets in all the buffers and which
369 // double buffers for each channel before rendering.
370         ArrayList<int64_t> offset_in_render;
371         ArrayList<int64_t> offset_out_render;
372         ArrayList<int64_t> double_buffer_in_render;
373         ArrayList<int64_t> double_buffer_out_render;
374
375 // don't delete buffers if they belong to a virtual module
376         int shared_buffers;
377 // Send new buffer information for next render
378         int new_buffers;
379
380
381         int plugin_open;                 // Whether or not the plugin is open.
382 // Specifies what type of plugin.
383         int realtime, multichannel, fileio;
384 // Plugin generates media
385         int synthesis;
386 // What data types the plugin can handle.  One of these is set.
387         int audio, video, theme;
388 // Can display a GUI
389         int uses_gui;
390 // Plugin is a transition
391         int transition;
392 // name/tip of plugin
393         char *title, *tip;
394         int64_t written_samples, written_frames;
395         char *path;           // location of plugin on disk
396         char *data_text;      // pointer to the data that was requested by a save_data command
397         char *args[4];
398         int total_args;
399         int error_flag;       // send plugin an error code on next request
400         int dir_idx;          // directory id, for icon visibility grouping
401 // Pointers to tracks affected by this plugin during a non realtime operation.
402 // Allows read functions to read data.
403         ArrayList<Module*> *modules;
404 // Used by realtime read functions to get data.  Corresponds to the buffer table in the
405 // attachment point.
406         ArrayList<VirtualNode*> *nodes;
407         AttachmentPoint *attachmentpoint;
408         MWindow *mwindow;
409 // Pointer to keyframe when plugin is not available
410         KeyFrame *keyframe;
411         AttachmentPoint *attachment;
412 // Storage of keyframes and GUI status
413         Plugin *plugin;
414
415 // Storage of session parameters
416         EDL *edl;
417         Preferences *preferences;
418         MenuEffectPrompt *prompt;
419         int gui_on;
420
421         VFrame *temp_frame;
422
423 // Icon for tracking update
424         VFrame *picon;
425 };
426
427
428 #endif