Add detection for repeated audio in capturing.

content/renderer/media/audio_repetition_detector.cc

Index: content/renderer/media/audio_repetition_detector.cc
diff --git a/content/renderer/media/audio_repetition_detector.cc b/content/renderer/media/audio_repetition_detector.cc
new file mode 100644
index 0000000000000000000000000000000000000000..71902cea844f0834c808d53a09d145c74f5faa01
--- /dev/null
+++ b/content/renderer/media/audio_repetition_detector.cc
@@ -0,0 +1,170 @@
+// Copyright 2015 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/audio_repetition_detector.h"
+
+#include "base/logging.h"
+#include "base/macros.h"
+
+namespace content {
+
+AudioRepetitionDetector::AudioRepetitionDetector(
+    int min_length_ms, size_t max_frames,
+    const std::vector<int>& look_back_times,
+    const RepetitionCallback& repetition_callback)
+    : max_look_back_ms_(0),
+      min_length_ms_(min_length_ms),
+      sample_rate_(0),
+      buffer_size_frames_(0),
+      buffer_end_index_(0),
+      max_frames_(max_frames),
+      repetition_callback_(repetition_callback) {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+  processing_thread_checker_.DetachFromThread();
+
+  // Avoid duplications in |look_back_times| if any.

[tommi (sloooow) - chröme, 2015/10/30 15:33:01]

Since we always create a copy here, would it make sense to expect
look_back_times to be sorted already?
(and have a DCHECK for that)

[minyue, 2015/10/30 20:17:05]

being sorted or not is not essential (except for the fact that we need to find
out |max_look_back_ms_|), the goal is to avoid duplication. The reason or
std::sort is because std::unique needs to go with std::sort to avoid
duplication. And unique + sort is known as a most efficient way to remove
duplication.

We may consider DCHECK of duplication. But I am not aware of a light-weighted
check for duplication. Thus DCHECK of duplication may be of the same complexity
as just removing the duplication when there is (removing it is a almost free
lunch)

[Henrik Grunell, 2015/11/02 09:12:11]

I'm in favor of DCHECK-ing that it's sorted and no duplicates. You should be
able to check the current value is larger than the previous.

+  std::vector<int> temp(look_back_times);
+  std::sort(temp.begin(), temp.end());
+  temp.erase(std::unique(temp.begin(), temp.end()), temp.end());

[tommi (sloooow) - chröme, 2015/10/30 15:33:01]

I guess this is what Henrik commented on (will you address?)

[minyue, 2015/10/30 20:17:05]

You mean the nit Henrik pointed out: i.e., erase vs resize. I tried to search
about a comparison of the two, I don't find any. I am not aware of any benefit.

+
+  max_look_back_ms_ = temp.back();
+  for (auto look_back : temp) {

[tommi (sloooow) - chröme, 2015/10/30 15:33:01]

no {}

[tommi (sloooow) - chröme, 2015/10/30 15:33:01]

instead of auto, just use int here.  The way auto is being used raises "by
value" questions. Besides, 'int' is shorter than 'auto' ;)

[minyue, 2015/10/30 20:17:05]

Done.

[minyue, 2015/10/30 20:17:05]

Done.

+    states_.push_back(new State(look_back));
+  }
+}
+
+AudioRepetitionDetector::~AudioRepetitionDetector() {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+}
+
+void AudioRepetitionDetector::Detect(const float* data, size_t num_frames,
+                                     size_t num_channels, int sample_rate) {
+  DCHECK(processing_thread_checker_.CalledOnValidThread());
+  DCHECK(!states_.empty());
+
+  if (num_channels != num_channels_ || sample_rate != sample_rate_)
+    Reset(num_channels, sample_rate);
+
+  // The maximum number of frames |audio_buffer_| can take in is |max_frames_|.
+  // Therefore, input data with larger frames needs be divided into chunks.
+  const size_t chunk_size = max_frames_ * num_channels;
+  while (num_frames > max_frames_) {
+    Detect(data, max_frames_, num_channels, sample_rate);
+    data += chunk_size;
+    num_frames -= max_frames_;
+  }
+
+  if (num_frames == 0)
+    return;
+
+  AddFramesToBuffer(data, num_frames);
+
+  for (size_t idx = num_frames; idx > 0; --idx, data += num_channels) {
+    for (State* state : states_) {
+      // Look back position depends on the sample rate. It is rounded down to
+      // the closest integer.
+      const size_t look_back_frames =
+          state->look_back_ms() * sample_rate_ / 1000;
+      // Equal(data, offset) checks if |data| equals the audio frame located
+      // |offset| frames from the end of buffer. Now a full frame has been
+      // inserted to the buffer, and thus |offset| should compensate for it.
+      if (Equal(data, look_back_frames + idx)) {
+        if (!state->reported()) {
+          state->Increment(IsZero(data, num_channels));
+          if (HasValidReport(state)) {
+            repetition_callback_.Run(state->look_back_ms());
+            state->set_reported(true);
+          }
+        }
+      } else {
+        state->Reset();
+      }
+    }
+  }
+}
+
+AudioRepetitionDetector::State::State(int look_back_ms)
+    : look_back_ms_(look_back_ms) {
+  Reset();
+}
+
+void AudioRepetitionDetector::State::Increment(bool zero) {
+  if (0 == count_frames_ && zero) {

[tommi (sloooow) - chröme, 2015/10/30 15:33:01]

nit: convention is how you would read it: |count_frames_ == 0|

[minyue, 2015/10/30 20:17:05]

Done.

+    // If a repetition starts with zeros, we enter the all zero mode until
+    // a non zero is found later. The point is that the beginning zeros should
+    // be counted in the length of the repetition as long as the repetition does
+    // not comprise only zeros.
+    all_zero_ = true;
+  }
+  ++count_frames_;
+  if (!zero)

[tommi (sloooow) - chröme, 2015/10/30 15:33:01]

it feels a bit strange to check this flag twice in the same function.  what
about:

-----
if (zero) {
  if (count_frames_ == 0) {
    // <comment>
    all_zero_ = true;
  }
} else {
  all_zero_ = false;
}

++count_frames_;
-----

Btw, what is the expected value of all_zero_ at the end of this function if zero
is true but count_frames_ != 0?  (can it be whatever?)

[minyue, 2015/10/30 20:17:05]

thanks, it reads much better.

if zero is true but count_frames_ != 0, that means there are some 0s at the
beginning of a repetition, e.g.

 0 0 0 1 2 3 | 0 0 0 1 2 3 

This is still a valid 6-long repetition. Therefore at the beginning 0s, we allow
count_frames_ to grow but all_zero_ will true until we meet "1"

+    all_zero_ = false;
+}
+
+void AudioRepetitionDetector::State::Reset() {
+  count_frames_ = 0;
+  all_zero_ = true;
+  reported_ = false;
+}
+
+void AudioRepetitionDetector::Reset(size_t num_channels, int sample_rate) {
+  DCHECK(processing_thread_checker_.CalledOnValidThread());
+  num_channels_ = num_channels;
+  sample_rate_ = sample_rate;
+
+  // |(xxx + 999) / 1000| is an arithmetic way to round up |xxx / 1000|.
+  buffer_size_frames_ =
+      (max_look_back_ms_ * sample_rate_ + 999) / 1000 + max_frames_;
+
+  audio_buffer_.resize(buffer_size_frames_ * num_channels_);
+  for (State* state : states_)
+    state->Reset();
+}
+
+void AudioRepetitionDetector::AddFramesToBuffer(const float* data,
+                                                size_t num_frames) {
+  DCHECK(processing_thread_checker_.CalledOnValidThread());
+  DCHECK_LE(num_frames, buffer_size_frames_);
+  const size_t margin = buffer_size_frames_ - buffer_end_index_;
+  const auto it = audio_buffer_.begin() + buffer_end_index_ * num_channels_;
+  if (num_frames <= margin) {
+    std::copy(data, data + num_frames * num_channels_, it);
+    buffer_end_index_ += num_frames;
+  } else {
+    std::copy(data, data + margin * num_channels_, it);
+    std::copy(data + margin * num_channels_, data + num_frames * num_channels_,
+              audio_buffer_.begin());
+    buffer_end_index_ = num_frames - margin;
+  }
+}
+
+bool AudioRepetitionDetector::Equal(const float* frame,
+                                    int look_back_frames) const {
+  DCHECK(processing_thread_checker_.CalledOnValidThread());
+  const size_t look_back_index =
+      (buffer_end_index_ + buffer_size_frames_ - look_back_frames) %
+      buffer_size_frames_ ;
+  auto it = audio_buffer_.begin() + look_back_index * num_channels_;
+  for (size_t channel = 0; channel < num_channels_; ++channel, ++frame, ++it) {
+    if (*frame != *it)
+      return false;
+  }
+  return true;
+}
+
+bool AudioRepetitionDetector::IsZero(const float* frame,
+                                     size_t num_channels) const {
+  for (size_t channel = 0; channel < num_channels; ++channel, ++frame) {
+    if (*frame != 0)
+      return false;
+  }
+  return true;
+}
+
+bool AudioRepetitionDetector::HasValidReport(const State* state) const {
+  return (!state->all_zero() && state->count_frames() >=
+      static_cast<size_t>(min_length_ms_ * sample_rate_ / 1000));
+}
+
+}  // namespace content