Fix FunASR-Nano hallucinating text on silent audio

sherpa-onnx/csrc/CMakeLists.txt

@@ -831,6 +831,7 @@ if(SHERPA_ONNX_ENABLE_TESTS)
     lfr-test.cc
     math-test.cc
     offline-recognizer-cohere-transcribe-impl-test.cc
+    offline-recognizer-funasr-nano-impl-test.cc
     offline-recognizer-moonshine-v2-impl-test.cc
     offline-recognizer-qwen3-asr-impl-test.cc
     offline-recognizer-shared-rng-test.cc

sherpa-onnx/csrc/offline-recognizer-funasr-nano-impl-test.cc

@@ -0,0 +1,54 @@
+// sherpa-onnx/csrc/offline-recognizer-funasr-nano-impl-test.cc
+//
+// Copyright (c)  2026  kyo-zzz
+
+#include "sherpa-onnx/csrc/offline-recognizer-funasr-nano-impl.h"
+
+#include <vector>
+
+#include "gtest/gtest.h"
+
+namespace sherpa_onnx {
+
+// Digital silence produces constant fbank frames (dither is disabled for this
+// model family), so FunASRNanoAudioIsSilent() must report silence for them
+// and signal for any varying content. DecodeStreams() uses this to return an
+// empty transcript before hotwords/language prompt tokens can bias the LLM
+// decoder into hallucinating text for silent audio, mirroring the Qwen3-ASR
+// recognizer.
+TEST(FunASRNanoAudioIsSilent, ConstantFramesAreSilence) {
+  // LFR stacks feature_dim*window floats per output frame; the values are
+  // identical for a constant input.
+  std::vector<float> features = {2.5f, 2.5f, 2.5f, 2.5f, 2.5f, 2.5f};
+  EXPECT_TRUE(FunASRNanoAudioIsSilent(features.data(), features.size()));
+}
+
+TEST(FunASRNanoAudioIsSilent, RepeatedNonUniformFramesAreSignal) {
+  // alternating values still vary frame to frame, so this is signal
+  std::vector<float> features = {1.0f, 2.0f, 1.0f, 2.0f};
+  EXPECT_FALSE(FunASRNanoAudioIsSilent(features.data(), features.size()));
+}
+
+TEST(FunASRNanoAudioIsSilent, VaryingFramesAreSignal) {
+  std::vector<float> features = {2.5f, 2.5f, -1.25f, 2.5f, 2.5f, 2.5f};
+  EXPECT_FALSE(FunASRNanoAudioIsSilent(features.data(), features.size()));
+}
+
+TEST(FunASRNanoAudioIsSilent, ZerosAreSilence) {
+  std::vector<float> features(64, 0.0f);
+  EXPECT_TRUE(FunASRNanoAudioIsSilent(features.data(), features.size()));
+}
+
+TEST(FunASRNanoAudioIsSilent, SingleValueIsSilence) {
+  // A single frame carries no variation to inspect.
+  std::vector<float> features = {2.5f};
+  EXPECT_TRUE(FunASRNanoAudioIsSilent(features.data(), features.size()));
+}
+
+TEST(FunASRNanoAudioIsSilent, EmptyInputIsNotSilence) {
+  // An empty input is handled by the caller (num_frames <= 0), not here.
+  float unused = 0;
+  EXPECT_FALSE(FunASRNanoAudioIsSilent(&unused, 0));
+}
+
+}  // namespace sherpa_onnx

sherpa-onnx/csrc/offline-recognizer-funasr-nano-impl.cc

@@ -177,6 +177,21 @@ static std::string BuildUserPrompt(const std::vector<std::string> &hotwords,
 
 }  // namespace
 
+bool FunASRNanoAudioIsSilent(const float *features, int32_t n) {
+  if (n <= 0) {
+    return false;
+  }
+
+  const float v0 = features[0];
+  for (int32_t i = 1; i != n; ++i) {
+    if (features[i] != v0) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 OfflineRecognizerFunASRNanoImpl::OfflineRecognizerFunASRNanoImpl(
     const OfflineRecognizerConfig &config)
     : OfflineRecognizerImpl(config),
@@ -868,6 +883,15 @@ void OfflineRecognizerFunASRNanoImpl::DecodeStreams(OfflineStream **ss,
       continue;
     }
 
+    if (FunASRNanoAudioIsSilent(f.data(), static_cast<int32_t>(f.size()))) {
+      // The whole clip is silence. Return an empty result now, before any
+      // hotwords/language prompt tokens are built, so they cannot bias the
+      // LLM decoder into hallucinating text for silent audio.
+      OfflineRecognitionResult r;
+      ss[i]->SetResult(r);
+      continue;
+    }
+
     std::array<int64_t, 3> shape{1, num_frames,
                                  static_cast<int64_t>(f.size() / num_frames)};
 

sherpa-onnx/csrc/offline-recognizer-funasr-nano-impl.h

@@ -22,6 +22,14 @@
 
 namespace sherpa_onnx {
 
+// Returns true when the (LFR-stacked) fbank frames are all identical, which
+// for this model family means the clip is digital silence: dither is disabled
+// and the fbank is deterministic, so constant samples produce constant frames
+// while any real signal varies from frame to frame.
+//
+// Exposed here (rather than kept file-local) so it can be unit tested.
+bool FunASRNanoAudioIsSilent(const float *features, int32_t n);
+
 class OfflineRecognizerFunASRNanoImpl : public OfflineRecognizerImpl {
  public:
   explicit OfflineRecognizerFunASRNanoImpl(