hvirtual/cinelerra/automation.C

   1 #include "autoconf.h"
   2 #include "automation.h"
   3 #include "autos.h"
   4 #include "atrack.inc"
   5 #include "bezierautos.h"
   6 #include "colors.h"
   7 #include "edl.h"
   8 #include "edlsession.h"
   9 #include "filexml.h"
  10 #include "floatautos.h"
  11 #include "intauto.h"
  12 #include "intautos.h"
  13 #include "maskautos.h"
  14 #include "panauto.h"
  15 #include "panautos.h"
  16 #include "intautos.h"
  17 #include "track.h"
  18 #include "transportque.inc"
  19
  20
  21 Automation::Automation(EDL *edl, Track *track)
  22 {
  23         this->edl = edl;
  24         this->track = track;
  25         camera_autos = 0;
  26         projector_autos = 0;
  27         pan_autos = 0;
  28         mute_autos = 0;
  29         fade_autos = 0;
  30         mode_autos = 0;
  31         mask_autos = 0;
  32         czoom_autos = 0;
  33         pzoom_autos = 0;
  34 }
  35
  36 Automation::~Automation()
  37 {
  38         if(mute_autos) delete mute_autos;
  39
  40         if(mode_autos) delete mode_autos;
  41         if(fade_autos) delete fade_autos;
  42         if(pan_autos) delete pan_autos;
  43         if(camera_autos) delete camera_autos;
  44         if(projector_autos) delete projector_autos;
  45         if(mask_autos) delete mask_autos;
  46         if(czoom_autos) delete czoom_autos;
  47         if(pzoom_autos) delete pzoom_autos;
  48 }
  49
  50 int Automation::create_objects()
  51 {
  52         mute_autos = new IntAutos(edl, track);
  53         mute_autos->create_objects();
  54         ((IntAuto*)mute_autos->default_auto)->value = 0;
  55         return 0;
  56 }
  57
  58 Automation& Automation::operator=(Automation& automation)
  59 {
  60 printf("Automation::operator= 1\n");
  61         copy_from(&automation);
  62         return *this;
  63 }
  64
  65 void Automation::equivalent_output(Automation *automation, int64_t *result)
  66 {
  67         mute_autos->equivalent_output(automation->mute_autos, 0, result);
  68         if(camera_autos) camera_autos->equivalent_output(automation->camera_autos, 0, result);
  69         if(projector_autos) projector_autos->equivalent_output(automation->projector_autos, 0, result);
  70         if(fade_autos) fade_autos->equivalent_output(automation->fade_autos, 0, result);
  71         if(pan_autos) pan_autos->equivalent_output(automation->pan_autos, 0, result);
  72         if(mode_autos) mode_autos->equivalent_output(automation->mode_autos, 0, result);
  73         if(mask_autos) mask_autos->equivalent_output(automation->mask_autos, 0, result);
  74         if(czoom_autos) czoom_autos->equivalent_output(automation->czoom_autos, 0, result);
  75         if(pzoom_autos) pzoom_autos->equivalent_output(automation->pzoom_autos, 0, result);
  76 }
  77
  78 void Automation::copy_from(Automation *automation)
  79 {
  80         mute_autos->copy_from(automation->mute_autos);
  81         if(camera_autos) camera_autos->copy_from(automation->camera_autos);
  82         if(projector_autos) projector_autos->copy_from(automation->projector_autos);
  83         if(fade_autos) fade_autos->copy_from(automation->fade_autos);
  84         if(pan_autos) pan_autos->copy_from(automation->pan_autos);
  85         if(mode_autos) mode_autos->copy_from(automation->mode_autos);
  86         if(mask_autos) mask_autos->copy_from(automation->mask_autos);
  87         if(czoom_autos) czoom_autos->copy_from(automation->czoom_autos);
  88         if(pzoom_autos) pzoom_autos->copy_from(automation->pzoom_autos);
  89 }
  90
  91 int Automation::load(FileXML *file)
  92 {
  93         if(file->tag.title_is("MUTEAUTOS") && mute_autos)
  94         {
  95                 mute_autos->load(file);
  96         }
  97         else
  98         if(file->tag.title_is("FADEAUTOS") && fade_autos)
  99         {
 100                 fade_autos->load(file);
 101         }
 102         else
 103         if(file->tag.title_is("PANAUTOS") && pan_autos)
 104         {
 105                 pan_autos->load(file);
 106         }
 107         else
 108         if(file->tag.title_is("CAMERAAUTOS") && camera_autos)
 109         {
 110                 camera_autos->load(file);
 111         }
 112         else
 113         if(file->tag.title_is("PROJECTORAUTOS") && projector_autos)
 114         {
 115                 projector_autos->load(file);
 116         }
 117         else
 118         if(file->tag.title_is("MODEAUTOS") && mode_autos)
 119         {
 120                 mode_autos->load(file);
 121         }
 122         else
 123         if(file->tag.title_is("MASKAUTOS") && mask_autos)
 124         {
 125                 mask_autos->load(file);
 126         }
 127         else
 128         if(file->tag.title_is("CZOOMAUTOS") && czoom_autos)
 129         {
 130                 czoom_autos->load(file);
 131         }
 132         else
 133         if(file->tag.title_is("PZOOMAUTOS") && pzoom_autos)
 134         {
 135                 pzoom_autos->load(file);
 136         }
 137         return 0;
 138 }
 139
 140 void Automation::paste(int64_t start,
 141         int64_t length,
 142         double scale,
 143         FileXML *file,
 144         int default_only,
 145         AutoConf *autoconf)
 146 {
 147 //printf("Automation::paste 1\n");
 148         if(!autoconf) autoconf = edl->session->auto_conf;
 149         if(file->tag.title_is("MUTEAUTOS") && mute_autos && autoconf->mute)
 150         {
 151                 mute_autos->paste(start, length, scale, file, default_only);
 152         }
 153         else
 154         if(file->tag.title_is("FADEAUTOS") && fade_autos && autoconf->fade)
 155         {
 156                 fade_autos->paste(start, length, scale, file, default_only);
 157         }
 158         else
 159         if(file->tag.title_is("PANAUTOS") && pan_autos && autoconf->pan)
 160         {
 161                 pan_autos->paste(start, length, scale, file, default_only);
 162         }
 163         else
 164         if(file->tag.title_is("CAMERAAUTOS") && camera_autos && autoconf->camera)
 165         {
 166                 camera_autos->paste(start, length, scale, file, default_only);
 167         }
 168         else
 169         if(file->tag.title_is("PROJECTORAUTOS") && projector_autos && autoconf->projector)
 170         {
 171                 projector_autos->paste(start, length, scale, file, default_only);
 172         }
 173         else
 174         if(file->tag.title_is("MODEAUTOS") && mode_autos && autoconf->mode)
 175         {
 176                 mode_autos->paste(start, length, scale, file, default_only);
 177         }
 178         else
 179         if(file->tag.title_is("MASKAUTOS") && mask_autos && autoconf->mask)
 180         {
 181                 mask_autos->paste(start, length, scale, file, default_only);
 182         }
 183         else
 184         if(file->tag.title_is("CZOOMAUTOS") && czoom_autos && autoconf->czoom)
 185         {
 186                 czoom_autos->paste(start, length, scale, file, default_only);
 187         }
 188         else
 189         if(file->tag.title_is("PZOOMAUTOS") && pzoom_autos && autoconf->pzoom)
 190         {
 191                 pzoom_autos->paste(start, length, scale, file, default_only);
 192         }
 193 }
 194
 195 int Automation::copy(int64_t start,
 196         int64_t end,
 197         FileXML *file,
 198         int default_only,
 199         int autos_only,
 200         AutoConf *autoconf)
 201 {
 202
 203         AutoConf *temp_autoconf = 0;
 204
 205         if(!autoconf)
 206         {
 207                 temp_autoconf = new AutoConf;
 208                 temp_autoconf->set_all();
 209                 autoconf = temp_autoconf;
 210         }
 211
 212 //printf("Automation::copy 1\n");
 213 // Always save these to save default
 214         if(mute_autos && autoconf->mute /* && mute_autos->total() */)
 215         {
 216                 file->tag.set_title("MUTEAUTOS");
 217                 file->append_tag();
 218                 file->append_newline();
 219                 mute_autos->copy(start,
 220                                                 end,
 221                                                 file,
 222                                                 default_only,
 223                                                 autos_only);
 224                 file->tag.set_title("/MUTEAUTOS");
 225                 file->append_tag();
 226                 file->append_newline();
 227         }
 228
 229 //printf("Automation::copy 1\n");
 230         if(fade_autos && autoconf->fade  /* && fade_autos->total() */)
 231         {
 232                 file->tag.set_title("FADEAUTOS");
 233                 file->append_tag();
 234                 file->append_newline();
 235                 fade_autos->copy(start,
 236                                                 end,
 237                                                 file,
 238                                                 default_only,
 239                                                 autos_only);
 240                 file->tag.set_title("/FADEAUTOS");
 241                 file->append_tag();
 242                 file->append_newline();
 243         }
 244
 245 //printf("Automation::copy 1\n");
 246         if(camera_autos && autoconf->camera )
 247         {
 248                 file->tag.set_title("CAMERAAUTOS");
 249                 file->append_tag();
 250                 file->append_newline();
 251                 camera_autos->copy(start,
 252                                                 end,
 253                                                 file,
 254                                                 default_only,
 255                                                 autos_only);
 256                 file->tag.set_title("/CAMERAAUTOS");
 257                 file->append_tag();
 258                 file->append_newline();
 259         }
 260
 261 //printf("Automation::copy 1\n");
 262         if(projector_autos && autoconf->projector )
 263         {
 264                 file->tag.set_title("PROJECTORAUTOS");
 265                 file->append_tag();
 266                 file->append_newline();
 267                 projector_autos->copy(start,
 268                                                 end,
 269                                                 file,
 270                                                 default_only,
 271                                                 autos_only);
 272                 file->tag.set_title("/PROJECTORAUTOS");
 273                 file->append_tag();
 274                 file->append_newline();
 275         }
 276
 277 //printf("Automation::copy 1\n");
 278         if(pan_autos && autoconf->pan )
 279         {
 280                 file->tag.set_title("PANAUTOS");
 281                 file->append_tag();
 282                 file->append_newline();
 283                 pan_autos->copy(start,
 284                                 end,
 285                                 file,
 286                                 default_only,
 287                                 autos_only);
 288                 file->append_newline();
 289                 file->tag.set_title("/PANAUTOS");
 290                 file->append_tag();
 291                 file->append_newline();
 292         }
 293
 294 //printf("Automation::copy 1\n");
 295         if(mode_autos && autoconf->mode)
 296         {
 297                 file->tag.set_title("MODEAUTOS");
 298                 file->append_tag();
 299                 file->append_newline();
 300                 mode_autos->copy(start,
 301                                 end,
 302                                 file,
 303                                 default_only,
 304                                 autos_only);
 305                 file->tag.set_title("/MODEAUTOS");
 306                 file->append_tag();
 307                 file->append_newline();
 308         }
 309
 310 //printf("Automation::copy 1\n");
 311         if(mask_autos && autoconf->mask)
 312         {
 313                 file->tag.set_title("MASKAUTOS");
 314                 file->append_tag();
 315                 file->append_newline();
 316                 mask_autos->copy(start,
 317                                 end,
 318                                 file,
 319                                 default_only,
 320                                 autos_only);
 321                 file->tag.set_title("/MASKAUTOS");
 322                 file->append_tag();
 323                 file->append_newline();
 324         }
 325
 326 //printf("Automation::copy 1\n");
 327         if(czoom_autos && autoconf->czoom)
 328         {
 329                 file->tag.set_title("CZOOMAUTOS");
 330                 file->append_tag();
 331                 file->append_newline();
 332                 czoom_autos->copy(start,
 333                                 end,
 334                                 file,
 335                                 default_only,
 336                                 autos_only);
 337                 file->tag.set_title("/CZOOMAUTOS");
 338                 file->append_tag();
 339                 file->append_newline();
 340         }
 341
 342 //printf("Automation::copy 1\n");
 343         if(pzoom_autos && autoconf->pzoom)
 344         {
 345                 file->tag.set_title("PZOOMAUTOS");
 346                 file->append_tag();
 347                 file->append_newline();
 348                 pzoom_autos->copy(start,
 349                                 end,
 350                                 file,
 351                                 default_only,
 352                                 autos_only);
 353                 file->tag.set_title("/PZOOMAUTOS");
 354                 file->append_tag();
 355                 file->append_newline();
 356         }
 357
 358         if (temp_autoconf)
 359                 delete temp_autoconf;
 360
 361 //printf("Automation::copy 100\n");
 362         return 0;
 363 }
 364
 365
 366 void Automation::clear(int64_t start,
 367         int64_t end,
 368         AutoConf *autoconf,
 369         int shift_autos)
 370 {
 371         AutoConf *temp_autoconf = 0;
 372
 373         if(!autoconf)
 374         {
 375                 temp_autoconf = new AutoConf;
 376                 temp_autoconf->set_all();
 377                 autoconf = temp_autoconf;
 378         }
 379
 380         if(autoconf->mute)
 381                 mute_autos->clear(start, end, shift_autos);
 382
 383         if(autoconf->fade)
 384                 fade_autos->clear(start, end, shift_autos);
 385
 386         if(camera_autos && autoconf->camera)
 387                 camera_autos->clear(start, end, shift_autos);
 388
 389         if(projector_autos && autoconf->projector)
 390                 projector_autos->clear(start, end, shift_autos);
 391
 392         if(pan_autos && autoconf->pan)
 393                 pan_autos->clear(start, end, shift_autos);
 394
 395         if(mode_autos && autoconf->mode)
 396                 mode_autos->clear(start, end, shift_autos);
 397
 398         if(mask_autos && autoconf->mask)
 399                 mask_autos->clear(start, end, shift_autos);
 400
 401         if(czoom_autos && autoconf->czoom)
 402                 czoom_autos->clear(start, end, shift_autos);
 403
 404         if(pzoom_autos && autoconf->pzoom)
 405                 pzoom_autos->clear(start, end, shift_autos);
 406
 407         if(temp_autoconf) delete temp_autoconf;
 408 }
 409
 410 void Automation::paste_silence(int64_t start, int64_t end)
 411 {
 412 // Unit conversion done in calling routine
 413         mute_autos->paste_silence(start, end);
 414         fade_autos->paste_silence(start, end);
 415
 416         if(camera_autos)
 417                 camera_autos->paste_silence(start, end);
 418         if(projector_autos)
 419                 projector_autos->paste_silence(start, end);
 420         if(pan_autos)
 421                 pan_autos->paste_silence(start, end);
 422         if(mode_autos)
 423                 mode_autos->paste_silence(start, end);
 424         if(mask_autos)
 425                 mask_autos->paste_silence(start, end);
 426         if(czoom_autos)
 427                 czoom_autos->paste_silence(start, end);
 428         if(pzoom_autos)
 429                 pzoom_autos->paste_silence(start, end);
 430 }
 431
 432 // We don't replace it in pasting but
 433 // when inserting the first EDL of a load operation we need to replace
 434 // the default keyframe.
 435 void Automation::insert_track(Automation *automation,
 436         int64_t start_unit,
 437         int64_t length_units,
 438         int replace_default)
 439 {
 440         mute_autos->insert_track(automation->mute_autos,
 441                 start_unit,
 442                 length_units,
 443                 replace_default);
 444         if(camera_autos)
 445                 camera_autos->insert_track(automation->camera_autos,
 446                 start_unit,
 447                 length_units,
 448                 replace_default);
 449         if(projector_autos) projector_autos->insert_track(automation->projector_autos,
 450                 start_unit,
 451                 length_units,
 452                 replace_default);
 453         if(fade_autos) fade_autos->insert_track(automation->fade_autos,
 454                 start_unit,
 455                 length_units,
 456                 replace_default);
 457         if(pan_autos) pan_autos->insert_track(automation->pan_autos,
 458                 start_unit,
 459                 length_units,
 460                 replace_default);
 461         if(mode_autos) mode_autos->insert_track(automation->mode_autos,
 462                 start_unit,
 463                 length_units,
 464                 replace_default);
 465         if(mask_autos) mask_autos->insert_track(automation->mask_autos,
 466                 start_unit,
 467                 length_units,
 468                 replace_default);
 469         if(czoom_autos) czoom_autos->insert_track(automation->czoom_autos,
 470                 start_unit,
 471                 length_units,
 472                 replace_default);
 473         if(pzoom_autos) pzoom_autos->insert_track(automation->pzoom_autos,
 474                 start_unit,
 475                 length_units,
 476                 replace_default);
 477 }
 478
 479 void Automation::resample(double old_rate, double new_rate)
 480 {
 481 // Run resample for all the autos structures and all the keyframes
 482         mute_autos->resample(old_rate, new_rate);
 483         if(camera_autos) camera_autos->resample(old_rate, new_rate);
 484         if(projector_autos) projector_autos->resample(old_rate, new_rate);
 485         if(fade_autos) fade_autos->resample(old_rate, new_rate);
 486         if(pan_autos) pan_autos->resample(old_rate, new_rate);
 487         if(mode_autos) mode_autos->resample(old_rate, new_rate);
 488         if(mask_autos) mask_autos->resample(old_rate, new_rate);
 489         if(czoom_autos) czoom_autos->resample(old_rate, new_rate);
 490         if(pzoom_autos) pzoom_autos->resample(old_rate, new_rate);
 491 }
 492
 493
 494
 495 int Automation::direct_copy_possible(int64_t start, int direction)
 496 {
 497         return 1;
 498 }
 499
 500
 501
 502 int64_t Automation::get_length()
 503 {
 504         int64_t length = 0;
 505         int64_t total_length = 0;
 506
 507         if(length > total_length) total_length = length;
 508
 509         if(mute_autos) length = mute_autos->get_length();
 510         if(length > total_length) total_length = length;
 511
 512         if(camera_autos) length = camera_autos->get_length();
 513         if(length > total_length) total_length = length;
 514
 515         if(projector_autos) length = projector_autos->get_length();
 516         if(length > total_length) total_length = length;
 517
 518         if(fade_autos) length = fade_autos->get_length();
 519         if(length > total_length) total_length = length;
 520
 521         if(pan_autos) length = pan_autos->get_length();
 522         if(length > total_length) total_length = length;
 523
 524         if(mode_autos) length = mode_autos->get_length();
 525         if(length > total_length) total_length = length;
 526
 527         if(mask_autos) length = mask_autos->get_length();
 528         if(length > total_length) total_length = length;
 529
 530         if(czoom_autos) length = czoom_autos->get_length();
 531         if(length > total_length) total_length = length;
 532
 533         if(pzoom_autos) length = pzoom_autos->get_length();
 534         if(length > total_length) total_length = length;
 535
 536         return total_length;
 537 }
 538
 539
 540
 541 void Automation::dump()
 542 {
 543         printf("   Automation: %p\n", this);
 544         printf("    mute_autos %p\n", mute_autos);
 545         mute_autos->dump();
 546
 547         if(fade_autos)
 548         {
 549                 printf("    fade_autos %p\n", fade_autos);
 550                 fade_autos->dump();
 551         }
 552
 553         if(pan_autos)
 554         {
 555                 printf("    pan_autos %p\n", pan_autos);
 556                 pan_autos->dump();
 557         }
 558
 559         if(camera_autos)
 560         {
 561                 printf("    camera_autos %p\n", camera_autos);
 562                 camera_autos->dump();
 563         }
 564
 565         if(projector_autos)
 566         {
 567                 printf("    projector_autos %p\n", projector_autos);
 568                 projector_autos->dump();
 569         }
 570
 571         if(mode_autos)
 572         {
 573                 printf("    mode_autos %p\n", mode_autos);
 574                 mode_autos->dump();
 575         }
 576
 577         if(mask_autos)
 578         {
 579                 printf("    mask_autos %p\n", mask_autos);
 580                 mask_autos->dump();
 581         }
 582
 583         if(czoom_autos)
 584         {
 585                 printf("    czoom_autos %p\n", czoom_autos);
 586                 czoom_autos->dump();
 587         }
 588
 589         if(pzoom_autos)
 590         {
 591                 printf("    pzoom_autos %p\n", pzoom_autos);
 592                 pzoom_autos->dump();
 593         }
 594 }