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(0,
 199 //                              input_ptr->get_w(),
 200 //                              input_ptr->get_h(),
 201 //                              project_color_model);
 202                         bgimage->copy_from(input_ptr);
 203                         break;
 204
 205                 case 1:
 206 /* step 2: add frame-2 to buffer-1 */
 207                         add_frames(bgimage, input_ptr);
 208                         break;
 209
 210                 case 2:
 211 /* step 3: grab frame-3 to buffer-2 */
 212                         tmp->copy_from(input_ptr);
 213                         break;
 214
 215                 case 3:
 216 /* step 4: add frame-4 to buffer-2 */
 217                         add_frames(tmp, input_ptr);
 218
 219
 220
 221 /* step 5: add buffer-3 to buffer-1 */
 222                         add_frames(bgimage, tmp);
 223
 224                         effecttv->image_bgset_y(bgimage);
 225
 226
 227                         delete tmp;
 228                         break;
 229         }
 230 }
 231
 232
 233 int HoloMain::process_realtime(VFrame *input_ptr, VFrame *output_ptr)
 234 {
 235         this->input_ptr = input_ptr;
 236         this->output_ptr = output_ptr;
 237
 238
 239
 240
 241         load_configuration();
 242
 243
 244
 245         if(do_reconfigure)
 246         {
 247                 if(!effecttv)
 248                 {
 249                         effecttv = new EffectTV(input_ptr->get_w(), input_ptr->get_h());
 250                         bgimage = new VFrame(0,
 251                                 -1,
 252                                 input_ptr->get_w(),
 253                                 input_ptr->get_h(),
 254                                 input_ptr->get_color_model(),
 255                                 -1);
 256
 257                         for(int i = 0; i < 256; i++)
 258                         {
 259                                 noisepattern[i] = (i * i * i / 40000)* i / 256;
 260                         }
 261
 262                         holo_server = new HoloServer(this, 1, 1);
 263                 }
 264
 265                 reconfigure();
 266         }
 267
 268         set_background();
 269
 270         holo_server->process_packages();
 271
 272         total++;
 273         if(total >= config.recycle * project_frame_rate)
 274                 total = 0;
 275
 276         return 0;
 277 }
 278
 279
 280
 281
 282
 283 HoloServer::HoloServer(HoloMain *plugin, int total_clients, int total_packages)
 284  : LoadServer(total_clients, total_packages)
 285 {
 286         this->plugin = plugin;
 287 }
 288
 289
 290 LoadClient* HoloServer::new_client()
 291 {
 292         return new HoloClient(this);
 293 }
 294
 295
 296
 297
 298 LoadPackage* HoloServer::new_package()
 299 {
 300         return new HoloPackage;
 301 }
 302
 303
 304
 305 void HoloServer::init_packages()
 306 {
 307         for(int i = 0; i < get_total_packages(); i++)
 308         {
 309                 HoloPackage *package = (HoloPackage*)get_package(i);
 310                 package->row1 = plugin->input_ptr->get_h() * i / get_total_packages();
 311                 package->row2 = plugin->input_ptr->get_h() * (i + 1) / get_total_packages();
 312         }
 313 }
 314
 315
 316
 317
 318
 319
 320
 321
 322 HoloClient::HoloClient(HoloServer *server)
 323  : LoadClient(server)
 324 {
 325         this->plugin = server->plugin;
 326         phase = 0;
 327 }
 328
 329
 330 void HoloClient::process_package(LoadPackage *package)
 331 {
 332         int x, y;
 333         HoloPackage *local_package = (HoloPackage*)package;
 334         unsigned char **input_rows = plugin->input_ptr->get_rows() + local_package->row1;
 335         unsigned char **output_rows = plugin->output_ptr->get_rows() + local_package->row1;
 336         int width = plugin->input_ptr->get_w();
 337         int height = local_package->row2 - local_package->row1;
 338         unsigned char *diff;
 339         uint32_t s, t;
 340         int r, g, b;
 341
 342         diff = plugin->effecttv->image_diff_filter(plugin->effecttv->image_bgsubtract_y(input_rows,
 343                 plugin->input_ptr->get_color_model()));
 344
 345         diff += width;
 346         output_rows++;
 347         input_rows++;
 348
 349
 350 // Convert discrete channels to a single 24 bit number
 351 #define STORE_PIXEL(type, components, dest, src, is_yuv) \
 352 if(sizeof(type) == 4) \
 353 { \
 354         int r = (int)(src[0] * 0xff); \
 355         int g = (int)(src[1] * 0xff); \
 356         int b = (int)(src[2] * 0xff); \
 357         CLAMP(r, 0, 0xff); \
 358         CLAMP(g, 0, 0xff); \
 359         CLAMP(b, 0, 0xff); \
 360         dest = (r << 16) | (g << 8) | b; \
 361 } \
 362 else \
 363 if(sizeof(type) == 2) \
 364 { \
 365         if(is_yuv) \
 366         { \
 367                 int r = (int)src[0] >> 8; \
 368                 int g = (int)src[1] >> 8; \
 369                 int b = (int)src[2] >> 8; \
 370                 plugin->yuv->yuv_to_rgb_8(r, g, b); \
 371                 dest = (r << 16) | (g << 8) | b; \
 372         } \
 373         else \
 374         { \
 375                 dest = (((uint32_t)src[0] << 8) & 0xff0000) | \
 376                         ((uint32_t)src[1] & 0xff00) | \
 377                         ((uint32_t)src[2]) >> 8; \
 378         } \
 379 } \
 380 else \
 381 { \
 382         if(is_yuv) \
 383         { \
 384                 int r = (int)src[0]; \
 385                 int g = (int)src[1]; \
 386                 int b = (int)src[2]; \
 387                 plugin->yuv->yuv_to_rgb_8(r, g, b); \
 388                 dest = (r << 16) | (g << 8) | b; \
 389         } \
 390         else \
 391         { \
 392                 dest = ((uint32_t)src[0] << 16) | \
 393                         ((uint32_t)src[1] << 8) | \
 394                         (uint32_t)src[2]; \
 395         } \
 396 }
 397
 398
 399
 400
 401 #define HOLO_CORE(type, components, is_yuv) \
 402         for(y = 1; y < height - 1; y++) \
 403         { \
 404                 type *src = (type*)input_rows[y]; \
 405                 type *bg = (type*)plugin->bgimage->get_rows()[y]; \
 406                 type *dest = (type*)output_rows[y]; \
 407  \
 408  \
 409  \
 410                 if(((y + phase) & 0x7f) < 0x58)  \
 411                 { \
 412                         for(x = 0 ; x < width; x++)  \
 413                         { \
 414                                 if(*diff) \
 415                                 { \
 416                                         STORE_PIXEL(type, components, s, src, is_yuv); \
 417  \
 418                                         t = (s & 0xff) +  \
 419                                                 ((s & 0xff00) >> 7) +  \
 420                                                 ((s & 0xff0000) >> 16); \
 421                                         t += plugin->noisepattern[EffectTV::fastrand() >> 24]; \
 422  \
 423                                         r = ((s & 0xff0000) >> 17) + t; \
 424                                         g = ((s & 0xff00) >> 8) + t; \
 425                                         b = (s & 0xff) + t; \
 426  \
 427                                         r = (r >> 1) - 100; \
 428                                         g = (g >> 1) - 100; \
 429                                         b = b >> 2; \
 430  \
 431                                         if(r < 20) r = 20; \
 432                                         if(g < 20) g = 20; \
 433  \
 434                                         STORE_PIXEL(type, components, s, bg, is_yuv); \
 435  \
 436                                         r += (s & 0xff0000) >> 17; \
 437                                         g += (s & 0xff00) >> 9; \
 438                                         b += ((s & 0xff) >> 1) + 40; \
 439  \
 440                                         if(r > 255) r = 255; \
 441                                         if(g > 255) g = 255; \
 442                                         if(b > 255) b = 255; \
 443  \
 444                                         if(is_yuv) plugin->yuv->rgb_to_yuv_8(r, g, b); \
 445                                         if(sizeof(type) == 4) \
 446                                         { \
 447                                                 dest[0] = (type)r / 0xff; \
 448                                                 dest[1] = (type)g / 0xff; \
 449                                                 dest[2] = (type)b / 0xff; \
 450                                         } \
 451                                         else \
 452                                         if(sizeof(type) == 2) \
 453                                         { \
 454                                                 dest[0] = (r << 8) | r; \
 455                                                 dest[1] = (g << 8) | g; \
 456                                                 dest[2] = (b << 8) | b; \
 457                                         } \
 458                                         else \
 459                                         { \
 460                                                 dest[0] = r; \
 461                                                 dest[1] = g; \
 462                                                 dest[2] = b; \
 463                                         } \
 464                                 }  \
 465                                 else  \
 466                                 { \
 467                                         dest[0] = bg[0]; \
 468                                         dest[1] = bg[1]; \
 469                                         dest[2] = bg[2]; \
 470                                 } \
 471  \
 472                                 diff++; \
 473                                 src += components; \
 474                                 dest += components; \
 475                                 bg += components; \
 476                         } \
 477                 }  \
 478                 else  \
 479                 { \
 480                         for(x = 0; x < width; x++) \
 481                         { \
 482                                 if(*diff) \
 483                                 { \
 484                                         STORE_PIXEL(type, components, s, src, is_yuv); \
 485  \
 486  \
 487                                         t = (s & 0xff) + ((s & 0xff00) >> 6) + ((s & 0xff0000) >> 16); \
 488                                         t += plugin->noisepattern[EffectTV::fastrand() >> 24]; \
 489  \
 490                                         r = ((s & 0xff0000) >> 16) + t; \
 491                                         g = ((s & 0xff00) >> 8) + t; \
 492                                         b = (s & 0xff) + t; \
 493  \
 494                                         r = (r >> 1) - 100; \
 495                                         g = (g >> 1) - 100; \
 496                                         b = b >> 2; \
 497  \
 498                                         if(r < 0) r = 0; \
 499                                         if(g < 0) g = 0; \
 500  \
 501                                         STORE_PIXEL(type, components, s, bg, is_yuv); \
 502  \
 503                                         r += ((s & 0xff0000) >> 17) + 10; \
 504                                         g += ((s & 0xff00) >> 9) + 10; \
 505                                         b += ((s & 0xff) >> 1) + 40; \
 506  \
 507                                         if(r > 255) r = 255; \
 508                                         if(g > 255) g = 255; \
 509                                         if(b > 255) b = 255; \
 510  \
 511                                         if(is_yuv) plugin->yuv->rgb_to_yuv_8(r, g, b); \
 512                                         if(sizeof(type) == 4) \
 513                                         { \
 514                                                 dest[0] = (type)r / 0xff; \
 515                                                 dest[1] = (type)g / 0xff; \
 516                                                 dest[2] = (type)b / 0xff; \
 517                                         } \
 518                                         else \
 519                                         if(sizeof(type) == 2) \
 520                                         { \
 521                                                 dest[0] = (r << 8) | r; \
 522                                                 dest[1] = (g << 8) | g; \
 523                                                 dest[2] = (b << 8) | b; \
 524                                         } \
 525                                         else \
 526                                         { \
 527                                                 dest[0] = r; \
 528                                                 dest[1] = g; \
 529                                                 dest[2] = b; \
 530                                         } \
 531                                 }  \
 532                                 else  \
 533                                 { \
 534                                         dest[0] = bg[0]; \
 535                                         dest[1] = bg[1]; \
 536                                         dest[2] = bg[2]; \
 537                                 } \
 538  \
 539                                 diff++; \
 540                                 src += components; \
 541                                 dest += components; \
 542                                 bg += components; \
 543                         } \
 544                 } \
 545         }
 546
 547
 548
 549
 550         switch(plugin->input_ptr->get_color_model())
 551         {
 552                 case BC_RGB888:
 553                         HOLO_CORE(uint8_t, 3, 0);
 554                         break;
 555                 case BC_RGB_FLOAT:
 556                         HOLO_CORE(float, 3, 0);
 557                         break;
 558                 case BC_YUV888:
 559                         HOLO_CORE(uint8_t, 3, 1);
 560                         break;
 561                 case BC_RGBA_FLOAT:
 562                         HOLO_CORE(float, 4, 0);
 563                         break;
 564                 case BC_RGBA8888:
 565                         HOLO_CORE(uint8_t, 4, 0);
 566                         break;
 567                 case BC_YUVA8888:
 568                         HOLO_CORE(uint8_t, 4, 1);
 569                         break;
 570                 case BC_RGB161616:
 571                         HOLO_CORE(uint16_t, 3, 0);
 572                         break;
 573                 case BC_YUV161616:
 574                         HOLO_CORE(uint16_t, 3, 1);
 575                         break;
 576                 case BC_RGBA16161616:
 577                         HOLO_CORE(uint16_t, 4, 0);
 578                         break;
 579                 case BC_YUVA16161616:
 580                         HOLO_CORE(uint16_t, 4, 1);
 581                         break;
 582         }
 583
 584
 585
 586         phase -= 37;
 587 }
 588
 589
 590
 591 HoloPackage::HoloPackage()
 592 {
 593 }
 594
 595
 596