hvirtual/plugins/wave/wave.C

   1 #include "bcdisplayinfo.h"
   2 #include "clip.h"
   3 #include "defaults.h"
   4 #include "filexml.h"
   5 #include "guicast.h"
   6 #include "keyframe.h"
   7 #include "loadbalance.h"
   8 #include "picon_png.h"
   9 #include "pluginvclient.h"
  10 #include "vframe.h"
  11
  12 #include <math.h>
  13 #include <stdint.h>
  14 #include <string.h>
  15
  16 #include <libintl.h>
  17 #define _(String) gettext(String)
  18 #define gettext_noop(String) String
  19 #define N_(String) gettext_noop (String)
  20
  21
  22
  23 #define SMEAR 0
  24 #define BLACKEN 1
  25
  26
  27
  28 class WaveEffect;
  29 class WaveWindow;
  30
  31
  32 class WaveConfig
  33 {
  34 public:
  35         WaveConfig();
  36         void copy_from(WaveConfig &src);
  37         int equivalent(WaveConfig &src);
  38         void interpolate(WaveConfig &prev,
  39                 WaveConfig &next,
  40                 long prev_frame,
  41                 long next_frame,
  42                 long current_frame);
  43         int mode;
  44         int reflective;
  45         float amplitude;
  46         float phase;
  47         float wavelength;
  48 };
  49
  50 class WaveSmear : public BC_Radial
  51 {
  52 public:
  53         WaveSmear(WaveEffect *plugin, WaveWindow *window, int x, int y);
  54         int handle_event();
  55         WaveEffect *plugin;
  56         WaveWindow *window;
  57 };
  58
  59 class WaveBlacken : public BC_Radial
  60 {
  61 public:
  62         WaveBlacken(WaveEffect *plugin, WaveWindow *window, int x, int y);
  63         int handle_event();
  64         WaveEffect *plugin;
  65         WaveWindow *window;
  66 };
  67
  68
  69 class WaveReflective : public BC_CheckBox
  70 {
  71 public:
  72         WaveReflective(WaveEffect *plugin, int x, int y);
  73         int handle_event();
  74         WaveEffect *plugin;
  75 };
  76
  77 class WaveAmplitude : public BC_FSlider
  78 {
  79 public:
  80         WaveAmplitude(WaveEffect *plugin, int x, int y);
  81         int handle_event();
  82         WaveEffect *plugin;
  83 };
  84
  85 class WavePhase : public BC_FSlider
  86 {
  87 public:
  88         WavePhase(WaveEffect *plugin, int x, int y);
  89         int handle_event();
  90         WaveEffect *plugin;
  91 };
  92
  93 class WaveLength : public BC_FSlider
  94 {
  95 public:
  96         WaveLength(WaveEffect *plugin, int x, int y);
  97         int handle_event();
  98         WaveEffect *plugin;
  99 };
 100
 101
 102
 103
 104
 105
 106
 107
 108
 109 class WaveWindow : public BC_Window
 110 {
 111 public:
 112         WaveWindow(WaveEffect *plugin, int x, int y);
 113         ~WaveWindow();
 114         void create_objects();
 115         int close_event();
 116         void update_mode();
 117         WaveEffect *plugin;
 118 //      WaveSmear *smear;
 119 //      WaveBlacken *blacken;
 120 //      WaveReflective *reflective;
 121         WaveAmplitude *amplitude;
 122         WavePhase *phase;
 123         WaveLength *wavelength;
 124 };
 125
 126
 127 PLUGIN_THREAD_HEADER(WaveEffect, WaveThread, WaveWindow)
 128
 129
 130
 131
 132
 133 class WaveServer : public LoadServer
 134 {
 135 public:
 136         WaveServer(WaveEffect *plugin, int cpus);
 137         void init_packages();
 138         LoadClient* new_client();
 139         LoadPackage* new_package();
 140         WaveEffect *plugin;
 141 };
 142
 143 class WavePackage : public LoadPackage
 144 {
 145 public:
 146         WavePackage();
 147         int row1, row2;
 148 };
 149
 150 class WaveUnit : public LoadClient
 151 {
 152 public:
 153         WaveUnit(WaveEffect *plugin, WaveServer *server);
 154         void process_package(LoadPackage *package);
 155         WaveEffect *plugin;
 156 };
 157
 158
 159
 160
 161
 162
 163
 164
 165
 166 class WaveEffect : public PluginVClient
 167 {
 168 public:
 169         WaveEffect(PluginServer *server);
 170         ~WaveEffect();
 171
 172         int process_realtime(VFrame *input, VFrame *output);
 173         int is_realtime();
 174         char* plugin_title();
 175         VFrame* new_picon();
 176         int load_configuration();
 177         int load_defaults();
 178         int save_defaults();
 179         void save_data(KeyFrame *keyframe);
 180         void read_data(KeyFrame *keyframe);
 181         int show_gui();
 182         int set_string();
 183         void raise_window();
 184         void update_gui();
 185
 186         WaveConfig config;
 187         VFrame *temp_frame;
 188         VFrame *input, *output;
 189         Defaults *defaults;
 190         WaveThread *thread;
 191         WaveServer *engine;
 192 };
 193
 194
 195
 196
 197
 198
 199
 200
 201
 202
 203
 204
 205
 206 WaveConfig::WaveConfig()
 207 {
 208         mode = SMEAR;
 209         reflective = 0;
 210         amplitude = 10;
 211         phase = 0;
 212         wavelength = 10;
 213 }
 214
 215 void WaveConfig::copy_from(WaveConfig &src)
 216 {
 217         this->mode = src.mode;
 218         this->reflective = src.reflective;
 219         this->amplitude = src.amplitude;
 220         this->phase = src.phase;
 221         this->wavelength = src.wavelength;
 222 }
 223
 224 int WaveConfig::equivalent(WaveConfig &src)
 225 {
 226         return
 227                 (this->mode == src.mode) &&
 228                 EQUIV(this->reflective, src.reflective) &&
 229                 EQUIV(this->amplitude, src.amplitude) &&
 230                 EQUIV(this->phase, src.phase) &&
 231                 EQUIV(this->wavelength, src.wavelength);
 232 }
 233
 234 void WaveConfig::interpolate(WaveConfig &prev,
 235                 WaveConfig &next,
 236                 long prev_frame,
 237                 long next_frame,
 238                 long current_frame)
 239 {
 240         double next_scale = (double)(current_frame - prev_frame) / (next_frame - prev_frame);
 241         double prev_scale = (double)(next_frame - current_frame) / (next_frame - prev_frame);
 242
 243         this->amplitude = prev.amplitude * prev_scale + next.amplitude * next_scale;
 244         this->phase = prev.phase * prev_scale + next.phase * next_scale;
 245         this->wavelength = prev.wavelength * prev_scale + next.wavelength * next_scale;
 246         this->mode = prev.mode;
 247         this->reflective = prev.reflective;
 248 }
 249
 250
 251
 252
 253
 254
 255
 256
 257 WaveSmear::WaveSmear(WaveEffect *plugin, WaveWindow *window, int x, int y)
 258  : BC_Radial(x, y, plugin->config.mode == SMEAR, _("Smear"))
 259 {
 260         this->plugin = plugin;
 261         this->window = window;
 262 }
 263 int WaveSmear::handle_event()
 264 {
 265         plugin->config.mode = SMEAR;
 266         window->update_mode();
 267         plugin->send_configure_change();
 268         return 1;
 269 }
 270
 271
 272
 273
 274 WaveBlacken::WaveBlacken(WaveEffect *plugin, WaveWindow *window, int x, int y)
 275  : BC_Radial(x, y, plugin->config.mode == BLACKEN, _("Blacken"))
 276 {
 277         this->plugin = plugin;
 278         this->window = window;
 279 }
 280 int WaveBlacken::handle_event()
 281 {
 282         plugin->config.mode = BLACKEN;
 283         window->update_mode();
 284         plugin->send_configure_change();
 285         return 1;
 286 }
 287
 288
 289
 290
 291
 292
 293 WaveReflective::WaveReflective(WaveEffect *plugin, int x, int y)
 294  : BC_CheckBox(x, y, plugin->config.reflective, _("Reflective"))
 295 {
 296         this->plugin = plugin;
 297 }
 298 int WaveReflective::handle_event()
 299 {
 300         plugin->config.reflective = get_value();
 301         plugin->send_configure_change();
 302         return 1;
 303 }
 304
 305
 306 WaveAmplitude::WaveAmplitude(WaveEffect *plugin, int x, int y)
 307  : BC_FSlider(x,
 308                         y,
 309                         0,
 310                         200,
 311                         200,
 312                         (float)0,
 313                         (float)100,
 314                         plugin->config.amplitude)
 315 {
 316         this->plugin = plugin;
 317 }
 318 int WaveAmplitude::handle_event()
 319 {
 320         plugin->config.amplitude = get_value();
 321         plugin->send_configure_change();
 322         return 1;
 323 }
 324
 325
 326
 327 WavePhase::WavePhase(WaveEffect *plugin, int x, int y)
 328  : BC_FSlider(x,
 329                         y,
 330                         0,
 331                         200,
 332                         200,
 333                         (float)0,
 334                         (float)360,
 335                         plugin->config.phase)
 336 {
 337         this->plugin = plugin;
 338 }
 339 int WavePhase::handle_event()
 340 {
 341         plugin->config.phase = get_value();
 342         plugin->send_configure_change();
 343         return 1;
 344 }
 345
 346 WaveLength::WaveLength(WaveEffect *plugin, int x, int y)
 347  : BC_FSlider(x,
 348                         y,
 349                         0,
 350                         200,
 351                         200,
 352                         (float)0,
 353                         (float)50,
 354                         plugin->config.wavelength)
 355 {
 356         this->plugin = plugin;
 357 }
 358 int WaveLength::handle_event()
 359 {
 360         plugin->config.wavelength = get_value();
 361         plugin->send_configure_change();
 362         return 1;
 363 }
 364
 365
 366
 367
 368
 369
 370
 371
 372
 373 WaveWindow::WaveWindow(WaveEffect *plugin, int x, int y)
 374  : BC_Window(plugin->gui_string,
 375         x,
 376         y,
 377         320,
 378         150,
 379         320,
 380         150,
 381         0,
 382         0,
 383         1)
 384 {
 385         this->plugin = plugin;
 386 }
 387
 388 WaveWindow::~WaveWindow()
 389 {
 390 }
 391
 392 void WaveWindow::create_objects()
 393 {
 394         int x = 10, y = 10, x1 = 100;
 395
 396 //      add_subwindow(new BC_Title(x, y, _("Mode:")));
 397 //      add_subwindow(smear = new WaveSmear(plugin, this, x1, y));
 398 //      y += 20;
 399 //      add_subwindow(blacken = new WaveBlacken(plugin, this, x1, y));
 400 //      y += 30;
 401 //      add_subwindow(reflective = new WaveReflective(plugin, x1, y));
 402 //      y += 30;
 403         add_subwindow(new BC_Title(x, y, _("Amplitude:")));
 404         add_subwindow(amplitude = new WaveAmplitude(plugin, x1, y));
 405         y += 30;
 406         add_subwindow(new BC_Title(x, y, _("Phase:")));
 407         add_subwindow(phase = new WavePhase(plugin, x1, y));
 408         y += 30;
 409         add_subwindow(new BC_Title(x, y, _("Wavelength:")));
 410         add_subwindow(wavelength = new WaveLength(plugin, x1, y));
 411
 412         show_window();
 413         flush();
 414 }
 415
 416 int WaveWindow::close_event()
 417 {
 418         set_done(1);
 419         return 1;
 420 }
 421
 422 void WaveWindow::update_mode()
 423 {
 424 //      smear->update(plugin->config.mode == SMEAR);
 425 //      blacken->update(plugin->config.mode == BLACKEN);
 426 }
 427
 428
 429 PLUGIN_THREAD_OBJECT(WaveEffect, WaveThread, WaveWindow)
 430
 431
 432
 433
 434 REGISTER_PLUGIN(WaveEffect)
 435
 436
 437
 438
 439 WaveEffect::WaveEffect(PluginServer *server)
 440  : PluginVClient(server)
 441 {
 442         temp_frame = 0;
 443         engine = 0;
 444         PLUGIN_CONSTRUCTOR_MACRO
 445 }
 446
 447 WaveEffect::~WaveEffect()
 448 {
 449         PLUGIN_DESTRUCTOR_MACRO
 450
 451         if(temp_frame) delete temp_frame;
 452         if(engine) delete engine;
 453 }
 454
 455
 456 int WaveEffect::is_realtime()
 457 {
 458         return 1;
 459 }
 460
 461 char* WaveEffect::plugin_title()
 462 {
 463         return _("Wave");
 464 }
 465
 466 NEW_PICON_MACRO(WaveEffect)
 467
 468 SHOW_GUI_MACRO(WaveEffect, WaveThread)
 469
 470 RAISE_WINDOW_MACRO(WaveEffect)
 471
 472 SET_STRING_MACRO(WaveEffect)
 473
 474 void WaveEffect::update_gui()
 475 {
 476         if(thread)
 477         {
 478                 thread->window->lock_window();
 479                 load_configuration();
 480                 thread->window->update_mode();
 481 //              thread->window->reflective->update(config.reflective);
 482                 thread->window->amplitude->update(config.amplitude);
 483                 thread->window->phase->update(config.phase);
 484                 thread->window->wavelength->update(config.wavelength);
 485                 thread->window->unlock_window();
 486         }
 487 }
 488
 489
 490 LOAD_CONFIGURATION_MACRO(WaveEffect, WaveConfig)
 491
 492 int WaveEffect::load_defaults()
 493 {
 494         char directory[BCTEXTLEN];
 495 // set the default directory
 496         sprintf(directory, "%swave.rc", BCASTDIR);
 497
 498 // load the defaults
 499         defaults = new Defaults(directory);
 500         defaults->load();
 501
 502         config.mode = defaults->get("MODE", config.mode);
 503         config.reflective = defaults->get("REFLECTIVE", config.reflective);
 504         config.amplitude = defaults->get("AMPLITUDE", config.amplitude);
 505         config.phase = defaults->get("PHASE", config.phase);
 506         config.wavelength = defaults->get("WAVELENGTH", config.wavelength);
 507         return 0;
 508 }
 509
 510 int WaveEffect::save_defaults()
 511 {
 512         defaults->update("MODE", config.mode);
 513         defaults->update("REFLECTIVE", config.reflective);
 514         defaults->update("AMPLITUDE", config.amplitude);
 515         defaults->update("PHASE", config.phase);
 516         defaults->update("WAVELENGTH", config.wavelength);
 517         defaults->save();
 518         return 0;
 519 }
 520
 521 void WaveEffect::save_data(KeyFrame *keyframe)
 522 {
 523         FileXML output;
 524
 525 // cause data to be stored directly in text
 526         output.set_shared_string(keyframe->data, MESSAGESIZE);
 527         output.tag.set_title("WAVE");
 528         output.tag.set_property("MODE", config.mode);
 529         output.tag.set_property("REFLECTIVE", config.reflective);
 530         output.tag.set_property("AMPLITUDE", config.amplitude);
 531         output.tag.set_property("PHASE", config.phase);
 532         output.tag.set_property("WAVELENGTH", config.wavelength);
 533         output.append_tag();
 534         output.terminate_string();
 535 }
 536
 537 void WaveEffect::read_data(KeyFrame *keyframe)
 538 {
 539         FileXML input;
 540
 541         input.set_shared_string(keyframe->data, strlen(keyframe->data));
 542
 543         while(!input.read_tag())
 544         {
 545                 if(input.tag.title_is("WAVE"))
 546                 {
 547                         config.mode = input.tag.get_property("MODE", config.mode);
 548                         config.reflective = input.tag.get_property("REFLECTIVE", config.reflective);
 549                         config.amplitude = input.tag.get_property("AMPLITUDE", config.amplitude);
 550                         config.phase = input.tag.get_property("PHASE", config.phase);
 551                         config.wavelength = input.tag.get_property("WAVELENGTH", config.wavelength);
 552                 }
 553         }
 554 }
 555
 556
 557 int WaveEffect::process_realtime(VFrame *input, VFrame *output)
 558 {
 559         load_configuration();
 560
 561
 562
 563 //printf("WaveEffect::process_realtime %f %d\n", config.radius, config.use_intensity);
 564         this->input = input;
 565         this->output = output;
 566
 567         if(EQUIV(config.amplitude, 0) || EQUIV(config.wavelength, 0))
 568         {
 569                 if(input->get_rows()[0] != output->get_rows()[0])
 570                         output->copy_from(input);
 571         }
 572         else
 573         {
 574                 if(input->get_rows()[0] == output->get_rows()[0])
 575                 {
 576                         if(!temp_frame) temp_frame = new VFrame(0,
 577                                 input->get_w(),
 578                                 input->get_h(),
 579                                 input->get_color_model());
 580                         temp_frame->copy_from(input);
 581                         this->input = temp_frame;
 582                 }
 583
 584
 585                 if(!engine)
 586                 {
 587                         engine = new WaveServer(this, (PluginClient::smp + 1));
 588                 }
 589
 590                 engine->process_packages();
 591         }
 592
 593
 594
 595         return 0;
 596 }
 597
 598
 599
 600
 601
 602
 603 WavePackage::WavePackage()
 604  : LoadPackage()
 605 {
 606 }
 607
 608
 609
 610
 611
 612
 613 WaveUnit::WaveUnit(WaveEffect *plugin, WaveServer *server)
 614  : LoadClient(server)
 615 {
 616         this->plugin = plugin;
 617 }
 618
 619
 620
 621 #define WITHIN(a, b, c) ((((a) <= (b)) && ((b) <= (c))) ? 1 : 0)
 622
 623 static float bilinear(double  x,
 624           double  y,
 625           float  *v)
 626 {
 627         double m0, m1;
 628         x = fmod(x, 1.0);
 629         y = fmod(y, 1.0);
 630
 631         if(x < 0)
 632         x += 1.0;
 633         if(y < 0)
 634         y += 1.0;
 635
 636         m0 = (1.0 - x) * v[0] + x * v[1];
 637         m1 = (1.0 - x) * v[2] + x * v[3];
 638
 639         return((1.0 - y) * m0 + y * m1);
 640 }
 641
 642 void WaveUnit::process_package(LoadPackage *package)
 643 {
 644         WavePackage *pkg = (WavePackage*)package;
 645         int w = plugin->input->get_w();
 646         int h = plugin->input->get_h();
 647         double cen_x, cen_y;       /* Center of wave */
 648         double xhsiz, yhsiz;       /* Half size of selection */
 649         double radius, radius2;    /* Radius and radius^2 */
 650         double amnt, d;
 651         double needx, needy;
 652         double dx, dy;
 653         double xscale, yscale;
 654         double wavelength;
 655         int xi, yi;
 656         float values[4];
 657         float val;
 658         int x1, y1, x2, y2;
 659         int x1_in, y1_in, x2_in, y2_in;
 660         double phase = plugin->config.phase * M_PI / 180;
 661
 662
 663         x1 = y1 = 0;
 664         x2 = w;
 665         y2 = h;
 666         cen_x = (double) (x2 - 1 + x1) / 2.0;
 667         cen_y = (double) (y2 - 1 + y1) / 2.0;
 668         xhsiz = (double) (x2 - x1) / 2.0;
 669         yhsiz = (double) (y2 - y1) / 2.0;
 670
 671         if (xhsiz < yhsiz)
 672     {
 673         xscale = yhsiz / xhsiz;
 674         yscale = 1.0;
 675     }
 676         else if (xhsiz > yhsiz)
 677     {
 678         xscale = 1.0;
 679         yscale = xhsiz / yhsiz;
 680     }
 681         else
 682     {
 683         xscale = 1.0;
 684         yscale = 1.0;
 685     }
 686
 687         radius  = MAX(xhsiz, yhsiz);
 688         radius2 = radius * radius;
 689
 690
 691         wavelength = plugin->config.wavelength / 100 * radius;
 692
 693
 694
 695
 696 #define WAVE(type, components, chroma_offset) \
 697 { \
 698         int row_size = w * components; \
 699         type **in_rows = (type**)plugin->input->get_rows(); \
 700         for(int y = pkg->row1; y < pkg->row2; y++) \
 701         { \
 702                 type *dest = (type*)plugin->output->get_rows()[y]; \
 703  \
 704                 for(int x = x1; x < x2; x++) \
 705                 { \
 706                         dx = (x - cen_x) * xscale; \
 707                         dy = (y - cen_y) * yscale; \
 708                     d = sqrt(dx * dx + dy * dy); \
 709  \
 710                         if(plugin->config.reflective) \
 711                         { \
 712                         amnt = plugin->config.amplitude *  \
 713                                         fabs(sin(((d / wavelength) *  \
 714                                                 (2.0 * M_PI) + \
 715                                                 phase))); \
 716  \
 717                         needx = (amnt * dx) / xscale + cen_x; \
 718                         needy = (amnt * dy) / yscale + cen_y; \
 719                         } \
 720                         else \
 721                         { \
 722                         amnt = plugin->config.amplitude *  \
 723                                         sin(((d / wavelength) *  \
 724                                                 (2.0 * M_PI) + \
 725                                         phase)); \
 726  \
 727                         needx = (amnt + dx) / xscale + cen_x; \
 728                         needy = (amnt + dy) / yscale + cen_y; \
 729                         } \
 730  \
 731                         xi = (int)needx; \
 732                         yi = (int)needy; \
 733  \
 734                         if(plugin->config.mode == SMEAR) \
 735                 { \
 736                         if(xi > w - 2) \
 737                                 { \
 738                                         xi = w - 2; \
 739                                 } \
 740                         else  \
 741                                 if(xi < 0) \
 742                                 { \
 743                                         xi = 0; \
 744                                 } \
 745  \
 746                         if(yi > h - 2) \
 747                                 { \
 748                                         yi = h - 2; \
 749                                 } \
 750                         else  \
 751                                 if(yi < 0) \
 752                                 { \
 753                                         yi = 0; \
 754                                 } \
 755                 } \
 756  \
 757                         type *p = in_rows[CLIP(yi, 0, h - 1)] + \
 758                                 CLIP(xi, 0, w - 1) * components; \
 759                         x1_in = WITHIN(0, xi, w - 1); \
 760                         y1_in = WITHIN(0, yi, h - 1); \
 761                         x2_in = WITHIN(0, xi + 1, w - 1); \
 762                         y2_in = WITHIN(0, yi + 1, h - 1); \
 763  \
 764  \
 765                         for(int k = 0; k < components; k++) \
 766                 { \
 767                         if (x1_in && y1_in) \
 768                                         values[0] = *(p + k); \
 769                         else \
 770                                         values[0] = ((k == 1 || k == 2) ? 0 : chroma_offset); \
 771  \
 772                         if (x2_in && y1_in) \
 773                                         values[1] = *(p + components + k); \
 774                         else \
 775                                         values[1] = ((k == 1 || k == 2) ? 0 : chroma_offset); \
 776  \
 777                         if (x1_in && y2_in) \
 778                                         values[2] = *(p + row_size + k); \
 779                         else \
 780                                         values[2] = ((k == 1 || k == 2) ? 0 : chroma_offset); \
 781  \
 782                         if (x2_in) \
 783                                 { \
 784                                         if (y2_in) \
 785                                         values[3] = *(p + row_size + components + k); \
 786                                         else \
 787                                         values[3] = ((k == 1 || k == 2) ? 0 : chroma_offset); \
 788                                 } \
 789                         else \
 790                                         values[3] = ((k == 1 || k == 2) ? 0 : chroma_offset); \
 791  \
 792                         val = bilinear(needx, needy, values); \
 793  \
 794                         *dest++ = (type)val; \
 795                 } \
 796                 } \
 797         } \
 798 }
 799
 800
 801
 802
 803         switch(plugin->input->get_color_model())
 804         {
 805                 case BC_RGB888:
 806                         WAVE(unsigned char, 3, 0x0);
 807                         break;
 808                 case BC_YUV888:
 809                         WAVE(unsigned char, 3, 0x80);
 810                         break;
 811                 case BC_RGB161616:
 812                         WAVE(uint16_t, 3, 0x0);
 813                         break;
 814                 case BC_YUV161616:
 815                         WAVE(uint16_t, 3, 0x8000);
 816                         break;
 817                 case BC_RGBA8888:
 818                         WAVE(unsigned char, 4, 0x0);
 819                         break;
 820                 case BC_YUVA8888:
 821                         WAVE(unsigned char, 4, 0x8000);
 822                         break;
 823                 case BC_RGBA16161616:
 824                         WAVE(uint16_t, 4, 0x0);
 825                         break;
 826                 case BC_YUVA16161616:
 827                         WAVE(uint16_t, 4, 0x8000);
 828                         break;
 829         }
 830
 831
 832
 833
 834 }
 835
 836
 837
 838
 839
 840
 841 WaveServer::WaveServer(WaveEffect *plugin, int cpus)
 842  : LoadServer(cpus, cpus)
 843 {
 844         this->plugin = plugin;
 845 }
 846
 847 void WaveServer::init_packages()
 848 {
 849         int increment = plugin->input->get_h() / LoadServer::total_packages + 1;
 850         int y = 0;
 851         for(int i = 0; i < LoadServer::total_packages; i++)
 852         {
 853                 WavePackage *pkg = (WavePackage*)packages[i];
 854                 pkg->row1 = y;
 855                 pkg->row2 = y + increment;
 856                 y += increment;
 857                 if(pkg->row2 > plugin->input->get_h())
 858                 {
 859                         y = pkg->row2 = plugin->input->get_h();
 860                 }
 861                 if(pkg->row1 > plugin->input->get_h())
 862                 {
 863                         y = pkg->row2 = plugin->input->get_h();
 864                 }
 865         }
 866 }
 867
 868
 869 LoadClient* WaveServer::new_client()
 870 {
 871         return new WaveUnit(plugin, this);
 872 }
 873
 874 LoadPackage* WaveServer::new_package()
 875 {
 876         return new WavePackage;
 877 }
 878