Ardour  9.0-pre0-582-g084a23a80d
triggerbox.h
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2021 Paul Davis <paul@linuxaudiosystems.com>
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 along
15  * with this program; if not, write to the Free Software Foundation, Inc.,
16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17  */
18 
19 #pragma once
20 
21 #include <pthread.h>
22 
23 #include <atomic>
24 #include <map>
25 #include <memory>
26 #include <vector>
27 #include <string>
28 #include <exception>
29 
30 #include <glibmm/threads.h>
31 
32 #include "pbd/crossthread.h"
33 #include "pbd/pcg_rand.h"
34 #include "pbd/pool.h"
35 #include "pbd/properties.h"
36 #include "pbd/ringbuffer.h"
37 #include "pbd/stateful.h"
38 
39 #include "midi++/types.h"
40 
41 #include "temporal/beats.h"
42 #include "temporal/bbt_time.h"
43 #include "temporal/tempo.h"
44 
45 #include "evoral/PatchChange.h"
46 #include "evoral/SMF.h"
47 
49 #include "ardour/midi_model.h"
51 #include "ardour/processor.h"
52 #include "ardour/rt_midibuffer.h"
54 #include "ardour/types.h"
55 #include "ardour/types_convert.h"
56 
58 
59 class XMLNode;
60 
61 namespace RubberBand {
62  class RubberBandStretcher;
63 }
64 
65 namespace MIDI {
66  class Parser;
67 }
68 
69 namespace ARDOUR {
70 
71 class Session;
72 class AudioRegion;
73 class MidiRegion;
74 class TriggerBox;
75 struct SlotArmInfo;
76 class SideChain;
77 class MidiPort;
78 
79 typedef uint32_t color_t;
80 
81 LIBARDOUR_API std::string cue_marker_name (int32_t);
82 
83 class Trigger;
84 
85 typedef std::shared_ptr<Trigger> TriggerPtr;
87 
89  public:
90  enum State {
91  /* This is the initial state for a Trigger, and means that it is not
92  * doing anything at all
93  */
95  /* A Trigger in this state has been chosen by its parent TriggerBox
96  * (e.g. because of a bang() call that put it in the queue), a Trigger in
97  * this state is waiting for the next occurence of its quantization to
98  * occur before transitioning to Running
99  */
101  /* a Trigger in this state is going to deliver data during calls
102  * to its ::run() method.
103  */
105  /* a Trigger in this state was running, has been re-triggered e.g. by a
106  * ::bang() call with LaunchStyle set to Repeat, and is waiting for the
107  * next occurence of its quantization to occur before transitioning
108  * back to Running.
109  */
111  /* a Trigger in this state is delivering data during calls to ::run(), but
112  * is waiting for the next occurence of its quantization to occur when it will
113  * transition to Stopping and then Stopped.
114  */
116  /* a Trigger in this state is delivering data during calls to ::run(), but
117  * is waiting for the next occurence of another Trigger's quantization to occur when it will
118  * transition to Stopping and then Stopped (and be followed by
119  * the other Trigger.
120  */
122  /* a Trigger in this state was Running but noticed that it should stop
123  * during the current call to ::run(). By the end of that call, it will
124  * have transitioned to Stopped.
125  */
127  };
128 
129  enum LaunchStyle {
130  OneShot, /* mouse down/NoteOn starts; mouse up/NoteOff ignored */
131  ReTrigger, /* mouse down/NoteOn starts or retriggers; mouse up/NoteOff */
132  Gate, /* runs till mouse up/note off then to next quantization */
133  Toggle, /* runs till next mouse down/NoteOn */
134  Repeat, /* plays only quantization extent until mouse up/note off */
135  };
136 
137  enum StretchMode { /* currently mapped to the matching RubberBand::RubberBandStretcher::Option */
141  };
142 
143  Trigger (uint32_t index, TriggerBox&);
144  virtual ~Trigger() {}
145 
146  static void make_property_quarks ();
147 
148  protected:
149  /* properties controllable by the user */
150 
166 
167  /* Properties that are not CAS-updated at retrigger */
168 
171 
172  public:
173  /* this is positioned here so that we can easily keep it in sync
174  with the properties list above.
175  */
176  struct UIState {
177  std::atomic<unsigned int> generation; /* used for CAS */
178 
183  uint32_t follow_count = 1;
186  bool use_follow_length = false;
187  bool legato = false;
188  gain_t gain = 1.0;
189  float velocity_effect = 0;
190  bool stretchable = true;
191  bool cue_isolated = false;
192  bool allow_patch_changes = true;
194 
197 
198  std::string name = "";
199  color_t color = 0xBEBEBEFF;
200  double tempo = 0; //unset
201 
202  UIState() : generation (0) {}
203 
204  UIState& operator= (UIState const & other) {
205 
206  /* we do not copy generation */
207 
208  generation = 0;
209 
210  launch_style = other.launch_style;
214  follow_count = other.follow_count;
215  quantization = other.quantization;
218  legato = other.legato;
219  gain = other.gain;
221  stretchable = other.stretchable;
222  cue_isolated = other.cue_isolated;
224  stretch_mode = other.stretch_mode;
226 
227  for (int i = 0; i<16; i++) {
228  if (other.patch_change[i].is_set()) {
229  patch_change[i] = other.patch_change[i];
230  }
231  }
232 
233  name = other.name;
234  color = other.color;
235  tempo = other.tempo;
236 
237  return *this;
238  }
239  };
240 
241 #define TRIGGERBOX_PROPERTY_DECL(name,type) void set_ ## name (type); type name () const;
242 #define TRIGGERBOX_PROPERTY_DECL_CONST_REF(name,type) void set_ ## name (type const &); type name () const
243 
261 
262 #undef TRIGGERBOX_PROPERTY_DECL
263 #undef TRIGGERBOX_PROPERTY_DECL_CONST_REF
264 
265  /* Calling ::bang() will cause this Trigger to be placed in its owning
266  TriggerBox's queue.
267  */
268  void bang (float velocity = 1.0f);
269 
270  /* Calling ::unbang() is equivalent to a mouse-up or note-off
271  ... it MIGHT cause a clip to stop, but more likely has no effect, depending on the slot's launch-style.
272  */
273  void unbang ();
274 
275  /* Calling ::request_stop() to stop a Trigger at the earliest possible
276  * opportunity, rather than at the next quantization point.
277  */
278  void request_stop ();
279 
280  /* Call ::stop_quantized() to stop a Trigger at the next quantization point.
281  */
282  void stop_quantized ();
283 
284  virtual void tempo_map_changed() {}
285 
286  virtual pframes_t run (BufferSet&, samplepos_t start_sample, samplepos_t end_sample,
287  Temporal::Beats const & start, Temporal::Beats const & end,
288  pframes_t nframes, pframes_t offset, double bpm, pframes_t& quantize_offset) = 0;
289  virtual void set_start (timepos_t const &) = 0;
290  virtual void set_end (timepos_t const &) = 0;
291  virtual void set_length (timecnt_t const &) = 0;
292  virtual void reload (BufferSet&, void*) = 0;
293  virtual void io_change () {}
294  virtual void set_legato_offset (timepos_t const & offset) = 0;
295 
297  double position_as_fraction() const;
298 
299  virtual void captured (SlotArmInfo&, BufferSet&) {}
300  virtual void arm();
301  virtual void disarm ();
302  bool armed() const { return _armed; }
304  static PBD::Signal<void(Trigger const *)> TriggerArmChanged;
305 
308  virtual void start_and_roll_to (samplepos_t start, samplepos_t position, uint32_t cnt) = 0;
309 
310  /* because follow actions involve probability is it easier to code the will-not-follow case */
311 
312  bool will_not_follow() const;
313  bool will_follow() const { return !will_not_follow(); }
314 
315  /* assumes that this is currently playing but does not enforce it */
316  bool cue_launched() const { return _cue_launched; }
317 
318  virtual bool probably_oneshot () const = 0;
319 
320  virtual timepos_t start_offset () const = 0; /* offset from start of data */
321  virtual timepos_t current_length() const = 0; /* offset from start() */
322  virtual timepos_t natural_length() const = 0; /* offset from start() */
323 
324  void process_state_requests (BufferSet& bufs, pframes_t dest_offset);
325 
326  bool active() const { return _state >= Running; }
327  State state() const { return _state; }
328 
329  void set_region (std::shared_ptr<Region>, bool use_thread = true);
330  void clear_region ();
331  virtual int set_region_in_worker_thread (std::shared_ptr<Region>) = 0;
332  virtual int set_region_in_worker_thread_from_capture (std::shared_ptr<Region>) = 0;
333  std::shared_ptr<Region> the_region() const { return _region; }
334  virtual bool playable() const = 0;
335 
336  uint32_t index() const { return _index; }
337 
338  /* Managed by TriggerBox, these record the time that the trigger is
339  * scheduled to start or stop at. Computed in
340  * Trigger::maybe_compute_next_transition().
341  */
345 
346  XMLNode& get_state () const;
347  int set_state (const XMLNode&, int version);
348 
349  void maybe_compute_next_transition (samplepos_t start_sample, Temporal::Beats const & start, Temporal::Beats const & end, pframes_t& nframes, pframes_t& dest_offset);
350 
351 
353  Temporal::BBT_Argument& t_bbt, Temporal::Beats& t_beats, samplepos_t& t_samples,
354  Temporal::TempoMap::SharedPtr const & tmap, Temporal::BBT_Offset const & q);
355 
357  Temporal::BBT_Argument& t_bbt, Temporal::Beats& t_beats, samplepos_t& t_samples,
358  Temporal::TempoMap::SharedPtr const & tmap);
359 
360 
361  template<typename TriggerType>
362  void start_and_roll_to (samplepos_t start_pos, samplepos_t end_position, TriggerType& trigger,
363  pframes_t (TriggerType::*run_method) (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample,
364  Temporal::Beats const & start_beats, Temporal::Beats const & end_beats,
365  pframes_t nframes, pframes_t dest_offset, double bpm, pframes_t&), uint32_t cnt);
366  void set_next_trigger (int n);
367  int next_trigger() const { return _next_trigger; }
368 
369  /* any non-zero value will work for the default argument, and means
370  "use your own launch quantization". BBT_Offset (0, 0, 0) means what
371  it says: start immediately
372  */
373  void startup (BufferSet&, pframes_t dest_offset, Temporal::BBT_Offset const & start_quantization = Temporal::BBT_Offset (9, 3,0));
374  void startup_from_ffwd (BufferSet&, uint32_t loop_cnt);
376  virtual void shutdown (BufferSet& bufs, pframes_t dest_offset);
377  virtual void jump_start ();
378  virtual void jump_stop (BufferSet& bufs, pframes_t dest_offset);
379  void begin_stop (bool explicit_stop = false);
381 
382  bool explicitly_stopped() const { return _explicitly_stopped; }
383 
384  uint32_t loop_count() const { return _loop_cnt; }
385 
386  void set_ui (void*);
387  void* ui () const { return _ui; }
388 
389  TriggerBox& box() const { return _box; }
390  std::shared_ptr<TriggerBox> boxptr() const;
391 
392  double estimated_tempo() const { return _estimated_tempo; }
393 
394  /* the following functions deal with audio- or midi-specific SegmentDescriptor properties, provided as virtuals so we don't have to do lots of dynamic_casting */
395  /* segment_tempo is currently a no-op for MIDI, but may be implemented later */
396  virtual double segment_tempo() const = 0;
397  virtual void set_segment_tempo (double t) = 0;
398 
399  /* used_channels is a no-op for audio */
402 
403  /* patch changes are a no-op for audio */
406  virtual void unset_patch_change (uint8_t channel) {}
407  virtual void unset_all_patch_changes () {}
408  virtual bool patch_change_set (uint8_t channel) const { return false; }
409 
410  virtual void setup_stretcher () = 0;
411 
412  Temporal::Meter meter() const { return _meter; }
413 
414  void set_velocity_gain (gain_t g) {_pending_velocity_gain=g;}
415 
418 
420 
422 
424 
425  static void request_trigger_delete (Trigger* t);
426 
427  /* these operations are provided to get/set all the "user visible" trigger properties at once */
428  /* examples: drag+dropping from slot to slot, or "Range->Bounce to Slot", where a single operation sets many */
429  void get_ui_state (UIState &state) const;
430  void set_ui_state (UIState &state);
431 
432  virtual void check_edit_swap (timepos_t const & time, bool playing, BufferSet& bufs) {}
433 
435 
437  virtual void bounds_changed (Temporal::timepos_t const & start, Temporal::timepos_t const & end) {}
438 
439  protected:
440  struct UIRequests {
441  std::atomic<bool> stop;
442  UIRequests() : stop (false) {}
443  };
444 
445  std::shared_ptr<Region> _region;
447  samplepos_t final_processed_sample; /* where we stop playing, in process time, compare with process_index */
452  bool _playout;
453  std::atomic<int> _bang;
454  std::atomic<int> _unbang;
455  uint32_t _index;
457  uint32_t _loop_cnt; /* how many times in a row has this played */
458  void* _ui;
463  bool _armed;
464 
465  /* these are only used by midi triggers but the ui_state API needs them */
468  std::vector<int> _channel_map;
469 
471 
472 
473  /* computed from data */
474 
475  double _estimated_tempo; //TODO: this should come from the MIDI file
476  double _segment_tempo; //TODO: this will likely get stored in the SegmentDescriptor for audio triggers
477 
478  /* basic process is :
479  1) when a file is loaded, we infer its bpm either by minibpm's estimate, a flag in the filename, metadata (TBD) or other means
480  2) we assume the clip must have an integer number of beats in it (simplest case is a one-bar loop with 4 beats in it)
481  3) ...so we round to the nearest beat length, and set the tempo to *exactly* fit the sample-length into the assumed beat-length
482  4) the user may recognize a problem: "this was a 3/4 beat, which was rounded to 4 beats but it should have been 3"
483  5) if the user changes the beat-length, then the tempo is recalculated for use during stretching
484  6) someday, we will also allow the sample start and length to be adjusted in a trimmer, and that will also adjust the tempo
485  7) in all cases the user should be in final control; but our "internal" value for stretching are just sample-start and BPM, end of story
486  */
487  double _beatcnt;
489 
493  std::atomic<Trigger*> _pending;
494  std::atomic<unsigned int> last_property_generation;
496 
497  void when_stopped_during_run (BufferSet& bufs, pframes_t dest_offset);
498  void set_region_internal (std::shared_ptr<Region>);
499  virtual void retrigger();
500  virtual void _startup (BufferSet&, pframes_t dest_offset, Temporal::BBT_Offset const &);
501 
504 };
505 
507  public:
508  AudioTrigger (uint32_t index, TriggerBox&);
510 
511  template<bool actually_run> pframes_t audio_run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample,
512  Temporal::Beats const & start, Temporal::Beats const & end,
513  pframes_t nframes, pframes_t dest_offset, double bpm, pframes_t& quantize_offset);
514 
515  pframes_t run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, Temporal::Beats const & start, Temporal::Beats const & end, pframes_t nframes, pframes_t dest_offset, double bpm, pframes_t& quantize_offset) {
516  return audio_run<true> (bufs, start_sample, end_sample, start, end, nframes, dest_offset, bpm, quantize_offset);
517  }
518 
519  bool playable() const { return data.length || _region; }
520 
521  StretchMode stretch_mode() const { return _stretch_mode; }
523 
524  double segment_tempo() const { return _segment_tempo; }
525  void set_segment_tempo (double t);
526 
527  double segment_beatcnt () { return _beatcnt; }
528  void set_segment_beatcnt (double count);
529 
530  void set_start (timepos_t const &);
531  void set_end (timepos_t const &);
532  void set_legato_offset (timepos_t const &);
533  void set_length (timecnt_t const &);
534  timepos_t start_offset () const; /* offset from start of data */
535  timepos_t current_length() const; /* offset from start of data */
536  timepos_t natural_length() const; /* offset from start of data */
537  void reload (BufferSet&, void*);
538  void io_change ();
539  bool probably_oneshot () const;
540 
542 
543  int set_region_in_worker_thread (std::shared_ptr<Region>);
544  int set_region_in_worker_thread_from_capture (std::shared_ptr<Region>);
545  void jump_start ();
546  void jump_stop (BufferSet& bufs, pframes_t dest_offset);
547 
548  XMLNode& get_state () const;
549  int set_state (const XMLNode&, int version);
550 
551  RubberBand::RubberBandStretcher* stretcher() { return (_stretcher); }
552 
556 
557  bool stretching () const;
558  uint32_t channels () const { return data.size(); }
559 
560  RubberBand::RubberBandStretcher* alloc_stretcher () const;
561 
562  struct AudioData : std::vector<Sample*> {
565 
566  AudioData () : length (0), capacity (0) {}
568 
569  samplecnt_t append (Sample const * src, samplecnt_t cnt, uint32_t chan);
570  void alloc (samplecnt_t cnt, uint32_t nchans);
571  };
572 
573 
574  Sample const * audio_data (size_t n) const;
575  size_t data_length() const { return data.length; }
576 
577  protected:
578  void retrigger ();
579 
580  private:
582  RubberBand::RubberBandStretcher* _stretcher;
584 
585 
586  /* computed during run */
587 
589  samplepos_t last_readable_sample; /* where the data runs out, relative to the start of the data, compare with read_index */
595 
596  virtual void setup_stretcher ();
597 
598  void drop_data ();
599  int load_data (std::shared_ptr<AudioRegion>);
600  void estimate_tempo ();
602  void _startup (BufferSet&, pframes_t dest_offset, Temporal::BBT_Offset const &);
603  int set_region_in_worker_thread_internal (std::shared_ptr<Region> r, bool from_capture);
604 };
605 
606 
608  public:
609  MIDITrigger (uint32_t index, TriggerBox&);
611 
612  bool playable() const { return rt_midibuffer.load() || _region; }
613 
615  void arm();
616  void disarm ();
617 
618  template<bool actually_run> pframes_t midi_run (BufferSet&, samplepos_t start_sample, samplepos_t end_sample,
619  Temporal::Beats const & start_beats, Temporal::Beats const & end_beats, pframes_t nframes, pframes_t offset, double bpm, pframes_t& quantize_offset);
620 
621  pframes_t run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, Temporal::Beats const & start, Temporal::Beats const & end, pframes_t nframes, pframes_t dest_offset, double bpm, pframes_t& quantize_offset) {
622  return midi_run<true> (bufs, start_sample, end_sample, start, end, nframes, dest_offset, bpm, quantize_offset);
623  }
624 
625  void set_start (timepos_t const &);
626  void set_end (timepos_t const &);
627  void set_legato_offset (timepos_t const &);
628  void set_length (timecnt_t const &);
630  timepos_t end() const; /* offset from start of data */
631  timepos_t current_length() const; /* offset from start of data */
632  timepos_t natural_length() const; /* offset from start of data */
633  void reload (BufferSet&, void*);
634  bool probably_oneshot () const;
635 
638 
639  int set_region_in_worker_thread (std::shared_ptr<Region>);
640  int set_region_in_worker_thread_from_capture (std::shared_ptr<Region>);
641  void jump_start ();
642  void shutdown (BufferSet& bufs, pframes_t dest_offset);
643  void jump_stop (BufferSet& bufs, pframes_t dest_offset);
644 
645  XMLNode& get_state () const;
646  int set_state (const XMLNode&, int version);
647 
651 
654  void unset_patch_change (uint8_t channel);
656  bool patch_change_set (uint8_t channel) const;
657 
658  /* It's possible that a portion of a midi file would use a subset of the total channels used, so store that info in the segment descriptor */
659  Evoral::SMF::UsedChannels used_channels() const { return ui_state.used_channels; }
661 
662  /* theoretically, MIDI files can have a dedicated tempo outside the session tempo map (*un-stretched*) but this is currently unimplemented */
663  /* boilerplate tempo functions are provided here so we don't have to do constant dynamic_cast checks to use the tempo+stretch APIs */
664  virtual double segment_tempo() const {return 120.0;}
665  virtual void set_segment_tempo (double t) {}
666  virtual void setup_stretcher () {}
667 
668  void set_channel_map (int channel, int target);
669  void unset_channel_map (int channel);
670  int channel_map (int channel);
671  std::vector<int> const & channel_map() const { return _channel_map; }
672 
673  void check_edit_swap (timepos_t const &, bool playing, BufferSet&);
674  RTMidiBufferBeats const & rt_midi_buffer() const { return *rt_midibuffer.load(); }
675 
677 
678  Temporal::Beats play_start() const { return _play_start; }
679  Temporal::Beats play_end() const { return _play_end; }
680  Temporal::Beats loop_start() const { return _loop_start; }
681  Temporal::Beats loop_end() const { return _loop_end; }
682 
683  protected:
684  void retrigger ();
685 
686  private:
688 
690 
691  Temporal::DoubleableBeats data_length; /* using timestamps from data */
694 
697 
698  std::shared_ptr<MidiModel> _model;
701 
708 
709  std::atomic<RTMidiBufferBeats*> rt_midibuffer;
710  uint32_t iter; /* index into the above RTMidiBufferBeats for current playback */
711 
712  struct PendingSwap {
719 
720  PendingSwap() : rt_midibuffer (nullptr) {}
721  ~PendingSwap() { delete rt_midibuffer; }
722  };
723 
724  std::atomic<PendingSwap*> pending_swap;
725  std::atomic<PendingSwap*> old_pending_swap;
726 
728 
729  int load_data (std::shared_ptr<MidiRegion>);
731  void _startup (BufferSet&, pframes_t dest_offset, Temporal::BBT_Offset const &);
733  void adjust_bounds (Temporal::Beats const & start, Temporal::Beats const & end, Temporal::Beats const & length, bool from_region);
734 };
735 
737 {
738  public:
741 
742  static void init_request_pool() { Request::init_pool(); }
743 
744  void set_region (TriggerBox&, uint32_t slot, std::shared_ptr<Region>);
746  void request_build_source (Trigger* t, Temporal::timecnt_t const & duration);
747 
748  void summon();
749  void stop();
751 
752  private:
753  static void* _thread_work(void *arg);
754  void* thread_work();
755 
756  enum RequestType {
760  BuildSourceAndRegion
761  };
762 
763  struct Request {
764 
765  Request (RequestType t) : type (t) {}
766 
768  /* for set region */
770  uint32_t slot;
771  std::shared_ptr<Region> region;
772  /* for DeleteTrigger and BuildSourceAndRegion */
775 
776  void* operator new (size_t);
777  void operator delete (void* ptr, size_t);
778 
780  static void init_pool ();
781  };
782 
783  pthread_t thread;
785 
789  void build_source (Trigger*, Temporal::timecnt_t const & duration);
792 };
793 
794 struct CueRecord {
795  int32_t cue_number;
797 
798  CueRecord (int32_t cn, samplepos_t t): cue_number (cn), when (t) {}
799  CueRecord () : cue_number (0), when (0) {}
800 
801  static const int32_t stop_all = INT32_MAX;
802 };
803 
805 
806 struct SlotArmInfo {
809 
818  RubberBand::RubberBandStretcher* stretcher;
819 };
820 
821 class LIBARDOUR_API TriggerBox : public Processor, public std::enable_shared_from_this<TriggerBox>
822 {
823  public:
824 
825 #ifdef MIXBUS
826  static const int32_t default_triggers_per_box = 8;
827 #else
828  static const int32_t default_triggers_per_box = 16;
829 #endif
830 
833 
835  static bool cue_recording () { return _cue_recording; }
836  static void set_cue_recording (bool yn);
838 
839  void set_record_enabled (bool yn);
840  RecordState record_enabled() const { return _record_state; }
843 
844  void arm_from_another_thread (Trigger& slot, samplepos_t, uint32_t chans);
845  void disarm();
846  void disarm_all();
847  bool armed() const { return (bool) _arm_info.load(); }
849 
850  void run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, double speed, pframes_t nframes, bool result_required);
851  void run_cycle (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, double speed, pframes_t nframes);
854 
855  bool empty() const { return _active_slots == 0; }
857 
858  int32_t order() const { return _order; }
859  void set_order(int32_t n);
860 
861  typedef std::vector<TriggerPtr> Triggers;
862 
863  TriggerPtr trigger (Triggers::size_type);
864 
865  void bang_trigger_at (Triggers::size_type row, float velocity = 1.0f);
866  void unbang_trigger_at (Triggers::size_type row);
867 
869 
870  void fast_forward (CueEvents const &, samplepos_t transport_postiion);
871  bool fast_forwarding() const { return _fast_forwarding; }
872 
873  void set_pending (uint32_t slot, Trigger*);
874 
875  XMLNode& get_state () const;
876  int set_state (const XMLNode&, int version);
877 
878  void deep_sources (std::set<std::shared_ptr<Source>>&);
879  void used_regions (std::set<std::shared_ptr<Region>>&);
880 
881  void set_from_path (uint32_t slot, std::string const & path);
882  void set_from_selection (uint32_t slot, std::shared_ptr<Region>);
883 
884  DataType data_type() const { return _data_type; }
885 
888 
889  TriggerPtr currently_playing() const { return _currently_playing; }
890 
892 
894  void clear_cue (int cue);
895  void set_all_follow_action (ARDOUR::FollowAction const &, uint32_t n=0);
898  void set_all_probability (int zero_to_a_hundred);
899 
900  /* Returns a negative value is there is no active Trigger, or a value between 0
901  * and 1.0 if there is, corresponding to the value of position_as_fraction() for
902  * the active Trigger.
903  */
904  double position_as_fraction() const;
905 
906  void queue_explict (uint32_t);
909 
910  void request_reload (int32_t slot, void*);
911  void set_region (uint32_t slot, std::shared_ptr<Region> region);
912 
916 
917  void enqueue_trigger_state_for_region (std::shared_ptr<Region>, std::shared_ptr<Trigger::UIState>);
918 
920 
921  /* valid only within the ::run() call tree */
922  int32_t active_scene() const { return _active_scene; }
923 
924  PBD::Signal<void(uint32_t)> TriggerSwapped;
925 
931  };
932 
933  /* This is null for TriggerBoxen constructed with DataType::AUDIO */
935 
936  static bool lookup_custom_midi_binding (std::vector<uint8_t> const &, int& x, int& y);
937  static void add_custom_midi_binding (std::vector<uint8_t> const &, int x, int y);
938  static void remove_custom_midi_binding (int x, int y);
940  static int save_custom_midi_bindings (std::string const & path);
941  static int load_custom_midi_bindings (XMLNode const &);
943 
944  void begin_midi_learn (int index);
945  void midi_unlearn (int index);
947 
948  static Temporal::BBT_Offset assumed_trigger_duration () { return _assumed_trigger_duration; }
950 
951  static TriggerMidiMapMode midi_map_mode () { return _midi_map_mode; }
953 
954  static int first_midi_note() { return _first_midi_note; }
955  static void set_first_midi_note (int n);
956 
957  static void init ();
958  static void static_init (Session&);
959  static void begin_process_cycle ();
960 
962 
964 
966 
969 
970  std::shared_ptr<MidiBuffer> get_gui_feed_buffer () const;
971 
972  void dump (std::ostream &) const;
973 
975 
976  private:
977  struct Requests {
978  std::atomic<bool> stop_all;
979 
980  Requests () : stop_all (false) {}
981  };
982 
984 
986  int32_t _order;
987  mutable Glib::Threads::RWLock trigger_lock; /* protects all_triggers */
989 
990  typedef std::vector<Trigger*> PendingTriggers;
992 
993  PBD::RingBuffer<uint32_t> explicit_queue; /* user queued triggers */
996  bool _stop_all;
997  int32_t _active_scene;
998  int32_t _active_slots;
1003 
1005 
1006  void maybe_capture (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, double speed, pframes_t nframes);
1009 
1010  /* These four are accessed (read/write) only from process() context */
1011 
1012  void drop_triggers ();
1015  int determine_next_trigger (uint32_t n);
1016  void stop_all ();
1017 
1018  void maybe_swap_pending (uint32_t);
1019 
1020  void parameter_changed (std::string const &);
1021  static void static_parameter_changed (std::string const &);
1022 
1023  static int _first_midi_note;
1025 
1026  struct Request {
1027  enum Type {
1030  };
1031 
1033 
1034  /* cannot use a union here because we need Request to have a
1035  * "trivial" constructor.
1036  */
1037 
1039  void* ptr;
1040  int32_t slot;
1041 
1042  Request (Type t) : type (t) {}
1043 
1045  static void init_pool();
1046 
1047  void* operator new (size_t);
1048  void operator delete (void* ptr, size_t);
1049  };
1050 
1053 
1056 
1057  void reload (BufferSet& bufs, int32_t slot, void* ptr);
1058 
1061  int handle_stopped_trigger (BufferSet& bufs, pframes_t dest_offset);
1062 
1064  std::atomic<SlotArmInfo*> _arm_info;
1065 
1070  mutable Glib::Threads::Mutex _gui_feed_reset_mutex;
1071 
1072  typedef std::map<std::vector<uint8_t>,std::pair<int,int> > CustomMidiMap;
1074 
1076  static std::shared_ptr<MIDI::Parser> input_parser;
1078  static void input_port_check ();
1080  static std::shared_ptr<MidiPort> current_input;
1081 
1082  static bool _learning;
1083  static std::pair<int,int> learning_for;
1085 
1086  static void init_pool();
1087 
1088  static std::atomic<int> active_trigger_boxes;
1089  static std::atomic<bool> _cue_recording;
1090  static bool roll_requested;
1091  static void maybe_request_roll (Session&);
1092 };
1093 
1095 {
1096  public:
1098  TriggerReference (std::shared_ptr<ARDOUR::TriggerBox> b, uint32_t s) : weak_box (b), _slot (s) {}
1099 
1100  std::shared_ptr<ARDOUR::Trigger> trigger() const { std::shared_ptr<ARDOUR::TriggerBox> box (weak_box.lock()); return box ? box->trigger (_slot) : std::shared_ptr<ARDOUR::Trigger>(); }
1101  void set (std::shared_ptr<ARDOUR::TriggerBox> b, uint32_t s) { weak_box = b; _slot = s; }
1102  uint32_t slot() const { return _slot; }
1103  std::shared_ptr<ARDOUR::TriggerBox> box() const { return weak_box.lock(); }
1104 
1105  private:
1106  std::weak_ptr<ARDOUR::TriggerBox> weak_box;
1107  uint32_t _slot;
1108 };
1109 
1110 namespace Properties {
1129  LIBARDOUR_API extern PBD::PropertyDescriptor<bool> patch_change; /* type not important */
1130  LIBARDOUR_API extern PBD::PropertyDescriptor<bool> channel_map; /* type not important */
1131  LIBARDOUR_API extern PBD::PropertyDescriptor<bool> used_channels; /* type not important */
1132  LIBARDOUR_API extern PBD::PropertyDescriptor<bool> region; /* type not important */
1133 
1134  LIBARDOUR_API extern PBD::PropertyDescriptor<bool> tempo_meter; /* only used to transmit changes, not storage */
1135 }
1136 
1137 
1138 } // namespace ARDOUR
1139 
1140 namespace PBD {
1144 } /* namespace PBD */
samplecnt_t to_pad
Definition: triggerbox.h:593
RubberBand::RubberBandStretcher * _stretcher
Definition: triggerbox.h:582
samplepos_t _legato_offset
Definition: triggerbox.h:590
bool stretching() const
int set_region_in_worker_thread_from_capture(std::shared_ptr< Region >)
SegmentDescriptor get_segment_descriptor() const
RubberBand::RubberBandStretcher * alloc_stretcher() const
samplepos_t last_readable_sample
Definition: triggerbox.h:589
void set_segment_tempo(double t)
void set_end(timepos_t const &)
timepos_t current_length() const
void set_start(timepos_t const &)
timepos_t compute_end(Temporal::TempoMap::SharedPtr const &, Temporal::BBT_Time const &, samplepos_t, Temporal::Beats &)
timepos_t natural_length() const
samplecnt_t read_index
Definition: triggerbox.h:588
samplecnt_t to_drop
Definition: triggerbox.h:594
XMLNode & get_state() const
void reload(BufferSet &, void *)
uint32_t channels() const
Definition: triggerbox.h:558
AudioTrigger(uint32_t index, TriggerBox &)
double segment_tempo() const
Definition: triggerbox.h:524
RubberBand::RubberBandStretcher * stretcher()
Definition: triggerbox.h:551
void set_length(timecnt_t const &)
size_t data_length() const
Definition: triggerbox.h:575
int set_state(const XMLNode &, int version)
int set_region_in_worker_thread(std::shared_ptr< Region >)
double segment_beatcnt()
Definition: triggerbox.h:527
virtual void setup_stretcher()
void captured(SlotArmInfo &, BufferSet &)
samplepos_t _start_offset
Definition: triggerbox.h:583
void _startup(BufferSet &, pframes_t dest_offset, Temporal::BBT_Offset const &)
int set_region_in_worker_thread_internal(std::shared_ptr< Region > r, bool from_capture)
void set_legato_offset(timepos_t const &)
void set_segment_beatcnt(double count)
StretchMode stretch_mode() const
Definition: triggerbox.h:521
int load_data(std::shared_ptr< AudioRegion >)
void set_stretch_mode(StretchMode)
samplecnt_t retrieved
Definition: triggerbox.h:591
samplecnt_t got_stretcher_padding
Definition: triggerbox.h:592
bool probably_oneshot() const
bool playable() const
Definition: triggerbox.h:519
timepos_t start_offset() const
pframes_t audio_run(BufferSet &bufs, samplepos_t start_sample, samplepos_t end_sample, Temporal::Beats const &start, Temporal::Beats const &end, pframes_t nframes, pframes_t dest_offset, double bpm, pframes_t &quantize_offset)
Sample const * audio_data(size_t n) const
pframes_t run(BufferSet &bufs, samplepos_t start_sample, samplepos_t end_sample, Temporal::Beats const &start, Temporal::Beats const &end, pframes_t nframes, pframes_t dest_offset, double bpm, pframes_t &quantize_offset)
Definition: triggerbox.h:515
void start_and_roll_to(samplepos_t start, samplepos_t position, uint32_t cnt)
void jump_stop(BufferSet &bufs, pframes_t dest_offset)
RTMidiBufferBeats const & rt_midi_buffer() const
Definition: triggerbox.h:674
void set_legato_offset(timepos_t const &)
samplepos_t last_event_samples
Definition: triggerbox.h:693
void check_edit_swap(timepos_t const &, bool playing, BufferSet &)
void shutdown(BufferSet &bufs, pframes_t dest_offset)
Temporal::Beats play_start() const
Definition: triggerbox.h:678
Temporal::Beats loop_start() const
Definition: triggerbox.h:680
std::atomic< PendingSwap * > old_pending_swap
Definition: triggerbox.h:725
uint32_t last_event_index
Definition: triggerbox.h:707
timepos_t current_length() const
void adjust_bounds(Temporal::Beats const &start, Temporal::Beats const &end, Temporal::Beats const &length, bool from_region)
void _startup(BufferSet &, pframes_t dest_offset, Temporal::BBT_Offset const &)
XMLNode & get_state() const
Temporal::Beats _play_start
Definition: triggerbox.h:702
void set_used_channels(Evoral::SMF::UsedChannels)
void compute_and_set_length()
void estimate_midi_patches()
Temporal::Beats _loop_end
Definition: triggerbox.h:705
void reload(BufferSet &, void *)
virtual double segment_tempo() const
Definition: triggerbox.h:664
Temporal::DoubleableBeats last_event_beats
Definition: triggerbox.h:692
Temporal::Beats _loop_start
Definition: triggerbox.h:704
void unset_all_patch_changes()
void bounds_changed(Temporal::timepos_t const &start, Temporal::timepos_t const &end)
timepos_t compute_end(Temporal::TempoMap::SharedPtr const &, Temporal::BBT_Time const &, samplepos_t, Temporal::Beats &)
bool patch_change_set(uint8_t channel) const
void unset_channel_map(int channel)
timepos_t natural_length() const
Temporal::Beats final_beat
Definition: triggerbox.h:689
Temporal::Beats _play_end
Definition: triggerbox.h:703
pframes_t midi_run(BufferSet &, samplepos_t start_sample, samplepos_t end_sample, Temporal::Beats const &start_beats, Temporal::Beats const &end_beats, pframes_t nframes, pframes_t offset, double bpm, pframes_t &quantize_offset)
void unset_patch_change(uint8_t channel)
void set_patch_change(Evoral::PatchChange< MidiBuffer::TimeType > const &)
int set_state(const XMLNode &, int version)
MIDITrigger(uint32_t index, TriggerBox &)
pframes_t run(BufferSet &bufs, samplepos_t start_sample, samplepos_t end_sample, Temporal::Beats const &start, Temporal::Beats const &end, pframes_t nframes, pframes_t dest_offset, double bpm, pframes_t &quantize_offset)
Definition: triggerbox.h:621
bool playable() const
Definition: triggerbox.h:612
timepos_t end() const
std::vector< int > const & channel_map() const
Definition: triggerbox.h:671
std::shared_ptr< MidiModel > _model
Definition: triggerbox.h:698
Evoral::SMF::UsedChannels used_channels() const
Definition: triggerbox.h:659
bool probably_oneshot() const
uint32_t first_event_index
Definition: triggerbox.h:706
Temporal::Beats play_end() const
Definition: triggerbox.h:679
Temporal::Beats loop_end() const
Definition: triggerbox.h:681
std::atomic< PendingSwap * > pending_swap
Definition: triggerbox.h:724
virtual void setup_stretcher()
Definition: triggerbox.h:666
Temporal::BBT_Offset _legato_offset
Definition: triggerbox.h:696
void set_length(timecnt_t const &)
void jump_stop(BufferSet &bufs, pframes_t dest_offset)
void model_contents_changed()
virtual void set_segment_tempo(double t)
Definition: triggerbox.h:665
int channel_map(int channel)
SegmentDescriptor get_segment_descriptor() const
void set_channel_map(int channel, int target)
std::atomic< RTMidiBufferBeats * > rt_midibuffer
Definition: triggerbox.h:709
Evoral::PatchChange< MidiBuffer::TimeType > const patch_change(uint8_t) const
void set_start(timepos_t const &)
int set_region_in_worker_thread(std::shared_ptr< Region >)
timepos_t start_offset() const
PBD::ScopedConnection content_connection
Definition: triggerbox.h:699
int load_data(std::shared_ptr< MidiRegion >)
Temporal::DoubleableBeats data_length
Definition: triggerbox.h:691
void start_and_roll_to(samplepos_t start, samplepos_t position, uint32_t cnt)
void set_end(timepos_t const &)
Temporal::BBT_Offset _start_offset
Definition: triggerbox.h:695
void captured(SlotArmInfo &, BufferSet &)
int set_region_in_worker_thread_from_capture(std::shared_ptr< Region >)
CrossThreadChannel _xthread
Definition: triggerbox.h:786
void build_source(Trigger *, Temporal::timecnt_t const &duration)
void set_region(TriggerBox &, uint32_t slot, std::shared_ptr< Region >)
void queue_request(Request *)
void build_midi_source(MIDITrigger *, Temporal::timecnt_t const &)
void build_audio_source(AudioTrigger *, Temporal::timecnt_t const &)
static void init_request_pool()
Definition: triggerbox.h:742
void delete_trigger(Trigger *)
void request_delete_trigger(Trigger *t)
void request_build_source(Trigger *t, Temporal::timecnt_t const &duration)
PBD::RingBuffer< Request * > requests
Definition: triggerbox.h:784
static void * _thread_work(void *arg)
static TriggerBoxThread * worker
Definition: triggerbox.h:961
static void static_parameter_changed(std::string const &)
void used_regions(std::set< std::shared_ptr< Region >> &)
int32_t active_scene() const
Definition: triggerbox.h:922
static TriggerMidiMapMode _midi_map_mode
Definition: triggerbox.h:1024
static void init()
static PBD::Signal< void()> TriggerRecEnableChanged
Definition: triggerbox.h:842
void arm_from_another_thread(Trigger &slot, samplepos_t, uint32_t chans)
static PBD::ScopedConnectionList static_connections
Definition: triggerbox.h:1079
void process_ui_trigger_requests()
TriggerBox(Session &, DataType dt)
double position_as_fraction() const
void set_record_enabled(bool yn)
void process_request(BufferSet &, Request *)
bool configure_io(ChanCount in, ChanCount out)
DataType _data_type
Definition: triggerbox.h:985
PendingTriggers pending
Definition: triggerbox.h:991
EventRingBuffer< samplepos_t > _gui_feed_fifo
Definition: triggerbox.h:1069
RequestBuffer requests
Definition: triggerbox.h:1052
PBD::ScopedConnection stop_all_connection
Definition: triggerbox.h:1063
void fast_forward_nothing_to_do()
void process_requests(BufferSet &)
TriggerPtr get_next_trigger()
int32_t _active_scene
Definition: triggerbox.h:997
static PBD::Signal< void(PBD::PropertyChange, int)> TriggerBoxPropertyChange
Definition: triggerbox.h:968
static void static_init(Session &)
void maybe_swap_pending(uint32_t)
Triggers all_triggers
Definition: triggerbox.h:988
void set_all_quantization(Temporal::BBT_Offset const &)
void set_armed(SlotArmInfo *)
static TriggerMidiMapMode midi_map_mode()
Definition: triggerbox.h:951
void deep_sources(std::set< std::shared_ptr< Source >> &)
void cancel_locate_armed()
int set_state(const XMLNode &, int version)
static void maybe_request_roll(Session &)
void set_from_selection(uint32_t slot, std::shared_ptr< Region >)
XMLNode & get_state() const
PBD::Signal< void(uint32_t)> TriggerSwapped
Definition: triggerbox.h:924
int handle_stopped_trigger(BufferSet &bufs, pframes_t dest_offset)
static void set_first_midi_note(int n)
static void add_custom_midi_binding(std::vector< uint8_t > const &, int x, int y)
void fast_forward(CueEvents const &, samplepos_t transport_postiion)
void dump(std::ostream &) const
static bool _learning
Definition: triggerbox.h:1082
TriggerPtr trigger(Triggers::size_type)
int32_t order() const
Definition: triggerbox.h:858
static void init_pool()
static CueRecords cue_records
Definition: triggerbox.h:834
int determine_next_trigger(uint32_t n)
void non_realtime_transport_stop(samplepos_t now, bool flush)
TriggerPtr peek_next_trigger()
static void midi_input_handler(MIDI::Parser &, MIDI::byte *, size_t, samplecnt_t)
static void set_midi_map_mode(TriggerMidiMapMode m)
static PBD::ScopedConnection midi_input_connection
Definition: triggerbox.h:1077
DataType data_type() const
Definition: triggerbox.h:884
void begin_midi_learn(int index)
static void clear_custom_midi_bindings()
PBD::Signal< void(samplecnt_t)> Captured
Definition: triggerbox.h:974
static std::pair< int, int > learning_for
Definition: triggerbox.h:1083
PBD::RingBuffer< Request * > RequestBuffer
Definition: triggerbox.h:1051
bool armed() const
Definition: triggerbox.h:847
static Temporal::BBT_Offset assumed_trigger_duration()
Definition: triggerbox.h:948
void midi_unlearn(int index)
static void begin_process_cycle()
bool can_support_io_configuration(const ChanCount &in, ChanCount &out)
void non_realtime_locate(samplepos_t now)
void set_all_launch_style(ARDOUR::Trigger::LaunchStyle)
static bool lookup_custom_midi_binding(std::vector< uint8_t > const &, int &x, int &y)
static std::atomic< int > active_trigger_boxes
Definition: triggerbox.h:1088
static void set_cue_recording(bool yn)
void set_all_follow_action(ARDOUR::FollowAction const &, uint32_t n=0)
std::map< std::vector< uint8_t >, std::pair< int, int > > CustomMidiMap
Definition: triggerbox.h:1072
static std::shared_ptr< MidiPort > current_input
Definition: triggerbox.h:1080
void set_pending(uint32_t slot, Trigger *)
static int first_midi_note()
Definition: triggerbox.h:954
static CustomMidiMap _custom_midi_map
Definition: triggerbox.h:1073
void set_order(int32_t n)
PBD::Signal< void()> ArmedChanged
Definition: triggerbox.h:848
void clear_cue(int cue)
void maybe_capture(BufferSet &bufs, samplepos_t start_sample, samplepos_t end_sample, double speed, pframes_t nframes)
PBD::Signal< void()> EmptyStatusChanged
Definition: triggerbox.h:856
void parameter_changed(std::string const &)
void request_reload(int32_t slot, void *)
static Temporal::BBT_Offset _assumed_trigger_duration
Definition: triggerbox.h:983
void bang_trigger_at(Triggers::size_type row, float velocity=1.0f)
PBD::Signal< void()> RecEnableChanged
Definition: triggerbox.h:841
static void remove_custom_midi_binding(int x, int y)
static bool roll_requested
Definition: triggerbox.h:1090
std::vector< Trigger * > PendingTriggers
Definition: triggerbox.h:990
RecordState _record_state
Definition: triggerbox.h:1002
std::shared_ptr< MidiBuffer > get_gui_feed_buffer() const
static int save_custom_midi_bindings(std::string const &path)
PBD::PCGRand _pcg
Definition: triggerbox.h:1004
std::vector< TriggerPtr > Triggers
Definition: triggerbox.h:861
Requests _requests
Definition: triggerbox.h:995
PBD::RingBuffer< uint32_t > explicit_queue
Definition: triggerbox.h:993
static PBD::Signal< void()> TriggerMIDILearned
Definition: triggerbox.h:1084
void queue_explict(uint32_t)
static std::atomic< bool > _cue_recording
Definition: triggerbox.h:1089
static void set_assumed_trigger_duration(Temporal::BBT_Offset const &)
void reload(BufferSet &bufs, int32_t slot, void *ptr)
void realtime_handle_transport_stopped()
void unbang_trigger_at(Triggers::size_type row)
static PBD::PropertyChange all_trigger_props()
void process_midi_trigger_requests(BufferSet &)
static void start_transport_stop(Session &)
bool fast_forwarding() const
Definition: triggerbox.h:871
static XMLNode * get_custom_midi_binding_state()
bool empty() const
Definition: triggerbox.h:855
TriggerPtr currently_playing() const
Definition: triggerbox.h:889
static int load_custom_midi_bindings(XMLNode const &)
void add_trigger(TriggerPtr)
void finish_recording(BufferSet &bufs)
void run(BufferSet &bufs, samplepos_t start_sample, samplepos_t end_sample, double speed, pframes_t nframes, bool result_required)
static bool cue_recording()
Definition: triggerbox.h:835
void send_property_change(PBD::PropertyChange pc)
void enqueue_trigger_state_for_region(std::shared_ptr< Region >, std::shared_ptr< Trigger::UIState >)
Glib::Threads::Mutex _gui_feed_reset_mutex
Definition: triggerbox.h:1070
static PBD::Signal< void()> CueRecordingChanged
Definition: triggerbox.h:837
static int _first_midi_note
Definition: triggerbox.h:1023
void run_cycle(BufferSet &bufs, samplepos_t start_sample, samplepos_t end_sample, double speed, pframes_t nframes)
static void input_port_check()
void set_region(uint32_t slot, std::shared_ptr< Region > region)
void set_from_path(uint32_t slot, std::string const &path)
Glib::Threads::RWLock trigger_lock
Definition: triggerbox.h:987
std::atomic< SlotArmInfo * > _arm_info
Definition: triggerbox.h:1064
void set_all_probability(int zero_to_a_hundred)
void stop_all_immediately()
MidiStateTracker * tracker
Definition: triggerbox.h:934
TriggerPtr trigger_by_id(PBD::ID)
static std::shared_ptr< MIDI::Parser > input_parser
Definition: triggerbox.h:1076
TriggerPtr _currently_playing
Definition: triggerbox.h:994
int32_t _active_slots
Definition: triggerbox.h:998
RecordState record_enabled() const
Definition: triggerbox.h:840
TriggerReference(std::shared_ptr< ARDOUR::TriggerBox > b, uint32_t s)
Definition: triggerbox.h:1098
std::shared_ptr< ARDOUR::Trigger > trigger() const
Definition: triggerbox.h:1100
void set(std::shared_ptr< ARDOUR::TriggerBox > b, uint32_t s)
Definition: triggerbox.h:1101
std::shared_ptr< ARDOUR::TriggerBox > box() const
Definition: triggerbox.h:1103
std::weak_ptr< ARDOUR::TriggerBox > weak_box
Definition: triggerbox.h:1106
uint32_t slot() const
Definition: triggerbox.h:1102
uint32_t loop_count() const
Definition: triggerbox.h:384
void process_state_requests(BufferSet &bufs, pframes_t dest_offset)
double _estimated_tempo
Definition: triggerbox.h:475
Temporal::Meter meter() const
Definition: triggerbox.h:412
virtual void shutdown(BufferSet &bufs, pframes_t dest_offset)
bool will_not_follow() const
samplecnt_t process_index
Definition: triggerbox.h:446
PBD::Property< bool > _cue_isolated
Definition: triggerbox.h:163
virtual void set_patch_change(Evoral::PatchChange< MidiBuffer::TimeType > const &)
Definition: triggerbox.h:404
uint32_t _loop_cnt
Definition: triggerbox.h:457
std::vector< int > _channel_map
Definition: triggerbox.h:468
PBD::Property< LaunchStyle > _launch_style
Definition: triggerbox.h:151
virtual Evoral::SMF::UsedChannels used_channels() const
Definition: triggerbox.h:400
virtual Evoral::PatchChange< MidiBuffer::TimeType > const patch_change(uint8_t) const
Definition: triggerbox.h:405
PBD::Property< Temporal::BBT_Offset > _quantization
Definition: triggerbox.h:156
virtual timepos_t current_length() const =0
Temporal::BBT_Offset _start_quantization
Definition: triggerbox.h:491
PBD::Property< FollowAction > _follow_action0
Definition: triggerbox.h:152
bool armed() const
Definition: triggerbox.h:302
void set_ui(void *)
TriggerBox & box() const
Definition: triggerbox.h:389
pframes_t compute_next_transition(samplepos_t start_sample, Temporal::Beats const &start, Temporal::Beats const &end, pframes_t nframes, Temporal::BBT_Argument &t_bbt, Temporal::Beats &t_beats, samplepos_t &t_samples, Temporal::TempoMap::SharedPtr const &tmap)
PBD::Property< FollowAction > _follow_action1
Definition: triggerbox.h:153
std::atomic< int > _bang
Definition: triggerbox.h:453
virtual bool patch_change_set(uint8_t channel) const
Definition: triggerbox.h:408
void begin_stop(bool explicit_stop=false)
PBD::Property< float > _velocity_effect
Definition: triggerbox.h:161
Temporal::Meter _meter
Definition: triggerbox.h:488
virtual void bounds_changed(Temporal::timepos_t const &start, Temporal::timepos_t const &end)
Definition: triggerbox.h:437
PBD::Property< bool > _stretchable
Definition: triggerbox.h:162
samplepos_t transition_samples
Definition: triggerbox.h:342
static PBD::Signal< void(Trigger const *)> TriggerArmChanged
Definition: triggerbox.h:304
void region_property_change(PBD::PropertyChange const &)
void set_region_internal(std::shared_ptr< Region >)
double position_as_fraction() const
int next_trigger() const
Definition: triggerbox.h:367
virtual void io_change()
Definition: triggerbox.h:293
samplepos_t final_processed_sample
Definition: triggerbox.h:447
static void request_trigger_delete(Trigger *t)
static Trigger *const MagicClearPointerValue
Definition: triggerbox.h:421
PBD::ScopedConnection region_connection
Definition: triggerbox.h:495
virtual void set_end(timepos_t const &)=0
PBD::Property< int > _follow_action_probability
Definition: triggerbox.h:154
virtual void jump_stop(BufferSet &bufs, pframes_t dest_offset)
virtual int set_region_in_worker_thread(std::shared_ptr< Region >)=0
virtual void captured(SlotArmInfo &, BufferSet &)
Definition: triggerbox.h:299
virtual void unset_patch_change(uint8_t channel)
Definition: triggerbox.h:406
virtual timepos_t compute_end(Temporal::TempoMap::SharedPtr const &, Temporal::BBT_Time const &, samplepos_t, Temporal::Beats &)=0
virtual void jump_start()
virtual void start_and_roll_to(samplepos_t start, samplepos_t position, uint32_t cnt)=0
void when_stopped_during_run(BufferSet &bufs, pframes_t dest_offset)
std::atomic< int > _unbang
Definition: triggerbox.h:454
bool will_follow() const
Definition: triggerbox.h:313
virtual timepos_t start_offset() const =0
int set_state(const XMLNode &, int version)
State state() const
Definition: triggerbox.h:327
PBD::Signal< void()> ArmChanged
Definition: triggerbox.h:303
PBD::Property< std::string > _name
Definition: triggerbox.h:169
virtual ~Trigger()
Definition: triggerbox.h:144
PBD::Property< gain_t > _gain
Definition: triggerbox.h:160
std::shared_ptr< TriggerBox > boxptr() const
bool active() const
Definition: triggerbox.h:326
static void make_property_quarks()
void copy_to_ui_state()
uint32_t index() const
Definition: triggerbox.h:336
virtual SegmentDescriptor get_segment_descriptor() const =0
Temporal::BBT_Argument compute_start(Temporal::TempoMap::SharedPtr const &, samplepos_t start, samplepos_t end, Temporal::BBT_Offset const &q, samplepos_t &start_samples, bool &will_start)
virtual void disarm()
samplepos_t expected_end_sample
Definition: triggerbox.h:490
virtual void arm()
std::shared_ptr< Region > the_region() const
Definition: triggerbox.h:333
PBD::Property< uint32_t > _follow_count
Definition: triggerbox.h:155
virtual void set_used_channels(Evoral::SMF::UsedChannels)
Definition: triggerbox.h:401
virtual int set_region_in_worker_thread_from_capture(std::shared_ptr< Region >)=0
PBD::Property< StretchMode > _stretch_mode
Definition: triggerbox.h:165
void set_ui_state(UIState &state)
Trigger(uint32_t index, TriggerBox &)
virtual void set_legato_offset(timepos_t const &offset)=0
void shutdown_from_fwd()
timepos_t current_pos() const
gain_t _pending_velocity_gain
Definition: triggerbox.h:460
virtual timepos_t natural_length() const =0
uint32_t _index
Definition: triggerbox.h:455
virtual void retrigger()
bool cue_launched() const
Definition: triggerbox.h:316
void set_pending(Trigger *)
virtual void reload(BufferSet &, void *)=0
virtual void setup_stretcher()=0
virtual bool probably_oneshot() const =0
void set_velocity_gain(gain_t g)
Definition: triggerbox.h:414
gain_t _velocity_gain
Definition: triggerbox.h:461
void stop_quantized()
virtual void _startup(BufferSet &, pframes_t dest_offset, Temporal::BBT_Offset const &)
UIState ui_state
Definition: triggerbox.h:448
std::shared_ptr< Region > _region
Definition: triggerbox.h:445
void startup_from_ffwd(BufferSet &, uint32_t loop_cnt)
virtual void set_length(timecnt_t const &)=0
virtual double segment_tempo() const =0
PBD::Property< bool > _legato
Definition: triggerbox.h:159
virtual void unset_all_patch_changes()
Definition: triggerbox.h:407
Trigger * swap_pending(Trigger *)
PBD::Property< color_t > _color
Definition: triggerbox.h:170
void begin_switch(TriggerPtr)
Evoral::SMF::UsedChannels _used_channels
Definition: triggerbox.h:466
bool compute_quantized_transition(samplepos_t start_sample, Temporal::Beats const &start, Temporal::Beats const &end, Temporal::BBT_Argument &t_bbt, Temporal::Beats &t_beats, samplepos_t &t_samples, Temporal::TempoMap::SharedPtr const &tmap, Temporal::BBT_Offset const &q)
XMLNode & get_state() const
PBD::Property< Temporal::BBT_Offset > _follow_length
Definition: triggerbox.h:157
static PBD::Signal< void(PBD::PropertyChange, Trigger *)> TriggerPropertyChange
Definition: triggerbox.h:434
void set_region(std::shared_ptr< Region >, bool use_thread=true)
double estimated_tempo() const
Definition: triggerbox.h:392
void get_ui_state(UIState &state) const
void * ui() const
Definition: triggerbox.h:387
UIRequests _requests
Definition: triggerbox.h:450
std::atomic< Trigger * > _pending
Definition: triggerbox.h:493
Temporal::BBT_Time _transition_bbt
Definition: triggerbox.h:344
void bang(float velocity=1.0f)
Temporal::Beats transition_beats
Definition: triggerbox.h:343
void maybe_compute_next_transition(samplepos_t start_sample, Temporal::Beats const &start, Temporal::Beats const &end, pframes_t &nframes, pframes_t &dest_offset)
void update_properties()
PBD::Property< bool > _use_follow_length
Definition: triggerbox.h:158
Temporal::BBT_Offset _nxt_quantization
Definition: triggerbox.h:492
virtual void set_segment_tempo(double t)=0
virtual bool playable() const =0
void send_property_change(PBD::PropertyChange pc)
virtual pframes_t run(BufferSet &, samplepos_t start_sample, samplepos_t end_sample, Temporal::Beats const &start, Temporal::Beats const &end, pframes_t nframes, pframes_t offset, double bpm, pframes_t &quantize_offset)=0
virtual void set_start(timepos_t const &)=0
void set_next_trigger(int n)
void start_and_roll_to(samplepos_t start_pos, samplepos_t end_position, TriggerType &trigger, pframes_t(TriggerType::*run_method)(BufferSet &bufs, samplepos_t start_sample, samplepos_t end_sample, Temporal::Beats const &start_beats, Temporal::Beats const &end_beats, pframes_t nframes, pframes_t dest_offset, double bpm, pframes_t &), uint32_t cnt)
bool explicitly_stopped() const
Definition: triggerbox.h:382
TriggerBox & _box
Definition: triggerbox.h:449
bool _explicitly_stopped
Definition: triggerbox.h:459
PBD::Property< bool > _allow_patch_changes
Definition: triggerbox.h:164
double _segment_tempo
Definition: triggerbox.h:476
std::atomic< unsigned int > last_property_generation
Definition: triggerbox.h:494
virtual void check_edit_swap(timepos_t const &time, bool playing, BufferSet &bufs)
Definition: triggerbox.h:432
virtual void tempo_map_changed()
Definition: triggerbox.h:284
void startup(BufferSet &, pframes_t dest_offset, Temporal::BBT_Offset const &start_quantization=Temporal::BBT_Offset(9, 3, 0))
bool internal_use_follow_length() const
bool is_set() const
Definition: PatchChange.h:110
std::bitset< 16 > UsedChannels
Definition: SMF.h:105
Definition: id.h:34
std::shared_ptr< TempoMap const > SharedPtr
Definition: xml++.h:114
GtkImageIconNameData name
Definition: gtkimage.h:6
#define LIBARDOUR_API
PBD::PropertyDescriptor< uint32_t > queued
PBD::PropertyDescriptor< gain_t > gain
PBD::PropertyDescriptor< bool > legato
PBD::PropertyDescriptor< bool > tempo_meter
PBD::PropertyDescriptor< Temporal::BBT_Offset > follow_length
PBD::PropertyDescriptor< bool > use_follow_length
PBD::PropertyDescriptor< bool > running
PBD::PropertyDescriptor< Trigger::LaunchStyle > launch_style
PBD::PropertyDescriptor< uint32_t > color
PBD::PropertyDescriptor< uint32_t > currently_playing
PBD::PropertyDescriptor< int > follow_action_probability
PBD::PropertyDescriptor< bool > allow_patch_changes
PBD::PropertyDescriptor< timecnt_t > length
PBD::PropertyDescriptor< bool > cue_isolated
PBD::PropertyDescriptor< Temporal::BBT_Offset > quantization
PBD::PropertyDescriptor< bool > region
PBD::PropertyDescriptor< bool > patch_change
PBD::PropertyDescriptor< FollowAction > follow_action1
PBD::PropertyDescriptor< timepos_t > start
PBD::PropertyDescriptor< float > velocity_effect
PBD::PropertyDescriptor< FollowAction > follow_action0
PBD::PropertyDescriptor< uint32_t > follow_count
PBD::PropertyDescriptor< bool > stretchable
PBD::PropertyDescriptor< bool > used_channels
PBD::PropertyDescriptor< Trigger::StretchMode > stretch_mode
PBD::PropertyDescriptor< bool > channel_map
PBD::RingBuffer< CueRecord > CueRecords
Definition: triggerbox.h:804
std::shared_ptr< Trigger > TriggerPtr
Definition: triggerbox.h:83
uint32_t pframes_t
std::vector< CueEvent > CueEvents
Temporal::samplecnt_t samplecnt_t
uint32_t color_t
Definition: triggerbox.h:77
RTMidiBufferBase< Temporal::Beats, Temporal::Beats > RTMidiBufferBeats
Definition: triggerbox.h:86
std::string cue_marker_name(int32_t)
Temporal::samplepos_t samplepos_t
void flush()
DebugBits Properties
Definition: axis_view.h:42
DEFINE_ENUM_CONVERT(ARDOUR::Track::FreezeState)
samplecnt_t append(Sample const *src, samplecnt_t cnt, uint32_t chan)
void alloc(samplecnt_t cnt, uint32_t nchans)
int32_t cue_number
Definition: triggerbox.h:795
static const int32_t stop_all
Definition: triggerbox.h:801
CueRecord(int32_t cn, samplepos_t t)
Definition: triggerbox.h:798
samplepos_t when
Definition: triggerbox.h:796
RTMidiBufferBeats * rt_midibuffer
Definition: triggerbox.h:713
Temporal::Beats end_beats
Definition: triggerbox.h:813
AudioTrigger::AudioData audio_buf
Definition: triggerbox.h:817
samplepos_t end_samples
Definition: triggerbox.h:814
Temporal::Beats start_beats
Definition: triggerbox.h:811
samplecnt_t captured
Definition: triggerbox.h:815
SlotArmInfo(Trigger &s)
samplepos_t start_samples
Definition: triggerbox.h:812
RTMidiBufferBeats * midi_buf
Definition: triggerbox.h:816
RubberBand::RubberBandStretcher * stretcher
Definition: triggerbox.h:818
Temporal::timecnt_t duration
Definition: triggerbox.h:774
static PBD::MultiAllocSingleReleasePool * pool
Definition: triggerbox.h:779
std::shared_ptr< Region > region
Definition: triggerbox.h:771
static PBD::MultiAllocSingleReleasePool * pool
Definition: triggerbox.h:1044
std::atomic< bool > stop_all
Definition: triggerbox.h:978
std::atomic< bool > stop
Definition: triggerbox.h:441
Temporal::BBT_Offset quantization
Definition: triggerbox.h:184
Temporal::BBT_Offset follow_length
Definition: triggerbox.h:185
StretchMode stretch_mode
Definition: triggerbox.h:193
LaunchStyle launch_style
Definition: triggerbox.h:179
FollowAction follow_action0
Definition: triggerbox.h:180
std::atomic< unsigned int > generation
Definition: triggerbox.h:177
Evoral::SMF::UsedChannels used_channels
Definition: triggerbox.h:195
Evoral::PatchChange< MidiBuffer::TimeType > patch_change[16]
Definition: triggerbox.h:196
FollowAction follow_action1
Definition: triggerbox.h:181
#define TRIGGERBOX_PROPERTY_DECL_CONST_REF(name, type)
Definition: triggerbox.h:242
#define TRIGGERBOX_PROPERTY_DECL(name, type)
Definition: triggerbox.h:241