cinelerra-5.1/plugins/holo/holo.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 "clip.h"
  23 #include "bccmodels.h"
  24 #include "effecttv.h"
  25 #include "filexml.h"
  26 #include "holo.h"
  27 #include "holowindow.h"
  28 #include "language.h"
  29 #include "bccolors.h"
  30
  31 #include <stdint.h>
  32 #include <stdio.h>
  33 #include <string.h>
  34
  35
  36 REGISTER_PLUGIN(HoloMain)
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47 HoloConfig::HoloConfig()
  48 {
  49         threshold = 40;
  50         recycle = 1.0;
  51 }
  52
  53
  54
  55
  56
  57 HoloMain::HoloMain(PluginServer *server)
  58  : PluginVClient(server)
  59 {
  60         effecttv = 0;
  61         bgimage = 0;
  62         do_reconfigure = 1;
  63         yuv = new YUV;
  64
  65 }
  66
  67 HoloMain::~HoloMain()
  68 {
  69
  70
  71
  72         if(effecttv)
  73         {
  74                 delete holo_server;
  75                 delete effecttv;
  76         }
  77
  78         if(bgimage)
  79                 delete bgimage;
  80         delete yuv;
  81 }
  82
  83 const char* HoloMain::plugin_title() { return _("HolographicTV"); }
  84 int HoloMain::is_realtime() { return 1; }
  85
  86 NEW_WINDOW_MACRO(HoloMain, HoloWindow)
  87
  88 int HoloMain::load_configuration()
  89 {
  90         return 0;
  91 }
  92
  93
  94 void HoloMain::save_data(KeyFrame *keyframe)
  95 {
  96 }
  97
  98 void HoloMain::read_data(KeyFrame *keyframe)
  99 {
 100 }
 101
 102 void HoloMain::reconfigure()
 103 {
 104         do_reconfigure = 0;
 105
 106         effecttv->image_set_threshold_y(config.threshold);
 107 }
 108
 109
 110 #define ADD_FRAMES(type, components) \
 111 { \
 112         type **input_rows = (type**)input->get_rows(); \
 113         type **output_rows = (type**)output->get_rows(); \
 114         int w = input->get_w(); \
 115         int h = input->get_h(); \
 116  \
 117         for(int i = 0; i < h; i++) \
 118         { \
 119                 type *output_row = (type*)output_rows[i]; \
 120                 type *input_row = (type*)input_rows[i]; \
 121  \
 122                 for(int j = 0; j < w; j++) \
 123                 { \
 124                         for(int k = 0; k < 3; k++) \
 125                         { \
 126                                 if(sizeof(type) == 4) \
 127                                 { \
 128                                         int in_temp = (int)(*input_row * 0xffff); \
 129                                         int out_temp = (int)(*output_row * 0xffff); \
 130                                         int temp = (in_temp & out_temp) + \
 131                                                 ((in_temp ^ out_temp) >> 1); \
 132                                         *output_row = (type)temp / 0xffff; \
 133                                 } \
 134                                 else \
 135                                 { \
 136                                         *output_row = ((uint16_t)*input_row & (uint16_t)*output_row) + \
 137                                                 (((uint16_t)*input_row ^ (uint16_t)*output_row) >> 1); \
 138                                 } \
 139                                 output_row++; \
 140                                 input_row++; \
 141                         } \
 142  \
 143                         if(components == 4) \
 144                         { \
 145                                 output_row++; \
 146                                 input_row++; \
 147                         } \
 148                 } \
 149         } \
 150 }
 151
 152
 153 // Add input to output and store result in output
 154 void HoloMain::add_frames(VFrame *output, VFrame *input)
 155 {
 156         switch(output->get_color_model())
 157         {
 158                 case BC_RGB888:
 159                 case BC_YUV888:
 160                         ADD_FRAMES(uint8_t, 3);
 161                         break;
 162                 case BC_RGB_FLOAT:
 163                         ADD_FRAMES(float, 3);
 164                         break;
 165                 case BC_RGBA_FLOAT:
 166                         ADD_FRAMES(float, 4);
 167                         break;
 168                 case BC_RGBA8888:
 169                 case BC_YUVA8888:
 170                         ADD_FRAMES(uint8_t, 4);
 171                         break;
 172                 case BC_RGB161616:
 173                 case BC_YUV161616:
 174                         ADD_FRAMES(uint16_t, 3);
 175                         break;
 176                 case BC_RGBA16161616:
 177                 case BC_YUVA16161616:
 178                         ADD_FRAMES(uint16_t, 4);
 179                         break;
 180         }
 181 }
 182
 183 void HoloMain::set_background()
 184 {
 185 /*
 186  * grab 4 frames and composite them to get a quality background image
 187  */
 188 /**
 189  * For Cinelerra, we make every frame a holograph and expect the user to
 190  * provide a matte.
 191  **/
 192 total = 0;
 193
 194         switch(total)
 195         {
 196                 case 0:
 197 /* step 1: grab frame-1 to buffer-1 */
 198 //                      tmp = new VFrame(input_ptr->get_w(),input_ptr->get_h(),
 199 //                              project_color_model, 0);
 200                         bgimage->copy_from(input_ptr);
 201                         break;
 202
 203                 case 1:
 204 /* step 2: add frame-2 to buffer-1 */
 205                         add_frames(bgimage, input_ptr);
 206                         break;
 207
 208                 case 2:
 209 /* step 3: grab frame-3 to buffer-2 */
 210                         tmp->copy_from(input_ptr);
 211                         break;
 212
 213                 case 3:
 214 /* step 4: add frame-4 to buffer-2 */
 215                         add_frames(tmp, input_ptr);
 216
 217
 218
 219 /* step 5: add buffer-3 to buffer-1 */
 220                         add_frames(bgimage, tmp);
 221
 222                         effecttv->image_bgset_y(bgimage);
 223
 224
 225                         delete tmp;
 226                         break;
 227         }
 228 }
 229
 230
 231 int HoloMain::process_realtime(VFrame *input_ptr, VFrame *output_ptr)
 232 {
 233         this->input_ptr = input_ptr;
 234         this->output_ptr = output_ptr;
 235
 236
 237
 238
 239         load_configuration();
 240
 241
 242
 243         if(do_reconfigure)
 244         {
 245                 if(!effecttv)
 246                 {
 247                         effecttv = new EffectTV(input_ptr->get_w(), input_ptr->get_h());
 248                         bgimage = new VFrame(input_ptr->get_w(), input_ptr->get_h(),
 249                                 input_ptr->get_color_model(), 0);
 250
 251                         for(int i = 0; i < 256; i++)
 252                         {
 253                                 noisepattern[i] = (i * i * i / 40000)* i / 256;
 254                         }
 255
 256                         holo_server = new HoloServer(this, 1, 1);
 257                 }
 258
 259                 reconfigure();
 260         }
 261
 262         set_background();
 263
 264         holo_server->process_packages();
 265
 266         total++;
 267         if(total >= config.recycle * project_frame_rate)
 268                 total = 0;
 269
 270         return 0;
 271 }
 272
 273
 274
 275
 276
 277 HoloServer::HoloServer(HoloMain *plugin, int total_clients, int total_packages)
 278  : LoadServer(total_clients, total_packages)
 279 {
 280         this->plugin = plugin;
 281 }
 282
 283
 284 LoadClient* HoloServer::new_client()
 285 {
 286         return new HoloClient(this);
 287 }
 288
 289
 290
 291
 292 LoadPackage* HoloServer::new_package()
 293 {
 294         return new HoloPackage;
 295 }
 296
 297
 298
 299 void HoloServer::init_packages()
 300 {
 301         for(int i = 0; i < get_total_packages(); i++)
 302         {
 303                 HoloPackage *package = (HoloPackage*)get_package(i);
 304                 package->row1 = plugin->input_ptr->get_h() * i / get_total_packages();
 305                 package->row2 = plugin->input_ptr->get_h() * (i + 1) / get_total_packages();
 306         }
 307 }
 308
 309
 310
 311
 312
 313
 314
 315
 316 HoloClient::HoloClient(HoloServer *server)
 317  : LoadClient(server)
 318 {
 319         this->plugin = server->plugin;
 320         phase = 0;
 321 }
 322
 323
 324 void HoloClient::process_package(LoadPackage *package)
 325 {
 326         int x, y;
 327         HoloPackage *local_package = (HoloPackage*)package;
 328         unsigned char **input_rows = plugin->input_ptr->get_rows() + local_package->row1;
 329         unsigned char **output_rows = plugin->output_ptr->get_rows() + local_package->row1;
 330         int width = plugin->input_ptr->get_w();
 331         int height = local_package->row2 - local_package->row1;
 332         unsigned char *diff;
 333         uint32_t s, t;
 334         int r, g, b;
 335
 336         diff = plugin->effecttv->image_diff_filter(plugin->effecttv->image_bgsubtract_y(input_rows,
 337                 plugin->input_ptr->get_color_model()));
 338
 339         diff += width;
 340         output_rows++;
 341         input_rows++;
 342
 343
 344 // Convert discrete channels to a single 24 bit number
 345 #define STORE_PIXEL(type, components, dest, src, is_yuv) \
 346 if(sizeof(type) == 4) \
 347 { \
 348         int r = (int)(src[0] * 0xff); \
 349         int g = (int)(src[1] * 0xff); \
 350         int b = (int)(src[2] * 0xff); \
 351         CLAMP(r, 0, 0xff); \
 352         CLAMP(g, 0, 0xff); \
 353         CLAMP(b, 0, 0xff); \
 354         dest = (r << 16) | (g << 8) | b; \
 355 } \
 356 else \
 357 if(sizeof(type) == 2) \
 358 { \
 359         if(is_yuv) \
 360         { \
 361                 int r = (int)src[0] >> 8; \
 362                 int g = (int)src[1] >> 8; \
 363                 int b = (int)src[2] >> 8; \
 364                 plugin->yuv->yuv_to_rgb_8(r, g, b); \
 365                 dest = (r << 16) | (g << 8) | b; \
 366         } \
 367         else \
 368         { \
 369                 dest = (((uint32_t)src[0] << 8) & 0xff0000) | \
 370                         ((uint32_t)src[1] & 0xff00) | \
 371                         ((uint32_t)src[2]) >> 8; \
 372         } \
 373 } \
 374 else \
 375 { \
 376         if(is_yuv) \
 377         { \
 378                 int r = (int)src[0]; \
 379                 int g = (int)src[1]; \
 380                 int b = (int)src[2]; \
 381                 plugin->yuv->yuv_to_rgb_8(r, g, b); \
 382                 dest = (r << 16) | (g << 8) | b; \
 383         } \
 384         else \
 385         { \
 386                 dest = ((uint32_t)src[0] << 16) | \
 387                         ((uint32_t)src[1] << 8) | \
 388                         (uint32_t)src[2]; \
 389         } \
 390 }
 391
 392
 393
 394
 395 #define HOLO_CORE(type, components, is_yuv) \
 396         for(y = 1; y < height - 1; y++) \
 397         { \
 398                 type *src = (type*)input_rows[y]; \
 399                 type *bg = (type*)plugin->bgimage->get_rows()[y]; \
 400                 type *dest = (type*)output_rows[y]; \
 401  \
 402  \
 403  \
 404                 if(((y + phase) & 0x7f) < 0x58)  \
 405                 { \
 406                         for(x = 0 ; x < width; x++)  \
 407                         { \
 408                                 if(*diff) \
 409                                 { \
 410                                         STORE_PIXEL(type, components, s, src, is_yuv); \
 411  \
 412                                         t = (s & 0xff) +  \
 413                                                 ((s & 0xff00) >> 7) +  \
 414                                                 ((s & 0xff0000) >> 16); \
 415                                         t += plugin->noisepattern[EffectTV::fastrand() >> 24]; \
 416  \
 417                                         r = ((s & 0xff0000) >> 17) + t; \
 418                                         g = ((s & 0xff00) >> 8) + t; \
 419                                         b = (s & 0xff) + t; \
 420  \
 421                                         r = (r >> 1) - 100; \
 422                                         g = (g >> 1) - 100; \
 423                                         b = b >> 2; \
 424  \
 425                                         if(r < 20) r = 20; \
 426                                         if(g < 20) g = 20; \
 427  \
 428                                         STORE_PIXEL(type, components, s, bg, is_yuv); \
 429  \
 430                                         r += (s & 0xff0000) >> 17; \
 431                                         g += (s & 0xff00) >> 9; \
 432                                         b += ((s & 0xff) >> 1) + 40; \
 433  \
 434                                         if(r > 255) r = 255; \
 435                                         if(g > 255) g = 255; \
 436                                         if(b > 255) b = 255; \
 437  \
 438                                         if(is_yuv) plugin->yuv->rgb_to_yuv_8(r, g, b); \
 439                                         if(sizeof(type) == 4) \
 440                                         { \
 441                                                 dest[0] = (type)r / 0xff; \
 442                                                 dest[1] = (type)g / 0xff; \
 443                                                 dest[2] = (type)b / 0xff; \
 444                                         } \
 445                                         else \
 446                                         if(sizeof(type) == 2) \
 447                                         { \
 448                                                 dest[0] = (r << 8) | r; \
 449                                                 dest[1] = (g << 8) | g; \
 450                                                 dest[2] = (b << 8) | b; \
 451                                         } \
 452                                         else \
 453                                         { \
 454                                                 dest[0] = r; \
 455                                                 dest[1] = g; \
 456                                                 dest[2] = b; \
 457                                         } \
 458                                 }  \
 459                                 else  \
 460                                 { \
 461                                         dest[0] = bg[0]; \
 462                                         dest[1] = bg[1]; \
 463                                         dest[2] = bg[2]; \
 464                                 } \
 465  \
 466                                 diff++; \
 467                                 src += components; \
 468                                 dest += components; \
 469                                 bg += components; \
 470                         } \
 471                 }  \
 472                 else  \
 473                 { \
 474                         for(x = 0; x < width; x++) \
 475                         { \
 476                                 if(*diff) \
 477                                 { \
 478                                         STORE_PIXEL(type, components, s, src, is_yuv); \
 479  \
 480  \
 481                                         t = (s & 0xff) + ((s & 0xff00) >> 6) + ((s & 0xff0000) >> 16); \
 482                                         t += plugin->noisepattern[EffectTV::fastrand() >> 24]; \
 483  \
 484                                         r = ((s & 0xff0000) >> 16) + t; \
 485                                         g = ((s & 0xff00) >> 8) + t; \
 486                                         b = (s & 0xff) + t; \
 487  \
 488                                         r = (r >> 1) - 100; \
 489                                         g = (g >> 1) - 100; \
 490                                         b = b >> 2; \
 491  \
 492                                         if(r < 0) r = 0; \
 493                                         if(g < 0) g = 0; \
 494  \
 495                                         STORE_PIXEL(type, components, s, bg, is_yuv); \
 496  \
 497                                         r += ((s & 0xff0000) >> 17) + 10; \
 498                                         g += ((s & 0xff00) >> 9) + 10; \
 499                                         b += ((s & 0xff) >> 1) + 40; \
 500  \
 501                                         if(r > 255) r = 255; \
 502                                         if(g > 255) g = 255; \
 503                                         if(b > 255) b = 255; \
 504  \
 505                                         if(is_yuv) plugin->yuv->rgb_to_yuv_8(r, g, b); \
 506                                         if(sizeof(type) == 4) \
 507                                         { \
 508                                                 dest[0] = (type)r / 0xff; \
 509                                                 dest[1] = (type)g / 0xff; \
 510                                                 dest[2] = (type)b / 0xff; \
 511                                         } \
 512                                         else \
 513                                         if(sizeof(type) == 2) \
 514                                         { \
 515                                                 dest[0] = (r << 8) | r; \
 516                                                 dest[1] = (g << 8) | g; \
 517                                                 dest[2] = (b << 8) | b; \
 518                                         } \
 519                                         else \
 520                                         { \
 521                                                 dest[0] = r; \
 522                                                 dest[1] = g; \
 523                                                 dest[2] = b; \
 524                                         } \
 525                                 }  \
 526                                 else  \
 527                                 { \
 528                                         dest[0] = bg[0]; \
 529                                         dest[1] = bg[1]; \
 530                                         dest[2] = bg[2]; \
 531                                 } \
 532  \
 533                                 diff++; \
 534                                 src += components; \
 535                                 dest += components; \
 536                                 bg += components; \
 537                         } \
 538                 } \
 539         }
 540
 541
 542
 543
 544         switch(plugin->input_ptr->get_color_model())
 545         {
 546                 case BC_RGB888:
 547                         HOLO_CORE(uint8_t, 3, 0);
 548                         break;
 549                 case BC_RGB_FLOAT:
 550                         HOLO_CORE(float, 3, 0);
 551                         break;
 552                 case BC_YUV888:
 553                         HOLO_CORE(uint8_t, 3, 1);
 554                         break;
 555                 case BC_RGBA_FLOAT:
 556                         HOLO_CORE(float, 4, 0);
 557                         break;
 558                 case BC_RGBA8888:
 559                         HOLO_CORE(uint8_t, 4, 0);
 560                         break;
 561                 case BC_YUVA8888:
 562                         HOLO_CORE(uint8_t, 4, 1);
 563                         break;
 564                 case BC_RGB161616:
 565                         HOLO_CORE(uint16_t, 3, 0);
 566                         break;
 567                 case BC_YUV161616:
 568                         HOLO_CORE(uint16_t, 3, 1);
 569                         break;
 570                 case BC_RGBA16161616:
 571                         HOLO_CORE(uint16_t, 4, 0);
 572                         break;
 573                 case BC_YUVA16161616:
 574                         HOLO_CORE(uint16_t, 4, 1);
 575                         break;
 576         }
 577
 578
 579
 580         phase -= 37;
 581 }
 582
 583
 584
 585 HoloPackage::HoloPackage()
 586 {
 587 }
 588
 589
 590