Add processing modes (#1729)

* Add processing modes

Remove the previous GPU Effects option and replace it with
multiple processing modes that enable higher bit depth and
linear color processing.

* Brightness is 10-bit now

* Clean up if statement.

Reduce property lookups

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Apply suggestions from code review

Co-authored-by: Dan Dennedy <dan@dennedy.org>

* Change GPU mode to linear

* Improve preview image format for GPU and/or DeckLink

* Use rgba64 with Linear10GpuCpu without HLG

Now in Export, when `color_trc` is arib-std-b67 (HLG) do not add
mlt_color_trc=linear.
Also, let user override `mlt_image_format` or `mlt_color_trc`.

* Fix HLG can be on/used with DeckLink turned off

* Fix serialized GPU processing mode

* Fix support for latest releases of MLT

* A little rewording of message dialogs

But this will change again when project conversion is added.

* Fix adding processing modes to QActionGroup

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Refactor Settings

* Fix processing mode after decline restart

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Dan Dennedy <dan@dennedy.org>

Author: 3 people

src/docks/encodedock.cpp

@@ -298,15 +298,12 @@ void EncodeDock::loadPresetFromProperties(Mlt::Properties &preset)
                 ui->fpsSpinner->setValue(preset.get_double("frame_rate_num")
                                          / preset.get_double("frame_rate_den"));
         } else if (name == "pix_fmt") {
-            // Handle 10 bit encoding with hardware encoder and GPU Effects
+            // Handle 10-bit encoding
             if (value.contains("p10le")) {
-                if (Settings.playerGPU()) {
-                    if (value == "yuva444p10le") {
-                        other.append("mlt_image_format=rgba");
-                    } else {
-                        other.append("mlt_image_format=yuv444p10");
-                    }
-                } else if (!other.contains("mlt_image_format=rgb")) {
+                // Let 8-bit processing modes utilize full range RGB
+                const auto pm = Settings.processingMode();
+                if ((pm == ShotcutSettings::Native8Cpu || pm == ShotcutSettings::Linear8Cpu)
+                    && !other.contains("mlt_image_format=rgb")) {
                     other.append("mlt_image_format=rgb");
                 }
                 // Hardware encoder
@@ -1146,9 +1143,29 @@ void EncodeDock::collectProperties(QDomElement &node, int realtime)
 {
     Mlt::Properties *p = collectProperties(realtime);
     if (p && p->is_valid()) {
-        for (int i = 0; i < p->count(); i++)
+        for (int i = 0; i < p->count(); i++) {
             if (p->get_name(i) && strcmp(p->get_name(i), ""))
                 node.setAttribute(p->get_name(i), p->get(i));
+        }
+
+        const auto processingMode = Settings.processingMode();
+        if (processingMode == ShotcutSettings::Native10Cpu
+            || processingMode == ShotcutSettings::Linear10Cpu
+            || processingMode == ShotcutSettings::Linear10GpuCpu) {
+            if (!p->property_exists("mlt_image_format")) {
+                if (::qstrcmp(p->get("color_trc"), "arib-std-b67"))
+                    node.setAttribute("mlt_image_format", "rgba64");
+                else
+                    node.setAttribute("mlt_image_format", "yuv444p10");
+            }
+        }
+        if (processingMode == ShotcutSettings::Linear8Cpu
+            || processingMode == ShotcutSettings::Linear10Cpu
+            || (processingMode == ShotcutSettings::Linear10GpuCpu
+                && ::qstrcmp(p->get("color_trc"), "arib-std-b67"))) {
+            if (!p->property_exists("mlt_color_trc"))
+                node.setAttribute("mlt_color_trc", "linear");
+        }
     }
     delete p;
 }

src/main.cpp

@@ -237,7 +237,7 @@ class Application : public QApplication
             ShotcutSettings::setAppDataForSession(appDirArg);
         }
         if (parser.isSet(gpuOption))
-            Settings.setPlayerGPU(true);
+            Settings.setProcessingMode(ShotcutSettings::Linear10GpuCpu);
         if (!parser.positionalArguments().isEmpty())
             resourceArg = parser.positionalArguments();
 

src/mainwindow.cpp

@@ -682,6 +682,7 @@ void MainWindow::setupAndConnectDocks()
             m_filterController->motionTrackerModel(),
             &MotionTrackerModel::removeFromService);
     connect(this, SIGNAL(audioChannelsChanged()), m_filterController, SLOT(setProducer()));
+    connect(this, SIGNAL(processingModeChanged()), m_filterController, SLOT(setProducer()));
     connect(m_timelineDock,
             &TimelineDock::trimStarted,
             m_filterController,
@@ -1042,7 +1043,97 @@ MainWindow::~MainWindow()
 void MainWindow::setupSettingsMenu()
 {
     LOG_DEBUG() << "begin";
+
+    Mlt::Filter filter(MLT.profile(), "color_transform");
+    if (!filter.is_valid()) {
+        ui->actionLinear8bitCpu->setVisible(false);
+#if LIBMLT_VERSION_INT < ((7 << 16) + (34 << 8))
+        ui->actionNative10bitCpu->setVisible(false);
+#endif
+        ui->actionLinear10bitCpu->setVisible(false);
+    }
     QActionGroup *group = new QActionGroup(this);
+    ui->actionNative8bitCpu->setData(ShotcutSettings::Native8Cpu);
+    if (ui->actionLinear8bitCpu->isVisible())
+        ui->actionLinear8bitCpu->setData(ShotcutSettings::Linear8Cpu);
+    if (ui->actionNative10bitCpu->isVisible())
+        ui->actionNative10bitCpu->setData(ShotcutSettings::Native10Cpu);
+    if (ui->actionLinear10bitCpu->isVisible())
+        ui->actionLinear10bitCpu->setData(ShotcutSettings::Linear10Cpu);
+    ui->actionLinear10bitGpuCpu->setData(ShotcutSettings::Linear10GpuCpu);
+    if (ui->actionNative8bitCpu->isVisible())
+        group->addAction(ui->actionNative8bitCpu);
+    if (ui->actionLinear8bitCpu->isVisible())
+        group->addAction(ui->actionLinear8bitCpu);
+    if (ui->actionNative10bitCpu->isVisible())
+        group->addAction(ui->actionNative10bitCpu);
+    if (ui->actionLinear10bitCpu->isVisible())
+        group->addAction(ui->actionLinear10bitCpu);
+    if (ui->actionLinear10bitGpuCpu->isVisible())
+        group->addAction(ui->actionLinear10bitGpuCpu);
+    for (auto a : group->actions()) {
+        const auto mode = (ShotcutSettings::ProcessingMode) a->data().toInt();
+        if (Settings.processingMode() == mode) {
+            a->setChecked(true);
+            setProcessingMode(mode);
+            break;
+        }
+    }
+    connect(group, &QActionGroup::triggered, this, [&](QAction *action) {
+        const auto oldMode = Settings.processingMode();
+        const auto newMode = (ShotcutSettings::ProcessingMode) action->data().toInt();
+        if (oldMode == newMode)
+            return;
+        LOG_INFO() << "Processing Mode" << oldMode << "->" << newMode;
+        if (newMode == ShotcutSettings::Linear10GpuCpu) {
+            QMessageBox
+                dialog(QMessageBox::Warning,
+                       qApp->applicationName(),
+                       tr("GPU processing is experimental and does not work on all computers. "
+                          "Plan to do some testing after turning this on.\n"
+                          "At this time, a project created with GPU processing cannot be "
+                          "converted to a CPU-only project later.\n"
+                          "Do you want to enable GPU processing and restart Shotcut?"),
+                       QMessageBox::No | QMessageBox::Yes,
+                       this);
+            dialog.setDefaultButton(QMessageBox::Yes);
+            dialog.setEscapeButton(QMessageBox::No);
+            dialog.setWindowModality(QmlApplication::dialogModality());
+            dialog.adjustSize();
+            if (dialog.exec() == QMessageBox::Yes) {
+                Settings.setProcessingMode(newMode);
+                m_exitCode = EXIT_RESTART;
+                QApplication::closeAllWindows();
+            }
+            for (auto a : action->actionGroup()->actions()) {
+                if (oldMode == a->data().toInt()) {
+                    a->setChecked(true);
+                    break;
+                }
+            }
+        } else if (oldMode == ShotcutSettings::Linear10GpuCpu) {
+            QMessageBox dialog(QMessageBox::Information,
+                               qApp->applicationName(),
+                               tr("Shotcut must restart to disable GPU processing.\n"
+                                  "Disable GPU processing and restart?"),
+                               QMessageBox::No | QMessageBox::Yes,
+                               this);
+            dialog.setDefaultButton(QMessageBox::Yes);
+            dialog.setEscapeButton(QMessageBox::No);
+            dialog.setWindowModality(QmlApplication::dialogModality());
+            dialog.adjustSize();
+            if (dialog.exec() == QMessageBox::Yes) {
+                Settings.setProcessingMode(newMode);
+                m_exitCode = EXIT_RESTART;
+                QApplication::closeAllWindows();
+            }
+            ui->actionLinear10bitGpuCpu->setChecked(true);
+        } else {
+            setProcessingMode((ShotcutSettings::ProcessingMode) action->data().toInt());
+        }
+    });
+
+    group = new QActionGroup(this);
     group->addAction(ui->actionChannels1);
     group->addAction(ui->actionChannels2);
     group->addAction(ui->actionChannels4);
@@ -1617,32 +1708,31 @@ bool MainWindow::isCompatibleWithGpuMode(MltXmlChecker &checker)
 {
     if (checker.needsGPU() && !Settings.playerGPU()) {
         LOG_INFO() << "file uses GPU but GPU not enabled";
-        QMessageBox
-            dialog(QMessageBox::Warning,
-                   qApp->applicationName(),
-                   tr("The file you opened uses GPU effects, but GPU effects are not enabled."),
-                   QMessageBox::Ok,
-                   this);
+        QMessageBox dialog(QMessageBox::Warning,
+                           qApp->applicationName(),
+                           tr("The file you opened uses GPU processing, which is not enabled."),
+                           QMessageBox::Ok,
+                           this);
         dialog.setWindowModality(QmlApplication::dialogModality());
         dialog.setDefaultButton(QMessageBox::Ok);
         dialog.setEscapeButton(QMessageBox::Ok);
         dialog.exec();
         return false;
     } else if (checker.needsCPU() && Settings.playerGPU()) {
-        LOG_INFO() << "file uses GPU incompatible filters but GPU is enabled";
-        QMessageBox dialog(QMessageBox::Question,
-                           qApp->applicationName(),
-                           tr("The file you opened uses CPU effects that are incompatible with GPU "
-                              "effects, but GPU effects are enabled.\n"
-                              "Do you want to disable GPU effects and restart?"),
-                           QMessageBox::No | QMessageBox::Yes,
-                           this);
+        LOG_INFO() << "file uses GPU incompatible filters but GPU processing is enabled";
+        QMessageBox dialog(
+            QMessageBox::Question,
+            qApp->applicationName(),
+            tr("The file you opened uses CPU effects that are incompatible with GPU processing.\n"
+               "Do you want to disable GPU processing and restart?"),
+            QMessageBox::No | QMessageBox::Yes,
+            this);
         dialog.setWindowModality(QmlApplication::dialogModality());
         dialog.setDefaultButton(QMessageBox::Yes);
         dialog.setEscapeButton(QMessageBox::No);
         int r = dialog.exec();
         if (r == QMessageBox::Yes) {
-            ui->actionGPU->setChecked(false);
+            Settings.setProcessingMode(ShotcutSettings::Native8Cpu);
             m_exitCode = EXIT_RESTART;
             QApplication::closeAllWindows();
         }
@@ -1847,6 +1937,34 @@ void MainWindow::setAudioChannels(int channels)
     emit audioChannelsChanged();
 }
 
+void MainWindow::setProcessingMode(ShotcutSettings::ProcessingMode mode)
+{
+    LOG_DEBUG() << mode;
+    if (mode != Settings.processingMode()) {
+        Settings.setProcessingMode(mode);
+    }
+    switch (mode) {
+    case ShotcutSettings::Native8Cpu:
+        ui->actionNative8bitCpu->setChecked(true);
+        break;
+    case ShotcutSettings::Linear8Cpu:
+        ui->actionLinear8bitCpu->setChecked(true);
+        break;
+    case ShotcutSettings::Native10Cpu:
+        ui->actionNative10bitCpu->setChecked(true);
+        break;
+    case ShotcutSettings::Linear10Cpu:
+        ui->actionLinear10bitCpu->setChecked(true);
+        break;
+    case ShotcutSettings::Linear10GpuCpu:
+        ui->actionLinear10bitGpuCpu->setChecked(true);
+        break;
+    }
+    MLT.videoWidget()->setProperty("processing_mode", mode);
+    MLT.setProcessingMode(mode);
+    emit processingModeChanged();
+}
+
 void MainWindow::showSaveError()
 {
     QMessageBox dialog(QMessageBox::Critical,
@@ -2093,6 +2211,9 @@ bool MainWindow::open(QString url, const Mlt::Properties *properties, bool play,
         m_player->setPauseAfterOpen(!play || !MLT.isClip());
 
         setAudioChannels(MLT.audioChannels());
+        Mlt::Filter filter(MLT.profile(), "color_transform");
+        if (filter.is_valid())
+            setProcessingMode(MLT.processingMode());
         if (url.endsWith(".mlt") || url.endsWith(".xml")) {
             if (MLT.producer()->get_int(kShotcutProjectFolder)) {
                 MLT.setProjectFolder(info.absolutePath());
@@ -2297,8 +2418,6 @@ void MainWindow::readPlayerSettings()
     ui->actionScrubAudio->setChecked(Settings.playerScrubAudio());
     if (ui->actionJack)
         ui->actionJack->setChecked(Settings.playerJACK());
-    if (ui->actionGPU)
-        ui->actionGPU->setChecked(Settings.playerGPU());
 
     QString external = Settings.playerExternal();
     bool ok = false;
@@ -2571,7 +2690,6 @@ void MainWindow::writeSettings()
     if (isFullScreen())
         showNormal();
 #endif
-    Settings.setPlayerGPU(ui->actionGPU->isChecked());
     Settings.setWindowGeometry(saveGeometry());
     Settings.setWindowState(saveState());
     Settings.sync();
@@ -4009,13 +4127,13 @@ void MainWindow::on_actionEnterFullScreen_triggered()
 
 void MainWindow::onGpuNotSupported()
 {
-    Settings.setPlayerGPU(false);
-    if (ui->actionGPU) {
-        ui->actionGPU->setChecked(false);
-        ui->actionGPU->setDisabled(true);
+    if (Settings.processingMode() == ShotcutSettings::Linear10GpuCpu) {
+        Settings.setProcessingMode(ShotcutSettings::Native8Cpu);
     }
+    ui->actionLinear10bitGpuCpu->setChecked(false);
+    ui->actionLinear10bitGpuCpu->setDisabled(true);
     LOG_WARNING() << "";
-    QMessageBox::critical(this, qApp->applicationName(), tr("GPU effects are not supported"));
+    QMessageBox::critical(this, qApp->applicationName(), tr("GPU processing is not supported"));
 }
 
 void MainWindow::onShuttle(float x)
@@ -4256,48 +4374,6 @@ void MainWindow::on_actionJack_triggered(bool checked)
     }
 }
 
-void MainWindow::on_actionGPU_triggered(bool checked)
-{
-    if (checked) {
-        QMessageBox dialog(QMessageBox::Warning,
-                           qApp->applicationName(),
-                           tr("GPU effects are experimental and do not work good on all computers. "
-                              "Plan to do some testing after turning this on.\n"
-                              "At this time, a project created with GPU effects cannot be "
-                              "converted to a CPU-only project later."
-                              "\n\n"
-                              "Do you want to enable GPU effects and restart Shotcut?"),
-                           QMessageBox::No | QMessageBox::Yes,
-                           this);
-        dialog.setDefaultButton(QMessageBox::Yes);
-        dialog.setEscapeButton(QMessageBox::No);
-        dialog.setWindowModality(QmlApplication::dialogModality());
-        if (dialog.exec() == QMessageBox::Yes) {
-            m_exitCode = EXIT_RESTART;
-            QApplication::closeAllWindows();
-        } else {
-            ui->actionGPU->setChecked(false);
-        }
-    } else {
-        QMessageBox dialog(QMessageBox::Information,
-                           qApp->applicationName(),
-                           tr("Shotcut must restart to disable GPU effects."
-                              "\n\n"
-                              "Disable GPU effects and restart?"),
-                           QMessageBox::No | QMessageBox::Yes,
-                           this);
-        dialog.setDefaultButton(QMessageBox::Yes);
-        dialog.setEscapeButton(QMessageBox::No);
-        dialog.setWindowModality(QmlApplication::dialogModality());
-        if (dialog.exec() == QMessageBox::Yes) {
-            m_exitCode = EXIT_RESTART;
-            QApplication::closeAllWindows();
-        } else {
-            ui->actionGPU->setChecked(true);
-        }
-    }
-}
-
 void MainWindow::onExternalTriggered(QAction *action)
 {
     LOG_DEBUG() << action->data().toString();
@@ -5678,25 +5754,22 @@ void MainWindow::on_actionClearRecentOnExit_toggled(bool arg1)
 void MainWindow::onSceneGraphInitialized()
 {
     if (Settings.playerGPU() && Settings.playerWarnGPU()) {
-        QMessageBox dialog(QMessageBox::Warning,
-                           qApp->applicationName(),
-                           tr("GPU effects are EXPERIMENTAL, UNSTABLE and UNSUPPORTED! Unsupported "
-                              "means do not report bugs about it.\n\n"
-                              "Do you want to disable GPU effects and restart Shotcut?"),
-                           QMessageBox::No | QMessageBox::Yes,
-                           this);
+        QMessageBox
+            dialog(QMessageBox::Warning,
+                   qApp->applicationName(),
+                   tr("GPU processing is EXPERIMENTAL, UNSTABLE and UNSUPPORTED! Unsupported "
+                      "means do not report bugs about it.\n\n"
+                      "Do you want to disable GPU processing and restart Shotcut?"),
+                   QMessageBox::No | QMessageBox::Yes,
+                   this);
         dialog.setDefaultButton(QMessageBox::Yes);
         dialog.setEscapeButton(QMessageBox::No);
         dialog.setWindowModality(QmlApplication::dialogModality());
         if (dialog.exec() == QMessageBox::Yes) {
-            ui->actionGPU->setChecked(false);
+            Settings.setProcessingMode(ShotcutSettings::Native8Cpu);
             m_exitCode = EXIT_RESTART;
             QApplication::closeAllWindows();
-        } else {
-            ui->actionGPU->setVisible(true);
         }
-    } else {
-        ui->actionGPU->setVisible(true);
     }
     auto videoWidget = (Mlt::VideoWidget *) &(MLT);
     videoWidget->setBlankScene();