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/meter.h"
  23
  24 #include <gtkmm2ext/utils.h>
  25 #include <gtkmm2ext/fastmeter.h>
  26 #include <gtkmm2ext/barcontroller.h>
  27 #include "midi++/manager.h"
  28 #include "pbd/fastlog.h"
  29
  30 #include "ardour_ui.h"
  31 #include "global_signals.h"
  32 #include "level_meter.h"
  33 #include "utils.h"
  34 #include "logmeter.h"
  35 #include "gui_thread.h"
  36 #include "keyboard.h"
  37 #include "public_editor.h"
  38
  39 #include "i18n.h"
  40
  41 using namespace ARDOUR;
  42 using namespace PBD;
  43 using namespace Gtkmm2ext;
  44 using namespace Gtk;
  45 using namespace std;
  46
  47 LevelMeter::LevelMeter (Session* s)
  48         : _meter (0)
  49         , meter_length (0)
  50         , thin_meter_width(2)
  51 {
  52         set_session (s);
  53         set_spacing (1);
  54         Config->ParameterChanged.connect (_parameter_connection, invalidator (*this), boost::bind (&LevelMeter::parameter_changed, this, _1), gui_context());
  55         UI::instance()->theme_changed.connect (sigc::mem_fun(*this, &LevelMeter::on_theme_changed));
  56         ColorsChanged.connect (sigc::mem_fun (*this, &LevelMeter::color_handler));
  57         max_peak = minus_infinity();
  58         meter_type = MeterPeak;
  59 }
  60
  61 void
  62 LevelMeter::on_theme_changed()
  63 {
  64         style_changed = true;
  65 }
  66
  67 LevelMeter::~LevelMeter ()
  68 {
  69         for (vector<MeterInfo>::iterator i = meters.begin(); i != meters.end(); i++) {
  70                 delete (*i).meter;
  71         }
  72 }
  73
  74 void
  75 LevelMeter::set_meter (PeakMeter* meter)
  76 {
  77         _configuration_connection.disconnect();
  78         _meter_type_connection.disconnect();
  79
  80         _meter = meter;
  81
  82         if (_meter) {
  83                 _meter->ConfigurationChanged.connect (_configuration_connection, invalidator (*this), boost::bind (&LevelMeter::configuration_changed, this, _1, _2), gui_context());
  84                 _meter->TypeChanged.connect (_meter_type_connection, invalidator (*this), boost::bind (&LevelMeter::meter_type_changed, this, _1), gui_context());
  85         }
  86 }
  87
  88 float
  89 LevelMeter::update_meters ()
  90 {
  91         vector<MeterInfo>::iterator i;
  92         uint32_t n;
  93         float peak, mpeak;
  94
  95         if (!_meter) {
  96                 return 0.0f;
  97         }
  98
  99         uint32_t nmidi = _meter->input_streams().n_midi();
 100
 101         for (n = 0, i = meters.begin(); i != meters.end(); ++i, ++n) {
 102                 if ((*i).packed) {
 103                         mpeak = _meter->meter_level(n, MeterMaxPeak);
 104                         if (mpeak > (*i).max_peak) {
 105                                 (*i).max_peak = mpeak;
 106                                 (*i).meter->set_highlight(mpeak > Config->get_meter_peak());
 107                         }
 108                         if (mpeak > max_peak) {
 109                                 max_peak = mpeak;
 110                         }
 111
 112                         peak = _meter->meter_level (n, meter_type);
 113                         if (n < nmidi) {
 114                                 (*i).meter->set (peak);
 115                         } else {
 116                                 (*i).meter->set (log_meter (peak), log_meter(_meter->meter_level(n, MeterPeak)));
 117                         }
 118                 }
 119         }
 120         return max_peak;
 121 }
 122
 123 void
 124 LevelMeter::parameter_changed (string p)
 125 {
 126         ENSURE_GUI_THREAD (*this, &LevelMeter::parameter_changed, p)
 127
 128         if (p == "meter-hold") {
 129                 vector<MeterInfo>::iterator i;
 130                 uint32_t n;
 131
 132                 for (n = 0, i = meters.begin(); i != meters.end(); ++i, ++n) {
 133                         (*i).meter->set_hold_count ((uint32_t) floor(Config->get_meter_hold()));
 134                 }
 135         }
 136         else if (p == "meter-line-up-level") {
 137                 color_changed = true;
 138                 setup_meters (meter_length, regular_meter_width, thin_meter_width);
 139         }
 140         else if (p == "meter-peak") {
 141                 vector<MeterInfo>::iterator i;
 142                 uint32_t n;
 143
 144                 for (n = 0, i = meters.begin(); i != meters.end(); ++i, ++n) {
 145                         (*i).max_peak = minus_infinity();
 146                 }
 147         }
 148 }
 149
 150 void
 151 LevelMeter::configuration_changed (ChanCount /*in*/, ChanCount /*out*/)
 152 {
 153         color_changed = true;
 154         setup_meters (meter_length, regular_meter_width, thin_meter_width);
 155 }
 156
 157 void
 158 LevelMeter::meter_type_changed (MeterType t)
 159 {
 160         meter_type = t;
 161         MeterTypeChanged(t);
 162 }
 163
 164 void
 165 LevelMeter::hide_all_meters ()
 166 {
 167         for (vector<MeterInfo>::iterator i = meters.begin(); i != meters.end(); ++i) {
 168                 if ((*i).packed) {
 169                         remove (*((*i).meter));
 170                         (*i).packed = false;
 171                 }
 172         }
 173 }
 174
 175 void
 176 LevelMeter::setup_meters (int len, int initial_width, int thin_width)
 177 {
 178         hide_all_meters ();
 179
 180         if (!_meter) {
 181                 return; /* do it later or never */
 182         }
 183
 184         int32_t nmidi = _meter->input_streams().n_midi();
 185         uint32_t nmeters = _meter->input_streams().n_total();
 186         regular_meter_width = initial_width;
 187         thin_meter_width = thin_width;
 188         meter_length = len;
 189
 190         guint16 width;
 191
 192         if (nmeters == 0) {
 193                 return;
 194         }
 195
 196         if (nmeters <= 2) {
 197                 width = regular_meter_width;
 198         } else {
 199                 width = thin_meter_width;
 200         }
 201
 202         while (meters.size() < nmeters) {
 203                 meters.push_back (MeterInfo());
 204         }
 205
 206         //cerr << "LevelMeter::setup_meters() called color_changed = " << color_changed << " colors: " << endl;//DEBUG
 207
 208         for (int32_t n = nmeters-1; nmeters && n >= 0 ; --n) {
 209                 uint32_t c[10];
 210                 float stp[4];
 211                 if (n < nmidi) {
 212                         c[0] = ARDOUR_UI::config()->canvasvar_MidiMeterColor0.get();
 213                         c[1] = ARDOUR_UI::config()->canvasvar_MidiMeterColor1.get();
 214                         c[2] = ARDOUR_UI::config()->canvasvar_MidiMeterColor2.get();
 215                         c[3] = ARDOUR_UI::config()->canvasvar_MidiMeterColor3.get();
 216                         c[4] = ARDOUR_UI::config()->canvasvar_MidiMeterColor4.get();
 217                         c[5] = ARDOUR_UI::config()->canvasvar_MidiMeterColor5.get();
 218                         c[6] = ARDOUR_UI::config()->canvasvar_MidiMeterColor6.get();
 219                         c[7] = ARDOUR_UI::config()->canvasvar_MidiMeterColor7.get();
 220                         c[8] = ARDOUR_UI::config()->canvasvar_MidiMeterColor8.get();
 221                         c[9] = ARDOUR_UI::config()->canvasvar_MidiMeterColor9.get();
 222                         stp[0] = 115.0 *  32.0 / 128.0;
 223                         stp[1] = 115.0 *  64.0 / 128.0;
 224                         stp[2] = 115.0 * 100.0 / 128.0;
 225                         stp[3] = 115.0 * 112.0 / 128.0;
 226                 } else {
 227                         switch (Config->get_meter_line_up_level()) {
 228                                 case MeteringLineUp24:
 229                                         stp[0] = 42.0;
 230                                         stp[1] = 77.5;
 231                                         stp[2] = 92.5;
 232                                         stp[3] = 100.0;
 233                                         break;
 234                                 case MeteringLineUp20:
 235                                         stp[0] = 50.0;
 236                                         stp[1] = 77.5;
 237                                         stp[2] = 92.5;
 238                                         stp[3] = 100.0;
 239                                         break;
 240                                 default:
 241                                 case MeteringLineUp18:
 242                                         stp[0] = 55.0;
 243                                         stp[1] = 77.5;
 244                                         stp[2] = 92.5;
 245                                         stp[3] = 100.0;
 246                                         break;
 247                                 case MeteringLineUp15:
 248                                         stp[0] = 62.5;
 249                                         stp[1] = 77.5;
 250                                         stp[2] = 92.5;
 251                                         stp[3] = 100.0;
 252                                         break;
 253                         }
 254                         c[0] = ARDOUR_UI::config()->canvasvar_MeterColor0.get();
 255                         c[1] = ARDOUR_UI::config()->canvasvar_MeterColor1.get();
 256                         c[2] = ARDOUR_UI::config()->canvasvar_MeterColor2.get();
 257                         c[3] = ARDOUR_UI::config()->canvasvar_MeterColor3.get();
 258                         c[4] = ARDOUR_UI::config()->canvasvar_MeterColor4.get();
 259                         c[5] = ARDOUR_UI::config()->canvasvar_MeterColor5.get();
 260                         c[6] = ARDOUR_UI::config()->canvasvar_MeterColor6.get();
 261                         c[7] = ARDOUR_UI::config()->canvasvar_MeterColor7.get();
 262                         c[8] = ARDOUR_UI::config()->canvasvar_MeterColor8.get();
 263                         c[9] = ARDOUR_UI::config()->canvasvar_MeterColor9.get();
 264                 }
 265                 if (meters[n].width != width || meters[n].length != len || color_changed) {
 266                         delete meters[n].meter;
 267                         meters[n].meter = new FastMeter ((uint32_t) floor (Config->get_meter_hold()), width, FastMeter::Vertical, len,
 268                                         c[0], c[1], c[2], c[3], c[4],
 269                                         c[5], c[6], c[7], c[8], c[9],
 270                                         ARDOUR_UI::config()->canvasvar_MeterBackgroundBot.get(),
 271                                         ARDOUR_UI::config()->canvasvar_MeterBackgroundTop.get(),
 272                                         0x991122ff, 0x551111ff,
 273                                         stp[0], stp[1], stp[2], stp[3]
 274                                         );
 275                         meters[n].width = width;
 276                         meters[n].length = len;
 277                         meters[n].meter->add_events (Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK);
 278                         meters[n].meter->signal_button_press_event().connect (sigc::mem_fun (*this, &LevelMeter::meter_button_press));
 279                         meters[n].meter->signal_button_release_event().connect (sigc::mem_fun (*this, &LevelMeter::meter_button_release));
 280                 }
 281
 282                 pack_end (*meters[n].meter, false, false);
 283                 meters[n].meter->show_all ();
 284                 meters[n].packed = true;
 285         }
 286         show();
 287         color_changed = false;
 288 }
 289
 290 void
 291 LevelMeter::set_type(MeterType t)
 292 {
 293         meter_type = t;
 294         _meter->set_type(t);
 295 }
 296
 297 bool
 298 LevelMeter::meter_button_press (GdkEventButton* ev)
 299 {
 300         return ButtonPress (ev); /* EMIT SIGNAL */
 301 }
 302
 303 bool
 304 LevelMeter::meter_button_release (GdkEventButton* ev)
 305 {
 306         if (ev->button == 1) {
 307                 clear_meters (false);
 308         }
 309
 310         return true;
 311 }
 312
 313
 314 void LevelMeter::clear_meters (bool reset_highlight)
 315 {
 316         for (vector<MeterInfo>::iterator i = meters.begin(); i < meters.end(); i++) {
 317                 (*i).meter->clear();
 318                 (*i).max_peak = minus_infinity();
 319                 if (reset_highlight)
 320                         (*i).meter->set_highlight(false);
 321         }
 322         max_peak = minus_infinity();
 323 }
 324
 325 void LevelMeter::hide_meters ()
 326 {
 327         hide_all_meters();
 328 }
 329
 330 void
 331 LevelMeter::color_handler ()
 332 {
 333         color_changed = true;
 334 }
 335