1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
// 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_MANAGER_H_
#define MEDIA_AUDIO_AUDIO_MANAGER_H_
#include <string>
#include "base/basictypes.h"
#include "base/memory/ref_counted.h"
#include "base/strings/string16.h"
#include "media/audio/audio_device_name.h"
#include "media/audio/audio_logging.h"
#include "media/audio/audio_parameters.h"
namespace base {
class MessageLoop;
class MessageLoopProxy;
}
namespace media {
class AudioInputStream;
class AudioOutputStream;
// Manages all audio resources. Provides some convenience functions that avoid
// the need to provide iterators over the existing streams.
class MEDIA_EXPORT AudioManager {
public:
virtual ~AudioManager();
// Construct the audio manager; only one instance is allowed. The manager
// will forward CreateAudioLog() calls to the provided AudioLogFactory; as
// such |audio_log_factory| must outlive the AudioManager.
static AudioManager* Create(AudioLogFactory* audio_log_factory);
// Similar to Create() except uses a FakeAudioLogFactory for testing.
static AudioManager* CreateForTesting();
// Returns the pointer to the last created instance, or NULL if not yet
// created. This is a utility method for the code outside of media directory,
// like src/chrome.
static AudioManager* Get();
// Returns true if the OS reports existence of audio devices. This does not
// guarantee that the existing devices support all formats and sample rates.
virtual bool HasAudioOutputDevices() = 0;
// Returns true if the OS reports existence of audio recording devices. This
// does not guarantee that the existing devices support all formats and
// sample rates.
virtual bool HasAudioInputDevices() = 0;
// Returns a human readable string for the model/make of the active audio
// input device for this computer.
virtual string16 GetAudioInputDeviceModel() = 0;
// Opens the platform default audio input settings UI.
// Note: This could invoke an external application/preferences pane, so
// ideally must not be called from the UI thread or other time sensitive
// threads to avoid blocking the rest of the application.
virtual void ShowAudioInputSettings() = 0;
// Appends a list of available input devices to |device_names|,
// which must initially be empty. It is not guaranteed that all the
// devices in the list support all formats and sample rates for
// recording.
//
// Not threadsafe; in production this should only be called from the
// Audio IO thread (see GetMessageLoop).
virtual void GetAudioInputDeviceNames(AudioDeviceNames* device_names) = 0;
// Appends a list of available output devices to |device_names|,
// which must initially be empty.
//
// Not threadsafe; in production this should only be called from the
// Audio IO thread (see GetMessageLoop).
virtual void GetAudioOutputDeviceNames(AudioDeviceNames* device_names) = 0;
// Factory for all the supported stream formats. |params| defines parameters
// of the audio stream to be created.
//
// |params.sample_per_packet| is the requested buffer allocation which the
// audio source thinks it can usually fill without blocking. Internally two
// or three buffers are created, one will be locked for playback and one will
// be ready to be filled in the call to AudioSourceCallback::OnMoreData().
//
// To create a stream for the default output device, pass an empty string
// for |device_id|, otherwise the specified audio device will be opened.
//
// The |input_device_id| is used for low-latency unified streams
// (input+output) only and then only if the audio parameters specify a >0
// input channel count. In other cases this id is ignored and should be
// empty.
//
// Returns NULL if the combination of the parameters is not supported, or if
// we have reached some other platform specific limit.
//
// |params.format| can be set to AUDIO_PCM_LOW_LATENCY and that has two
// effects:
// 1- Instead of triple buffered the audio will be double buffered.
// 2- A low latency driver or alternative audio subsystem will be used when
// available.
//
// Do not free the returned AudioOutputStream. It is owned by AudioManager.
virtual AudioOutputStream* MakeAudioOutputStream(
const AudioParameters& params,
const std::string& device_id,
const std::string& input_device_id) = 0;
// Creates new audio output proxy. A proxy implements
// AudioOutputStream interface, but unlike regular output stream
// created with MakeAudioOutputStream() it opens device only when a
// sound is actually playing.
virtual AudioOutputStream* MakeAudioOutputStreamProxy(
const AudioParameters& params,
const std::string& device_id,
const std::string& input_device_id) = 0;
// Factory to create audio recording streams.
// |channels| can be 1 or 2.
// |sample_rate| is in hertz and can be any value supported by the platform.
// |bits_per_sample| can be any value supported by the platform.
// |samples_per_packet| is in hertz as well and can be 0 to |sample_rate|,
// with 0 suggesting that the implementation use a default value for that
// platform.
// Returns NULL if the combination of the parameters is not supported, or if
// we have reached some other platform specific limit.
//
// Do not free the returned AudioInputStream. It is owned by AudioManager.
// When you are done with it, call |Stop()| and |Close()| to release it.
virtual AudioInputStream* MakeAudioInputStream(
const AudioParameters& params, const std::string& device_id) = 0;
// Returns message loop used for audio IO.
virtual scoped_refptr<base::MessageLoopProxy> GetMessageLoop() = 0;
// Heavyweight tasks should use GetWorkerLoop() instead of GetMessageLoop().
// On most platforms they are the same, but some share the UI loop with the
// audio IO loop.
virtual scoped_refptr<base::MessageLoopProxy> GetWorkerLoop() = 0;
// Allows clients to listen for device state changes; e.g. preferred sample
// rate or channel layout changes. The typical response to receiving this
// callback is to recreate the stream.
class AudioDeviceListener {
public:
virtual void OnDeviceChange() = 0;
};
virtual void AddOutputDeviceChangeListener(AudioDeviceListener* listener) = 0;
virtual void RemoveOutputDeviceChangeListener(
AudioDeviceListener* listener) = 0;
// Returns the default output hardware audio parameters for opening output
// streams. It is a convenience interface to
// AudioManagerBase::GetPreferredOutputStreamParameters and each AudioManager
// does not need their own implementation to this interface.
// TODO(tommi): Remove this method and use GetOutputStreamParameteres instead.
virtual AudioParameters GetDefaultOutputStreamParameters() = 0;
// Returns the output hardware audio parameters for a specific output device.
virtual AudioParameters GetOutputStreamParameters(
const std::string& device_id) = 0;
// Returns the input hardware audio parameters of the specific device
// for opening input streams. Each AudioManager needs to implement their own
// version of this interface.
virtual AudioParameters GetInputStreamParameters(
const std::string& device_id) = 0;
// Returns the device id of an output device that belongs to the same hardware
// as the specified input device.
// If the hardware has only an input device (e.g. a webcam), the return value
// will be empty (which the caller can then interpret to be the default output
// device). Implementations that don't yet support this feature, must return
// an empty string.
virtual std::string GetAssociatedOutputDeviceID(
const std::string& input_device_id) = 0;
// Create a new AudioLog object for tracking the behavior for one or more
// instances of the given component. See AudioLogFactory for more details.
virtual scoped_ptr<AudioLog> CreateAudioLog(
AudioLogFactory::AudioComponent component) = 0;
// Called when a component has detected a OS level audio wedge. Shuts down
// all active audio streams and then restarts them transparently. See
// http://crbug.com/160920
virtual void FixWedgedAudio() = 0;
protected:
AudioManager();
private:
DISALLOW_COPY_AND_ASSIGN(AudioManager);
};
} // namespace media
#endif // MEDIA_AUDIO_AUDIO_MANAGER_H_
|
