show RNNoise option.

bygreencn · bygreencn · commit 642f37570707 · 2024-06-30T21:21:51.000+08:00
diff --git a/examples/common-portaudio.cpp b/examples/common-portaudio.cpp
@@ -20,8 +20,9 @@ audio_async::audio_async()
     m_pInParamsRecord(NULL),
     m_pParamsRecord(NULL),
     m_pStreamRecord(NULL),
-    m_running(false){
-    m_pAudioBuffer = new AudioBuffer<float>((size_t)(OUTPOUT_SAMPLE_RATE * 300));
+    m_running(false),
+    m_pAudioBuffer(NULL)
+{
     m_psys = &portaudio::System::instance();
 }
 
@@ -48,7 +49,7 @@ audio_async::~audio_async() {
     }
 }
 
-bool audio_async::init(int iInputDevice, uint8_t save_audio){
+bool audio_async::init(int iInputDevice, uint8_t save_audio, bool enable_rnnoise){
 
     try
 	{
@@ -82,6 +83,10 @@ bool audio_async::init(int iInputDevice, uint8_t save_audio){
             std::cout << strDetails.c_str() << std::endl;
         }
 #endif
+        m_pAudioBuffer = new AudioBuffer<float>((size_t)(OUTPOUT_SAMPLE_RATE * 300), enable_rnnoise);
+        
+        if (NULL == m_pAudioBuffer)
+            return false;
    
         m_pAudioBuffer->setSaveAudioFlag(save_audio);
 
diff --git a/examples/common-portaudio.h b/examples/common-portaudio.h
@@ -712,7 +712,7 @@ template<typename T>
 class AudioBuffer : public CircularQueue<T>
 {
 	public:
-    	AudioBuffer(size_t capacity) : CircularQueue<T>(capacity), 
+    	AudioBuffer(size_t capacity, bool enable_rnnoise = true) : CircularQueue<T>(capacity), 
                                         srcState(NULL), 
                                         resample_outputBuffer(NULL), 
                                         m_un8SaveAudioFlag(0)
@@ -736,10 +736,14 @@ class AudioBuffer : public CircularQueue<T>
 			src_data.end_of_input = 0;
 			src_data.src_ratio = (double)OUTPOUT_SAMPLE_RATE / INPUT_SAMPLE_RATE;
 
-           
-            if (!rnnoise.available())
-            {
-                cout << "AudioBuffer::RNNoise was NULL!" << endl;
+
+            m_bEnableRnnoise = enable_rnnoise;
+            if (m_bEnableRnnoise)
+            { 
+                if (!rnnoise.available())
+                {
+                    cout << "AudioBuffer::RNNoise was NULL!" << endl;
+                }
             }
 		};
 		~AudioBuffer() {
@@ -755,7 +759,7 @@ class AudioBuffer : public CircularQueue<T>
             {
                 wavWriterRaw.close();
             }
-            if (m_un8SaveAudioFlag & SAVE_AUDIO_RNNOISED)
+            if (this->m_bEnableRnnoise && m_un8SaveAudioFlag & SAVE_AUDIO_RNNOISED)
             {
                 wavWriterRnnoised.close();
             }
@@ -790,13 +794,13 @@ class AudioBuffer : public CircularQueue<T>
                 wavWriterRaw.write(pData[0], iFramesPerBuffer);
             }
 
-            if (rnnoise.available())
+            if (m_bEnableRnnoise && rnnoise.available())
             {
                 rnnoise.process(pData[0], iFramesPerBuffer);
             }
 
 
-            if (m_un8SaveAudioFlag & SAVE_AUDIO_RNNOISED)
+            if (m_bEnableRnnoise && m_un8SaveAudioFlag & SAVE_AUDIO_RNNOISED)
             {
                 this->wavWriterRnnoised.write(pData[0], iFramesPerBuffer);// Copy all the frames over to our internal vector of samples
             }
@@ -860,7 +864,7 @@ class AudioBuffer : public CircularQueue<T>
                 std::string filename = std::string(buffer) + "_raw.wav";
                 wavWriterRaw.open(filename, (uint32_t)INPUT_SAMPLE_RATE, 32, 1);
             }
-            if (m_un8SaveAudioFlag & SAVE_AUDIO_RNNOISED)
+            if (this->m_bEnableRnnoise && m_un8SaveAudioFlag & SAVE_AUDIO_RNNOISED)
             {
                 std::string filename = std::string(buffer) + "_rnnoise.wav";
                 wavWriterRnnoised.open(filename, (uint32_t)INPUT_SAMPLE_RATE, 32, 1);
@@ -883,6 +887,7 @@ class AudioBuffer : public CircularQueue<T>
     	float              *resample_outputBuffer;
     	SRC_DATA            src_data;
         // RNN-based noise suppression
+        bool m_bEnableRnnoise;
         RNNoiseIterator rnnoise;
 
 public:
@@ -904,7 +909,7 @@ class audio_async {
     audio_async(); 
     ~audio_async();
 
-    bool init(int iInputDevice, uint8_t save_audio = 0);
+    bool init(int iInputDevice, uint8_t save_audio = 0, bool enable_rnnoise = true);
 
     // start capturing audio via the provided SDL callback
     // keep last len_ms seconds of audio in a circular buffer
diff --git a/examples/stream-portaudio/stream-portaudio.cpp b/examples/stream-portaudio/stream-portaudio.cpp
@@ -70,6 +70,7 @@ struct whisper_params {
     std::string language  = "zh";
     std::string model     = "models/ggml-base-q5_1.bin";
     std::string fname_out;
+    bool enable_rnnoise = true;
 };
 
 void whisper_print_usage(int argc, const char ** argv, const whisper_params & params);
@@ -102,6 +103,7 @@ bool whisper_params_parse(int argc, const char ** argv, whisper_params & params)
         else if (arg == "-sa"   || arg == "--save-audio")    { params.save_audio    = std::stoi(argv[++i]); }
         else if (arg == "-ng"   || arg == "--no-gpu")        { params.use_gpu       = false; }
         else if (arg == "-fa"   || arg == "--flash-attn")    { params.flash_attn    = true; }
+        else if (arg == "-nr"   || arg == "--no-rnnoise")    { params.enable_rnnoise = false; }
 
         else {
             fprintf(stderr, "error: unknown argument: %s\n", arg.c_str());
@@ -139,6 +141,7 @@ void whisper_print_usage(int /*argc*/, const char ** argv, const whisper_params
     fprintf(stderr, "  -sa,      --save-audio    [%-7x] save the recorded audio to a file\n",              params.save_audio);
     fprintf(stderr, "  -ng,      --no-gpu        [%-7s] disable GPU inference\n",                          params.use_gpu ? "false" : "true");
     fprintf(stderr, "  -fa,      --flash-attn    [%-7s] flash attention during inference\n",               params.flash_attn ? "true" : "false");
+    fprintf(stderr, "  -nr,      --no-rnnoise    [%-7s] disable RNNoise\n",                                params.enable_rnnoise ? "true" : "false");
     fprintf(stderr, "\n");
 }
 
@@ -173,7 +176,7 @@ int run(int argc, const char ** argv) {
     // init audio
 
     audio_async audio;
-    if (!audio.init(params.capture_id, params.save_audio)) {
+    if (!audio.init(params.capture_id, params.save_audio, params.enable_rnnoise)) {
         printf("%s: audio.init() failed!\n", __func__);
         return 1;
     }

Original file line number	Diff line number	Diff line change
`@@ -20,8 +20,9 @@ audio_async::audio_async()`
`20`	`20`	`m_pInParamsRecord(NULL),`
`21`	`21`	`m_pParamsRecord(NULL),`
`22`	`22`	`m_pStreamRecord(NULL),`
`23`		`- m_running(false){`
`24`		`- m_pAudioBuffer = new AudioBuffer<float>((size_t)(OUTPOUT_SAMPLE_RATE * 300));`
	`23`	`+ m_running(false),`
	`24`	`+ m_pAudioBuffer(NULL)`
	`25`	`+{`
`25`	`26`	`m_psys = &portaudio::System::instance();`
`26`	`27`	`}`
`27`	`28`
`@@ -48,7 +49,7 @@ audio_async::~audio_async() {`
`48`	`49`	`}`
`49`	`50`	`}`
`50`	`51`
`51`		`-bool audio_async::init(int iInputDevice, uint8_t save_audio){`
	`52`	`+bool audio_async::init(int iInputDevice, uint8_t save_audio, bool enable_rnnoise){`
`52`	`53`
`53`	`54`	`try`
`54`	`55`	`{`
`@@ -82,6 +83,10 @@ bool audio_async::init(int iInputDevice, uint8_t save_audio){`
`82`	`83`	`std::cout << strDetails.c_str() << std::endl;`
`83`	`84`	`}`
`84`	`85`	`#endif`
	`86`	`+ m_pAudioBuffer = new AudioBuffer<float>((size_t)(OUTPOUT_SAMPLE_RATE * 300), enable_rnnoise);`
	`87`	`+`
	`88`	`+ if (NULL == m_pAudioBuffer)`
	`89`	`+ return false;`
`85`	`90`
`86`	`91`	`m_pAudioBuffer->setSaveAudioFlag(save_audio);`
`87`	`92`
Original file line number	Diff line number	Diff line change
`@@ -712,7 +712,7 @@ template<typename T>`
`712`	`712`	`class AudioBuffer : public CircularQueue<T>`
`713`	`713`	`{`
`714`	`714`	`public:`
`715`		`- AudioBuffer(size_t capacity) : CircularQueue<T>(capacity),`
	`715`	`+ AudioBuffer(size_t capacity, bool enable_rnnoise = true) : CircularQueue<T>(capacity),`
`716`	`716`	`srcState(NULL),`
`717`	`717`	`resample_outputBuffer(NULL),`
`718`	`718`	`m_un8SaveAudioFlag(0)`
`@@ -736,10 +736,14 @@ class AudioBuffer : public CircularQueue<T>`
`736`	`736`	`src_data.end_of_input = 0;`
`737`	`737`	`src_data.src_ratio = (double)OUTPOUT_SAMPLE_RATE / INPUT_SAMPLE_RATE;`
`738`	`738`
`739`		`-`
`740`		`- if (!rnnoise.available())`
`741`		`- {`
`742`		`- cout << "AudioBuffer::RNNoise was NULL!" << endl;`
	`739`	`+`
	`740`	`+ m_bEnableRnnoise = enable_rnnoise;`
	`741`	`+ if (m_bEnableRnnoise)`
	`742`	`+ {`
	`743`	`+ if (!rnnoise.available())`
	`744`	`+ {`
	`745`	`+ cout << "AudioBuffer::RNNoise was NULL!" << endl;`
	`746`	`+ }`
`743`	`747`	`}`
`744`	`748`	`};`
`745`	`749`	`~AudioBuffer() {`
`@@ -755,7 +759,7 @@ class AudioBuffer : public CircularQueue<T>`
`755`	`759`	`{`
`756`	`760`	`wavWriterRaw.close();`
`757`	`761`	`}`
`758`		`- if (m_un8SaveAudioFlag & SAVE_AUDIO_RNNOISED)`
	`762`	`+ if (this->m_bEnableRnnoise && m_un8SaveAudioFlag & SAVE_AUDIO_RNNOISED)`
`759`	`763`	`{`
`760`	`764`	`wavWriterRnnoised.close();`
`761`	`765`	`}`
`@@ -790,13 +794,13 @@ class AudioBuffer : public CircularQueue<T>`
`790`	`794`	`wavWriterRaw.write(pData[0], iFramesPerBuffer);`
`791`	`795`	`}`
`792`	`796`
`793`		`- if (rnnoise.available())`
	`797`	`+ if (m_bEnableRnnoise && rnnoise.available())`
`794`	`798`	`{`
`795`	`799`	`rnnoise.process(pData[0], iFramesPerBuffer);`
`796`	`800`	`}`
`797`	`801`
`798`	`802`
`799`		`- if (m_un8SaveAudioFlag & SAVE_AUDIO_RNNOISED)`
	`803`	`+ if (m_bEnableRnnoise && m_un8SaveAudioFlag & SAVE_AUDIO_RNNOISED)`
`800`	`804`	`{`
`801`	`805`	`this->wavWriterRnnoised.write(pData[0], iFramesPerBuffer);// Copy all the frames over to our internal vector of samples`
`802`	`806`	`}`
`@@ -860,7 +864,7 @@ class AudioBuffer : public CircularQueue<T>`
`860`	`864`	`std::string filename = std::string(buffer) + "_raw.wav";`
`861`	`865`	`wavWriterRaw.open(filename, (uint32_t)INPUT_SAMPLE_RATE, 32, 1);`
`862`	`866`	`}`
`863`		`- if (m_un8SaveAudioFlag & SAVE_AUDIO_RNNOISED)`
	`867`	`+ if (this->m_bEnableRnnoise && m_un8SaveAudioFlag & SAVE_AUDIO_RNNOISED)`
`864`	`868`	`{`
`865`	`869`	`std::string filename = std::string(buffer) + "_rnnoise.wav";`
`866`	`870`	`wavWriterRnnoised.open(filename, (uint32_t)INPUT_SAMPLE_RATE, 32, 1);`
`@@ -883,6 +887,7 @@ class AudioBuffer : public CircularQueue<T>`
`883`	`887`	`float *resample_outputBuffer;`
`884`	`888`	`SRC_DATA src_data;`
`885`	`889`	`// RNN-based noise suppression`
	`890`	`+ bool m_bEnableRnnoise;`
`886`	`891`	`RNNoiseIterator rnnoise;`
`887`	`892`
`888`	`893`	`public:`
`@@ -904,7 +909,7 @@ class audio_async {`
`904`	`909`	`audio_async();`
`905`	`910`	`~audio_async();`
`906`	`911`
`907`		`- bool init(int iInputDevice, uint8_t save_audio = 0);`
	`912`	`+ bool init(int iInputDevice, uint8_t save_audio = 0, bool enable_rnnoise = true);`
`908`	`913`
`909`	`914`	`// start capturing audio via the provided SDL callback`
`910`	`915`	`// keep last len_ms seconds of audio in a circular buffer`