hvirtual/plugins/blurzoom/blurzoom.C

   1 #include "clip.h"
   2 #include "colormodels.h"
   3 #include "filexml.h"
   4 #include "picon_png.h"
   5 #include "blurzoom.h"
   6 #include "blurzoomwindow.h"
   7
   8 #include <stdint.h>
   9 #include <stdio.h>
  10 #include <string.h>
  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 PluginClient* new_plugin(PluginServer *server)
  18 {
  19         return new BlurZoomMain(server);
  20 }
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33 BlurZoomConfig::BlurZoomConfig()
  34 {
  35 }
  36
  37 BlurZoomMain::BlurZoomMain(PluginServer *server)
  38  : PluginVClient(server)
  39 {
  40         thread = 0;
  41         defaults = 0;
  42         load_defaults();
  43 }
  44
  45 BlurZoomMain::~BlurZoomMain()
  46 {
  47         if(thread)
  48         {
  49 // Set result to 0 to indicate a server side close
  50                 thread->window->set_done(0);
  51                 thread->completion.lock();
  52                 delete thread;
  53         }
  54
  55         save_defaults();
  56         if(defaults) delete defaults;
  57 }
  58
  59 char* BlurZoomMain::plugin_title() { return N_("RadioacTV"); }
  60 int BlurZoomMain::is_realtime() { return 1; }
  61
  62 VFrame* BlurZoomMain::new_picon()
  63 {
  64         return new VFrame(picon_png);
  65 }
  66
  67 int BlurZoomMain::load_defaults()
  68 {
  69         return 0;
  70 }
  71
  72 int BlurZoomMain::save_defaults()
  73 {
  74         return 0;
  75 }
  76
  77 void BlurZoomMain::load_configuration()
  78 {
  79 }
  80
  81
  82 void BlurZoomMain::save_data(KeyFrame *keyframe)
  83 {
  84 }
  85
  86 void BlurZoomMain::read_data(KeyFrame *keyframe)
  87 {
  88 }
  89
  90
  91 #define VIDEO_HWIDTH (buf_width/2)
  92 #define VIDEO_HHEIGHT (buf_height/2)
  93
  94
  95 #define MAGIC_THRESHOLD 40
  96 #define RATIO 0.95
  97
  98 void BlurZoomMain::image_set_threshold_y(int threshold)
  99 {
 100         y_threshold = threshold * 7; /* fake-Y value is timed by 7 */
 101 }
 102
 103
 104 void BlurZoomMain::set_table()
 105 {
 106         int bits, x, y, tx, ty, xx;
 107         int ptr, prevptr;
 108
 109         prevptr = (int)(0.5 + RATIO * (-VIDEO_HWIDTH) + VIDEO_HWIDTH);
 110
 111         for(xx = 0; xx < (buf_width_blocks); xx++)
 112         {
 113                 bits = 0;
 114                 for(x = 0; x < 32; x++)
 115                 {
 116                         ptr = (int)(0.5 + RATIO * (xx * 32 + x - VIDEO_HWIDTH) + VIDEO_HWIDTH);
 117                         bits = bits << 1;
 118                         if(ptr != prevptr)
 119                                 bits |= 1;
 120                         prevptr = ptr;
 121                 }
 122                 blurzoomx[xx] = bits;
 123         }
 124
 125         ty = (int)(0.5 + RATIO * (-VIDEO_HHEIGHT) + VIDEO_HHEIGHT);
 126         tx = (int)(0.5 + RATIO*  (-VIDEO_HWIDTH) + VIDEO_HWIDTH);
 127         xx = (int)(0.5 + RATIO *( buf_width - 1 - VIDEO_HWIDTH) + VIDEO_HWIDTH);
 128         blurzoomy[0] = ty * buf_width + tx;
 129         prevptr = ty * buf_width + xx;
 130
 131         for(y = 1; y < buf_height; y++)
 132         {
 133                 ty = (int)(0.5 + RATIO * (y - VIDEO_HHEIGHT) + VIDEO_HHEIGHT);
 134                 blurzoomy[y] = ty * buf_width + tx - prevptr;
 135                 prevptr = ty * buf_width + xx;
 136         }
 137 }
 138
 139 void BlurZoomMain::make_palette()
 140 {
 141         int i;
 142
 143 #define DELTA (255 / (COLORS / 2 - 1))
 144
 145         for(i = 0; i < COLORS / 2; i++)
 146         {
 147                 palette_r[i] = i * DELTA;
 148                 palette_g[i] = i * DELTA;
 149                 palette_b[i] = i * DELTA;
 150         }
 151
 152         for(i = 0; i < COLORS / 2; i++)
 153         {
 154                 palette_r[i + COLORS / 2] = (i * DELTA);
 155                 palette_g[i + COLORS / 2] = (i * DELTA);
 156                 palette_b[i + COLORS / 2] = 255;
 157         }
 158 }
 159
 160
 161
 162
 163
 164
 165
 166
 167
 168
 169
 170
 171
 172
 173
 174
 175
 176
 177
 178 int BlurZoomMain::start_realtime()
 179 {
 180         buf_width_blocks = project_frame_w / 32;
 181         buf_width = buf_width_blocks * 32;
 182         buf_height = project_frame_h;
 183         buf_area = buf_width * buf_height;
 184         buf_margin_left = (project_frame_w - buf_width) / 2;
 185         buf_margin_right = project_frame_w - buf_width - buf_margin_left;
 186         blurzoombuf = new unsigned char[buf_area * 2];
 187         blurzoomx = new int[buf_width];
 188         blurzoomy = new int[buf_height];
 189
 190         set_table();
 191         make_palette();
 192
 193         bzero(blurzoombuf, buf_area * 2);
 194
 195
 196         background = new uint16_t[project_frame_w * project_frame_h];
 197         diff = new unsigned char[project_frame_w * project_frame_h];
 198         image_set_threshold_y(MAGIC_THRESHOLD);
 199
 200         blurzoom_server = new BlurZoomServer(this, 1, 1);
 201         return 0;
 202 }
 203
 204 int BlurZoomMain::stop_realtime()
 205 {
 206         delete blurzoom_server;
 207
 208
 209
 210
 211
 212         delete [] blurzoombuf;
 213         delete [] blurzoomx;
 214         delete [] blurzoomy;
 215
 216
 217
 218
 219
 220         delete [] background;
 221         delete [] diff;
 222
 223
 224
 225
 226         return 0;
 227 }
 228
 229 int BlurZoomMain::process_realtime(VFrame *input_ptr, VFrame *output_ptr)
 230 {
 231         load_configuration();
 232         this->input_ptr = input_ptr;
 233         this->output_ptr = output_ptr;
 234
 235
 236         blurzoom_server->process_packages();
 237
 238         return 0;
 239 }
 240
 241 int BlurZoomMain::show_gui()
 242 {
 243         load_configuration();
 244         thread = new BlurZoomThread(this);
 245         thread->start();
 246         return 0;
 247 }
 248
 249 int BlurZoomMain::set_string()
 250 {
 251         if(thread) thread->window->set_title(gui_string);
 252         return 0;
 253 }
 254
 255 void BlurZoomMain::raise_window()
 256 {
 257         if(thread)
 258         {
 259                 thread->window->raise_window();
 260                 thread->window->flush();
 261         }
 262 }
 263
 264
 265
 266
 267 BlurZoomServer::BlurZoomServer(BlurZoomMain *plugin, int total_clients, int total_packages)
 268  : LoadServer(total_clients, total_packages)
 269 {
 270         this->plugin = plugin;
 271 }
 272
 273
 274 LoadClient* BlurZoomServer::new_client()
 275 {
 276         return new BlurZoomClient(this);
 277 }
 278
 279
 280
 281
 282 LoadPackage* BlurZoomServer::new_package()
 283 {
 284         return new BlurZoomPackage;
 285 }
 286
 287
 288
 289 void BlurZoomServer::init_packages()
 290 {
 291         for(int i = 0; i < total_packages; i++)
 292         {
 293                 BlurZoomPackage *package = (BlurZoomPackage*)packages[i];
 294                 package->row1 = plugin->input_ptr->get_h() / total_packages * i;
 295                 package->row2 = package->row1 + plugin->input_ptr->get_h() / total_packages;
 296                 if(i >= total_packages - 1)
 297                         package->row2 = plugin->input_ptr->get_h();
 298         }
 299 }
 300
 301
 302
 303
 304
 305
 306
 307
 308 BlurZoomClient::BlurZoomClient(BlurZoomServer *server)
 309  : LoadClient(server)
 310 {
 311         this->plugin = server->plugin;
 312 }
 313
 314
 315
 316
 317
 318
 319
 320
 321
 322 /* Background image is refreshed every frame */
 323 #define IMAGE_BGSUBTRACT_UPDATE_Y(result, \
 324         input_rows,  \
 325         type,  \
 326         components) \
 327 { \
 328         int i; \
 329         int R, G, B; \
 330         type *p; \
 331         int16_t *q; \
 332         unsigned char *r; \
 333         int v; \
 334  \
 335         q = (int16_t *)background; \
 336         r = diff; \
 337  \
 338         for(i = 0; i < project_frame_h; i++)  \
 339         { \
 340                 p = input_rows[j]; \
 341  \
 342                 for(j = 0; j < project_frame_w; j++) \
 343                 { \
 344                         if(sizeof(type) == 2) \
 345                         { \
 346                                 R = p[0] >> (8 - 1); \
 347                                 G = p[1] >> (8 - 2); \
 348                                 B = p[2] >> 8; \
 349                         } \
 350                         else \
 351                         { \
 352                                 R = p[0] << 1; \
 353                                 G = p[1] << 2; \
 354                                 B = p[2]; \
 355                         } \
 356  \
 357                         v = (R + G + B) - (int)(*q); \
 358                         *q = (int16_t)(R + G + B); \
 359                         *r = ((v + y_threshold) >> 24) | ((y_threshold - v) >> 24); \
 360  \
 361                         p += components; \
 362                         q++; \
 363                         r++; \
 364                 } \
 365         } \
 366  \
 367         result = diff; \
 368 }
 369
 370
 371
 372
 373 #define BLURZOOM_FINAL(type, components)
 374 {
 375         for(y = 0; y < h; y++)
 376         {
 377                 memcpy(output_rows[y],
 378                         input_rows[y],
 379                         buf_margin_left * plugin->input_ptr->get_bytes_per_pixel());
 380
 381
 382                 for(x = 0; x < buf_width; x++)
 383                 {
 384                         for(c = 0; c < components; c++)
 385                         {
 386                                 a = *src++ & 0xfefeff;
 387                                 b = palette[*p++];
 388                                 a += b;
 389                                 b = a & 0x1010100;
 390                                 *dest++ = a | (b - (b >> 8));
 391                         }
 392                 }
 393
 394                 memcpy(output_rows[y] + project_frame_w - buf_margin_right,
 395                         input_rows[y] + project_frame_w - buf_margin_right,
 396                         buf_margin_right * plugin->input_ptr->get_bytes_per_pixel());
 397         }
 398 }
 399
 400
 401
 402 void BlurZoomClient::process_package(LoadPackage *package)
 403 {
 404         BlurZoomPackage *local_package = (BlurZoomPackage*)package;
 405         unsigned char **input_rows = plugin->input_ptr->get_rows() + local_package->row1;
 406         unsigned char **output_rows = plugin->output_ptr->get_rows() + local_package->row1;
 407         int w = plugin->input_ptr->get_w();
 408         int h = local_package->row2 - local_package->row1;
 409         int x, y;
 410         int a, b, c;
 411         unsigned char *diff, *p;
 412
 413         switch(plugin->input_ptr->get_color_model())
 414         {
 415                 case BC_RGB888:
 416                 case BC_YUV888:
 417                         IMAGE_BGSUBTRACT_UPDATE_Y(diff,
 418                                 input_rows,
 419                                 uint8_t,
 420                                 3);
 421                         break;
 422                 case BC_RGBA8888:
 423                 case BC_YUVA8888:
 424                         IMAGE_BGSUBTRACT_UPDATE_Y(diff,
 425                                 input_rows,
 426                                 uint8_t,
 427                                 4);
 428                         break;
 429                 case BC_RGB161616:
 430                 case BC_YUV161616:
 431                         IMAGE_BGSUBTRACT_UPDATE_Y(diff,
 432                                 input_rows,
 433                                 uint16_t,
 434                                 3);
 435                         break;
 436                 case BC_RGBA16161616:
 437                 case BC_YUVA16161616:
 438                         IMAGE_BGSUBTRACT_UPDATE_Y(diff,
 439                                 input_rows,
 440                                 uint16_t,
 441                                 4);
 442                         break;
 443         }
 444
 445
 446         diff += buf_margin_left;
 447         p = blurzoombuf;
 448
 449
 450
 451         for(y = 0; y < buf_height; y++)
 452         {
 453                 for(x = 0; x < buf_width; x++)
 454                 {
 455                         p[x] |= diff[x] >> 3;
 456                 }
 457
 458                 diff += w;
 459                 p += buf_width;
 460         }
 461
 462
 463 // Assembly language only
 464         blurzoomcore();
 465
 466
 467         p = blurzoombuf;
 468
 469
 470
 471         switch(plugin->input_ptr->get_color_model())
 472         {
 473                 case BC_RGB888:
 474                 case BC_YUV888:
 475                         BLURZOOM_FINAL(uint8_t, 3);
 476                         break;
 477                 case BC_RGBA8888:
 478                 case BC_YUVA8888:
 479                         BLURZOOM_FINAL(uint8_t, 4);
 480                         break;
 481                 case BC_RGB161616:
 482                 case BC_YUV161616:
 483                         BLURZOOM_FINAL(uint16_t, 3);
 484                         break;
 485                 case BC_RGBA16161616:
 486                 case BC_YUVA16161616:
 487                         BLURZOOM_FINAL(uint16_t, 4);
 488                         break;
 489         }
 490
 491
 492
 493
 494 }
 495
 496
 497
 498 BlurZoomPackage::BlurZoomPackage()
 499 {
 500 }
 501
 502
 503