blob: 2c5f2afbcd4507a9d4aa80ceb4cd819066c5ada9 (
plain)
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
|
// 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/string16.h"
#include "base/task.h"
#include "media/audio/audio_device_name.h"
#include "media/audio/audio_parameters.h"
class AudioInputStream;
class AudioOutputStream;
class MessageLoop;
// Manages all audio resources. In particular it owns the AudioOutputStream
// objects. Provides some convenience functions that avoid the need to provide
// iterators over the existing streams.
// TODO(tommi): Make the manager non-refcounted when it's safe to do so.
// -> Bug 107087.
class MEDIA_EXPORT AudioManager
: public base::RefCountedThreadSafe<AudioManager> {
public:
AudioManager();
#ifndef NDEBUG
// Allow base classes in debug builds to override the reference counting
// functions. This allows us to protect against regressions and enforce
// correct usage. The default implementation just calls the base class.
virtual void AddRef() const;
virtual void Release() const;
#endif
// Use to construct the audio manager.
// NOTE: There should only be one instance. If you try to create more than
// one instance, it will hit a CHECK().
static scoped_refptr<AudioManager> Create();
// 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;
// Returns true if the platform specific audio input settings UI is known
// and can be shown.
virtual bool CanShowAudioInputSettings() = 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. It is not guaranteed that
// all the devices in the list support all formats and sample rates for
// recording.
virtual void GetAudioInputDeviceNames(
media::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().
//
// 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) = 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) = 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;
// Muting continues playback but effectively the volume is set to zero.
// Un-muting returns the volume to the previous level.
virtual void MuteAll() = 0;
virtual void UnMuteAll() = 0;
// Used to determine if something else is currently making use of audio input.
virtual bool IsRecordingInProcess() = 0;
// Returns message loop used for audio IO.
virtual MessageLoop* GetMessageLoop() = 0;
protected:
// Called from Create() to initialize the instance.
virtual void Init() = 0;
friend class base::RefCountedThreadSafe<AudioManager>;
virtual ~AudioManager();
};
#endif // MEDIA_AUDIO_AUDIO_MANAGER_H_
|
