gtk2_ardour/level_meter.cc

   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 */
  19
  20 #include <limits.h>
  21
  22 #include "ardour/session.h"
  23 #include "ardour/session_route.h"
  24 #include "ardour/dB.h"
  25 #include "ardour/meter.h"
  26
  27 #include <gtkmm2ext/utils.h>
  28 #include <gtkmm2ext/fastmeter.h>
  29 #include <gtkmm2ext/stop_signal.h>
  30 #include <gtkmm2ext/barcontroller.h>
  31 #include "midi++/manager.h"
  32 #include "pbd/fastlog.h"
  33
  34 #include "ardour_ui.h"
  35 #include "level_meter.h"
  36 #include "utils.h"
  37 #include "logmeter.h"
  38 #include "gui_thread.h"
  39 #include "keyboard.h"
  40 #include "public_editor.h"
  41
  42 #include "ardour/session.h"
  43
  44 #include "i18n.h"
  45
  46 using namespace ARDOUR;
  47 using namespace PBD;
  48 using namespace Gtkmm2ext;
  49 using namespace Gtk;
  50 using namespace std;
  51
  52 //sigc::signal<void> LevelMeter::ResetAllPeakDisplays;
  53 //sigc::signal<void,RouteGroup*> LevelMeter::ResetGroupPeakDisplays;
  54
  55
  56 LevelMeter::LevelMeter (Session* s)
  57         : _meter (0)
  58         , meter_length (0)
  59 {
  60         set_session (s);
  61         set_spacing (1);
  62         Config->ParameterChanged.connect (_parameter_connection, ui_bind (&LevelMeter::parameter_changed, this, _1), gui_context());
  63         UI::instance()->theme_changed.connect (sigc::mem_fun(*this, &LevelMeter::on_theme_changed));
  64         ColorsChanged.connect (sigc::mem_fun (*this, &LevelMeter::color_handler));
  65         max_peak = minus_infinity();
  66 }
  67
  68 void
  69 LevelMeter::on_theme_changed()
  70 {
  71         style_changed = true;
  72 }
  73
  74 LevelMeter::~LevelMeter ()
  75 {
  76         for (vector<MeterInfo>::iterator i = meters.begin(); i != meters.end(); i++) {
  77                 delete (*i).meter;
  78         }
  79 }
  80
  81 void
  82 LevelMeter::set_meter (PeakMeter* meter)
  83 {
  84         _configuration_connection.disconnect();
  85         _meter = meter;
  86
  87         if (_meter) {
  88                 _meter->ConfigurationChanged.connect (_configuration_connection, ui_bind (&LevelMeter::configuration_changed, this, _1, _2), gui_context());
  89         }
  90 }
  91
  92 float
  93 LevelMeter::update_meters ()
  94 {
  95         vector<MeterInfo>::iterator i;
  96         uint32_t n;
  97         float peak, mpeak;
  98
  99         if (!_meter) {
 100                 return 0.0f;
 101         }
 102
 103         for (n = 0, i = meters.begin(); i != meters.end(); ++i, ++n) {
 104                 if ((*i).packed) {
 105                         peak = _meter->peak_power (n);
 106                         (*i).meter->set (log_meter (peak));
 107                         mpeak = _meter->max_peak_power(n);
 108                         if (mpeak > max_peak) {
 109                                 max_peak = mpeak;
 110                         }
 111                         if (mpeak > max_peak) {
 112                                 max_peak = mpeak;
 113                         }
 114                 }
 115         }
 116         return max_peak;
 117 }
 118
 119 void
 120 LevelMeter::parameter_changed (string p)
 121 {
 122         ENSURE_GUI_THREAD (*this, &LevelMeter::parameter_changed, p)
 123
 124         if (p == "meter-hold") {
 125
 126                 vector<MeterInfo>::iterator i;
 127                 uint32_t n;
 128
 129                 for (n = 0, i = meters.begin(); i != meters.end(); ++i, ++n) {
 130
 131                         (*i).meter->set_hold_count ((uint32_t) floor(Config->get_meter_hold()));
 132                 }
 133         }
 134 }
 135
 136 void
 137 LevelMeter::configuration_changed (ChanCount /*in*/, ChanCount /*out*/)
 138 {
 139         color_changed = true;
 140         setup_meters (meter_length, regular_meter_width);
 141 }
 142
 143 void
 144 LevelMeter::hide_all_meters ()
 145 {
 146         for (vector<MeterInfo>::iterator i = meters.begin(); i != meters.end(); ++i) {
 147                 if ((*i).packed) {
 148                         remove (*((*i).meter));
 149                         (*i).packed = false;
 150                 }
 151         }
 152 }
 153
 154 void
 155 LevelMeter::setup_meters (int len, int initial_width)
 156 {
 157         hide_all_meters ();
 158
 159         if (!_meter) {
 160                 return; /* do it later or never */
 161         }
 162
 163         int32_t nmidi = _meter->input_streams().n_midi();
 164         uint32_t nmeters = _meter->input_streams().n_total();
 165         regular_meter_width = initial_width;
 166         meter_length = len;
 167
 168         guint16 width;
 169
 170         if (nmeters == 0) {
 171                 return;
 172         }
 173
 174         if (nmeters <= 2) {
 175                 width = regular_meter_width;
 176         } else {
 177                 width = thin_meter_width;
 178         }
 179
 180         while (meters.size() < nmeters) {
 181                 meters.push_back (MeterInfo());
 182         }
 183
 184         //cerr << "LevelMeter::setup_meters() called color_changed = " << color_changed << " colors: " << endl;//DEBUG
 185
 186         for (int32_t n = nmeters-1; nmeters && n >= 0 ; --n) {
 187                 uint32_t b, m, t, c;
 188                 if (n < nmidi) {
 189                         b = ARDOUR_UI::config()->canvasvar_MidiNoteMeterColorBase.get();
 190                         m = ARDOUR_UI::config()->canvasvar_MidiNoteMeterColorMid.get();
 191                         t = ARDOUR_UI::config()->canvasvar_MidiNoteMeterColorTop.get();
 192                         c = ARDOUR_UI::config()->canvasvar_MeterColorClip.get();
 193                 } else {
 194                         b = ARDOUR_UI::config()->canvasvar_MeterColorBase.get();
 195                         m = ARDOUR_UI::config()->canvasvar_MeterColorMid.get();
 196                         t = ARDOUR_UI::config()->canvasvar_MeterColorTop.get();
 197                         c = ARDOUR_UI::config()->canvasvar_MeterColorClip.get();
 198                 }
 199                 if (meters[n].width != width || meters[n].length != len || color_changed) {
 200                         delete meters[n].meter;
 201                         meters[n].meter = new FastMeter ((uint32_t) floor (Config->get_meter_hold()), width, FastMeter::Vertical, len, b, m, t, c);
 202                         //cerr << "LevelMeter::setup_meters() w:l = " << width << ":" << len << endl;//DEBUG
 203                         meters[n].width = width;
 204                         meters[n].length = len;
 205                         meters[n].meter->add_events (Gdk::BUTTON_RELEASE_MASK);
 206                         meters[n].meter->signal_button_release_event().connect (sigc::bind (sigc::mem_fun(*this, &LevelMeter::meter_button_release), n));
 207                 }
 208
 209                 pack_end (*meters[n].meter, false, false);
 210                 meters[n].meter->show_all ();
 211                 meters[n].packed = true;
 212         }
 213         show();
 214         color_changed = false;
 215 }
 216
 217 gint
 218 LevelMeter::meter_button_release (GdkEventButton* ev, uint32_t /*which*/)
 219 {
 220         if (ev->button == 1) {
 221                 clear_meters();
 222         }
 223         return true;
 224 }
 225
 226
 227 void LevelMeter::clear_meters ()
 228 {
 229         for (vector<MeterInfo>::iterator i = meters.begin(); i < meters.end(); i++) {
 230                 (*i).meter->clear();
 231         }
 232         max_peak = minus_infinity();
 233 }
 234
 235 void LevelMeter::hide_meters ()
 236 {
 237         hide_all_meters();
 238 }
 239
 240 void
 241 LevelMeter::color_handler ()
 242 {
 243         color_changed = true;
 244 }
 245