ardour/ardour
ardour
/
ardour
13
1
Fork 0
Code Pull Requests Releases Activity

implement new meter types

This commit is contained in:
Robin Gareus 2013-07-22 18:45:08 +02:00 committed by Paul Davis
parent bd2ddc09ab
commit 553d393d30
10 changed files with 715 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
gtk2_ardour/gain_meter.cc
View File

@ -1019,19 +1019,22 @@ GainMeter::get_gm_width ()
gint
GainMeter::meter_metrics_expose (GdkEventExpose *ev)
{
return meter_expose_metrics(ev, _types, &meter_metric_area);
assert(_route);
return meter_expose_metrics(ev, _route->meter_type(), _types, &meter_metric_area);
}
gint
GainMeter::meter_ticks1_expose (GdkEventExpose *ev)
{
return meter_expose_ticks(ev, _types, &meter_ticks1_area);
assert(_route);
return meter_expose_ticks(ev, _route->meter_type(), _types, &meter_ticks1_area);
}
gint
GainMeter::meter_ticks2_expose (GdkEventExpose *ev)
{
return meter_expose_ticks(ev, _types, &meter_ticks2_area);
assert(_route);
return meter_expose_ticks(ev, _route->meter_type(), _types, &meter_ticks2_area);
}
boost::shared_ptr<PBD::Controllable>
@ -1113,4 +1116,5 @@ void
GainMeter::meter_type_changed (MeterType t)
{
_route->set_meter_type(t);
RedrawMetrics();
}

110
gtk2_ardour/level_meter.cc
View File

@ -114,6 +114,18 @@ LevelMeter::update_meters ()
const float peak = _meter->meter_level (n, meter_type);
if (meter_type == MeterPeak) {
(*i).meter->set (log_meter (peak));
} else if (meter_type == MeterIEC1NOR) {
(*i).meter->set (meter_deflect_nordic (peak));
} else if (meter_type == MeterIEC1DIN) {
(*i).meter->set (meter_deflect_din (peak));
} else if (meter_type == MeterIEC2BBC || meter_type == MeterIEC2EBU) {
(*i).meter->set (meter_deflect_ppm (peak));
} else if (meter_type == MeterVU) {
(*i).meter->set (meter_deflect_vu (peak));
} else if (meter_type == MeterK14) {
(*i).meter->set (meter_deflect_k (peak, 14), meter_deflect_k(_meter->meter_level(n, MeterPeak), 14));
} else if (meter_type == MeterK20) {
(*i).meter->set (meter_deflect_k (peak, 20), meter_deflect_k(_meter->meter_level(n, MeterPeak), 20));
} else {
(*i).meter->set (log_meter (peak), log_meter(_meter->meter_level(n, MeterPeak)));
}
@ -161,6 +173,8 @@ void
LevelMeter::meter_type_changed (MeterType t)
{
meter_type = t;
color_changed = true;
setup_meters (meter_length, regular_meter_width, thin_meter_width);
MeterTypeChanged(t);
}
@ -227,33 +241,6 @@ LevelMeter::setup_meters (int len, int initial_width, int thin_width)
stp[2] = 115.0 * 100.0 / 128.0;
stp[3] = 115.0 * 112.0 / 128.0;
} else {
switch (Config->get_meter_line_up_level()) {
case MeteringLineUp24:
stp[0] = 42.0;
stp[1] = 77.5;
stp[2] = 92.5;
stp[3] = 100.0;
break;
case MeteringLineUp20:
stp[0] = 50.0;
stp[1] = 77.5;
stp[2] = 92.5;
stp[3] = 100.0;
break;
default:
case MeteringLineUp18:
stp[0] = 55.0;
stp[1] = 77.5;
stp[2] = 92.5;
stp[3] = 100.0;
break;
case MeteringLineUp15:
stp[0] = 62.5;
stp[1] = 77.5;
stp[2] = 92.5;
stp[3] = 100.0;
break;
}
c[0] = ARDOUR_UI::config()->get_canvasvar_MeterColor0();
c[1] = ARDOUR_UI::config()->get_canvasvar_MeterColor1();
c[2] = ARDOUR_UI::config()->get_canvasvar_MeterColor2();
@ -264,6 +251,75 @@ LevelMeter::setup_meters (int len, int initial_width, int thin_width)
c[7] = ARDOUR_UI::config()->get_canvasvar_MeterColor7();
c[8] = ARDOUR_UI::config()->get_canvasvar_MeterColor8();
c[9] = ARDOUR_UI::config()->get_canvasvar_MeterColor9();
switch (meter_type) {
case MeterK20:
stp[0] = 115.0 * meter_deflect_k(-40, 20); //-20
stp[1] = 115.0 * meter_deflect_k(-20, 20); // 0
stp[2] = 115.0 * meter_deflect_k(-18, 20); // +2
stp[3] = 115.0 * meter_deflect_k(-16, 20); // +4
c[0] = c[1] = 0x008800ff;
c[2] = c[3] = 0x00ff00ff;
c[4] = c[5] = 0xffff00ff;
c[6] = c[7] = 0xffff00ff;
c[8] = c[9] = 0xff0000ff;
break;
case MeterK14:
stp[0] = 115.0 * meter_deflect_k(-34, 14); //-20
stp[1] = 115.0 * meter_deflect_k(-14, 14); // 0
stp[2] = 115.0 * meter_deflect_k(-12, 14); // +2
stp[3] = 115.0 * meter_deflect_k(-10, 14); // +4
c[0] = c[1] = 0x008800ff;
c[2] = c[3] = 0x00ff00ff;
c[4] = c[5] = 0xffff00ff;
c[6] = c[7] = 0xffff00ff;
c[8] = c[9] = 0xff0000ff;
break;
case MeterIEC2EBU:
case MeterIEC2BBC:
stp[0] = 115.0 * meter_deflect_ppm(-18);
stp[1] = 115.0 * meter_deflect_ppm(-14);
stp[2] = 115.0 * meter_deflect_ppm(-10);
stp[3] = 115.0 * meter_deflect_ppm( -8);
break;
case MeterIEC1NOR:
stp[0] = 115.0 * meter_deflect_nordic(-18);
stp[1] = 115.0 * meter_deflect_nordic(-15);
stp[2] = 115.0 * meter_deflect_nordic(-12);
stp[3] = 115.0 * meter_deflect_nordic( -9);
break;
case MeterIEC1DIN:
stp[0] = 115.0 * meter_deflect_din(-29);
stp[1] = 115.0 * meter_deflect_din(-18);
stp[2] = 115.0 * meter_deflect_din(-15);
stp[3] = 115.0 * meter_deflect_din( -9);
break;
case MeterVU:
stp[0] = 115.0 * meter_deflect_vu(-26); // -6
stp[1] = 115.0 * meter_deflect_vu(-23); // -3
stp[2] = 115.0 * meter_deflect_vu(-20); // 0
stp[3] = 115.0 * meter_deflect_vu(-18); // +2
break;
default: // PEAK, RMS
stp[1] = 77.5; // 115 * log_meter(-10)
stp[2] = 92.5; // 115 * log_meter(-3)
stp[3] = 100.0; // 115 * log_meter(0)
switch (Config->get_meter_line_up_level()) {
case MeteringLineUp24:
stp[0] = 42.0;
break;
case MeteringLineUp20:
stp[0] = 50.0;
break;
default:
case MeteringLineUp18:
stp[0] = 55.0;
break;
case MeteringLineUp15:
stp[0] = 62.5;
break;
}
}
}
if (meters[n].width != width || meters[n].length != len || color_changed) {
delete meters[n].meter;

77
gtk2_ardour/logmeter.h
View File

@ -34,6 +34,16 @@ alt_log_meter (float power)
}
#endif
/* prototypes - avoid compiler warning */
inline float log_meter (float db);
inline float meter_deflect_ppm (float);
inline float meter_deflect_din (float);
inline float meter_deflect_nordic (float);
inline float meter_deflect_vu (float);
inline float meter_deflect_k (float, float);
inline float
log_meter (float db)
{
@ -65,4 +75,71 @@ log_meter (float db)
return def/115.0f;
}
inline float
meter_deflect_ppm (float db)
{
if (db < -30) {
// 2.258 == ((-30 + 32.0)/ 28.0) / 10^(-30 / 20);
return (dB_to_coefficient(db) * 2.258769757f);
} else {
const float rv = (db + 32.0f) / 28.0f;
if (rv < 1.0) {
return rv;
} else {
return 1.0;
}
}
}
inline float
meter_deflect_din (float db)
{
float rv = dB_to_coefficient(db);
rv = sqrtf (sqrtf (2.3676f * rv)) - 0.1803f;
if (rv >= 1.0) {
return 1.0;
} else {
return (rv > 0 ? rv : 0.0);
}
}
inline float
meter_deflect_nordic (float db)
{
if (db < -60) {
return 0.0;
} else {
const float rv = (db + 60.0f) / 54.0f;
if (rv < 1.0) {
return rv;
} else {
return 1.0;
}
}
}
inline float
meter_deflect_vu (float db)
{
const float rv = 6.77165f * dB_to_coefficient(db);
if (rv > 1.0) return 1.0;
return rv;
}
inline float
meter_deflect_k (float db, float krange)
{
db+=krange;
if (db < -40.0f) {
return (dB_to_coefficient(db) * 500.0f / (krange + 45.0f));
} else {
const float rv = (db + 45.0f) / (krange + 45.0f);
if (rv < 1.0) {
return rv;
} else {
return 1.0;
}
}
}
#endif /* __ardour_gtk_log_meter_h__ */

