cinelerra-5.1/cinelerra/pluginclient.h

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 1997-2011 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 PLUGINCLIENT_H
  23 #define PLUGINCLIENT_H
  24
  25 // Base class inherited by all the different types of plugins.
  26
  27 #define BCASTDIR "~/.bcast5/"
  28 #define MAX_FRAME_BUFFER 1024
  29
  30 class PluginClient;
  31
  32
  33 #include "arraylist.h"
  34 #include "bchash.inc"
  35 #include "condition.h"
  36 #include "edlsession.inc"
  37 #include "keyframe.h"
  38 #include "mainprogress.inc"
  39 #include "maxbuffers.h"
  40 #include "pluginclient.inc"
  41 #include "plugincommands.h"
  42 #include "pluginserver.inc"
  43 #include "samples.inc"
  44 #include "theme.inc"
  45 #include "vframe.h"
  46
  47
  48 extern "C"
  49 {
  50 extern PluginClient* new_plugin(PluginServer *server);
  51 }
  52
  53 class PluginClientAuto
  54 {
  55 public:
  56         float position;
  57         float intercept;
  58         float slope;
  59 };
  60
  61
  62
  63
  64 // Convenience functions
  65
  66 #define REGISTER_PLUGIN(class_title) \
  67 PluginClient* new_plugin(PluginServer *server) \
  68 { \
  69         return new class_title(server); \
  70 }
  71
  72
  73
  74
  75
  76
  77
  78
  79 // Prototypes for user to put in class header
  80 #define PLUGIN_CLASS_MEMBERS(config_name) \
  81         int load_configuration(); \
  82         const char* plugin_title(); \
  83         PluginClientWindow* new_window(); \
  84         config_name config;
  85
  86
  87
  88 // Prototypes for user to put in class header
  89 #define PLUGIN_CLASS_MEMBERS2(config_name) \
  90         int load_configuration(); \
  91         const char* plugin_title(); \
  92         PluginClientWindow* new_window(); \
  93         config_name config;
  94
  95
  96
  97
  98
  99 #define NEW_WINDOW_MACRO(plugin_class, window_class) \
 100 PluginClientWindow* plugin_class::new_window() \
 101 { \
 102         return new window_class(this); \
 103 }
 104
 105 // Not all plugins load configuration the same way.  Use this to define
 106 // the normal way.
 107 #define LOAD_CONFIGURATION_MACRO(plugin_class, config_class) \
 108 int plugin_class::load_configuration() \
 109 { \
 110         KeyFrame *prev_keyframe, *next_keyframe; \
 111         prev_keyframe = get_prev_keyframe(get_source_position()); \
 112         next_keyframe = get_next_keyframe(get_source_position()); \
 113  \
 114         int64_t next_position = edl_to_local(next_keyframe->position); \
 115         int64_t prev_position = edl_to_local(prev_keyframe->position); \
 116  \
 117         config_class old_config, prev_config, next_config; \
 118         old_config.copy_from(config); \
 119         read_data(prev_keyframe); \
 120         prev_config.copy_from(config); \
 121         read_data(next_keyframe); \
 122         next_config.copy_from(config); \
 123  \
 124         config.interpolate(prev_config,  \
 125                 next_config,  \
 126                 (next_position == prev_position) ? \
 127                         get_source_position() : \
 128                         prev_position, \
 129                 (next_position == prev_position) ? \
 130                         get_source_position() + 1 : \
 131                         next_position, \
 132                 get_source_position()); \
 133  \
 134         if(!config.equivalent(old_config)) \
 135                 return 1; \
 136         else \
 137                 return 0; \
 138 }
 139
 140
 141
 142
 143 class PluginClientWindow : public BC_Window
 144 {
 145 public:
 146         PluginClientWindow(PluginClient *client,
 147                 int w,
 148                 int h,
 149                 int min_w,
 150                 int min_h,
 151                 int allow_resize);
 152         PluginClientWindow(const char *title,
 153                 int x,
 154                 int y,
 155                 int w,
 156                 int h,
 157                 int min_w,
 158                 int min_h,
 159                 int allow_resize);
 160         virtual ~PluginClientWindow();
 161
 162         virtual int translation_event();
 163         virtual int close_event();
 164
 165         PluginClient *client;
 166 };
 167
 168
 169
 170
 171 class PluginClientThread : public Thread
 172 {
 173 public:
 174         PluginClientThread(PluginClient *client);
 175         ~PluginClientThread();
 176         void run();
 177
 178         friend class PluginClient;
 179
 180         BC_WindowBase* get_window();
 181         PluginClient* get_client();
 182         BC_WindowBase *window;
 183         PluginClient *client;
 184
 185 private:
 186         Condition *init_complete;
 187 };
 188
 189
 190
 191 // Client overrides for GUI update data
 192 class PluginClientFrame
 193 {
 194 public:
 195 // Period_d is 1 second
 196         PluginClientFrame(int data_size, int period_n, int period_d);
 197         virtual ~PluginClientFrame();
 198         int data_size;
 199         int period_n;
 200         int period_d;
 201 // Draw immediately
 202         int force;
 203 };
 204
 205
 206
 207 class PluginClient
 208 {
 209 public:
 210         PluginClient(PluginServer *server);
 211         virtual ~PluginClient();
 212
 213         friend class PluginClientThread;
 214         friend class PluginClientWindow;
 215
 216 // Queries for the plugin server.
 217         virtual int is_realtime();
 218         virtual int is_audio();
 219         virtual int is_video();
 220         virtual int is_fileio();
 221         virtual int is_theme();
 222         virtual int uses_gui();
 223         virtual int is_multichannel();
 224         virtual int is_synthesis();
 225         virtual int is_transition();
 226         virtual const char* plugin_title();   // return the title of the plugin
 227         virtual Theme* new_theme();
 228 // Get theme being used by Cinelerra currently.  Used by all plugins.
 229         Theme* get_theme();
 230
 231
 232
 233
 234
 235
 236 // Non realtime signal processors define these.
 237 // Give the samplerate of the output for a non realtime plugin.
 238 // For realtime plugins give the requested samplerate.
 239         virtual int get_samplerate();
 240 // Give the framerate of the output for a non realtime plugin.
 241 // For realtime plugins give the requested framerate.
 242         virtual double get_framerate();
 243         virtual int delete_nonrealtime_parameters();
 244         virtual int start_plugin();         // run a non realtime plugin
 245         virtual int get_parameters();     // get information from user before non realtime processing
 246         virtual int64_t get_in_buffers(int64_t recommended_size);  // return desired size for input buffers
 247         virtual int64_t get_out_buffers(int64_t recommended_size);     // return desired size for output buffers
 248         virtual int start_loop();
 249         virtual int process_loop();
 250         virtual int stop_loop();
 251 // Hash files are the defaults for rendered plugins
 252         virtual int load_defaults();       // load default settings for the plugin
 253         virtual int save_defaults();      // save the current settings as defaults
 254         BC_Hash* get_defaults();
 255
 256
 257
 258
 259 // Realtime commands for signal processors.
 260 // These must be defined by the plugin itself.
 261 // Set the GUI title identifying the plugin to modules and patches.
 262         int set_string();
 263 // cause the plugin to create a new GUI class
 264         virtual BC_WindowBase* new_window();
 265 // Load the current keyframe.  Return 1 if it changed.
 266         virtual int load_configuration();
 267 // cause the plugin to hide the gui
 268         void client_side_close();
 269         void update_display_title();
 270 // Raise the GUI
 271         void raise_window();
 272 // Create GUI
 273         int show_gui();
 274 // XML keyframes are the defaults for realtime plugins
 275         void load_defaults_xml();
 276         void save_defaults_xml();
 277 // Tell the client if the load is the defaults
 278         int is_defaults();
 279
 280         virtual void update_gui();
 281         virtual void save_data(KeyFrame *keyframe) {};    // write the plugin settings to text in text format
 282         virtual void read_data(KeyFrame *keyframe) {};    // read the plugin settings from the text
 283         int send_hide_gui();                                    // should be sent when the GUI recieves a close event from the user
 284 // Destroys the window but not the thread pointer.
 285         void hide_gui();
 286
 287         int get_configure_change();                             // get propogated configuration change from a send_configure_change
 288
 289 // Called by plugin server to update GUI with rendered data.
 290         void plugin_render_gui(void *data);
 291         void plugin_render_gui(void *data, int size);
 292
 293         void begin_process_buffer();
 294         void end_process_buffer();
 295
 296         void plugin_update_gui();
 297         virtual int plugin_process_loop(VFrame **buffers, int64_t &write_length) { return 1; };
 298         virtual int plugin_process_loop(Samples **buffers, int64_t &write_length) { return 1; };
 299 // get parameters depending on video or audio
 300         virtual int init_realtime_parameters();
 301 // release objects which are required after playback stops
 302         virtual void render_stop() {};
 303         int get_gui_status();
 304         char* get_gui_string();
 305
 306 // Used by themes
 307 // Used by plugins which need to know where they are.
 308         char* get_path();
 309 // Get the directory for plugins
 310         char* get_plugin_dir();
 311
 312 // Return keyframe objects.  The position in the resulting object
 313 // is relative to the EDL rate.  This is the only way to avoid copying the
 314 // data for every frame.
 315 // If the result is the default keyframe, the keyframe's position is 0.
 316 // position - relative to EDL rate or local rate to allow simple
 317 //     passing of get_source_position.
 318 //     If -1 the tracking position in the edl is used.
 319 // is_local - if 1, the position is converted to the EDL rate.
 320         KeyFrame* get_prev_keyframe(int64_t position, int is_local = 1);
 321         KeyFrame* get_next_keyframe(int64_t position, int is_local = 1);
 322 // get current camera and projector position
 323         void get_camera(float *x, float *y, float *z, int64_t position);
 324         void get_projector(float *x, float *y, float *z, int64_t position);
 325 // When this plugin is adjusted, propogate parameters back to EDL and virtual
 326 // console.  This gets a keyframe from the EDL, with the position set to the
 327 // EDL tracking position.
 328         int send_configure_change();
 329
 330
 331 // Called from process_buffer
 332 // Returns 1 if a GUI is open so OpenGL routines can determine if
 333 // they can run.
 334         int gui_open();
 335
 336
 337
 338 // Length of source.  For effects it's the plugin length.  For transitions
 339 // it's the transition length.  Relative to the requested rate.
 340 // The only way to get smooth interpolation is to make all position queries
 341 // relative to the requested rate.
 342         int64_t get_total_len();
 343
 344 // For realtime plugins gets the lowest sample of the plugin in the requested
 345 // rate.  For others it's the start of the EDL selection in the EDL rate.
 346         int64_t get_source_start();
 347
 348 // Convert the position relative to the requested rate to the position
 349 // relative to the EDL rate.  If the argument is < 0, it is not changed.
 350 // Used for interpreting keyframes.
 351         virtual int64_t local_to_edl(int64_t position);
 352
 353 // Convert the EDL position to the local position.
 354         virtual int64_t edl_to_local(int64_t position);
 355
 356 // For transitions the source_position is the playback position relative
 357 // to the start of the transition.
 358 // For realtime effects, the start of the most recent process_buffer in forward
 359 // and the end of the range to process in reverse.  Relative to start of EDL in
 360 // the requested rate.
 361         int64_t get_source_position();
 362
 363 // Get the EDL Session.  May return 0 if the server has no edl.
 364         EDLSession* get_edlsession();
 365
 366
 367 // Get the direction of the most recent process_buffer
 368         int get_direction();
 369
 370 // Plugin must call this before performing OpenGL operations.
 371 // Returns 1 if the user supports opengl buffers.
 372         int get_use_opengl();
 373
 374 // Get total tracks to process
 375         int get_total_buffers();
 376
 377 // Get size of buffer to fill in non-realtime plugin
 378         int get_buffer_size();
 379
 380 // Get interpolation used by EDL from overlayframe.inc
 381         int get_interpolation_type();
 382
 383 // Get the values from the color picker
 384         float get_red();
 385         float get_green();
 386         float get_blue();
 387
 388
 389
 390 // Operations for file handlers
 391         virtual int open_file() { return 0; };
 392         virtual int get_audio_parameters() { return 0; };
 393         virtual int get_video_parameters() { return 0; };
 394         virtual int check_header(char *path) { return 0; };
 395         virtual int open_file(char *path, int wr, int rd) { return 1; };
 396         virtual int close_file() { return 0; };
 397
 398
 399
 400
 401
 402 // All plugins define these.
 403         PluginClientThread* get_thread();
 404
 405
 406
 407 // Non realtime operations for signal processors.
 408         virtual int plugin_start_loop(int64_t start,
 409                 int64_t end,
 410                 int64_t buffer_size,
 411                 int total_buffers);
 412         int plugin_stop_loop();
 413         int plugin_process_loop();
 414         MainProgressBar* start_progress(char *string, int64_t length);
 415 // get samplerate of EDL
 416         int get_project_samplerate();
 417 // get framerate of EDL
 418         double get_project_framerate();
 419 // Total number of processors - 1
 420         int get_project_smp();
 421         int get_aspect_ratio(float &aspect_w, float &aspect_h);
 422
 423
 424         int write_frames(int64_t total_frames);  // returns 1 for failure / tells the server that all output channel buffers are ready to go
 425         int write_samples(int64_t total_samples);  // returns 1 for failure / tells the server that all output channel buffers are ready to go
 426         virtual int plugin_get_parameters();
 427         const char* get_defaultdir();     // Directory defaults should be stored in
 428         void set_interactive();
 429
 430 // Realtime operations.
 431         int reset();
 432 // Extension of plugin_run for derived plugins
 433         virtual int plugin_command_derived(int plugin_command) { return 0; };
 434         int plugin_get_range();
 435         int plugin_init_realtime(int realtime_priority,
 436                 int total_in_buffers,
 437                 int buffer_size);
 438
 439
 440 // GUI updating wrappers for realtime plugins
 441 // Append frame to queue for next send_frame_buffer
 442         void add_gui_frame(PluginClientFrame *frame);
 443
 444
 445
 446         virtual void render_gui(void *data);
 447         virtual void render_gui(void *data, int size);
 448
 449 // Called by client to get the total number of frames to draw in update_gui
 450         int get_gui_update_frames();
 451 // Get GUI frame from frame_buffer.  Client must delete it.
 452         PluginClientFrame* get_gui_frame();
 453
 454 // Called by client to cause GUI to be rendered with data.
 455         void send_render_gui();
 456         void send_render_gui(void *data);
 457         void send_render_gui(void *data, int size);
 458
 459
 460
 461
 462
 463
 464
 465
 466 // create pointers to buffers of the plugin's type before realtime rendering
 467         virtual int delete_buffer_ptrs();
 468
 469
 470
 471
 472 // communication convenience routines for the base class
 473         int stop_gui_client();
 474         int save_data_client();
 475         int load_data_client();
 476         int set_string_client(char *string);                // set the string identifying the plugin
 477         int send_cancelled();        // non realtime plugin sends when cancelled
 478
 479 // ================================= Buffers ===============================
 480
 481 // number of double buffers for each channel
 482         ArrayList<int> double_buffers_in;
 483         ArrayList<int> double_buffers_out;
 484 // When arming buffers need to know the offsets in all the buffers and which
 485 // double buffers for each channel before rendering.
 486         ArrayList<int64_t> offset_in_render;
 487         ArrayList<int64_t> offset_out_render;
 488         ArrayList<int64_t> double_buffer_in_render;
 489         ArrayList<int64_t> double_buffer_out_render;
 490 // total size of each buffer depends on if it's a master or node
 491         ArrayList<int64_t> realtime_in_size;
 492         ArrayList<int64_t> realtime_out_size;
 493
 494 // ================================= Automation ===========================
 495
 496         ArrayList<PluginClientAuto> automation;
 497
 498 // ================================== Messages ===========================
 499         char gui_string[BCTEXTLEN];          // string identifying module and plugin
 500         int master_gui_on;              // Status of the master gui plugin
 501         int client_gui_on;              // Status of this client's gui
 502
 503         int show_initially;             // set to show a realtime plugin initially
 504 // range in project for processing
 505         int64_t start, end;
 506         int interactive;                // for the progress bar plugin
 507         int success;
 508         int total_out_buffers;          // total send buffers allocated by the server
 509         int total_in_buffers;           // total recieve buffers allocated by the server
 510         int wr, rd;                     // File permissions for fileio plugins.
 511
 512 // These give the largest fragment the plugin is expected to handle.
 513 // size of a send buffer to the server
 514         int64_t out_buffer_size;
 515 // size of a recieve buffer from the server
 516         int64_t in_buffer_size;
 517
 518
 519
 520
 521 // Direction of most recent process_buffer
 522         int direction;
 523
 524 // Operating system scheduling
 525         int realtime_priority;
 526
 527 // Position relative to start of EDL in requested rate.  Calculated for every process
 528 // command.  Used for keyframes.
 529         int64_t source_position;
 530 // For realtime plugins gets the lowest sample of the plugin in the requested
 531 // rate.  For others it's always 0.
 532         int64_t source_start;
 533 // Length of source.  For effects it's the plugin length.  For transitions
 534 // it's the transition length.  Relative to the requested rate.
 535         int64_t total_len;
 536 // Total number of processors available - 1
 537         int smp;
 538         PluginServer *server;
 539         BC_Hash *defaults;
 540         PluginClientThread *thread;
 541
 542 // Frames for updating GUI
 543         ArrayList<PluginClientFrame*> frame_buffer;
 544 // Time of last GUI update
 545         Timer *update_timer;
 546
 547
 548 private:
 549         int using_defaults;
 550 // Temporaries set in new_window
 551         int window_x, window_y;
 552 // File handlers:
 553 //      Asset *asset;     // Point to asset structure in shared memory
 554 };
 555
 556
 557 #endif