libs/ardour/ardour/port.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_port_h__
  22 #define __ardour_port_h__
  23
  24 #include <sigc++/signal.h>
  25 #include <pbd/failed_constructor.h>
  26 #include <ardour/ardour.h>
  27 #include <jack/jack.h>
  28
  29 namespace ARDOUR {
  30
  31 class AudioEngine;
  32
  33 class Port : public sigc::trackable {
  34    public:
  35         virtual ~Port() {
  36                 free (_port);
  37         }
  38
  39         Sample *get_buffer (jack_nframes_t nframes) {
  40                 if (_flags & JackPortIsOutput) {
  41                         return _buffer;
  42                 } else {
  43                         return (Sample *) jack_port_get_buffer (_port, nframes);
  44                 }
  45         }
  46
  47         void reset_buffer () {
  48                 if (_flags & JackPortIsOutput) {
  49                         _buffer = (Sample *) jack_port_get_buffer (_port, 0);
  50                 } else {
  51                         _buffer = 0; /* catch illegal attempts to use it */
  52                 }
  53                 _silent = false;
  54         }
  55
  56         std::string name() {
  57                 return _name;
  58         }
  59
  60         std::string short_name() {
  61                 return jack_port_short_name (_port);
  62         }
  63
  64         int set_name (std::string str);
  65
  66         JackPortFlags flags() const {
  67                 return _flags;
  68         }
  69
  70         bool is_mine (jack_client_t *client) {
  71                 return jack_port_is_mine (client, _port);
  72         }
  73
  74         const char* type() const {
  75                 return _type.c_str();
  76         }
  77
  78         int connected () const {
  79                 return jack_port_connected (_port);
  80         }
  81
  82         bool connected_to (const std::string& portname) const {
  83                 return jack_port_connected_to (_port, portname.c_str());
  84         }
  85
  86         const char ** get_connections () const {
  87                 return jack_port_get_connections (_port);
  88         }
  89
  90         void reset_overs () {
  91                 _short_overs = 0;
  92                 _long_overs = 0;
  93                 _overlen = 0;
  94         }
  95
  96         void reset_peak_meter () {
  97                 _peak = 0;
  98         }
  99
 100         void reset_meters () {
 101                 reset_peak_meter ();
 102                 reset_overs ();
 103         }
 104
 105         void enable_metering() {
 106                 _metering++;
 107         }
 108
 109         void disable_metering () {
 110                 if (_metering) { _metering--; }
 111         }
 112
 113         float                       peak_db() const { return _peak_db; }
 114         jack_default_audio_sample_t peak()    const { return _peak; }
 115
 116         uint32_t short_overs () const { return _short_overs; }
 117         uint32_t long_overs ()  const { return _long_overs; }
 118
 119         static void set_short_over_length (jack_nframes_t);
 120         static void set_long_over_length (jack_nframes_t);
 121
 122         bool receives_input() const {
 123                 return _flags & JackPortIsInput;
 124         }
 125
 126         bool sends_output () const {
 127                 return _flags & JackPortIsOutput;
 128         }
 129
 130         bool monitoring_input () const {
 131                 return jack_port_monitoring_input (_port);
 132         }
 133
 134         bool can_monitor () const {
 135                 return _flags & JackPortCanMonitor;
 136         }
 137
 138         void ensure_monitor_input (bool yn) {
 139                 jack_port_ensure_monitor (_port, yn);
 140         }
 141
 142         /*XXX completely bloody useless imho*/
 143         void request_monitor_input (bool yn) {
 144                 jack_port_request_monitor (_port, yn);
 145         }
 146
 147         jack_nframes_t latency () const {
 148                 return jack_port_get_latency (_port);
 149         }
 150
 151         void set_latency (jack_nframes_t nframes) {
 152                 jack_port_set_latency (_port, nframes);
 153         }
 154
 155         sigc::signal<void,bool> MonitorInputChanged;
 156         sigc::signal<void,bool> ClockSyncChanged;
 157
 158         bool is_silent() const { return _silent; }
 159
 160         /** Assumes that the port is an audio output port */
 161         void silence (jack_nframes_t nframes, jack_nframes_t offset) {
 162                 if (!_silent) {
 163                         memset (_buffer + offset, 0, sizeof (Sample) * nframes);
 164                         if (offset == 0) {
 165                                 /* XXX this isn't really true, but i am not sure
 166                                    how to set this correctly. we really just
 167                                    want to set it true when the entire port
 168                                    buffer has been overrwritten.
 169                                 */
 170                                 _silent = true;
 171                         }
 172                 }
 173         }
 174
 175         void mark_silence (bool yn) {
 176                 _silent = yn;
 177         }
 178
 179   private:
 180         friend class AudioEngine;
 181
 182         Port (jack_port_t *port);
 183         void reset ();
 184
 185         /* engine isn't supposed to below here */
 186
 187         Sample *_buffer;
 188
 189         /* cache these 3 from JACK so that we can
 190            access them for reconnecting.
 191         */
 192
 193         JackPortFlags _flags;
 194         std::string   _type;
 195         std::string   _name;
 196
 197         bool                         _last_monitor : 1;
 198         bool                         _silent : 1;
 199         jack_port_t                 *_port;
 200         jack_nframes_t               _overlen;
 201         jack_default_audio_sample_t  _peak;
 202         float                        _peak_db;
 203         uint32_t                     _short_overs;
 204         uint32_t                     _long_overs;
 205         unsigned short               _metering;
 206
 207         static jack_nframes_t        _long_over_length;
 208         static jack_nframes_t        _short_over_length;
 209 };
 210
 211 } // namespace ARDOUR
 212
 213 #endif /* __ardour_port_h__ */