libs/ardour/session_events.cc

   1 /*
   2     Copyright (C) 1999-2004 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 */
  19
  20 #include <cmath>
  21 #include <unistd.h>
  22
  23 #include "pbd/error.h"
  24 #include "pbd/enumwriter.h"
  25 #include "pbd/stacktrace.h"
  26 #include "pbd/pthread_utils.h"
  27
  28 #include "ardour/debug.h"
  29 #include "ardour/session_event.h"
  30
  31 #include "i18n.h"
  32
  33 using namespace std;
  34 using namespace ARDOUR;
  35 using namespace PBD;
  36
  37 PerThreadPool* SessionEvent::pool;
  38
  39 void
  40 SessionEvent::init_event_pool ()
  41 {
  42         pool = new PerThreadPool;
  43 }
  44
  45 void
  46 SessionEvent::create_per_thread_pool (const std::string& name, uint32_t nitems)
  47 {
  48         /* this is a per-thread call that simply creates a thread-private ptr to
  49            a CrossThreadPool for use by this thread whenever events are allocated/released
  50            from SessionEvent::pool()
  51         */
  52         pool->create_per_thread_pool (name, sizeof (SessionEvent), nitems);
  53 }
  54
  55 void *
  56 SessionEvent::operator new (size_t)
  57 {
  58         CrossThreadPool* p = pool->per_thread_pool ();
  59         SessionEvent* ev = static_cast<SessionEvent*> (p->alloc ());
  60         DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("%1 Allocating SessionEvent from %2 ev @ %3\n", pthread_name(), p->name(), ev));
  61 #ifndef NDEBUG
  62         if (DEBUG::SessionEvents & PBD::debug_bits) {
  63                 stacktrace (cerr, 40);
  64         }
  65 #endif
  66         ev->own_pool = p;
  67         return ev;
  68 }
  69
  70 void
  71 SessionEvent::operator delete (void *ptr, size_t /*size*/)
  72 {
  73         Pool* p = pool->per_thread_pool ();
  74         SessionEvent* ev = static_cast<SessionEvent*> (ptr);
  75
  76         DEBUG_TRACE (DEBUG::SessionEvents, string_compose (
  77                              "%1 Deleting SessionEvent @ %2 ev thread pool = %3 ev pool = %4\n",
  78                              pthread_name(), ev, p->name(), ev->own_pool->name()
  79                              ));
  80
  81 #ifndef NDEBUG
  82         if (DEBUG::SessionEvents & PBD::debug_bits) {
  83                 stacktrace (cerr, 40);
  84         }
  85 #endif
  86
  87         if (p == ev->own_pool) {
  88                 p->release (ptr);
  89         } else {
  90                 ev->own_pool->push (ev);
  91         }
  92 }
  93
  94 void
  95 SessionEventManager::add_event (framepos_t frame, SessionEvent::Type type, framepos_t target_frame)
  96 {
  97         SessionEvent* ev = new SessionEvent (type, SessionEvent::Add, frame, target_frame, 0);
  98         queue_event (ev);
  99 }
 100
 101 void
 102 SessionEventManager::remove_event (framepos_t frame, SessionEvent::Type type)
 103 {
 104         SessionEvent* ev = new SessionEvent (type, SessionEvent::Remove, frame, 0, 0);
 105         queue_event (ev);
 106 }
 107
 108 void
 109 SessionEventManager::replace_event (SessionEvent::Type type, framepos_t frame, framepos_t target)
 110 {
 111         SessionEvent* ev = new SessionEvent (type, SessionEvent::Replace, frame, target, 0);
 112         queue_event (ev);
 113 }
 114
 115 void
 116 SessionEventManager::clear_events (SessionEvent::Type type)
 117 {
 118         SessionEvent* ev = new SessionEvent (type, SessionEvent::Clear, 0, 0, 0);
 119         queue_event (ev);
 120 }
 121
 122
 123 void
 124 SessionEventManager::dump_events () const
 125 {
 126         cerr << "EVENT DUMP" << endl;
 127         for (Events::const_iterator i = events.begin(); i != events.end(); ++i) {
 128
 129                 cerr << "\tat " << (*i)->action_frame << ' ' << enum_2_string ((*i)->type) << " target = " << (*i)->target_frame << endl;
 130         }
 131         cerr << "Next event: ";
 132
 133         if ((Events::const_iterator) next_event == events.end()) {
 134                 cerr << "none" << endl;
 135         } else {
 136                 cerr << "at " << (*next_event)->action_frame << ' '
 137                      << enum_2_string ((*next_event)->type) << " target = "
 138                      << (*next_event)->target_frame << endl;
 139         }
 140         cerr << "Immediate events pending:\n";
 141         for (Events::const_iterator i = immediate_events.begin(); i != immediate_events.end(); ++i) {
 142                 cerr << "\tat " << (*i)->action_frame << ' ' << enum_2_string((*i)->type) << " target = " << (*i)->target_frame << endl;
 143         }
 144         cerr << "END EVENT_DUMP" << endl;
 145 }
 146
 147 void
 148 SessionEventManager::merge_event (SessionEvent* ev)
 149 {
 150         switch (ev->action) {
 151         case SessionEvent::Remove:
 152                 _remove_event (ev);
 153                 delete ev;
 154                 return;
 155
 156         case SessionEvent::Replace:
 157                 _replace_event (ev);
 158                 return;
 159
 160         case SessionEvent::Clear:
 161                 _clear_event_type (ev->type);
 162                 delete ev;
 163                 return;
 164
 165         case SessionEvent::Add:
 166                 break;
 167         }
 168
 169         /* try to handle immediate events right here */
 170
 171         if (ev->action_frame == 0) {
 172                 process_event (ev);
 173                 return;
 174         }
 175
 176         switch (ev->type) {
 177         case SessionEvent::AutoLoop:
 178         case SessionEvent::AutoLoopDeclick:
 179         case SessionEvent::StopOnce:
 180                 _clear_event_type (ev->type);
 181                 break;
 182
 183         default:
 184                 for (Events::iterator i = events.begin(); i != events.end(); ++i) {
 185                         if ((*i)->type == ev->type && (*i)->action_frame == ev->action_frame) {
 186                           error << string_compose(_("Session: cannot have two events of type %1 at the same frame (%2)."),
 187                                                   enum_2_string (ev->type), ev->action_frame) << endmsg;
 188                                 return;
 189                         }
 190                 }
 191         }
 192
 193         events.insert (events.begin(), ev);
 194         events.sort (SessionEvent::compare);
 195         next_event = events.begin();
 196         set_next_event ();
 197 }
 198
 199 /** @return true when @a ev is deleted. */
 200 bool
 201 SessionEventManager::_replace_event (SessionEvent* ev)
 202 {
 203         bool ret = false;
 204         Events::iterator i;
 205
 206         /* private, used only for events that can only exist once in the queue */
 207
 208         for (i = events.begin(); i != events.end(); ++i) {
 209                 if ((*i)->type == ev->type) {
 210                         (*i)->action_frame = ev->action_frame;
 211                         (*i)->target_frame = ev->target_frame;
 212                         if ((*i) == ev) {
 213                                 ret = true;
 214                         }
 215                         delete ev;
 216                         break;
 217                 }
 218         }
 219
 220         if (i == events.end()) {
 221                 events.insert (events.begin(), ev);
 222         }
 223
 224         events.sort (SessionEvent::compare);
 225         next_event = events.end();
 226         set_next_event ();
 227
 228         return ret;
 229 }
 230
 231 /** @return true when @a ev is deleted. */
 232 bool
 233 SessionEventManager::_remove_event (SessionEvent* ev)
 234 {
 235         bool ret = false;
 236         Events::iterator i;
 237
 238         for (i = events.begin(); i != events.end(); ++i) {
 239                 if ((*i)->type == ev->type && (*i)->action_frame == ev->action_frame) {
 240                         if ((*i) == ev) {
 241                                 ret = true;
 242                         }
 243
 244                         delete *i;
 245                         if (i == next_event) {
 246                                 ++next_event;
 247                         }
 248                         i = events.erase (i);
 249                         break;
 250                 }
 251         }
 252
 253         if (i != events.end()) {
 254                 set_next_event ();
 255         }
 256
 257         return ret;
 258 }
 259
 260 void
 261 SessionEventManager::_clear_event_type (SessionEvent::Type type)
 262 {
 263         Events::iterator i, tmp;
 264
 265         for (i = events.begin(); i != events.end(); ) {
 266
 267                 tmp = i;
 268                 ++tmp;
 269
 270                 if ((*i)->type == type) {
 271                         delete *i;
 272                         if (i == next_event) {
 273                                 ++next_event;
 274                         }
 275                         events.erase (i);
 276                 }
 277
 278                 i = tmp;
 279         }
 280
 281         for (i = immediate_events.begin(); i != immediate_events.end(); ) {
 282
 283                 tmp = i;
 284                 ++tmp;
 285
 286                 if ((*i)->type == type) {
 287                         delete *i;
 288                         immediate_events.erase (i);
 289                 }
 290
 291                 i = tmp;
 292         }
 293
 294         set_next_event ();
 295 }
 296