Adds Analog Gain Control (AGC) to the WebRTC client.

media/audio/audio_input_controller.h

 // 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.
 
 #ifndef MEDIA_AUDIO_AUDIO_INPUT_CONTROLLER_H_
 #define MEDIA_AUDIO_AUDIO_INPUT_CONTROLLER_H_
 
 #include <string>
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
@@ skipping 79 matching lines @@
   class SyncWriter {
    public:
     virtual ~SyncWriter() {}
 
     // Notify the synchronous writer about the number of bytes in the
     // soundcard which has been recorded.
     virtual void UpdateRecordedBytes(uint32 bytes) = 0;
 
     // Write certain amount of data from |data|. This method returns
     // number of written bytes.
-    virtual uint32 Write(const void* data, uint32 size) = 0;
+    virtual uint32 Write(const void* data, uint32 size, double volume) = 0;
 
     // Close this synchronous writer.
     virtual void Close() = 0;
   };
 
   // AudioInputController::Create() can use the currently registered Factory
   // to create the AudioInputController. Factory is intended for testing only.
   class Factory {
    public:
     virtual AudioInputController* Create(AudioManager* audio_manager,
@@ skipping 38 matching lines @@
 
   // Closes the audio input stream. The state is changed and the resources
   // are freed on the audio thread. |closed_task| is executed after that.
   // Callbacks (EventHandler and SyncWriter) must exist until |closed_task|
   // is called.
   // It is safe to call this method more than once. Calls after the first one
   // will have no effect.
   // This method is called on the audio thread.
   virtual void Close(const base::Closure& closed_task);
 
+  // Sets the capture volume of the input stream. The value 0.0 corresponds
+  // to muted and 1.0 to maximum volume.
+  virtual void SetVolume(double volume);
+
+  // Sets the Automatic Gain Control (AGC) state of the input stream.
+  virtual void SetAutomaticGainControl(bool enabled);
+
   // AudioInputCallback implementation. Threading details depends on the
   // device-specific implementation.
   virtual void OnData(AudioInputStream* stream, const uint8* src, uint32 size,
-                      uint32 hardware_delay_bytes) OVERRIDE;
+                      uint32 hardware_delay_bytes, double volume) OVERRIDE;
   virtual void OnClose(AudioInputStream* stream) OVERRIDE;
   virtual void OnError(AudioInputStream* stream, int code) OVERRIDE;
 
   bool LowLatencyMode() const { return sync_writer_ != NULL; }
   scoped_refptr<base::MessageLoopProxy> message_loop() const {
     return message_loop_;
   }
 
  protected:
   // Internal state of the source.
   enum State {
     kEmpty,
     kCreated,
     kRecording,
     kClosed,
     kError
   };
 
   AudioInputController(EventHandler* handler, SyncWriter* sync_writer);
 
   // Methods called on the audio thread (owned by the AudioManager).
   void DoCreate(AudioManager* audio_manager, const AudioParameters& params,
                 const std::string& device_id);
   void DoRecord();
   void DoClose(const base::Closure& closed_task);
   void DoReportError(int code);
+  void DoSetVolume(double volume);
+  void DoSetAutomaticGainControl(bool enabled);
 
   // Methods which ensures that OnError() is triggered when data recording
   // times out. Both are called on the creating thread.
   void DoReportNoDataError();
   void DoResetNoDataTimer();
 
   // Helper method that stops, closes, and NULL:s |*stream_|.
   // Signals event when done if the event is not NULL.
   void DoStopCloseAndClearStream(base::WaitableEvent* done);
 
@@ skipping 22 matching lines @@
   // reading on the audio input controller thread.
   State state_;
 
   base::Lock lock_;
 
   // SyncWriter is used only in low-latency mode for synchronous writing.
   SyncWriter* sync_writer_;
 
   static Factory* factory_;
 
+  double max_volume_;
+
   DISALLOW_COPY_AND_ASSIGN(AudioInputController);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_AUDIO_AUDIO_INPUT_CONTROLLER_H_