Add detection for repeated audio in capturing.

content/renderer/media/media_stream_audio_processor.cc

 // Copyright 2013 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/renderer/media/media_stream_audio_processor.h"
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 11 matching lines @@
 
 namespace content {
 
 namespace {
 
 using webrtc::AudioProcessing;
 using webrtc::NoiseSuppression;
 
 const int kAudioProcessingNumberOfChannels = 1;
 
+// Minimum duration of any detectable audio repetition.
+const int kMinLengthMs = 1;
+
+// The following variables defines the look back time of audio repetitions that
+// will be logged. The complexity of the detector is proportional to the number
+// of look back times we keep track.
+const int kMinLookbackTimeMs = 10;
+const int kMaxLookbackTimeMs = 200;
+const int kLookbackTimeStepMs = 10;
+
+// Maximum frames of any input chunk of audio. Used by
+// |MediaStreamAudioProcessor::audio_repetition_detector_|. Input longer than
+// |kMaxFrames| won't cause any problem, and will only affect computational
+// efficiency.
+const size_t kMaxFrames = 480;  // 10 ms * 48 kHz
+
+// Send UMA report on an audio repetition being detected. |look_back_ms|
+// provides the look back time of the detected repetition. This function is
+// called back by |MediaStreamAudioProcessor::audio_repetition_detector_|.
+void ReportRepetition(int look_back_ms) {
+  UMA_HISTOGRAM_CUSTOM_COUNTS(
+      "Media.AudioCapturerRepetition", look_back_ms,
+      kMinLookbackTimeMs, kMaxLookbackTimeMs,
+      (kMaxLookbackTimeMs - kMinLookbackTimeMs) / kLookbackTimeStepMs + 1);
+}
+
 AudioProcessing::ChannelLayout MapLayout(media::ChannelLayout media_layout) {
   switch (media_layout) {
     case media::CHANNEL_LAYOUT_MONO:
       return AudioProcessing::kMono;
     case media::CHANNEL_LAYOUT_STEREO:
       return AudioProcessing::kStereo;
     case media::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC:
       return AudioProcessing::kStereoAndKeyboard;
     default:
       NOTREACHED() << "Layout not supported: " << media_layout;
@@ skipping 202 matching lines @@
   capture_thread_checker_.DetachFromThread();
   render_thread_checker_.DetachFromThread();
   InitializeAudioProcessingModule(constraints, input_params);
 
   aec_dump_message_filter_ = AecDumpMessageFilter::Get();
   // In unit tests not creating a message filter, |aec_dump_message_filter_|
   // will be NULL. We can just ignore that. Other unit tests and browser tests
   // ensure that we do get the filter when we should.
   if (aec_dump_message_filter_.get())
     aec_dump_message_filter_->AddDelegate(this);
+
+  // Create and configure |audio_repetition_detector_|.
+  std::vector<int> look_back_times;
+  for (int time = kMaxLookbackTimeMs; time >= kMinLookbackTimeMs;
+       time -= kLookbackTimeStepMs) {
+    look_back_times.push_back(time);
+  }
+  audio_repetition_detector_.reset(
+      new AudioRepetitionDetector(kMinLengthMs, kMaxFrames, &look_back_times[0],

[Henrik Grunell, 2015/10/23 13:49:02]

Instead of a ptr and size, let it take a const std::vector<int>&.

[minyue, 2015/10/26 10:41:46]

good,changed the signature

+                                  look_back_times.size(),
+                                  base::Bind(&ReportRepetition)));
 }
 
 MediaStreamAudioProcessor::~MediaStreamAudioProcessor() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   Stop();
 }
 
 void MediaStreamAudioProcessor::OnCaptureFormatChanged(
     const media::AudioParameters& input_format) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
@@ skipping 25 matching lines @@
   DCHECK(processed_data);
   DCHECK(capture_delay);
   DCHECK(new_volume);
 
   TRACE_EVENT0("audio", "MediaStreamAudioProcessor::ProcessAndConsumeData");
 
   MediaStreamAudioBus* process_bus;
   if (!capture_fifo_->Consume(&process_bus, capture_delay))
     return false;
 
+  // Detect bit-exact repetition of audio present in the captured audio.
+  // We detect only one channel.
+  audio_repetition_detector_->Detect(process_bus->bus()->channel(0),
+                                     process_bus->bus()->frames(),
+                                     1,  // number of channels
+                                     input_format_.sample_rate());
+
   // Use the process bus directly if audio processing is disabled.
   MediaStreamAudioBus* output_bus = process_bus;
   *new_volume = 0;
   if (audio_processing_) {
     output_bus = output_bus_.get();
     *new_volume = ProcessData(process_bus->channel_ptrs(),
                               process_bus->bus()->frames(), *capture_delay,
                               volume, key_pressed, output_bus->channel_ptrs());
   }
 
@@ skipping 369 matching lines @@
   if (echo_information_) {
     echo_information_.get()->UpdateAecDelayStats(ap->echo_cancellation());
   }
 
   // Return 0 if the volume hasn't been changed, and otherwise the new volume.
   return (agc->stream_analog_level() == volume) ?
       0 : agc->stream_analog_level();
 }
 
 }  // namespace content