Implements the GetSignalLevel and GetStats interface for the local audio track.

content/renderer/media/webrtc_audio_capturer.cc

 // Copyright (c) 2012 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/webrtc_audio_capturer.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
@@ skipping 50 matching lines @@
                          need_audio_processing);
     }
   }
 
   void OnSetFormat(const media::AudioParameters& params) {
     base::AutoLock lock(lock_);
     if (delegate_)
       delegate_->OnSetFormat(params);
   }
 
+  void SetAudioProcessor(
+      const scoped_refptr<MediaStreamAudioProcessor>& processor) {
+    base::AutoLock lock(lock_);
+    if (delegate_)
+      delegate_->SetAudioProcessor(processor);
+  }
+
   void Reset() {
     base::AutoLock lock(lock_);
     delegate_ = NULL;
   }
 
   void Stop() {
     base::AutoLock lock(lock_);
     DCHECK(delegate_);
 
     // This can be reentrant so reset |delegate_| before calling out.
@@ skipping 208 matching lines @@
   // Dispatch the new parameters both to the sink(s) and to the new source,
   // also apply the new |constraints|.
   // The idea is to get rid of any dependency of the microphone parameters
   // which would normally be used by default.
   // bits_per_sample is always 16 for now.
   int buffer_size = GetBufferSize(sample_rate);
   media::AudioParameters params(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                                 channel_layout, 0, sample_rate,
                                 16, buffer_size, effects);
   scoped_refptr<MediaStreamAudioProcessor> new_audio_processor(
-      new MediaStreamAudioProcessor(params, constraints, effects,
-                                    audio_device_));
+      new talk_base::RefCountedObject<MediaStreamAudioProcessor>(
+          params, constraints, effects, audio_device_));
   {
     base::AutoLock auto_lock(lock_);
     audio_processor_ = new_audio_processor;
     need_audio_processing_ = NeedsAudioProcessing(constraints, effects);
 
     // Notify all tracks about the new format.
     tracks_.TagAll();
   }
 
   if (source.get())
@@ skipping 152 matching lines @@
             audio_processor->InputFormat().channels());
   DCHECK_EQ(audio_source->frames(),
            audio_processor->InputFormat().frames_per_buffer());
 
   // Notify the tracks on when the format changes. This will do nothing if
   // |tracks_to_notify_format| is empty.
   media::AudioParameters output_params = audio_processor_->OutputFormat();
   for (TrackList::ItemList::const_iterator it = tracks_to_notify_format.begin();
        it != tracks_to_notify_format.end(); ++it) {
     (*it)->OnSetFormat(output_params);
+    (*it)->SetAudioProcessor(audio_processor);
   }
 
   // Push the data to the processor for processing.
   audio_processor->PushCaptureData(audio_source);
 
   // Process and consume the data in the processor until there is not enough
   // data in the processor.
   int16* output = NULL;
   int new_volume = 0;
   while (audio_processor->ProcessAndConsumeData(
@@ skipping 77 matching lines @@
     const scoped_refptr<media::AudioCapturerSource>& source,
     media::AudioParameters params) {
   // Create a new audio stream as source which uses the new source.
   SetCapturerSource(source, params.channel_layout(),
                     static_cast<float>(params.sample_rate()),
                     params.effects(),
                     constraints_);
 }
 
 }  // namespace content