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_ 172