| // 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. |
| // |
| // AudioRendererHost serves audio related requests from AudioRenderer which |
| // lives inside the render process and provide access to audio hardware. |
| // |
| // This class is owned by BrowserRenderProcessHost, and instantiated on UI |
| // thread, but all other operations and method calls happen on IO thread, so we |
| // need to be extra careful about the lifetime of this object. AudioManager is a |
| // singleton and created in IO thread, audio output streams are also created in |
| // the IO thread, so we need to destroy them also in IO thread. After this class |
| // is created, a task of OnInitialized() is posted on IO thread in which |
| // singleton of AudioManager is created. |
| // |
| // Here's an example of a typical IPC dialog for audio: |
| // |
| // Renderer AudioRendererHost |
| // | | |
| // | CreateStream > | |
| // | < NotifyStreamCreated | |
| // | | |
| // | PlayStream > | |
| // | < NotifyStreamStateChanged | kAudioStreamPlaying |
| // | | |
| // | PauseStream > | |
| // | < NotifyStreamStateChanged | kAudioStreamPaused |
| // | | |
| // | PlayStream > | |
| // | < NotifyStreamStateChanged | kAudioStreamPlaying |
| // | ... | |
| // | CloseStream > | |
| // v v |
| |
| // A SyncSocket pair is used to signal buffer readiness between processes. |
| |
| #ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_RENDERER_HOST_H_ |
| #define CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_RENDERER_HOST_H_ |
| |
| #include <map> |
| |
| #include "base/gtest_prod_util.h" |
| #include "base/memory/ref_counted.h" |
| #include "base/memory/scoped_ptr.h" |
| #include "base/process/process.h" |
| #include "base/sequenced_task_runner_helpers.h" |
| #include "content/common/content_export.h" |
| #include "content/public/browser/browser_message_filter.h" |
| #include "content/public/browser/browser_thread.h" |
| #include "content/public/browser/render_view_host.h" |
| #include "media/audio/audio_io.h" |
| #include "media/audio/audio_output_controller.h" |
| #include "media/audio/simple_sources.h" |
| |
| namespace media { |
| class AudioManager; |
| class AudioParameters; |
| } |
| |
| namespace content { |
| |
| class AudioMirroringManager; |
| class MediaInternals; |
| class MediaStreamManager; |
| class ResourceContext; |
| |
| class CONTENT_EXPORT AudioRendererHost : public BrowserMessageFilter { |
| public: |
| // Called from UI thread from the owner of this object. |
| AudioRendererHost(int render_process_id, |
| media::AudioManager* audio_manager, |
| AudioMirroringManager* mirroring_manager, |
| MediaInternals* media_internals, |
| MediaStreamManager* media_stream_manager); |
| |
| // Calls |callback| with the list of AudioOutputControllers for this object. |
| void GetOutputControllers( |
| int render_view_id, |
| const RenderViewHost::GetAudioOutputControllersCallback& callback) const; |
| |
| // BrowserMessageFilter implementation. |
| virtual void OnChannelClosing() OVERRIDE; |
| virtual void OnDestruct() const OVERRIDE; |
| virtual bool OnMessageReceived(const IPC::Message& message, |
| bool* message_was_ok) OVERRIDE; |
| |
| private: |
| friend class AudioRendererHostTest; |
| friend class BrowserThread; |
| friend class base::DeleteHelper<AudioRendererHost>; |
| friend class MockAudioRendererHost; |
| friend class TestAudioRendererHost; |
| FRIEND_TEST_ALL_PREFIXES(AudioRendererHostTest, CreateMockStream); |
| FRIEND_TEST_ALL_PREFIXES(AudioRendererHostTest, MockStreamDataConversation); |
| |
| class AudioEntry; |
| typedef std::map<int, AudioEntry*> AudioEntryMap; |
| |
| virtual ~AudioRendererHost(); |
| |
| // Methods called on IO thread ---------------------------------------------- |
| |
| // Audio related IPC message handlers. |
| |
| // Creates an audio output stream with the specified format whose data is |
| // produced by an entity in the render view referenced by |render_view_id|. |
| // |session_id| is used for unified IO to find out which input device to be |
| // opened for the stream. For clients that do not use unified IO, |
| // |session_id| will be ignored. |
| // Upon success/failure, the peer is notified via the NotifyStreamCreated |
| // message. |
| void OnCreateStream(int stream_id, |
| int render_view_id, |
| int session_id, |
| const media::AudioParameters& params); |
| |
| // Play the audio stream referenced by |stream_id|. |
| void OnPlayStream(int stream_id); |
| |
| // Pause the audio stream referenced by |stream_id|. |
| void OnPauseStream(int stream_id); |
| |
| // Close the audio stream referenced by |stream_id|. |
| void OnCloseStream(int stream_id); |
| |
| // Set the volume of the audio stream referenced by |stream_id|. |
| void OnSetVolume(int stream_id, double volume); |
| |
| // Complete the process of creating an audio stream. This will set up the |
| // shared memory or shared socket in low latency mode and send the |
| // NotifyStreamCreated message to the peer. |
| void DoCompleteCreation(int stream_id); |
| |
| RenderViewHost::AudioOutputControllerList DoGetOutputControllers( |
| int render_view_id) const; |
| |
| // Propagate measured power level of the audio signal to MediaObserver. |
| void DoNotifyAudioPowerLevel(int stream_id, float power_dbfs, bool clipped); |
| |
| // Send an error message to the renderer. |
| void SendErrorMessage(int stream_id); |
| |
| // Delete an audio entry, notifying observers first. This is called by |
| // AudioOutputController after it has closed. |
| void DeleteEntry(scoped_ptr<AudioEntry> entry); |
| |
| // Send an error message to the renderer, then close the stream. |
| void ReportErrorAndClose(int stream_id); |
| |
| // A helper method to look up a AudioEntry identified by |stream_id|. |
| // Returns NULL if not found. |
| AudioEntry* LookupById(int stream_id); |
| |
| // ID of the RenderProcessHost that owns this instance. |
| const int render_process_id_; |
| |
| media::AudioManager* const audio_manager_; |
| AudioMirroringManager* const mirroring_manager_; |
| MediaInternals* const media_internals_; |
| |
| // Used to access to AudioInputDeviceManager. |
| MediaStreamManager* media_stream_manager_; |
| |
| // A map of stream IDs to audio sources. |
| AudioEntryMap audio_entries_; |
| |
| DISALLOW_COPY_AND_ASSIGN(AudioRendererHost); |
| }; |
| |
| } // namespace content |
| |
| #endif // CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_RENDERER_HOST_H_ |