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                 cerr << "\tat " << (*i)->action_frame << ' ' << (*i)->type << " target = " << (*i)->target_frame << endl;
 129         }
 130         cerr << "Next event: ";
 131
 132         if ((Events::const_iterator) next_event == events.end()) {
 133                 cerr << "none" << endl;
 134         } else {
 135                 cerr << "at " << (*next_event)->action_frame << ' '
 136                      << (*next_event)->type << " target = "
 137                      << (*next_event)->target_frame << endl;
 138         }
 139         cerr << "Immediate events pending:\n";
 140         for (Events::const_iterator i = immediate_events.begin(); i != immediate_events.end(); ++i) {
 141                 cerr << "\tat " << (*i)->action_frame << ' ' << (*i)->type << " target = " << (*i)->target_frame << endl;
 142         }
 143         cerr << "END EVENT_DUMP" << endl;
 144 }
 145
 146 void
 147 SessionEventManager::merge_event (SessionEvent* ev)
 148 {
 149         switch (ev->action) {
 150         case SessionEvent::Remove:
 151                 _remove_event (ev);
 152                 delete ev;
 153                 return;
 154
 155         case SessionEvent::Replace:
 156                 _replace_event (ev);
 157                 return;
 158
 159         case SessionEvent::Clear:
 160                 _clear_event_type (ev->type);
 161                 delete ev;
 162                 return;
 163
 164         case SessionEvent::Add:
 165                 break;
 166         }
 167
 168         /* try to handle immediate events right here */
 169
 170         if (ev->action_frame == 0) {
 171                 process_event (ev);
 172                 return;
 173         }
 174
 175         switch (ev->type) {
 176         case SessionEvent::AutoLoop:
 177         case SessionEvent::AutoLoopDeclick:
 178         case SessionEvent::StopOnce:
 179                 _clear_event_type (ev->type);
 180                 break;
 181
 182         default:
 183                 for (Events::iterator i = events.begin(); i != events.end(); ++i) {
 184                         if ((*i)->type == ev->type && (*i)->action_frame == ev->action_frame) {
 185                           error << string_compose(_("Session: cannot have two events of type %1 at the same frame (%2)."),
 186                                                   enum_2_string (ev->type), ev->action_frame) << endmsg;
 187                                 return;
 188                         }
 189                 }
 190         }
 191
 192         events.insert (events.begin(), ev);
 193         events.sort (SessionEvent::compare);
 194         next_event = events.begin();
 195         set_next_event ();
 196 }
 197
 198 /** @return true when @a ev is deleted. */
 199 bool
 200 SessionEventManager::_replace_event (SessionEvent* ev)
 201 {
 202         bool ret = false;
 203         Events::iterator i;
 204
 205         /* private, used only for events that can only exist once in the queue */
 206
 207         for (i = events.begin(); i != events.end(); ++i) {
 208                 if ((*i)->type == ev->type) {
 209                         (*i)->action_frame = ev->action_frame;
 210                         (*i)->target_frame = ev->target_frame;
 211                         if ((*i) == ev) {
 212                                 ret = true;
 213                         }
 214                         delete ev;
 215                         break;
 216                 }
 217         }
 218
 219         if (i == events.end()) {
 220                 events.insert (events.begin(), ev);
 221         }
 222
 223         events.sort (SessionEvent::compare);
 224         next_event = events.end();
 225         set_next_event ();
 226
 227         return ret;
 228 }
 229
 230 /** @return true when @a ev is deleted. */
 231 bool
 232 SessionEventManager::_remove_event (SessionEvent* ev)
 233 {
 234         bool ret = false;
 235         Events::iterator i;
 236
 237         for (i = events.begin(); i != events.end(); ++i) {
 238                 if ((*i)->type == ev->type && (*i)->action_frame == ev->action_frame) {
 239                         if ((*i) == ev) {
 240                                 ret = true;
 241                         }
 242
 243                         delete *i;
 244                         if (i == next_event) {
 245                                 ++next_event;
 246                         }
 247                         events.erase (i);
 248                         break;
 249                 }
 250         }
 251
 252         if (i != events.end()) {
 253                 set_next_event ();
 254         }
 255
 256         return ret;
 257 }
 258
 259 void
 260 SessionEventManager::_clear_event_type (SessionEvent::Type type)
 261 {
 262         Events::iterator i, tmp;
 263
 264         for (i = events.begin(); i != events.end(); ) {
 265
 266                 tmp = i;
 267                 ++tmp;
 268
 269                 if ((*i)->type == type) {
 270                         delete *i;
 271                         if (i == next_event) {
 272                                 ++next_event;
 273                         }
 274                         events.erase (i);
 275                 }
 276
 277                 i = tmp;
 278         }
 279
 280         for (i = immediate_events.begin(); i != immediate_events.end(); ) {
 281
 282                 tmp = i;
 283                 ++tmp;
 284
 285                 if ((*i)->type == type) {
 286                         delete *i;
 287                         immediate_events.erase (i);
 288                 }
 289
 290                 i = tmp;
 291         }
 292
 293         set_next_event ();
 294 }
 295