git.sesse.net Git - nageru/blob - mainwindow.cpp

   1 #include "mainwindow.h"
   2
   3 #include <math.h>
   4 #include <stdio.h>
   5 #include <signal.h>
   6 #include <algorithm>
   7 #include <chrono>
   8 #include <string>
   9 #include <vector>
  10 #include <QBoxLayout>
  11 #include <QInputDialog>
  12 #include <QKeySequence>
  13 #include <QLabel>
  14 #include <QMessageBox>
  15 #include <QMetaType>
  16 #include <QPushButton>
  17 #include <QResizeEvent>
  18 #include <QShortcut>
  19 #include <QSize>
  20 #include <QString>
  21
  22 #include "aboutdialog.h"
  23 #include "disk_space_estimator.h"
  24 #include "flags.h"
  25 #include "glwidget.h"
  26 #include "input_mapping_dialog.h"
  27 #include "lrameter.h"
  28 #include "midi_mapping.pb.h"
  29 #include "midi_mapping_dialog.h"
  30 #include "mixer.h"
  31 #include "post_to_main_thread.h"
  32 #include "ui_audio_miniview.h"
  33 #include "ui_audio_expanded_view.h"
  34 #include "ui_display.h"
  35 #include "ui_mainwindow.h"
  36 #include "vumeter.h"
  37
  38 class QResizeEvent;
  39
  40 using namespace std;
  41 using namespace std::chrono;
  42 using namespace std::placeholders;
  43
  44 Q_DECLARE_METATYPE(std::string);
  45 Q_DECLARE_METATYPE(std::vector<std::string>);
  46
  47 MainWindow *global_mainwindow = nullptr;
  48
  49 // -0.1 dBFS is EBU peak limit. We use it consistently, even for the bus meters
  50 // (which don't calculate interpolate peak, and in general don't follow EBU recommendations).
  51 constexpr float peak_limit_dbfs = -0.1f;
  52
  53 namespace {
  54
  55 void schedule_cut_signal(int ignored)
  56 {
  57         global_mixer->schedule_cut();
  58 }
  59
  60 void quit_signal(int ignored)
  61 {
  62         global_mainwindow->close();
  63 }
  64
  65 void slave_knob(QDial *master, QDial *slave)
  66 {
  67         QWidget::connect(master, &QDial::valueChanged, [slave](int value){
  68                 slave->blockSignals(true);
  69                 slave->setValue(value);
  70                 slave->blockSignals(false);
  71         });
  72         QWidget::connect(slave, &QDial::valueChanged, [master](int value){
  73                 master->setValue(value);
  74         });
  75 }
  76
  77 void slave_checkbox(QCheckBox *master, QCheckBox *slave)
  78 {
  79         QWidget::connect(master, &QCheckBox::stateChanged, [slave](int state){
  80                 slave->blockSignals(true);
  81                 slave->setCheckState(Qt::CheckState(state));
  82                 slave->blockSignals(false);
  83         });
  84         QWidget::connect(slave, &QCheckBox::stateChanged, [master](int state){
  85                 master->setCheckState(Qt::CheckState(state));
  86         });
  87 }
  88
  89 void slave_fader(NonLinearFader *master, NonLinearFader *slave)
  90 {
  91         QWidget::connect(master, &NonLinearFader::dbValueChanged, [slave](double value) {
  92                 slave->blockSignals(true);
  93                 slave->setDbValue(value);
  94                 slave->blockSignals(false);
  95         });
  96         QWidget::connect(slave, &NonLinearFader::dbValueChanged, [master](double value){
  97                 master->setDbValue(value);
  98         });
  99 }
 100
 101 constexpr unsigned DB_NO_FLAGS = 0x0;
 102 constexpr unsigned DB_WITH_SIGN = 0x1;
 103 constexpr unsigned DB_BARE = 0x2;
 104
 105 string format_db(double db, unsigned flags)
 106 {
 107         string text;
 108         if (flags & DB_WITH_SIGN) {
 109                 if (isfinite(db)) {
 110                         char buf[256];
 111                         snprintf(buf, sizeof(buf), "%+.1f", db);
 112                         text = buf;
 113                 } else if (db < 0.0) {
 114                         text = "-∞";
 115                 } else {
 116                         // Should never happen, really.
 117                         text = "+∞";
 118                 }
 119         } else {
 120                 if (isfinite(db)) {
 121                         char buf[256];
 122                         snprintf(buf, sizeof(buf), "%.1f", db);
 123                         text = buf;
 124                 } else if (db < 0.0) {
 125                         text = "-∞";
 126                 } else {
 127                         // Should never happen, really.
 128                         text = "∞";
 129                 }
 130         }
 131         if (!(flags & DB_BARE)) {
 132                 text += " dB";
 133         }
 134         return text;
 135 }
 136
 137 void set_peak_label(QLabel *peak_label, float peak_db)
 138 {
 139         peak_label->setText(QString::fromStdString(format_db(peak_db, DB_BARE)));
 140
 141         if (peak_db > peak_limit_dbfs) {
 142                 peak_label->setStyleSheet("QLabel { background-color: red; color: white; }");
 143         } else {
 144                 peak_label->setStyleSheet("");
 145         }
 146 }
 147
 148 }  // namespace
 149
 150 MainWindow::MainWindow()
 151         : ui(new Ui::MainWindow), midi_mapper(this)
 152 {
 153         global_mainwindow = this;
 154         ui->setupUi(this);
 155
 156         global_disk_space_estimator = new DiskSpaceEstimator(bind(&MainWindow::report_disk_space, this, _1, _2));
 157         disk_free_label = new QLabel(this);
 158         disk_free_label->setStyleSheet("QLabel {padding-right: 5px;}");
 159         ui->menuBar->setCornerWidget(disk_free_label);
 160
 161         QActionGroup *audio_mapping_group = new QActionGroup(this);
 162         ui->simple_audio_mode->setActionGroup(audio_mapping_group);
 163         ui->multichannel_audio_mode->setActionGroup(audio_mapping_group);
 164
 165         ui->me_live->set_output(Mixer::OUTPUT_LIVE);
 166         ui->me_preview->set_output(Mixer::OUTPUT_PREVIEW);
 167
 168         // The menus.
 169         connect(ui->cut_action, &QAction::triggered, this, &MainWindow::cut_triggered);
 170         connect(ui->exit_action, &QAction::triggered, this, &MainWindow::exit_triggered);
 171         connect(ui->about_action, &QAction::triggered, this, &MainWindow::about_triggered);
 172         connect(ui->simple_audio_mode, &QAction::triggered, this, &MainWindow::simple_audio_mode_triggered);
 173         connect(ui->multichannel_audio_mode, &QAction::triggered, this, &MainWindow::multichannel_audio_mode_triggered);
 174         connect(ui->input_mapping_action, &QAction::triggered, this, &MainWindow::input_mapping_triggered);
 175         connect(ui->midi_mapping_action, &QAction::triggered, this, &MainWindow::midi_mapping_triggered);
 176
 177         if (global_flags.x264_video_to_http) {
 178                 connect(ui->x264_bitrate_action, &QAction::triggered, this, &MainWindow::x264_bitrate_triggered);
 179         } else {
 180                 ui->x264_bitrate_action->setEnabled(false);
 181         }
 182
 183         // Hook up the transition buttons. (Keyboard shortcuts are set in set_transition_names().)
 184         // TODO: Make them dynamic.
 185         connect(ui->transition_btn1, &QPushButton::clicked, bind(&MainWindow::transition_clicked, this, 0));
 186         connect(ui->transition_btn2, &QPushButton::clicked, bind(&MainWindow::transition_clicked, this, 1));
 187         connect(ui->transition_btn3, &QPushButton::clicked, bind(&MainWindow::transition_clicked, this, 2));
 188
 189         // Aiee...
 190         transition_btn1 = ui->transition_btn1;
 191         transition_btn2 = ui->transition_btn2;
 192         transition_btn3 = ui->transition_btn3;
 193         qRegisterMetaType<string>("std::string");
 194         qRegisterMetaType<vector<string>>("std::vector<std::string>");
 195         connect(ui->me_live, &GLWidget::transition_names_updated, this, &MainWindow::set_transition_names);
 196         qRegisterMetaType<Mixer::Output>("Mixer::Output");
 197
 198         // Hook up the prev/next buttons on the audio views.
 199         connect(ui->compact_prev_page, &QAbstractButton::clicked, bind(&QStackedWidget::setCurrentIndex, ui->audio_views, 1));
 200         connect(ui->compact_next_page, &QAbstractButton::clicked, bind(&QStackedWidget::setCurrentIndex, ui->audio_views, 1));
 201         connect(ui->full_prev_page, &QAbstractButton::clicked, bind(&QStackedWidget::setCurrentIndex, ui->audio_views, 0));
 202         connect(ui->full_next_page, &QAbstractButton::clicked, bind(&QStackedWidget::setCurrentIndex, ui->audio_views, 0));
 203
 204         // And bind the same to PgUp/PgDown.
 205         auto switch_page = [this]{
 206                 if (global_audio_mixer->get_mapping_mode() == AudioMixer::MappingMode::MULTICHANNEL) {
 207                         ui->audio_views->setCurrentIndex(1 - ui->audio_views->currentIndex());
 208                 }
 209         };
 210         connect(new QShortcut(QKeySequence::MoveToNextPage, this), &QShortcut::activated, switch_page);
 211         connect(new QShortcut(QKeySequence::MoveToPreviousPage, this), &QShortcut::activated, switch_page);
 212
 213         last_audio_level_callback = steady_clock::now() - seconds(1);
 214
 215         if (!global_flags.midi_mapping_filename.empty()) {
 216                 MIDIMappingProto midi_mapping;
 217                 if (!load_midi_mapping_from_file(global_flags.midi_mapping_filename, &midi_mapping)) {
 218                         fprintf(stderr, "Couldn't load MIDI mapping '%s'; exiting.\n",
 219                                 global_flags.midi_mapping_filename.c_str());
 220                         exit(1);
 221                 }
 222                 midi_mapper.set_midi_mapping(midi_mapping);
 223         }
 224         midi_mapper.start_thread();
 225 }
 226
 227 void MainWindow::resizeEvent(QResizeEvent* event)
 228 {
 229         QMainWindow::resizeEvent(event);
 230
 231         // Ask for a relayout, but only after the event loop is done doing relayout
 232         // on everything else.
 233         QMetaObject::invokeMethod(this, "relayout", Qt::QueuedConnection);
 234 }
 235
 236 void MainWindow::mixer_created(Mixer *mixer)
 237 {
 238         // Make the previews.
 239         unsigned num_previews = mixer->get_num_channels();
 240
 241         for (unsigned i = 0; i < num_previews; ++i) {
 242                 Mixer::Output output = Mixer::Output(Mixer::OUTPUT_INPUT0 + i);
 243
 244                 QWidget *preview = new QWidget(this);
 245                 Ui::Display *ui_display = new Ui::Display;
 246                 ui_display->setupUi(preview);
 247                 ui_display->label->setText(mixer->get_channel_name(output).c_str());
 248                 ui_display->display->set_output(output);
 249                 ui->preview_displays->insertWidget(previews.size(), preview, 1);
 250                 previews.push_back(ui_display);
 251
 252                 // Hook up the click.
 253                 connect(ui_display->display, &GLWidget::clicked, bind(&MainWindow::channel_clicked, this, i));
 254
 255                 // Let the theme update the text whenever the resolution or color changed.
 256                 connect(ui_display->display, &GLWidget::name_updated, this, &MainWindow::update_channel_name);
 257                 connect(ui_display->display, &GLWidget::color_updated, this, &MainWindow::update_channel_color);
 258
 259                 // Hook up the keyboard key.
 260                 QShortcut *shortcut = new QShortcut(QKeySequence(Qt::Key_1 + i), this);
 261                 connect(shortcut, &QShortcut::activated, bind(&MainWindow::channel_clicked, this, i));
 262
 263                 // Hook up the white balance button (irrelevant if invisible).
 264                 ui_display->wb_button->setVisible(mixer->get_supports_set_wb(output));
 265                 connect(ui_display->wb_button, &QPushButton::clicked, bind(&MainWindow::wb_button_clicked, this, i));
 266         }
 267
 268         global_audio_mixer->set_state_changed_callback(bind(&MainWindow::audio_state_changed, this));
 269
 270         slave_knob(ui->locut_cutoff_knob, ui->locut_cutoff_knob_2);
 271         slave_knob(ui->limiter_threshold_knob, ui->limiter_threshold_knob_2);
 272         slave_knob(ui->makeup_gain_knob, ui->makeup_gain_knob_2);
 273         slave_checkbox(ui->makeup_gain_auto_checkbox, ui->makeup_gain_auto_checkbox_2);
 274         slave_checkbox(ui->limiter_enabled, ui->limiter_enabled_2);
 275
 276         reset_audio_mapping_ui();
 277
 278         // TODO: Fetch all of the values these for completeness,
 279         // not just the enable knobs implied by flags.
 280         ui->limiter_enabled->setChecked(global_audio_mixer->get_limiter_enabled());
 281         ui->makeup_gain_auto_checkbox->setChecked(global_audio_mixer->get_final_makeup_gain_auto());
 282
 283         // Controls used only for simple audio fetch their state from the first bus.
 284         constexpr unsigned simple_bus_index = 0;
 285         if (global_audio_mixer->get_mapping_mode() == AudioMixer::MappingMode::SIMPLE) {
 286                 ui->locut_enabled->setChecked(global_audio_mixer->get_locut_enabled(simple_bus_index));
 287                 ui->gainstaging_knob->setValue(global_audio_mixer->get_gain_staging_db(simple_bus_index));
 288                 ui->gainstaging_auto_checkbox->setChecked(global_audio_mixer->get_gain_staging_auto(simple_bus_index));
 289                 ui->compressor_enabled->setChecked(global_audio_mixer->get_compressor_enabled(simple_bus_index));
 290                 ui->compressor_threshold_db_display->setText(
 291                         QString::fromStdString(format_db(mixer->get_audio_mixer()->get_compressor_threshold_dbfs(simple_bus_index), DB_WITH_SIGN)));
 292         }
 293         connect(ui->locut_enabled, &QCheckBox::stateChanged, [this](int state){
 294                 global_audio_mixer->set_locut_enabled(simple_bus_index, state == Qt::Checked);
 295                 midi_mapper.refresh_lights();
 296         });
 297         connect(ui->gainstaging_knob, &QAbstractSlider::valueChanged,
 298                 bind(&MainWindow::gain_staging_knob_changed, this, simple_bus_index, _1));
 299         connect(ui->gainstaging_auto_checkbox, &QCheckBox::stateChanged, [this, simple_bus_index](int state){
 300                 global_audio_mixer->set_gain_staging_auto(simple_bus_index, state == Qt::Checked);
 301                 midi_mapper.refresh_lights();
 302         });
 303         connect(ui->compressor_threshold_knob, &QDial::valueChanged,
 304                 bind(&MainWindow::compressor_threshold_knob_changed, this, simple_bus_index, _1));
 305         connect(ui->compressor_enabled, &QCheckBox::stateChanged, [this, simple_bus_index](int state){
 306                 global_audio_mixer->set_compressor_enabled(simple_bus_index, state == Qt::Checked);
 307                 midi_mapper.refresh_lights();
 308         });
 309
 310         // Global mastering controls.
 311         QString limiter_threshold_label(
 312                 QString::fromStdString(format_db(mixer->get_audio_mixer()->get_limiter_threshold_dbfs(), DB_WITH_SIGN)));
 313         ui->limiter_threshold_db_display->setText(limiter_threshold_label);
 314         ui->limiter_threshold_db_display_2->setText(limiter_threshold_label);
 315
 316         connect(ui->locut_cutoff_knob, &QDial::valueChanged, this, &MainWindow::cutoff_knob_changed);
 317         cutoff_knob_changed(ui->locut_cutoff_knob->value());
 318
 319         connect(ui->makeup_gain_knob, &QAbstractSlider::valueChanged, this, &MainWindow::final_makeup_gain_knob_changed);
 320         connect(ui->makeup_gain_auto_checkbox, &QCheckBox::stateChanged, [this](int state){
 321                 global_audio_mixer->set_final_makeup_gain_auto(state == Qt::Checked);
 322                 midi_mapper.refresh_lights();
 323         });
 324
 325         connect(ui->limiter_threshold_knob, &QDial::valueChanged, this, &MainWindow::limiter_threshold_knob_changed);
 326         connect(ui->limiter_enabled, &QCheckBox::stateChanged, [this](int state){
 327                 global_audio_mixer->set_limiter_enabled(state == Qt::Checked);
 328                 midi_mapper.refresh_lights();
 329         });
 330         connect(ui->reset_meters_button, &QPushButton::clicked, this, &MainWindow::reset_meters_button_clicked);
 331         mixer->get_audio_mixer()->set_audio_level_callback(bind(&MainWindow::audio_level_callback, this, _1, _2, _3, _4, _5, _6, _7, _8));
 332
 333         midi_mapper.refresh_highlights();
 334         midi_mapper.refresh_lights();
 335
 336         struct sigaction act;
 337         memset(&act, 0, sizeof(act));
 338         act.sa_handler = schedule_cut_signal;
 339         act.sa_flags = SA_RESTART;
 340         sigaction(SIGHUP, &act, nullptr);
 341
 342         // Mostly for debugging. Don't override SIGINT, that's so evil if
 343         // shutdown isn't instant.
 344         memset(&act, 0, sizeof(act));
 345         act.sa_handler = quit_signal;
 346         act.sa_flags = SA_RESTART;
 347         sigaction(SIGUSR1, &act, nullptr);
 348 }
 349
 350 void MainWindow::reset_audio_mapping_ui()
 351 {
 352         bool simple = (global_audio_mixer->get_mapping_mode() == AudioMixer::MappingMode::SIMPLE);
 353
 354         ui->simple_audio_mode->setChecked(simple);
 355         ui->multichannel_audio_mode->setChecked(!simple);
 356         ui->input_mapping_action->setEnabled(!simple);
 357         ui->midi_mapping_action->setEnabled(!simple);
 358
 359         ui->locut_enabled->setVisible(simple);
 360         ui->gainstaging_label->setVisible(simple);
 361         ui->gainstaging_knob->setVisible(simple);
 362         ui->gainstaging_db_display->setVisible(simple);
 363         ui->gainstaging_auto_checkbox->setVisible(simple);
 364         ui->compressor_threshold_label->setVisible(simple);
 365         ui->compressor_threshold_knob->setVisible(simple);
 366         ui->compressor_threshold_db_display->setVisible(simple);
 367         ui->compressor_enabled->setVisible(simple);
 368
 369         setup_audio_miniview();
 370         setup_audio_expanded_view();
 371
 372         if (simple) {
 373                 ui->audio_views->setCurrentIndex(0);
 374         }
 375         ui->compact_header->setVisible(!simple);
 376
 377         midi_mapper.refresh_highlights();
 378         midi_mapper.refresh_lights();
 379 }
 380
 381 void MainWindow::setup_audio_miniview()
 382 {
 383         // Remove any existing channels.
 384         for (QLayoutItem *item; (item = ui->faders->takeAt(0)) != nullptr; ) {
 385                 delete item->widget();
 386                 delete item;
 387         }
 388         audio_miniviews.clear();
 389
 390         if (global_audio_mixer->get_mapping_mode() == AudioMixer::MappingMode::SIMPLE) {
 391                 return;
 392         }
 393
 394         // Set up brand new ones from the input mapping.
 395         InputMapping mapping = global_audio_mixer->get_input_mapping();
 396         audio_miniviews.resize(mapping.buses.size());
 397         for (unsigned bus_index = 0; bus_index < mapping.buses.size(); ++bus_index) {
 398                 QWidget *channel = new QWidget(this);
 399                 Ui::AudioMiniView *ui_audio_miniview = new Ui::AudioMiniView;
 400                 ui_audio_miniview->setupUi(channel);
 401                 ui_audio_miniview->bus_desc_label->setFullText(
 402                         QString::fromStdString(mapping.buses[bus_index].name));
 403                 audio_miniviews[bus_index] = ui_audio_miniview;
 404
 405                 // Set up the peak meter.
 406                 VUMeter *peak_meter = ui_audio_miniview->peak_meter;
 407                 peak_meter->set_min_level(-30.0f);
 408                 peak_meter->set_max_level(0.0f);
 409                 peak_meter->set_ref_level(0.0f);
 410
 411                 ui_audio_miniview->fader->setDbValue(global_audio_mixer->get_fader_volume(bus_index));
 412
 413                 ui->faders->addWidget(channel);
 414
 415                 connect(ui_audio_miniview->fader, &NonLinearFader::dbValueChanged,
 416                         bind(&MainWindow::mini_fader_changed, this, bus_index, _1));
 417                 connect(ui_audio_miniview->peak_display_label, &ClickableLabel::clicked,
 418                         [bus_index]() {
 419                                 global_audio_mixer->reset_peak(bus_index);
 420                         });
 421         }
 422 }
 423
 424 void MainWindow::setup_audio_expanded_view()
 425 {
 426         // Remove any existing channels.
 427         for (QLayoutItem *item; (item = ui->buses->takeAt(0)) != nullptr; ) {
 428                 delete item->widget();
 429                 delete item;
 430         }
 431         audio_expanded_views.clear();
 432
 433         if (global_audio_mixer->get_mapping_mode() == AudioMixer::MappingMode::SIMPLE) {
 434                 return;
 435         }
 436
 437         // Set up brand new ones from the input mapping.
 438         InputMapping mapping = global_audio_mixer->get_input_mapping();
 439         audio_expanded_views.resize(mapping.buses.size());
 440         for (unsigned bus_index = 0; bus_index < mapping.buses.size(); ++bus_index) {
 441                 QWidget *channel = new QWidget(this);
 442                 Ui::AudioExpandedView *ui_audio_expanded_view = new Ui::AudioExpandedView;
 443                 ui_audio_expanded_view->setupUi(channel);
 444                 ui_audio_expanded_view->bus_desc_label->setFullText(
 445                         QString::fromStdString(mapping.buses[bus_index].name));
 446                 audio_expanded_views[bus_index] = ui_audio_expanded_view;
 447                 update_eq_label(bus_index, EQ_BAND_TREBLE, global_audio_mixer->get_eq(bus_index, EQ_BAND_TREBLE));
 448                 update_eq_label(bus_index, EQ_BAND_MID, global_audio_mixer->get_eq(bus_index, EQ_BAND_MID));
 449                 update_eq_label(bus_index, EQ_BAND_BASS, global_audio_mixer->get_eq(bus_index, EQ_BAND_BASS));
 450                 ui_audio_expanded_view->fader->setDbValue(global_audio_mixer->get_fader_volume(bus_index));
 451                 ui->buses->addWidget(channel);
 452
 453                 ui_audio_expanded_view->locut_enabled->setChecked(global_audio_mixer->get_locut_enabled(bus_index));
 454                 connect(ui_audio_expanded_view->locut_enabled, &QCheckBox::stateChanged, [this, bus_index](int state){
 455                         global_audio_mixer->set_locut_enabled(bus_index, state == Qt::Checked);
 456                         midi_mapper.refresh_lights();
 457                 });
 458
 459                 connect(ui_audio_expanded_view->treble_knob, &QDial::valueChanged,
 460                         bind(&MainWindow::eq_knob_changed, this, bus_index, EQ_BAND_TREBLE, _1));
 461                 connect(ui_audio_expanded_view->mid_knob, &QDial::valueChanged,
 462                         bind(&MainWindow::eq_knob_changed, this, bus_index, EQ_BAND_MID, _1));
 463                 connect(ui_audio_expanded_view->bass_knob, &QDial::valueChanged,
 464                         bind(&MainWindow::eq_knob_changed, this, bus_index, EQ_BAND_BASS, _1));
 465
 466                 ui_audio_expanded_view->gainstaging_knob->setValue(global_audio_mixer->get_gain_staging_db(bus_index));
 467                 ui_audio_expanded_view->gainstaging_auto_checkbox->setChecked(global_audio_mixer->get_gain_staging_auto(bus_index));
 468                 ui_audio_expanded_view->compressor_enabled->setChecked(global_audio_mixer->get_compressor_enabled(bus_index));
 469
 470                 connect(ui_audio_expanded_view->gainstaging_knob, &QAbstractSlider::valueChanged, bind(&MainWindow::gain_staging_knob_changed, this, bus_index, _1));
 471                 connect(ui_audio_expanded_view->gainstaging_auto_checkbox, &QCheckBox::stateChanged, [this, bus_index](int state){
 472                         global_audio_mixer->set_gain_staging_auto(bus_index, state == Qt::Checked);
 473                         midi_mapper.refresh_lights();
 474                 });
 475
 476                 connect(ui_audio_expanded_view->compressor_threshold_knob, &QDial::valueChanged, bind(&MainWindow::compressor_threshold_knob_changed, this, bus_index, _1));
 477                 connect(ui_audio_expanded_view->compressor_enabled, &QCheckBox::stateChanged, [this, bus_index](int state){
 478                         global_audio_mixer->set_compressor_enabled(bus_index, state == Qt::Checked);
 479                         midi_mapper.refresh_lights();
 480                 });
 481
 482                 slave_fader(audio_miniviews[bus_index]->fader, ui_audio_expanded_view->fader);
 483
 484                 // Set up the peak meter.
 485                 VUMeter *peak_meter = ui_audio_expanded_view->peak_meter;
 486                 peak_meter->set_min_level(-30.0f);
 487                 peak_meter->set_max_level(0.0f);
 488                 peak_meter->set_ref_level(0.0f);
 489
 490                 connect(ui_audio_expanded_view->peak_display_label, &ClickableLabel::clicked,
 491                         [this, bus_index]() {
 492                                 global_audio_mixer->reset_peak(bus_index);
 493                                 midi_mapper.refresh_lights();
 494                         });
 495
 496                 // Set up the compression attenuation meter.
 497                 VUMeter *reduction_meter = ui_audio_expanded_view->reduction_meter;
 498                 reduction_meter->set_min_level(0.0f);
 499                 reduction_meter->set_max_level(10.0f);
 500                 reduction_meter->set_ref_level(0.0f);
 501                 reduction_meter->set_flip(true);
 502         }
 503
 504         update_cutoff_labels(global_audio_mixer->get_locut_cutoff());
 505 }
 506
 507 void MainWindow::mixer_shutting_down()
 508 {
 509         ui->me_live->clean_context();
 510         ui->me_preview->clean_context();
 511         for (Ui::Display *display : previews) {
 512                 display->display->clean_context();
 513         }
 514 }
 515
 516 void MainWindow::cut_triggered()
 517 {
 518         global_mixer->schedule_cut();
 519 }
 520
 521 void MainWindow::x264_bitrate_triggered()
 522 {
 523         bool ok;
 524         int new_bitrate = QInputDialog::getInt(this, "Change x264 bitrate", "Choose new bitrate for x264 HTTP output (from 100–100,000 kbit/sec):", global_flags.x264_bitrate, /*min=*/100, /*max=*/100000, /*step=*/100, &ok);
 525         if (ok && new_bitrate >= 100 && new_bitrate <= 100000) {
 526                 global_flags.x264_bitrate = new_bitrate;
 527                 global_mixer->change_x264_bitrate(new_bitrate);
 528         }
 529 }
 530
 531 void MainWindow::exit_triggered()
 532 {
 533         close();
 534 }
 535
 536 void MainWindow::about_triggered()
 537 {
 538         AboutDialog().exec();
 539 }
 540
 541 void MainWindow::simple_audio_mode_triggered()
 542 {
 543         if (global_audio_mixer->get_mapping_mode() == AudioMixer::MappingMode::SIMPLE) {
 544                 return;
 545         }
 546         unsigned card_index = global_audio_mixer->get_simple_input();
 547         if (card_index == numeric_limits<unsigned>::max()) {
 548                 QMessageBox::StandardButton reply =
 549                         QMessageBox::question(this,
 550                                 "Mapping too complex",
 551                                 "The current audio mapping is too complicated to be representable in simple mode, "
 552                                         "and will be discarded if you proceed. Really go to simple audio mode?",
 553                                 QMessageBox::Yes | QMessageBox::No);
 554                 if (reply == QMessageBox::No) {
 555                         ui->simple_audio_mode->setChecked(false);
 556                         ui->multichannel_audio_mode->setChecked(true);
 557                         return;
 558                 }
 559                 card_index = 0;
 560         }
 561         global_audio_mixer->set_simple_input(/*card_index=*/card_index);
 562         reset_audio_mapping_ui();
 563 }
 564
 565 void MainWindow::multichannel_audio_mode_triggered()
 566 {
 567         if (global_audio_mixer->get_mapping_mode() == AudioMixer::MappingMode::MULTICHANNEL) {
 568                 return;
 569         }
 570
 571         // Take the generated input mapping from the simple input,
 572         // and set it as a normal multichannel mapping, which causes
 573         // the mode to go to multichannel.
 574         global_audio_mixer->set_input_mapping(global_audio_mixer->get_input_mapping());
 575         reset_audio_mapping_ui();
 576 }
 577
 578 void MainWindow::input_mapping_triggered()
 579 {
 580         if (InputMappingDialog().exec() == QDialog::Accepted) {
 581                 setup_audio_miniview();
 582                 setup_audio_expanded_view();
 583         }
 584         midi_mapper.refresh_highlights();
 585         midi_mapper.refresh_lights();
 586 }
 587
 588 void MainWindow::midi_mapping_triggered()
 589 {
 590         MIDIMappingDialog(&midi_mapper).exec();
 591 }
 592
 593 void MainWindow::gain_staging_knob_changed(unsigned bus_index, int value)
 594 {
 595         if (bus_index == 0) {
 596                 ui->gainstaging_auto_checkbox->setCheckState(Qt::Unchecked);
 597         }
 598         if (bus_index < audio_expanded_views.size()) {
 599                 audio_expanded_views[bus_index]->gainstaging_auto_checkbox->setCheckState(Qt::Unchecked);
 600         }
 601
 602         float gain_db = value * 0.1f;
 603         global_audio_mixer->set_gain_staging_db(bus_index, gain_db);
 604
 605         // The label will be updated by the audio level callback.
 606 }
 607
 608 void MainWindow::final_makeup_gain_knob_changed(int value)
 609 {
 610         ui->makeup_gain_auto_checkbox->setCheckState(Qt::Unchecked);
 611
 612         float gain_db = value * 0.1f;
 613         global_audio_mixer->set_final_makeup_gain_db(gain_db);
 614
 615         // The label will be updated by the audio level callback.
 616 }
 617
 618 void MainWindow::cutoff_knob_changed(int value)
 619 {
 620         float octaves = value * 0.1f;
 621         float cutoff_hz = 20.0 * pow(2.0, octaves);
 622         global_audio_mixer->set_locut_cutoff(cutoff_hz);
 623         update_cutoff_labels(cutoff_hz);
 624 }
 625
 626 void MainWindow::update_cutoff_labels(float cutoff_hz)
 627 {
 628         char buf[256];
 629         snprintf(buf, sizeof(buf), "%ld Hz", lrintf(cutoff_hz));
 630         ui->locut_cutoff_display->setText(buf);
 631         ui->locut_cutoff_display_2->setText(buf);
 632
 633         for (unsigned bus_index = 0; bus_index < audio_expanded_views.size(); ++bus_index) {
 634                 audio_expanded_views[bus_index]->locut_enabled->setText(
 635                         QString("Lo-cut: ") + buf);
 636         }
 637 }
 638
 639 void MainWindow::report_disk_space(off_t free_bytes, double estimated_seconds_left)
 640 {
 641         char time_str[256];
 642         if (estimated_seconds_left < 60.0) {
 643                 strcpy(time_str, "<font color=\"red\">Less than a minute</font>");
 644         } else if (estimated_seconds_left < 1800.0) {  // Less than half an hour: Xm Ys (red).
 645                 int s = lrintf(estimated_seconds_left);
 646                 int m = s / 60;
 647                 s %= 60;
 648                 snprintf(time_str, sizeof(time_str), "<font color=\"red\">%dm %ds</font>", m, s);
 649         } else if (estimated_seconds_left < 3600.0) {  // Less than an hour: Xm.
 650                 int m = lrintf(estimated_seconds_left / 60.0);
 651                 snprintf(time_str, sizeof(time_str), "%dm", m);
 652         } else if (estimated_seconds_left < 36000.0) {  // Less than ten hours: Xh Ym.
 653                 int m = lrintf(estimated_seconds_left / 60.0);
 654                 int h = m / 60;
 655                 m %= 60;
 656                 snprintf(time_str, sizeof(time_str), "%dh %dm", h, m);
 657         } else {  // More than ten hours: Xh.
 658                 int h = lrintf(estimated_seconds_left / 3600.0);
 659                 snprintf(time_str, sizeof(time_str), "%dh", h);
 660         }
 661         char buf[256];
 662         snprintf(buf, sizeof(buf), "Disk free: %'.0f MB (approx. %s)", free_bytes / 1048576.0, time_str);
 663
 664         std::string label = buf;
 665
 666         post_to_main_thread([this, label]{
 667                 disk_free_label->setText(QString::fromStdString(label));
 668                 ui->menuBar->setCornerWidget(disk_free_label);  // Need to set this again for the sizing to get right.
 669         });
 670 }
 671
 672 void MainWindow::eq_knob_changed(unsigned bus_index, EQBand band, int value)
 673 {
 674         float gain_db = value * 0.1f;
 675         global_audio_mixer->set_eq(bus_index, band, gain_db);
 676
 677         update_eq_label(bus_index, band, gain_db);
 678 }
 679
 680 void MainWindow::update_eq_label(unsigned bus_index, EQBand band, float gain_db)
 681 {
 682         Ui::AudioExpandedView *view = audio_expanded_views[bus_index];
 683         string db_string = format_db(gain_db, DB_WITH_SIGN);
 684         switch (band) {
 685         case EQ_BAND_TREBLE:
 686                 view->treble_label->setText(QString::fromStdString("Treble: " + db_string));
 687                 break;
 688         case EQ_BAND_MID:
 689                 view->mid_label->setText(QString::fromStdString("Mid: " + db_string));
 690                 break;
 691         case EQ_BAND_BASS:
 692                 view->bass_label->setText(QString::fromStdString("Bass: " + db_string));
 693                 break;
 694         default:
 695                 assert(false);
 696         }
 697 }
 698
 699 void MainWindow::limiter_threshold_knob_changed(int value)
 700 {
 701         float threshold_dbfs = value * 0.1f;
 702         global_audio_mixer->set_limiter_threshold_dbfs(threshold_dbfs);
 703         ui->limiter_threshold_db_display->setText(
 704                 QString::fromStdString(format_db(threshold_dbfs, DB_WITH_SIGN)));
 705         ui->limiter_threshold_db_display_2->setText(
 706                 QString::fromStdString(format_db(threshold_dbfs, DB_WITH_SIGN)));
 707 }
 708
 709 void MainWindow::compressor_threshold_knob_changed(unsigned bus_index, int value)
 710 {
 711         float threshold_dbfs = value * 0.1f;
 712         global_audio_mixer->set_compressor_threshold_dbfs(bus_index, threshold_dbfs);
 713
 714         QString label(QString::fromStdString(format_db(threshold_dbfs, DB_WITH_SIGN)));
 715         if (bus_index == 0) {
 716                 ui->compressor_threshold_db_display->setText(label);
 717         }
 718         if (bus_index < audio_expanded_views.size()) {
 719                 audio_expanded_views[bus_index]->compressor_threshold_db_display->setText(label);
 720         }
 721 }
 722
 723 void MainWindow::mini_fader_changed(int bus, double volume_db)
 724 {
 725         QString label(QString::fromStdString(format_db(volume_db, DB_WITH_SIGN)));
 726         audio_miniviews[bus]->fader_label->setText(label);
 727         audio_expanded_views[bus]->fader_label->setText(label);
 728
 729         global_audio_mixer->set_fader_volume(bus, volume_db);
 730 }
 731
 732 void MainWindow::reset_meters_button_clicked()
 733 {
 734         global_audio_mixer->reset_meters();
 735         ui->peak_display->setText(QString::fromStdString(format_db(-HUGE_VAL, DB_WITH_SIGN | DB_BARE)));
 736         ui->peak_display->setStyleSheet("");
 737 }
 738
 739 void MainWindow::audio_level_callback(float level_lufs, float peak_db, vector<AudioMixer::BusLevel> bus_levels,
 740                                       float global_level_lufs,
 741                                       float range_low_lufs, float range_high_lufs,
 742                                       float final_makeup_gain_db,
 743                                       float correlation)
 744 {
 745         steady_clock::time_point now = steady_clock::now();
 746
 747         // The meters are somewhat inefficient to update. Only update them
 748         // every 100 ms or so (we get updates every 5–20 ms). Note that this
 749         // means that the digital peak meters are ever so slightly too low
 750         // (each update won't be a faithful representation of the highest peak
 751         // since the previous update, since there are frames we won't draw),
 752         // but the _peak_ of the peak meters will be correct (it's tracked in
 753         // AudioMixer, not here), and that's much more important.
 754         double last_update_age = duration<double>(now - last_audio_level_callback).count();
 755         if (last_update_age < 0.100) {
 756                 return;
 757         }
 758         last_audio_level_callback = now;
 759
 760         post_to_main_thread([=]() {
 761                 ui->vu_meter->set_level(level_lufs);
 762                 for (unsigned bus_index = 0; bus_index < bus_levels.size(); ++bus_index) {
 763                         if (bus_index < audio_miniviews.size()) {
 764                                 const AudioMixer::BusLevel &level = bus_levels[bus_index];
 765                                 Ui::AudioMiniView *miniview = audio_miniviews[bus_index];
 766                                 miniview->peak_meter->set_level(
 767                                         level.current_level_dbfs[0], level.current_level_dbfs[1]);
 768                                 miniview->peak_meter->set_peak(
 769                                         level.peak_level_dbfs[0], level.peak_level_dbfs[1]);
 770                                 set_peak_label(miniview->peak_display_label, level.historic_peak_dbfs);
 771
 772                                 Ui::AudioExpandedView *view = audio_expanded_views[bus_index];
 773                                 view->peak_meter->set_level(
 774                                         level.current_level_dbfs[0], level.current_level_dbfs[1]);
 775                                 view->peak_meter->set_peak(
 776                                         level.peak_level_dbfs[0], level.peak_level_dbfs[1]);
 777                                 view->reduction_meter->set_level(level.compressor_attenuation_db);
 778                                 view->gainstaging_knob->blockSignals(true);
 779                                 view->gainstaging_knob->setValue(lrintf(level.gain_staging_db * 10.0f));
 780                                 view->gainstaging_knob->blockSignals(false);
 781                                 view->gainstaging_db_display->setText(
 782                                         QString("Gain: ") +
 783                                         QString::fromStdString(format_db(level.gain_staging_db, DB_WITH_SIGN)));
 784                                 set_peak_label(view->peak_display_label, level.historic_peak_dbfs);
 785
 786                                 midi_mapper.set_has_peaked(bus_index, level.historic_peak_dbfs >= -0.1f);
 787                         }
 788                 }
 789                 ui->lra_meter->set_levels(global_level_lufs, range_low_lufs, range_high_lufs);
 790                 ui->correlation_meter->set_correlation(correlation);
 791
 792                 ui->peak_display->setText(QString::fromStdString(format_db(peak_db, DB_BARE)));
 793                 set_peak_label(ui->peak_display, peak_db);
 794
 795                 // NOTE: Will be invisible when using multitrack audio.
 796                 ui->gainstaging_knob->blockSignals(true);
 797                 ui->gainstaging_knob->setValue(lrintf(bus_levels[0].gain_staging_db * 10.0f));
 798                 ui->gainstaging_knob->blockSignals(false);
 799                 ui->gainstaging_db_display->setText(
 800                         QString::fromStdString(format_db(bus_levels[0].gain_staging_db, DB_WITH_SIGN)));
 801
 802                 ui->makeup_gain_knob->blockSignals(true);
 803                 ui->makeup_gain_knob->setValue(lrintf(final_makeup_gain_db * 10.0f));
 804                 ui->makeup_gain_knob->blockSignals(false);
 805                 ui->makeup_gain_db_display->setText(
 806                         QString::fromStdString(format_db(final_makeup_gain_db, DB_WITH_SIGN)));
 807                 ui->makeup_gain_db_display_2->setText(
 808                         QString::fromStdString(format_db(final_makeup_gain_db, DB_WITH_SIGN)));
 809
 810                 // Peak labels could have changed.
 811                 midi_mapper.refresh_lights();
 812         });
 813 }
 814
 815 void MainWindow::relayout()
 816 {
 817         int height = ui->vertical_layout->geometry().height();
 818
 819         double remaining_height = height;
 820
 821         // Allocate the height; the most important part is to keep the main displays
 822         // at 16:9 if at all possible.
 823         double me_width = ui->me_preview->width();
 824         double me_height = me_width * 9.0 / 16.0 + ui->label_preview->height() + ui->preview_vertical_layout->spacing();
 825
 826         // TODO: Scale the widths when we need to do this.
 827         if (me_height / double(height) > 0.8) {
 828                 me_height = height * 0.8;
 829         }
 830         remaining_height -= me_height + ui->vertical_layout->spacing();
 831
 832         // Space between the M/E displays and the audio strip.
 833         remaining_height -= ui->vertical_layout->spacing();
 834
 835         // The label above the audio strip.
 836         double compact_label_height = ui->compact_label->minimumHeight() +
 837                 ui->compact_audio_layout->spacing();
 838         remaining_height -= compact_label_height;
 839
 840         // The previews will be constrained by the remaining height, and the width.
 841         double preview_label_height = previews[0]->title_bar->geometry().height() +
 842                 previews[0]->main_vertical_layout->spacing();
 843         int preview_total_width = ui->preview_displays->geometry().width() - (previews.size() - 1) * ui->preview_displays->spacing();
 844         double preview_height = min(remaining_height - preview_label_height, (preview_total_width / double(previews.size())) * 9.0 / 16.0);
 845         remaining_height -= preview_height + preview_label_height + ui->vertical_layout->spacing();
 846
 847         ui->vertical_layout->setStretch(0, lrintf(me_height));
 848         ui->vertical_layout->setStretch(1,
 849                 lrintf(compact_label_height) +
 850                 lrintf(remaining_height) +
 851                 lrintf(preview_height + preview_label_height));  // Audio strip and previews together.
 852
 853         ui->compact_audio_layout->setStretch(0, lrintf(compact_label_height));
 854         ui->compact_audio_layout->setStretch(1, lrintf(remaining_height));  // Audio strip.
 855         ui->compact_audio_layout->setStretch(2, lrintf(preview_height + preview_label_height));
 856
 857         // Set the widths for the previews.
 858         double preview_width = preview_height * 16.0 / 9.0;
 859         for (unsigned i = 0; i < previews.size(); ++i) {
 860                 ui->preview_displays->setStretch(i, lrintf(preview_width));
 861         }
 862
 863         // The preview horizontal spacer.
 864         double remaining_preview_width = preview_total_width - previews.size() * preview_width;
 865         ui->preview_displays->setStretch(previews.size(), lrintf(remaining_preview_width));
 866 }
 867
 868 void MainWindow::set_locut(float value)
 869 {
 870         set_relative_value(ui->locut_cutoff_knob, value);
 871 }
 872
 873 void MainWindow::set_limiter_threshold(float value)
 874 {
 875         set_relative_value(ui->limiter_threshold_knob, value);
 876 }
 877
 878 void MainWindow::set_makeup_gain(float value)
 879 {
 880         set_relative_value(ui->makeup_gain_knob, value);
 881 }
 882
 883 void MainWindow::set_treble(unsigned bus_idx, float value)
 884 {
 885         set_relative_value_if_exists(bus_idx, &Ui::AudioExpandedView::treble_knob, value);
 886 }
 887
 888 void MainWindow::set_mid(unsigned bus_idx, float value)
 889 {
 890         set_relative_value_if_exists(bus_idx, &Ui::AudioExpandedView::mid_knob, value);
 891 }
 892
 893 void MainWindow::set_bass(unsigned bus_idx, float value)
 894 {
 895         set_relative_value_if_exists(bus_idx, &Ui::AudioExpandedView::bass_knob, value);
 896 }
 897
 898 void MainWindow::set_gain(unsigned bus_idx, float value)
 899 {
 900         set_relative_value_if_exists(bus_idx, &Ui::AudioExpandedView::gainstaging_knob, value);
 901 }
 902
 903 void MainWindow::set_compressor_threshold(unsigned bus_idx, float value)
 904 {
 905         set_relative_value_if_exists(bus_idx, &Ui::AudioExpandedView::compressor_threshold_knob, value);
 906 }
 907
 908 void MainWindow::set_fader(unsigned bus_idx, float value)
 909 {
 910         set_relative_value_if_exists(bus_idx, &Ui::AudioExpandedView::fader, value);
 911 }
 912
 913 void MainWindow::toggle_locut(unsigned bus_idx)
 914 {
 915         click_button_if_exists(bus_idx, &Ui::AudioExpandedView::locut_enabled);
 916 }
 917
 918 void MainWindow::toggle_auto_gain_staging(unsigned bus_idx)
 919 {
 920         click_button_if_exists(bus_idx, &Ui::AudioExpandedView::gainstaging_auto_checkbox);
 921 }
 922
 923 void MainWindow::toggle_compressor(unsigned bus_idx)
 924 {
 925         click_button_if_exists(bus_idx, &Ui::AudioExpandedView::compressor_enabled);
 926 }
 927
 928 void MainWindow::clear_peak(unsigned bus_idx)
 929 {
 930         post_to_main_thread([=]{
 931                 if (global_audio_mixer->get_mapping_mode() == AudioMixer::MappingMode::MULTICHANNEL) {
 932                         global_audio_mixer->reset_peak(bus_idx);
 933                         midi_mapper.set_has_peaked(bus_idx, false);
 934                         midi_mapper.refresh_lights();
 935                 }
 936         });
 937 }
 938
 939 void MainWindow::clear_all_highlights()
 940 {
 941         post_to_main_thread([this]{
 942                 highlight_locut(false);
 943                 highlight_limiter_threshold(false);
 944                 highlight_makeup_gain(false);
 945                 highlight_toggle_limiter(false);
 946                 highlight_toggle_auto_makeup_gain(false);
 947                 for (unsigned bus_idx = 0; bus_idx < audio_expanded_views.size(); ++bus_idx) {
 948                         highlight_treble(bus_idx, false);
 949                         highlight_mid(bus_idx, false);
 950                         highlight_bass(bus_idx, false);
 951                         highlight_gain(bus_idx, false);
 952                         highlight_compressor_threshold(bus_idx, false);
 953                         highlight_fader(bus_idx, false);
 954                         highlight_toggle_locut(bus_idx, false);
 955                         highlight_toggle_auto_gain_staging(bus_idx, false);
 956                         highlight_toggle_compressor(bus_idx, false);
 957                 }
 958         });
 959 }
 960
 961 void MainWindow::toggle_limiter()
 962 {
 963         if (global_audio_mixer->get_mapping_mode() == AudioMixer::MappingMode::MULTICHANNEL) {
 964                 ui->limiter_enabled->click();
 965         }
 966 }
 967
 968 void MainWindow::toggle_auto_makeup_gain()
 969 {
 970         if (global_audio_mixer->get_mapping_mode() == AudioMixer::MappingMode::MULTICHANNEL) {
 971                 ui->makeup_gain_auto_checkbox->click();
 972         }
 973 }
 974
 975 void MainWindow::highlight_locut(bool highlight)
 976 {
 977         post_to_main_thread([this, highlight]{
 978                 highlight_control(ui->locut_cutoff_knob, highlight);
 979                 highlight_control(ui->locut_cutoff_knob_2, highlight);
 980         });
 981 }
 982
 983 void MainWindow::highlight_limiter_threshold(bool highlight)
 984 {
 985         post_to_main_thread([this, highlight]{
 986                 highlight_control(ui->limiter_threshold_knob, highlight);
 987                 highlight_control(ui->limiter_threshold_knob_2, highlight);
 988         });
 989 }
 990
 991 void MainWindow::highlight_makeup_gain(bool highlight)
 992 {
 993         post_to_main_thread([this, highlight]{
 994                 highlight_control(ui->makeup_gain_knob, highlight);
 995                 highlight_control(ui->makeup_gain_knob_2, highlight);
 996         });
 997 }
 998
 999 void MainWindow::highlight_treble(unsigned bus_idx, bool highlight)