641
gtk2_ardour/meter_patterns.cc
View File

@ -39,6 +39,8 @@ using namespace ArdourMeter;
static const int max_pattern_metric_size = 1026;
/* signals used by meters */
sigc::signal<void> ArdourMeter::ResetAllPeakDisplays;
sigc::signal<void,ARDOUR::Route*> ArdourMeter::ResetRoutePeakDisplays;
sigc::signal<void,ARDOUR::RouteGroup*> ArdourMeter::ResetGroupPeakDisplays;
@ -46,13 +48,28 @@ sigc::signal<void> ArdourMeter::RedrawMetrics;
sigc::signal<void, int, ARDOUR::RouteGroup*, ARDOUR::MeterType> ArdourMeter::SetMeterTypeMulti;
/* pattern cache */
struct MeterMatricsMapKey {
MeterMatricsMapKey (std::string n, MeterType t)
: _n(n)
, _t(t)
{}
inline bool operator<(const MeterMatricsMapKey& rhs) const {
return (_n < rhs._n) || (_n == rhs._n && _t < rhs._t);
}
std::string _n;
MeterType _t;
};
namespace ArdourMeter {
typedef std::map<std::string,cairo_pattern_t*> TickPatterns;
typedef std::map<std::string,cairo_pattern_t*> MetricPatterns;
typedef std::map<MeterMatricsMapKey, cairo_pattern_t*> MetricPatternMap;
}
static ArdourMeter::TickPatterns ticks_patterns;
static ArdourMeter::MetricPatterns metric_patterns;
static ArdourMeter::MetricPatternMap ticks_patterns;
static ArdourMeter::MetricPatternMap metric_patterns;
const std::string
ArdourMeter::meter_type_string (ARDOUR::MeterType mt)
@ -61,14 +78,26 @@ ArdourMeter::meter_type_string (ARDOUR::MeterType mt)
case MeterPeak:
return _("Peak");
break;
case MeterKrms:
case MeterRMS:
return _("RMS + Peak");
break;
case MeterIEC1:
return _("DIN");
case MeterIEC1DIN:
return _("IEC1/DIN");
break;
case MeterIEC2:
return _("EBU/BBC");
case MeterIEC1NOR:
return _("IEC1/NOR");
break;
case MeterIEC2BBC:
return _("IEC2/BBC");
break;
case MeterIEC2EBU:
return _("IEC2/EBU");
break;
case MeterK20:
return _("K20");
break;
case MeterK14:
return _("K14");
break;
case MeterVU:
return _("VU");
@ -79,8 +108,99 @@ ArdourMeter::meter_type_string (ARDOUR::MeterType mt)
}
}
static inline float mtr_col_and_fract(
cairo_t* cr, Gdk::Color const * const c, const uint32_t peakcolor, const MeterType mt, const float val)
{
float fraction = 0;
switch (mt) {
default:
case MeterRMS:
case MeterPeak:
fraction = log_meter (val);
if (val >= 0 || val == -9) {
cairo_set_source_rgb (cr,
UINT_RGBA_R_FLT(peakcolor),
UINT_RGBA_G_FLT(peakcolor),
UINT_RGBA_B_FLT(peakcolor));
} else {
cairo_set_source_rgb (cr, c->get_red_p(), c->get_green_p(), c->get_blue_p());
}
break;
case MeterIEC2BBC:
case MeterIEC2EBU:
fraction = meter_deflect_ppm(val);
if (val >= -10.0) {
cairo_set_source_rgb (cr,
UINT_RGBA_R_FLT(peakcolor),
UINT_RGBA_G_FLT(peakcolor),
UINT_RGBA_B_FLT(peakcolor));
} else {
cairo_set_source_rgb (cr, c->get_red_p(), c->get_green_p(), c->get_blue_p());
}
break;
case MeterIEC1NOR:
fraction = meter_deflect_nordic(val);
if (val >= -12.0) {
cairo_set_source_rgb (cr,
UINT_RGBA_R_FLT(peakcolor),
UINT_RGBA_G_FLT(peakcolor),
UINT_RGBA_B_FLT(peakcolor));
} else {
cairo_set_source_rgb (cr, c->get_red_p(), c->get_green_p(), c->get_blue_p());
}
break;
case MeterIEC1DIN:
fraction = meter_deflect_din(val);
if (val >= -9.0) {
cairo_set_source_rgb (cr,
UINT_RGBA_R_FLT(peakcolor),
UINT_RGBA_G_FLT(peakcolor),
UINT_RGBA_B_FLT(peakcolor));
} else {
cairo_set_source_rgb (cr, c->get_red_p(), c->get_green_p(), c->get_blue_p());
}
break;
case MeterVU:
fraction = meter_deflect_vu(val);
if (val >= -20.0) {
cairo_set_source_rgb (cr,
UINT_RGBA_R_FLT(peakcolor),
UINT_RGBA_G_FLT(peakcolor),
UINT_RGBA_B_FLT(peakcolor));
} else {
cairo_set_source_rgb (cr, c->get_red_p(), c->get_green_p(), c->get_blue_p());
}
break;
case MeterK20:
fraction = meter_deflect_k (val, 20);
if (val >= -16.0) {
cairo_set_source_rgb (cr, 1.0, 0.0, 0.0); // red
} else if (val >= -20.0) {
cairo_set_source_rgb (cr, 0.8, 0.8, 0.0); // yellow
} else {
cairo_set_source_rgb (cr, 0.0, 1.0, 0.0); // green
}
break;
case MeterK14:
if (val >= -10.0) {
cairo_set_source_rgb (cr, 1.0, 0.0, 0.0); // red
} else if (val >= -14.0) {
cairo_set_source_rgb (cr, 0.8, 0.8, 0.0); // yellow
} else {
cairo_set_source_rgb (cr, 0.0, 1.0, 0.0); // green
}
fraction = meter_deflect_k (val, 14);
break;
}
return fraction;
}
static cairo_pattern_t*
meter_render_ticks (Gtk::Widget& w, vector<ARDOUR::DataType> types)
meter_render_ticks (Gtk::Widget& w, MeterType type, vector<ARDOUR::DataType> types)
{
Glib::RefPtr<Gdk::Window> win (w.get_window());
@ -131,45 +251,153 @@ meter_render_ticks (Gtk::Widget& w, vector<ARDOUR::DataType> types)
switch (*i) {
case DataType::AUDIO:
points.insert (std::pair<int,float>(-60, 0.5));
points.insert (std::pair<int,float>(-50, 0.5));
points.insert (std::pair<int,float>(-40, 0.5));
points.insert (std::pair<int,float>(-30, 0.5));
if (Config->get_meter_line_up_level() == MeteringLineUp24) {
points.insert (std::pair<int,float>(-24, 0.5));
} else {
points.insert (std::pair<int,float>(-25, 0.5));
switch (type) {
case MeterK14:
points.insert (std::pair<int,float>(-54.0f, 1.0));
points.insert (std::pair<int,float>(-44.0f, 1.0));
points.insert (std::pair<int,float>(-34.0f, 1.0));
points.insert (std::pair<int,float>(-24.0f, 1.0));
points.insert (std::pair<int,float>(-20.0f, 1.0));
points.insert (std::pair<int,float>(-17.0f, 1.0));
points.insert (std::pair<int,float>(-14.0f, 1.0));
points.insert (std::pair<int,float>(-11.0f, 1.0));
points.insert (std::pair<int,float>( -8.0f, 1.0));
points.insert (std::pair<int,float>( -4.0f, 1.0));
points.insert (std::pair<int,float>( 0.0f, 1.0));
break;
case MeterK20:
points.insert (std::pair<int,float>(-60.0f, 1.0));
points.insert (std::pair<int,float>(-50.0f, 1.0));
points.insert (std::pair<int,float>(-40.0f, 1.0));
points.insert (std::pair<int,float>(-30.0f, 1.0));
points.insert (std::pair<int,float>(-26.0f, 1.0));
points.insert (std::pair<int,float>(-23.0f, 1.0));
points.insert (std::pair<int,float>(-20.0f, 1.0));
points.insert (std::pair<int,float>(-17.0f, 1.0));
points.insert (std::pair<int,float>(-14.0f, 1.0));
points.insert (std::pair<int,float>(-10.0f, 1.0));
points.insert (std::pair<int,float>( -5.0f, 1.0));
points.insert (std::pair<int,float>( 0.0f, 1.0));
break;
case MeterIEC2EBU:
points.insert (std::pair<float,float>(-30.0f, 1.0));
points.insert (std::pair<float,float>(-28.0f, 0.5));
points.insert (std::pair<float,float>(-26.0f, 1.0));
points.insert (std::pair<float,float>(-24.0f, 0.5));
points.insert (std::pair<float,float>(-22.0f, 1.0));
points.insert (std::pair<float,float>(-20.0f, 0.5));
points.insert (std::pair<float,float>(-18.0f, 1.0));
points.insert (std::pair<float,float>(-16.0f, 0.5));
points.insert (std::pair<float,float>(-14.0f, 1.0));
points.insert (std::pair<float,float>(-12.0f, 0.5));
points.insert (std::pair<float,float>(-10.0f, 1.0));
points.insert (std::pair<float,float>( -9.0f, 0.5));
points.insert (std::pair<float,float>( -8.0f, 0.5));
points.insert (std::pair<float,float>( -6.0f, 1.0));
break;
case MeterIEC2BBC:
points.insert (std::pair<float,float>(-30.0f, 1.0));
points.insert (std::pair<float,float>(-26.0f, 1.0));
points.insert (std::pair<float,float>(-22.0f, 1.0));
points.insert (std::pair<float,float>(-18.0f, 1.0));
points.insert (std::pair<float,float>(-14.0f, 1.0));
points.insert (std::pair<float,float>(-10.0f, 1.0));
points.insert (std::pair<float,float>( -6.0f, 1.0));
break;
case MeterIEC1NOR:
points.insert (std::pair<float,float>(-60.0f, 1.0)); // -42
points.insert (std::pair<float,float>(-57.0f, 0.5));
points.insert (std::pair<float,float>(-54.0f, 1.0));
points.insert (std::pair<float,float>(-51.0f, 0.5));
points.insert (std::pair<float,float>(-48.0f, 1.0));
points.insert (std::pair<float,float>(-45.0f, 0.5));
points.insert (std::pair<float,float>(-42.0f, 1.0));
points.insert (std::pair<float,float>(-39.0f, 0.5));
points.insert (std::pair<float,float>(-36.0f, 1.0));
points.insert (std::pair<float,float>(-33.0f, 1.0));
points.insert (std::pair<float,float>(-30.0f, 1.0));
points.insert (std::pair<float,float>(-27.0f, 1.0));
points.insert (std::pair<float,float>(-24.0f, 1.0));
points.insert (std::pair<float,float>(-21.0f, 1.0));
points.insert (std::pair<float,float>(-18.0f, 1.0));
points.insert (std::pair<float,float>(-15.0f, 1.0));
points.insert (std::pair<float,float>(-12.0f, 1.0));
points.insert (std::pair<float,float>( -9.0f, 1.0));
points.insert (std::pair<float,float>( -6.0f, 1.0));
break;
case MeterIEC1DIN:
points.insert (std::pair<float,float>( -3.0f, 0.5)); // "200%"
points.insert (std::pair<float,float>( -4.0f, 1.0)); // "100%"
points.insert (std::pair<float,float>( -9.0f, 1.0));
points.insert (std::pair<float,float>(-14.0f, 1.0));
points.insert (std::pair<float,float>(-15.0f, 0.5)); // "50%"
points.insert (std::pair<float,float>(-18.0f, 0.5)); // "-9"
points.insert (std::pair<float,float>(-19.0f, 1.0)); // "30%"
points.insert (std::pair<float,float>(-29.0f, 1.0)); // "10%"
points.insert (std::pair<float,float>(-35.0f, 0.5)); // "5%" " -20"
points.insert (std::pair<float,float>(-39.0f, 1.0)); // "3%"
points.insert (std::pair<float,float>(-49.0f, 0.5)); // "1%"
points.insert (std::pair<float,float>(-59.0f, 1.0));
break;
case MeterVU:
points.insert (std::pair<float,float>(-17.0f, 1.0));
points.insert (std::pair<float,float>(-18.0f, 1.0));
points.insert (std::pair<float,float>(-19.0f, 1.0));
points.insert (std::pair<float,float>(-20.0f, 1.0));
points.insert (std::pair<float,float>(-21.0f, 1.0));
points.insert (std::pair<float,float>(-22.0f, 1.0));
points.insert (std::pair<float,float>(-23.0f, 1.0));
points.insert (std::pair<float,float>(-25.0f, 1.0));
points.insert (std::pair<float,float>(-27.0f, 1.0));
points.insert (std::pair<float,float>(-30.0f, 1.0));
points.insert (std::pair<float,float>(-40.0f, 1.0));
break;
default:
points.insert (std::pair<int,float>(-60, 0.5));
points.insert (std::pair<int,float>(-50, 1.0));
points.insert (std::pair<int,float>(-40, 1.0));
points.insert (std::pair<int,float>(-30, 1.0));
if (Config->get_meter_line_up_level() == MeteringLineUp24) {
points.insert (std::pair<int,float>(-24, 1.0));
} else {
points.insert (std::pair<int,float>(-25, 1.0));
}
points.insert (std::pair<int,float>(-20, 1.0));
points.insert (std::pair<int,float>(-19, 0.5));
points.insert (std::pair<int,float>(-18, 1.0));
points.insert (std::pair<int,float>(-17, 0.5));
points.insert (std::pair<int,float>(-16, 0.5));
points.insert (std::pair<int,float>(-15, 1.0));
points.insert (std::pair<int,float>(-14, 0.5));
points.insert (std::pair<int,float>(-13, 0.5));
points.insert (std::pair<int,float>(-12, 0.5));
points.insert (std::pair<int,float>(-11, 0.5));
points.insert (std::pair<int,float>(-10, 1.0));
points.insert (std::pair<int,float>( -9, 1.0));
points.insert (std::pair<int,float>( -8, 0.5));
points.insert (std::pair<int,float>( -7, 0.5));
points.insert (std::pair<int,float>( -6, 0.5));
points.insert (std::pair<int,float>( -5, 1.0));
points.insert (std::pair<int,float>( -4, 0.5));
points.insert (std::pair<int,float>( -3, 1.0));
points.insert (std::pair<int,float>( -2, 0.5));
points.insert (std::pair<int,float>( -1, 0.5));
points.insert (std::pair<int,float>( 0, 1.0));
points.insert (std::pair<int,float>( 1, 0.5));
points.insert (std::pair<int,float>( 2, 0.5));
points.insert (std::pair<int,float>( 3, 1.0));
points.insert (std::pair<int,float>( 4, 0.5));
points.insert (std::pair<int,float>( 5, 0.5));
break;
}
points.insert (std::pair<int,float>(-20, 1.0));
points.insert (std::pair<int,float>(-19, 0.5));
points.insert (std::pair<int,float>(-18, 1.0));
points.insert (std::pair<int,float>(-17, 0.5));
points.insert (std::pair<int,float>(-16, 0.5));
points.insert (std::pair<int,float>(-15, 1.0));
points.insert (std::pair<int,float>(-14, 0.5));
points.insert (std::pair<int,float>(-13, 0.5));
points.insert (std::pair<int,float>(-12, 0.5));
points.insert (std::pair<int,float>(-11, 0.5));
points.insert (std::pair<int,float>(-10, 1.0));
points.insert (std::pair<int,float>( -9, 0.5));
points.insert (std::pair<int,float>( -8, 0.5));
points.insert (std::pair<int,float>( -7, 0.5));
points.insert (std::pair<int,float>( -6, 0.5));
points.insert (std::pair<int,float>( -5, 1.0));
points.insert (std::pair<int,float>( -4, 0.5));
points.insert (std::pair<int,float>( -3, 0.5));
points.insert (std::pair<int,float>( -2, 0.5));
points.insert (std::pair<int,float>( -1, 0.5));
points.insert (std::pair<int,float>( 0, 1.0));
points.insert (std::pair<int,float>( 1, 0.5));
points.insert (std::pair<int,float>( 2, 0.5));
points.insert (std::pair<int,float>( 3, 0.5));
points.insert (std::pair<int,float>( 4, 0.5));
points.insert (std::pair<int,float>( 5, 0.5));
break;
case DataType::MIDI:
@ -194,16 +422,10 @@ meter_render_ticks (Gtk::Widget& w, vector<ARDOUR::DataType> types)
switch (*i) {
case DataType::AUDIO:
if (j->first >= 0 || j->first == -9) {
cairo_set_source_rgb (cr,
UINT_RGBA_R_FLT(peakcolor),
UINT_RGBA_G_FLT(peakcolor),
UINT_RGBA_B_FLT(peakcolor));
} else {
cairo_set_source_rgb (cr, c.get_red_p(), c.get_green_p(), c.get_blue_p());
}
fraction = log_meter (j->first);
fraction = mtr_col_and_fract(cr, &c, peakcolor, type, j->first);
pos = height - (gint) floor (height * fraction);
pos = max (pos, 1);
cairo_move_to(cr, 0, pos + .5);
cairo_line_to(cr, 3, pos + .5);
cairo_stroke (cr);
@ -227,9 +449,8 @@ meter_render_ticks (Gtk::Widget& w, vector<ARDOUR::DataType> types)
return pattern;
}
static cairo_pattern_t*
meter_render_metrics (Gtk::Widget& w, vector<DataType> types)
meter_render_metrics (Gtk::Widget& w, MeterType type, vector<DataType> types)
{
Glib::RefPtr<Gdk::Window> win (w.get_window());
@ -286,16 +507,16 @@ meter_render_metrics (Gtk::Widget& w, vector<DataType> types)
}
cairo_fill (cr);
cairo_set_line_width (cr, 1.0);
height = min(max_pattern_metric_size, height);
uint32_t peakcolor = ARDOUR_UI::config()->color_by_name ("meterbridge peaklabel");
for (vector<DataType>::const_iterator i = types.begin(); i != types.end(); ++i) {
Gdk::Color c;
if (types.size() > 1) {
/* we're overlaying more than 1 set of marks, so use different colours */
Gdk::Color c;
switch (*i) {
case DataType::AUDIO:
c = w.get_style()->get_fg (Gtk::STATE_NORMAL);
@ -311,100 +532,191 @@ meter_render_metrics (Gtk::Widget& w, vector<DataType> types)
cairo_set_source_rgb (cr, c.get_red_p(), c.get_green_p(), c.get_blue_p());
}
std::map<int,float> points;
std::map<float,string> points;
switch (*i) {
case DataType::AUDIO:
layout->set_attributes (audio_font_attributes);
points.insert (std::pair<int,float>(-50, 0.5));
points.insert (std::pair<int,float>(-40, 0.5));
points.insert (std::pair<int,float>(-30, 0.5));
points.insert (std::pair<int,float>(-20, 1.0));
if (types.size() == 1) {
if (Config->get_meter_line_up_level() == MeteringLineUp24) {
points.insert (std::pair<int,float>(-24, 0.5));
} else {
points.insert (std::pair<int,float>(-25, 0.5));
}
points.insert (std::pair<int,float>(-15, 1.0));
}
points.insert (std::pair<int,float>(-18, 1.0));
points.insert (std::pair<int,float>(-10, 1.0));
points.insert (std::pair<int,float>( -5, 1.0));
points.insert (std::pair<int,float>( -3, 0.5));
points.insert (std::pair<int,float>( 0, 1.0));
points.insert (std::pair<int,float>( 3, 0.5));
break;
switch (type) {
case MeterK14:
points.insert (std::pair<int,string>(-54.0f, "-40"));
points.insert (std::pair<int,string>(-44.0f, "-30"));
points.insert (std::pair<int,string>(-34.0f, "-20"));
points.insert (std::pair<int,string>(-24.0f, "-10"));
points.insert (std::pair<int,string>(-20.0f, "-6"));
points.insert (std::pair<int,string>(-17.0f, "-3"));
points.insert (std::pair<int,string>(-14.0f, "0"));
points.insert (std::pair<int,string>(-11.0f, "+3"));
points.insert (std::pair<int,string>( -8.0f, "+6"));
points.insert (std::pair<int,string>( -4.0f, "+10"));
points.insert (std::pair<int,string>( 0.0f, "+14"));
break;
case MeterK20:
points.insert (std::pair<int,string>(-60.0f, "-40"));
points.insert (std::pair<int,string>(-50.0f, "-30"));
points.insert (std::pair<int,string>(-40.0f, "-20"));
points.insert (std::pair<int,string>(-30.0f, "-10"));
points.insert (std::pair<int,string>(-26.0f, "-6"));
points.insert (std::pair<int,string>(-23.0f, "-3"));
points.insert (std::pair<int,string>(-20.0f, "0"));
points.insert (std::pair<int,string>(-17.0f, "+3"));
points.insert (std::pair<int,string>(-14.0f, "+6"));
points.insert (std::pair<int,string>(-10.0f, "+10"));
points.insert (std::pair<int,string>( -5.0f, "+15"));
points.insert (std::pair<int,string>( 0.0f, "+20"));
break;
default:
case MeterPeak:
case MeterRMS:
points.insert (std::pair<int,string>(-50.0f, "-50"));
points.insert (std::pair<int,string>(-40.0f, "-40"));
points.insert (std::pair<int,string>(-30.0f, "-30"));
points.insert (std::pair<int,string>(-20.0f, "-20"));
if (types.size() == 1) {
if (Config->get_meter_line_up_level() == MeteringLineUp24) {
points.insert (std::pair<int,string>(-24.0f, "-24"));
} else {
points.insert (std::pair<int,string>(-25.0f, "-25"));
}
points.insert (std::pair<int,string>(-15.0f, "-15"));
}
points.insert (std::pair<int,string>(-18.0f, "-18"));
points.insert (std::pair<int,string>(-10.0f, "-10"));
points.insert (std::pair<int,string>( -5.0f, "-5"));
points.insert (std::pair<int,string>( -3.0f, "-3"));
points.insert (std::pair<int,string>( 0.0f, "+0"));
points.insert (std::pair<int,string>( 3.0f, "+3"));
break;
case MeterIEC2EBU:
points.insert (std::pair<float,string>(-30.0f, "-12"));
points.insert (std::pair<float,string>(-26.0f, "-8"));
points.insert (std::pair<float,string>(-22.0f, "-4"));
points.insert (std::pair<float,string>(-18.0f, "TST"));
points.insert (std::pair<float,string>(-14.0f, "+4"));
points.insert (std::pair<float,string>(-10.0f, "+8"));
points.insert (std::pair<float,string>( -6.0f, "+12"));
break;
case MeterIEC2BBC:
points.insert (std::pair<float,string>(-30.0f, "1"));
points.insert (std::pair<float,string>(-26.0f, "2"));
points.insert (std::pair<float,string>(-22.0f, "3"));
points.insert (std::pair<float,string>(-18.0f, "4"));
points.insert (std::pair<float,string>(-14.0f, "5"));
points.insert (std::pair<float,string>(-10.0f, "6"));
points.insert (std::pair<float,string>( -6.0f, "7"));
break;
case MeterIEC1NOR:
//points.insert (std::pair<float,string>(-60.0f, "-42"));
points.insert (std::pair<float,string>(-54.0f, "-36"));
points.insert (std::pair<float,string>(-48.0f, "-30"));
points.insert (std::pair<float,string>(-42.0f, "-24"));
points.insert (std::pair<float,string>(-36.0f, "-18"));
points.insert (std::pair<float,string>(-33.0f, "-15"));
points.insert (std::pair<float,string>(-30.0f, "-12"));
points.insert (std::pair<float,string>(-27.0f, "-9"));
points.insert (std::pair<float,string>(-24.0f, "-6"));
points.insert (std::pair<float,string>(-21.0f, "-3"));
points.insert (std::pair<float,string>(-18.0f, "TST"));
points.insert (std::pair<float,string>(-15.0f, "+3"));
points.insert (std::pair<float,string>(-12.0f, "+6"));
points.insert (std::pair<float,string>( -9.0f, "+9"));
points.insert (std::pair<float,string>( -6.0f, "+12"));
break;
case MeterIEC1DIN:
//points.insert (std::pair<float,string>( -3.0f, "200%"));
points.insert (std::pair<float,string>( -4.0f, "+5")); // "100%"
points.insert (std::pair<float,string>( -9.0f, "0"));
points.insert (std::pair<float,string>(-14.0f, "-5"));
//points.insert (std::pair<float,string>(-15.0f, "50%"));
//points.insert (std::pair<float,string>(-18.0f, "-9"));
points.insert (std::pair<float,string>(-19.0f, "-10")); // "30%"
points.insert (std::pair<float,string>(-29.0f, "-20")); // "10%"
//points.insert (std::pair<float,string>(-35.0f, "-20")); // "5%"
points.insert (std::pair<float,string>(-39.0f, "-30")); // "3%"
//points.insert (std::pair<float,string>(-49.0f, "1%"));
points.insert (std::pair<float,string>(-59.0f, "-50"));
break;
case MeterVU:
points.insert (std::pair<float,string>(-17.0f, "+3"));
points.insert (std::pair<float,string>(-18.0f, "+2"));
points.insert (std::pair<float,string>(-19.0f, "+1"));
points.insert (std::pair<float,string>(-20.0f, "0"));
points.insert (std::pair<float,string>(-21.0f, "-1"));
points.insert (std::pair<float,string>(-22.0f, "-2"));
points.insert (std::pair<float,string>(-23.0f, "-3"));
points.insert (std::pair<float,string>(-25.0f, "-5"));
points.insert (std::pair<float,string>(-27.0f, "-7"));
points.insert (std::pair<float,string>(-30.0f, "-10"));
points.insert (std::pair<float,string>(-40.0f, "-20"));
break;
}
break;
case DataType::MIDI:
layout->set_attributes (midi_font_attributes);
points.insert (std::pair<int,float>( 0, 1.0));
points.insert (std::pair<int,string>( 0, "0"));
if (types.size() == 1) {
points.insert (std::pair<int,float>( 16, 0.5));
points.insert (std::pair<int,float>( 32, 0.5));
points.insert (std::pair<int,float>( 48, 0.5));
points.insert (std::pair<int,float>( 64, 1.0));
points.insert (std::pair<int,float>( 80, 0.5));
points.insert (std::pair<int,float>( 96, 0.5));
points.insert (std::pair<int,float>(100, 0.5));
points.insert (std::pair<int,float>(112, 0.5));
points.insert (std::pair<int,string>( 16, "16"));
points.insert (std::pair<int,string>( 32, "32"));
points.insert (std::pair<int,string>( 48, "48"));
points.insert (std::pair<int,string>( 64, "64"));
points.insert (std::pair<int,string>( 80, "80"));
points.insert (std::pair<int,string>( 96, "96"));
points.insert (std::pair<int,string>(100, "100"));
points.insert (std::pair<int,string>(112, "112"));
} else {
/* labels that don't overlay with dB */
points.insert (std::pair<int,float>( 24, 0.5));
points.insert (std::pair<int,float>( 48, 0.5));
points.insert (std::pair<int,float>( 72, 0.5));
points.insert (std::pair<int,string>( 24, "24"));
points.insert (std::pair<int,string>( 48, "48"));
points.insert (std::pair<int,string>( 72, "74"));
}
points.insert (std::pair<int,float>(127, 1.0));
points.insert (std::pair<int,string>(127, "127"));
break;
}
char buf[32];
gint pos;
for (std::map<int,float>::const_iterator j = points.begin(); j != points.end(); ++j) {
for (std::map<float,string>::const_iterator j = points.begin(); j != points.end(); ++j) {
float fraction = 0;
switch (*i) {
case DataType::AUDIO:
cairo_set_line_width (cr, (j->second));
if (j->first >= 0) {
cairo_set_source_rgb (cr,
UINT_RGBA_R_FLT(peakcolor),
UINT_RGBA_G_FLT(peakcolor),
UINT_RGBA_B_FLT(peakcolor));
}
fraction = log_meter (j->first);
snprintf (buf, sizeof (buf), "%+2d", j->first);
pos = height - (gint) floor (height * fraction);
if (tickleft) {
cairo_move_to(cr, width-1.5, pos + .5);
cairo_line_to(cr, width, pos + .5);
cairo_stroke (cr);
} else if (tickright) {
cairo_move_to(cr, 0, pos + .5);
cairo_line_to(cr, 1.5, pos + .5);
cairo_stroke (cr);
}
break;
case DataType::MIDI:
cairo_set_line_width (cr, 1.0);
fraction = (j->first) / 127.0;
snprintf (buf, sizeof (buf), "%3d", j->first);
pos = 1 + height - (gint) rintf (height * fraction);
pos = min (pos, height);
if (tickleft) {
cairo_arc(cr, width - 2.0, pos + .5, 1.0, 0, 2 * M_PI);
cairo_fill(cr);
} else if (tickright) {
cairo_arc(cr, 3, pos + .5, 1.0, 0, 2 * M_PI);
cairo_fill(cr);
}
break;
case DataType::AUDIO:
fraction = mtr_col_and_fract(cr, &c, peakcolor, type, j->first);
pos = height - (gint) floor (height * fraction);
pos = max (pos, 1);
if (tickleft) {
cairo_move_to(cr, width-1.5, pos + .5);
cairo_line_to(cr, width, pos + .5);
cairo_stroke (cr);
} else if (tickright) {
cairo_move_to(cr, 0, pos + .5);
cairo_line_to(cr, 1.5, pos + .5);
cairo_stroke (cr);
}
break;
case DataType::MIDI:
fraction = (j->first) / 127.0;
pos = 1 + height - (gint) rintf (height * fraction);
pos = min (pos, height);
if (tickleft) {
cairo_arc(cr, width - 2.0, pos + .5, 1.0, 0, 2 * M_PI);
cairo_fill(cr);
} else if (tickright) {
cairo_arc(cr, 3, pos + .5, 1.0, 0, 2 * M_PI);
cairo_fill(cr);
}
break;
}
layout->set_text(buf);
/* we want logical extents, not ink extents here */
layout->set_text(j->second.c_str());
int tw, th;
layout->get_pixel_size(tw, th);
@ -418,12 +730,40 @@ meter_render_metrics (Gtk::Widget& w, vector<DataType> types)
}
}
// add legend
if (types.size() == 1) {
int tw, th;
layout->set_attributes (unit_font_attributes);
switch (types.at(0)) {
case DataType::AUDIO:
layout->set_text("dBFS");
switch (type) {
case MeterK20:
layout->set_text("K20");
break;
case MeterK14:
layout->set_text("K14");
break;
default:
case MeterPeak:
case MeterRMS:
layout->set_text("dBFS");
break;
case MeterIEC2EBU:
layout->set_text("EBU");
break;
case MeterIEC2BBC:
layout->set_text("BBC");
break;
case MeterIEC1DIN:
layout->set_text("DIN");
break;
case MeterIEC1NOR:
layout->set_text("NOR");
break;
case MeterVU:
layout->set_text("VU");
break;
}
layout->get_pixel_size(tw, th);
break;
case DataType::MIDI:
@ -445,9 +785,8 @@ meter_render_metrics (Gtk::Widget& w, vector<DataType> types)
return pattern;
}
gint
ArdourMeter::meter_expose_ticks (GdkEventExpose *ev, std::vector<ARDOUR::DataType> types, Gtk::DrawingArea *mta)
ArdourMeter::meter_expose_ticks (GdkEventExpose *ev, MeterType type, std::vector<ARDOUR::DataType> types, Gtk::DrawingArea *mta)
{
Glib::RefPtr<Gdk::Window> win (mta->get_window());
cairo_t* cr;
@ -460,11 +799,12 @@ ArdourMeter::meter_expose_ticks (GdkEventExpose *ev, std::vector<ARDOUR::DataTyp
cairo_clip (cr);
cairo_pattern_t* pattern;
TickPatterns::iterator i = ticks_patterns.find (mta->get_name());
const MeterMatricsMapKey key (mta->get_name(), type);
MetricPatternMap::iterator i = ticks_patterns.find (key);
if (i == ticks_patterns.end()) {
pattern = meter_render_ticks (*mta, types);
ticks_patterns[mta->get_name()] = pattern;
pattern = meter_render_ticks (*mta, type, types);
ticks_patterns[key] = pattern;
} else {
pattern = i->second;
}
@ -484,7 +824,7 @@ ArdourMeter::meter_expose_ticks (GdkEventExpose *ev, std::vector<ARDOUR::DataTyp
}
gint
ArdourMeter::meter_expose_metrics (GdkEventExpose *ev, std::vector<ARDOUR::DataType> types, Gtk::DrawingArea *mma)
ArdourMeter::meter_expose_metrics (GdkEventExpose *ev, MeterType type, std::vector<ARDOUR::DataType> types, Gtk::DrawingArea *mma)
{
Glib::RefPtr<Gdk::Window> win (mma->get_window());
cairo_t* cr;
@ -497,11 +837,12 @@ ArdourMeter::meter_expose_metrics (GdkEventExpose *ev, std::vector<ARDOUR::DataT
cairo_clip (cr);
cairo_pattern_t* pattern;
MetricPatterns::iterator i = metric_patterns.find (mma->get_name());
const MeterMatricsMapKey key (mma->get_name(), type);
MetricPatternMap::iterator i = metric_patterns.find (key);
if (i == metric_patterns.end()) {
pattern = meter_render_metrics (*mma, types);
metric_patterns[mma->get_name()] = pattern;
pattern = meter_render_metrics (*mma, type, types);
metric_patterns[key] = pattern;
} else {
pattern = i->second;
}
@ -522,12 +863,13 @@ ArdourMeter::meter_expose_metrics (GdkEventExpose *ev, std::vector<ARDOUR::DataT
void
ArdourMeter::meter_clear_pattern_cache(int which) {
MetricPatterns::iterator i = metric_patterns.begin();
TickPatterns::iterator j = ticks_patterns.begin();
MetricPatternMap::iterator i = metric_patterns.begin();
MetricPatternMap::iterator j = ticks_patterns.begin();
while (i != metric_patterns.end()) {
int m = 4;
std::string n = i->first;
MeterMatricsMapKey const * const key = &(i->first);
std::string n = key->_n;
if (n.substr(n.length() - 4) == "Left") { m = 1; }
if (n.substr(n.length() - 5) == "Right") { m = 2; }
if (which & m) {
@ -540,7 +882,8 @@ ArdourMeter::meter_clear_pattern_cache(int which) {
while (j != ticks_patterns.end()) {
int m = 4;
std::string n = j->first;
MeterMatricsMapKey const * const key = &(j->first);
std::string n = key->_n;
if (n.substr(n.length() - 4) == "Left") { m = 1; }
if (n.substr(n.length() - 5) == "Right") { m = 2; }
if (which & m) {

4
gtk2_ardour/meter_patterns.h
View File

@ -37,8 +37,8 @@ extern sigc::signal<void> RedrawMetrics;
extern sigc::signal<void, int, ARDOUR::RouteGroup*, ARDOUR::MeterType> SetMeterTypeMulti;
gint meter_expose_ticks (GdkEventExpose *ev, std::vector<ARDOUR::DataType> types, Gtk::DrawingArea *mta);
gint meter_expose_metrics (GdkEventExpose *ev, std::vector<ARDOUR::DataType> types, Gtk::DrawingArea *mma);
gint meter_expose_ticks (GdkEventExpose *ev, ARDOUR::MeterType type, std::vector<ARDOUR::DataType> types, Gtk::DrawingArea *mta);
gint meter_expose_metrics (GdkEventExpose *ev, ARDOUR::MeterType type, std::vector<ARDOUR::DataType> types, Gtk::DrawingArea *mma);
void meter_clear_pattern_cache(int which=7);

23
gtk2_ardour/meter_strip.cc
View File

@ -112,8 +112,8 @@ MeterStrip::MeterStrip (Session* sess, boost::shared_ptr<ARDOUR::Route> rt)
level_meter = new LevelMeter(sess);
level_meter->set_meter (_route->shared_peak_meter().get());
level_meter->clear_meters();
level_meter->setup_meters (220, meter_width, 6);
level_meter->set_type (_route->meter_type());
level_meter->setup_meters (220, meter_width, 6);
level_meter->ButtonPress.connect_same_thread (level_meter_connection, boost::bind (&MeterStrip::level_meter_button_press, this, _1));
level_meter->MeterTypeChanged.connect_same_thread (level_meter_connection, boost::bind (&MeterStrip::meter_type_changed, this, _1));
@ -394,7 +394,8 @@ MeterStrip::on_size_allocate (Gtk::Allocation& a)
gint
MeterStrip::meter_metrics_expose (GdkEventExpose *ev)
{
return meter_expose_metrics(ev, _types, &meter_metric_area);
// TODO meter-type - set with set_metric_mode()
return meter_expose_metrics(ev, /*XXX*/ MeterPeak, _types, &meter_metric_area);
}
void
@ -432,13 +433,15 @@ MeterStrip::set_pos (int pos)
gint
MeterStrip::meter_ticks1_expose (GdkEventExpose *ev)
{
return meter_expose_ticks(ev, _types, &meter_ticks1_area);
assert(_route);
return meter_expose_ticks(ev, _route->meter_type(), _types, &meter_ticks1_area);
}
gint
MeterStrip::meter_ticks2_expose (GdkEventExpose *ev)
{
return meter_expose_ticks(ev, _types, &meter_ticks2_area);
assert(_route);
return meter_expose_ticks(ev, _route->meter_type(), _types, &meter_ticks2_area);
}
void
@ -572,10 +575,14 @@ MeterStrip::popup_level_meter_menu (GdkEventButton* ev)
_suspend_menu_callbacks = true;
add_level_meter_item (items, group, ArdourMeter::meter_type_string(MeterPeak), MeterPeak);
add_level_meter_item (items, group, ArdourMeter::meter_type_string(MeterKrms), MeterKrms);
add_level_meter_item (items, group, ArdourMeter::meter_type_string(MeterIEC1), MeterIEC1);
add_level_meter_item (items, group, ArdourMeter::meter_type_string(MeterIEC2), MeterIEC2);
add_level_meter_item (items, group, ArdourMeter::meter_type_string(MeterVU), MeterVU);
add_level_meter_item (items, group, ArdourMeter::meter_type_string(MeterRMS), MeterRMS);
add_level_meter_item (items, group, ArdourMeter::meter_type_string(MeterIEC1DIN), MeterIEC1DIN);
add_level_meter_item (items, group, ArdourMeter::meter_type_string(MeterIEC1NOR), MeterIEC1NOR);
add_level_meter_item (items, group, ArdourMeter::meter_type_string(MeterIEC2BBC), MeterIEC2BBC);
add_level_meter_item (items, group, ArdourMeter::meter_type_string(MeterIEC2EBU), MeterIEC2EBU);
add_level_meter_item (items, group, ArdourMeter::meter_type_string(MeterK20), MeterK20);
add_level_meter_item (items, group, ArdourMeter::meter_type_string(MeterK14), MeterK14);
add_level_meter_item (items, group, ArdourMeter::meter_type_string(MeterVU), MeterVU);
MeterType cmt = _route->meter_type();
const std::string cmn = ArdourMeter::meter_type_string(cmt);

12
gtk2_ardour/mixer_strip.cc
View File

@ -2134,10 +2134,14 @@ MixerStrip::popup_level_meter_menu (GdkEventButton* ev)
items.push_back (SeparatorElem());
add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterPeak), MeterPeak);
add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterKrms), MeterKrms);
add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterIEC1), MeterIEC1);
add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterIEC2), MeterIEC2);
add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterVU), MeterVU);
add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterRMS), MeterRMS);
add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterIEC1DIN), MeterIEC1DIN);
add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterIEC1NOR), MeterIEC1NOR);
add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterIEC2BBC), MeterIEC2BBC);
add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterIEC2EBU), MeterIEC2EBU);
add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterK20), MeterK20);
add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterK14), MeterK14);
add_level_meter_item_type (items, tgroup, ArdourMeter::meter_type_string(MeterVU), MeterVU);
int _strip_type;
if (_route->is_master()) {

18
libs/ardour/ardour/types.h
View File

@ -178,13 +178,17 @@ namespace ARDOUR {
};
enum MeterType {
MeterMaxSignal = 0x01,
MeterMaxPeak = 0x02,
MeterPeak = 0x04,
MeterKrms = 0x08,
MeterIEC1 = 0x10,
MeterIEC2 = 0x20,
MeterVU = 0x40
MeterMaxSignal = 0x001,
MeterMaxPeak = 0x002,
MeterPeak = 0x004,
MeterRMS = 0x008,
MeterK20 = 0x010,
MeterK14 = 0x020,
MeterIEC1DIN = 0x040,
MeterIEC1NOR = 0x080,
MeterIEC2BBC = 0x100,
MeterIEC2EBU = 0x200,
MeterVU = 0x400
};
enum TrackMode {

10
libs/ardour/enums.cc
View File

@ -176,9 +176,13 @@ setup_enum_writer ()
REGISTER_ENUM (MeterMaxSignal);
REGISTER_ENUM (MeterMaxPeak);
REGISTER_ENUM (MeterPeak);
REGISTER_ENUM (MeterKrms);
REGISTER_ENUM (MeterIEC1);
REGISTER_ENUM (MeterIEC2);
REGISTER_ENUM (MeterRMS);
REGISTER_ENUM (MeterK20);
REGISTER_ENUM (MeterK14);
REGISTER_ENUM (MeterIEC1DIN);
REGISTER_ENUM (MeterIEC1NOR);
REGISTER_ENUM (MeterIEC2BBC);
REGISTER_ENUM (MeterIEC2EBU);
REGISTER_ENUM (MeterVU);
REGISTER (_MeterType);

22
libs/ardour/meter.cc
View File

@ -106,13 +106,13 @@ PeakMeter::run (BufferSet& bufs, framepos_t /*start_frame*/, framepos_t /*end_fr
// Meter audio in to the rest of the peaks
for (uint32_t i = 0; i < n_audio; ++i, ++n) {
_peak_signal[n] = compute_peak (bufs.get_audio(i).data(), nframes, _peak_signal[n]);
if (_meter_type & MeterKrms) {
if (_meter_type & (MeterRMS | MeterK20 | MeterK14)) {
_kmeter[i]->process(bufs.get_audio(i).data(), nframes);
}
if (_meter_type & MeterIEC1) {
if (_meter_type & (MeterIEC1DIN | MeterIEC1NOR)) {
_iec1meter[i]->process(bufs.get_audio(i).data(), nframes);
}
if (_meter_type & MeterIEC2) {
if (_meter_type & (MeterIEC2BBC | MeterIEC2EBU)) {
_iec2meter[i]->process(bufs.get_audio(i).data(), nframes);
}
if (_meter_type & MeterVU) {
@ -323,7 +323,9 @@ PeakMeter::meter ()
float
PeakMeter::meter_level(uint32_t n, MeterType type) {
switch (type) {
case MeterKrms:
case MeterRMS:
case MeterK20:
case MeterK14:
{
const uint32_t n_midi = current_meters.n_midi();
if ((n - n_midi) < _kmeter.size() && (n - n_midi) >= 0) {
@ -331,7 +333,8 @@ PeakMeter::meter_level(uint32_t n, MeterType type) {
}
}
break;
case MeterIEC1:
case MeterIEC1DIN:
case MeterIEC1NOR:
{
const uint32_t n_midi = current_meters.n_midi();
if ((n - n_midi) < _iec1meter.size() && (n - n_midi) >= 0) {
@ -339,7 +342,8 @@ PeakMeter::meter_level(uint32_t n, MeterType type) {
}
}
break;
case MeterIEC2:
case MeterIEC2BBC:
case MeterIEC2EBU:
{
const uint32_t n_midi = current_meters.n_midi();
if ((n - n_midi) < _iec2meter.size() && (n - n_midi) >= 0) {
@ -381,19 +385,19 @@ PeakMeter::set_type(MeterType t)
_meter_type = t;
if (t & MeterKrms) {
if (t & (MeterRMS | MeterK20 | MeterK14)) {
const size_t n_audio = current_meters.n_audio();
for (size_t n = 0; n < n_audio; ++n) {
_kmeter[n]->reset();
}
}
if (t & MeterIEC1) {
if (t & (MeterIEC1DIN | MeterIEC1NOR)) {
const size_t n_audio = current_meters.n_audio();
for (size_t n = 0; n < n_audio; ++n) {
_iec1meter[n]->reset();
}
}
if (t & MeterIEC2) {
if (t & (MeterIEC2BBC | MeterIEC2EBU)) {
const size_t n_audio = current_meters.n_audio();
for (size_t n = 0; n < n_audio; ++n) {
_iec2meter[n]->reset();