cinelerra-5.1/plugins/linearblur/linearblur.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 LINEARBLUR_H
  23 #define LINEARBLUR_H
  24
  25
  26 #include <math.h>
  27 #include <stdint.h>
  28 #include <string.h>
  29
  30 #include "bcdisplayinfo.h"
  31 #include "clip.h"
  32 #include "bchash.h"
  33 #include "filexml.h"
  34 #include "keyframe.h"
  35 #include "language.h"
  36 #include "loadbalance.h"
  37 #include "pluginvclient.h"
  38 #include "vframe.h"
  39
  40 #define RESET_DEFAULT_SETTINGS 10
  41 #define RESET_ALL    0
  42 #define RESET_RADIUS 1
  43 #define RESET_ANGLE  2
  44 #define RESET_STEPS  3
  45
  46 class LinearBlurMain;
  47 class LinearBlurWindow;
  48 class LinearBlurEngine;
  49 class LinearBlurReset;
  50 class LinearBlurDefaultSettings;
  51 class LinearBlurSliderClr;
  52
  53
  54
  55 class LinearBlurConfig
  56 {
  57 public:
  58         LinearBlurConfig();
  59
  60         void reset(int clear);
  61         int equivalent(LinearBlurConfig &that);
  62         void copy_from(LinearBlurConfig &that);
  63         void interpolate(LinearBlurConfig &prev,
  64                 LinearBlurConfig &next,
  65                 long prev_frame,
  66                 long next_frame,
  67                 long current_frame);
  68
  69         int radius;
  70         int steps;
  71         int angle;
  72         int r;
  73         int g;
  74         int b;
  75         int a;
  76 };
  77
  78
  79
  80 class LinearBlurSize : public BC_ISlider
  81 {
  82 public:
  83         LinearBlurSize(LinearBlurMain *plugin,
  84                 int x,
  85                 int y,
  86                 int *output,
  87                 int min,
  88                 int max);
  89         int handle_event();
  90         LinearBlurMain *plugin;
  91         int *output;
  92 };
  93
  94 class LinearBlurToggle : public BC_CheckBox
  95 {
  96 public:
  97         LinearBlurToggle(LinearBlurMain *plugin,
  98                 int x,
  99                 int y,
 100                 int *output,
 101                 char *string);
 102         int handle_event();
 103         LinearBlurMain *plugin;
 104         int *output;
 105 };
 106
 107 class LinearBlurReset : public BC_GenericButton
 108 {
 109 public:
 110         LinearBlurReset(LinearBlurMain *plugin, LinearBlurWindow *gui, int x, int y);
 111         ~LinearBlurReset();
 112         int handle_event();
 113         LinearBlurMain *plugin;
 114         LinearBlurWindow *gui;
 115 };
 116
 117 class LinearBlurDefaultSettings : public BC_GenericButton
 118 {
 119 public:
 120         LinearBlurDefaultSettings(LinearBlurMain *plugin, LinearBlurWindow *gui, int x, int y, int w);
 121         ~LinearBlurDefaultSettings();
 122         int handle_event();
 123         LinearBlurMain *plugin;
 124         LinearBlurWindow *gui;
 125 };
 126
 127 class LinearBlurSliderClr : public BC_Button
 128 {
 129 public:
 130         LinearBlurSliderClr(LinearBlurMain *plugin, LinearBlurWindow *gui, int x, int y, int w, int clear);
 131         ~LinearBlurSliderClr();
 132         int handle_event();
 133         LinearBlurMain *plugin;
 134         LinearBlurWindow *gui;
 135         int clear;
 136 };
 137
 138 class LinearBlurWindow : public PluginClientWindow
 139 {
 140 public:
 141         LinearBlurWindow(LinearBlurMain *plugin);
 142         ~LinearBlurWindow();
 143
 144         void create_objects();
 145         void update_gui(int clear);
 146
 147         LinearBlurSize *angle, *steps, *radius;
 148         LinearBlurToggle *r, *g, *b, *a;
 149         LinearBlurMain *plugin;
 150         LinearBlurReset *reset;
 151         LinearBlurDefaultSettings *default_settings;
 152         LinearBlurSliderClr *radiusClr;
 153         LinearBlurSliderClr *angleClr;
 154         LinearBlurSliderClr *stepsClr;
 155 };
 156
 157
 158
 159
 160
 161 // Output coords for a layer of blurring
 162 // Used for OpenGL only
 163 class LinearBlurLayer
 164 {
 165 public:
 166         LinearBlurLayer() {};
 167         int x, y;
 168 };
 169
 170 class LinearBlurMain : public PluginVClient
 171 {
 172 public:
 173         LinearBlurMain(PluginServer *server);
 174         ~LinearBlurMain();
 175
 176         int process_buffer(VFrame *frame,
 177                 int64_t start_position,
 178                 double frame_rate);
 179         int is_realtime();
 180         void save_data(KeyFrame *keyframe);
 181         void read_data(KeyFrame *keyframe);
 182         void update_gui();
 183         int handle_opengl();
 184
 185         PLUGIN_CLASS_MEMBERS(LinearBlurConfig)
 186
 187         void delete_tables();
 188         VFrame *input, *output, *temp;
 189         LinearBlurEngine *engine;
 190         int **scale_y_table;
 191         int **scale_x_table;
 192         LinearBlurLayer *layer_table;
 193         int table_entries;
 194         int need_reconfigure;
 195 // The accumulation buffer is needed because 8 bits isn't precise enough
 196         unsigned char *accum;
 197 };
 198
 199 class LinearBlurPackage : public LoadPackage
 200 {
 201 public:
 202         LinearBlurPackage();
 203         int y1, y2;
 204 };
 205
 206 class LinearBlurUnit : public LoadClient
 207 {
 208 public:
 209         LinearBlurUnit(LinearBlurEngine *server, LinearBlurMain *plugin);
 210         void process_package(LoadPackage *package);
 211         LinearBlurEngine *server;
 212         LinearBlurMain *plugin;
 213 };
 214
 215 class LinearBlurEngine : public LoadServer
 216 {
 217 public:
 218         LinearBlurEngine(LinearBlurMain *plugin,
 219                 int total_clients,
 220                 int total_packages);
 221         void init_packages();
 222         LoadClient* new_client();
 223         LoadPackage* new_package();
 224         LinearBlurMain *plugin;
 225 };
 226
 227 #endif