hvirtual/plugins/interpolateall/interpolateall.C

   1 #include "bcdisplayinfo.h"
   2 #include "clip.h"
   3 #include "defaults.h"
   4 #include "guicast.h"
   5 #include "filexml.h"
   6 #include "mainprogress.h"
   7 #include "pluginaclient.h"
   8
   9 #include <string.h>
  10
  11
  12 #include <libintl.h>
  13 #define _(String) gettext(String)
  14 #define gettext_noop(String) String
  15 #define N_(String) gettext_noop (String)
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25 class InterpolateAllEffect : public PluginAClient
  26 {
  27 public:
  28         InterpolateAllEffect(PluginServer *server);
  29         ~InterpolateAllEffect();
  30
  31         char* plugin_title();
  32         int is_realtime();
  33         int is_multichannel();
  34         int get_parameters();
  35         int start_loop();
  36         int process_loop(double *buffer, long &output_lenght);
  37         int stop_loop();
  38
  39
  40
  41
  42         int state;
  43         enum
  44         {
  45                 READING,
  46                 WRITING
  47         };
  48         double sample1;
  49         double sample2;
  50         int current_position;
  51         double slope;
  52         double intercept;
  53
  54         MainProgressBar *progress;
  55 };
  56
  57
  58
  59
  60 REGISTER_PLUGIN(InterpolateAllEffect)
  61
  62
  63
  64
  65
  66
  67
  68
  69 InterpolateAllEffect::InterpolateAllEffect(PluginServer *server)
  70  : PluginAClient(server)
  71 {
  72 }
  73
  74 InterpolateAllEffect::~InterpolateAllEffect()
  75 {
  76 }
  77
  78
  79
  80
  81 char* InterpolateAllEffect::plugin_title()
  82 {
  83         return _("Interpolate");
  84 }
  85
  86
  87 int InterpolateAllEffect::is_realtime()
  88 {
  89         return 0;
  90 }
  91
  92 int InterpolateAllEffect::is_multichannel()
  93 {
  94         return 0;
  95 }
  96
  97
  98 int InterpolateAllEffect::get_parameters()
  99 {
 100         return 0;
 101 }
 102
 103 int InterpolateAllEffect::start_loop()
 104 {
 105         state = READING;
 106         char string[BCTEXTLEN];
 107         sprintf(string, "%s...", plugin_title());
 108         progress = start_progress(string, (PluginClient::end - PluginClient::start));
 109         current_position = PluginClient::start;
 110         return 0;
 111 }
 112
 113 int InterpolateAllEffect::stop_loop()
 114 {
 115         progress->stop_progress();
 116         delete progress;
 117         return 0;
 118 }
 119
 120 int InterpolateAllEffect::process_loop(double *buffer, long &write_length)
 121 {
 122 //printf("InterpolateAllEffect::process_loop 1\n");
 123         int result = 0;
 124         if(state == READING)
 125         {
 126 // Read a certain amount before the first sample
 127                 int leadin = PluginClient::in_buffer_size;
 128 //printf("InterpolateAllEffect::process_loop 2\n");
 129                 double buffer[leadin];
 130                 if(PluginClient::start - leadin < 0) leadin = PluginClient::start;
 131                 read_samples(buffer, PluginClient::start - leadin, leadin);
 132                 sample1 = buffer[leadin - 1];
 133
 134 // Read a certain amount before the last sample
 135                 leadin = PluginClient::in_buffer_size;
 136                 if(PluginClient::end - leadin < 0) leadin = PluginClient::end;
 137                 read_samples(buffer, PluginClient::end - leadin, leadin);
 138                 sample2 = buffer[leadin - 1];
 139                 state = WRITING;
 140                 current_position = PluginClient::start;
 141
 142 // Get slope and intercept
 143                 slope = (sample2 - sample1) /
 144                         (PluginClient::end - PluginClient::start);
 145                 intercept = sample1;
 146 //printf("InterpolateAllEffect::process_loop 3\n");
 147         }
 148 //printf("InterpolateAllEffect::process_loop 4\n");
 149
 150         int fragment_len = PluginClient::in_buffer_size;
 151         if(current_position + fragment_len > PluginClient::end) fragment_len = PluginClient::end - current_position;
 152         double intercept2 = intercept + slope * (current_position - PluginClient::start);
 153         for(int i = 0; i < fragment_len; i++)
 154         {
 155                 buffer[i] = intercept2 + slope * i;
 156         }
 157         current_position += fragment_len;
 158         write_length = fragment_len;
 159         result = progress->update(PluginClient::end -
 160                 PluginClient::start +
 161                 current_position -
 162                 PluginClient::start);
 163         if(current_position >= PluginClient::end) result = 1;
 164 //printf("InterpolateAllEffect::process_loop 5\n");
 165
 166
 167         return result;
 168 }
 169
 170
 171