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"
38 #include "keyframe.inc"
40 #include "mainprogress.inc"
41 #include "maxbuffers.h"
42 #include "menueffects.inc"
44 #include "mwindow.inc"
46 #include "pluginaclientlad.inc"
47 #include "pluginclient.inc"
48 #include "pluginserver.inc"
49 #include "preferences.inc"
50 #include "samples.inc"
55 #include "videodevice.inc"
56 #include "virtualnode.inc"
66 PluginObj() { dlobj = 0; }
68 PluginObj(PluginObj &that) { dlobj = 0; }
70 void *load_obj() { return dlobj; }
71 void *load_obj(const char *path) { return dlobj = dlopen(path, RTLD_NOW); }
72 static void unload_obj(void *dlp) { if( dlp ) dlclose(dlp); }
73 void unload_obj() { unload_obj(dlobj); }
74 void *load_sym(const char *sym) { return dlsym(dlobj, sym); }
75 const char *load_error() { return dlerror(); }
78 class PluginServer : public PluginObj
80 int reset_parameters();
83 // Base class created by client
85 // If no path, this is going to be set to a function which
86 // instantiates the plugin.
87 PluginClient* (*new_plugin)(PluginServer*);
92 LADSPA_Descriptor_Function lad_descriptor_function;
93 const LADSPA_Descriptor *lad_descriptor;
95 // Driver for opengl calls.
99 PluginServer(char *path, MWindow *mwindow=0);
100 PluginServer(PluginServer &);
101 virtual ~PluginServer();
104 friend class PluginAClientLAD;
105 friend class PluginAClientConfig;
106 friend class PluginAClientWindow;
108 // open a plugin and wait for commands
109 // Get information for plugindb if master.
110 #define PLUGINSERVER_IS_LAD 2
111 #define PLUGINSERVER_NOT_RECOGNIZED 1
112 #define PLUGINSERVER_OK 0
113 int open_plugin(int master, Preferences *preferences,
114 EDL *edl, Plugin *plugin);
118 char *get_plugin_png_path(char *png_path);
119 void dump(FILE *fp=stdout);
120 // Release any objects which are required after playback stops.
122 // Write entry into plugin table
123 void write_table(FILE *fp, int idx);
124 static char *table_quoted_field(char *&sp);
125 int read_table(char *text);
127 void set_title(const char *string);
128 // Generate title for display
129 void generate_display_title(char *string);
130 // Get keyframes for configuration. Position is always relative to EDL rate.
131 KeyFrame* get_prev_keyframe(int64_t position);
132 KeyFrame* get_next_keyframe(int64_t position);
133 // get camera and projector positions
134 void get_camera(float *x, float *y, float *z,
135 int64_t position, int direction);
136 void get_projector(float *x, float *y, float *z,
137 int64_t position, int direction);
138 // Get interpolation used by EDL
139 int get_interpolation_type();
140 // Get or create keyframe for writing, depending on whether auto keyframes
141 // is enabled. Called by PluginClient::send_configure_change
142 KeyFrame* get_keyframe();
143 // Apply new settings from the plugin GUI. Called by PluginClient::send_configure_change
144 // Used in keyframe spanning mode.
145 void apply_keyframe(KeyFrame *src);
147 // Create new theme object. Used by theme plugins.
149 // Get theme being used by Cinelerra currently. Used by all plugins.
151 // Get picon png vframe image
153 VFrame *get_plugin_images();
155 void set_lad_index(int i);
158 // =============================== for realtime plugins
159 // save configuration of plugin
160 void save_data(KeyFrame *keyframe);
161 // Update EDL and playback engines to reflect changes
162 void sync_parameters();
163 // set for realtime processor usage
164 int set_realtime_sched();
165 int get_gui_status();
168 // cause the plugin to show the GUI
169 // Called by MWindow::show_plugin
172 // Update GUI with keyframe settings
175 void client_side_close();
176 // Set to 1 before every process call if the user supports OpenGL buffers.
177 // Also provides the driver location.
178 void set_use_opengl(int value, VideoDevice *vdevice);
179 // Plugin must call this before performing OpenGL operations.
180 int get_use_opengl();
182 // Called from plugin client
183 // Returns 1 if a GUI is open so OpenGL routines can determine if
186 // Called by plugin client to request synchronous routine.
187 void run_opengl(PluginClient *plugin_client);
189 // set the string that appears on the plugin title
190 int set_string(char *string);
191 // give the buffers and sizes and prepare processing realtime data
192 int init_realtime(int realtime_sched,
193 int total_in_buffers,
195 // process the data in the buffers
196 // input - the current edit's data
197 // output - the previous edit's data and the destination of the transition output
198 // current_position - Position from start of the transition and
199 // relative to the transition.
200 // total_len - total len for transition
201 void process_transition(VFrame *input,
203 int64_t current_position,
205 void process_transition(Samples *input,
207 int64_t current_position,
208 int64_t fragment_size,
211 // Process using pull method.
212 // current_position - start of region if forward, end of region if reverse
213 // relative to requested rate
214 // fragment_size - amount of data to put in buffer relative to requested rate
215 // sample_rate - sample rate of requested output
216 // frame_rate - frame rate of requested output
217 // total_len - length of plugin in track units relative to the EDL rate
218 // Units are kept relative to the EDL rate so plugins don't need to convert rates
219 // to get the keyframes.
220 void process_buffer(VFrame **frame,
221 int64_t current_position,
225 void process_buffer(Samples **buffer,
226 int64_t current_position,
227 int64_t fragment_size,
232 // Called by rendering client to cause the GUI to display something with the data.
233 void send_render_gui(void *data);
234 void send_render_gui(void *data, int size);
235 // Called by MWindow to cause GUI to display
236 void render_gui(void *data);
237 void render_gui(void *data, int size);
239 // Send the boundary autos of the next fragment
240 int set_automation(FloatAutos *autos, FloatAuto **start_auto, FloatAuto **end_auto, int reverse);
244 // set the fragment position of a buffer before rendering
245 int arm_buffer(int buffer_number,
246 int64_t in_fragment_position,
247 int64_t out_fragment_position,
248 int double_buffer_in,
249 int double_buffer_out);
250 // Detach all the shared buffers.
251 int detach_buffers();
253 int send_buffer_info();
256 // ============================ for non realtime plugins
257 // start processing data in plugin
258 int start_loop(int64_t start, int64_t end, int64_t buffer_size, int total_buffers);
259 // Do one iteration of a nonrealtime plugin and return if finished
260 int process_loop(VFrame **buffers, int64_t &write_length);
261 int process_loop(Samples **buffers, int64_t &write_length);
265 // Called by client to read data in non-realtime effect
266 int read_frame(VFrame *buffer,
268 int64_t start_position);
269 int read_samples(Samples *buffer,
271 int64_t start_position,
275 // Called by client to read data in realtime effect.
276 // Returns -1 if error or 0 if success.
277 int read_frame(VFrame *buffer,
279 int64_t start_position,
281 // Set to 1 if the reader can use OpenGL objects.
283 int read_samples(Samples *buffer,
286 int64_t start_position,
289 // For non realtime, prompt user for parameters, waits for plugin to finish and returns a result
290 int get_parameters(int64_t start, int64_t end, int channels);
291 int get_samplerate(); // get samplerate produced by plugin
292 double get_framerate(); // get framerate produced by plugin
293 int get_project_samplerate(); // get samplerate of project data before processing
294 double get_project_framerate(); // get framerate of project data before processing
295 int set_path(char *path); // required first
298 void get_defaults_path(char *path);
299 void save_defaults();
300 // Used by PluginArray and MenuEffects to get user parameters and progress bar.
301 // Set pointer to mwindow for opening GUI and reconfiguring EDL.
302 void set_mwindow(MWindow *mwindow);
303 // Used in VirtualConsole
304 // Set pointer to AttachmentPoint to render GUI.
305 void set_attachmentpoint(AttachmentPoint *attachmentpoint);
306 // Set pointer to a default keyframe when there is no plugin
307 void set_keyframe(KeyFrame *keyframe);
308 // Set pointer to menueffect window
309 void set_prompt(MenuEffectPrompt *prompt);
310 int set_interactive(); // make this the master plugin for progress bars
311 int set_error(); // flag to send plugin an error on next request
312 MainProgressBar* start_progress(char *string, int64_t length);
314 // add track to the list of affected tracks for a non realtime plugin
315 void append_module(Module *module);
316 // add node for realtime plugin
317 void append_node(VirtualNode *node);
318 // reset node table after virtual console reconfiguration
321 int64_t get_written_samples(); // after samples are written, get the number written
322 int64_t get_written_frames(); // after frames are written, get the number written
326 int64_t out_buffer_size; // size of a send buffer to the plugin
327 int64_t in_buffer_size; // size of a recieve buffer from the plugin
328 int total_in_buffers;
329 int total_out_buffers;
331 // number of double buffers for each channel
332 ArrayList<int> ring_buffers_in;
333 ArrayList<int> ring_buffers_out;
334 // Parameters for automation. Setting autos to 0 disables automation.
335 FloatAuto **start_auto, **end_auto;
339 // size of each buffer
340 ArrayList<int64_t> realtime_in_size;
341 ArrayList<int64_t> realtime_out_size;
343 // When arming buffers need to know the offsets in all the buffers and which
344 // double buffers for each channel before rendering.
345 ArrayList<int64_t> offset_in_render;
346 ArrayList<int64_t> offset_out_render;
347 ArrayList<int64_t> double_buffer_in_render;
348 ArrayList<int64_t> double_buffer_out_render;
350 // don't delete buffers if they belong to a virtual module
352 // Send new buffer information for next render
356 int plugin_open; // Whether or not the plugin is open.
357 // Specifies what type of plugin.
358 int realtime, multichannel, fileio;
359 // Plugin generates media
361 // What data types the plugin can handle. One of these is set.
362 int audio, video, theme;
365 // Plugin is a transition
367 // name of plugin in english.
368 // Compared against the title value in the plugin for resolving symbols.
370 int64_t written_samples, written_frames;
371 char *path; // location of plugin on disk
372 char *data_text; // pointer to the data that was requested by a save_data command
375 int error_flag; // send plugin an error code on next request
376 int dir_idx; // directory id, for icon visibility grouping
377 // Pointers to tracks affected by this plugin during a non realtime operation.
378 // Allows read functions to read data.
379 ArrayList<Module*> *modules;
380 // Used by realtime read functions to get data. Corresponds to the buffer table in the
382 ArrayList<VirtualNode*> *nodes;
383 AttachmentPoint *attachmentpoint;
385 // Pointer to keyframe when plugin is not available
387 AttachmentPoint *attachment;
388 // Storage of keyframes and GUI status
391 // Storage of session parameters
393 Preferences *preferences;
394 MenuEffectPrompt *prompt;
399 // Icon for tracking update