cinelerra-5.1/plugins/whirl/whirl.C

   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 #include "bcdisplayinfo.h"
  23 #include "clip.h"
  24 #include "bchash.h"
  25 #include "filexml.h"
  26 #include "guicast.h"
  27 #include "keyframe.h"
  28 #include "language.h"
  29 #include "loadbalance.h"
  30 #include "pluginvclient.h"
  31 #include "vframe.h"
  32
  33
  34
  35 #include <stdint.h>
  36 #include <string.h>
  37
  38 class WhirlEffect;
  39 class WhirlWindow;
  40 class WhirlEngine;
  41
  42 #define MAXRADIUS 100
  43 #define MAXPINCH 100
  44
  45
  46
  47
  48
  49
  50 class WhirlConfig
  51 {
  52 public:
  53         WhirlConfig();
  54
  55         void copy_from(WhirlConfig &src);
  56         int equivalent(WhirlConfig &src);
  57         void interpolate(WhirlConfig &prev,
  58                 WhirlConfig &next,
  59                 long prev_frame,
  60                 long next_frame,
  61                 long current_frame);
  62
  63         float angle;
  64         float pinch;
  65         float radius;
  66 };
  67
  68
  69 class WhirlAngle : public BC_FSlider
  70 {
  71 public:
  72         WhirlAngle(WhirlEffect *plugin, int x, int y);
  73         int handle_event();
  74         WhirlEffect *plugin;
  75 };
  76
  77
  78
  79 class WhirlPinch : public BC_FSlider
  80 {
  81 public:
  82         WhirlPinch(WhirlEffect *plugin, int x, int y);
  83         int handle_event();
  84         WhirlEffect *plugin;
  85 };
  86
  87
  88
  89 class WhirlRadius : public BC_FSlider
  90 {
  91 public:
  92         WhirlRadius(WhirlEffect *plugin, int x, int y);
  93         int handle_event();
  94         WhirlEffect *plugin;
  95 };
  96
  97 class WhirlWindow : public PluginClientWindow
  98 {
  99 public:
 100         WhirlWindow(WhirlEffect *plugin);
 101         void create_objects();
 102         WhirlEffect *plugin;
 103         WhirlRadius *radius;
 104         WhirlPinch *pinch;
 105         WhirlAngle *angle;
 106 };
 107
 108
 109
 110
 111
 112 class WhirlPackage : public LoadPackage
 113 {
 114 public:
 115         WhirlPackage();
 116         int row1, row2;
 117 };
 118
 119 class WhirlUnit : public LoadClient
 120 {
 121 public:
 122         WhirlUnit(WhirlEffect *plugin, WhirlEngine *server);
 123         void process_package(LoadPackage *package);
 124         WhirlEngine *server;
 125         WhirlEffect *plugin;
 126
 127 };
 128
 129
 130 class WhirlEngine : public LoadServer
 131 {
 132 public:
 133         WhirlEngine(WhirlEffect *plugin, int cpus);
 134         void init_packages();
 135         LoadClient* new_client();
 136         LoadPackage* new_package();
 137         WhirlEffect *plugin;
 138 };
 139
 140
 141
 142 class WhirlEffect : public PluginVClient
 143 {
 144 public:
 145         WhirlEffect(PluginServer *server);
 146         ~WhirlEffect();
 147
 148         PLUGIN_CLASS_MEMBERS(WhirlConfig)
 149         int process_realtime(VFrame *input, VFrame *output);
 150         int is_realtime();
 151         void update_gui();
 152         void save_data(KeyFrame *keyframe);
 153         void read_data(KeyFrame *keyframe);
 154
 155         WhirlEngine *engine;
 156         VFrame *temp_frame;
 157         VFrame *input, *output;
 158         int need_reconfigure;
 159 };
 160
 161
 162
 163
 164
 165
 166 REGISTER_PLUGIN(WhirlEffect)
 167
 168
 169
 170
 171
 172
 173
 174
 175
 176
 177
 178
 179
 180
 181
 182
 183 WhirlConfig::WhirlConfig()
 184 {
 185         angle = 0.0;
 186         pinch = 0.0;
 187         radius = 0.0;
 188 }
 189
 190 void WhirlConfig::copy_from(WhirlConfig &src)
 191 {
 192         this->angle = src.angle;
 193         this->pinch = src.pinch;
 194         this->radius = src.radius;
 195 }
 196
 197 int WhirlConfig::equivalent(WhirlConfig &src)
 198 {
 199         return EQUIV(this->angle, src.angle) &&
 200                 EQUIV(this->pinch, src.pinch) &&
 201                 EQUIV(this->radius, src.radius);
 202 }
 203
 204 void WhirlConfig::interpolate(WhirlConfig &prev,
 205         WhirlConfig &next,
 206         long prev_frame,
 207         long next_frame,
 208         long current_frame)
 209 {
 210         double next_scale = (double)(current_frame - prev_frame) / (next_frame - prev_frame);
 211         double prev_scale = (double)(next_frame - current_frame) / (next_frame - prev_frame);
 212
 213         this->angle = prev.angle * prev_scale + next.angle * next_scale;
 214         this->pinch = prev.pinch * prev_scale + next.pinch * next_scale;
 215         this->radius = prev.radius * prev_scale + next.radius * next_scale;
 216 }
 217
 218
 219
 220
 221
 222
 223
 224
 225
 226
 227 WhirlWindow::WhirlWindow(WhirlEffect *plugin)
 228  : PluginClientWindow(plugin,
 229         220,
 230         200,
 231         220,
 232         200,
 233         0)
 234 {
 235         this->plugin = plugin;
 236 }
 237
 238
 239
 240 void WhirlWindow::create_objects()
 241 {
 242         int x = 10, y = 10;
 243         add_subwindow(new BC_Title(x, y, _("Radius")));
 244         y += 20;
 245         add_subwindow(radius = new WhirlRadius(plugin, x, y));
 246         y += 40;
 247         add_subwindow(new BC_Title(x, y, _("Pinch")));
 248         y += 20;
 249         add_subwindow(pinch = new WhirlPinch(plugin, x, y));
 250         y += 40;
 251         add_subwindow(new BC_Title(x, y, _("Angle")));
 252         y += 20;
 253         add_subwindow(angle = new WhirlAngle(plugin, x, y));
 254
 255         show_window();
 256         flush();
 257 }
 258
 259
 260
 261
 262
 263
 264
 265
 266
 267
 268
 269
 270
 271
 272 WhirlAngle::WhirlAngle(WhirlEffect *plugin, int x, int y)
 273  : BC_FSlider(x,
 274                 y,
 275                 0,
 276                 200,
 277                 200,
 278                 (float)0,
 279                 (float)360,
 280                 plugin->config.angle)
 281 {
 282         this->plugin = plugin;
 283 }
 284 int WhirlAngle::handle_event()
 285 {
 286         plugin->config.angle = get_value();
 287         plugin->send_configure_change();
 288         return 1;
 289 }
 290
 291
 292
 293
 294 WhirlPinch::WhirlPinch(WhirlEffect *plugin, int x, int y)
 295  : BC_FSlider(x,
 296                 y,
 297                 0,
 298                 200,
 299                 200,
 300                 (float)0,
 301                 (float)MAXPINCH,
 302                 plugin->config.pinch)
 303 {
 304         this->plugin = plugin;
 305 }
 306 int WhirlPinch::handle_event()
 307 {
 308         plugin->config.pinch = get_value();
 309         plugin->send_configure_change();
 310         return 1;
 311 }
 312
 313
 314
 315
 316 WhirlRadius::WhirlRadius(WhirlEffect *plugin, int x, int y)
 317  : BC_FSlider(x,
 318                 y,
 319                 0,
 320                 200,
 321                 200,
 322                 (float)0,
 323                 (float)MAXRADIUS,
 324                 plugin->config.radius)
 325 {
 326         this->plugin = plugin;
 327 }
 328 int WhirlRadius::handle_event()
 329 {
 330         plugin->config.radius = get_value();
 331         plugin->send_configure_change();
 332         return 1;
 333 }
 334
 335
 336
 337
 338
 339
 340
 341
 342
 343
 344
 345 WhirlEffect::WhirlEffect(PluginServer *server)
 346  : PluginVClient(server)
 347 {
 348         need_reconfigure = 1;
 349         engine = 0;
 350         temp_frame = 0;
 351
 352 }
 353
 354 WhirlEffect::~WhirlEffect()
 355 {
 356
 357         if(engine) delete engine;
 358         if(temp_frame) delete temp_frame;
 359 }
 360
 361
 362
 363
 364
 365
 366 const char* WhirlEffect::plugin_title() { return N_("Whirl"); }
 367 int WhirlEffect::is_realtime() { return 1; }
 368
 369
 370
 371 NEW_WINDOW_MACRO(WhirlEffect, WhirlWindow)
 372
 373
 374 void WhirlEffect::update_gui()
 375 {
 376         if(thread)
 377         {
 378                 load_configuration();
 379                 thread->window->lock_window();
 380                 ((WhirlWindow*)thread->window)->angle->update(config.angle);
 381                 ((WhirlWindow*)thread->window)->pinch->update(config.pinch);
 382                 ((WhirlWindow*)thread->window)->radius->update(config.radius);
 383                 thread->window->unlock_window();
 384         }
 385 }
 386
 387 LOAD_CONFIGURATION_MACRO(WhirlEffect, WhirlConfig)
 388
 389
 390
 391
 392 void WhirlEffect::save_data(KeyFrame *keyframe)
 393 {
 394         FileXML output;
 395
 396 // cause data to be stored directly in text
 397         output.set_shared_output(keyframe->xbuf);
 398
 399         output.tag.set_title("WHIRL");
 400         output.tag.set_property("ANGLE", config.angle);
 401         output.tag.set_property("PINCH", config.pinch);
 402         output.tag.set_property("RADIUS", config.radius);
 403         output.append_tag();
 404         output.tag.set_title("/WHIRL");
 405         output.append_tag();
 406         output.append_newline();
 407         output.terminate_string();
 408 // data is now in *text
 409 }
 410
 411 void WhirlEffect::read_data(KeyFrame *keyframe)
 412 {
 413         FileXML input;
 414
 415         input.set_shared_input(keyframe->xbuf);
 416
 417         int result = 0;
 418
 419         while(!result)
 420         {
 421                 result = input.read_tag();
 422
 423                 if(!result)
 424                 {
 425                         if(input.tag.title_is("WHIRL"))
 426                         {
 427                                 config.angle = input.tag.get_property("ANGLE", config.angle);
 428                                 config.pinch = input.tag.get_property("PINCH", config.pinch);
 429                                 config.radius = input.tag.get_property("RADIUS", config.radius);
 430                         }
 431                 }
 432         }
 433 }
 434
 435 int WhirlEffect::process_realtime(VFrame *input, VFrame *output)
 436 {
 437         need_reconfigure |= load_configuration();
 438         this->input = input;
 439         this->output = output;
 440
 441         if(EQUIV(config.angle, 0) ||
 442                 (EQUIV(config.radius, 0) && EQUIV(config.pinch, 0)))
 443         {
 444                 if(input->get_rows()[0] != output->get_rows()[0])
 445                         output->copy_from(input);
 446         }
 447         else
 448         {
 449                 if(input->get_rows()[0] == output->get_rows()[0])
 450                 {
 451                         if(!temp_frame) temp_frame = new VFrame(input->get_w(), input->get_h(),
 452                                 input->get_color_model(), 0);
 453                         temp_frame->copy_from(input);
 454                         this->input = temp_frame;
 455                 }
 456
 457                 if(!engine) engine = new WhirlEngine(this, PluginClient::smp + 1);
 458
 459                 engine->process_packages();
 460         }
 461         return 0;
 462 }
 463
 464
 465
 466
 467
 468
 469
 470
 471 WhirlPackage::WhirlPackage()
 472  : LoadPackage()
 473 {
 474 }
 475
 476
 477
 478 WhirlUnit::WhirlUnit(WhirlEffect *plugin, WhirlEngine *server)
 479  : LoadClient(server)
 480 {
 481         this->plugin = plugin;
 482 }
 483
 484
 485
 486 static int calc_undistorted_coords(double cen_x,
 487                         double cen_y,
 488                         double scale_x,
 489                         double scale_y,
 490                         double radius,
 491                         double radius2,
 492                         double radius3,
 493                         double pinch,
 494                         double wx,
 495                         double wy,
 496                         double &whirl,
 497                         double &x,
 498                         double &y)
 499 {
 500         double dx, dy;
 501         double d, factor;
 502         double dist;
 503         double ang, sina, cosa;
 504         int inside;
 505
 506 /* Distances to center, scaled */
 507
 508         dx = (wx - cen_x) * scale_x;
 509         dy = (wy - cen_y) * scale_y;
 510
 511 /* Distance^2 to center of *circle* (scaled ellipse) */
 512
 513         d = dx * dx + dy * dy;
 514
 515 /*  If we are inside circle, then distort.
 516  *  Else, just return the same position
 517  */
 518
 519         inside = (d < radius2);
 520
 521         if(inside)
 522     {
 523         dist = sqrt(d / radius3) / radius;
 524
 525 /* Pinch */
 526
 527         factor = pow(sin(M_PI / 2 * dist), -pinch);
 528
 529         dx *= factor;
 530         dy *= factor;
 531
 532 /* Whirl */
 533
 534         factor = 1.0 - dist;
 535
 536         ang = whirl * factor * factor;
 537
 538         sina = sin(ang);
 539         cosa = cos(ang);
 540
 541         x = (cosa * dx - sina * dy) / scale_x + cen_x;
 542         y = (sina * dx + cosa * dy) / scale_y + cen_y;
 543     }
 544
 545         return inside;
 546 }
 547
 548
 549
 550 #define GET_PIXEL(components, x, y, input_rows) \
 551         input_rows[CLIP(y, 0, (h - 1))] + components * CLIP(x, 0, (w - 1))
 552
 553
 554
 555
 556
 557
 558 static float bilinear(double x, double y, double *values)
 559 {
 560         double m0, m1;
 561         x = fmod(x, 1.0);
 562         y = fmod(y, 1.0);
 563
 564         if(x < 0.0) x += 1.0;
 565         if(y < 0.0) y += 1.0;
 566
 567         m0 = (double)values[0] + x * ((double)values[1] - values[0]);
 568         m1 = (double)values[2] + x * ((double)values[3] - values[2]);
 569         return m0 + y * (m1 - m0);
 570 }
 571
 572
 573
 574
 575
 576 #define WHIRL_MACRO(type, max, components) \
 577 { \
 578         type **input_rows = (type**)plugin->input->get_rows(); \
 579 /* Compiler error requires separate arrays */ \
 580         double top_values[4], bot_values[4]; \
 581         for( int i=0; i<4; ++i ) top_values[i] = bot_values[i] = 0; \
 582         for(int row = pkg->row1 / 2; row <= (pkg->row2 + pkg->row1) / 2; row++) \
 583         { \
 584                 type *top_row = (type*)plugin->output->get_rows()[row]; \
 585                 type *bot_row = (type*)plugin->output->get_rows()[h - row - 1]; \
 586                 type *top_p = top_row; \
 587                 type *bot_p = bot_row + components * w - components; \
 588                 type *pixel1; \
 589                 type *pixel2; \
 590                 type *pixel3; \
 591                 type *pixel4; \
 592  \
 593                 for(int col = 0; col < w; col++) \
 594                 { \
 595                         if(calc_undistorted_coords(cen_x, \
 596                                 cen_y, \
 597                                 scale_x, \
 598                                 scale_y, \
 599                                 radius, \
 600                                 radius2, \
 601                                 radius3, \
 602                                 pinch, \
 603                                 col, \
 604                                 row, \
 605                                 whirl, \
 606                                 cx, \
 607                                 cy)) \
 608                         { \
 609 /* Inside distortion area */ \
 610 /* Do top */ \
 611                                 if(cx >= 0.0) \
 612                                         ix = (int)cx; \
 613                                 else \
 614                                         ix = -((int)-cx + 1); \
 615  \
 616                                 if(cy >= 0.0) \
 617                                         iy = (int)cy; \
 618                                 else \
 619                                         iy = -((int)-cy + 1); \
 620  \
 621                                 pixel1 = GET_PIXEL(components, ix,     iy,     input_rows); \
 622                                 pixel2 = GET_PIXEL(components, ix + 1, iy,     input_rows); \
 623                                 pixel3 = GET_PIXEL(components, ix,     iy + 1, input_rows); \
 624                                 pixel4 = GET_PIXEL(components, ix + 1, iy + 1, input_rows); \
 625  \
 626                                 top_values[0] = pixel1[0]; \
 627                                 top_values[1] = pixel2[0]; \
 628                                 top_values[2] = pixel3[0]; \
 629                                 top_values[3] = pixel4[0]; \
 630                                 top_p[0] = (type)bilinear(cx, cy, top_values); \
 631  \
 632                                 top_values[0] = pixel1[1]; \
 633                                 top_values[1] = pixel2[1]; \
 634                                 top_values[2] = pixel3[1]; \
 635                                 top_values[3] = pixel4[1]; \
 636                                 top_p[1] = (type)bilinear(cx, cy, top_values); \
 637  \
 638                                 top_values[0] = pixel1[2]; \
 639                                 top_values[1] = pixel2[2]; \
 640                                 top_values[2] = pixel3[2]; \
 641                                 top_values[3] = pixel4[2]; \
 642                                 top_p[2] = (type)bilinear(cx, cy, top_values); \
 643  \
 644                                 if(components == 4) \
 645                                 { \
 646                                         top_values[0] = pixel1[3]; \
 647                                         top_values[1] = pixel2[3]; \
 648                                         top_values[2] = pixel3[3]; \
 649                                         top_values[3] = pixel4[3]; \
 650                                         top_p[3] = (type)bilinear(cx, cy, top_values); \
 651                                 } \
 652  \
 653                                 top_p += components; \
 654  \
 655 /* Do bottom */ \
 656                         cx = cen_x + (cen_x - cx); \
 657                         cy = cen_y + (cen_y - cy); \
 658  \
 659                         if(cx >= 0.0) \
 660                                         ix = (int)cx; \
 661                         else \
 662                                         ix = -((int)-cx + 1); \
 663  \
 664                         if(cy >= 0.0) \
 665                                         iy = (int)cy; \
 666                         else \
 667                                         iy = -((int)-cy + 1); \
 668  \
 669                                 pixel1 = GET_PIXEL(components, ix,     iy,     input_rows); \
 670                                 pixel2 = GET_PIXEL(components, ix + 1, iy,     input_rows); \
 671                                 pixel3 = GET_PIXEL(components, ix,     iy + 1, input_rows); \
 672                                 pixel4 = GET_PIXEL(components, ix + 1, iy + 1, input_rows); \
 673  \
 674  \
 675  \
 676                                 bot_values[0] = pixel1[0]; \
 677                                 bot_values[1] = pixel2[0]; \
 678                                 bot_values[2] = pixel3[0]; \
 679                                 bot_values[3] = pixel4[0]; \
 680                                 bot_p[0] = (type)bilinear(cx, cy, bot_values); \
 681  \
 682                                 bot_values[0] = pixel1[1]; \
 683                                 bot_values[1] = pixel2[1]; \
 684                                 bot_values[2] = pixel3[1]; \
 685                                 bot_values[3] = pixel4[1]; \
 686                                 bot_p[1] = (type)bilinear(cx, cy, bot_values); \
 687  \
 688                                 bot_values[0] = pixel1[2]; \
 689                                 bot_values[1] = pixel2[2]; \
 690                                 bot_values[2] = pixel3[2]; \
 691                                 bot_values[3] = pixel4[2]; \
 692                                 bot_p[2] = (type)bilinear(cx, cy, bot_values); \
 693  \
 694                                 if(components == 4) \
 695                                 { \
 696                                         bot_values[0] = pixel1[3]; \
 697                                         bot_values[1] = pixel2[3]; \
 698                                         bot_values[2] = pixel3[3]; \
 699                                         bot_values[3] = pixel4[3]; \
 700                                         bot_p[3] = (type)bilinear(cx, cy, bot_values); \
 701                                 } \
 702  \
 703                                 bot_p -= components; \
 704  \
 705  \
 706                         } \
 707                         else \
 708                         { \
 709 /* Outside distortion area */ \
 710 /* Do top */ \
 711                                 top_p[0] = input_rows[row][components * col + 0]; \
 712                                 top_p[1] = input_rows[row][components * col + 1]; \
 713                                 top_p[2] = input_rows[row][components * col + 2]; \
 714                                 if(components == 4) top_p[3] = input_rows[row][components * col + 3]; \
 715  \
 716  \
 717                                 top_p += components; \
 718  \
 719 /* Do bottom */ \
 720                                 int bot_offset = w * components - col * components - components; \
 721                                 int bot_row = h - 1 - row; \
 722                                 bot_p[0] = input_rows[bot_row][bot_offset + 0]; \
 723                                 bot_p[1] = input_rows[bot_row][bot_offset + 1]; \
 724                                 bot_p[2] = input_rows[bot_row][bot_offset + 2]; \
 725                                 if(components == 4) bot_p[3] = input_rows[bot_row][bot_offset + 3]; \
 726                                 bot_p -= components; \
 727                         } \
 728                 } \
 729         } \
 730 }
 731
 732 void WhirlUnit::process_package(LoadPackage *package)
 733 {
 734         WhirlPackage *pkg = (WhirlPackage*)package;
 735         int w = plugin->input->get_w();
 736         int h = plugin->input->get_h();
 737         double whirl = plugin->config.angle * M_PI / 180;
 738         double pinch = plugin->config.pinch / MAXPINCH;
 739         double cx, cy;
 740     int ix, iy;
 741         double cen_x = (double)(w - 1) / 2.0;
 742         double cen_y = (double)(h - 1) / 2.0;
 743         double radius = MAX(w, h);
 744         double radius3 = plugin->config.radius / MAXRADIUS;
 745         double radius2 = radius * radius * radius3;
 746         double scale_x;
 747         double scale_y;
 748
 749
 750 //printf("WhirlUnit::process_package 1 %f %f %f\n",
 751 //      plugin->config.angle, plugin->config.pinch, plugin->config.radius);
 752         if(w < h)
 753         {
 754         scale_x = (double)h / w;
 755         scale_y = 1.0;
 756         }
 757         else
 758         if(w > h)
 759         {
 760         scale_x = 1.0;
 761         scale_y = (double)w / h;
 762         }
 763         else
 764         {
 765         scale_x = 1.0;
 766         scale_y = 1.0;
 767         }
 768
 769
 770
 771         switch(plugin->input->get_color_model())
 772         {
 773                 case BC_RGB_FLOAT:
 774                         WHIRL_MACRO(float, 1, 3);
 775                         break;
 776                 case BC_RGB888:
 777                 case BC_YUV888:
 778                         WHIRL_MACRO(unsigned char, 0xff, 3);
 779                         break;
 780                 case BC_RGBA_FLOAT:
 781                         WHIRL_MACRO(float, 1, 4);
 782                         break;
 783                 case BC_RGBA8888:
 784                 case BC_YUVA8888:
 785                         WHIRL_MACRO(unsigned char, 0xff, 4);
 786                         break;
 787                 case BC_RGB161616:
 788                 case BC_YUV161616:
 789                         WHIRL_MACRO(uint16_t, 0xffff, 3);
 790                         break;
 791                 case BC_RGBA16161616:
 792                 case BC_YUVA16161616:
 793                         WHIRL_MACRO(uint16_t, 0xffff, 4);
 794                         break;
 795
 796         }
 797 }
 798
 799
 800
 801
 802
 803
 804
 805 WhirlEngine::WhirlEngine(WhirlEffect *plugin, int cpus)
 806 // : LoadServer(1, 1)
 807  : LoadServer(cpus, cpus)
 808 {
 809         this->plugin = plugin;
 810 }
 811 void WhirlEngine::init_packages()
 812 {
 813         for(int i = 0; i < LoadServer::get_total_packages(); i++)
 814         {
 815                 WhirlPackage *pkg = (WhirlPackage*)get_package(i);
 816                 pkg->row1 = plugin->input->get_h() * i / LoadServer::get_total_packages();
 817                 pkg->row2 = plugin->input->get_h() * (i + 1) / LoadServer::get_total_packages();
 818         }
 819
 820 }
 821
 822 LoadClient* WhirlEngine::new_client()
 823 {
 824         return new WhirlUnit(plugin, this);
 825 }
 826
 827 LoadPackage* WhirlEngine::new_package()
 828 {
 829         return new WhirlPackage;
 830 }
 831