libs/ardour/location.cc

   1 /*
   2     Copyright (C) 2000 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18     $Id$
  19 */
  20
  21 #include <algorithm>
  22 #include <set>
  23 #include <cstdio> /* for sprintf */
  24 #include <unistd.h>
  25 #include <cerrno>
  26 #include <ctime>
  27 #include <sigc++/bind.h>
  28
  29 #include <pbd/stl_delete.h>
  30 #include <pbd/xml++.h>
  31
  32 #include <ardour/location.h>
  33 #include <ardour/session.h>
  34 #include <ardour/audiofilesource.h>
  35
  36 #include "i18n.h"
  37
  38 using namespace std;
  39 using namespace ARDOUR;
  40 using namespace sigc;
  41 using namespace PBD;
  42
  43 Location::Location (const Location& other)
  44         : _name (other._name),
  45           _start (other._start),
  46           _end (other._end),
  47           _flags (other._flags)
  48 {
  49         /* start and end flags can never be copied, because there can only ever be one of each */
  50
  51         _flags = Flags (_flags & ~IsStart);
  52         _flags = Flags (_flags & ~IsEnd);
  53 }
  54
  55 Location::Location (const XMLNode& node)
  56 {
  57         if (set_state (node)) {
  58                 throw failed_constructor ();
  59         }
  60 }
  61
  62 Location*
  63 Location::operator= (const Location& other)
  64 {
  65         if (this == &other) {
  66                 return this;
  67         }
  68
  69         _name = other._name;
  70         _start = other._start;
  71         _end = other._end;
  72         _flags = other._flags;
  73
  74         /* "changed" not emitted on purpose */
  75
  76         return this;
  77 }
  78
  79 int
  80 Location::set_start (nframes_t s)
  81 {
  82         if (is_mark()) {
  83                 if (_start != s) {
  84
  85                         _start = s;
  86                         _end = s;
  87
  88                         start_changed(this); /* EMIT SIGNAL */
  89
  90                         if ( is_start() ) {
  91
  92                                 Session::StartTimeChanged (); /* EMIT SIGNAL */
  93                                 AudioFileSource::set_header_position_offset ( s );
  94                         }
  95
  96                         if ( is_end() ) {
  97                                 Session::EndTimeChanged (); /* EMIT SIGNAL */
  98                         }
  99                 }
 100                 return 0;
 101         }
 102
 103         if (((is_auto_punch() || is_auto_loop()) && s >= _end) || s > _end) {
 104                 return -1;
 105         }
 106
 107         if (s != _start) {
 108                 _start = s;
 109                 start_changed(this); /* EMIT SIGNAL */
 110         }
 111
 112         return 0;
 113 }
 114
 115 int
 116 Location::set_end (nframes_t e)
 117 {
 118         if (is_mark()) {
 119                 if (_start != e) {
 120                         _start = e;
 121                         _end = e;
 122                         end_changed(this); /* EMIT SIGNAL */
 123                 }
 124                 return 0;
 125         }
 126
 127         if (((is_auto_punch() || is_auto_loop()) && e <= _start) || e < _start) {
 128                 return -1;
 129         }
 130
 131         if (e != _end) {
 132                 _end = e;
 133                  end_changed(this); /* EMIT SIGNAL */
 134         }
 135         return 0;
 136 }
 137
 138 int
 139 Location::set (nframes_t start, nframes_t end)
 140 {
 141         if (is_mark() && start != end) {
 142                 return -1;
 143         } else if (((is_auto_punch() || is_auto_loop()) && start >= end) || (start > end)) {
 144                 return -1;
 145         }
 146
 147         if (_start != start) {
 148                 _start = start;
 149                 start_changed(this); /* EMIT SIGNAL */
 150         }
 151
 152         if (_end != end) {
 153                 _end = end;
 154                 end_changed(this); /* EMIT SIGNAL */
 155         }
 156         return 0;
 157 }
 158
 159 void
 160 Location::set_hidden (bool yn, void *src)
 161 {
 162         if (set_flag_internal (yn, IsHidden)) {
 163                  FlagsChanged (this, src); /* EMIT SIGNAL */
 164         }
 165 }
 166
 167 void
 168 Location::set_cd (bool yn, void *src)
 169 {
 170         if (set_flag_internal (yn, IsCDMarker)) {
 171                  FlagsChanged (this, src); /* EMIT SIGNAL */
 172         }
 173 }
 174
 175 void
 176 Location::set_is_end (bool yn, void *src)
 177 {
 178         if (set_flag_internal (yn, IsEnd)) {
 179                  FlagsChanged (this, src); /* EMIT SIGNAL */
 180         }
 181 }
 182
 183 void
 184 Location::set_is_start (bool yn, void *src)
 185 {
 186         if (set_flag_internal (yn, IsStart)) {
 187                  FlagsChanged (this, src); /* EMIT SIGNAL */
 188         }
 189 }
 190
 191 void
 192 Location::set_auto_punch (bool yn, void *src)
 193 {
 194         if (is_mark() || _start == _end) {
 195                 return;
 196         }
 197
 198         if (set_flag_internal (yn, IsAutoPunch)) {
 199                  FlagsChanged (this, src); /* EMIT SIGNAL */
 200         }
 201 }
 202
 203 void
 204 Location::set_auto_loop (bool yn, void *src)
 205 {
 206         if (is_mark() || _start == _end) {
 207                 return;
 208         }
 209
 210         if (set_flag_internal (yn, IsAutoLoop)) {
 211                  FlagsChanged (this, src); /* EMIT SIGNAL */
 212         }
 213 }
 214
 215 bool
 216 Location::set_flag_internal (bool yn, Flags flag)
 217 {
 218         if (yn) {
 219                 if (!(_flags & flag)) {
 220                         _flags |= flag;
 221                         return true;
 222                 }
 223         } else {
 224                 if (_flags & flag) {
 225                         _flags &= ~flag;
 226                         return true;
 227                 }
 228         }
 229         return false;
 230 }
 231
 232 void
 233 Location::set_mark (bool yn)
 234 {
 235         /* This function is private, and so does not emit signals */
 236
 237         if (_start != _end) {
 238                 return;
 239         }
 240
 241         set_flag_internal (yn, IsMark);
 242 }
 243
 244
 245 XMLNode&
 246 Location::cd_info_node(const string & name, const string & value)
 247 {
 248         XMLNode* root = new XMLNode("CD-Info");
 249
 250         root->add_property("name", name);
 251         root->add_property("value", value);
 252
 253         return *root;
 254 }
 255
 256
 257 XMLNode&
 258 Location::get_state (void)
 259 {
 260         XMLNode *node = new XMLNode ("Location");
 261         char buf[64];
 262
 263         typedef map<string, string>::const_iterator CI;
 264
 265         for(CI m = cd_info.begin(); m != cd_info.end(); ++m){
 266                 node->add_child_nocopy(cd_info_node(m->first, m->second));
 267         }
 268
 269         id().print (buf, sizeof (buf));
 270         node->add_property("id", buf);
 271         node->add_property ("name", name());
 272         snprintf (buf, sizeof (buf), "%u", start());
 273         node->add_property ("start", buf);
 274         snprintf (buf, sizeof (buf), "%u", end());
 275         node->add_property ("end", buf);
 276         snprintf (buf, sizeof (buf), "%" PRIu32, (uint32_t) _flags);
 277         node->add_property ("flags", buf);
 278
 279         return *node;
 280 }
 281
 282 int
 283 Location::set_state (const XMLNode& node)
 284 {
 285         const XMLProperty *prop;
 286
 287         XMLNodeList cd_list = node.children();
 288         XMLNodeConstIterator cd_iter;
 289         XMLNode *cd_node;
 290
 291         string cd_name;
 292         string cd_value;
 293
 294         if (node.name() != "Location") {
 295                 error << _("incorrect XML node passed to Location::set_state") << endmsg;
 296                 return -1;
 297         }
 298
 299         if ((prop = node.property ("id")) == 0) {
 300                 warning << _("XML node for Location has no ID information") << endmsg;
 301         } else {
 302                 _id = prop->value ();
 303         }
 304
 305         if ((prop = node.property ("name")) == 0) {
 306                 error << _("XML node for Location has no name information") << endmsg;
 307                 return -1;
 308         }
 309
 310         set_name (prop->value());
 311
 312         if ((prop = node.property ("start")) == 0) {
 313                 error << _("XML node for Location has no start information") << endmsg;
 314                 return -1;
 315         }
 316
 317                 /* can't use set_start() here, because _end
 318                    may make the value of _start illegal.
 319                 */
 320
 321         _start = atoi (prop->value().c_str());
 322
 323         if ((prop = node.property ("end")) == 0) {
 324                   error << _("XML node for Location has no end information") << endmsg;
 325                   return -1;
 326         }
 327
 328         _end = atoi (prop->value().c_str());
 329
 330         _flags = 0;
 331
 332         if ((prop = node.property ("flags")) == 0) {
 333                   error << _("XML node for Location has no flags information") << endmsg;
 334                   return -1;
 335         }
 336
 337         _flags = Flags (atoi (prop->value().c_str()));
 338
 339         for (cd_iter = cd_list.begin(); cd_iter != cd_list.end(); ++cd_iter) {
 340
 341                   cd_node = *cd_iter;
 342
 343                   if (cd_node->name() != "CD-Info") {
 344                     continue;
 345                   }
 346
 347                   if ((prop = cd_node->property ("name")) != 0) {
 348                     cd_name = prop->value();
 349                   } else {
 350                     throw failed_constructor ();
 351                   }
 352
 353                   if ((prop = cd_node->property ("value")) != 0) {
 354                     cd_value = prop->value();
 355                   } else {
 356                     throw failed_constructor ();
 357                   }
 358
 359
 360                   cd_info[cd_name] = cd_value;
 361
 362         }
 363
 364         changed(this); /* EMIT SIGNAL */
 365
 366         return 0;
 367 }
 368
 369 /*---------------------------------------------------------------------- */
 370
 371 Locations::Locations ()
 372
 373 {
 374         current_location = 0;
 375 }
 376
 377 Locations::~Locations ()
 378 {
 379         for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
 380                 LocationList::iterator tmp = i;
 381                 ++tmp;
 382                 delete *i;
 383                 i = tmp;
 384         }
 385 }
 386
 387 int
 388 Locations::set_current (Location *loc, bool want_lock)
 389
 390 {
 391         int ret;
 392
 393         if (want_lock) {
 394                 Glib::Mutex::Lock lm (lock);
 395                 ret = set_current_unlocked (loc);
 396         } else {
 397                 ret = set_current_unlocked (loc);
 398         }
 399
 400         if (ret == 0) {
 401                  current_changed (current_location); /* EMIT SIGNAL */
 402         }
 403         return ret;
 404 }
 405
 406 int
 407 Locations::set_current_unlocked (Location *loc)
 408 {
 409         if (find (locations.begin(), locations.end(), loc) == locations.end()) {
 410                 error << _("Locations: attempt to use unknown location as selected location") << endmsg;
 411                 return -1;
 412         }
 413
 414         current_location = loc;
 415         return 0;
 416 }
 417
 418 void
 419 Locations::clear ()
 420 {
 421         {
 422                 Glib::Mutex::Lock lm (lock);
 423                 LocationList::iterator tmp;
 424                 for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
 425                         tmp = i;
 426                         ++tmp;
 427                         if (!(*i)->is_end() && !(*i)->is_start()) {
 428                                 locations.erase (i);
 429                         }
 430                         i = tmp;
 431                 }
 432
 433                 locations.clear ();
 434                 current_location = 0;
 435         }
 436
 437         changed (); /* EMIT SIGNAL */
 438         current_changed (0); /* EMIT SIGNAL */
 439 }
 440
 441 void
 442 Locations::clear_markers ()
 443 {
 444         {
 445                 Glib::Mutex::Lock lm (lock);
 446                 LocationList::iterator tmp;
 447
 448                 for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
 449                         tmp = i;
 450                         ++tmp;
 451
 452                         if ((*i)->is_mark() && !(*i)->is_end() && !(*i)->is_start()) {
 453                                 locations.erase (i);
 454                         }
 455
 456                         i = tmp;
 457                 }
 458         }
 459
 460         changed (); /* EMIT SIGNAL */
 461 }
 462
 463 void
 464 Locations::clear_ranges ()
 465 {
 466         {
 467                 Glib::Mutex::Lock lm (lock);
 468                 LocationList::iterator tmp;
 469
 470                 for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
 471
 472                         tmp = i;
 473                         ++tmp;
 474
 475                         if (!(*i)->is_mark()) {
 476                                 locations.erase (i);
 477
 478                         }
 479
 480                         i = tmp;
 481                 }
 482
 483                 current_location = 0;
 484         }
 485
 486         changed (); /* EMIT SIGNAL */
 487         current_changed (0); /* EMIT SIGNAL */
 488 }
 489
 490 void
 491 Locations::add (Location *loc, bool make_current)
 492 {
 493         {
 494                 Glib::Mutex::Lock lm (lock);
 495                 locations.push_back (loc);
 496
 497                 if (make_current) {
 498                         current_location = loc;
 499                 }
 500         }
 501
 502         added (loc); /* EMIT SIGNAL */
 503
 504         if (make_current) {
 505                  current_changed (current_location); /* EMIT SIGNAL */
 506         }
 507 }
 508
 509 void
 510 Locations::remove (Location *loc)
 511
 512 {
 513         bool was_removed = false;
 514         bool was_current = false;
 515         LocationList::iterator i;
 516
 517         if (loc->is_end() || loc->is_start()) {
 518                 return;
 519         }
 520
 521         {
 522                 Glib::Mutex::Lock lm (lock);
 523
 524                 for (i = locations.begin(); i != locations.end(); ++i) {
 525                         if ((*i) == loc) {
 526                                 locations.erase (i);
 527                                 was_removed = true;
 528                                 if (current_location == loc) {
 529                                         current_location = 0;
 530                                         was_current = true;
 531                                 }
 532                                 break;
 533                         }
 534                 }
 535         }
 536
 537         if (was_removed) {
 538
 539                 removed (loc); /* EMIT SIGNAL */
 540
 541                 if (was_current) {
 542                          current_changed (0); /* EMIT SIGNAL */
 543                 }
 544
 545                 changed (); /* EMIT_SIGNAL */
 546         }
 547 }
 548
 549 void
 550 Locations::location_changed (Location* loc)
 551 {
 552         changed (); /* EMIT SIGNAL */
 553 }
 554
 555 XMLNode&
 556 Locations::get_state ()
 557 {
 558         XMLNode *node = new XMLNode ("Locations");
 559         LocationList::iterator iter;
 560         Glib::Mutex::Lock lm (lock);
 561
 562         for (iter  = locations.begin(); iter != locations.end(); ++iter) {
 563                 node->add_child_nocopy ((*iter)->get_state ());
 564         }
 565
 566         return *node;
 567 }
 568
 569 int
 570 Locations::set_state (const XMLNode& node)
 571 {
 572         XMLNodeList nlist;
 573         XMLNodeConstIterator niter;
 574
 575         if (node.name() != "Locations") {
 576                 error << _("incorrect XML mode passed to Locations::set_state") << endmsg;
 577                 return -1;
 578         }
 579
 580         nlist = node.children();
 581
 582         {
 583                 Glib::Mutex::Lock lm (lock);
 584
 585                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
 586
 587                         try {
 588
 589                                 Location *loc = new Location (**niter);
 590                                 locations.push_back (loc);
 591                         }
 592
 593                         catch (failed_constructor& err) {
 594                                 error << _("could not load location from session file - ignored") << endmsg;
 595                         }
 596                 }
 597
 598                 if (locations.size()) {
 599
 600                         current_location = locations.front();
 601                 } else {
 602                         current_location = 0;
 603                 }
 604         }
 605
 606         changed (); /* EMIT SIGNAL */
 607
 608         return 0;
 609 }
 610
 611 struct LocationStartEarlierComparison
 612 {
 613     bool operator() (Location *a, Location *b) {
 614         return a->start() < b->start();
 615     }
 616 };
 617
 618 struct LocationStartLaterComparison
 619 {
 620     bool operator() (Location *a, Location *b) {
 621         return a->start() > b->start();
 622     }
 623 };
 624
 625 Location *
 626 Locations::first_location_before (nframes_t frame)
 627 {
 628         LocationList locs;
 629
 630         {
 631                 Glib::Mutex::Lock lm (lock);
 632                 locs = locations;
 633         }
 634
 635         LocationStartLaterComparison cmp;
 636         locs.sort (cmp);
 637
 638         /* locs is now sorted latest..earliest */
 639
 640         for (LocationList::iterator i = locs.begin(); i != locs.end(); ++i) {
 641                 if (!(*i)->is_hidden() && (*i)->start() < frame) {
 642                         return (*i);
 643                 }
 644         }
 645
 646         return 0;
 647 }
 648
 649 Location *
 650 Locations::first_location_after (nframes_t frame)
 651 {
 652         LocationList locs;
 653
 654         {
 655                 Glib::Mutex::Lock lm (lock);
 656                 locs = locations;
 657         }
 658
 659         LocationStartEarlierComparison cmp;
 660         locs.sort (cmp);
 661
 662         /* locs is now sorted earliest..latest */
 663
 664         for (LocationList::iterator i = locs.begin(); i != locs.end(); ++i) {
 665                 if (!(*i)->is_hidden() && (*i)->start() > frame) {
 666                         return (*i);
 667                 }
 668         }
 669
 670         return 0;
 671 }
 672
 673 nframes_t
 674 Locations::first_mark_before (nframes_t frame)
 675 {
 676         LocationList locs;
 677
 678         {
 679         Glib::Mutex::Lock lm (lock);
 680                 locs = locations;
 681         }
 682
 683         LocationStartLaterComparison cmp;
 684         locs.sort (cmp);
 685
 686         /* locs is now sorted latest..earliest */
 687
 688         for (LocationList::iterator i = locs.begin(); i != locs.end(); ++i) {
 689                 if (!(*i)->is_hidden()) {
 690                         if ((*i)->is_mark()) {
 691                                 /* MARK: start == end */
 692                                 if ((*i)->start() < frame) {
 693                                         return (*i)->start();
 694                                 }
 695                         } else {
 696                                 /* RANGE: start != end, compare start and end */
 697                                 if ((*i)->end() < frame) {
 698                                         return (*i)->end();
 699                                 }
 700                                 if ((*i)->start () < frame) {
 701                                         return (*i)->start();
 702                                 }
 703                         }
 704                 }
 705         }
 706
 707         return 0;
 708 }
 709
 710 nframes_t
 711 Locations::first_mark_after (nframes_t frame)
 712 {
 713         LocationList locs;
 714
 715         {
 716         Glib::Mutex::Lock lm (lock);
 717                 locs = locations;
 718         }
 719
 720         LocationStartEarlierComparison cmp;
 721         locs.sort (cmp);
 722
 723         /* locs is now sorted earliest..latest */
 724
 725         for (LocationList::iterator i = locs.begin(); i != locs.end(); ++i) {
 726                 if (!(*i)->is_hidden()) {
 727                         if ((*i)->is_mark()) {
 728                                 /* MARK, start == end so just compare start */
 729                                 if ((*i)->start() > frame) {
 730                                         return (*i)->start();
 731                                 }
 732                         } else {
 733                                 /* RANGE, start != end, compare start and end */
 734                                 if ((*i)->start() > frame ) {
 735                                         return (*i)->start ();
 736                                 }
 737                                 if ((*i)->end() > frame) {
 738                                         return (*i)->end ();
 739                                 }
 740                         }
 741                 }
 742         }
 743
 744         return max_frames;
 745 }
 746
 747 Location*
 748 Locations::end_location () const
 749 {
 750         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
 751                 if ((*i)->is_end()) {
 752                         return const_cast<Location*> (*i);
 753                 }
 754         }
 755         return 0;
 756 }
 757
 758 Location*
 759 Locations::start_location () const
 760 {
 761         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
 762                 if ((*i)->is_start()) {
 763                         return const_cast<Location*> (*i);
 764                 }
 765         }
 766         return 0;
 767 }
 768
 769 Location*
 770 Locations::auto_loop_location () const
 771 {
 772         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
 773                 if ((*i)->is_auto_loop()) {
 774                         return const_cast<Location*> (*i);
 775                 }
 776         }
 777         return 0;
 778 }
 779
 780 Location*
 781 Locations::auto_punch_location () const
 782 {
 783         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
 784                 if ((*i)->is_auto_punch()) {
 785                         return const_cast<Location*> (*i);
 786                 }
 787         }
 788        return 0;
 789 }
 790
 791 uint32_t
 792 Locations::num_range_markers () const
 793 {
 794         uint32_t cnt = 0;
 795         Glib::Mutex::Lock lm (lock);
 796         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
 797                 if ((*i)->is_range_marker()) {
 798                         ++cnt;
 799                 }
 800         }
 801         return cnt;
 802 }
 803
 804 Location *
 805 Locations::get_location_by_id(PBD::ID id)
 806 {
 807     LocationList::iterator it;
 808     for (it  = locations.begin(); it != locations.end(); it++)
 809         if (id == (*it)->id())
 810             return *it;
 811
 812     return 0;
 813 }