diff --git a/docs/dev/build-instructions/cmake_options.md b/docs/dev/build-instructions/cmake_options.md index aea4aed7cad..74e547b8698 100644 --- a/docs/dev/build-instructions/cmake_options.md +++ b/docs/dev/build-instructions/cmake_options.md @@ -319,6 +319,11 @@ All warnings are treated as errors. Build support for WASAPI. (Default: ON) +### webrtc-audio-processing + +Use WebRTC audio processing for various dsp features. +(Default: OFF) + ### xboxinput Build support for global shortcuts from Xbox controllers via the XInput DLL. diff --git a/src/mumble/AudioConfigDialog.cpp b/src/mumble/AudioConfigDialog.cpp index f9d377ada1f..f9f1801edd2 100644 --- a/src/mumble/AudioConfigDialog.cpp +++ b/src/mumble/AudioConfigDialog.cpp @@ -11,6 +11,7 @@ #include "AudioOutputSample.h" #include "AudioOutputToken.h" #include "NetworkConfig.h" +#include "Settings.h" #include "Utils.h" #include "Global.h" @@ -127,10 +128,24 @@ void AudioInputDialog::load(const Settings &r) { loadSlider(qsDoublePush, static_cast< int >(static_cast< float >(r.uiDoublePush) / 1000.f + 0.5f)); loadSlider(qsPTTHold, static_cast< int >(r.pttHold)); - if (r.vsVAD == Settings::Amplitude) - qrbAmplitude->setChecked(true); - else - qrbSNR->setChecked(true); +#ifdef USE_WEBRTC_AUDIO_PROCESSING + loadSlider(qsWebRTCAggressiveness, r.fVADWebRTCAggressiveness); + qrbWebRTC->show(); +#endif + + switch (r.vsVAD) { + case Settings::Amplitude: + qrbAmplitude->setChecked(true); + break; +#ifdef USE_WEBRTC_AUDIO_PROCESSING + case Settings::WebRTC: + qrbWebRTC->setChecked(true); + break; +#endif + default: + qrbSNR->setChecked(true); + break; + } loadCheckBox(qcbPushWindow, r.bShowPTTButtonWindow); loadCheckBox(qcbEnableCuePTT, r.audioCueEnabledPTT); @@ -241,11 +256,22 @@ void AudioInputDialog::save() const { s.noiseCancelMode = Settings::NoiseCancelSpeex; } - s.iMinLoudness = 18000 - qsAmp->value() + 2000; - s.iVoiceHold = qsTransmitHold->value(); - s.fVADmin = static_cast< float >(qsTransmitMin->value()) / 32767.0f; - s.fVADmax = static_cast< float >(qsTransmitMax->value()) / 32767.0f; - s.vsVAD = qrbSNR->isChecked() ? Settings::SignalToNoise : Settings::Amplitude; + s.iMinLoudness = 18000 - qsAmp->value() + 2000; + s.iVoiceHold = qsTransmitHold->value(); + s.fVADmin = static_cast< float >(qsTransmitMin->value()) / 32767.0f; + s.fVADmax = static_cast< float >(qsTransmitMax->value()) / 32767.0f; + + s.fVADWebRTCAggressiveness = qsWebRTCAggressiveness->value(); + + if (qrbAmplitude->isChecked()) + s.vsVAD = Settings::Amplitude; +#ifdef USE_WEBRTC_AUDIO_PROCESSING + else if (qrbWebRTC->isChecked()) + s.vsVAD = Settings::WebRTC; +#endif + else + s.vsVAD = Settings::SignalToNoise; + s.iFramesPerPacket = qsFrames->value(); s.iFramesPerPacket = (s.iFramesPerPacket == 1) ? 1 : ((s.iFramesPerPacket - 1) * 2); s.uiDoublePush = static_cast< unsigned int >(qsDoublePush->value() * 1000); @@ -354,6 +380,20 @@ void AudioInputDialog::on_qsTransmitMax_valueChanged() { Mumble::Accessibility::setSliderSemanticValue(qsTransmitMax, Mumble::Accessibility::SliderMode::READ_PERCENT, "%"); } +void AudioInputDialog::updateVad() { + Settings::VADSource vad = Settings::SignalToNoise; + + if (qrbAmplitude->isChecked()) + vad = Settings::Amplitude; +#ifdef USE_WEBRTC_AUDIO_PROCESSING + else if (qrbWebRTC->isChecked()) + vad = Settings::WebRTC; +#endif + + AudioInputPtr ai = Global::get().ai; + ai->updateVad(vad); +} + void AudioInputDialog::updateBitrate() { if (!qsQuality || !qsFrames || !qlBitrate) return; @@ -622,6 +662,26 @@ void AudioInputDialog::on_qrbNoiseSupBoth_toggled(bool checked) { showSpeexNoiseSuppressionSlider(checked); } +#ifdef USE_WEBRTC_AUDIO_PROCESSING +void AudioInputDialog::on_qrbWebRTC_toggled(bool checked) { + updateVad(); + + qliWebRTCAggressiveness->setVisible(checked); + qsWebRTCAggressiveness->setVisible(checked); + + qliTransmitMax->setVisible(!checked); + qsTransmitMax->setVisible(!checked); + qliTransmitMin->setVisible(!checked); + qsTransmitMin->setVisible(!checked); +} + +void AudioInputDialog::on_qsWebRTCAggressiveness_valueChanged(int aggressiveness) { + AudioInputPtr ai = Global::get().ai; + ai->updateWebrtcAggressiveness(static_cast< webrtc::Vad::Aggressiveness >(aggressiveness)); + updateVad(); +} +#endif + void AudioOutputDialog::enablePulseAudioAttenuationOptionsFor(const QString &outputName) { if (outputName == QLatin1String("PulseAudio")) { qcbOnlyAttenuateSameOutput->show(); diff --git a/src/mumble/AudioConfigDialog.h b/src/mumble/AudioConfigDialog.h index 37a0a19f899..ac08c335892 100644 --- a/src/mumble/AudioConfigDialog.h +++ b/src/mumble/AudioConfigDialog.h @@ -17,6 +17,7 @@ class AudioInputDialog : public ConfigWidget, public Ui::AudioInput { Q_DISABLE_COPY(AudioInputDialog) void updateAudioCueEnabled(); + void updateVad(); protected: QTimer *qtTick; @@ -67,6 +68,11 @@ public slots: void on_qcbIdleAction_currentIndexChanged(int v); void on_qrbNoiseSupSpeex_toggled(bool checked); void on_qrbNoiseSupBoth_toggled(bool checked); + +#ifdef USE_WEBRTC_AUDIO_PROCESSING + void on_qrbWebRTC_toggled(bool); + void on_qsWebRTCAggressiveness_valueChanged(int); +#endif }; class AudioOutputDialog : public ConfigWidget, public Ui::AudioOutput { diff --git a/src/mumble/AudioInput.cpp b/src/mumble/AudioInput.cpp index a2265cbc574..5d2f4003edf 100644 --- a/src/mumble/AudioInput.cpp +++ b/src/mumble/AudioInput.cpp @@ -18,6 +18,10 @@ #include "VoiceRecorder.h" #include "Global.h" +#ifdef USE_WEBRTC_AUDIO_PROCESSING +#include "WebRTC_Priv.h" +#endif + #include #ifdef USE_RNNOISE @@ -27,6 +31,7 @@ extern "C" { #endif #include +#include #include #include #include @@ -251,6 +256,12 @@ AudioInput::AudioInput() denoiseState = rnnoise_create(nullptr); #endif +#ifdef USE_WEBRTC_AUDIO_PROCESSING + m_vadWebrtcAggressiveness = static_cast< webrtc::Vad::Aggressiveness >(Global::get().s.fVADWebRTCAggressiveness); +#endif + + updateVad(Global::get().s.vsVAD); + qWarning("AudioInput: %d bits/s, %d hz, %d sample", iAudioQuality, iSampleRate, iFrameSize); iEchoFreq = iMicFreq = iSampleRate; @@ -941,11 +952,28 @@ void AudioInput::encodeAudioFrame(AudioChunk chunk) { static_cast< std::streamsize >(iFrameSize * sizeof(short))); } - fSpeechProb = static_cast< float >(m_preprocessor.getSpeechProb()) / 100.0f; + Settings::VADSource currentVad = m_vad.load(); + + switch (currentVad) { +#ifdef USE_WEBRTC_AUDIO_PROCESSING + case Settings::WebRTC: { + auto webrtcVad = std::atomic_load(&m_vadWebrtc); + + if (!webrtcVad) { + break; + } + + fSpeechProb = !!webrtcVad->VoiceActivity(psSource, iFrameSize, iSampleRate); + break; + } +#endif + default: + fSpeechProb = static_cast< float >(m_preprocessor.getSpeechProb()) / 100.0f; + } // clean microphone level: peak of filtered signal attenuated by AGC gain dPeakCleanMic = qMax(dPeakSignal - static_cast< float >(gainValue), -96.0f); - float level = (Global::get().s.vsVAD == Settings::SignalToNoise) ? fSpeechProb : (1.0f + dPeakCleanMic / 96.0f); + float level = (currentVad == Settings::Amplitude) ? (1.0f + dPeakCleanMic / 96.0f) : fSpeechProb; bool bIsSpeech = false; @@ -1244,5 +1272,35 @@ void AudioInput::updateUserMuteDeafState(const ClientUser *user) { } } +void AudioInput::updateVad(Settings::VADSource src) { +#ifdef USE_WEBRTC_AUDIO_PROCESSING + if (src == Settings::WebRTC) { + auto u = webrtc::CreateVad(m_vadWebrtcAggressiveness); + if (!u) { + qWarning() << "AudioInput: Failed to initialize WebRTC VAD, disabled"; + } + std::shared_ptr< webrtc::Vad > s = std::move(u); + std::atomic_store(&m_vadWebrtc, std::move(s)); + } else { + std::atomic_store(&m_vadWebrtc, std::shared_ptr< webrtc::Vad >(nullptr)); + } +#endif + m_vad.store(src); +} + +#ifdef USE_WEBRTC_AUDIO_PROCESSING +void AudioInput::updateWebrtcAggressiveness(webrtc::Vad::Aggressiveness aggressiveness) { + m_vadWebrtcAggressiveness = aggressiveness; + if (m_vad.load() == Settings::WebRTC && m_vadWebrtc) { + auto u = webrtc::CreateVad(m_vadWebrtcAggressiveness); + if (!u) { + qWarning() << "AudioInput: Failed to initialize WebRTC VAD, disabled"; + } + std::shared_ptr< webrtc::Vad > s = std::move(u); + std::atomic_store(&m_vadWebrtc, std::move(s)); + } +} +#endif + void AudioInput::onUserMutedChanged() { } diff --git a/src/mumble/AudioInput.h b/src/mumble/AudioInput.h index 5a87257090e..3c2fc2c0c35 100644 --- a/src/mumble/AudioInput.h +++ b/src/mumble/AudioInput.h @@ -11,6 +11,7 @@ #include #include +#include #include #include #include @@ -29,6 +30,10 @@ #include "Settings.h" #include "Timer.h" +#ifdef USE_WEBRTC_AUDIO_PROCESSING +#include "WebRTC_Priv.h" +#endif + class AudioInput; struct OpusEncoder; struct DenoiseState; @@ -226,6 +231,13 @@ class AudioInput : public QThread { AudioPreprocessor m_preprocessor; SpeexEchoState *sesEcho; + std::atomic< Settings::VADSource > m_vad; + +#ifdef USE_WEBRTC_AUDIO_PROCESSING + std::shared_ptr< webrtc::Vad > m_vadWebrtc; + webrtc::Vad::Aggressiveness m_vadWebrtcAggressiveness; +#endif + /// bResetEncoder is a flag that notifies /// our encoder functions that the encoder /// needs to be reset. @@ -313,6 +325,13 @@ class AudioInput : public QThread { virtual bool isAlive() const; bool isTransmitting() const; + void updateVad(Settings::VADSource src); + +#ifdef USE_WEBRTC_AUDIO_PROCESSING + void updateWebrtcAggressiveness(webrtc::Vad::Aggressiveness); +#endif + + void updateUserMuteDeafState(const ClientUser *user); protected: diff --git a/src/mumble/AudioInput.ui b/src/mumble/AudioInput.ui index 6833533066b..db07e153af7 100644 --- a/src/mumble/AudioInput.ui +++ b/src/mumble/AudioInput.ui @@ -411,6 +411,22 @@ + + + + Use WebRTC GMM based speech detection + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + false + + + WebRTC GMM + + + @@ -490,6 +506,44 @@ + + + + false + + + Aggressiveness + + + qsWebRTCAggressiveness + + + + + + + false + + + Controls aggressiveness of WebRTC VAD + + + Higher values make the VAD more aggressive in filtering noise. + + + 0 + + + 3 + + + 1 + + + Qt::Horizontal + + + @@ -1175,9 +1229,11 @@ qcbTransmit qrbAmplitude qrbSNR + qrbWebRTC qsTransmitHold qsTransmitMin qsTransmitMax + qsWebRTCAggressiveness qsQuality qsDoublePush qsPTTHold diff --git a/src/mumble/AudioWizard.cpp b/src/mumble/AudioWizard.cpp index d5cbb8b27f6..5789cf36094 100644 --- a/src/mumble/AudioWizard.cpp +++ b/src/mumble/AudioWizard.cpp @@ -15,6 +15,10 @@ #include "GlobalShortcut.h" #include "GlobalShortcutButtons.h" +#ifdef USE_WEBRTC_AUDIO_PROCESSING +#include "WebRTC_Priv.h" +#endif + #include #include @@ -124,6 +128,10 @@ AudioWizard::AudioWizard(QWidget *p) : QWizard(p) { abAmplify->qcInside = Qt::green; abAmplify->qcAbove = Qt::red; +#ifdef USE_WEBRTC_AUDIO_PROCESSING + qrWebRTC->setVisible(true); +#endif + for (const auto &shortcut : Global::get().s.qlShortcuts) { if (shortcut.iIndex == Global::get().mw->gsPushTalk->idx) { pttButtons = shortcut.qlButtons; @@ -135,6 +143,17 @@ AudioWizard::AudioWizard(QWidget *p) : QWizard(p) { qrPTT->setChecked(true); else if (Global::get().s.vsVAD == Settings::Amplitude) qrAmplitude->setChecked(true); +#ifdef USE_WEBRTC_AUDIO_PROCESSING + else if (Global::get().s.vsVAD == Settings::WebRTC) { + qrWebRTC->setChecked(true); + qsWebRTCAggressiveness->setValue(Global::get().s.fVADWebRTCAggressiveness); + qliVadTuningText->hide(); + qliVadTuningTextHC->hide(); + qliVadTuningTextWebRTC->show(); + qsWebRTCAggressiveness->show(); + qsVAD->hide(); + } +#endif else qrSNR->setChecked(true); @@ -607,6 +626,7 @@ void AudioWizard::on_qrSNR_clicked(bool on) { if (on) { Global::get().s.vsVAD = Settings::SignalToNoise; Global::get().s.atTransmit = Settings::VAD; + updateVad(); updateTriggerWidgets(false); bTransmitChanged = true; } @@ -616,11 +636,44 @@ void AudioWizard::on_qrAmplitude_clicked(bool on) { if (on) { Global::get().s.vsVAD = Settings::Amplitude; Global::get().s.atTransmit = Settings::VAD; + updateVad(); + updateTriggerWidgets(false); + bTransmitChanged = true; + } +} + +#ifdef USE_WEBRTC_AUDIO_PROCESSING +void AudioWizard::on_qrWebRTC_toggled(bool on) { + if (on) { + Global::get().s.vsVAD = Settings::WebRTC; + Global::get().s.atTransmit = Settings::VAD; + updateVad(); updateTriggerWidgets(false); bTransmitChanged = true; + + qsWebRTCAggressiveness->setValue(Global::get().s.fVADWebRTCAggressiveness); + + qliVadTuningText->hide(); + qliVadTuningTextHC->hide(); + qliVadTuningTextWebRTC->show(); + qsWebRTCAggressiveness->show(); + qsVAD->hide(); + } else { + qliVadTuningText->setVisible(!Global::get().s.bHighContrast); + qliVadTuningTextHC->setVisible(Global::get().s.bHighContrast); + qliVadTuningTextWebRTC->hide(); + qsWebRTCAggressiveness->hide(); + qsVAD->show(); } } +void AudioWizard::on_qsWebRTCAggressiveness_valueChanged(int aggressiveness) { + Global::get().s.fVADWebRTCAggressiveness = aggressiveness; + Global::get().ai->updateWebrtcAggressiveness(static_cast< webrtc::Vad::Aggressiveness >(aggressiveness)); + updateVad(); +} +#endif + void AudioWizard::on_qrPTT_clicked(bool on) { if (on) { Global::get().s.atTransmit = Settings::PushToTalk; @@ -735,6 +788,11 @@ void AudioWizard::on_qcbHighContrast_clicked(bool on) { qliVolumeTuningText->setVisible(!Global::get().s.bHighContrast); qliVolumeTuningTextHC->setVisible(Global::get().s.bHighContrast); +#ifdef USE_WEBRTC_AUDIO_PROCESSING + if (Global::get().s.vsVAD == Settings::WebRTC) + return; +#endif + qliVadTuningText->setVisible(!Global::get().s.bHighContrast); qliVadTuningTextHC->setVisible(Global::get().s.bHighContrast); } @@ -763,6 +821,11 @@ void AudioWizard::on_qrbQualityCustom_clicked() { restartAudio(true); } +void AudioWizard::updateVad() { + AudioInputPtr ai = Global::get().ai; + ai->updateVad(Global::get().s.vsVAD); +} + void AudioWizard::updateEchoCheckbox(AudioInputRegistrar *air) { bool echoCancelPossible = firstUsableEchoCancellation(air, qcbOutput->currentText()) != EchoCancelOptionID::DISABLED; diff --git a/src/mumble/AudioWizard.h b/src/mumble/AudioWizard.h index c0e3ef2cfb5..663dde6f062 100644 --- a/src/mumble/AudioWizard.h +++ b/src/mumble/AudioWizard.h @@ -21,6 +21,7 @@ class AudioWizard : public QWizard, public Ui::AudioWizard { Q_DISABLE_COPY(AudioWizard) void updateEchoCheckbox(AudioInputRegistrar *air); + void updateVad(); /// Which echo cancellation is usable depends on the audio backend and the device combination. /// This function will iterate through the list of available echo cancellation in the audio backend and check with @@ -67,6 +68,10 @@ public slots: void on_qsVAD_valueChanged(int); void on_qrAmplitude_clicked(bool); void on_qrSNR_clicked(bool); +#ifdef USE_WEBRTC_AUDIO_PROCESSING + void on_qrWebRTC_toggled(bool); + void on_qsWebRTCAggressiveness_valueChanged(int); +#endif void on_qrPTT_clicked(bool); void on_qpbPTT_clicked(); void on_qcbEcho_clicked(bool); diff --git a/src/mumble/AudioWizard.ui b/src/mumble/AudioWizard.ui index e80b2c83ae8..cb7b8e6eca6 100644 --- a/src/mumble/AudioWizard.ui +++ b/src/mumble/AudioWizard.ui @@ -576,6 +576,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou + + + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + false + + + true + + + Qt::LinksAccessibleByMouse|Qt::TextSelectableByMouse + + + @@ -601,6 +617,31 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou + + + + false + + + Voice activity detection aggressiveness level + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + 0 + + + 3 + + + 1 + + + Qt::Horizontal + + + @@ -681,6 +722,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou + + + + + 0 + 0 + + + + false + + + WebRTC GMM + + + diff --git a/src/mumble/CMakeLists.txt b/src/mumble/CMakeLists.txt index 1f3daa534c2..dd1dd725c2c 100644 --- a/src/mumble/CMakeLists.txt +++ b/src/mumble/CMakeLists.txt @@ -24,6 +24,8 @@ option(bundled-speex "Build the included version of Speex instead of looking for option(rnnoise "Use RNNoise for machine learning noise reduction." ON) option(bundled-rnnoise "Build the included version of RNNoise instead of looking for one on the system." ${rnnoise}) +option(webrtc-audio-processing "Use WebRTC audio processing for various dsp features." OFF) + option(manual-plugin "Include the built-in \"manual\" positional audio plugin." ON) option(qtspeech "Use Qt's text-to-speech system (part of the Qt Speech module) instead of Mumble's own OS-specific text-to-speech implementations." OFF) @@ -815,6 +817,25 @@ else() endif() endif() +if(webrtc-audio-processing) + find_pkg(webrtc-audio-processing REQUIRED) + + target_compile_definitions(mumble_client_object_lib + PUBLIC + "USE_WEBRTC_AUDIO_PROCESSING" + ) + + target_include_directories(mumble_client_object_lib + PUBLIC + ${webrtc-audio-processing_INCLUDE_DIRS} + ) + + target_link_libraries(mumble_client_object_lib + PUBLIC + ${webrtc-audio-processing_LIBRARIES} + ) +endif() + if(crash-report) target_sources(mumble_client_object_lib PRIVATE diff --git a/src/mumble/EnumStringConversions.cpp b/src/mumble/EnumStringConversions.cpp index c4be0959b29..0e3e4e025ba 100644 --- a/src/mumble/EnumStringConversions.cpp +++ b/src/mumble/EnumStringConversions.cpp @@ -12,7 +12,8 @@ #define VAD_SOURCE_VALUES \ PROCESS(Settings::VADSource, Amplitude, "Amplitude") \ - PROCESS(Settings::VADSource, SignalToNoise, "SignalToNoise") + PROCESS(Settings::VADSource, SignalToNoise, "SignalToNoise") \ + PROCESS(Settings::VADSource, WebRTC, "WebRTC") #define LOOP_MODE_VALUES \ PROCESS(Settings::LoopMode, None, "None") \ diff --git a/src/mumble/Settings.h b/src/mumble/Settings.h index 232f987e03e..9ad2fdd32d9 100644 --- a/src/mumble/Settings.h +++ b/src/mumble/Settings.h @@ -190,7 +190,7 @@ struct OverlaySettings { struct Settings { enum AudioTransmit { Continuous, VAD, PushToTalk }; - enum VADSource { Amplitude, SignalToNoise }; + enum VADSource { Amplitude, SignalToNoise, WebRTC }; enum LoopMode { None, Local, Server }; enum ChannelExpand { NoChannels, ChannelsWithUsers, AllChannels }; enum ChannelDrag { Ask, DoNothing, Move }; @@ -280,6 +280,7 @@ struct Settings { VADSource vsVAD = Amplitude; float fVADmin = 0.80f; float fVADmax = 0.98f; + int fVADWebRTCAggressiveness = 0; int iFramesPerPacket = 2; QString qsAudioInput = {}; QString qsAudioOutput = {}; diff --git a/src/mumble/SettingsKeys.h b/src/mumble/SettingsKeys.h index 6ff85bec573..e6dbe86fd94 100644 --- a/src/mumble/SettingsKeys.h +++ b/src/mumble/SettingsKeys.h @@ -62,6 +62,7 @@ const SettingsKey ATTENUATE_LOOPBACK_KEY = { "attenuate_loo const SettingsKey VAD_MODE_KEY = { "vad_mode" }; const SettingsKey VAD_MIN_KEY = { "vad_min" }; const SettingsKey VAD_MAX_KEY = { "vad_max" }; +const SettingsKey VAD_WEBRTC_AGGRESSIVENESS_KEY = { "vad_webrtc_aggressiveness" }; const SettingsKey NOISE_CANCEL_MODE_KEY = { "noise_cancel_mode" }; const SettingsKey SPEEX_NOISE_CANCEL_STRENGTH_KEY = { "speex_noise_cancel_strength" }; const SettingsKey INPUT_CHANNEL_MASK_KEY = { "input_channel_mask" }; diff --git a/src/mumble/SettingsMacros.h b/src/mumble/SettingsMacros.h index 293e206cdda..61ee96020ec 100644 --- a/src/mumble/SettingsMacros.h +++ b/src/mumble/SettingsMacros.h @@ -46,6 +46,7 @@ PROCESS(audio, VAD_MODE_KEY, vsVAD) \ PROCESS(audio, VAD_MIN_KEY, fVADmin) \ PROCESS(audio, VAD_MAX_KEY, fVADmax) \ + PROCESS(audio, VAD_WEBRTC_AGGRESSIVENESS_KEY, fVADWebRTCAggressiveness) \ PROCESS(audio, NOISE_CANCEL_MODE_KEY, noiseCancelMode) \ PROCESS(audio, SPEEX_NOISE_CANCEL_STRENGTH_KEY, iSpeexNoiseCancelStrength) \ PROCESS(audio, INPUT_CHANNEL_MASK_KEY, uiAudioInputChannelMask) \ diff --git a/src/mumble/WebRTC_Priv.h b/src/mumble/WebRTC_Priv.h new file mode 100644 index 00000000000..057902024d1 --- /dev/null +++ b/src/mumble/WebRTC_Priv.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +// webrtc::Vad is part of webrtc-audio-processing but this header not included in +// distribution. However the code base of the library hasn't been updating for +// years. So we expect this private header to be stable. + +#ifndef COMMON_AUDIO_VAD_INCLUDE_VAD_H_ +#define COMMON_AUDIO_VAD_INCLUDE_VAD_H_ + +#include +#include +#include + + +namespace webrtc { + +class Vad { +public: + enum Aggressiveness { kVadNormal = 0, kVadLowBitrate = 1, kVadAggressive = 2, kVadVeryAggressive = 3 }; + + enum Activity { kPassive = 0, kActive = 1, kError = -1 }; + + virtual ~Vad() = default; + + // Calculates a VAD decision for the given audio frame. Valid sample rates + // are 8000, 16000, and 32000 Hz; the number of samples must be such that the + // frame is 10, 20, or 30 ms long. + virtual Activity VoiceActivity(const int16_t *audio, size_t num_samples, int sample_rate_hz) = 0; + + // Resets VAD state. + virtual void Reset() = 0; +}; + +// Returns a Vad instance that's implemented on top of WebRtcVad. +std::unique_ptr< Vad > CreateVad(Vad::Aggressiveness aggressiveness); + +} // namespace webrtc + +#endif // COMMON_AUDIO_VAD_INCLUDE_VAD_H_ diff --git a/src/mumble/mumble_ar.ts b/src/mumble/mumble_ar.ts index 3db10db4512..235704cf860 100644 --- a/src/mumble/mumble_ar.ts +++ b/src/mumble/mumble_ar.ts @@ -1231,6 +1231,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2277,6 +2301,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_bg.ts b/src/mumble/mumble_bg.ts index 7c609998816..c01ae321628 100644 --- a/src/mumble/mumble_bg.ts +++ b/src/mumble/mumble_bg.ts @@ -1232,6 +1232,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2278,6 +2302,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_br.ts b/src/mumble/mumble_br.ts index 269d0747d65..2e7c8a6594a 100644 --- a/src/mumble/mumble_br.ts +++ b/src/mumble/mumble_br.ts @@ -1231,6 +1231,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2277,6 +2301,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_ca.ts b/src/mumble/mumble_ca.ts index 71eb27b3d9b..63c33cf1b76 100644 --- a/src/mumble/mumble_ca.ts +++ b/src/mumble/mumble_ca.ts @@ -1239,6 +1239,30 @@ Aquest valor us permet establir el nombre màxim d'usuaris permesos al cana <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). <b>Això mostra el pic de l'ample de banda de sortida utilitzat.</b><br /> Mostra el màxim ample de banda enviat des de la vostra màquina. La taxa de bits d'àudio és la taxa de bits màxima només per a les dades d'àudio. La posició és la taxa de bits utilitzada per a la informació posicional. El superior és el nostre enquadrament i les capçaleres de paquets IP (IP i UDP és 75% d'aquesta sobrecàrrega). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Parlaeu en veu alta, com quan esteu molest o emocionat. Disminuiu el volum del t This visually represents the positional audio that is currently being played Això mostra l'àudio posicional que s'està reproduïnt + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_cs.ts b/src/mumble/mumble_cs.ts index 90c929687e5..314b9f78354 100644 --- a/src/mumble/mumble_cs.ts +++ b/src/mumble/mumble_cs.ts @@ -1239,6 +1239,30 @@ Tato hodnota Vám umožňuje nastavit maximální počet povolených uživatelů <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Mluvte nahlas, jako kdybyste byli podráždění nebo nadšení. Snižujte hlasi This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_cy.ts b/src/mumble/mumble_cy.ts index bb40b1ab8fc..fdac7817eb3 100644 --- a/src/mumble/mumble_cy.ts +++ b/src/mumble/mumble_cy.ts @@ -1232,6 +1232,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2278,6 +2302,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_da.ts b/src/mumble/mumble_da.ts index 14e06985ff4..6a2d922fb02 100644 --- a/src/mumble/mumble_da.ts +++ b/src/mumble/mumble_da.ts @@ -1239,6 +1239,30 @@ Denne værdi tillader dig at indstille det maksimale antal brugere tilladt på k <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Tal højlydt som når du er irriteret og ophidset. Formindsk nu lydstyrken i lyd This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_de.ts b/src/mumble/mumble_de.ts index d2354fc3d5a..c10e56454a0 100644 --- a/src/mumble/mumble_de.ts +++ b/src/mumble/mumble_de.ts @@ -1239,6 +1239,30 @@ Dieser Wert erlaubt das Einstellen der maximal im Kanal erlaubten Benutzeranzahl <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). <b>Dies zeigt die maximale ausgehende Bandbreite an.</b><br />Dies zeigt die maximale Bandbreite an, die von deinem Rechner gesendet wird. Audio-Bitrate ist die maximale Bitrate für die Audiodaten allein. Position ist die Bitrate, die für Positionsdaten verwendet wird. Overhead ist unser Framing und die IP-Paket-Header (IP und UDP machen 75% dieses Overheads aus). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Sprechen Sie so laut als wären Sie wütend oder aufgeregt. Verringern Sie die M This visually represents the positional audio that is currently being played Das aktuelle Positionsaudiosignal wird visuell dargestellt + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_el.ts b/src/mumble/mumble_el.ts index f8adf2e99df..5139a559a7f 100644 --- a/src/mumble/mumble_el.ts +++ b/src/mumble/mumble_el.ts @@ -1239,6 +1239,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_en.ts b/src/mumble/mumble_en.ts index efe1fea961e..c57051bff80 100644 --- a/src/mumble/mumble_en.ts +++ b/src/mumble/mumble_en.ts @@ -1231,6 +1231,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2277,6 +2301,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_en_GB.ts b/src/mumble/mumble_en_GB.ts index cb8ec9b69a1..387be80c960 100644 --- a/src/mumble/mumble_en_GB.ts +++ b/src/mumble/mumble_en_GB.ts @@ -1239,6 +1239,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). <b>This shows the peak outgoing bandwidth used.</b><br />This shows the peak bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP are 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Speak loudly as if you are annoyed or excited. Decrease the volume in the sound This visually represents the positional audio that is currently being played This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_eo.ts b/src/mumble/mumble_eo.ts index 539cf8cec44..de3ab2f2c28 100644 --- a/src/mumble/mumble_eo.ts +++ b/src/mumble/mumble_eo.ts @@ -1239,6 +1239,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2285,6 +2309,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_es.ts b/src/mumble/mumble_es.ts index 78741f9c4ea..9c896890c5f 100644 --- a/src/mumble/mumble_es.ts +++ b/src/mumble/mumble_es.ts @@ -1239,6 +1239,30 @@ Este valor permite fijar el número máximo de usuarios permitidos en el canal. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). <b>Esto muestra el ancho de banda saliente maximo utilizado.</b><br />Esto muestra la cantidad maxima de ancho de banda enviado desde su maquina. La tasa de bits de audio es la tasa de bits maxima solo para los datos de audio. La posicion es la tasa de bits utilizada para la informacion posicional. Los gastos generales son encabezados de los paquetes IP (IP y UPD representan el 75% de estos gastos generales). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Hable fuerte en voz alta, como cuando está molesto o entusiasmado. Baje el volu This visually represents the positional audio that is currently being played Representa visualmente el audio posicional que se está reproduciendo + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_et.ts b/src/mumble/mumble_et.ts index 0302021ea4e..80e1cad59ad 100644 --- a/src/mumble/mumble_et.ts +++ b/src/mumble/mumble_et.ts @@ -1232,6 +1232,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2278,6 +2302,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_eu.ts b/src/mumble/mumble_eu.ts index fb052715f51..970c9eae5be 100644 --- a/src/mumble/mumble_eu.ts +++ b/src/mumble/mumble_eu.ts @@ -1241,6 +1241,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2287,6 +2311,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_fa_IR.ts b/src/mumble/mumble_fa_IR.ts index 7685d73347d..66980c4f869 100644 --- a/src/mumble/mumble_fa_IR.ts +++ b/src/mumble/mumble_fa_IR.ts @@ -1233,6 +1233,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2279,6 +2303,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_fi.ts b/src/mumble/mumble_fi.ts index b1c35ceb7ac..dc55b685237 100644 --- a/src/mumble/mumble_fi.ts +++ b/src/mumble/mumble_fi.ts @@ -1239,6 +1239,30 @@ Tämän numeron ollessa suurempi kuin nolla kanava sallii enintään numeron suu <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). <b>Tämä osoittaa yleisimmin käytettyä kaistanleveyttä.</b> <br />Tämä osoittaa, kuinka paljon kaistanleveyttä lähetetään pois koneesta. Audio bitrate on suurin biraatti vain äänidatalle. Sijainti on biraatti, jota käytetään positiaalitietoihin. Yläpuolella on kehys ja IP-pakkausotsikot (IP ja UDP ovat 75 % tästä). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Puhu kovalla äänellä, aivan kuin olisit ärsyyntynyt tai kiihtynyt. Vähennä This visually represents the positional audio that is currently being played Tämä esittää visuaalisesti sijainninmukaisen äänen joka nyt kuuluu + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_fr.ts b/src/mumble/mumble_fr.ts index b7a3f9484bf..f55f2ec6d50 100644 --- a/src/mumble/mumble_fr.ts +++ b/src/mumble/mumble_fr.ts @@ -1239,6 +1239,30 @@ Cette valeur vous permet de définir un nombre maximum d'utilisateurs autor <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). <b>Ceci montre le débit sortant maximal utilisé.</b><br />Ceci montre le débit maximal envoyé depuis votre machine. Le débit audio est le débit maximal pour les données audio seules. La position est le débit utilisé pour les informations de position. La surcharge correspond à la trame et aux en-têtes de paquets IP (IP et UDP représentent 75 % de cette surcharge). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Parlez fort, comme lorsque vous êtes irrité ou excité. Diminuez le volume dan This visually represents the positional audio that is currently being played Cela représente visuellement l'audio positionnel qui est actuellement joué + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_gl.ts b/src/mumble/mumble_gl.ts index 51690ba3c25..1339518dbf1 100644 --- a/src/mumble/mumble_gl.ts +++ b/src/mumble/mumble_gl.ts @@ -1233,6 +1233,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2279,6 +2303,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_he.ts b/src/mumble/mumble_he.ts index dd0d1206350..f492c71f4ab 100644 --- a/src/mumble/mumble_he.ts +++ b/src/mumble/mumble_he.ts @@ -1240,6 +1240,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2307,6 +2331,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_hi.ts b/src/mumble/mumble_hi.ts index 109e2d6c90a..9a26cb5238b 100644 --- a/src/mumble/mumble_hi.ts +++ b/src/mumble/mumble_hi.ts @@ -1232,6 +1232,30 @@ Contains the list of members inherited by the current channel. Uncheck <i> <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2265,6 +2289,22 @@ Mumble is under continuous development, and the development team wants to focus This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_hu.ts b/src/mumble/mumble_hu.ts index ffb22e4a4c3..da0efa96d4c 100644 --- a/src/mumble/mumble_hu.ts +++ b/src/mumble/mumble_hu.ts @@ -1235,6 +1235,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2299,6 +2323,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_it.ts b/src/mumble/mumble_it.ts index 7e03557a63a..c420492de83 100644 --- a/src/mumble/mumble_it.ts +++ b/src/mumble/mumble_it.ts @@ -1239,6 +1239,30 @@ Questo valore ti permette di impostare il numero massimo di utenti consentiti ne <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). <b>Questo mostra il picco di banda utilizzata in uscita.</b><br />Questo mostra il picco di banda in uscita dalla tua macchina. Il bitrate audio è il massimo bitrate solamente relativo ai dati audio. "Posizione" indica il bitrate usato per le informazioni posizionali. L'overhead è costituito dall'incapsulamento e dalle intestazioni IP dei pacchetti (IP e UDP rappresentano il 75% di questo overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Parla ad alta voce, come quando sei infastidito o eccitato. Poi diminuisci il vo This visually represents the positional audio that is currently being played Rappresenta la posizione dell'audio che è in riproduzione al momento + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_ja.ts b/src/mumble/mumble_ja.ts index fc72386a94f..8ffad9883f9 100644 --- a/src/mumble/mumble_ja.ts +++ b/src/mumble/mumble_ja.ts @@ -1240,6 +1240,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2306,6 +2330,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_ko.ts b/src/mumble/mumble_ko.ts index fd1cbe8122b..bc03959829e 100644 --- a/src/mumble/mumble_ko.ts +++ b/src/mumble/mumble_ko.ts @@ -1239,6 +1239,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_lt.ts b/src/mumble/mumble_lt.ts index f97957e7cee..4766b72d58d 100644 --- a/src/mumble/mumble_lt.ts +++ b/src/mumble/mumble_lt.ts @@ -1235,6 +1235,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2299,6 +2323,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_nl.ts b/src/mumble/mumble_nl.ts index f2c9abe6884..ab7a31dfdee 100644 --- a/src/mumble/mumble_nl.ts +++ b/src/mumble/mumble_nl.ts @@ -1239,6 +1239,30 @@ Deze waarde laat je toe om een maximum aantal gebruikers in te stellen voor het <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Spreek vervolgens luid, zoals je zou spreken als je geïrriteerd of opgewonden b This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_no.ts b/src/mumble/mumble_no.ts index 6992c1a8d36..28226613d60 100644 --- a/src/mumble/mumble_no.ts +++ b/src/mumble/mumble_no.ts @@ -1239,6 +1239,30 @@ Denne verdien gjør at du setter maksimalt antall brukere tillatt i kanalen. Hvi <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2323,6 +2347,22 @@ Ingen snakking. Krysset (Definitivt ikke tale) This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_oc.ts b/src/mumble/mumble_oc.ts index 62a61e74219..e7cc115854e 100644 --- a/src/mumble/mumble_oc.ts +++ b/src/mumble/mumble_oc.ts @@ -1232,6 +1232,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2278,6 +2302,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_pl.ts b/src/mumble/mumble_pl.ts index 64fce966348..81cb9e214cb 100644 --- a/src/mumble/mumble_pl.ts +++ b/src/mumble/mumble_pl.ts @@ -1239,6 +1239,30 @@ Określa maksymalną dozwoloną liczbę użytkowników na tym kanale. Jeżeli wa <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). <b>Pokazuje szczytowe wykorzystanie przepustowości wychodzącej.</b><br />Pokazuje szczytową wielkość przepustowości wysyłanej z komputera. Szybkość transmisji audio to maksymalna szybkość transmisji samych danych audio. Pozycja to szybkość transmisji używana dla informacji o położeniu. Narzutem jest ramkowanie i nagłówki pakietów IP (IP i UDP stanowią 75% tego narzutu). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Mów głośno, tak jakbyś był wkurzony lub podekscytowany. Zmniejsz głośnoś This visually represents the positional audio that is currently being played Wizualnie przedstawia to dźwięk pozycyjny, który jest aktualnie odtwarzany + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_pt_BR.ts b/src/mumble/mumble_pt_BR.ts index 41ff3da98a4..85ac337342e 100644 --- a/src/mumble/mumble_pt_BR.ts +++ b/src/mumble/mumble_pt_BR.ts @@ -1239,6 +1239,30 @@ Este valor permite que você especifique o número máximo de usuários permitid <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). <b>Exibe o pico de uso de largura de banda de saída.</b><br />Exibe a quantidade máxima de largura de banda enviada do seu dispositivo. A taxa de bits de áudio representa o valor máximo somente para os dados de áudio. Posição é a taxa de bits utilizada para informações de posição. Sobrecarga é o nosso enquadramento e cabeçalhos de pacotes de IP (IP e UDP representam 75% dessa sobrecarga). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Fale alto, como quando você está incomodado ou animado. Diminua o volume no pa This visually represents the positional audio that is currently being played Representa visualmente o áudio posicional que está sendo reproduzido no momento + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_pt_PT.ts b/src/mumble/mumble_pt_PT.ts index 8781d7dfbf7..24088d449d7 100644 --- a/src/mumble/mumble_pt_PT.ts +++ b/src/mumble/mumble_pt_PT.ts @@ -1239,6 +1239,30 @@ Este valor permite definir o número máximo de utilizadores permitido no canal. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Fale alto, como quando está incomodado ou animado. Diminua o volume no painel d This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_ro.ts b/src/mumble/mumble_ro.ts index 05d4cd91321..f9bef9bc09f 100644 --- a/src/mumble/mumble_ro.ts +++ b/src/mumble/mumble_ro.ts @@ -1239,6 +1239,30 @@ Această valoare vă permite să setați numărul maxim de utilizatori permis î <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2285,6 +2309,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_ru.ts b/src/mumble/mumble_ru.ts index dab51179d1a..6449d7ae5c0 100644 --- a/src/mumble/mumble_ru.ts +++ b/src/mumble/mumble_ru.ts @@ -1239,6 +1239,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). <b>Это показывает пиковую используемую исходящую полосу пропускания.</b><br />Здесь показан пиковый объем полосы пропускания, передаваемый с вашего компьютера. Битрейт аудио - максимальный битрейт только для аудиоданных. Позиция - битрейт, используемый для позиционной информации. Накладные расходы - это наше кадрирование и заголовки IP-пакетов (на IP и UDP приходится 75 % этих накладных расходов). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played Это визуальное представление позиционного аудио, которое воспроизводится в данный момент + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_si.ts b/src/mumble/mumble_si.ts index ab08ed89903..5c09e30e328 100644 --- a/src/mumble/mumble_si.ts +++ b/src/mumble/mumble_si.ts @@ -1227,6 +1227,30 @@ Contains the list of members inherited by the current channel. Uncheck <i> <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2260,6 +2284,22 @@ Mumble is under continuous development, and the development team wants to focus This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_sk.ts b/src/mumble/mumble_sk.ts index 210782b206d..7af292ba938 100644 --- a/src/mumble/mumble_sk.ts +++ b/src/mumble/mumble_sk.ts @@ -1230,6 +1230,30 @@ Contains the list of members inherited by the current channel. Uncheck <i> <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2263,6 +2287,22 @@ Mumble is under continuous development, and the development team wants to focus This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_sq.ts b/src/mumble/mumble_sq.ts index bf792cd97d6..4f97723d7fa 100644 --- a/src/mumble/mumble_sq.ts +++ b/src/mumble/mumble_sq.ts @@ -1233,6 +1233,30 @@ Contains the list of members inherited by the current channel. Uncheck <i> <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2266,6 +2290,22 @@ Mumble is under continuous development, and the development team wants to focus This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_sv.ts b/src/mumble/mumble_sv.ts index 8ee33c44661..7ff2266e093 100644 --- a/src/mumble/mumble_sv.ts +++ b/src/mumble/mumble_sv.ts @@ -1239,6 +1239,30 @@ Det värdet tillåter dig att ställa in ett maximalt antal av användare som ä <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Tala högt, som om du är irriterad eller upphetsad. Minska volymen i kontrollpa This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_te.ts b/src/mumble/mumble_te.ts index 8d44cdb11e7..6dc59f51c15 100644 --- a/src/mumble/mumble_te.ts +++ b/src/mumble/mumble_te.ts @@ -1237,6 +1237,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2283,6 +2307,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_th.ts b/src/mumble/mumble_th.ts index 66c9169181b..c8b3503dfd8 100644 --- a/src/mumble/mumble_th.ts +++ b/src/mumble/mumble_th.ts @@ -1231,6 +1231,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2277,6 +2301,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_tr.ts b/src/mumble/mumble_tr.ts index 2be0c9604cd..aac7e11c2be 100644 --- a/src/mumble/mumble_tr.ts +++ b/src/mumble/mumble_tr.ts @@ -1239,6 +1239,30 @@ Bu değer kanalda izin verilen azami kullanıcı sayısını ayarlamanıza izin <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). <b>Bu, kullanılan en yüksek giden bant genişliğini gösterir.</b><br />Bu, makinenizden gönderilen en yüksek bant genişliği miktarını gösterir. Ses bit hızı, yalnızca ses verileri için en yüksek bit hızıdır. Konum, konumsal bilgiler için kullanılan bit hızıdır. Ek yük bizim çerçeveleme ve IP paket başlıklarımızdır (IP ve UDP bu ek yükün %75'idir). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Sinirli ya da coştuğunuz zamanlardaki gibi yüksek sesle konuşunuz. Kontrol p This visually represents the positional audio that is currently being played Bu, görsel olarak şimdi çalınan konumsal sesi temsil eder + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_uk.ts b/src/mumble/mumble_uk.ts index 09133e20d4c..e7b7ff4e5d0 100644 --- a/src/mumble/mumble_uk.ts +++ b/src/mumble/mumble_uk.ts @@ -1239,6 +1239,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). <b>Це показує максимальну вихідну пропускну здатність, що використовується.</b><br />Це показує максимальну пропускну здатність, надіслану з вашого комп’ютера. Бітрейт аудіо – це максимальний бітрейт лише для аудіоданих. Позиція – це бітрейт, який використовується для позиційної інформації. Накладні витрати — це наше кадрування та заголовки IP-пакетів (IP і UDP становлять 75% цих накладних витрат). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played Це візуально представляє позиційне аудіо, яке зараз відтворюється + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_zh_CN.ts b/src/mumble/mumble_zh_CN.ts index 50e2d4a1987..a87ca3abfac 100644 --- a/src/mumble/mumble_zh_CN.ts +++ b/src/mumble/mumble_zh_CN.ts @@ -1239,6 +1239,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). <b>显示所用的最大传出带宽。</b><br />显示从您机器发出的带宽的最大值。音频比特率是音频数据本身的最大比特率。位置是定位信息所用的比特率。开销是我们的帧结构和 IP 数据包头（IP 和 UDP 是开销的 75%）。 + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2309,6 +2333,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played 可视化展示当前播放的定位音频 + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_zh_HK.ts b/src/mumble/mumble_zh_HK.ts index 4dd7d9578c5..671566c4ec5 100644 --- a/src/mumble/mumble_zh_HK.ts +++ b/src/mumble/mumble_zh_HK.ts @@ -1231,6 +1231,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2277,6 +2301,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog diff --git a/src/mumble/mumble_zh_TW.ts b/src/mumble/mumble_zh_TW.ts index 2039b91111a..5dfedaee418 100644 --- a/src/mumble/mumble_zh_TW.ts +++ b/src/mumble/mumble_zh_TW.ts @@ -1234,6 +1234,30 @@ This value allows you to set the maximum number of users allowed in the channel. <b>This shows peak outgoing bandwidth used.</b><br />This shows the peak amount of bandwidth sent out from your machine. Audio bitrate is the maximum bitrate for the audio data alone. Position is the bitrate used for positional information. Overhead is our framing and the IP packet headers (IP and UDP is 75% of this overhead). + + Use WebRTC GMM based speech detection + + + + <b>This sets speech detection to use the WebRTC VAD algorithm.</b><br />In this mode, a configuration-free Gaussian Mixture Model is used to detect speech. + + + + WebRTC GMM + + + + Aggressiveness + + + + Controls aggressiveness of WebRTC VAD + + + + Higher values make the VAD more aggressive in filtering noise. + + AudioInputDialog @@ -2298,6 +2322,22 @@ Speak loudly, as when you are annoyed or excited. Decrease the volume in the sou This visually represents the positional audio that is currently being played + + Next you need to choose the voice detection sensitivity. The aggressiveness level controls how strictly speech is detected. Lower levels are more permissive and will pick up quiet or distant speech, but may also trigger on background noise. Higher levels are more strict and will better filter out noise, but may cut off softer speech. + + + + Voice activity detection aggressiveness level + + + + This will set the aggressiveness in which Mumble will consider a signal speech. Increase value to make voice activation less sensitive. + + + + WebRTC GMM + + BanDialog