libs/ardour/ardour/audio_track.h

   1 /*
   2     Copyright (C) 2002 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 #ifndef __ardour_audio_track_h__
  22 #define __ardour_audio_track_h__
  23
  24 #include <ardour/route.h>
  25
  26 namespace ARDOUR {
  27
  28 class Session;
  29 class DiskStream;
  30 class AudioPlaylist;
  31
  32 class AudioTrack : public Route
  33 {
  34   public:
  35         AudioTrack (Session&, string name, Route::Flag f = Route::Flag (0));
  36         AudioTrack (Session&, const XMLNode&);
  37         ~AudioTrack ();
  38
  39         int set_name (string str, void *src);
  40
  41         int  roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame,
  42
  43                    jack_nframes_t offset, int declick, bool can_record, bool rec_monitors_input);
  44         int  no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame,
  45                       jack_nframes_t offset, bool state_changing, bool can_record, bool rec_monitors_input);
  46         int  silent_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame,
  47                           jack_nframes_t offset, bool can_record, bool rec_monitors_input);
  48
  49         void toggle_monitor_input ();
  50
  51         bool can_record() const { return true; }
  52         void set_record_enable (bool yn, void *src);
  53
  54         DiskStream& disk_stream() const { return *diskstream; }
  55         int set_diskstream (DiskStream&, void *);
  56         int use_diskstream (string name);
  57         int use_diskstream (id_t id);
  58
  59         jack_nframes_t update_total_latency();
  60         void set_latency_delay (jack_nframes_t);
  61
  62         int export_stuff (vector<Sample*>& buffers, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t end_frame);
  63
  64         sigc::signal<void,void*> diskstream_changed;
  65
  66         enum FreezeState {
  67                 NoFreeze,
  68                 Frozen,
  69                 UnFrozen
  70         };
  71
  72         FreezeState freeze_state() const;
  73
  74         sigc::signal<void> FreezeChange;
  75
  76         void freeze (InterThreadInfo&);
  77         void unfreeze ();
  78
  79         void bounce (InterThreadInfo&);
  80         void bounce_range (jack_nframes_t start, jack_nframes_t end, InterThreadInfo&);
  81
  82         XMLNode& get_state();
  83         int set_state(const XMLNode& node);
  84
  85         MIDI::Controllable& midi_rec_enable_control() {
  86                 return _midi_rec_enable_control;
  87         }
  88
  89         void reset_midi_control (MIDI::Port*, bool);
  90         void send_all_midi_feedback ();
  91
  92         bool record_enabled() const;
  93         void set_meter_point (MeterPoint, void* src);
  94
  95   protected:
  96         DiskStream *diskstream;
  97         MeterPoint _saved_meter_point;
  98
  99         void passthru_silence (jack_nframes_t start_frame, jack_nframes_t end_frame,
 100                                jack_nframes_t nframes, jack_nframes_t offset, int declick,
 101                                bool meter);
 102
 103         uint32_t n_process_buffers ();
 104
 105   private:
 106         struct FreezeRecordInsertInfo {
 107             FreezeRecordInsertInfo(XMLNode& st)
 108                     : state (st), insert (0) {}
 109
 110             XMLNode  state;
 111             Insert*  insert;
 112             id_t     id;
 113             UndoAction memento;
 114         };
 115
 116         struct FreezeRecord {
 117             FreezeRecord() {
 118                     playlist = 0;
 119                     have_mementos = false;
 120             }
 121
 122             ~FreezeRecord();
 123
 124             AudioPlaylist* playlist;
 125             vector<FreezeRecordInsertInfo*> insert_info;
 126             bool have_mementos;
 127             FreezeState state;
 128         };
 129
 130         FreezeRecord _freeze_record;
 131         XMLNode* pending_state;
 132
 133         void diskstream_record_enable_changed (void *src);
 134         void diskstream_input_channel_changed (void *src);
 135
 136         void input_change_handler (void *src);
 137
 138         sigc::connection recenable_connection;
 139         sigc::connection ic_connection;
 140
 141         XMLNode& state(bool);
 142
 143         int deprecated_use_diskstream_connections ();
 144         void set_state_part_two ();
 145         void set_state_part_three ();
 146
 147         struct MIDIRecEnableControl : public MIDI::Controllable {
 148                 MIDIRecEnableControl (AudioTrack&, MIDI::Port *);
 149                 void set_value (float);
 150                 void send_feedback (bool);
 151                 MIDI::byte* write_feedback (MIDI::byte* buf, int32_t& bufsize, bool val, bool force = false);
 152                 AudioTrack& track;
 153                 bool setting;
 154                 bool last_written;
 155         };
 156
 157         MIDIRecEnableControl _midi_rec_enable_control;
 158 };
 159
 160 }; /* namespace ARDOUR*/
 161
 162 #endif /* __ardour_audio_track_h__ */