//***************************************************************************
void Kwave::FilterPlugin::run(QStringList params)
{
Kwave::UndoTransactionGuard *undo_guard = 0;
m_pause = false;
if (!interpreteParameters(params)) m_params = params;
sample_index_t first, last;
QList<unsigned int> tracks;
selection(&tracks, &first, &last, true);
// switch to interactive mode in pre-listen mode
Kwave::StreamObject::setInteractive(m_listen);
// create all objects
Kwave::MultiTrackReader source(
(m_listen) ? Kwave::FullSnapshot : Kwave::SinglePassForward,
signalManager(), tracks, first, last);
Kwave::SampleSource *filter = createFilter(tracks.count());
Q_ASSERT(filter);
if (m_listen) {
// pre-listen mode
Q_ASSERT(m_sink);
} else {
// normal mode, with undo
undo_guard = new(std::nothrow)
Kwave::UndoTransactionGuard(*this, actionName());
Q_ASSERT(undo_guard);
if (!undo_guard) {
if (filter) delete filter;
Kwave::StreamObject::setInteractive(false);
return;
}
m_sink = new(std::nothrow) MultiTrackWriter(signalManager(), tracks,
Kwave::Overwrite, first, last);
Q_ASSERT(m_sink);
}
if (!filter || !m_sink || m_sink->done()) {
if (filter) delete filter;
if (undo_guard) delete undo_guard;
if (m_sink) delete m_sink;
m_sink = 0;
Kwave::StreamObject::setInteractive(false);
return;
}
// set up the progress dialog when in processing (not pre-listen) mode
if (!m_listen) {
connect(&source, SIGNAL(progress(qreal)),
this, SLOT(updateProgress(qreal)),
Qt::BlockingQueuedConnection);
}
// force initial update of the filter settings
updateFilter(filter, true);
// connect them
Kwave::connect(source, SIGNAL(output(Kwave::SampleArray)),
*filter, SLOT(input(Kwave::SampleArray)));
Kwave::connect(*filter, SIGNAL(output(Kwave::SampleArray)),
*m_sink, SLOT(input(Kwave::SampleArray)));
// transport the samples
while (!shouldStop() && (!source.done() || m_listen)) {
// process one step
source.goOn();
filter->goOn();
// watch out for changed parameters when in
// pre-listen mode
if (m_listen && paramsChanged()) {
updateFilter(filter);
}
if (m_listen && source.done()) {
// start the next loop
source.reset();
continue;
}
// this lets the process wait if the user pressed cancel
// and the confirm_cancel dialog is active
while (m_pause && !shouldStop())
sleep(1);
}
// cleanup
if (filter) delete filter;
if (m_sink) delete m_sink;
m_sink = 0;
if (undo_guard) delete undo_guard;
m_pause = false;
m_listen = false;
Kwave::StreamObject::setInteractive(false);
}
int main(int argc, char *argv[])
{
try
{
QCommandLineParser parser;
parser.setApplicationDescription("Plex Media Player");
parser.addHelpOption();
parser.addVersionOption();
parser.addOptions({{{"l", "licenses"}, "Show license information"}});
parser.addOptions({{{"a", "from-auto-update"}, "When invoked from auto-update"}});
char **newArgv = appendCommandLineArguments(argc, argv, g_qtFlags);
argc += g_qtFlags.size();
// Suppress SSL related warnings on OSX
// See https://bugreports.qt.io/browse/QTBUG-43173 for more info
//
#ifdef Q_OS_MAC
qputenv("QT_LOGGING_RULES", "qt.network.ssl.warning=false");
#endif
// Qt calls setlocale(LC_ALL, "") in a bunch of places, which breaks
// float/string processing in mpv and ffmpeg.
#ifdef Q_OS_UNIX
qputenv("LC_ALL", "C");
qputenv("LC_NUMERIC", "C");
#endif
detectOpenGLEarly();
preinitQt();
QGuiApplication app(argc, newArgv);
app.setWindowIcon(QIcon(":/images/icon.png"));
// Get the arguments from the app, this is the parsed version of newArgc and newArgv
QStringList args = app.arguments();
// Remove the qt flags above so that our command line parser doesn't get cranky.
for (auto flag : g_qtFlags)
args.removeAll(flag);
// Now parse the command line.
parser.process(args);
if (parser.isSet("licenses"))
{
ShowLicenseInfo();
return EXIT_SUCCESS;
}
// init breakpad.
setupCrashDumper();
UniqueApplication* uniqueApp = new UniqueApplication();
if (!uniqueApp->ensureUnique())
return EXIT_SUCCESS;
#ifdef Q_OS_UNIX
// install signals handlers for proper app closing.
SignalManager signalManager(&app);
Q_UNUSED(signalManager);
#endif
Log::Init();
// Quit app and apply update if we find one.
if (UpdateManager::CheckForUpdates())
{
app.quit();
return 0;
}
detectOpenGLLate();
#ifdef Q_OS_WIN32
initD3DDevice();
#endif
Codecs::preinitCodecs();
// Initialize all the components. This needs to be done
// early since most everything else relies on it
//
ComponentManager::Get().initialize();
// enable remote inspection if we have the correct setting for it.
if (SettingsComponent::Get().value(SETTINGS_SECTION_MAIN, "remoteInspector").toBool())
qputenv("QTWEBENGINE_REMOTE_DEBUGGING", "0.0.0.0:9992");
QtWebEngine::initialize();
// start our helper
HelperLauncher::Get().connectToHelper();
// load QtWebChannel so that we can register our components with it.
QQmlApplicationEngine *engine = Globals::Engine();
KonvergoWindow::RegisterClass();
Globals::SetContextProperty("components", &ComponentManager::Get().getQmlPropertyMap());
// the only way to detect if QML parsing fails is to hook to this signal and then see
// if we get a valid object passed to it. Any error messages will be reported on stderr
// but since no normal user should ever see this it should be fine
//
QObject::connect(engine, &QQmlApplicationEngine::objectCreated, [=](QObject* object, const QUrl& url)
{
Q_UNUSED(url);
if (object == nullptr)
throw FatalException(QObject::tr("Failed to parse application engine script."));
KonvergoWindow* window = Globals::MainWindow();
QObject* webChannel = qvariant_cast<QObject*>(window->property("webChannel"));
Q_ASSERT(webChannel);
ComponentManager::Get().setWebChannel(qobject_cast<QWebChannel*>(webChannel));
QObject::connect(uniqueApp, &UniqueApplication::otherApplicationStarted, window, &KonvergoWindow::otherAppFocus);
});
engine->load(QUrl(QStringLiteral("qrc:/ui/webview.qml")));
Log::UpdateLogLevel();
// run our application
int ret = app.exec();
delete uniqueApp;
Globals::EngineDestroy();
Log::Uninit();
return ret;
}
catch (FatalException& e)
{
QLOG_FATAL() << "Unhandled FatalException:" << qPrintable(e.message());
QApplication errApp(argc, argv);
auto msg = new ErrorMessage(e.message(), true);
msg->show();
errApp.exec();
Log::Uninit();
return 1;
}
}
QString path = url.path();
QDir dir;
if (!dir.mkpath(path))
qWarning("creating path '%s' failed", DBG(path));
}
}
// save the current selection, we have to restore it afterwards!
sample_index_t saved_selection_left = 0;
sample_index_t saved_selection_right = 0;
selection(0, &saved_selection_left, &saved_selection_right, false);
// now we can loop over all blocks and save them
sample_index_t block_start;
sample_index_t block_end = 0;
Kwave::LabelList labels(signalManager().metaData());
Kwave::LabelListIterator it(labels);
Kwave::Label label = it.hasNext() ? it.next() : Kwave::Label();
for (unsigned int index = first;;) {
block_start = block_end;
block_end = (label.isNull()) ? signalLength() : label.pos();
if ((selection_left < block_end) && (selection_right > block_start)) {
// found a block to save...
Q_ASSERT(index < first + count);
sample_index_t left = block_start;
sample_index_t right = block_end - 1;
if (left < selection_left) left = selection_left;
if (right > selection_right) right = selection_right;