Skip to content

Commit f3a4c50

Browse files
hajimehoshihajimehoshi
committed
internal/oboe: update Oboe to v1.10.0
1 parent 7c2f94b commit f3a4c50

31 files changed

+2085
-161
lines changed

‎internal/oboe/gen.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@ import (
2929
"strings"
3030
)
3131

32-
const oboeVersion = "1.9.3"
32+
const oboeVersion = "1.10.0"
3333

3434
func main() {
3535
if err := run(); err != nil {

‎internal/oboe/oboe_aaudio_AAudioExtensions_android.h‎

Lines changed: 146 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,9 @@
1717
#ifndef OBOE_AAUDIO_EXTENSIONS_H
1818
#define OBOE_AAUDIO_EXTENSIONS_H
1919

20+
#include <algorithm>
2021
#include <dlfcn.h>
22+
#include <set>
2123
#include <stdint.h>
2224

2325
#include <sys/system_properties.h>
@@ -37,22 +39,82 @@ namespace oboe {
3739

3840
typedef struct AAudioStreamStruct AAudioStream;
3941

42+
// The output device type collection must be updated if there is any new added output device type
43+
const static std::set<DeviceType> ALL_OUTPUT_DEVICE_TYPES = {
44+
DeviceType::BuiltinEarpiece,
45+
DeviceType::BuiltinSpeaker,
46+
DeviceType::WiredHeadset,
47+
DeviceType::WiredHeadphones,
48+
DeviceType::LineAnalog,
49+
DeviceType::LineDigital,
50+
DeviceType::BluetoothSco,
51+
DeviceType::BluetoothA2dp,
52+
DeviceType::Hdmi,
53+
DeviceType::HdmiArc,
54+
DeviceType::HdmiEarc,
55+
DeviceType::UsbDevice,
56+
DeviceType::UsbHeadset,
57+
DeviceType::UsbAccessory,
58+
DeviceType::Dock,
59+
DeviceType::DockAnalog,
60+
DeviceType::FM,
61+
DeviceType::Telephony,
62+
DeviceType::AuxLine,
63+
DeviceType::IP,
64+
DeviceType::Bus,
65+
DeviceType::HearingAid,
66+
DeviceType::BuiltinSpeakerSafe,
67+
DeviceType::RemoteSubmix,
68+
DeviceType::BleHeadset,
69+
DeviceType::BleSpeaker,
70+
DeviceType::BleBroadcast,
71+
};
72+
73+
// The input device type collection must be updated if there is any new added input device type
74+
const static std::set<DeviceType> ALL_INPUT_DEVICE_TYPES = {
75+
DeviceType::BuiltinMic,
76+
DeviceType::BluetoothSco,
77+
DeviceType::WiredHeadset,
78+
DeviceType::Hdmi,
79+
DeviceType::Telephony,
80+
DeviceType::Dock,
81+
DeviceType::DockAnalog,
82+
DeviceType::UsbAccessory,
83+
DeviceType::UsbDevice,
84+
DeviceType::UsbHeadset,
85+
DeviceType::FMTuner,
86+
DeviceType::TVTuner,
87+
DeviceType::LineAnalog,
88+
DeviceType::LineDigital,
89+
DeviceType::BluetoothA2dp,
90+
DeviceType::IP,
91+
DeviceType::Bus,
92+
DeviceType::RemoteSubmix,
93+
DeviceType::BleHeadset,
94+
DeviceType::HdmiArc,
95+
DeviceType::HdmiEarc,
96+
};
97+
4098
/**
4199
* Call some AAudio test routines that are not part of the normal API.
42100
*/
43101
class AAudioExtensions {
44102
private: // Because it is a singleton. Call getInstance() instead.
45103
AAudioExtensions() {
46-
int32_t policy = getIntegerProperty("aaudio.mmap_policy", 0);
47-
mMMapSupported = isPolicyEnabled(policy);
104+
mLibLoader = AAudioLoader::getInstance();
105+
if (!initMMapPolicy()) {
106+
int32_t policy = getIntegerProperty("aaudio.mmap_policy", 0);
107+
mMMapSupported = isPolicyEnabled(policy);
48108

49-
policy = getIntegerProperty("aaudio.mmap_exclusive_policy", 0);
50-
mMMapExclusiveSupported = isPolicyEnabled(policy);
109+
policy = getIntegerProperty("aaudio.mmap_exclusive_policy", 0);
110+
mMMapExclusiveSupported = isPolicyEnabled(policy);
111+
}
51112
}
52113

53114
public:
54115
static bool isPolicyEnabled(int32_t policy) {
55-
return (policy == AAUDIO_POLICY_AUTO || policy == AAUDIO_POLICY_ALWAYS);
116+
const MMapPolicy mmapPolicy = static_cast<MMapPolicy>(policy);
117+
return (mmapPolicy == MMapPolicy::Auto || mmapPolicy == MMapPolicy::Always);
56118
}
57119

58120
static AAudioExtensions &getInstance() {
@@ -66,6 +128,9 @@ class AAudioExtensions {
66128
}
67129

68130
bool isMMapUsed(AAudioStream *aaudioStream) {
131+
if (mLibLoader != nullptr && mLibLoader->stream_isMMapUsed != nullptr) {
132+
return mLibLoader->stream_isMMapUsed(aaudioStream);
133+
}
69134
if (loadSymbols()) return false;
70135
if (mAAudioStream_isMMap == nullptr) return false;
71136
return mAAudioStream_isMMap(aaudioStream);
@@ -80,12 +145,27 @@ class AAudioExtensions {
80145
* @return 0 or a negative error code
81146
*/
82147
int32_t setMMapEnabled(bool enabled) {
148+
// The API for setting mmap policy is public after API level 36.
149+
if (mLibLoader != nullptr && mLibLoader->aaudio_setMMapPolicy != nullptr) {
150+
return mLibLoader->aaudio_setMMapPolicy(
151+
static_cast<aaudio_policy_t>(enabled ? MMapPolicy::Auto : MMapPolicy::Never));
152+
}
153+
// When there is no public API, fallback to loading the symbol from hidden API.
83154
if (loadSymbols()) return AAUDIO_ERROR_UNAVAILABLE;
84155
if (mAAudio_setMMapPolicy == nullptr) return false;
85-
return mAAudio_setMMapPolicy(enabled ? AAUDIO_POLICY_AUTO : AAUDIO_POLICY_NEVER);
156+
return mAAudio_setMMapPolicy(
157+
static_cast<int32_t>(enabled ? MMapPolicy::Auto : MMapPolicy::Never));
86158
}
87159

88160
bool isMMapEnabled() {
161+
// The API for getting mmap policy is public after API level 36.
162+
// Use it when it is available.
163+
if (mLibLoader != nullptr && mLibLoader->aaudio_getMMapPolicy != nullptr) {
164+
MMapPolicy policy = static_cast<MMapPolicy>(mLibLoader->aaudio_getMMapPolicy());
165+
return policy == MMapPolicy::Unspecified
166+
? mMMapSupported : isPolicyEnabled(static_cast<int32_t>(policy));
167+
}
168+
// When there is no public API, fallback to loading the symbol from hidden API.
89169
if (loadSymbols()) return false;
90170
if (mAAudio_getMMapPolicy == nullptr) return false;
91171
int32_t policy = mAAudio_getMMapPolicy();
@@ -100,14 +180,63 @@ class AAudioExtensions {
100180
return mMMapExclusiveSupported;
101181
}
102182

103-
private:
183+
MMapPolicy getMMapPolicy(DeviceType deviceType, Direction direction) {
184+
if (mLibLoader == nullptr ||
185+
mLibLoader->aaudio_getPlatformMMapPolicy == nullptr) {
186+
return MMapPolicy::Unspecified;
187+
}
188+
return static_cast<MMapPolicy>(mLibLoader->aaudio_getPlatformMMapPolicy(
189+
static_cast<AAudio_DeviceType>(deviceType),
190+
static_cast<aaudio_direction_t>(direction)));
191+
}
104192

105-
enum {
106-
AAUDIO_POLICY_NEVER = 1,
107-
AAUDIO_POLICY_AUTO,
108-
AAUDIO_POLICY_ALWAYS
109-
};
110-
typedef int32_t aaudio_policy_t;
193+
MMapPolicy getMMapExclusivePolicy(DeviceType deviceType, Direction direction) {
194+
if (mLibLoader == nullptr ||
195+
mLibLoader->aaudio_getPlatformMMapExclusivePolicy == nullptr) {
196+
return MMapPolicy::Unspecified;
197+
}
198+
return static_cast<MMapPolicy>(mLibLoader->aaudio_getPlatformMMapExclusivePolicy(
199+
static_cast<AAudio_DeviceType>(deviceType),
200+
static_cast<aaudio_direction_t>(direction)));
201+
}
202+
203+
bool isPartialDataCallbackSupported() {
204+
return mLibLoader != nullptr && mLibLoader->builder_setPartialDataCallback != nullptr;
205+
}
206+
207+
private:
208+
bool initMMapPolicy() {
209+
if (mLibLoader == nullptr || mLibLoader->open() != 0) {
210+
return false;
211+
}
212+
if (mLibLoader->aaudio_getPlatformMMapPolicy == nullptr ||
213+
mLibLoader->aaudio_getPlatformMMapExclusivePolicy == nullptr) {
214+
return false;
215+
}
216+
mMMapSupported =
217+
std::any_of(ALL_INPUT_DEVICE_TYPES.begin(), ALL_INPUT_DEVICE_TYPES.end(),
218+
[this](DeviceType deviceType) {
219+
return isPolicyEnabled(static_cast<int32_t>(
220+
getMMapPolicy(deviceType, Direction::Input)));
221+
}) ||
222+
std::any_of(ALL_OUTPUT_DEVICE_TYPES.begin(), ALL_OUTPUT_DEVICE_TYPES.end(),
223+
[this](DeviceType deviceType) {
224+
return isPolicyEnabled(static_cast<int32_t>(
225+
getMMapPolicy(deviceType, Direction::Output)));
226+
});
227+
mMMapExclusiveSupported =
228+
std::any_of(ALL_INPUT_DEVICE_TYPES.begin(), ALL_INPUT_DEVICE_TYPES.end(),
229+
[this](DeviceType deviceType) {
230+
return isPolicyEnabled(static_cast<int32_t>(
231+
getMMapExclusivePolicy(deviceType, Direction::Input)));
232+
}) ||
233+
std::any_of(ALL_OUTPUT_DEVICE_TYPES.begin(), ALL_OUTPUT_DEVICE_TYPES.end(),
234+
[this](DeviceType deviceType) {
235+
return isPolicyEnabled(static_cast<int32_t>(
236+
getMMapExclusivePolicy(deviceType, Direction::Output)));
237+
});
238+
return true;
239+
}
111240

112241
int getIntegerProperty(const char *name, int defaultValue) {
113242
int result = defaultValue;
@@ -130,14 +259,12 @@ class AAudioExtensions {
130259
return 0;
131260
}
132261

133-
AAudioLoader *libLoader = AAudioLoader::getInstance();
134-
int openResult = libLoader->open();
135-
if (openResult != 0) {
262+
if (mLibLoader == nullptr || mLibLoader->open() != 0) {
136263
LOGD("%s() could not open " LIB_AAUDIO_NAME, __func__);
137264
return AAUDIO_ERROR_UNAVAILABLE;
138265
}
139266

140-
void *libHandle = AAudioLoader::getInstance()->getLibHandle();
267+
void *libHandle = mLibLoader->getLibHandle();
141268
if (libHandle == nullptr) {
142269
LOGE("%s() could not find " LIB_AAUDIO_NAME, __func__);
143270
return AAUDIO_ERROR_UNAVAILABLE;
@@ -173,6 +300,8 @@ class AAudioExtensions {
173300
bool (*mAAudioStream_isMMap)(AAudioStream *stream) = nullptr;
174301
int32_t (*mAAudio_setMMapPolicy)(aaudio_policy_t policy) = nullptr;
175302
aaudio_policy_t (*mAAudio_getMMapPolicy)() = nullptr;
303+
304+
AAudioLoader *mLibLoader;
176305
};
177306

178307
} // namespace oboe

‎internal/oboe/oboe_aaudio_AAudioLoader_android.cpp‎

Lines changed: 128 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -102,6 +102,10 @@ int AAudioLoader::open() {
102102
builder_setSpatializationBehavior = load_V_PBI("AAudioStreamBuilder_setSpatializationBehavior");
103103
}
104104

105+
if (getSdkVersion() >= __ANDROID_API_B__) {
106+
builder_setPresentationEndCallback = load_V_PBPRPV("AAudioStreamBuilder_setPresentationEndCallback");
107+
}
108+
105109
builder_delete = load_I_PB("AAudioStreamBuilder_delete");
106110

107111

@@ -177,6 +181,32 @@ int AAudioLoader::open() {
177181
stream_getHardwareFormat = load_F_PS("AAudioStream_getHardwareFormat");
178182
}
179183

184+
// TODO: Remove pre-release check after Android B release
185+
if (getSdkVersion() >= __ANDROID_API_B__ || isAtLeastPreReleaseCodename("Baklava")) {
186+
aaudio_getPlatformMMapPolicy = load_I_II("AAudio_getPlatformMMapPolicy");
187+
aaudio_getPlatformMMapExclusivePolicy = load_I_II("AAudio_getPlatformMMapExclusivePolicy");
188+
aaudio_setMMapPolicy = load_I_I("AAudio_setMMapPolicy");
189+
aaudio_getMMapPolicy = load_I("AAudio_getMMapPolicy");
190+
stream_isMMapUsed = load_O_PS("AAudioStream_isMMapUsed");
191+
192+
stream_setOffloadDelayPadding = load_I_PSII("AAudioStream_setOffloadDelayPadding");
193+
stream_getOffloadDelay = load_I_PS("AAudioStream_getOffloadDelay");
194+
stream_getOffloadPadding = load_I_PS("AAudioStream_getOffloadPadding");
195+
stream_setOffloadEndOfStream = load_I_PS("AAudioStream_setOffloadEndOfStream");
196+
197+
stream_getDeviceIds = load_I_PSPIPI("AAudioStream_getDeviceIds");
198+
199+
// TODO: Use 25Q4 version code and name when it is defined.
200+
stream_flushFromFrame = load_I_PSIPL("AAudioStream_flushFromFrame");
201+
stream_getPlaybackParameters =
202+
load_I_PSPM("AAudioStream_getPlaybackParameters");
203+
stream_setPlaybackParameters =
204+
load_I_PSCPM("AAudioStream_setPlaybackParameters");
205+
206+
builder_setPartialDataCallback =
207+
load_V_PBPDPV("AAudioStreamBuilder_setPartialDataCallback");
208+
}
209+
180210
return 0;
181211
}
182212

@@ -306,6 +336,60 @@ AAudioLoader::signature_V_PBO AAudioLoader::load_V_PBO(const char *functionName)
306336
return reinterpret_cast<signature_V_PBO>(proc);
307337
}
308338

339+
AAudioLoader::signature_I_II AAudioLoader::load_I_II(const char *functionName) {
340+
void *proc = dlsym(mLibHandle, functionName);
341+
AAudioLoader_check(proc, functionName);
342+
return reinterpret_cast<signature_I_II>(proc);
343+
}
344+
345+
AAudioLoader::signature_I_I AAudioLoader::load_I_I(const char *functionName) {
346+
void *proc = dlsym(mLibHandle, functionName);
347+
AAudioLoader_check(proc, functionName);
348+
return reinterpret_cast<signature_I_I>(proc);
349+
}
350+
351+
AAudioLoader::signature_I AAudioLoader::load_I(const char *functionName) {
352+
void *proc = dlsym(mLibHandle, functionName);
353+
AAudioLoader_check(proc, functionName);
354+
return reinterpret_cast<signature_I>(proc);
355+
}
356+
357+
AAudioLoader::signature_V_PBPRPV AAudioLoader::load_V_PBPRPV(const char *functionName) {
358+
void *proc = dlsym(mLibHandle, functionName);
359+
AAudioLoader_check(proc, functionName);
360+
return reinterpret_cast<signature_V_PBPRPV>(proc);
361+
}
362+
363+
AAudioLoader::signature_I_PSII AAudioLoader::load_I_PSII(const char *functionName) {
364+
void *proc = dlsym(mLibHandle, functionName);
365+
AAudioLoader_check(proc, functionName);
366+
return reinterpret_cast<signature_I_PSII>(proc);
367+
}
368+
369+
AAudioLoader::signature_I_PSPIPI AAudioLoader::load_I_PSPIPI(const char *functionName) {
370+
void *proc = dlsym(mLibHandle, functionName);
371+
AAudioLoader_check(proc, functionName);
372+
return reinterpret_cast<signature_I_PSPIPI>(proc);
373+
}
374+
375+
AAudioLoader::signature_I_PSIPL AAudioLoader::load_I_PSIPL(const char *functionName) {
376+
void *proc = dlsym(mLibHandle, functionName);
377+
AAudioLoader_check(proc, functionName);
378+
return reinterpret_cast<signature_I_PSIPL>(proc);
379+
}
380+
381+
AAudioLoader::signature_I_PSPM AAudioLoader::load_I_PSPM(const char *functionName) {
382+
void *proc = dlsym(mLibHandle, functionName);
383+
AAudioLoader_check(proc, functionName);
384+
return reinterpret_cast<signature_I_PSPM>(proc);
385+
}
386+
387+
AAudioLoader::signature_I_PSCPM AAudioLoader::load_I_PSCPM(const char *functionName) {
388+
void *proc = dlsym(mLibHandle, functionName);
389+
AAudioLoader_check(proc, functionName);
390+
return reinterpret_cast<signature_I_PSCPM>(proc);
391+
}
392+
309393
// Ensure that all AAudio primitive data types are int32_t
310394
#define ASSERT_INT32(type) static_assert(std::is_same<int32_t, type>::value, \
311395
#type" must be int32_t")
@@ -501,6 +585,50 @@ AAudioLoader::signature_V_PBO AAudioLoader::load_V_PBO(const char *functionName)
501585

502586
#endif
503587

588+
// The aaudio device type and aaudio policy were added in NDK 29,
589+
// which is the first version to support Android B (API 36).
590+
#if __NDK_MAJOR__ >= 30
591+
592+
ASSERT_INT32(AAudio_DeviceType);
593+
static_assert((int32_t)DeviceType::BuiltinEarpiece == AAUDIO_DEVICE_BUILTIN_EARPIECE, ERRMSG);
594+
static_assert((int32_t)DeviceType::BuiltinSpeaker == AAUDIO_DEVICE_BUILTIN_SPEAKER, ERRMSG);
595+
static_assert((int32_t)DeviceType::WiredHeadset == AAUDIO_DEVICE_WIRED_HEADSET, ERRMSG);
596+
static_assert((int32_t)DeviceType::WiredHeadphones == AAUDIO_DEVICE_WIRED_HEADPHONES, ERRMSG);
597+
static_assert((int32_t)DeviceType::LineAnalog == AAUDIO_DEVICE_LINE_ANALOG, ERRMSG);
598+
static_assert((int32_t)DeviceType::LineDigital == AAUDIO_DEVICE_LINE_DIGITAL, ERRMSG);
599+
static_assert((int32_t)DeviceType::BluetoothSco == AAUDIO_DEVICE_BLUETOOTH_SCO, ERRMSG);
600+
static_assert((int32_t)DeviceType::BluetoothA2dp == AAUDIO_DEVICE_BLUETOOTH_A2DP, ERRMSG);
601+
static_assert((int32_t)DeviceType::Hdmi == AAUDIO_DEVICE_HDMI, ERRMSG);
602+
static_assert((int32_t)DeviceType::HdmiArc == AAUDIO_DEVICE_HDMI_ARC, ERRMSG);
603+
static_assert((int32_t)DeviceType::UsbDevice == AAUDIO_DEVICE_USB_DEVICE, ERRMSG);
604+
static_assert((int32_t)DeviceType::UsbAccessory == AAUDIO_DEVICE_USB_ACCESSORY, ERRMSG);
605+
static_assert((int32_t)DeviceType::Dock == AAUDIO_DEVICE_DOCK, ERRMSG);
606+
static_assert((int32_t)DeviceType::FM == AAUDIO_DEVICE_FM, ERRMSG);
607+
static_assert((int32_t)DeviceType::BuiltinMic == AAUDIO_DEVICE_BUILTIN_MIC, ERRMSG);
608+
static_assert((int32_t)DeviceType::FMTuner == AAUDIO_DEVICE_FM_TUNER, ERRMSG);
609+
static_assert((int32_t)DeviceType::TVTuner == AAUDIO_DEVICE_TV_TUNER, ERRMSG);
610+
static_assert((int32_t)DeviceType::Telephony == AAUDIO_DEVICE_TELEPHONY, ERRMSG);
611+
static_assert((int32_t)DeviceType::AuxLine == AAUDIO_DEVICE_AUX_LINE, ERRMSG);
612+
static_assert((int32_t)DeviceType::IP == AAUDIO_DEVICE_IP, ERRMSG);
613+
static_assert((int32_t)DeviceType::Bus == AAUDIO_DEVICE_BUS, ERRMSG);
614+
static_assert((int32_t)DeviceType::UsbHeadset == AAUDIO_DEVICE_USB_HEADSET, ERRMSG);
615+
static_assert((int32_t)DeviceType::HearingAid == AAUDIO_DEVICE_HEARING_AID, ERRMSG);
616+
static_assert((int32_t)DeviceType::BuiltinSpeakerSafe == AAUDIO_DEVICE_BUILTIN_SPEAKER_SAFE, ERRMSG);
617+
static_assert((int32_t)DeviceType::RemoteSubmix == AAUDIO_DEVICE_REMOTE_SUBMIX, ERRMSG);
618+
static_assert((int32_t)DeviceType::BleHeadset == AAUDIO_DEVICE_BLE_HEADSET, ERRMSG);
619+
static_assert((int32_t)DeviceType::BleSpeaker == AAUDIO_DEVICE_BLE_SPEAKER, ERRMSG);
620+
static_assert((int32_t)DeviceType::HdmiEarc == AAUDIO_DEVICE_HDMI_EARC, ERRMSG);
621+
static_assert((int32_t)DeviceType::BleBroadcast == AAUDIO_DEVICE_BLE_BROADCAST, ERRMSG);
622+
static_assert((int32_t)DeviceType::DockAnalog == AAUDIO_DEVICE_DOCK_ANALOG, ERRMSG);
623+
624+
ASSERT_INT32(aaudio_policy_t);
625+
static_assert((int32_t)MMapPolicy::Unspecified == AAUDIO_UNSPECIFIED, ERRMSG);
626+
static_assert((int32_t)MMapPolicy::Never == AAUDIO_POLICY_NEVER, ERRMSG);
627+
static_assert((int32_t)MMapPolicy::Auto == AAUDIO_POLICY_AUTO, ERRMSG);
628+
static_assert((int32_t)MMapPolicy::Always == AAUDIO_POLICY_ALWAYS, ERRMSG);
629+
630+
#endif // __NDK_MAJOR__ >= 29
631+
504632
#endif // AAUDIO_AAUDIO_H
505633

506634
} // namespace oboe

0 commit comments

Comments
 (0)