libs/ardour/meter.cc

   1 /*
   2  * Copyright (C) 2006-2016 David Robillard <d@drobilla.net>
   3  * Copyright (C) 2007-2017 Paul Davis <paul@linuxaudiosystems.com>
   4  * Copyright (C) 2009-2011 Carl Hetherington <carl@carlh.net>
   5  * Copyright (C) 2013-2019 Robin Gareus <robin@gareus.org>
   6  * Copyright (C) 2015-2016 Len Ovens <len@ovenwerks.net>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; if not, write to the Free Software Foundation, Inc.,
  20  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22
  23 #include <algorithm>
  24 #include <cmath>
  25 #include <limits>
  26
  27 #include "pbd/compose.h"
  28
  29 #include "ardour/audio_buffer.h"
  30 #include "ardour/buffer_set.h"
  31 #include "ardour/dB.h"
  32 #include "ardour/meter.h"
  33 #include "ardour/midi_buffer.h"
  34 #include "ardour/session.h"
  35 #include "ardour/rc_configuration.h"
  36 #include "ardour/runtime_functions.h"
  37
  38 using namespace std;
  39
  40 using namespace ARDOUR;
  41
  42 PeakMeter::PeakMeter (Session& s, const std::string& name)
  43     : Processor (s, string_compose ("meter-%1", name))
  44 {
  45         Kmeterdsp::init(s.nominal_sample_rate());
  46         Iec1ppmdsp::init(s.nominal_sample_rate());
  47         Iec2ppmdsp::init(s.nominal_sample_rate());
  48         Vumeterdsp::init(s.nominal_sample_rate());
  49         _pending_active = true;
  50         _meter_type = MeterPeak;
  51         _reset_dpm = true;
  52         _reset_max = true;
  53         _bufcnt = 0;
  54         _combined_peak = 0;
  55 }
  56
  57 PeakMeter::~PeakMeter ()
  58 {
  59         while (_kmeter.size() > 0) {
  60                 delete (_kmeter.back());
  61                 delete (_iec1meter.back());
  62                 delete (_iec2meter.back());
  63                 delete (_vumeter.back());
  64                 _kmeter.pop_back();
  65                 _iec1meter.pop_back();
  66                 _iec2meter.pop_back();
  67                 _vumeter.pop_back();
  68         }
  69         while (_peak_power.size() > 0) {
  70                 _peak_buffer.pop_back();
  71                 _peak_power.pop_back();
  72                 _max_peak_signal.pop_back();
  73         }
  74 }
  75
  76
  77 /** Get peaks from @a bufs
  78  * Input acceptance is lenient - the first n buffers from @a bufs will
  79  * be metered, where n was set by the last call to setup(), excess meters will
  80  * be set to 0.
  81  *
  82  * (runs in jack realtime context)
  83  */
  84 void
  85 PeakMeter::run (BufferSet& bufs, samplepos_t /*start_sample*/, samplepos_t /*end_sample*/, double /*speed*/, pframes_t nframes, bool)
  86 {
  87         if (!_active && !_pending_active) {
  88                 return;
  89         }
  90         const bool do_reset_max = _reset_max;
  91         // XXX max-peak is set from DPM's peak-buffer, so DPM also needs to be reset in sync:
  92         const bool do_reset_dpm = _reset_dpm || do_reset_max;
  93
  94         _reset_max = false;
  95         _reset_dpm = false;
  96         _combined_peak = 0;
  97
  98         // cerr << "meter " << name() << " runs with " << bufs.available() << " inputs\n";
  99
 100         const uint32_t n_audio = min (current_meters.n_audio(), bufs.count().n_audio());
 101         const uint32_t n_midi  = min (current_meters.n_midi(), bufs.count().n_midi());
 102
 103         uint32_t n = 0;
 104
 105         const float falloff_dB = Config->get_meter_falloff() * nframes / _session.nominal_sample_rate();
 106         const uint32_t zoh = _session.nominal_sample_rate() * .021;
 107         _bufcnt += nframes;
 108
 109         // Meter MIDI in to the first n_midi peaks
 110         for (uint32_t i = 0; i < n_midi; ++i, ++n) {
 111                 float val = 0.0f;
 112                 if (do_reset_dpm) {
 113                         _peak_power[n] = 0;
 114                 }
 115                 const MidiBuffer& buf (bufs.get_midi(i));
 116
 117                 for (MidiBuffer::const_iterator e = buf.begin(); e != buf.end(); ++e) {
 118                         const Evoral::Event<samplepos_t> ev(*e, false);
 119                         if (ev.is_note_on()) {
 120                                 const float this_vel = ev.buffer()[2] / 127.0;
 121                                 if (this_vel > val) {
 122                                         val = this_vel;
 123                                 }
 124                                 if (val > 0.01) {
 125                                         if (_combined_peak < 0.01) {
 126                                                 _combined_peak = 0.01;
 127                                         }
 128                                 }
 129                         } else {
 130                                 val += 1.0 / bufs.get_midi(n).capacity();
 131                                 if (val > 1.0) {
 132                                         val = 1.0;
 133                                 }
 134                         }
 135                 }
 136                 if (_peak_power[n] < (1.0 / 512.0)) {
 137                         _peak_power[n] = 0;
 138                 } else {
 139                         /* empirical algorithm WRT to audio falloff times */
 140                         _peak_power[n] -= sqrtf (_peak_power[n]) * falloff_dB * 0.045f;
 141                 }
 142                 _peak_power[n] = max(_peak_power[n], val);
 143                 _max_peak_signal[n] = 0;
 144         }
 145
 146         // Meter audio in to the rest of the peaks
 147         for (uint32_t i = 0; i < n_audio; ++i, ++n) {
 148                 if (bufs.get_audio(i).silent()) {
 149                         _peak_buffer[n] = 0;
 150                 } else {
 151                         _peak_buffer[n] = compute_peak (bufs.get_audio(i).data(), nframes, _peak_buffer[n]);
 152                         _peak_buffer[n] = std::min (_peak_buffer[n], 100.f); // cut off at +40dBFS for falloff.
 153                         _max_peak_signal[n] = std::max(_peak_buffer[n], _max_peak_signal[n]); // todo sync reset
 154                         _combined_peak = std::max(_peak_buffer[n], _combined_peak);
 155                 }
 156
 157                 if (do_reset_max) {
 158                         _max_peak_signal[n] = 0;
 159                 }
 160
 161                 if (do_reset_dpm) {
 162                         _peak_buffer[n] = 0;
 163                         _peak_power[n] = -std::numeric_limits<float>::infinity();
 164                 } else {
 165                         // falloff
 166                         if (_peak_power[n] >  -318.8f) {
 167                                 _peak_power[n] -= falloff_dB;
 168                         } else {
 169                                 _peak_power[n] = -std::numeric_limits<float>::infinity();
 170                         }
 171                         _peak_power[n] = max(_peak_power[n], accurate_coefficient_to_dB(_peak_buffer[n]));
 172                         // integration buffer, retain peaks > 49Hz
 173                         if (_bufcnt > zoh) {
 174                                 _peak_buffer[n] = 0;
 175                         }
 176                 }
 177
 178                 if (_meter_type & (MeterKrms | MeterK20 | MeterK14 | MeterK12)) {
 179                         _kmeter[i]->process(bufs.get_audio(i).data(), nframes);
 180                 }
 181                 if (_meter_type & (MeterIEC1DIN | MeterIEC1NOR)) {
 182                         _iec1meter[i]->process(bufs.get_audio(i).data(), nframes);
 183                 }
 184                 if (_meter_type & (MeterIEC2BBC | MeterIEC2EBU)) {
 185                         _iec2meter[i]->process(bufs.get_audio(i).data(), nframes);
 186                 }
 187                 if (_meter_type & MeterVU) {
 188                         _vumeter[i]->process(bufs.get_audio(i).data(), nframes);
 189                 }
 190         }
 191
 192         // Zero any excess peaks
 193         for (uint32_t i = n; i < _peak_power.size(); ++i) {
 194                 _peak_power[i] = -std::numeric_limits<float>::infinity();
 195                 _max_peak_signal[n] = 0;
 196         }
 197
 198         if (_bufcnt > zoh) {
 199                 _bufcnt = 0;
 200         }
 201
 202         _active = _pending_active;
 203 }
 204
 205 void
 206 PeakMeter::reset ()
 207 {
 208         if (_active || _pending_active) {
 209                 _reset_dpm = true;
 210         } else {
 211                 for (size_t i = 0; i < _peak_power.size(); ++i) {
 212                         _peak_power[i] = -std::numeric_limits<float>::infinity();
 213                         _peak_buffer[i] = 0;
 214                 }
 215                 const uint32_t n_midi = min (current_meters.n_midi(), (uint32_t)_peak_power.size());
 216                 for (size_t i = 0; i < n_midi; ++i) {
 217                         _peak_power[i] = 0;
 218                 }
 219         }
 220
 221         // these are handled async just fine.
 222         for (size_t n = 0; n < _kmeter.size(); ++n) {
 223                 _kmeter[n]->reset();
 224                 _iec1meter[n]->reset();
 225                 _iec2meter[n]->reset();
 226                 _vumeter[n]->reset();
 227         }
 228 }
 229
 230 void
 231 PeakMeter::reset_max ()
 232 {
 233         if (_active || _pending_active) {
 234                 _reset_max = true;
 235                 return;
 236         }
 237         for (size_t i = 0; i < _max_peak_signal.size(); ++i) {
 238                 _max_peak_signal[i] = 0;
 239                 _peak_buffer[i] = 0;
 240         }
 241 }
 242
 243 bool
 244 PeakMeter::can_support_io_configuration (const ChanCount& in, ChanCount& out)
 245 {
 246         out = in;
 247         return true;
 248 }
 249
 250 bool
 251 PeakMeter::configure_io (ChanCount in, ChanCount out)
 252 {
 253         bool changed = false;
 254         if (out != in) { // always 1:1
 255                 return false;
 256         }
 257
 258         if (current_meters != in) {
 259                 changed = true;
 260         }
 261
 262         current_meters = in;
 263
 264         set_max_channels (in);
 265
 266         if (changed) {
 267                 reset_max();
 268         }
 269
 270         return Processor::configure_io (in, out);
 271 }
 272
 273 void
 274 PeakMeter::reflect_inputs (const ChanCount& in)
 275 {
 276         reset();
 277         current_meters = in;
 278         reset_max();
 279         // ConfigurationChanged() postponed
 280 }
 281
 282 void
 283 PeakMeter::emit_configuration_changed () {
 284         ConfigurationChanged (current_meters, current_meters); /* EMIT SIGNAL */
 285 }
 286
 287 void
 288 PeakMeter::set_max_channels (const ChanCount& chn)
 289 {
 290         uint32_t const limit = chn.n_total();
 291         const size_t n_audio = chn.n_audio();
 292
 293         while (_peak_power.size() > limit) {
 294                 _peak_buffer.pop_back();
 295                 _peak_power.pop_back();
 296                 _max_peak_signal.pop_back();
 297         }
 298
 299         while (_peak_power.size() < limit) {
 300                 _peak_buffer.push_back(0);
 301                 if (_peak_power.size() < current_meters.n_midi()) {
 302                         _peak_power.push_back(0);
 303                 } else {
 304                         _peak_power.push_back(-std::numeric_limits<float>::infinity());
 305                 }
 306                 _max_peak_signal.push_back(0);
 307         }
 308
 309         assert(_peak_buffer.size() == limit);
 310         assert(_peak_power.size() == limit);
 311         assert(_max_peak_signal.size() == limit);
 312
 313         /* alloc/free other audio-only meter types. */
 314         while (_kmeter.size() > n_audio) {
 315                 delete (_kmeter.back());
 316                 delete (_iec1meter.back());
 317                 delete (_iec2meter.back());
 318                 delete (_vumeter.back());
 319                 _kmeter.pop_back();
 320                 _iec1meter.pop_back();
 321                 _iec2meter.pop_back();
 322                 _vumeter.pop_back();
 323         }
 324         while (_kmeter.size() < n_audio) {
 325                 _kmeter.push_back(new Kmeterdsp());
 326                 _iec1meter.push_back(new Iec1ppmdsp());
 327                 _iec2meter.push_back(new Iec2ppmdsp());
 328                 _vumeter.push_back(new Vumeterdsp());
 329         }
 330         assert(_kmeter.size() == n_audio);
 331         assert(_iec1meter.size() == n_audio);
 332         assert(_iec2meter.size() == n_audio);
 333         assert(_vumeter.size() == n_audio);
 334
 335         reset();
 336         reset_max();
 337 }
 338
 339 /** To be driven by the Meter signal from IO.
 340  * Caller MUST hold its own processor_lock to prevent reconfiguration
 341  * of meter size during this call.
 342  */
 343
 344 #define CHECKSIZE(MTR) (n < MTR.size() + n_midi && n >= n_midi)
 345
 346 float
 347 PeakMeter::meter_level(uint32_t n, MeterType type) {
 348         float mcptmp;
 349         switch (type) {
 350                 case MeterKrms:
 351                 case MeterK20:
 352                 case MeterK14:
 353                 case MeterK12:
 354                         {
 355                                 const uint32_t n_midi = current_meters.n_midi();
 356                                 if (CHECKSIZE(_kmeter)) {
 357                                         return accurate_coefficient_to_dB (_kmeter[n - n_midi]->read());
 358                                 }
 359                         }
 360                         break;
 361                 case MeterIEC1DIN:
 362                 case MeterIEC1NOR:
 363                         {
 364                                 const uint32_t n_midi = current_meters.n_midi();
 365                                 if (CHECKSIZE(_iec1meter)) {
 366                                         return accurate_coefficient_to_dB (_iec1meter[n - n_midi]->read());
 367                                 }
 368                         }
 369                         break;
 370                 case MeterIEC2BBC:
 371                 case MeterIEC2EBU:
 372                         {
 373                                 const uint32_t n_midi = current_meters.n_midi();
 374                                 if (CHECKSIZE(_iec2meter)) {
 375                                         return accurate_coefficient_to_dB (_iec2meter[n - n_midi]->read());
 376                                 }
 377                         }
 378                         break;
 379                 case MeterVU:
 380                         {
 381                                 const uint32_t n_midi = current_meters.n_midi();
 382                                 if (CHECKSIZE(_vumeter)) {
 383                                         return accurate_coefficient_to_dB (_vumeter[n - n_midi]->read());
 384                                 }
 385                         }
 386                         break;
 387                 case MeterPeak:
 388                 case MeterPeak0dB:
 389                         if (n < _peak_power.size()) {
 390                                 return _peak_power[n];
 391                         }
 392                         break;
 393                 case MeterMCP:
 394                         mcptmp = _combined_peak;
 395                         return accurate_coefficient_to_dB(mcptmp);
 396                 case MeterMaxSignal:
 397                         assert(0);
 398                         break;
 399                 default:
 400                 case MeterMaxPeak:
 401                         if (n < _max_peak_signal.size()) {
 402                                 return accurate_coefficient_to_dB(_max_peak_signal[n]);
 403                         }
 404                         break;
 405         }
 406         return minus_infinity();
 407 }
 408
 409 void
 410 PeakMeter::set_meter_type (MeterType t)
 411 {
 412         if (t == _meter_type) {
 413                 return;
 414         }
 415
 416         _meter_type = t;
 417
 418         if (t & (MeterKrms | MeterK20 | MeterK14 | MeterK12)) {
 419                 const size_t n_audio = current_meters.n_audio();
 420                 for (size_t n = 0; n < n_audio; ++n) {
 421                         _kmeter[n]->reset();
 422                 }
 423         }
 424         if (t & (MeterIEC1DIN | MeterIEC1NOR)) {
 425                 const size_t n_audio = current_meters.n_audio();
 426                 for (size_t n = 0; n < n_audio; ++n) {
 427                         _iec1meter[n]->reset();
 428                 }
 429         }
 430         if (t & (MeterIEC2BBC | MeterIEC2EBU)) {
 431                 const size_t n_audio = current_meters.n_audio();
 432                 for (size_t n = 0; n < n_audio; ++n) {
 433                         _iec2meter[n]->reset();
 434                 }
 435         }
 436         if (t & MeterVU) {
 437                 const size_t n_audio = current_meters.n_audio();
 438                 for (size_t n = 0; n < n_audio; ++n) {
 439                         _vumeter[n]->reset();
 440                 }
 441         }
 442
 443         MeterTypeChanged (t); /* EMIT SIGNAL */
 444 }
 445
 446 XMLNode&
 447 PeakMeter::state ()
 448 {
 449         XMLNode& node (Processor::state ());
 450         node.set_property("type", "meter");
 451         return node;
 452 }