Add a noise indicator to the speech bubble volume indicator.

content/browser/speech/speech_recognizer.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/speech/speech_recognizer.h"
 
 #include "base/time.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/net/url_request_context_getter.h"
 #include "content/browser/browser_thread.h"
 
 using media::AudioInputController;
 using std::string;
 
 namespace {
 
 // The following constants are related to the volume level indicator shown in
 // the UI for recorded audio.
 // Multiplier used when new volume is greater than previous level.
-const float kUpSmoothingFactor = 0.9f;
+const float kUpSmoothingFactor = 1.0f;
 // Multiplier used when new volume is lesser than previous level.
-const float kDownSmoothingFactor = 0.4f;
-const float kAudioMeterMinDb = 10.0f;  // Lower bar for volume meter.
-const float kAudioMeterDbRange = 25.0f;
+const float kDownSmoothingFactor = 0.7f;
+// RMS dB value of a maximum (unclipped) sine wave for int16 samples.
+const float kAudioMeterMaxDb = 90.31f;
+// This value corresponds to RMS dB for int16 with 6 most-significant-bits = 0.
+// Values lower than this will display as empty level-meter.
+const float kAudioMeterMinDb = 60.21f;
+const float kAudioMeterDbRange = kAudioMeterMaxDb - kAudioMeterMinDb;
+
+// Maximum level to draw to display unclipped meter. (1.0f displays clipping.)
+const float kAudioMeterRangeMaxUnclipped = 47.0f / 48.0f;
+
+// Returns true if more than 5% of the samples are at min or max value.
+bool Clipping(const int16* samples, int num_samples) {
+  int clipping_samples = 0;
+  for (int i = 0; i < num_samples; ++i) {
+    if (samples[i] <= -32767 || samples[i] >= 32767) {
+      ++clipping_samples;

[bulach, 2011/03/01 17:39:04]

you may want to short circuit rather than traverse the whole thing all the
time..
const int kThreshold = num_samples / 20;
for (...) {
  if (samples[i] ... ) {
    if (++clipping_samples > kThreshold)
      return true;
  }
}
return false;

+    }
+  }
+  return clipping_samples > (num_samples / 20);
+}
+
 }  // namespace
 
 namespace speech_input {
 
 const int SpeechRecognizer::kAudioSampleRate = 16000;
 const int SpeechRecognizer::kAudioPacketIntervalMs = 100;
 const int SpeechRecognizer::kNumAudioChannels = 1;
 const int SpeechRecognizer::kNumBitsPerAudioSample = 16;
 const int SpeechRecognizer::kNoSpeechTimeoutSec = 8;
 const int SpeechRecognizer::kEndpointerEstimationTimeMs = 300;
@@ skipping 178 matching lines @@
 
   // Check if we have waited too long without hearing any speech.
   if (!endpointer_.DidStartReceivingSpeech() &&
       num_samples_recorded_ >= kNoSpeechTimeoutSec * kAudioSampleRate) {
     InformErrorAndCancelRecognition(RECOGNIZER_ERROR_NO_SPEECH);
     return;
   }
 
   // Calculate the input volume to display in the UI, smoothing towards the
   // new level.
-  float level = (rms - kAudioMeterMinDb) / kAudioMeterDbRange;
-  level = std::min(std::max(0.0f, level), 1.0f);
+  float level = (rms - kAudioMeterMinDb) /
+      (kAudioMeterDbRange / kAudioMeterRangeMaxUnclipped);
+  level = std::min(std::max(0.0f, level), kAudioMeterRangeMaxUnclipped);
   if (level > audio_level_) {
     audio_level_ += (level - audio_level_) * kUpSmoothingFactor;
   } else {
     audio_level_ += (level - audio_level_) * kDownSmoothingFactor;
   }
-  delegate_->SetInputVolume(caller_id_, audio_level_);
+
+  float noise_level = (endpointer_.NoiseLevelDB() - kAudioMeterMinDb) /
+      (kAudioMeterDbRange / kAudioMeterRangeMaxUnclipped);
+  noise_level = std::min(std::max(0.0f, noise_level),
+      kAudioMeterRangeMaxUnclipped);
+
+  delegate_->SetInputVolume(caller_id_,
+      Clipping(samples, num_samples) ? 1.0f : audio_level_, noise_level);
 
   if (endpointer_.speech_input_complete()) {
     StopRecording();
   }
 
   // TODO(satish): Once we have streaming POST, start sending the data received
   // here as POST chunks.
 }
 
 void SpeechRecognizer::SetRecognitionResult(
@@ skipping 12 matching lines @@
 
 void SpeechRecognizer::InformErrorAndCancelRecognition(ErrorCode error) {
   CancelRecognition();
 
   // Guard against the delegate freeing us until we finish our job.
   scoped_refptr<SpeechRecognizer> me(this);
   delegate_->OnRecognizerError(caller_id_, error);
 }
 
 }  // namespace speech_input