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 #define RADIUS_MIN   0
  47 #define RADIUS_MAX 100
  48 #define ANGLE_MAX  180
  49 #define STEPS_MIN    1
  50 #define STEPS_MAX  200
  51
  52 class LinearBlurMain;
  53 class LinearBlurWindow;
  54 class LinearBlurEngine;
  55 class LinearBlurIText;
  56 class LinearBlurISlider;
  57 class LinearBlurToggle;
  58 class LinearBlurReset;
  59 class LinearBlurDefaultSettings;
  60 class LinearBlurClr;
  61
  62
  63
  64 class LinearBlurConfig
  65 {
  66 public:
  67         LinearBlurConfig();
  68
  69         void reset(int clear);
  70         int equivalent(LinearBlurConfig &that);
  71         void copy_from(LinearBlurConfig &that);
  72         void interpolate(LinearBlurConfig &prev,
  73                 LinearBlurConfig &next,
  74                 long prev_frame,
  75                 long next_frame,
  76                 long current_frame);
  77
  78         int radius;
  79         int steps;
  80         int angle;
  81         int r;
  82         int g;
  83         int b;
  84         int a;
  85 };
  86
  87
  88
  89 class LinearBlurSize : public BC_ISlider
  90 {
  91 public:
  92         LinearBlurSize(LinearBlurMain *plugin,
  93                 int x,
  94                 int y,
  95                 int *output,
  96                 int min,
  97                 int max);
  98         int handle_event();
  99         LinearBlurMain *plugin;
 100         int *output;
 101 };
 102
 103 class LinearBlurIText : public BC_TumbleTextBox
 104 {
 105 public:
 106         LinearBlurIText(LinearBlurWindow *gui, LinearBlurMain *plugin,
 107                 LinearBlurISlider *slider, int *output, int x, int y, int min, int max);
 108         ~LinearBlurIText();
 109         int handle_event();
 110         LinearBlurWindow *gui;
 111         LinearBlurMain *plugin;
 112         LinearBlurISlider *slider;
 113         int *output;
 114         int min, max;
 115 };
 116
 117 class LinearBlurISlider : public BC_ISlider
 118 {
 119 public:
 120         LinearBlurISlider(LinearBlurMain *plugin,
 121                 LinearBlurIText *text, int *output, int x, int y,
 122                 int min, int max, int w);
 123         ~LinearBlurISlider();
 124         int handle_event();
 125         LinearBlurMain *plugin;
 126         LinearBlurIText *text;
 127         int *output;
 128 };
 129
 130 class LinearBlurToggle : public BC_CheckBox
 131 {
 132 public:
 133         LinearBlurToggle(LinearBlurMain *plugin,
 134                 int x,
 135                 int y,
 136                 int *output,
 137                 char *string);
 138         int handle_event();
 139         LinearBlurMain *plugin;
 140         int *output;
 141 };
 142
 143 class LinearBlurReset : public BC_GenericButton
 144 {
 145 public:
 146         LinearBlurReset(LinearBlurMain *plugin, LinearBlurWindow *gui, int x, int y);
 147         ~LinearBlurReset();
 148         int handle_event();
 149         LinearBlurMain *plugin;
 150         LinearBlurWindow *gui;
 151 };
 152
 153 class LinearBlurDefaultSettings : public BC_GenericButton
 154 {
 155 public:
 156         LinearBlurDefaultSettings(LinearBlurMain *plugin, LinearBlurWindow *gui, int x, int y, int w);
 157         ~LinearBlurDefaultSettings();
 158         int handle_event();
 159         LinearBlurMain *plugin;
 160         LinearBlurWindow *gui;
 161 };
 162
 163 class LinearBlurClr : public BC_Button
 164 {
 165 public:
 166         LinearBlurClr(LinearBlurMain *plugin, LinearBlurWindow *gui, int x, int y, int clear);
 167         ~LinearBlurClr();
 168         int handle_event();
 169         LinearBlurMain *plugin;
 170         LinearBlurWindow *gui;
 171         int clear;
 172 };
 173
 174 class LinearBlurWindow : public PluginClientWindow
 175 {
 176 public:
 177         LinearBlurWindow(LinearBlurMain *plugin);
 178         ~LinearBlurWindow();
 179
 180         void create_objects();
 181         void update_gui(int clear);
 182
 183         LinearBlurIText *radius_text;
 184         LinearBlurISlider *radius_slider;
 185         LinearBlurClr *radius_Clr;
 186
 187         LinearBlurIText *angle_text;
 188         LinearBlurISlider *angle_slider;
 189         LinearBlurClr *angle_Clr;
 190
 191         LinearBlurIText *steps_text;
 192         LinearBlurISlider *steps_slider;
 193         LinearBlurClr *steps_Clr;
 194
 195         LinearBlurToggle *r, *g, *b, *a;
 196         LinearBlurMain *plugin;
 197         LinearBlurReset *reset;
 198         LinearBlurDefaultSettings *default_settings;
 199 };
 200
 201
 202
 203
 204
 205 // Output coords for a layer of blurring
 206 // Used for OpenGL only
 207 class LinearBlurLayer
 208 {
 209 public:
 210         LinearBlurLayer() {};
 211         int x, y;
 212 };
 213
 214 class LinearBlurMain : public PluginVClient
 215 {
 216 public:
 217         LinearBlurMain(PluginServer *server);
 218         ~LinearBlurMain();
 219
 220         int process_buffer(VFrame *frame,
 221                 int64_t start_position,
 222                 double frame_rate);
 223         int is_realtime();
 224         void save_data(KeyFrame *keyframe);
 225         void read_data(KeyFrame *keyframe);
 226         void update_gui();
 227         int handle_opengl();
 228
 229         PLUGIN_CLASS_MEMBERS(LinearBlurConfig)
 230
 231         void delete_tables();
 232         VFrame *input, *output, *temp;
 233         LinearBlurEngine *engine;
 234         int **scale_y_table;
 235         int **scale_x_table;
 236         LinearBlurLayer *layer_table;
 237         int table_entries;
 238         int need_reconfigure;
 239 // The accumulation buffer is needed because 8 bits isn't precise enough
 240         unsigned char *accum;
 241 };
 242
 243 class LinearBlurPackage : public LoadPackage
 244 {
 245 public:
 246         LinearBlurPackage();
 247         int y1, y2;
 248 };
 249
 250 class LinearBlurUnit : public LoadClient
 251 {
 252 public:
 253         LinearBlurUnit(LinearBlurEngine *server, LinearBlurMain *plugin);
 254         void process_package(LoadPackage *package);
 255         LinearBlurEngine *server;
 256         LinearBlurMain *plugin;
 257 };
 258
 259 class LinearBlurEngine : public LoadServer
 260 {
 261 public:
 262         LinearBlurEngine(LinearBlurMain *plugin,
 263                 int total_clients,
 264                 int total_packages);
 265         void init_packages();
 266         LoadClient* new_client();
 267         LoadPackage* new_package();
 268         LinearBlurMain *plugin;
 269 };
 270
 271 #endif