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