1000 {
1001         highlight_control_if_exists(bus_idx, &Ui::AudioExpandedView::treble_knob, highlight);
1002 }
1003
1004 void MainWindow::highlight_mid(unsigned bus_idx, bool highlight)
1005 {
1006         highlight_control_if_exists(bus_idx, &Ui::AudioExpandedView::mid_knob, highlight);
1007 }
1008
1009 void MainWindow::highlight_bass(unsigned bus_idx, bool highlight)
1010 {
1011         highlight_control_if_exists(bus_idx, &Ui::AudioExpandedView::bass_knob, highlight);
1012 }
1013
1014 void MainWindow::highlight_gain(unsigned bus_idx, bool highlight)
1015 {
1016         highlight_control_if_exists(bus_idx, &Ui::AudioExpandedView::gainstaging_knob, highlight);
1017 }
1018
1019 void MainWindow::highlight_compressor_threshold(unsigned bus_idx, bool highlight)
1020 {
1021         highlight_control_if_exists(bus_idx, &Ui::AudioExpandedView::compressor_threshold_knob, highlight);
1022 }
1023
1024 void MainWindow::highlight_fader(unsigned bus_idx, bool highlight)
1025 {
1026         highlight_control_if_exists(bus_idx, &Ui::AudioExpandedView::fader, highlight);
1027 }
1028
1029 void MainWindow::highlight_toggle_locut(unsigned bus_idx, bool highlight)
1030 {
1031         highlight_control_if_exists(bus_idx, &Ui::AudioExpandedView::locut_enabled, highlight);
1032 }
1033
1034 void MainWindow::highlight_toggle_auto_gain_staging(unsigned bus_idx, bool highlight)
1035 {
1036         highlight_control_if_exists(bus_idx, &Ui::AudioExpandedView::gainstaging_auto_checkbox, highlight);
1037 }
1038
1039 void MainWindow::highlight_toggle_compressor(unsigned bus_idx, bool highlight)
1040 {
1041         highlight_control_if_exists(bus_idx, &Ui::AudioExpandedView::compressor_enabled, highlight);
1042 }
1043
1044 void MainWindow::highlight_toggle_limiter(bool highlight)
1045 {
1046         post_to_main_thread([this, highlight]{
1047                 highlight_control(ui->limiter_enabled, highlight);
1048                 highlight_control(ui->limiter_enabled_2, highlight);
1049         });
1050 }
1051
1052 void MainWindow::highlight_toggle_auto_makeup_gain(bool highlight)
1053 {
1054         post_to_main_thread([this, highlight]{
1055                 highlight_control(ui->makeup_gain_auto_checkbox, highlight);
1056                 highlight_control(ui->makeup_gain_auto_checkbox_2, highlight);
1057         });
1058 }
1059
1060 template<class T>
1061 void MainWindow::set_relative_value(T *control, float value)
1062 {
1063         post_to_main_thread([control, value]{
1064                 control->setValue(lrintf(control->minimum() + value * (control->maximum() - control->minimum())));
1065         });
1066 }
1067
1068 template<class T>
1069 void MainWindow::set_relative_value_if_exists(unsigned bus_idx, T *(Ui_AudioExpandedView::*control), float value)
1070 {
1071         if (global_audio_mixer != nullptr &&
1072             global_audio_mixer->get_mapping_mode() == AudioMixer::MappingMode::MULTICHANNEL &&
1073             bus_idx < audio_expanded_views.size()) {
1074                 set_relative_value(audio_expanded_views[bus_idx]->*control, value);
1075         }
1076 }
1077
1078 template<class T>
1079 void MainWindow::click_button_if_exists(unsigned bus_idx, T *(Ui_AudioExpandedView::*control))
1080 {
1081         post_to_main_thread([this, bus_idx, control]{
1082                 if (global_audio_mixer != nullptr &&
1083                     global_audio_mixer->get_mapping_mode() == AudioMixer::MappingMode::MULTICHANNEL &&
1084                     bus_idx < audio_expanded_views.size()) {
1085                         (audio_expanded_views[bus_idx]->*control)->click();
1086                 }
1087         });
1088 }
1089
1090 template<class T>
1091 void MainWindow::highlight_control(T *control, bool highlight)
1092 {
1093         if (control == nullptr) {
1094                 return;
1095         }
1096         if (global_audio_mixer == nullptr ||
1097             global_audio_mixer->get_mapping_mode() != AudioMixer::MappingMode::MULTICHANNEL) {
1098                 highlight = false;
1099         }
1100         if (highlight) {
1101                 control->setStyleSheet("background: rgb(0,255,0,80)");
1102         } else {
1103                 control->setStyleSheet("");
1104         }
1105 }
1106
1107 template<class T>
1108 void MainWindow::highlight_control_if_exists(unsigned bus_idx, T *(Ui_AudioExpandedView::*control), bool highlight)
1109 {
1110         post_to_main_thread([this, bus_idx, control, highlight]{
1111                 if (bus_idx < audio_expanded_views.size()) {
1112                         highlight_control(audio_expanded_views[bus_idx]->*control, highlight);
1113                 }
1114         });
1115 }
1116
1117 void MainWindow::set_transition_names(vector<string> transition_names)
1118 {
1119         if (transition_names.size() < 1 || transition_names[0].empty()) {
1120                 transition_btn1->setText(QString(""));
1121         } else {
1122                 transition_btn1->setText(QString::fromStdString(transition_names[0] + " (J)"));
1123                 ui->transition_btn1->setShortcut(QKeySequence("J"));
1124         }
1125         if (transition_names.size() < 2 || transition_names[1].empty()) {
1126                 transition_btn2->setText(QString(""));
1127         } else {
1128                 transition_btn2->setText(QString::fromStdString(transition_names[1] + " (K)"));
1129                 ui->transition_btn2->setShortcut(QKeySequence("K"));
1130         }
1131         if (transition_names.size() < 3 || transition_names[2].empty()) {
1132                 transition_btn3->setText(QString(""));
1133         } else {
1134                 transition_btn3->setText(QString::fromStdString(transition_names[2] + " (L)"));
1135                 ui->transition_btn3->setShortcut(QKeySequence("L"));
1136         }
1137 }
1138
1139 void MainWindow::update_channel_name(Mixer::Output output, const string &name)
1140 {
1141         if (output >= Mixer::OUTPUT_INPUT0) {
1142                 unsigned channel = output - Mixer::OUTPUT_INPUT0;
1143                 previews[channel]->label->setText(name.c_str());
1144         }
1145 }
1146
1147 void MainWindow::update_channel_color(Mixer::Output output, const string &color)
1148 {
1149         if (output >= Mixer::OUTPUT_INPUT0) {
1150                 unsigned channel = output - Mixer::OUTPUT_INPUT0;
1151                 previews[channel]->frame->setStyleSheet(QString::fromStdString("background-color:" + color));
1152         }
1153 }
1154
1155 void MainWindow::transition_clicked(int transition_number)
1156 {
1157         global_mixer->transition_clicked(transition_number);
1158 }
1159
1160 void MainWindow::channel_clicked(int channel_number)
1161 {
1162         if (current_wb_pick_display == channel_number) {
1163                 // The picking was already done from eventFilter(), since we don't get
1164                 // the mouse pointer here.
1165         } else {
1166                 global_mixer->channel_clicked(channel_number);
1167         }
1168 }
1169
1170 void MainWindow::wb_button_clicked(int channel_number)
1171 {
1172         current_wb_pick_display = channel_number;
1173         QApplication::setOverrideCursor(Qt::CrossCursor);
1174 }
1175
1176 bool MainWindow::eventFilter(QObject *watched, QEvent *event)
1177 {
1178         if (current_wb_pick_display != -1 &&
1179             event->type() == QEvent::MouseButtonRelease &&
1180             watched->isWidgetType()) {
1181                 QApplication::restoreOverrideCursor();
1182                 if (watched == previews[current_wb_pick_display]->display) {
1183                         const QMouseEvent *mouse_event = (QMouseEvent *)event;
1184                         set_white_balance(current_wb_pick_display, mouse_event->x(), mouse_event->y());
1185                 } else {
1186                         // The user clicked on something else, give up.
1187                         // (The click goes through, which might not be ideal, but, yes.)
1188                         current_wb_pick_display = -1;
1189                 }
1190         }
1191         return false;
1192 }
1193
1194 namespace {
1195
1196 double srgb_to_linear(double x)
1197 {
1198         if (x < 0.04045) {
1199                 return x / 12.92;
1200         } else {
1201                 return pow((x + 0.055) / 1.055, 2.4);
1202         }
1203 }
1204
1205 }  // namespace
1206
1207 void MainWindow::set_white_balance(int channel_number, int x, int y)
1208 {
1209         // Set the white balance to neutral for the grab. It's probably going to
1210         // flicker a bit, but hopefully this display is not live anyway.
1211         global_mixer->set_wb(Mixer::OUTPUT_INPUT0 + channel_number, 0.5, 0.5, 0.5);
1212         previews[channel_number]->display->updateGL();
1213         QRgb reference_color = previews[channel_number]->display->grabFrameBuffer().pixel(x, y);
1214
1215         double r = srgb_to_linear(qRed(reference_color) / 255.0);
1216         double g = srgb_to_linear(qGreen(reference_color) / 255.0);
1217         double b = srgb_to_linear(qBlue(reference_color) / 255.0);
1218         global_mixer->set_wb(Mixer::OUTPUT_INPUT0 + channel_number, r, g, b);
1219         previews[channel_number]->display->updateGL();
1220 }
1221
1222 void MainWindow::audio_state_changed()
1223 {
1224         post_to_main_thread([this]{
1225                 InputMapping mapping = global_audio_mixer->get_input_mapping();
1226                 for (unsigned bus_index = 0; bus_index < mapping.buses.size(); ++bus_index) {
1227                         const InputMapping::Bus &bus = mapping.buses[bus_index];
1228                         string suffix;
1229                         if (bus.device.type == InputSourceType::ALSA_INPUT) {
1230                                 ALSAPool::Device::State state = global_audio_mixer->get_alsa_card_state(bus.device.index);
1231                                 if (state == ALSAPool::Device::State::STARTING) {
1232                                         suffix = " (busy)";
1233                                 } else if (state == ALSAPool::Device::State::DEAD) {
1234                                         suffix = " (dead)";
1235                                 }
1236                         }
1237
1238                         audio_miniviews[bus_index]->bus_desc_label->setFullText(
1239                                 QString::fromStdString(bus.name + suffix));
1240                         audio_expanded_views[bus_index]->bus_desc_label->setFullText(
1241                                 QString::fromStdString(bus.name + suffix));
1242                 }
1243         });
1244 }