4 * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
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.
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.
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
22 #ifndef PLUGINSERVER_H
23 #define PLUGINSERVER_H
25 // inherited by plugins
33 #include "arraylist.h"
34 #include "attachmentpoint.inc"
36 #include "floatauto.inc"
37 #include "floatautos.inc"
39 #include "keyframe.inc"
41 #include "mainprogress.inc"
42 #include "maxbuffers.h"
43 #include "menueffects.inc"
45 #include "mwindow.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"
57 #include "videodevice.inc"
58 #include "virtualnode.inc"
62 class PluginObj : public Garbage {
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; }
73 PluginObj() : Garbage("PluginObj:Garbage") { dlobj = 0; }
74 ~PluginObj() { if( dlobj ) unload(dlobj); }
77 class PluginGUIs : public ArrayList<PluginServer*>
82 PluginGUIs(MWindow *mwindow);
85 void append(PluginServer *server);
86 PluginServer *gui_server(int gui_id);
91 PluginObj *plugin_obj;
93 const char *load_error();
94 void *get_sym(const char *sym);
96 int reset_parameters();
100 // Base class created by client
101 PluginClient *client;
102 // If no path, this is going to be set to a function which
103 // instantiates the plugin.
104 PluginClient* (*new_plugin)(PluginServer*);
108 LADSPA_Descriptor_Function lad_descriptor_function;
109 const LADSPA_Descriptor *lad_descriptor;
114 // Driver for opengl calls.
115 VideoDevice *vdevice;
118 PluginServer(MWindow *mwindow, const char *path, int type);
119 PluginServer(PluginServer &);
120 virtual ~PluginServer();
122 friend class PluginAClientLAD;
123 friend class PluginAClientConfig;
124 friend class PluginAClientWindow;
126 friend class PluginFClient;
127 friend class PluginFAClient;
128 friend class PluginFVClient;
129 friend class PluginFClientConfig;
130 friend class PluginFClientWindow;
132 // open a plugin and wait for commands
133 // Get information for plugindb if master.
134 #define PLUGINSERVER_IS_LAD 2
135 #define PLUGINSERVER_NOT_RECOGNIZED 1
136 #define PLUGINSERVER_OK 0
137 int open_plugin(int master, Preferences *preferences,
138 EDL *edl, Plugin *plugin);
141 void get_plugin_png_name(char *png_name);
142 int get_plugin_png_path(char *png_path, const char *plugin_icons);
143 int get_plugin_png_path(char *png_path);
144 void dump(FILE *fp=stdout);
145 // Release any objects which are required after playback stops.
147 // Write entry into plugin table
148 void write_table(FILE *fp, const char *path, int idx, int64_t mtime);
149 static int scan_table(char *text, int &type, char *path, char *title, int64_t &mtime);
150 int read_table(char *text);
152 void set_title(const char *string);
153 // Generate title for display
154 void generate_display_title(char *string);
155 // Get keyframes for configuration. Position is always relative to EDL rate.
156 KeyFrame* get_prev_keyframe(int64_t position);
157 KeyFrame* get_next_keyframe(int64_t position);
158 // get camera and projector positions
159 void get_camera(float *x, float *y, float *z,
160 int64_t position, int direction);
161 void get_projector(float *x, float *y, float *z,
162 int64_t position, int direction);
163 // Get interpolation used by EDL
164 int get_interpolation_type();
165 // plugin position or -1 if no plugin
166 int64_t get_startproject();
167 int64_t get_endproject();
168 // Get or create keyframe for writing, depending on whether auto keyframes
169 // is enabled. Called by PluginClient::send_configure_change
170 KeyFrame* get_keyframe();
171 // Apply new settings from the plugin GUI. Called by PluginClient::send_configure_change
172 // Used in keyframe spanning mode.
173 void apply_keyframe(KeyFrame *src);
175 // Create new theme object. Used by theme plugins.
177 // Get theme being used by Cinelerra currently. Used by all plugins.
179 // Get picon png vframe image
181 VFrame *get_plugin_images();
188 PluginClient *new_ffmpeg_plugin();
190 void set_lad_index(int i);
195 PluginClient *new_lv2_plugin();
196 // =============================== for realtime plugins
197 // save configuration of plugin
198 void save_data(KeyFrame *keyframe);
199 // Update EDL and playback engines to reflect changes
200 void sync_parameters();
201 // set for realtime processor usage
202 int set_realtime_sched();
203 int get_gui_status();
206 // cause the plugin to show the GUI
207 // Called by MWindow::show_plugin
210 // Update GUI with keyframe settings
213 void client_side_close();
214 // Set to 1 before every process call if the user supports OpenGL buffers.
215 // Also provides the driver location.
216 void set_use_opengl(int value, VideoDevice *vdevice);
217 // Plugin must call this before performing OpenGL operations.
218 int get_use_opengl();
220 // Called from plugin client
221 // Returns 1 if a GUI is open so OpenGL routines can determine if
224 // Called by plugin client to request synchronous routine.
225 void run_opengl(PluginClient *plugin_client);
227 // set the string that appears on the plugin title
228 int set_string(char *string);
229 // give the buffers and sizes and prepare processing realtime data
230 int init_realtime(int realtime_sched,
231 int total_in_buffers,
233 // process the data in the buffers
234 // input - the current edit's data
235 // output - the previous edit's data and the destination of the transition output
236 // current_position - Position from start of the transition and
237 // relative to the transition.
238 // total_len - total len for transition
239 void process_transition(VFrame *input,
241 int64_t current_position,
243 void process_transition(Samples *input,
245 int64_t current_position,
246 int64_t fragment_size,
249 // Process using pull method.
250 // current_position - start of region if forward, end of region if reverse
251 // relative to requested rate
252 // fragment_size - amount of data to put in buffer relative to requested rate
253 // sample_rate - sample rate of requested output
254 // frame_rate - frame rate of requested output
255 // total_len - length of plugin in track units relative to the EDL rate
256 // Units are kept relative to the EDL rate so plugins don't need to convert rates
257 // to get the keyframes.
258 void process_buffer(VFrame **frame,
259 int64_t current_position,
263 void process_buffer(Samples **buffer,
264 int64_t current_position,
265 int64_t fragment_size,
270 // Called by rendering client to cause the GUI to display something with the data.
271 void send_render_gui(void *data);
272 void send_render_gui(void *data, int size);
274 // Called by MWindow to cause GUI to display
275 void render_gui(void *data);
276 void render_gui(void *data, int size);
277 // PluginClientFrames queuing to gui client_frames
278 void send_reset_gui_frames();
279 void reset_gui_frames();
280 void render_gui_frames(PluginClientFrames *frames);
281 void reset_plugin_gui_frames();
282 void render_plugin_gui_frames(PluginClientFrames *frames);
284 // Send the boundary autos of the next fragment
285 int set_automation(FloatAutos *autos, FloatAuto **start_auto, FloatAuto **end_auto, int reverse);
289 // set the fragment position of a buffer before rendering
290 int arm_buffer(int buffer_number,
291 int64_t in_fragment_position,
292 int64_t out_fragment_position,
293 int double_buffer_in,
294 int double_buffer_out);
295 // Detach all the shared buffers.
296 int detach_buffers();
298 int send_buffer_info();
301 // ============================ for non realtime plugins
302 // start processing data in plugin
303 int start_loop(int64_t start, int64_t end, int64_t buffer_size, int total_buffers);
304 // Do one iteration of a nonrealtime plugin and return if finished
305 int process_loop(VFrame **buffers, int64_t &write_length);
306 int process_loop(Samples **buffers, int64_t &write_length);
310 // Called by client to read data in non-realtime effect
311 int read_frame(VFrame *buffer,
313 int64_t start_position);
314 int read_samples(Samples *buffer,
316 int64_t start_position,
320 // Called by client to read data in realtime effect.
321 // Returns -1 if error or 0 if success.
322 int read_frame(VFrame *buffer,
324 int64_t start_position,
326 // Set to 1 if the reader can use OpenGL objects.
328 int read_samples(Samples *buffer,
331 int64_t start_position,
334 // For non realtime, prompt user for parameters, waits for plugin to finish and returns a result
335 int get_parameters(int64_t start, int64_t end, int channels);
336 int get_samplerate(); // get samplerate produced by plugin
337 double get_framerate(); // get framerate produced by plugin
338 int get_project_samplerate(); // get samplerate of project data before processing
339 double get_project_framerate(); // get framerate of project data before processing
340 void set_path(const char *path); // required first
343 void get_defaults_path(char *path);
344 void save_defaults();
345 // Used by PluginArray and MenuEffects to get user parameters and progress bar.
346 // Set pointer to mwindow for opening GUI and reconfiguring EDL.
347 void set_mwindow(MWindow *mwindow);
348 // Used in VirtualConsole
349 // Set pointer to AttachmentPoint to render GUI.
350 void set_attachmentpoint(AttachmentPoint *attachmentpoint);
351 // Set pointer to a default keyframe when there is no plugin
352 void set_keyframe(KeyFrame *keyframe);
353 // Set pointer to menueffect window
354 void set_prompt(MenuEffectPrompt *prompt);
355 int set_interactive(); // make this the master plugin for progress bars
356 int set_error(); // flag to send plugin an error on next request
357 MainProgressBar* start_progress(char *string, int64_t length);
359 // add track to the list of affected tracks for a non realtime plugin
360 void append_module(Module *module);
361 // add node for realtime plugin
362 void append_node(VirtualNode *node);
363 // reset node table after virtual console reconfiguration
366 int64_t get_written_samples(); // after samples are written, get the number written
367 int64_t get_written_frames(); // after frames are written, get the number written
374 int64_t out_buffer_size; // size of a send buffer to the plugin
375 int64_t in_buffer_size; // size of a receive buffer from the plugin
376 int total_in_buffers;
377 int total_out_buffers;
379 // number of double buffers for each channel
380 ArrayList<int> ring_buffers_in;
381 ArrayList<int> ring_buffers_out;
382 // Parameters for automation. Setting autos to 0 disables automation.
383 FloatAuto **start_auto, **end_auto;
387 // size of each buffer
388 ArrayList<int64_t> realtime_in_size;
389 ArrayList<int64_t> realtime_out_size;
391 // When arming buffers need to know the offsets in all the buffers and which
392 // double buffers for each channel before rendering.
393 ArrayList<int64_t> offset_in_render;
394 ArrayList<int64_t> offset_out_render;
395 ArrayList<int64_t> double_buffer_in_render;
396 ArrayList<int64_t> double_buffer_out_render;
398 // don't delete buffers if they belong to a virtual module
400 // Send new buffer information for next render
404 int plugin_open; // Whether or not the plugin is open.
405 // Specifies what type of plugin.
406 int realtime, multichannel, fileio;
407 // Plugin generates media
409 // What data types the plugin can handle. One of these is set.
410 int audio, video, theme;
413 // Plugin is a transition
415 // name/tip of plugin
417 int64_t written_samples, written_frames;
418 char *path; // location of plugin on disk
419 char *data_text; // pointer to the data that was requested by a save_data command
422 int error_flag; // send plugin an error code on next request
423 int dir_idx; // directory id, for icon visibility grouping
424 // Pointers to tracks affected by this plugin during a non realtime operation.
425 // Allows read functions to read data.
426 ArrayList<Module*> *modules;
427 // Used by realtime read functions to get data. Corresponds to the buffer table in the
429 ArrayList<VirtualNode*> *nodes;
430 AttachmentPoint *attachmentpoint;
432 // Pointer to keyframe when plugin is not available
434 AttachmentPoint *attachment;
436 // Storage of session parameters
438 Preferences *preferences;
439 MenuEffectPrompt *prompt;
444 // Icon for tracking update