libs/ardour/ardour/audio_track.h

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