cinelerra-5.1/cinelerra/tracksedit.C

   1 /*
   2  * CINELERRA
   3  * Copyright (C) 2010 Adam Williams <broadcast at earthling dot net>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  */
  20
  21 #include "assets.h"
  22 #include "atrack.h"
  23 #include "automation.h"
  24 #include "aedits.h"
  25 #include "bcsignals.h"
  26 #include "edit.h"
  27 #include "edits.h"
  28 #include "edl.h"
  29 #include "edlsession.h"
  30 #include "filexml.h"
  31 #include "intauto.h"
  32 #include "intautos.h"
  33 #include "labels.h"
  34 #include "localsession.h"
  35 #include "mainundo.h"
  36 #include "module.h"
  37 #include "mainsession.h"
  38 #include "pluginserver.h"
  39 #include "pluginset.h"
  40 #include "plugin.h"
  41 #include "timebar.h"
  42 #include "trackcanvas.h"
  43 #include "tracks.h"
  44 #include "trackscroll.h"
  45 #include "transition.h"
  46 #include "transportque.h"
  47 #include "vtrack.h"
  48 #include <string.h>
  49
  50 int Tracks::blade(double position)
  51 {
  52         for( Track *track=first; track!=0; track=track->next ) {
  53                 if( !track->is_armed() ) continue;
  54                 track->blade(position);
  55         }
  56         return 0;
  57 }
  58
  59 int Tracks::clear(double start, double end, int clear_plugins, int edit_autos)
  60 {
  61         Track *current_track;
  62
  63         for(current_track = first;
  64                 current_track;
  65                 current_track = current_track->next)
  66         {
  67                 if(current_track->is_armed())
  68                 {
  69                         current_track->clear(start,
  70                                 end,
  71                                 1, // edits
  72                                 1, // labels
  73                                 clear_plugins, // edit_plugins
  74                                 edit_autos,
  75                                 0); // trim_edits
  76                 }
  77         }
  78         return 0;
  79 }
  80
  81 void Tracks::clear_automation(double selectionstart, double selectionend)
  82 {
  83         Track* current_track;
  84
  85         for(current_track = first; current_track; current_track = current_track->next)
  86         {
  87                 if(current_track->is_armed())
  88                 {
  89                         current_track->clear_automation(selectionstart,
  90                                 selectionend,
  91                                 0,
  92                                 0);
  93                 }
  94         }
  95 }
  96
  97 void Tracks::clear_transitions(double start, double end)
  98 {
  99         for(Track *current_track = first;
 100                 current_track;
 101                 current_track = current_track->next)
 102         {
 103                 if(current_track->is_armed())
 104                 {
 105                         int64_t start_units = current_track->to_units(start, 0);
 106                         int64_t end_units = current_track->to_units(end, 0);
 107
 108                         for(Edit *current_edit = current_track->edits->first;
 109                                 current_edit;
 110                                 current_edit = current_edit->next)
 111                         {
 112                                 if(current_edit->startproject >= start_units &&
 113                                         current_edit->startproject < end_units &&
 114                                         current_edit->transition)
 115                                 {
 116                                         current_edit->detach_transition();
 117                                 }
 118                         }
 119                 }
 120         }
 121 }
 122
 123 int Tracks::clear_hard_edges(double start, double end)
 124 {
 125         for( Track *track=first; track; track=track->next ) {
 126                 if( !track->is_armed() ) continue;
 127                 int64_t start_units = track->to_units(start, 0);
 128                 int64_t end_units = track->to_units(end, 0);
 129
 130                 for( Edit *edit=track->edits->first; edit; edit=edit->next ) {
 131                         int64_t pos = edit->startproject;
 132                         if( pos > end_units ) break;
 133                         if( pos >= start_units ) {
 134                                 edit->hard_left = 0;
 135                                 if( edit->previous )
 136                                         edit->previous->hard_right = 0;
 137                         }
 138                         pos += edit->length;
 139                         if( pos > end_units ) break;
 140                         if( pos >= start_units ) {
 141                                 edit->hard_right = 0;
 142                                 if( edit->next )
 143                                         edit->next->hard_left = 0;
 144                         }
 145                 }
 146         }
 147         return 0;
 148 }
 149
 150 void Tracks::shuffle_edits(double start, double end)
 151 {
 152 // This doesn't affect automation or effects
 153 // Labels follow the first track.
 154         int first_track = 1;
 155         for(Track *current_track = first;
 156                 current_track;
 157                 current_track = current_track->next)
 158         {
 159                 if(current_track->is_armed())
 160                 {
 161                         current_track->shuffle_edits(start, end, first_track);
 162
 163                         first_track = 0;
 164                 }
 165         }
 166 }
 167
 168 void Tracks::reverse_edits(double start, double end)
 169 {
 170 // This doesn't affect automation or effects
 171 // Labels follow the first track.
 172         int first_track = 1;
 173         for(Track *current_track = first;
 174                 current_track;
 175                 current_track = current_track->next)
 176         {
 177                 if(current_track->is_armed())
 178                 {
 179                         current_track->reverse_edits(start, end, first_track);
 180
 181                         first_track = 0;
 182                 }
 183         }
 184 }
 185
 186 void Tracks::align_edits(double start, double end)
 187 {
 188 // This doesn't affect automation or effects
 189         Track *master_track = 0;
 190         for( Track *track=first; track; track=track->next ) {
 191                 if( !track->is_armed() ) continue;
 192                 if( !master_track )
 193                         master_track = track;
 194                 else
 195                         track->align_edits(start, end, master_track);
 196         }
 197 }
 198
 199 void Tracks::set_edit_length(double start, double end, double length)
 200 {
 201         int first_track = 1;
 202         for(Track *current_track = first;
 203                 current_track;
 204                 current_track = current_track->next)
 205         {
 206                 if(current_track->is_armed())
 207                 {
 208 #define USE_FLOATING_LENGTHS
 209
 210 #ifdef USE_FLOATING_LENGTHS
 211
 212
 213 // The first edit anchors the length offsets.
 214 // Round edits up & down so they end where they would if they all had floating point lengths.
 215                         //int first_edit = 1;
 216                         int64_t start_units = current_track->to_units(start, 0);
 217                         int64_t end_units = current_track->to_units(end, 0);
 218 // Total time of edits accumulated, in track units
 219                         int64_t total_units = 0;
 220 // Number of length offsets added so far
 221                         int total_lengths = 0;
 222
 223                         for(Edit *current_edit = current_track->edits->last;
 224                                 current_edit;
 225                                 current_edit = current_edit->previous)
 226                         {
 227                                 if(current_edit->startproject >= start_units &&
 228                                         current_edit->startproject + current_edit->length <= end_units)
 229                                 {
 230 // Calculate true length based on number of length offsets & total time
 231                                         double end_time = (1 + total_lengths) * length;
 232                                         int64_t length_units = current_track->to_units(end_time, 0) -
 233                                                 total_units;
 234                                         if(length_units < 1) length_units = 1;
 235 //printf("Tracks::set_edit_length %d %f %f\n", __LINE__,
 236 // end_time, current_track->from_units(total_units));
 237                                         total_units += length_units;
 238
 239 // Go in using the edit handle interface
 240                                         int64_t starting_length = current_edit->length;
 241
 242                                         current_edit->shift_end(MOVE_RIPPLE,
 243                                                 current_edit->startproject + length_units,
 244                                                 current_edit->startproject + current_edit->length,
 245                                                 0,
 246                                                 edl->session->autos_follow_edits,
 247                                                 edl->session->plugins_follow_edits,
 248                                                 0);
 249
 250                                         int64_t ending_length = current_edit->length;
 251
 252                                         if(edl->session->labels_follow_edits && first_track)
 253                                         {
 254 // printf("Tracks::set_edit_length %d %f %f\n",
 255 // __LINE__,
 256 // current_track->from_units(current_edit->startproject + starting_length),
 257 // current_track->from_units(current_edit->startproject + ending_length));
 258                                                  edl->labels->modify_handles(
 259                                                         current_track->from_units(current_edit->startproject + starting_length),
 260                                                         current_track->from_units(current_edit->startproject + ending_length),
 261                                                         1);
 262                                         }
 263
 264
 265                                         //first_edit = 0;
 266                                         total_lengths++;
 267                                 }
 268                         }
 269
 270
 271
 272 #else // USE_FLOATING_LENGTHS
 273
 274 // The first edit anchors the length offsets.
 275 // The idea was to round edits up & down so they end where they should
 276 // if they all had floating point lengths.  It's easier just to make sure the framerate
 277 // is divisible by the required length.
 278 //                      int first_edit = 1;
 279                         int64_t start_units = current_track->to_units(start, 0);
 280                         int64_t end_units = current_track->to_units(end, 0);
 281                         int64_t length_units = current_track->to_units(length, 1);
 282 // Starting time of the length offsets in seconds
 283 //                      double start_time = 0;
 284 // Number of length offsets added so far
 285 //                      int total_lengths = 0;
 286
 287                         for(Edit *current_edit = current_track->edits->last;
 288                                 current_edit;
 289                                 current_edit = current_edit->previous)
 290                         {
 291                                 if(current_edit->startproject >= start_units &&
 292                                         current_edit->startproject + current_edit->length <= end_units)
 293                                 {
 294 // Calculate starting time of length offsets
 295 //                                      if(first_edit)
 296 //                                      {
 297 //                                              start_time = current_track->from_units(current_edit->startproject);
 298 //                                      }
 299
 300 // Calculate true length based on number of length offsets
 301 //                                      double end_time = start_time + (1 + total_lengths) * length;
 302 //                                      int64_t length_units = current_track->to_units(end_time, 0) -
 303 //                                              current_edit->startproject;
 304 //                                      if(length_units < 1) length_units = 1;
 305
 306 // Go in using the edit handle interface
 307                                         int64_t starting_length = current_edit->length;
 308
 309                                         current_edit->shift_end(MOVE_RIPPLE,
 310                                                 current_edit->startproject + length_units,
 311                                                 current_edit->startproject + current_edit->length,
 312                                                 0,
 313                                                 edl->session->autos_follow_edits,
 314                                                 edl->session->plugins_follow_edits,
 315                                                 0);
 316
 317                                         int64_t ending_length = current_edit->length;
 318
 319                                         if(edl->session->labels_follow_edits && first_track) {
 320 // printf("Tracks::set_edit_length %d %f %f\n", __LINE__,
 321 // current_track->from_units(current_edit->startproject + starting_length),
 322 // current_track->from_units(current_edit->startproject + ending_length));
 323                                                  edl->labels->modify_handles(
 324                                                         current_track->from_units(current_edit->startproject + starting_length),
 325                                                         current_track->from_units(current_edit->startproject + ending_length),
 326                                                         1);
 327                                         }
 328
 329
 330 //                                      first_edit = 0;
 331 //                                      total_lengths++;
 332                                 }
 333                         }
 334 #endif // !USE_FLOATING_LENGTHS
 335
 336                         first_track = 0;
 337                 }
 338         }
 339 }
 340
 341 void Tracks::set_transition_length(double start, double end, double length)
 342 {
 343         for(Track *current_track = first;
 344                 current_track;
 345                 current_track = current_track->next)
 346         {
 347                 if(current_track->is_armed())
 348                 {
 349                         int64_t start_units = current_track->to_units(start, 0);
 350                         int64_t end_units = current_track->to_units(end, 0);
 351
 352                         for(Edit *current_edit = current_track->edits->first;
 353                                 current_edit;
 354                                 current_edit = current_edit->next)
 355                         {
 356                                 if(current_edit->startproject >= start_units &&
 357                                         current_edit->startproject < end_units &&
 358                                         current_edit->transition)
 359                                 {
 360                                         current_edit->transition->length =
 361                                                 current_track->to_units(length, 1);
 362                                         if( current_edit == current_track->edits->last &&
 363                                             current_edit->silence() ) {
 364                                                 current_edit->length = current_edit->transition->length;
 365                                         }
 366                                 }
 367                         }
 368                 }
 369         }
 370 }
 371
 372 void Tracks::set_transition_length(Transition *transition, double length)
 373 {
 374 // Must verify existence of transition
 375         int found = 0;
 376         if( !transition ) return;
 377         for( Track *track=first; track && !found; track=track->next ) {
 378                 for( Edit *edit=track->edits->first; edit && !found; edit = edit->next ) {
 379                         if( edit->transition == transition ) {
 380                                 transition->length = track->to_units(length, 1);
 381                                 if( edit == track->edits->last && edit->silence() ) {
 382                                         edit->length = edit->transition->length;
 383                                 }
 384                                 found = 1;
 385                         }
 386                 }
 387         }
 388         if( !found ) return;
 389         if( edl->session->gang_tracks == GANG_NONE ) return;
 390         Track *track = transition->edit->track;
 391         double pos = track->from_units(transition->edit->startproject);
 392         Track *current = edl->tracks->first;
 393         for( ; current; current=current->next ) {
 394                 if( current == track ) continue;
 395                 if( current->data_type != track->data_type ) continue;
 396                 if( !current->armed_gang(track) ) continue;
 397                 int64_t track_pos = current->to_units(pos, 1);
 398                 Edit *edit = current->edits->editof(track_pos, PLAY_FORWARD, 0);
 399                 if( !edit || !edit->transition ) continue;
 400                 double edit_pos = track->from_units(edit->startproject);
 401                 if( !edl->equivalent(pos, edit_pos) ) continue;
 402 // modify gang same transitions at same position
 403                 if( edit->transition->Plugin::identical(transition) ) {
 404                         edit->transition->length = transition->length;
 405                 }
 406                 if( edit == track->edits->last && edit->silence() ) {
 407                         edit->length = edit->transition->length;
 408                 }
 409         }
 410 }
 411
 412 void Tracks::paste_transitions(double start, double end, int track_type, char* title)
 413 {
 414         int count = 0;
 415         for( Track *track=first; track; track=track->next ) {
 416                 if( !track->is_armed() || track->data_type != track_type ) continue;
 417                 for( Edit *edit=track->edits->first;  edit; edit=edit->next ) {
 418                         if( !edit->is_selected ) continue;
 419                         edit->insert_transition(title);
 420                         ++count;
 421                 }
 422         }
 423         if( count > 0 ) {
 424                 clear_selected_edits();
 425                 return;
 426         }
 427
 428         for( Track *track=first; track; track=track->next ) {
 429                 if( !track->is_armed() || track->data_type != track_type ) continue;
 430                 int64_t start_units = track->to_units(start, 0);
 431                 int64_t end_units = track->to_units(end, 0);
 432                 if( start_units == end_units ) {
 433                         for( Edit *edit = track->edits->first; edit; edit = edit->next) {
 434                                 int64_t edit_start = edit->startproject;
 435                                 int64_t edit_end = edit_start + edit->length;
 436                                 if( edit_start > start_units ) continue;
 437                                 if( start_units == track->edits->length() ) {
 438                                         double length = edl->session->default_transition_length;
 439                                         int64_t units = track->to_units(length, 1);
 440                                         edit = track->edits->
 441                                                 create_silence(start_units, start_units+units);
 442                                 }
 443                                 else if( start_units >= edit_end ) continue;
 444                                 edit->insert_transition(title);
 445                         }
 446                 }
 447                 else {
 448                         for( Edit *edit=track->edits->first; edit; edit=edit->next) {
 449                                 int64_t edit_start = edit->startproject;
 450                                 if( !edit_start ) continue;
 451                                 if( edit_start >= start_units && edit_start < end_units ) {
 452                                         edit->insert_transition(title);
 453                                 }
 454                         }
 455                 }
 456         }
 457 }
 458
 459 void Tracks::set_automation_mode(double selectionstart,
 460         double selectionend,
 461         int mode)
 462 {
 463         Track* current_track;
 464
 465         for(current_track = first; current_track; current_track = current_track->next)
 466         {
 467                 if(current_track->is_armed())
 468                 {
 469                         current_track->set_automation_mode(selectionstart,
 470                                 selectionend,
 471                                 mode);
 472                 }
 473         }
 474 }
 475
 476 int Tracks::clear_default_keyframe()
 477 {
 478         for(Track *current = first; current; current = NEXT)
 479         {
 480                 if(current->is_armed())
 481                         current->clear_automation(0, 0, 0, 1);
 482         }
 483         return 0;
 484 }
 485
 486 int Tracks::clear_handle(double start,
 487         double end,
 488         double &longest_distance,
 489         int clear_labels,
 490         int clear_plugins,
 491         int edit_autos)
 492 {
 493         Track* current_track;
 494         double distance;
 495
 496         for(current_track = first; current_track; current_track = current_track->next)
 497         {
 498                 if(current_track->is_armed())
 499                 {
 500                         current_track->clear_handle(start,
 501                                 end,
 502                                 clear_labels,
 503                                 clear_plugins,
 504                                 edit_autos,
 505                                 distance);
 506                         if(distance > longest_distance) longest_distance = distance;
 507                 }
 508         }
 509
 510         return 0;
 511 }
 512
 513 int Tracks::copy_automation(double selectionstart,
 514         double selectionend,
 515         FileXML *file,
 516         int default_only,
 517         int autos_only)
 518 {
 519 // called by MWindow::copy_automation for copying automation alone
 520         Track* current_track;
 521
 522         file->tag.set_title("AUTO_CLIPBOARD");
 523         file->tag.set_property("LENGTH", selectionend - selectionstart);
 524         file->tag.set_property("FRAMERATE", edl->session->frame_rate);
 525         file->tag.set_property("SAMPLERATE", edl->session->sample_rate);
 526         file->append_tag();
 527         file->append_newline();
 528         file->append_newline();
 529
 530         for(current_track = first;
 531                 current_track;
 532                 current_track = current_track->next)
 533         {
 534                 if(current_track->is_armed())
 535                 {
 536                         current_track->copy_automation(selectionstart,
 537                                 selectionend,
 538                                 file,
 539                                 default_only,
 540                                 autos_only);
 541                 }
 542         }
 543
 544         file->tag.set_title("/AUTO_CLIPBOARD");
 545         file->append_tag();
 546         file->append_newline();
 547         file->terminate_string();
 548         return 0;
 549 }
 550
 551 // int Tracks::copy_default_keyframe(FileXML *file)
 552 // {
 553 //      copy_automation(0, 0, file, 1, 0);
 554 //      return 0;
 555 // }
 556
 557 int Tracks::delete_tracks()
 558 {
 559         int total_deleted = 0;
 560         int done = 0;
 561         int gang = edl->session->gang_tracks != GANG_NONE ? 1 : 0;
 562
 563         while( !done ) {
 564                 done = 1;
 565                 for( Track* track=first, *nxt=0; done && track; track=nxt ) {
 566                         nxt = track->next;
 567                         if( gang ) {
 568                                 while( nxt && !nxt->master ) nxt = nxt->next;
 569                         }
 570                         if( !track->is_armed() ) continue;
 571                         delete_track(track);
 572                         ++total_deleted;
 573                 }
 574         }
 575         return total_deleted;
 576 }
 577
 578 void Tracks::move_edits(ArrayList<Edit*> *in_edits, Track *track, double position,
 579         int edit_labels, int edit_plugins, int edit_autos, int mode)
 580 {
 581 // have to make a copy, optimize kills edits
 582         ArrayList<Edit*> edits;
 583         for( int i=0; i<in_edits->size(); ++i ) {
 584                 Edit *edit = in_edits->get(i);
 585                 Edit *new_edit = new Edit(edit->edl, edit->track);
 586                 new_edit->copy_from(edit);
 587                 edits.append(new_edit);
 588         }
 589
 590         int current_aedit = 0, current_vedit = 0;
 591 //printf("Tracks::move_edits 1\n");
 592         for( Track *dest_track=track; dest_track; dest_track=dest_track->next ) {
 593                 if( !dest_track->is_armed() ) continue;
 594 // Need a local copy of the source edit since the original source edit may
 595 // change in the editing operation.
 596 // Get source edit
 597                 Edit *source_edit = 0;
 598                 Track *clip_track = 0;
 599                 switch( dest_track->data_type ) {
 600                 case TRACK_AUDIO: {
 601                         while( current_aedit < edits.size() ) {
 602                                 Edit *edit = edits[current_aedit++];
 603                                 if( edit->track->data_type == TRACK_AUDIO ) {
 604                                         source_edit = edit;
 605                                         ATrack *atrack = new ATrack(dest_track->edl, 0);
 606                                         atrack->create_objects();
 607                                         clip_track = atrack;
 608                                         break;
 609                                 }
 610                         }
 611                         break; }
 612                 case TRACK_VIDEO: {
 613                         while( current_vedit < edits.size() ) {
 614                                 Edit *edit = edits[current_vedit++];
 615                                 if( edit->track->data_type == TRACK_VIDEO ) {
 616                                         source_edit = edit;
 617                                         VTrack *vtrack = new VTrack(dest_track->edl, 0);
 618                                         vtrack->create_objects();
 619                                         clip_track = vtrack;
 620                                         break;
 621                                 }
 622                         }
 623                         break; }
 624                 }
 625                 if( !source_edit ) continue;
 626
 627                 Track *source_track = source_edit->track;
 628                 int64_t start = source_edit->startproject;
 629                 int64_t length = source_edit->length, end = start + length;
 630                 double source_start = source_track->from_units(start);
 631                 double source_end = source_track->from_units(start+length);
 632                 double len = source_end - source_start;
 633                 double dest_start = position;
 634                 double dest_end = dest_start + len;
 635
 636                 if( edit_labels && dest_track == track ) {
 637                         FileXML label_xml;
 638                         Labels labels(0, "LABELS");
 639                         source_edit->edl->labels->copy(source_start, source_end, &label_xml);
 640                         source_edit->edl->labels->clear(source_start, source_end, mode);
 641                         if( !label_xml.read_tag() )
 642                                 labels.load(&label_xml, LOAD_ALL);
 643                         double pos = dest_start;
 644                         if( mode && source_start < dest_start ) pos -= len;
 645                         edl->labels->insert_labels(&labels, pos, len, mode);
 646                         edit_labels = 0;
 647                 }
 648
 649                 FileXML track_xml;
 650                 source_track->copy(COPY_TRACKS, source_start, source_end, &track_xml, "");
 651                 if( !track_xml.read_tag() )
 652                         clip_track->load(&track_xml, 0, LOAD_ALL);
 653
 654                 if( !mode ) { // mute and overwrite
 655                         source_track->clear(start, end, 1, 0,
 656                                 edit_plugins, edit_autos, 0);
 657                         source_track->edits->paste_silence(start, end);
 658                         if( edit_autos )
 659                                 source_track->shift_keyframes(start, length);
 660                         if( edit_plugins ) {
 661                                 int n = source_track->plugin_set.size();
 662                                 if( n > 0 ) dest_track->expand_view = 1;
 663                                 for( int k=0; k<n; ++k )
 664                                         source_track->plugin_set[k]->paste_silence(start, end, 1);
 665                         }
 666                         dest_track->clear(dest_start, dest_end, 1, 0,
 667                                 edit_plugins, edit_autos, 0);
 668                         dest_track->insert_track(clip_track, dest_start, 0,
 669                                 edit_plugins, edit_autos, len);
 670                 }
 671                 else { // cut and paste
 672                         dest_track->insert_track(clip_track, dest_start, 0,
 673                                 edit_plugins, edit_autos, len);
 674                         if( source_track == dest_track && dest_start < source_start ) {
 675                                 source_start += len;   source_end += len;
 676                         }
 677                         source_track->clear(source_start, source_end, 1, 0,
 678                                 edit_plugins, edit_autos, 0);
 679                 }
 680
 681                 delete clip_track;
 682                 dest_track->optimize();
 683         }
 684
 685         edits.remove_all_objects();
 686 }
 687
 688 void Tracks::move_effect(Plugin *plugin, Track *track, int64_t position)
 689 {
 690         Track *source_track = plugin->track;
 691         Plugin *result = 0;
 692 // Create a new plugin set
 693         double start = track->from_units(position);
 694         double length = track->from_units(plugin->length);
 695
 696         result = track->insert_effect("", &plugin->shared_location, 0, 0,
 697                                 start, length, plugin->plugin_type);
 698         result->copy_from(plugin);
 699         result->shift(position - plugin->startproject);
 700
 701 // Clear new plugin from old set
 702         plugin->plugin_set->clear(plugin->startproject,
 703                 plugin->startproject + plugin->length,
 704                 edl->session->autos_follow_edits);
 705
 706         source_track->optimize();
 707 }
 708
 709 void Tracks::move_effect(Plugin *plugin, PluginSet *plugin_set, int64_t position)
 710 {
 711 // src/dest track must be the same
 712 // replace plugin in source plugin_set with silence
 713         PluginSet *src_plugin_set = plugin->plugin_set;
 714         Plugin *silent = new Plugin(edl, src_plugin_set, "");
 715         silent->startproject = plugin->startproject;
 716         silent->length = plugin->length;
 717         src_plugin_set->insert_after(plugin, silent);
 718         src_plugin_set->remove_pointer(plugin);
 719 // truncate previous plugin
 720         Plugin *dest = (Plugin *)plugin_set->editof(position, PLAY_FORWARD, 0);
 721 // add plugin after dest
 722         plugin_set->insert_after(dest, plugin);
 723         if( dest ) {
 724                 dest->length = position - dest->startproject;
 725                 if( dest->length < 0 ) dest->length = 0;
 726         }
 727 // update plugin position
 728         plugin->startproject = position;
 729         plugin->plugin_set = plugin_set;
 730         plugin->edits = plugin_set;
 731         src_plugin_set->track->optimize();
 732 }
 733
 734 int Tracks::concatenate_tracks(int edit_plugins, int edit_autos)
 735 {
 736         Track *output_track, *first_output_track, *input_track;
 737         int i, data_type = TRACK_AUDIO;
 738         double output_start;
 739         int result = 0;
 740
 741 // Relocate tracks
 742         for(i = 0; i < 2; i++)
 743         {
 744 // Get first output track
 745                 for(output_track = first;
 746                         output_track;
 747                         output_track = output_track->next)
 748                         if(output_track->data_type == data_type &&
 749                                 output_track->is_armed()) break;
 750
 751                 first_output_track = output_track;
 752
 753 // Get first input track
 754                 for(input_track = first;
 755                         input_track;
 756                         input_track = input_track->next)
 757                 {
 758                         if(input_track->data_type == data_type &&
 759                                 input_track->play &&
 760                                 !input_track->is_armed()) break;
 761                 }
 762
 763
 764                 if(output_track && input_track)
 765                 {
 766 // Transfer input track to end of output track one at a time
 767                         while(input_track)
 768                         {
 769                                 output_start = output_track->get_length();
 770                                 output_track->insert_track(input_track,
 771                                         output_start,
 772                                         0,
 773                                         edit_plugins,
 774                                         edit_autos,
 775                                         0);
 776
 777 // Get next source and destination
 778                                 for(input_track = input_track->next;
 779                                         input_track;
 780                                         input_track = input_track->next)
 781                                 {
 782
 783                                         if(input_track->data_type == data_type &&
 784                                                 !input_track->is_armed() &&
 785                                                 input_track->play) break;
 786                                 }
 787
 788                                 for(output_track = output_track->next;
 789                                         output_track;
 790                                         output_track = output_track->next)
 791                                 {
 792                                         if(output_track->data_type == data_type &&
 793                                                 output_track->is_armed()) break;
 794                                 }
 795
 796                                 if(!output_track)
 797                                 {
 798                                         output_track = first_output_track;
 799                                 }
 800                         }
 801                         result = 1;
 802                 }
 803
 804                 if(data_type == TRACK_AUDIO) data_type = TRACK_VIDEO;
 805         }
 806
 807         return result;
 808 }
 809
 810 int Tracks::delete_all_tracks()
 811 {
 812         while(last) delete last;
 813         return 0;
 814 }
 815
 816
 817 void Tracks::change_modules(int old_location, int new_location, int do_swap)
 818 {
 819         for(Track* current = first ; current; current = current->next)
 820         {
 821                 current->change_modules(old_location, new_location, do_swap);
 822         }
 823 }
 824
 825 void Tracks::change_plugins(SharedLocation &old_location, SharedLocation &new_location, int do_swap)
 826 {
 827         for(Track* current = first ; current; current = current->next)
 828         {
 829                 current->change_plugins(old_location, new_location, do_swap);
 830         }
 831 }
 832
 833
 834
 835 // =========================================== EDL editing
 836
 837
 838 int Tracks::copy(int copy_flags, double start, double end,
 839                 FileXML *file, const char *output_path)
 840 {
 841         int all = (copy_flags & COPY_ALL) ? 1 : 0;
 842 // if nothing selected
 843         if( start == end && !all ) return 1;
 844         for( Track *track=first; track; track=track->next ) {
 845                 if( track->is_armed() || all )
 846                         track->copy(copy_flags, start, end, file, output_path);
 847         }
 848         return 0;
 849 }
 850
 851
 852
 853 int Tracks::move_track_up(Track *track)
 854 {
 855         if( first == last ) return 1;
 856         int n = 1;
 857         Track *src = track, *dst = src->previous;
 858         if( edl->session->gang_tracks != GANG_NONE ) {
 859                 while( src && !src->master ) src = src->previous;
 860                 if( !src ) src = first;
 861                 Track *nxt = src->next;
 862                 while( nxt && !nxt->master ) { ++n;  nxt = nxt->next; }
 863                 dst = src->previous;
 864                 while( dst && !dst->master ) { dst = dst->previous; }
 865         }
 866         if( src == dst ) return 1;
 867         move_tracks(src, dst, n);
 868         return 0;
 869 }
 870
 871 int Tracks::move_track_down(Track *track)
 872 {
 873         if( first == last ) return 1;
 874         int n = 1;
 875         Track *src = track, *dst = src->next;
 876         if( edl->session->gang_tracks != GANG_NONE ) {
 877                 while( src && !src->master ) src = src->previous;
 878                 if( !src ) src = first;
 879                 Track *nxt = src->next;
 880                 while( nxt && !nxt->master ) { ++n;  nxt = nxt->next; }
 881                 if( nxt ) {
 882                         nxt = nxt->next;
 883                         while( nxt && !nxt->master ) { nxt = nxt->next; }
 884                 }
 885                 else
 886                         nxt = first;
 887                 dst = nxt;
 888         }
 889         else
 890                 dst = !dst ? first : dst->next;
 891         if( src == dst ) return 1;
 892         move_tracks(src, dst, n);
 893         return 0;
 894 }
 895
 896
 897 int Tracks::move_tracks_up()
 898 {
 899         if( first == last ) return 1;
 900         int n = 1;
 901         Track *src = first, *dst = 0;
 902         if( edl->session->gang_tracks != GANG_NONE ) {
 903                 Track *nxt = src->next;
 904                 while( nxt && !nxt->master ) { ++n;  nxt = nxt->next; }
 905         }
 906         if( src == dst ) return 1;
 907         move_tracks(src, dst, n);
 908         return 0;
 909 }
 910
 911 int Tracks::move_tracks_down()
 912 {
 913         if( first == last ) return 1;
 914         int n = 1;
 915         Track *src = last, *dst = first;
 916         if( edl->session->gang_tracks != GANG_NONE ) {
 917                 while( src && !src->master ) { ++n;  src = src->previous; }
 918         }
 919         if( src == dst ) return 1;
 920         move_tracks(src, dst, n);
 921         return 0;
 922 }
 923
 924
 925 int Tracks::swap_track_up(Track *track)
 926 {
 927         Track *next_track = track->previous;
 928         if(!next_track) next_track = last;
 929
 930         change_modules(number_of(track), number_of(next_track), 1);
 931         swap(track, next_track);
 932         return 0;
 933 }
 934
 935 int Tracks::swap_track_down(Track *track)
 936 {
 937         Track *next_track = track->next;
 938         if(!next_track) next_track = first;
 939
 940         change_modules(number_of(track), number_of(next_track), 1);
 941         swap(track, next_track);
 942         return 0;
 943 }
 944
 945
 946 int Tracks::swap_tracks_up()
 947 {
 948         int result = 0;
 949         Track *next = first;
 950         while( next ) {
 951                 Track *track = next;  next = track->next;
 952                 if( !track->armed ) continue;
 953                 if( track->previous ) {
 954                         change_modules(number_of(track->previous), number_of(track), 1);
 955                         swap(track->previous, track);
 956                         result = 1;
 957                 }
 958         }
 959
 960         return result;
 961 }
 962
 963 int Tracks::swap_tracks_down()
 964 {
 965         int result = 0;
 966         Track *prev = last;
 967         while( prev ) {
 968                 Track *track = prev;  prev = track->previous;
 969                 if( !track->armed ) continue;
 970                 if( track->next ) {
 971                         change_modules(number_of(track), number_of(track->next), 1);
 972                         swap(track, track->next);
 973                         result = 1;
 974                 }
 975         }
 976
 977         return result;
 978 }
 979
 980 void Tracks::paste_audio_transition(PluginServer *server)
 981 {
 982         for(Track *current = first; current; current = NEXT)
 983         {
 984                 if(current->data_type == TRACK_AUDIO &&
 985                         current->is_armed())
 986                 {
 987                         int64_t position = current->to_units(
 988                                 edl->local_session->get_selectionstart(), 0);
 989                         Edit *current_edit = current->edits->editof(position,
 990                                 PLAY_FORWARD,
 991                                 0);
 992                         if( !current_edit && position == current->edits->length() ) {
 993                                 double length = edl->session->default_transition_length;
 994                                 int64_t units = current->to_units(length, 1);
 995                                 current_edit = current->edits->create_silence(position, position+units);
 996                         }
 997                         if(current_edit)
 998                         {
 999                                 paste_transition(server, current_edit);
1000                         }
1001                 }
1002         }
1003 }
1004
1005 void Tracks::paste_automation(double selectionstart,
1006         FileXML *file,
1007         int default_only,
1008         int active_only,
1009         int typeless)
1010 {
1011         Track* current_track = 0;
1012         Track* current_atrack = 0;
1013         Track* current_vtrack = 0;
1014         Track* dst_track = 0;
1015         int src_type;
1016         int result = 0;
1017         double length;
1018         double frame_rate = edl->session->frame_rate;
1019         int64_t sample_rate = edl->session->sample_rate;
1020         char string[BCTEXTLEN];
1021         string[0] = 0;
1022
1023 // Search for start
1024         do{
1025           result = file->read_tag();
1026         }while(!result &&
1027                 !file->tag.title_is("AUTO_CLIPBOARD"));
1028
1029         if(!result)
1030         {
1031                 length = file->tag.get_property("LENGTH", 0);
1032                 frame_rate = file->tag.get_property("FRAMERATE", frame_rate);
1033                 sample_rate = file->tag.get_property("SAMPLERATE", sample_rate);
1034
1035
1036                 do
1037                 {
1038                         result = file->read_tag();
1039
1040                         if(!result)
1041                         {
1042                                 if(file->tag.title_is("/AUTO_CLIPBOARD"))
1043                                 {
1044                                         result = 1;
1045                                 }
1046                                 else
1047                                 if(file->tag.title_is("TRACK"))
1048                                 {
1049                                         file->tag.get_property("TYPE", string);
1050                                         if(!strcmp(string, "AUDIO"))
1051                                         {
1052                                                 src_type = TRACK_AUDIO;
1053                                         }
1054                                         else
1055                                         {
1056                                                 src_type = TRACK_VIDEO;
1057                                         }
1058
1059 // paste to any media type
1060                                         if(typeless)
1061                                         {
1062                                                 if(!current_track) current_track = first;
1063                                                 while(current_track && !current_track->is_armed())
1064                                                         current_track = current_track->next;
1065                                                 dst_track = current_track;
1066                                         }
1067                                         else
1068                                         if(!strcmp(string, "AUDIO"))
1069                                         {
1070 // Get next audio track
1071                                                 if(!current_atrack)
1072                                                         current_atrack = first;
1073                                                 else
1074                                                         current_atrack = current_atrack->next;
1075
1076                                                 while(current_atrack &&
1077                                                         (current_atrack->data_type != TRACK_AUDIO ||
1078                                                         !current_atrack->is_armed()))
1079                                                         current_atrack = current_atrack->next;
1080                                                 dst_track = current_atrack;
1081                                         }
1082                                         else
1083                                         {
1084 // Get next video track
1085                                                 if(!current_vtrack)
1086                                                         current_vtrack = first;
1087                                                 else
1088                                                         current_vtrack = current_vtrack->next;
1089
1090                                                 while(current_vtrack &&
1091                                                         (current_vtrack->data_type != TRACK_VIDEO ||
1092                                                         !current_vtrack->is_armed()))
1093                                                         current_vtrack = current_vtrack->next;
1094
1095                                                 dst_track = current_vtrack;
1096                                         }
1097
1098                                         if(dst_track)
1099                                         {
1100                                                 double frame_rate2 = frame_rate;
1101                                                 double sample_rate2 = sample_rate;
1102
1103                                                 if(src_type != dst_track->data_type)
1104                                                 {
1105                                                         frame_rate2 = sample_rate;
1106                                                         sample_rate2 = frame_rate;
1107                                                 }
1108
1109                                                 dst_track->paste_automation(selectionstart,
1110                                                         length,
1111                                                         frame_rate2,
1112                                                         sample_rate2,
1113                                                         file,
1114                                                         default_only,
1115                                                         active_only);
1116                                         }
1117                                 }
1118                         }
1119                 }while(!result);
1120         }
1121 }
1122
1123 // int Tracks::paste_default_keyframe(FileXML *file)
1124 // {
1125 //      paste_automation(0, file, 1, 0);
1126 //      return 0;
1127 // }
1128
1129 void Tracks::paste_transition(PluginServer *server, Edit *dest_edit)
1130 {
1131         dest_edit->insert_transition(server->title);
1132         if( edl->session->gang_tracks == GANG_NONE ) return;
1133         Track *track = dest_edit->track;
1134         double pos = track->from_units(dest_edit->startproject);
1135         for( Track *current=first; current; current=current->next ) {
1136                 if( current == track ) continue;
1137                 if( current->data_type != track->data_type ) continue;
1138                 if( !current->armed_gang(track) ) continue;
1139                 int64_t track_pos = current->to_units(pos, 1);
1140                 Edit *edit = current->edits->editof(track_pos, PLAY_FORWARD, 0);
1141                 if( !edit ) continue;
1142                 double edit_pos = track->from_units(edit->startproject);
1143                 if( !edl->equivalent(pos, edit_pos) ) continue;
1144                 edit->insert_transition(server->title);
1145         }
1146 }
1147
1148 void Tracks::paste_video_transition(PluginServer *server, int first_track)
1149 {
1150         for(Track *current = first; current; current = NEXT)
1151         {
1152                 if(current->data_type == TRACK_VIDEO &&
1153                         current->is_armed())
1154                 {
1155                         int64_t position = current->to_units(
1156                                 edl->local_session->get_selectionstart(), 0);
1157                         Edit *current_edit = current->edits->editof(position,
1158                                 PLAY_FORWARD,
1159                                 0);
1160                         if( !current_edit && position == current->edits->length() ) {
1161                                 double length = edl->session->default_transition_length;
1162                                 int64_t units = current->to_units(length, 1);
1163                                 current_edit = current->edits->create_silence(position, position+units);
1164                         }
1165                         if(current_edit)
1166                         {
1167                                 paste_transition(server, current_edit);
1168                         }
1169                         if(first_track) break;
1170                 }
1171         }
1172 }
1173
1174
1175 int Tracks::paste_silence(double start,
1176         double end,
1177         int edit_plugins,
1178         int edit_autos)
1179 {
1180         Track* current_track;
1181
1182         for(current_track = first;
1183                 current_track;
1184                 current_track = current_track->next)
1185         {
1186                 if(current_track->is_armed())
1187                 {
1188                         current_track->paste_silence(start,
1189                                 end,
1190                                 edit_plugins,
1191                                 edit_autos);
1192                 }
1193         }
1194         return 0;
1195 }
1196
1197
1198
1199 int Tracks::select_auto(int cursor_x, int cursor_y)
1200 {
1201         int result = 0;
1202         for(Track* current = first; current && !result; current = NEXT) { result = current->select_auto(&auto_conf, cursor_x, cursor_y); }
1203         return result;
1204 }
1205
1206 int Tracks::move_auto(int cursor_x, int cursor_y, int shift_down)
1207 {
1208         int result = 0;
1209
1210         for(Track* current = first; current && !result; current = NEXT)
1211         {
1212                 result = current->move_auto(&auto_conf, cursor_x, cursor_y, shift_down);
1213         }
1214         return 0;
1215 }
1216
1217 int Tracks::modify_edithandles(double &oldposition, double &newposition,
1218         int currentend, int handle_mode, int edit_labels,
1219         int edit_plugins, int edit_autos, int group_id)
1220 {
1221         for( Track *track=first; track; track=track->next ) {
1222                 if( !track->is_armed() ) continue;
1223                 track->modify_edithandles(oldposition, newposition,
1224                         currentend, handle_mode, edit_labels,
1225                         edit_plugins, edit_autos, group_id);
1226 // labels follow first armed track
1227                 edit_labels = 0;
1228         }
1229         return 0;
1230 }
1231
1232 int Tracks::modify_pluginhandles(double &oldposition, double &newposition,
1233         int currentend, int handle_mode, int edit_labels,
1234         int edit_autos, Edits *trim_edits)
1235 {
1236         for( Track *track=first; track; track=track->next ) {
1237                 if( !track->is_armed() ) continue;
1238                 track->modify_pluginhandles(oldposition, newposition,
1239                         currentend, handle_mode, edit_labels,
1240                         edit_autos, trim_edits);
1241         }
1242         return 0;
1243 }
1244
1245
1246 int Tracks::purge_asset(Asset *asset)
1247 {
1248         Track *current_track;
1249         int result = 0;
1250
1251         for(current_track = first; current_track; current_track = current_track->next)
1252         {
1253                 result += current_track->purge_asset(asset);
1254         }
1255         return result;
1256 }
1257
1258 int Tracks::asset_used(Asset *asset)
1259 {
1260         Track *current_track;
1261         int result = 0;
1262
1263         for(current_track = first; current_track; current_track = current_track->next)
1264         {
1265                 result += current_track->asset_used(asset);
1266         }
1267         return result;
1268 }
1269
1270 int Tracks::scale_time(float rate_scale, int ignore_record, int scale_edits, int scale_autos, int64_t start, int64_t end)
1271 {
1272         Track *current_track;
1273
1274         for(current_track = first;
1275                 current_track;
1276                 current_track = current_track->next)
1277         {
1278                 if((current_track->is_armed() || ignore_record) &&
1279                         current_track->data_type == TRACK_VIDEO)
1280                 {
1281                         current_track->scale_time(rate_scale, scale_edits, scale_autos, start, end);
1282                 }
1283         }
1284         return 0;
1285 }
1286