content/browser/renderer_host/media/audio_input_renderer_host.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4 //
   5 // AudioInputRendererHost serves audio related requests from audio capturer
   6 // which lives inside the render process and provide access to audio hardware.
   7 //
   8 // Create stream sequence (AudioInputController = AIC):
   9 //
  10 // AudioInputHostMsg_CreateStream -> OnCreateStream -> AIC::CreateLowLatency ->
  11 //   <- AudioInputMsg_NotifyStreamCreated <- DoCompleteCreation <- OnCreated <-
  12 //
  13 // Close stream sequence:
  14 //
  15 // AudioInputHostMsg_CloseStream -> OnCloseStream -> AIC::Close ->
  16 //
  17 // This class is owned by BrowserRenderProcessHost and instantiated on UI
  18 // thread. All other operations and method calls happen on IO thread, so we
  19 // need to be extra careful about the lifetime of this object.
  20 //
  21 // To ensure low latency audio, a SyncSocket pair is used to signal buffer
  22 // readiness without having to route messages using the IO thread.
  23
  24 #ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_INPUT_RENDERER_HOST_H_
  25 #define CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_INPUT_RENDERER_HOST_H_
  26
  27 #include <map>
  28 #include <string>
  29
  30 #include "base/compiler_specific.h"
  31 #include "base/gtest_prod_util.h"
  32 #include "base/memory/ref_counted.h"
  33 #include "base/memory/scoped_ptr.h"
  34 #include "base/memory/shared_memory.h"
  35 #include "base/process/process.h"
  36 #include "base/sequenced_task_runner_helpers.h"
  37 #include "content/common/media/audio_messages.h"
  38 #include "content/public/browser/browser_message_filter.h"
  39 #include "content/public/browser/browser_thread.h"
  40 #include "media/audio/audio_input_controller.h"
  41 #include "media/audio/audio_io.h"
  42 #include "media/audio/audio_logging.h"
  43 #include "media/audio/simple_sources.h"
  44
  45 namespace media {
  46 class AudioManager;
  47 class AudioParameters;
  48 class UserInputMonitor;
  49 }
  50
  51 namespace content {
  52 class AudioMirroringManager;
  53 class MediaStreamManager;
  54
  55 class CONTENT_EXPORT AudioInputRendererHost
  56     : public BrowserMessageFilter,
  57       public media::AudioInputController::EventHandler {
  58  public:
  59   // Called from UI thread from the owner of this object.
  60   // |user_input_monitor| is used for typing detection and can be NULL.
  61   AudioInputRendererHost(media::AudioManager* audio_manager,
  62                          MediaStreamManager* media_stream_manager,
  63                          AudioMirroringManager* audio_mirroring_manager,
  64                          media::UserInputMonitor* user_input_monitor);
  65
  66   // BrowserMessageFilter implementation.
  67   virtual void OnChannelClosing() OVERRIDE;
  68   virtual void OnDestruct() const OVERRIDE;
  69   virtual bool OnMessageReceived(const IPC::Message& message,
  70                                  bool* message_was_ok) OVERRIDE;
  71
  72   // AudioInputController::EventHandler implementation.
  73   virtual void OnCreated(media::AudioInputController* controller) OVERRIDE;
  74   virtual void OnRecording(media::AudioInputController* controller) OVERRIDE;
  75   virtual void OnError(media::AudioInputController* controller) OVERRIDE;
  76   virtual void OnData(media::AudioInputController* controller,
  77                       const uint8* data,
  78                       uint32 size) OVERRIDE;
  79
  80  private:
  81   // TODO(henrika): extend test suite (compare AudioRenderHost)
  82   friend class BrowserThread;
  83   friend class TestAudioInputRendererHost;
  84   friend class base::DeleteHelper<AudioInputRendererHost>;
  85
  86   struct AudioEntry;
  87   typedef std::map<int, AudioEntry*> AudioEntryMap;
  88
  89   virtual ~AudioInputRendererHost();
  90
  91   // Methods called on IO thread ----------------------------------------------
  92
  93   // Audio related IPC message handlers.
  94
  95   // Creates an audio input stream with the specified format whose data is
  96   // consumed by an entity in the render view referenced by |render_view_id|.
  97   // |session_id| is used to find out which device to be used for the stream.
  98   // Upon success/failure, the peer is notified via the
  99   // NotifyStreamCreated message.
 100   void OnCreateStream(int stream_id,
 101                       int render_view_id,
 102                       int session_id,
 103                       const AudioInputHostMsg_CreateStream_Config& config);
 104
 105   // Record the audio input stream referenced by |stream_id|.
 106   void OnRecordStream(int stream_id);
 107
 108   // Close the audio stream referenced by |stream_id|.
 109   void OnCloseStream(int stream_id);
 110
 111   // Set the volume of the audio stream referenced by |stream_id|.
 112   void OnSetVolume(int stream_id, double volume);
 113
 114   // Complete the process of creating an audio input stream. This will set up
 115   // the shared memory or shared socket in low latency mode and send the
 116   // NotifyStreamCreated message to the peer.
 117   void DoCompleteCreation(media::AudioInputController* controller);
 118
 119   // Send a state change message to the renderer.
 120   void DoSendRecordingMessage(media::AudioInputController* controller);
 121
 122   // Handle error coming from audio stream.
 123   void DoHandleError(media::AudioInputController* controller);
 124
 125   // Send an error message to the renderer.
 126   void SendErrorMessage(int stream_id);
 127
 128   // Delete all audio entry and all audio streams
 129   void DeleteEntries();
 130
 131   // Closes the stream. The stream is then deleted in DeleteEntry() after it
 132   // is closed.
 133   void CloseAndDeleteStream(AudioEntry* entry);
 134
 135   // Delete an audio entry and close the related audio stream.
 136   void DeleteEntry(AudioEntry* entry);
 137
 138   // Delete audio entry and close the related audio input stream.
 139   void DeleteEntryOnError(AudioEntry* entry);
 140
 141   // A helper method to look up a AudioEntry identified by |stream_id|.
 142   // Returns NULL if not found.
 143   AudioEntry* LookupById(int stream_id);
 144
 145   // Search for a AudioEntry having the reference to |controller|.
 146   // This method is used to look up an AudioEntry after a controller
 147   // event is received.
 148   AudioEntry* LookupByController(media::AudioInputController* controller);
 149
 150   // Used to create an AudioInputController.
 151   media::AudioManager* audio_manager_;
 152
 153   // Used to access to AudioInputDeviceManager.
 154   MediaStreamManager* media_stream_manager_;
 155
 156   AudioMirroringManager* audio_mirroring_manager_;
 157
 158   // A map of stream IDs to audio sources.
 159   AudioEntryMap audio_entries_;
 160
 161   // Raw pointer of the UserInputMonitor.
 162   media::UserInputMonitor* user_input_monitor_;
 163
 164   scoped_ptr<media::AudioLog> audio_log_;
 165
 166   DISALLOW_COPY_AND_ASSIGN(AudioInputRendererHost);
 167 };
 168
 169 }  // namespace content
 170
 171 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_INPUT_RENDERER_HOST_H_