cinelerra-5.1/cinelerra/compressortools.h

   1 /*
   2  * CINELERRA
   3  * Copyright (C) 2008-2019 Adam Williams <broadcast at earthling dot net>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  */
  20
  21
  22 // Base classes for compressors
  23
  24 #ifndef COMPRESSORTOOLS_H
  25 #define COMPRESSORTOOLS_H
  26
  27
  28 #include "guicast.h"
  29 #include "pluginaclient.h"
  30 #include "samples.inc"
  31
  32
  33 #define MIN_ATTACK -10
  34 #define MAX_ATTACK 10
  35 #define MIN_DECAY 0
  36 #define MAX_DECAY 255
  37 #define MIN_TRIGGER 0
  38 #define MAX_TRIGGER 255
  39 // range of the meter
  40 #define MIN_GAIN_CHANGE -20
  41 #define MAX_GAIN_CHANGE 20
  42
  43
  44 class CompressorConfigBase;
  45 class CompressorPopup;
  46
  47
  48 // get sample from trigger buffer
  49 #define GET_TRIGGER(buffer, offset) \
  50 double sample = 0; \
  51 switch(config->input) \
  52 { \
  53         case CompressorConfigBase::MAX: \
  54         { \
  55                 double max = 0; \
  56                 for(int channel = 0; channel < channels; channel++) \
  57                 { \
  58                         sample = fabs((buffer)[offset]); \
  59                         if(sample > max) max = sample; \
  60                 } \
  61                 sample = max; \
  62                 break; \
  63         } \
  64  \
  65         case CompressorConfigBase::TRIGGER: \
  66                 sample = fabs(trigger_buffer[offset]); \
  67                 break; \
  68  \
  69         case CompressorConfigBase::SUM: \
  70         { \
  71                 double max = 0; \
  72                 for(int channel = 0; channel < channels; channel++) \
  73                 { \
  74                         sample = fabs((buffer)[offset]); \
  75                         max += sample; \
  76                 } \
  77                 sample = max; \
  78                 break; \
  79         } \
  80 }
  81
  82
  83
  84
  85
  86 typedef struct
  87 {
  88 // DB from min_db - 0
  89         double x, y;
  90 } compressor_point_t;
  91
  92 class BandConfig
  93 {
  94 public:
  95         BandConfig();
  96         virtual ~BandConfig();
  97
  98         void copy_from(BandConfig *src);
  99         int equiv(BandConfig *src);
 100         void boundaries(CompressorConfigBase *base);
 101         void save_data(FileXML *xml, int number, int do_multiband);
 102         void read_data(FileXML *xml, int do_multiband);
 103         void reset();
 104
 105         ArrayList<compressor_point_t> levels;
 106         int solo;
 107         int bypass;
 108 // units of seconds
 109 //      double readahead_len;
 110         double attack_len;
 111         double release_len;
 112         double mkup_gain;
 113
 114 // upper frequency in Hz
 115         int freq;
 116 };
 117
 118 class CompressorConfigBase
 119 {
 120 public:
 121         CompressorConfigBase(int total_bands);
 122         virtual ~CompressorConfigBase();
 123
 124         virtual void copy_from(CompressorConfigBase &that);
 125         virtual int equivalent(CompressorConfigBase &that);
 126         void boundaries();
 127
 128         void reset_base();
 129         void reset_bands();
 130         void remove_point(int band, int number);
 131         int set_point(int band, double x, double y);
 132         double calculate_db(int band, double x);
 133         double get_x(int band, int number);
 134         double get_y(int band, int number);
 135         double calculate_gain(int band, double input);
 136
 137 // Calculate linear output from linear input
 138         double calculate_output(int band, double x);
 139
 140 // min DB of the graph
 141         double min_db;
 142 // max DB of the graph
 143         double max_db;
 144
 145         BandConfig *bands;
 146         int total_bands;
 147         int current_band;
 148         int trigger;
 149         int input;
 150         enum
 151         {
 152                 TRIGGER,
 153                 MAX,
 154                 SUM
 155         };
 156
 157         double min_value;
 158 //      double min_x, min_y;
 159 //      double max_x, max_y;
 160         int smoothing_only;
 161 };
 162
 163
 164 class CompressorCanvasBase : public BC_SubWindow
 165 {
 166 public:
 167         CompressorCanvasBase(CompressorConfigBase *config, PluginClient *plugin,
 168                 PluginClientWindow *window, int x, int y, int w, int h);
 169         virtual ~CompressorCanvasBase();
 170         int is_dragging();
 171         int button_press_event();
 172         int button_release_event();
 173         int cursor_motion_event();
 174         void create_objects();
 175         void draw_scales();
 176         void update();
 177         int x_to_y(int band, int x);
 178         int db_to_x(double db);
 179         int db_to_y(double db);
 180         double x_to_db(int x);
 181         double y_to_db(int y);
 182
 183         virtual void update_window();
 184
 185         enum { NONE, DRAG };
 186
 187 // clickable area of canvas
 188         int graph_x, graph_y;
 189         int graph_w, graph_h;
 190         int current_point;
 191         int current_operation;
 192         int divisions;
 193         int subdivisions;
 194         CompressorConfigBase *config;
 195         CompressorPopup *menu;
 196         PluginClient *plugin;
 197         PluginClientWindow *window;
 198 };
 199
 200
 201 #define FREQ_COMPRESSORFRAME 0
 202 #define GAIN_COMPRESSORFRAME 1
 203 // used in eqcanvas, compressortools,
 204 //  plugins: compressor, compressormulti
 205 class CompressorClientFrame : public PluginClientFrame
 206 {
 207 public:
 208         CompressorClientFrame();
 209         ~CompressorClientFrame();
 210         int type, band;
 211 };
 212
 213 class CompressorFreqFrame : public CompressorClientFrame
 214 {
 215 public:
 216         CompressorFreqFrame();
 217         ~CompressorFreqFrame();
 218
 219         double freq_max, time_max;
 220         double *data;
 221         int data_size;
 222         int nyquist;
 223 };
 224
 225 class CompressorGainFrame : public CompressorClientFrame
 226 {
 227 public:
 228         CompressorGainFrame();
 229         ~CompressorGainFrame();
 230
 231         double gain, level;
 232 };
 233
 234 class CompressorEngine
 235 {
 236 public:
 237         CompressorEngine(CompressorConfigBase *config,
 238                 int band);
 239         ~CompressorEngine();
 240
 241         void reset();
 242         void calculate_ranges(int *attack_samples,
 243                 int *release_samples,
 244                 int *preview_samples,
 245                 int sample_rate);
 246         void process(Samples **output_buffer,
 247                 Samples **input_buffer,
 248                 int size,
 249                 int sample_rate,
 250                 int channels,
 251                 int64_t start_position);
 252
 253         CompressorConfigBase *config;
 254         int band;
 255 // the current line segment defining the smooth signal level
 256 // starting input value of line segment
 257         double slope_value1;
 258 // ending input value of line segment
 259         double slope_value2;
 260 // samples comprising the line segment
 261         int slope_samples;
 262 // samples from the start of the line to the peak that determined the slope
 263         int peak_samples;
 264 // current sample from 0 to slope_samples
 265         int slope_current_sample;
 266 // current value in the line segment
 267         double current_value;
 268 // gain change values to draw on the GUI
 269         ArrayList<double> gui_gains;
 270 // input levels to draw on the GUI
 271         ArrayList<double> gui_levels;
 272 // which second in process() the gui_values came from
 273         ArrayList<double> gui_offsets;
 274 // samples between gui_values.  Set by the user.
 275         int gui_frame_samples;
 276 // temporaries
 277         int gui_frame_counter;
 278         double gui_max_gain;
 279         double gui_max_level;
 280 };
 281
 282
 283 class CompressorCopy : public BC_MenuItem
 284 {
 285 public:
 286         CompressorCopy(CompressorPopup *popup);
 287         ~CompressorCopy();
 288         int handle_event();
 289         CompressorPopup *popup;
 290 };
 291
 292 class CompressorPaste : public BC_MenuItem
 293 {
 294 public:
 295         CompressorPaste(CompressorPopup *popup);
 296         ~CompressorPaste();
 297         int handle_event();
 298         CompressorPopup *popup;
 299 };
 300
 301 class CompressorClearGraph : public BC_MenuItem
 302 {
 303 public:
 304         CompressorClearGraph(CompressorPopup *popup);
 305         ~CompressorClearGraph();
 306         int handle_event();
 307         CompressorPopup *popup;
 308 };
 309
 310 class CompressorPopup : public BC_PopupMenu
 311 {
 312 public:
 313         CompressorPopup(CompressorCanvasBase *canvas);
 314         ~CompressorPopup();
 315
 316         void create_objects();
 317
 318
 319         CompressorCanvasBase *canvas;
 320 };
 321
 322 #endif
 323
 324
 325
 326