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
|
// 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_ANDROID_AUDIO_MANAGER_ANDROID_H_
#define MEDIA_AUDIO_ANDROID_AUDIO_MANAGER_ANDROID_H_
#include <set>
#include "base/android/jni_android.h"
#include "base/macros.h"
#include "base/synchronization/lock.h"
#include "base/synchronization/waitable_event.h"
#include "media/audio/audio_manager_base.h"
namespace media {
class MuteableAudioOutputStream;
// Android implemention of AudioManager.
class MEDIA_EXPORT AudioManagerAndroid : public AudioManagerBase {
public:
AudioManagerAndroid(std::unique_ptr<AudioThread> audio_thread,
AudioLogFactory* audio_log_factory);
AudioManagerAndroid(const AudioManagerAndroid&) = delete;
AudioManagerAndroid& operator=(const AudioManagerAndroid&) = delete;
~AudioManagerAndroid() override;
void InitializeIfNeeded();
// Implementation of AudioManager.
bool HasAudioOutputDevices() override;
bool HasAudioInputDevices() override;
void GetAudioInputDeviceNames(AudioDeviceNames* device_names) override;
void GetAudioOutputDeviceNames(AudioDeviceNames* device_names) override;
AudioParameters GetInputStreamParameters(
const std::string& device_id) override;
AudioOutputStream* MakeAudioOutputStream(
const AudioParameters& params,
const std::string& device_id,
const LogCallback& log_callback) override;
AudioInputStream* MakeAudioInputStream(
const AudioParameters& params,
const std::string& device_id,
const LogCallback& log_callback) override;
void ReleaseOutputStream(AudioOutputStream* stream) override;
void ReleaseInputStream(AudioInputStream* stream) override;
const char* GetName() override;
// Implementation of AudioManagerBase.
AudioOutputStream* MakeLinearOutputStream(
const AudioParameters& params,
const LogCallback& log_callback) override;
AudioOutputStream* MakeLowLatencyOutputStream(
const AudioParameters& params,
const std::string& device_id,
const LogCallback& log_callback) override;
AudioOutputStream* MakeBitstreamOutputStream(
const AudioParameters& params,
const std::string& device_id,
const LogCallback& log_callback) override;
AudioInputStream* MakeLinearInputStream(
const AudioParameters& params,
const std::string& device_id,
const LogCallback& log_callback) override;
AudioInputStream* MakeLowLatencyInputStream(
const AudioParameters& params,
const std::string& device_id,
const LogCallback& log_callback) override;
// Indicates if there's support for the OpenSLES performance mode keys. See
// OpenSLESOutputStream for specific details. Essentially this allows for low
// power audio when large buffer sizes can be used.
static bool SupportsPerformanceModeForOutput();
void SetMute(JNIEnv* env,
const base::android::JavaParamRef<jobject>& obj,
jboolean muted);
// Sets a volume that applies to all this manager's output audio streams.
// This overrides other SetVolume calls (e.g. through AudioHostMsg_SetVolume).
void SetOutputVolumeOverride(double volume);
bool HasOutputVolumeOverride(double* out_volume) const;
// Get the latency introduced by the hardware. It relies on
// AudioManager.getOutputLatency, which is both (a) hidden and (b) not
// guaranteed to be meaningful. Do not use this, except in the context of
// b/80326798 to adjust (hackily) for hardware latency that OpenSLES isn't
// otherwise accounting for.
base::TimeDelta GetOutputLatency();
bool IsUsingAAudioForTesting() { return UseAAudio(); }
protected:
void ShutdownOnAudioThread() override;
AudioParameters GetPreferredOutputStreamParameters(
const std::string& output_device_id,
const AudioParameters& input_params) override;
private:
const base::android::JavaRef<jobject>& GetJavaAudioManager();
bool HasNoAudioInputStreams();
void SetCommunicationAudioModeOn(bool on);
bool SetAudioDevice(const std::string& device_id);
int GetNativeOutputSampleRate();
bool IsAudioLowLatencySupported();
int GetAudioLowLatencyOutputFrameSize();
int GetOptimalOutputFrameSize(int sample_rate, int channels);
void DoSetMuteOnAudioThread(bool muted);
void DoSetVolumeOnAudioThread(double volume);
// Returns whether or not we can and should use AAudio.
bool UseAAudio();
// Java AudioManager instance.
base::android::ScopedJavaGlobalRef<jobject> j_audio_manager_;
typedef std::set<MuteableAudioOutputStream*> OutputStreams;
OutputStreams streams_;
// Enabled when first input stream is created and set to false when last
// input stream is destroyed. Also affects the stream type of output streams.
bool communication_mode_is_on_;
absl::optional<bool> is_aaudio_available_;
// If set, overrides volume level on output streams
bool output_volume_override_set_;
double output_volume_override_;
};
} // namespace media
#endif // MEDIA_AUDIO_ANDROID_AUDIO_MANAGER_ANDROID_H_
|
