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
  60   // Error codes to make native loggin more clear. These error codes are added
  61   // to generic error strings to provide a higher degree of details.
  62   // Changing these values can lead to problems when matching native debug
  63   // logs with the actual cause of error.
  64   enum ErrorCode {
  65     // An unspecified error occured.
  66     UNKNOWN_ERROR = 0,
  67
  68     // Failed to look up audio intry for the provided stream id.
  69     INVALID_AUDIO_ENTRY,  // = 1
  70
  71     // A stream with the specified stream id already exists.
  72     STREAM_ALREADY_EXISTS,  // = 2
  73
  74     // The page does not have permission to open the specified capture device.
  75     PERMISSION_DENIED,  // = 3
  76
  77     // Failed to create shared memory.
  78     SHARED_MEMORY_CREATE_FAILED,  // = 4
  79
  80     // Failed to initialize the AudioInputSyncWriter instance.
  81     SYNC_WRITER_INIT_FAILED,  // = 5
  82
  83     // Failed to create native audio input stream.
  84     STREAM_CREATE_ERROR,  // = 6
  85
  86     // Renderer process handle is invalid.
  87     INVALID_PEER_HANDLE,  // = 7
  88
  89     // Only low-latency mode is supported.
  90     INVALID_LATENCY_MODE,  // = 8
  91
  92     // Failed to map and share the shared memory.
  93     MEMORY_SHARING_FAILED,  // = 9
  94
  95     // Unable to prepare the foreign socket handle.
  96     SYNC_SOCKET_ERROR,  // = 10
  97
  98     // This error message comes from the AudioInputController instance.
  99     AUDIO_INPUT_CONTROLLER_ERROR,  // = 11
 100   };
 101
 102   // Called from UI thread from the owner of this object.
 103   // |user_input_monitor| is used for typing detection and can be NULL.
 104   AudioInputRendererHost(int render_process_id,
 105                          media::AudioManager* audio_manager,
 106                          MediaStreamManager* media_stream_manager,
 107                          AudioMirroringManager* audio_mirroring_manager,
 108                          media::UserInputMonitor* user_input_monitor);
 109
 110   // BrowserMessageFilter implementation.
 111   void OnChannelClosing() override;
 112   void OnDestruct() const override;
 113   bool OnMessageReceived(const IPC::Message& message) override;
 114
 115   // AudioInputController::EventHandler implementation.
 116   void OnCreated(media::AudioInputController* controller) override;
 117   void OnRecording(media::AudioInputController* controller) override;
 118   void OnError(media::AudioInputController* controller,
 119                media::AudioInputController::ErrorCode error_code) override;
 120   void OnData(media::AudioInputController* controller,
 121               const media::AudioBus* data) override;
 122   void OnLog(media::AudioInputController* controller,
 123              const std::string& message) override;
 124
 125  private:
 126   // TODO(henrika): extend test suite (compare AudioRenderHost)
 127   friend class BrowserThread;
 128   friend class TestAudioInputRendererHost;
 129   friend class base::DeleteHelper<AudioInputRendererHost>;
 130
 131   struct AudioEntry;
 132   typedef std::map<int, AudioEntry*> AudioEntryMap;
 133
 134   ~AudioInputRendererHost() override;
 135
 136   // Methods called on IO thread ----------------------------------------------
 137
 138   // Audio related IPC message handlers.
 139
 140   // For ChromeOS: Checks if the stream should contain keyboard mic, if so
 141   // registers to AudioInputDeviceManager. Then calls DoCreateStream.
 142   // For non-ChromeOS: Just calls DoCreateStream.
 143   void OnCreateStream(int stream_id,
 144                       int render_frame_id,
 145                       int session_id,
 146                       const AudioInputHostMsg_CreateStream_Config& config);
 147
 148   // Creates an audio input stream with the specified format whose data is
 149   // consumed by an entity in the RenderFrame referenced by |render_frame_id|.
 150   // |session_id| is used to find out which device to be used for the stream.
 151   // Upon success/failure, the peer is notified via the
 152   // NotifyStreamCreated message.
 153   void DoCreateStream(int stream_id,
 154                       int render_frame_id,
 155                       int session_id,
 156                       const AudioInputHostMsg_CreateStream_Config& config);
 157
 158   // Record the audio input stream referenced by |stream_id|.
 159   void OnRecordStream(int stream_id);
 160
 161   // Close the audio stream referenced by |stream_id|.
 162   void OnCloseStream(int stream_id);
 163
 164   // Set the volume of the audio stream referenced by |stream_id|.
 165   void OnSetVolume(int stream_id, double volume);
 166
 167   // Complete the process of creating an audio input stream. This will set up
 168   // the shared memory or shared socket in low latency mode and send the
 169   // NotifyStreamCreated message to the peer.
 170   void DoCompleteCreation(media::AudioInputController* controller);
 171
 172   // Send a state change message to the renderer.
 173   void DoSendRecordingMessage(media::AudioInputController* controller);
 174
 175   // Handle error coming from audio stream.
 176   void DoHandleError(media::AudioInputController* controller,
 177       media::AudioInputController::ErrorCode error_code);
 178
 179   // Log audio level of captured audio stream.
 180   void DoLog(media::AudioInputController* controller,
 181              const std::string& message);
 182
 183   // Send an error message to the renderer.
 184   void SendErrorMessage(int stream_id, ErrorCode error_code);
 185
 186   // Delete all audio entry and all audio streams
 187   void DeleteEntries();
 188
 189   // Closes the stream. The stream is then deleted in DeleteEntry() after it
 190   // is closed.
 191   void CloseAndDeleteStream(AudioEntry* entry);
 192
 193   // Delete an audio entry and close the related audio stream.
 194   void DeleteEntry(AudioEntry* entry);
 195
 196   // Delete audio entry and close the related audio input stream.
 197   void DeleteEntryOnError(AudioEntry* entry, ErrorCode error_code);
 198
 199   // A helper method to look up a AudioEntry identified by |stream_id|.
 200   // Returns NULL if not found.
 201   AudioEntry* LookupById(int stream_id);
 202
 203   // Search for a AudioEntry having the reference to |controller|.
 204   // This method is used to look up an AudioEntry after a controller
 205   // event is received.
 206   AudioEntry* LookupByController(media::AudioInputController* controller);
 207
 208   // If ChromeOS and |config|'s layout has keyboard mic, unregister in
 209   // AudioInputDeviceManager.
 210   void MaybeUnregisterKeyboardMicStream(
 211       const AudioInputHostMsg_CreateStream_Config& config);
 212
 213   // ID of the RenderProcessHost that owns this instance.
 214   const int render_process_id_;
 215
 216   // Used to create an AudioInputController.
 217   media::AudioManager* audio_manager_;
 218
 219   // Used to access to AudioInputDeviceManager.
 220   MediaStreamManager* media_stream_manager_;
 221
 222   AudioMirroringManager* audio_mirroring_manager_;
 223
 224   // A map of stream IDs to audio sources.
 225   AudioEntryMap audio_entries_;
 226
 227   // Raw pointer of the UserInputMonitor.
 228   media::UserInputMonitor* user_input_monitor_;
 229
 230   scoped_ptr<media::AudioLog> audio_log_;
 231
 232   DISALLOW_COPY_AND_ASSIGN(AudioInputRendererHost);
 233 };
 234
 235 }  // namespace content
 236
 237 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_INPUT_RENDERER_HOST_H_