cinelerra-5.1/cinelerra/pluginset.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 "edl.h"
  23 #include "edlsession.h"
  24 #include "filexml.h"
  25 #include "keyframe.h"
  26 #include "keyframes.h"
  27 #include "plugin.h"
  28 #include "pluginautos.h"
  29 #include "pluginset.h"
  30 #include "track.h"
  31 #include "transportque.inc"
  32
  33 #include <string.h>
  34
  35 PluginSet::PluginSet(EDL *edl, Track *track)
  36  : Edits(edl, track)
  37 {
  38         record = 1;
  39 }
  40
  41 PluginSet::~PluginSet()
  42 {
  43         while(last) delete last;
  44 }
  45
  46
  47 PluginSet& PluginSet::operator=(PluginSet& plugins)
  48 {
  49 printf("PluginSet::operator= 1\n");
  50         copy_from(&plugins);
  51         return *this;
  52 }
  53
  54 void PluginSet::copy_from(PluginSet *src)
  55 {
  56         while(last) delete last;
  57         for(Plugin *current = (Plugin*)src->first; current; current = (Plugin*)NEXT)
  58         {
  59                 Plugin *new_plugin;
  60                 append(new_plugin = (Plugin*)create_edit());
  61                 new_plugin->copy_from(current);
  62         }
  63         this->record = src->record;
  64 }
  65
  66 Plugin* PluginSet::get_first_plugin()
  67 {
  68 // Called when a new pluginset is added.
  69 // Get first non-silence plugin in the plugin set.
  70         for(Plugin *current = (Plugin*)first; current; current = (Plugin*)NEXT)
  71         {
  72                 if(current && current->plugin_type != PLUGIN_NONE)
  73                 {
  74                         return current;
  75                 }
  76         }
  77         return 0;
  78 }
  79
  80 int64_t PluginSet::plugin_change_duration(int64_t input_position,
  81         int64_t input_length,
  82         int reverse)
  83 {
  84         int result = input_length;
  85         Edit *current;
  86
  87         if(reverse)
  88         {
  89                 int input_start = input_position - input_length;
  90                 for(current = last; current; current = PREVIOUS)
  91                 {
  92                         int start = current->startproject;
  93                         int end = start + current->length;
  94                         if(end > input_start && end < input_position)
  95                         {
  96                                 result = input_position - end;
  97                                 return result;
  98                         }
  99                         else
 100                         if(start > input_start && start < input_position)
 101                         {
 102                                 result = input_position - start;
 103                                 return result;
 104                         }
 105                 }
 106         }
 107         else
 108         {
 109                 int input_end = input_position + input_length;
 110                 for(current = first; current; current = NEXT)
 111                 {
 112                         int start = current->startproject;
 113                         int end = start + current->length;
 114                         if(start > input_position && start < input_end)
 115                         {
 116                                 result = start - input_position;
 117                                 return result;
 118                         }
 119                         else
 120                         if(end > input_position && end < input_end)
 121                         {
 122                                 result = end - input_position;
 123                                 return result;
 124                         }
 125                 }
 126         }
 127         return input_length;
 128 }
 129
 130 void PluginSet::synchronize_params(PluginSet *plugin_set)
 131 {
 132         for(Plugin *this_plugin = (Plugin*)first, *that_plugin = (Plugin*)plugin_set->first;
 133                 this_plugin && that_plugin;
 134                 this_plugin = (Plugin*)this_plugin->next, that_plugin = (Plugin*)that_plugin->next)
 135         {
 136                 this_plugin->synchronize_params(that_plugin);
 137         }
 138 }
 139
 140 Plugin* PluginSet::insert_plugin(const char *title,
 141         int64_t unit_position, int64_t unit_length, int plugin_type,
 142         SharedLocation *shared_location, KeyFrame *default_keyframe,
 143         int do_optimize)
 144 {
 145         Plugin *plugin = (Plugin*)create_silence(unit_position, unit_position + unit_length);
 146         plugin->init(title, unit_position, unit_length, plugin_type,
 147                         shared_location, default_keyframe);
 148 // May delete the plugin we just added so not desirable while loading.
 149         if( do_optimize ) optimize();
 150         return plugin;
 151 }
 152
 153 Edit* PluginSet::create_edit()
 154 {
 155         Plugin* result = new Plugin(edl, this, "");
 156         return result;
 157 }
 158
 159 Edit* PluginSet::insert_edit_after(Edit *previous_edit)
 160 {
 161         Plugin *current = new Plugin(edl, this, "");
 162         List<Edit>::insert_after(previous_edit, current);
 163         return (Edit*)current;
 164 }
 165
 166 KeyFrame *PluginSet::nearest_keyframe(int64_t pos, int dir)
 167 {
 168         Plugin *plugin = (Plugin*)editof(pos, dir, 0);
 169         if( !plugin ) return 0;
 170         KeyFrame *keyframe = (KeyFrame *)(dir == PLAY_FORWARD ?
 171                 plugin->keyframes->nearest_after(pos) :
 172                 plugin->keyframes->nearest_before(pos));
 173         return keyframe;
 174 }
 175
 176 int PluginSet::get_number()
 177 {
 178         return track->plugin_set.number_of(this);
 179 }
 180
 181 void PluginSet::clear(int64_t start, int64_t end, int edit_autos)
 182 {
 183         if(edit_autos)
 184         {
 185 // Clear keyframes
 186                 for(Plugin *current = (Plugin*)first;
 187                         current;
 188                         current = (Plugin*)NEXT)
 189                 {
 190                         current->keyframes->clear(start, end, 1);
 191                 }
 192         }
 193
 194 // Clear edits
 195         Edits::clear(start, end);
 196 }
 197
 198 //void PluginSet::clear_recursive(int64_t start, int64_t end)
 199 //{
 200 //printf("PluginSet::clear_recursive 1\n");
 201 //      clear(start, end, 1);
 202 //}
 203
 204 void PluginSet::shift_keyframes_recursive(int64_t position, int64_t length)
 205 {
 206 // Plugin keyframes are shifted in shift_effects
 207 }
 208
 209 void PluginSet::shift_effects_recursive(int64_t position, int64_t length, int edit_autos)
 210 {
 211 // Effects are shifted in length extension
 212 }
 213
 214
 215 void PluginSet::clear_keyframes(int64_t start, int64_t end)
 216 {
 217         for(Plugin *current = (Plugin*)first; current; current = (Plugin*)NEXT)
 218         {
 219                 current->clear_keyframes(start, end);
 220         }
 221 }
 222
 223 void PluginSet::copy_keyframes(int64_t start,
 224         int64_t end,
 225         FileXML *file,
 226         int default_only,
 227         int active_only)
 228 {
 229         file->tag.set_title("PLUGINSET");
 230         file->append_tag();
 231         file->append_newline();
 232
 233         for(Plugin *current = (Plugin*)first;
 234                 current;
 235                 current = (Plugin*)NEXT)
 236         {
 237                 current->copy_keyframes(start, end, file, default_only, active_only);
 238         }
 239
 240         file->tag.set_title("/PLUGINSET");
 241         file->append_tag();
 242         file->append_newline();
 243 }
 244
 245
 246 void PluginSet::paste_keyframes(int64_t start,
 247         int64_t length,
 248         FileXML *file,
 249         int default_only,
 250         int active_only)
 251 {
 252         int result = 0;
 253         int first_keyframe = 1;
 254         Plugin *current;
 255
 256
 257         while(!result)
 258         {
 259                 result = file->read_tag();
 260
 261                 if(!result)
 262                 {
 263                         if(file->tag.title_is("/PLUGINSET"))
 264                                 result = 1;
 265                         else
 266                         if(file->tag.title_is("KEYFRAME"))
 267                         {
 268                                 int64_t position = file->tag.get_property("POSITION", 0);
 269                                 if(first_keyframe && default_only)
 270                                 {
 271                                         position = start;
 272                                 }
 273                                 else
 274                                 {
 275                                         position += start;
 276                                 }
 277
 278 // Get plugin owning keyframe
 279                                 for(current = (Plugin*)last;
 280                                         current;
 281                                         current = (Plugin*)PREVIOUS)
 282                                 {
 283 // We want keyframes to exist beyond the end of the last plugin to
 284 // make editing intuitive, but it will always be possible to
 285 // paste keyframes from one plugin into an incompatible plugin.
 286                                         if(position >= current->startproject)
 287                                         {
 288                                                 KeyFrame *keyframe = 0;
 289                                                 if(file->tag.get_property("DEFAULT", 0) || default_only)
 290                                                 {
 291                                                         keyframe = (KeyFrame*)current->keyframes->default_auto;
 292                                                 }
 293                                                 else
 294                                                 if(!default_only)
 295                                                 {
 296                                                         keyframe =
 297                                                                 (KeyFrame*)current->keyframes->insert_auto(position);
 298                                                 }
 299
 300                                                 if(keyframe)
 301                                                 {
 302                                                         keyframe->load(file);
 303                                                         keyframe->position = position;
 304                                                 }
 305                                                 break;
 306                                         }
 307                                 }
 308
 309                                 first_keyframe = 0;
 310                         }
 311                 }
 312         }
 313 }
 314
 315 void PluginSet::shift_effects(int64_t start, int64_t length, int edit_autos)
 316 {
 317         for(Plugin *current = (Plugin*)first;
 318                 current;
 319                 current = (Plugin*)NEXT)
 320         {
 321 // Shift beginning of this effect
 322                 if(current->startproject >= start)
 323                 {
 324                         current->startproject += length;
 325                 }
 326                 else
 327 // Extend end of this effect.
 328 // In loading new files, the effect should extend to fill the entire track.
 329 // In muting, the effect must extend to fill the gap if another effect follows.
 330 // The user should use Settings->edit effects to disable this.
 331                 if(current->startproject + current->length >= start)
 332                 {
 333                         current->length += length;
 334                 }
 335
 336 // Shift keyframes in this effect.
 337 // If the default keyframe lands on the starting point, it must be shifted
 338 // since the effect start is shifted.
 339                 if(edit_autos && current->keyframes->default_auto->position >= start)
 340                         current->keyframes->default_auto->position += length;
 341
 342                 if(edit_autos) current->keyframes->paste_silence(start, start + length);
 343         }
 344 }
 345
 346 void PluginSet::paste_silence(int64_t start, int64_t end, int edit_autos)
 347 {
 348         Plugin *new_plugin = (Plugin *) insert_new_edit(start);
 349         int64_t length = end - start;
 350         new_plugin->length = length;
 351         while( (new_plugin=(Plugin *)new_plugin->next) != 0 ) {
 352                 new_plugin->startproject += length;
 353                 if( !edit_autos ) continue;
 354                 new_plugin->keyframes->default_auto->position += length;
 355                 new_plugin->keyframes->paste_silence(start, end);
 356         }
 357 }
 358
 359 void PluginSet::copy(int64_t start, int64_t end, FileXML *file)
 360 {
 361         file->tag.set_title("PLUGINSET");
 362         file->tag.set_property("RECORD", record);
 363         file->append_tag();
 364         file->append_newline();
 365
 366         for(Plugin *current = (Plugin*)first; current; current = (Plugin*)NEXT)
 367         {
 368                 current->copy(start, end, file);
 369         }
 370
 371         file->tag.set_title("/PLUGINSET");
 372         file->append_tag();
 373         file->append_newline();
 374 }
 375
 376 void PluginSet::save(FileXML *file)
 377 {
 378         copy(0, length(), file);
 379 }
 380
 381 void PluginSet::load(FileXML *file, uint32_t load_flags)
 382 {
 383         int result = 0;
 384 // Current plugin being amended
 385         Plugin *plugin = (Plugin*)first;
 386         int64_t startproject = 0;
 387
 388         record = file->tag.get_property("RECORD", record);
 389         do{
 390                 result = file->read_tag();
 391
 392
 393                 if(!result)
 394                 {
 395                         if(file->tag.title_is("/PLUGINSET"))
 396                         {
 397                                 result = 1;
 398                         }
 399                         else
 400                         if(file->tag.title_is("PLUGIN"))
 401                         {
 402                                 int64_t length = file->tag.get_property("LENGTH", (int64_t)0);
 403                                 int plugin_type = file->tag.get_property("TYPE", 1);
 404                                 char title[BCTEXTLEN];
 405                                 title[0] = 0;
 406                                 file->tag.get_property("TITLE", title);
 407                                 Plugin::fix_plugin_title(title);
 408                                 SharedLocation shared_location;
 409                                 shared_location.load(file);
 410
 411
 412                                 if(load_flags & LOAD_EDITS)
 413                                 {
 414                                         plugin = insert_plugin(title,
 415                                                 startproject,
 416                                                 length,
 417                                                 plugin_type,
 418                                                 &shared_location,
 419                                                 0,
 420                                                 0);
 421                                         plugin->load(file);
 422                                         startproject += length;
 423                                 }
 424                                 else
 425                                 if(load_flags & LOAD_AUTOMATION)
 426                                 {
 427                                         if(plugin)
 428                                         {
 429                                                 plugin->load(file);
 430                                                 plugin = (Plugin*)plugin->next;
 431                                         }
 432                                 }
 433                         }
 434                 }
 435         } while(!result);
 436
 437         optimize();
 438 }
 439
 440 int PluginSet::optimize()
 441 {
 442         int result = 1;
 443         Plugin *current_edit;
 444
 445
 446 // Delete keyframes out of range
 447         for(current_edit = (Plugin*)first;
 448                 current_edit;
 449                 current_edit = (Plugin*)current_edit->next)
 450         {
 451                 current_edit->keyframes->default_auto->position = 0;
 452                 for(KeyFrame *current_keyframe = (KeyFrame*)current_edit->keyframes->last;
 453                         current_keyframe; )
 454                 {
 455                         KeyFrame *previous_keyframe = (KeyFrame*)current_keyframe->previous;
 456                         if(current_keyframe->position >
 457                                 current_edit->startproject + current_edit->length ||
 458                                 current_keyframe->position < current_edit->startproject)
 459                         {
 460                                 delete current_keyframe;
 461                         }
 462                         current_keyframe = previous_keyframe;
 463                 }
 464         }
 465
 466 // Insert silence between plugins
 467         for(Plugin *current = (Plugin*)last; current; current = (Plugin*)PREVIOUS)
 468         {
 469                 if(current->previous)
 470                 {
 471                         Plugin *previous = (Plugin*)PREVIOUS;
 472
 473                         if(current->startproject -
 474                                 previous->startproject -
 475                                 previous->length > 0)
 476                         {
 477                                 Plugin *new_plugin = (Plugin*)create_edit();
 478                                 insert_before(current, new_plugin);
 479                                 new_plugin->startproject = previous->startproject +
 480                                         previous->length;
 481                                 new_plugin->length = current->startproject -
 482                                         previous->startproject -
 483                                         previous->length;
 484                         }
 485                 }
 486                 else
 487                 if(current->startproject > 0)
 488                 {
 489                         Plugin *new_plugin = (Plugin*)create_edit();
 490                         insert_before(current, new_plugin);
 491                         new_plugin->length = current->startproject;
 492                 }
 493         }
 494
 495
 496 // delete 0 length plugins
 497         while(result)
 498         {
 499                 result = 0;
 500
 501                 for(current_edit = (Plugin*)first; !result && current_edit; ) {
 502                         Plugin* next = (Plugin*)current_edit->next;
 503                         if(current_edit->length == 0) {
 504                                 delete current_edit;
 505                                 result = 1;
 506                         }
 507                         current_edit = next;
 508                 }
 509
 510
 511 // merge identical plugins with same keyframes
 512                 for( current_edit = (Plugin*)first;
 513                         !result && current_edit && current_edit->next; ) {
 514                         Plugin *next_edit = (Plugin*)current_edit->next;
 515
 516 // plugins identical
 517                         if(next_edit->identical(current_edit)) {
 518                                 current_edit->length += next_edit->length;
 519 // Merge keyframes
 520                                 for(KeyFrame *source = (KeyFrame*)next_edit->keyframes->first;
 521                                         source;
 522                                         source = (KeyFrame*)source->next) {
 523                                         KeyFrame *dest = new KeyFrame(edl, current_edit->keyframes);
 524                                         dest->copy_from(source);
 525                                         current_edit->keyframes->append(dest);
 526                                 }
 527                                 remove(next_edit);
 528                                 result = 1;
 529                                 continue;
 530                         }
 531
 532                         current_edit = next_edit;
 533
 534 // delete last edit if 0 length or silence
 535                         if( last && (last->silence() || !last->length) ) {
 536                                 delete last;
 537                                 result = 1;
 538                         }
 539                 }
 540         }
 541
 542         return 0;
 543 }
 544
 545
 546
 547
 548
 549 void PluginSet::dump(FILE *fp)
 550 {
 551         fprintf(fp,"   PLUGIN_SET:\n");
 552         for(Plugin *current = (Plugin*)first; current; current =  (Plugin*)NEXT)
 553                 current->dump(fp);
 554 }