1 /*
2 * Copyright (C) 2023 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <dlfcn.h>
18 #include <string.h>
19
20 #include "SLES/OpenSLES.h"
21 #include "SLES/OpenSLES_Android.h"
22
23 #include "berberis/base/logging.h"
24 #include "berberis/base/macros.h"
25 #include "berberis/guest_abi/function_wrappers.h"
26 #include "berberis/guest_abi/guest_params.h"
27 #include "berberis/guest_state/guest_addr.h"
28 #include "berberis/guest_state/guest_state.h"
29 #include "berberis/proxy_loader/proxy_library_builder.h"
30
31 #define LOG_SLES(...)
32
33 namespace berberis {
34
35 namespace {
36
37 #define REGISTER_TRAMPOLINE(itf_name, func_name) \
38 WrapHostFunction((*itf)->func_name, #itf_name "::" #func_name)
39
40 #define REGISTER_CUSTOM_TRAMPOLINE(itf_name, func_name) \
41 do { \
42 void* func = reinterpret_cast<void*>((*itf)->func_name); \
43 WrapHostFunctionImpl( \
44 func, DoCustomTrampoline_##itf_name##_##func_name, #itf_name "::" #func_name); \
45 } while (0)
46
RegisterSL3DCommitItfMethods(SL3DCommitItf itf)47 void RegisterSL3DCommitItfMethods(SL3DCommitItf itf) {
48 REGISTER_TRAMPOLINE(SL3DCommit, Commit);
49 REGISTER_TRAMPOLINE(SL3DCommit, SetDeferred);
50 }
51
RegisterSL3DDopplerItfMethods(SL3DDopplerItf itf)52 void RegisterSL3DDopplerItfMethods(SL3DDopplerItf itf) {
53 REGISTER_TRAMPOLINE(SL3DDoppler, SetVelocityCartesian);
54 REGISTER_TRAMPOLINE(SL3DDoppler, SetVelocitySpherical);
55 REGISTER_TRAMPOLINE(SL3DDoppler, GetVelocityCartesian);
56 REGISTER_TRAMPOLINE(SL3DDoppler, SetDopplerFactor);
57 REGISTER_TRAMPOLINE(SL3DDoppler, GetDopplerFactor);
58 }
59
RegisterSL3DGroupingItfMethods(SL3DGroupingItf itf)60 void RegisterSL3DGroupingItfMethods(SL3DGroupingItf itf) {
61 REGISTER_TRAMPOLINE(SL3DGrouping, Set3DGroup);
62 REGISTER_TRAMPOLINE(SL3DGrouping, Get3DGroup);
63 }
64
RegisterSL3DLocationItfMethods(SL3DLocationItf itf)65 void RegisterSL3DLocationItfMethods(SL3DLocationItf itf) {
66 REGISTER_TRAMPOLINE(SL3DLocation, SetLocationCartesian);
67 REGISTER_TRAMPOLINE(SL3DLocation, SetLocationSpherical);
68 REGISTER_TRAMPOLINE(SL3DLocation, Move);
69 REGISTER_TRAMPOLINE(SL3DLocation, GetLocationCartesian);
70 REGISTER_TRAMPOLINE(SL3DLocation, SetOrientationVectors);
71 REGISTER_TRAMPOLINE(SL3DLocation, SetOrientationAngles);
72 REGISTER_TRAMPOLINE(SL3DLocation, Rotate);
73 REGISTER_TRAMPOLINE(SL3DLocation, GetOrientationVectors);
74 }
75
RegisterSL3DMacroscopicItfMethods(SL3DMacroscopicItf itf)76 void RegisterSL3DMacroscopicItfMethods(SL3DMacroscopicItf itf) {
77 REGISTER_TRAMPOLINE(SL3DMacroscopic, SetSize);
78 REGISTER_TRAMPOLINE(SL3DMacroscopic, GetSize);
79 REGISTER_TRAMPOLINE(SL3DMacroscopic, SetOrientationAngles);
80 REGISTER_TRAMPOLINE(SL3DMacroscopic, SetOrientationVectors);
81 REGISTER_TRAMPOLINE(SL3DMacroscopic, Rotate);
82 REGISTER_TRAMPOLINE(SL3DMacroscopic, GetOrientationVectors);
83 }
84
RegisterSL3DSourceItfMethods(SL3DSourceItf itf)85 void RegisterSL3DSourceItfMethods(SL3DSourceItf itf) {
86 REGISTER_TRAMPOLINE(SL3DSource, SetHeadRelative);
87 REGISTER_TRAMPOLINE(SL3DSource, GetHeadRelative);
88 REGISTER_TRAMPOLINE(SL3DSource, SetRolloffDistances);
89 REGISTER_TRAMPOLINE(SL3DSource, GetRolloffDistances);
90 REGISTER_TRAMPOLINE(SL3DSource, SetRolloffMaxDistanceMute);
91 REGISTER_TRAMPOLINE(SL3DSource, GetRolloffMaxDistanceMute);
92 REGISTER_TRAMPOLINE(SL3DSource, SetRolloffFactor);
93 REGISTER_TRAMPOLINE(SL3DSource, GetRolloffFactor);
94 REGISTER_TRAMPOLINE(SL3DSource, SetRoomRolloffFactor);
95 REGISTER_TRAMPOLINE(SL3DSource, GetRoomRolloffFactor);
96 REGISTER_TRAMPOLINE(SL3DSource, SetRolloffModel);
97 REGISTER_TRAMPOLINE(SL3DSource, GetRolloffModel);
98 REGISTER_TRAMPOLINE(SL3DSource, SetCone);
99 REGISTER_TRAMPOLINE(SL3DSource, GetCone);
100 }
101
RegisterSLAndroidAcousticEchoCancellationItfMethods(SLAndroidAcousticEchoCancellationItf itf)102 void RegisterSLAndroidAcousticEchoCancellationItfMethods(SLAndroidAcousticEchoCancellationItf itf) {
103 REGISTER_TRAMPOLINE(SLAndroidAcousticEchoCancellation, SetEnabled);
104 REGISTER_TRAMPOLINE(SLAndroidAcousticEchoCancellation, IsEnabled);
105 }
106
RegisterSLAndroidAutomaticGainControlItfMethods(SLAndroidAutomaticGainControlItf itf)107 void RegisterSLAndroidAutomaticGainControlItfMethods(SLAndroidAutomaticGainControlItf itf) {
108 REGISTER_TRAMPOLINE(SLAndroidAutomaticGainControl, SetEnabled);
109 REGISTER_TRAMPOLINE(SLAndroidAutomaticGainControl, IsEnabled);
110 }
111
DoCustomTrampoline_SLAndroidBufferQueueItf_RegisterCallback(HostCode,ProcessState *)112 void DoCustomTrampoline_SLAndroidBufferQueueItf_RegisterCallback(HostCode /* callee */,
113 ProcessState* /* state */) {
114 LOG_ALWAYS_FATAL("not implemented: SLAndroidBufferQueueItf::RegisterCallback");
115 }
116
RegisterSLAndroidBufferQueueItfMethods(SLAndroidBufferQueueItf itf)117 void RegisterSLAndroidBufferQueueItfMethods(SLAndroidBufferQueueItf itf) {
118 REGISTER_CUSTOM_TRAMPOLINE(SLAndroidBufferQueueItf, RegisterCallback);
119 REGISTER_TRAMPOLINE(SLAndroidBufferQueue, Clear);
120 REGISTER_TRAMPOLINE(SLAndroidBufferQueue, Enqueue);
121 REGISTER_TRAMPOLINE(SLAndroidBufferQueue, GetState);
122 REGISTER_TRAMPOLINE(SLAndroidBufferQueue, SetCallbackEventsMask);
123 REGISTER_TRAMPOLINE(SLAndroidBufferQueue, GetCallbackEventsMask);
124 }
125
RegisterSLAndroidConfigurationItfMethods(SLAndroidConfigurationItf itf)126 void RegisterSLAndroidConfigurationItfMethods(SLAndroidConfigurationItf itf) {
127 REGISTER_TRAMPOLINE(SLAndroidConfiguration, SetConfiguration);
128 REGISTER_TRAMPOLINE(SLAndroidConfiguration, GetConfiguration);
129 REGISTER_TRAMPOLINE(SLAndroidConfiguration, AcquireJavaProxy);
130 REGISTER_TRAMPOLINE(SLAndroidConfiguration, ReleaseJavaProxy);
131 }
132
RegisterSLAndroidEffectItfMethods(SLAndroidEffectItf itf)133 void RegisterSLAndroidEffectItfMethods(SLAndroidEffectItf itf) {
134 REGISTER_TRAMPOLINE(SLAndroidEffect, CreateEffect);
135 REGISTER_TRAMPOLINE(SLAndroidEffect, ReleaseEffect);
136 REGISTER_TRAMPOLINE(SLAndroidEffect, SetEnabled);
137 REGISTER_TRAMPOLINE(SLAndroidEffect, IsEnabled);
138 REGISTER_TRAMPOLINE(SLAndroidEffect, SendCommand);
139 }
140
RegisterSLAndroidEffectCapabilitiesItfMethods(SLAndroidEffectCapabilitiesItf itf)141 void RegisterSLAndroidEffectCapabilitiesItfMethods(SLAndroidEffectCapabilitiesItf itf) {
142 REGISTER_TRAMPOLINE(SLAndroidEffectCapabilities, QueryNumEffects);
143 REGISTER_TRAMPOLINE(SLAndroidEffectCapabilities, QueryEffect);
144 }
145
RegisterSLAndroidEffectSendItfMethods(SLAndroidEffectSendItf itf)146 void RegisterSLAndroidEffectSendItfMethods(SLAndroidEffectSendItf itf) {
147 REGISTER_TRAMPOLINE(SLAndroidEffectSend, EnableEffectSend);
148 REGISTER_TRAMPOLINE(SLAndroidEffectSend, IsEnabled);
149 REGISTER_TRAMPOLINE(SLAndroidEffectSend, SetDirectLevel);
150 REGISTER_TRAMPOLINE(SLAndroidEffectSend, GetDirectLevel);
151 REGISTER_TRAMPOLINE(SLAndroidEffectSend, SetSendLevel);
152 REGISTER_TRAMPOLINE(SLAndroidEffectSend, GetSendLevel);
153 }
154
RegisterSLAndroidNoiseSuppressionItfMethods(SLAndroidNoiseSuppressionItf itf)155 void RegisterSLAndroidNoiseSuppressionItfMethods(SLAndroidNoiseSuppressionItf itf) {
156 REGISTER_TRAMPOLINE(SLAndroidNoiseSuppression, SetEnabled);
157 REGISTER_TRAMPOLINE(SLAndroidNoiseSuppression, IsEnabled);
158 }
159
DoCustomTrampoline_SLAndroidSimpleBufferQueueItf_RegisterCallback(HostCode callee,ProcessState * state)160 void DoCustomTrampoline_SLAndroidSimpleBufferQueueItf_RegisterCallback(HostCode callee,
161 ProcessState* state) {
162 using PFN_callee = decltype(std::declval<SLAndroidSimpleBufferQueueItf_>().RegisterCallback);
163 PFN_callee callee_function = AsFuncPtr(callee);
164 auto [buffer_queue, guest_callback, context] = GuestParamsValues<PFN_callee>(state);
165 slAndroidSimpleBufferQueueCallback host_callback =
166 WrapGuestFunction(guest_callback, "SLAndroidSimpleBufferQueueItf_RegisterCallback-callback");
167 auto&& [ret] = GuestReturnReference<PFN_callee>(state);
168 ret = callee_function(buffer_queue, host_callback, context);
169 }
170
RegisterSLAndroidSimpleBufferQueueItfMethods(SLAndroidSimpleBufferQueueItf itf)171 void RegisterSLAndroidSimpleBufferQueueItfMethods(SLAndroidSimpleBufferQueueItf itf) {
172 REGISTER_TRAMPOLINE(SLAndroidSimpleBufferQueue, Enqueue);
173 REGISTER_TRAMPOLINE(SLAndroidSimpleBufferQueue, Clear);
174 REGISTER_TRAMPOLINE(SLAndroidSimpleBufferQueue, GetState);
175 REGISTER_CUSTOM_TRAMPOLINE(SLAndroidSimpleBufferQueueItf, RegisterCallback);
176 }
177
RegisterSLAudioDecoderCapabilitiesItfMethods(SLAudioDecoderCapabilitiesItf itf)178 void RegisterSLAudioDecoderCapabilitiesItfMethods(SLAudioDecoderCapabilitiesItf itf) {
179 REGISTER_TRAMPOLINE(SLAudioDecoderCapabilities, GetAudioDecoders);
180 REGISTER_TRAMPOLINE(SLAudioDecoderCapabilities, GetAudioDecoderCapabilities);
181 }
182
RegisterSLAudioEncoderItfMethods(SLAudioEncoderItf itf)183 void RegisterSLAudioEncoderItfMethods(SLAudioEncoderItf itf) {
184 REGISTER_TRAMPOLINE(SLAudioEncoder, SetEncoderSettings);
185 REGISTER_TRAMPOLINE(SLAudioEncoder, GetEncoderSettings);
186 }
187
RegisterSLAudioEncoderCapabilitiesItfMethods(SLAudioEncoderCapabilitiesItf itf)188 void RegisterSLAudioEncoderCapabilitiesItfMethods(SLAudioEncoderCapabilitiesItf itf) {
189 REGISTER_TRAMPOLINE(SLAudioEncoderCapabilities, GetAudioEncoders);
190 REGISTER_TRAMPOLINE(SLAudioEncoderCapabilities, GetAudioEncoderCapabilities);
191 }
192
DoCustomTrampoline_SLAudioIODeviceCapabilitiesItf_RegisterAvailableAudioInputsChangedCallback(HostCode,ProcessState *)193 void DoCustomTrampoline_SLAudioIODeviceCapabilitiesItf_RegisterAvailableAudioInputsChangedCallback(
194 HostCode /* callee */,
195 ProcessState* /* state */) {
196 LOG_ALWAYS_FATAL(
197 "not implemented: "
198 "SLAudioIODeviceCapabilitiesItf::RegisterAvailableAudioInputsChangedCallback");
199 }
200
DoCustomTrampoline_SLAudioIODeviceCapabilitiesItf_RegisterAvailableAudioOutputsChangedCallback(HostCode,ProcessState *)201 void DoCustomTrampoline_SLAudioIODeviceCapabilitiesItf_RegisterAvailableAudioOutputsChangedCallback(
202 HostCode /* callee */,
203 ProcessState* /* state */) {
204 LOG_ALWAYS_FATAL(
205 "not implemented: "
206 "SLAudioIODeviceCapabilitiesItf::RegisterAvailableAudioOutputsChangedCallback");
207 }
208
DoCustomTrampoline_SLAudioIODeviceCapabilitiesItf_RegisterDefaultDeviceIDMapChangedCallback(HostCode,ProcessState *)209 void DoCustomTrampoline_SLAudioIODeviceCapabilitiesItf_RegisterDefaultDeviceIDMapChangedCallback(
210 HostCode /* callee */,
211 ProcessState* /* state */) {
212 LOG_ALWAYS_FATAL(
213 "not implemented: SLAudioIODeviceCapabilitiesItf::RegisterDefaultDeviceIDMapChangedCallback");
214 }
215
RegisterSLAudioIODeviceCapabilitiesItfMethods(SLAudioIODeviceCapabilitiesItf itf)216 void RegisterSLAudioIODeviceCapabilitiesItfMethods(SLAudioIODeviceCapabilitiesItf itf) {
217 REGISTER_TRAMPOLINE(SLAudioIODeviceCapabilities, GetAvailableAudioInputs);
218 REGISTER_TRAMPOLINE(SLAudioIODeviceCapabilities, QueryAudioInputCapabilities);
219 REGISTER_CUSTOM_TRAMPOLINE(SLAudioIODeviceCapabilitiesItf,
220 RegisterAvailableAudioInputsChangedCallback);
221 REGISTER_TRAMPOLINE(SLAudioIODeviceCapabilities, GetAvailableAudioOutputs);
222 REGISTER_TRAMPOLINE(SLAudioIODeviceCapabilities, QueryAudioOutputCapabilities);
223 REGISTER_CUSTOM_TRAMPOLINE(SLAudioIODeviceCapabilitiesItf,
224 RegisterAvailableAudioOutputsChangedCallback);
225 REGISTER_CUSTOM_TRAMPOLINE(SLAudioIODeviceCapabilitiesItf,
226 RegisterDefaultDeviceIDMapChangedCallback);
227 REGISTER_TRAMPOLINE(SLAudioIODeviceCapabilities, GetAssociatedAudioInputs);
228 REGISTER_TRAMPOLINE(SLAudioIODeviceCapabilities, GetAssociatedAudioOutputs);
229 REGISTER_TRAMPOLINE(SLAudioIODeviceCapabilities, GetDefaultAudioDevices);
230 REGISTER_TRAMPOLINE(SLAudioIODeviceCapabilities, QuerySampleFormatsSupported);
231 }
232
RegisterSLBassBoostItfMethods(SLBassBoostItf itf)233 void RegisterSLBassBoostItfMethods(SLBassBoostItf itf) {
234 REGISTER_TRAMPOLINE(SLBassBoost, SetEnabled);
235 REGISTER_TRAMPOLINE(SLBassBoost, IsEnabled);
236 REGISTER_TRAMPOLINE(SLBassBoost, SetStrength);
237 REGISTER_TRAMPOLINE(SLBassBoost, GetRoundedStrength);
238 REGISTER_TRAMPOLINE(SLBassBoost, IsStrengthSupported);
239 }
240
DoCustomTrampoline_SLBufferQueueItf_RegisterCallback(HostCode callee,ProcessState * state)241 void DoCustomTrampoline_SLBufferQueueItf_RegisterCallback(HostCode callee, ProcessState* state) {
242 using PFN_callee = decltype(std::declval<SLBufferQueueItf_>().RegisterCallback);
243 PFN_callee callee_function = AsFuncPtr(callee);
244 auto [buffer_queue, guest_callback, context] = GuestParamsValues<PFN_callee>(state);
245 slBufferQueueCallback host_callback =
246 WrapGuestFunction(guest_callback, "SLBufferQueueItf_RegisterCallback-callback");
247 auto&& [ret] = GuestReturnReference<PFN_callee>(state);
248 ret = callee_function(buffer_queue, host_callback, context);
249 }
250
RegisterSLBufferQueueItfMethods(SLBufferQueueItf itf)251 void RegisterSLBufferQueueItfMethods(SLBufferQueueItf itf) {
252 REGISTER_TRAMPOLINE(SLBufferQueue, Enqueue);
253 REGISTER_TRAMPOLINE(SLBufferQueue, Clear);
254 REGISTER_TRAMPOLINE(SLBufferQueue, GetState);
255 REGISTER_CUSTOM_TRAMPOLINE(SLBufferQueueItf, RegisterCallback);
256 }
257
RegisterSLDeviceVolumeItfMethods(SLDeviceVolumeItf itf)258 void RegisterSLDeviceVolumeItfMethods(SLDeviceVolumeItf itf) {
259 REGISTER_TRAMPOLINE(SLDeviceVolume, GetVolumeScale);
260 REGISTER_TRAMPOLINE(SLDeviceVolume, SetVolume);
261 REGISTER_TRAMPOLINE(SLDeviceVolume, GetVolume);
262 }
263
DoCustomTrampoline_SLDynamicInterfaceManagementItf_RegisterCallback(HostCode,ProcessState *)264 void DoCustomTrampoline_SLDynamicInterfaceManagementItf_RegisterCallback(
265 HostCode /* callee */,
266 ProcessState* /* state */) {
267 LOG_ALWAYS_FATAL("not implemented: SLDynamicInterfaceManagementItf::RegisterCallback");
268 }
269
RegisterSLDynamicInterfaceManagementItfMethods(SLDynamicInterfaceManagementItf itf)270 void RegisterSLDynamicInterfaceManagementItfMethods(SLDynamicInterfaceManagementItf itf) {
271 REGISTER_TRAMPOLINE(SLDynamicInterfaceManagement, AddInterface);
272 REGISTER_TRAMPOLINE(SLDynamicInterfaceManagement, RemoveInterface);
273 REGISTER_TRAMPOLINE(SLDynamicInterfaceManagement, ResumeInterface);
274 REGISTER_CUSTOM_TRAMPOLINE(SLDynamicInterfaceManagementItf, RegisterCallback);
275 }
276
RegisterSLDynamicSourceItfMethods(SLDynamicSourceItf itf)277 void RegisterSLDynamicSourceItfMethods(SLDynamicSourceItf itf) {
278 REGISTER_TRAMPOLINE(SLDynamicSource, SetSource);
279 }
280
RegisterSLEffectSendItfMethods(SLEffectSendItf itf)281 void RegisterSLEffectSendItfMethods(SLEffectSendItf itf) {
282 REGISTER_TRAMPOLINE(SLEffectSend, EnableEffectSend);
283 REGISTER_TRAMPOLINE(SLEffectSend, IsEnabled);
284 REGISTER_TRAMPOLINE(SLEffectSend, SetDirectLevel);
285 REGISTER_TRAMPOLINE(SLEffectSend, GetDirectLevel);
286 REGISTER_TRAMPOLINE(SLEffectSend, SetSendLevel);
287 REGISTER_TRAMPOLINE(SLEffectSend, GetSendLevel);
288 }
289
RegisterSLEngineItfMethods(SLEngineItf itf)290 void RegisterSLEngineItfMethods(SLEngineItf itf) {
291 REGISTER_TRAMPOLINE(SLEngine, CreateLEDDevice);
292 REGISTER_TRAMPOLINE(SLEngine, CreateVibraDevice);
293 REGISTER_TRAMPOLINE(SLEngine, CreateAudioPlayer);
294 REGISTER_TRAMPOLINE(SLEngine, CreateAudioRecorder);
295 REGISTER_TRAMPOLINE(SLEngine, CreateMidiPlayer);
296 REGISTER_TRAMPOLINE(SLEngine, CreateListener);
297 REGISTER_TRAMPOLINE(SLEngine, Create3DGroup);
298 REGISTER_TRAMPOLINE(SLEngine, CreateOutputMix);
299 REGISTER_TRAMPOLINE(SLEngine, CreateMetadataExtractor);
300 REGISTER_TRAMPOLINE(SLEngine, CreateExtensionObject);
301 REGISTER_TRAMPOLINE(SLEngine, QueryNumSupportedInterfaces);
302 REGISTER_TRAMPOLINE(SLEngine, QuerySupportedInterfaces);
303 REGISTER_TRAMPOLINE(SLEngine, QueryNumSupportedExtensions);
304 REGISTER_TRAMPOLINE(SLEngine, QuerySupportedExtension);
305 REGISTER_TRAMPOLINE(SLEngine, IsExtensionSupported);
306 }
307
RegisterSLEngineCapabilitiesItfMethods(SLEngineCapabilitiesItf itf)308 void RegisterSLEngineCapabilitiesItfMethods(SLEngineCapabilitiesItf itf) {
309 REGISTER_TRAMPOLINE(SLEngineCapabilities, QuerySupportedProfiles);
310 REGISTER_TRAMPOLINE(SLEngineCapabilities, QueryAvailableVoices);
311 REGISTER_TRAMPOLINE(SLEngineCapabilities, QueryNumberOfMIDISynthesizers);
312 REGISTER_TRAMPOLINE(SLEngineCapabilities, QueryAPIVersion);
313 REGISTER_TRAMPOLINE(SLEngineCapabilities, QueryLEDCapabilities);
314 REGISTER_TRAMPOLINE(SLEngineCapabilities, QueryVibraCapabilities);
315 REGISTER_TRAMPOLINE(SLEngineCapabilities, IsThreadSafe);
316 }
317
RegisterSLEnvironmentalReverbItfMethods(SLEnvironmentalReverbItf itf)318 void RegisterSLEnvironmentalReverbItfMethods(SLEnvironmentalReverbItf itf) {
319 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, SetRoomLevel);
320 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, GetRoomLevel);
321 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, SetRoomHFLevel);
322 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, GetRoomHFLevel);
323 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, SetDecayTime);
324 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, GetDecayTime);
325 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, SetDecayHFRatio);
326 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, GetDecayHFRatio);
327 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, SetReflectionsLevel);
328 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, GetReflectionsLevel);
329 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, SetReflectionsDelay);
330 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, GetReflectionsDelay);
331 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, SetReverbLevel);
332 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, GetReverbLevel);
333 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, SetReverbDelay);
334 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, GetReverbDelay);
335 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, SetDiffusion);
336 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, GetDiffusion);
337 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, SetDensity);
338 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, GetDensity);
339 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, SetEnvironmentalReverbProperties);
340 REGISTER_TRAMPOLINE(SLEnvironmentalReverb, GetEnvironmentalReverbProperties);
341 }
342
RegisterSLEqualizerItfMethods(SLEqualizerItf itf)343 void RegisterSLEqualizerItfMethods(SLEqualizerItf itf) {
344 REGISTER_TRAMPOLINE(SLEqualizer, SetEnabled);
345 REGISTER_TRAMPOLINE(SLEqualizer, IsEnabled);
346 REGISTER_TRAMPOLINE(SLEqualizer, GetNumberOfBands);
347 REGISTER_TRAMPOLINE(SLEqualizer, GetBandLevelRange);
348 REGISTER_TRAMPOLINE(SLEqualizer, SetBandLevel);
349 REGISTER_TRAMPOLINE(SLEqualizer, GetBandLevel);
350 REGISTER_TRAMPOLINE(SLEqualizer, GetCenterFreq);
351 REGISTER_TRAMPOLINE(SLEqualizer, GetBandFreqRange);
352 REGISTER_TRAMPOLINE(SLEqualizer, GetBand);
353 REGISTER_TRAMPOLINE(SLEqualizer, GetCurrentPreset);
354 REGISTER_TRAMPOLINE(SLEqualizer, UsePreset);
355 REGISTER_TRAMPOLINE(SLEqualizer, GetNumberOfPresets);
356 REGISTER_TRAMPOLINE(SLEqualizer, GetPresetName);
357 }
358
RegisterSLLEDArrayItfMethods(SLLEDArrayItf itf)359 void RegisterSLLEDArrayItfMethods(SLLEDArrayItf itf) {
360 REGISTER_TRAMPOLINE(SLLEDArray, ActivateLEDArray);
361 REGISTER_TRAMPOLINE(SLLEDArray, IsLEDArrayActivated);
362 REGISTER_TRAMPOLINE(SLLEDArray, SetColor);
363 REGISTER_TRAMPOLINE(SLLEDArray, GetColor);
364 }
365
DoCustomTrampoline_SLMIDIMessageItf_RegisterMetaEventCallback(HostCode,ProcessState *)366 void DoCustomTrampoline_SLMIDIMessageItf_RegisterMetaEventCallback(HostCode /* callee */,
367 ProcessState* /* state */) {
368 LOG_ALWAYS_FATAL("not implemented: SLMIDIMessageItf::RegisterMetaEventCallback");
369 }
370
DoCustomTrampoline_SLMIDIMessageItf_RegisterMIDIMessageCallback(HostCode,ProcessState *)371 void DoCustomTrampoline_SLMIDIMessageItf_RegisterMIDIMessageCallback(HostCode /* callee */,
372 ProcessState* /* state */) {
373 LOG_ALWAYS_FATAL("not implemented: SLMIDIMessageItf::RegisterMIDIMessageCallback");
374 }
375
RegisterSLMIDIMessageItfMethods(SLMIDIMessageItf itf)376 void RegisterSLMIDIMessageItfMethods(SLMIDIMessageItf itf) {
377 REGISTER_TRAMPOLINE(SLMIDIMessage, SendMessage);
378 REGISTER_CUSTOM_TRAMPOLINE(SLMIDIMessageItf, RegisterMetaEventCallback);
379 REGISTER_CUSTOM_TRAMPOLINE(SLMIDIMessageItf, RegisterMIDIMessageCallback);
380 REGISTER_TRAMPOLINE(SLMIDIMessage, AddMIDIMessageCallbackFilter);
381 REGISTER_TRAMPOLINE(SLMIDIMessage, ClearMIDIMessageCallbackFilter);
382 }
383
RegisterSLMIDIMuteSoloItfMethods(SLMIDIMuteSoloItf itf)384 void RegisterSLMIDIMuteSoloItfMethods(SLMIDIMuteSoloItf itf) {
385 REGISTER_TRAMPOLINE(SLMIDIMuteSolo, SetChannelMute);
386 REGISTER_TRAMPOLINE(SLMIDIMuteSolo, GetChannelMute);
387 REGISTER_TRAMPOLINE(SLMIDIMuteSolo, SetChannelSolo);
388 REGISTER_TRAMPOLINE(SLMIDIMuteSolo, GetChannelSolo);
389 REGISTER_TRAMPOLINE(SLMIDIMuteSolo, GetTrackCount);
390 REGISTER_TRAMPOLINE(SLMIDIMuteSolo, SetTrackMute);
391 REGISTER_TRAMPOLINE(SLMIDIMuteSolo, GetTrackMute);
392 REGISTER_TRAMPOLINE(SLMIDIMuteSolo, SetTrackSolo);
393 REGISTER_TRAMPOLINE(SLMIDIMuteSolo, GetTrackSolo);
394 }
395
RegisterSLMIDITempoItfMethods(SLMIDITempoItf itf)396 void RegisterSLMIDITempoItfMethods(SLMIDITempoItf itf) {
397 REGISTER_TRAMPOLINE(SLMIDITempo, SetTicksPerQuarterNote);
398 REGISTER_TRAMPOLINE(SLMIDITempo, GetTicksPerQuarterNote);
399 REGISTER_TRAMPOLINE(SLMIDITempo, SetMicrosecondsPerQuarterNote);
400 REGISTER_TRAMPOLINE(SLMIDITempo, GetMicrosecondsPerQuarterNote);
401 }
402
RegisterSLMIDITimeItfMethods(SLMIDITimeItf itf)403 void RegisterSLMIDITimeItfMethods(SLMIDITimeItf itf) {
404 REGISTER_TRAMPOLINE(SLMIDITime, GetDuration);
405 REGISTER_TRAMPOLINE(SLMIDITime, SetPosition);
406 REGISTER_TRAMPOLINE(SLMIDITime, GetPosition);
407 REGISTER_TRAMPOLINE(SLMIDITime, SetLoopPoints);
408 REGISTER_TRAMPOLINE(SLMIDITime, GetLoopPoints);
409 }
410
RegisterSLMetadataExtractionItfMethods(SLMetadataExtractionItf itf)411 void RegisterSLMetadataExtractionItfMethods(SLMetadataExtractionItf itf) {
412 REGISTER_TRAMPOLINE(SLMetadataExtraction, GetItemCount);
413 REGISTER_TRAMPOLINE(SLMetadataExtraction, GetKeySize);
414 REGISTER_TRAMPOLINE(SLMetadataExtraction, GetKey);
415 REGISTER_TRAMPOLINE(SLMetadataExtraction, GetValueSize);
416 REGISTER_TRAMPOLINE(SLMetadataExtraction, GetValue);
417 REGISTER_TRAMPOLINE(SLMetadataExtraction, AddKeyFilter);
418 REGISTER_TRAMPOLINE(SLMetadataExtraction, ClearKeyFilter);
419 }
420
RegisterSLMetadataTraversalItfMethods(SLMetadataTraversalItf itf)421 void RegisterSLMetadataTraversalItfMethods(SLMetadataTraversalItf itf) {
422 REGISTER_TRAMPOLINE(SLMetadataTraversal, SetMode);
423 REGISTER_TRAMPOLINE(SLMetadataTraversal, GetChildCount);
424 REGISTER_TRAMPOLINE(SLMetadataTraversal, GetChildMIMETypeSize);
425 REGISTER_TRAMPOLINE(SLMetadataTraversal, GetChildInfo);
426 REGISTER_TRAMPOLINE(SLMetadataTraversal, SetActiveNode);
427 }
428
RegisterSLMuteSoloItfMethods(SLMuteSoloItf itf)429 void RegisterSLMuteSoloItfMethods(SLMuteSoloItf itf) {
430 REGISTER_TRAMPOLINE(SLMuteSolo, SetChannelMute);
431 REGISTER_TRAMPOLINE(SLMuteSolo, GetChannelMute);
432 REGISTER_TRAMPOLINE(SLMuteSolo, SetChannelSolo);
433 REGISTER_TRAMPOLINE(SLMuteSolo, GetChannelSolo);
434 REGISTER_TRAMPOLINE(SLMuteSolo, GetNumChannels);
435 }
436
437 void RegisterMethodsById(SLInterfaceID id, void* itf);
438
DoCustomTrampoline_SLObjectItf_GetInterface(HostCode callee,ProcessState * state)439 void DoCustomTrampoline_SLObjectItf_GetInterface(HostCode callee, ProcessState* state) {
440 using PFN_callee = decltype(std::declval<SLObjectItf_>().GetInterface);
441 PFN_callee callee_function = AsFuncPtr(callee);
442 auto [itf, id, pInterface] = GuestParamsValues<PFN_callee>(state);
443 auto&& [ret] = GuestReturnReference<PFN_callee>(state);
444 ret = callee_function(itf, id, pInterface);
445 if (ret != SL_RESULT_SUCCESS) {
446 return;
447 }
448 RegisterMethodsById(id, pInterface);
449 }
450
DoCustomTrampoline_SLObjectItf_RegisterCallback(HostCode callee,ProcessState * state)451 void DoCustomTrampoline_SLObjectItf_RegisterCallback(HostCode callee, ProcessState* state) {
452 using PFN_callee = decltype(std::declval<SLObjectItf_>().RegisterCallback);
453 PFN_callee callee_function = AsFuncPtr(callee);
454 auto [play, guest_callback, context] = GuestParamsValues<PFN_callee>(state);
455 slObjectCallback host_callback =
456 WrapGuestFunction(guest_callback, "SLObjectItf_RegisterCallback-callback");
457 auto&& [ret] = GuestReturnReference<PFN_callee>(state);
458 ret = callee_function(play, host_callback, context);
459 }
460
RegisterSLObjectItfMethods(SLObjectItf itf)461 void RegisterSLObjectItfMethods(SLObjectItf itf) {
462 REGISTER_TRAMPOLINE(SLObject, Realize);
463 REGISTER_TRAMPOLINE(SLObject, Resume);
464 REGISTER_TRAMPOLINE(SLObject, GetState);
465 REGISTER_CUSTOM_TRAMPOLINE(SLObjectItf, GetInterface);
466 REGISTER_CUSTOM_TRAMPOLINE(SLObjectItf, RegisterCallback);
467 REGISTER_TRAMPOLINE(SLObject, AbortAsyncOperation);
468 REGISTER_TRAMPOLINE(SLObject, Destroy);
469 REGISTER_TRAMPOLINE(SLObject, SetPriority);
470 REGISTER_TRAMPOLINE(SLObject, GetPriority);
471 REGISTER_TRAMPOLINE(SLObject, SetLossOfControlInterfaces);
472 }
473
DoCustomTrampoline_SLOutputMixItf_RegisterDeviceChangeCallback(HostCode,ProcessState *)474 void DoCustomTrampoline_SLOutputMixItf_RegisterDeviceChangeCallback(HostCode /* callee */,
475 ProcessState* /* state */) {
476 LOG_ALWAYS_FATAL("not implemented: SLOutputMixItf::RegisterDeviceChangeCallback");
477 }
478
RegisterSLOutputMixItfMethods(SLOutputMixItf itf)479 void RegisterSLOutputMixItfMethods(SLOutputMixItf itf) {
480 REGISTER_TRAMPOLINE(SLOutputMix, GetDestinationOutputDeviceIDs);
481 REGISTER_CUSTOM_TRAMPOLINE(SLOutputMixItf, RegisterDeviceChangeCallback);
482 REGISTER_TRAMPOLINE(SLOutputMix, ReRoute);
483 }
484
RegisterSLPitchItfMethods(SLPitchItf itf)485 void RegisterSLPitchItfMethods(SLPitchItf itf) {
486 REGISTER_TRAMPOLINE(SLPitch, SetPitch);
487 REGISTER_TRAMPOLINE(SLPitch, GetPitch);
488 REGISTER_TRAMPOLINE(SLPitch, GetPitchCapabilities);
489 }
490
DoCustomTrampoline_SLPlayItf_RegisterCallback(HostCode callee,ProcessState * state)491 void DoCustomTrampoline_SLPlayItf_RegisterCallback(HostCode callee, ProcessState* state) {
492 using PFN_callee = decltype(std::declval<SLPlayItf_>().RegisterCallback);
493 PFN_callee callee_function = AsFuncPtr(callee);
494 auto [play, guest_callback, context] = GuestParamsValues<PFN_callee>(state);
495 slPlayCallback host_callback =
496 WrapGuestFunction(guest_callback, "SLPlayItf_RegisterCallback-callback");
497 auto&& [ret] = GuestReturnReference<PFN_callee>(state);
498 ret = callee_function(play, host_callback, context);
499 }
500
RegisterSLPlayItfMethods(SLPlayItf itf)501 void RegisterSLPlayItfMethods(SLPlayItf itf) {
502 REGISTER_TRAMPOLINE(SLPlay, SetPlayState);
503 REGISTER_TRAMPOLINE(SLPlay, GetPlayState);
504 REGISTER_TRAMPOLINE(SLPlay, GetDuration);
505 REGISTER_TRAMPOLINE(SLPlay, GetPosition);
506 REGISTER_CUSTOM_TRAMPOLINE(SLPlayItf, RegisterCallback);
507 REGISTER_TRAMPOLINE(SLPlay, SetCallbackEventsMask);
508 REGISTER_TRAMPOLINE(SLPlay, GetCallbackEventsMask);
509 REGISTER_TRAMPOLINE(SLPlay, SetMarkerPosition);
510 REGISTER_TRAMPOLINE(SLPlay, ClearMarkerPosition);
511 REGISTER_TRAMPOLINE(SLPlay, GetMarkerPosition);
512 REGISTER_TRAMPOLINE(SLPlay, SetPositionUpdatePeriod);
513 REGISTER_TRAMPOLINE(SLPlay, GetPositionUpdatePeriod);
514 }
515
RegisterSLPlaybackRateItfMethods(SLPlaybackRateItf itf)516 void RegisterSLPlaybackRateItfMethods(SLPlaybackRateItf itf) {
517 REGISTER_TRAMPOLINE(SLPlaybackRate, SetRate);
518 REGISTER_TRAMPOLINE(SLPlaybackRate, GetRate);
519 REGISTER_TRAMPOLINE(SLPlaybackRate, SetPropertyConstraints);
520 REGISTER_TRAMPOLINE(SLPlaybackRate, GetProperties);
521 REGISTER_TRAMPOLINE(SLPlaybackRate, GetCapabilitiesOfRate);
522 REGISTER_TRAMPOLINE(SLPlaybackRate, GetRateRange);
523 }
524
DoCustomTrampoline_SLPrefetchStatusItf_RegisterCallback(HostCode callee,ProcessState * state)525 void DoCustomTrampoline_SLPrefetchStatusItf_RegisterCallback(HostCode callee, ProcessState* state) {
526 using PFN_callee = decltype(std::declval<SLPrefetchStatusItf_>().RegisterCallback);
527 PFN_callee callee_function = AsFuncPtr(callee);
528 auto [self, guest_callback, context] = GuestParamsValues<PFN_callee>(state);
529 slPrefetchCallback host_callback =
530 WrapGuestFunction(guest_callback, "SLPrefetchStatusItf_RegisterCallback-callback");
531 auto&& [ret] = GuestReturnReference<PFN_callee>(state);
532 ret = callee_function(self, host_callback, context);
533 }
534
RegisterSLPrefetchStatusItfMethods(SLPrefetchStatusItf itf)535 void RegisterSLPrefetchStatusItfMethods(SLPrefetchStatusItf itf) {
536 REGISTER_TRAMPOLINE(SLPrefetchStatus, GetPrefetchStatus);
537 REGISTER_TRAMPOLINE(SLPrefetchStatus, GetFillLevel);
538 REGISTER_CUSTOM_TRAMPOLINE(SLPrefetchStatusItf, RegisterCallback);
539 REGISTER_TRAMPOLINE(SLPrefetchStatus, SetCallbackEventsMask);
540 REGISTER_TRAMPOLINE(SLPrefetchStatus, GetCallbackEventsMask);
541 REGISTER_TRAMPOLINE(SLPrefetchStatus, SetFillUpdatePeriod);
542 REGISTER_TRAMPOLINE(SLPrefetchStatus, GetFillUpdatePeriod);
543 }
544
RegisterSLPresetReverbItfMethods(SLPresetReverbItf itf)545 void RegisterSLPresetReverbItfMethods(SLPresetReverbItf itf) {
546 REGISTER_TRAMPOLINE(SLPresetReverb, SetPreset);
547 REGISTER_TRAMPOLINE(SLPresetReverb, GetPreset);
548 }
549
RegisterSLRatePitchItfMethods(SLRatePitchItf itf)550 void RegisterSLRatePitchItfMethods(SLRatePitchItf itf) {
551 REGISTER_TRAMPOLINE(SLRatePitch, SetRate);
552 REGISTER_TRAMPOLINE(SLRatePitch, GetRate);
553 REGISTER_TRAMPOLINE(SLRatePitch, GetRatePitchCapabilities);
554 }
555
DoCustomTrampoline_SLRecordItf_RegisterCallback(HostCode callee,ProcessState * state)556 void DoCustomTrampoline_SLRecordItf_RegisterCallback(HostCode callee, ProcessState* state) {
557 using PFN_callee = decltype(std::declval<SLRecordItf_>().RegisterCallback);
558 PFN_callee callee_function = AsFuncPtr(callee);
559 auto [record, guest_callback, context] = GuestParamsValues<PFN_callee>(state);
560 slRecordCallback host_callback =
561 WrapGuestFunction(guest_callback, "SLRecordItf_RegisterCallback-callback");
562 auto&& [ret] = GuestReturnReference<PFN_callee>(state);
563 ret = callee_function(record, host_callback, context);
564 }
565
RegisterSLRecordItfMethods(SLRecordItf itf)566 void RegisterSLRecordItfMethods(SLRecordItf itf) {
567 REGISTER_TRAMPOLINE(SLRecord, SetRecordState);
568 REGISTER_TRAMPOLINE(SLRecord, GetRecordState);
569 REGISTER_TRAMPOLINE(SLRecord, SetDurationLimit);
570 REGISTER_TRAMPOLINE(SLRecord, GetPosition);
571 REGISTER_CUSTOM_TRAMPOLINE(SLRecordItf, RegisterCallback);
572 REGISTER_TRAMPOLINE(SLRecord, SetCallbackEventsMask);
573 REGISTER_TRAMPOLINE(SLRecord, GetCallbackEventsMask);
574 REGISTER_TRAMPOLINE(SLRecord, SetMarkerPosition);
575 REGISTER_TRAMPOLINE(SLRecord, ClearMarkerPosition);
576 REGISTER_TRAMPOLINE(SLRecord, GetMarkerPosition);
577 REGISTER_TRAMPOLINE(SLRecord, SetPositionUpdatePeriod);
578 REGISTER_TRAMPOLINE(SLRecord, GetPositionUpdatePeriod);
579 }
580
RegisterSLSeekItfMethods(SLSeekItf itf)581 void RegisterSLSeekItfMethods(SLSeekItf itf) {
582 REGISTER_TRAMPOLINE(SLSeek, SetPosition);
583 REGISTER_TRAMPOLINE(SLSeek, SetLoop);
584 REGISTER_TRAMPOLINE(SLSeek, GetLoop);
585 }
586
RegisterSLThreadSyncItfMethods(SLThreadSyncItf itf)587 void RegisterSLThreadSyncItfMethods(SLThreadSyncItf itf) {
588 REGISTER_TRAMPOLINE(SLThreadSync, EnterCriticalSection);
589 REGISTER_TRAMPOLINE(SLThreadSync, ExitCriticalSection);
590 }
591
RegisterSLVibraItfMethods(SLVibraItf itf)592 void RegisterSLVibraItfMethods(SLVibraItf itf) {
593 REGISTER_TRAMPOLINE(SLVibra, Vibrate);
594 REGISTER_TRAMPOLINE(SLVibra, IsVibrating);
595 REGISTER_TRAMPOLINE(SLVibra, SetFrequency);
596 REGISTER_TRAMPOLINE(SLVibra, GetFrequency);
597 REGISTER_TRAMPOLINE(SLVibra, SetIntensity);
598 REGISTER_TRAMPOLINE(SLVibra, GetIntensity);
599 }
600
RegisterSLVirtualizerItfMethods(SLVirtualizerItf itf)601 void RegisterSLVirtualizerItfMethods(SLVirtualizerItf itf) {
602 REGISTER_TRAMPOLINE(SLVirtualizer, SetEnabled);
603 REGISTER_TRAMPOLINE(SLVirtualizer, IsEnabled);
604 REGISTER_TRAMPOLINE(SLVirtualizer, SetStrength);
605 REGISTER_TRAMPOLINE(SLVirtualizer, GetRoundedStrength);
606 REGISTER_TRAMPOLINE(SLVirtualizer, IsStrengthSupported);
607 }
608
DoCustomTrampoline_SLVisualizationItf_RegisterVisualizationCallback(HostCode,ProcessState *)609 void DoCustomTrampoline_SLVisualizationItf_RegisterVisualizationCallback(
610 HostCode /* callee */,
611 ProcessState* /* state */) {
612 LOG_ALWAYS_FATAL("not implemented: SLVisualizationItf::RegisterVisualizationCallback");
613 }
614
RegisterSLVisualizationItfMethods(SLVisualizationItf itf)615 void RegisterSLVisualizationItfMethods(SLVisualizationItf itf) {
616 REGISTER_CUSTOM_TRAMPOLINE(SLVisualizationItf, RegisterVisualizationCallback);
617 REGISTER_TRAMPOLINE(SLVisualization, GetMaxRate);
618 }
619
RegisterSLVolumeItfMethods(SLVolumeItf itf)620 void RegisterSLVolumeItfMethods(SLVolumeItf itf) {
621 REGISTER_TRAMPOLINE(SLVolume, SetVolumeLevel);
622 REGISTER_TRAMPOLINE(SLVolume, GetVolumeLevel);
623 REGISTER_TRAMPOLINE(SLVolume, GetMaxVolumeLevel);
624 REGISTER_TRAMPOLINE(SLVolume, SetMute);
625 REGISTER_TRAMPOLINE(SLVolume, GetMute);
626 REGISTER_TRAMPOLINE(SLVolume, EnableStereoPosition);
627 REGISTER_TRAMPOLINE(SLVolume, IsEnabledStereoPosition);
628 REGISTER_TRAMPOLINE(SLVolume, SetStereoPosition);
629 REGISTER_TRAMPOLINE(SLVolume, GetStereoPosition);
630 }
631
632 #undef REGISTER_CUSTOM_TRAMPOLINE
633
isSLID(SLInterfaceID id,SLInterfaceID id2)634 bool isSLID(SLInterfaceID id, SLInterfaceID id2) {
635 return memcmp(id, id2, sizeof(*id)) == 0;
636 }
637
638 const char* GetIDName(const SLInterfaceID& id);
639
RegisterMethodsById(SLInterfaceID id,void * itf)640 void RegisterMethodsById(SLInterfaceID id, void* itf) {
641 if (isSLID(id, SL_IID_3DCOMMIT)) {
642 LOG_SLES("SL_IID_3DCOMMIT");
643 RegisterSL3DCommitItfMethods(*static_cast<SL3DCommitItf*>(itf));
644 return;
645 }
646 if (isSLID(id, SL_IID_3DDOPPLER)) {
647 LOG_SLES("SL_IID_3DDOPPLER");
648 RegisterSL3DDopplerItfMethods(*static_cast<SL3DDopplerItf*>(itf));
649 return;
650 }
651 if (isSLID(id, SL_IID_3DGROUPING)) {
652 LOG_SLES("SL_IID_3DGROUPING");
653 RegisterSL3DGroupingItfMethods(*static_cast<SL3DGroupingItf*>(itf));
654 return;
655 }
656 if (isSLID(id, SL_IID_3DLOCATION)) {
657 LOG_SLES("SL_IID_3DLOCATION");
658 RegisterSL3DLocationItfMethods(*static_cast<SL3DLocationItf*>(itf));
659 return;
660 }
661 if (isSLID(id, SL_IID_3DMACROSCOPIC)) {
662 LOG_SLES("SL_IID_3DMACROSCOPIC");
663 RegisterSL3DMacroscopicItfMethods(*static_cast<SL3DMacroscopicItf*>(itf));
664 return;
665 }
666 if (isSLID(id, SL_IID_3DSOURCE)) {
667 LOG_SLES("SL_IID_3DSOURCE");
668 RegisterSL3DSourceItfMethods(*static_cast<SL3DSourceItf*>(itf));
669 return;
670 }
671 if (isSLID(id, SL_IID_ANDROIDACOUSTICECHOCANCELLATION)) {
672 LOG_SLES("SL_IID_ANDROIDACOUSTICECHOCANCELLATION");
673 RegisterSLAndroidAcousticEchoCancellationItfMethods(
674 *static_cast<SLAndroidAcousticEchoCancellationItf*>(itf));
675 return;
676 }
677 if (isSLID(id, SL_IID_ANDROIDAUTOMATICGAINCONTROL)) {
678 LOG_SLES("SL_IID_ANDROIDAUTOMATICGAINCONTROL");
679 RegisterSLAndroidAutomaticGainControlItfMethods(
680 *static_cast<SLAndroidAutomaticGainControlItf*>(itf));
681 return;
682 }
683 if (isSLID(id, SL_IID_ANDROIDBUFFERQUEUESOURCE)) {
684 LOG_SLES("SL_IID_ANDROIDBUFFERQUEUESOURCE");
685 RegisterSLAndroidBufferQueueItfMethods(*static_cast<SLAndroidBufferQueueItf*>(itf));
686 return;
687 }
688 if (isSLID(id, SL_IID_ANDROIDCONFIGURATION)) {
689 LOG_SLES("SL_IID_ANDROIDCONFIGURATION");
690 RegisterSLAndroidConfigurationItfMethods(*static_cast<SLAndroidConfigurationItf*>(itf));
691 return;
692 }
693 if (isSLID(id, SL_IID_ANDROIDEFFECT)) {
694 LOG_SLES("SL_IID_ANDROIDEFFECT");
695 RegisterSLAndroidEffectItfMethods(*static_cast<SLAndroidEffectItf*>(itf));
696 return;
697 }
698 if (isSLID(id, SL_IID_ANDROIDEFFECTCAPABILITIES)) {
699 LOG_SLES("SL_IID_ANDROIDEFFECTCAPABILITIES");
700 RegisterSLAndroidEffectCapabilitiesItfMethods(
701 *static_cast<SLAndroidEffectCapabilitiesItf*>(itf));
702 return;
703 }
704 if (isSLID(id, SL_IID_ANDROIDEFFECTSEND)) {
705 LOG_SLES("SL_IID_ANDROIDEFFECTSEND");
706 RegisterSLAndroidEffectSendItfMethods(*static_cast<SLAndroidEffectSendItf*>(itf));
707 return;
708 }
709 if (isSLID(id, SL_IID_ANDROIDNOISESUPPRESSION)) {
710 LOG_SLES("SL_IID_ANDROIDNOISESUPPRESSION");
711 RegisterSLAndroidNoiseSuppressionItfMethods(*static_cast<SLAndroidNoiseSuppressionItf*>(itf));
712 return;
713 }
714 if (isSLID(id, SL_IID_ANDROIDSIMPLEBUFFERQUEUE)) {
715 LOG_SLES("SL_IID_ANDROIDSIMPLEBUFFERQUEUE");
716 RegisterSLAndroidSimpleBufferQueueItfMethods(*static_cast<SLAndroidSimpleBufferQueueItf*>(itf));
717 return;
718 }
719 if (isSLID(id, SL_IID_AUDIODECODERCAPABILITIES)) {
720 LOG_SLES("SL_IID_AUDIODECODERCAPABILITIES");
721 RegisterSLAudioDecoderCapabilitiesItfMethods(*static_cast<SLAudioDecoderCapabilitiesItf*>(itf));
722 return;
723 }
724 if (isSLID(id, SL_IID_AUDIOENCODER)) {
725 LOG_SLES("SL_IID_AUDIOENCODER");
726 RegisterSLAudioEncoderItfMethods(*static_cast<SLAudioEncoderItf*>(itf));
727 return;
728 }
729 if (isSLID(id, SL_IID_AUDIOENCODERCAPABILITIES)) {
730 LOG_SLES("SL_IID_AUDIOENCODERCAPABILITIES");
731 RegisterSLAudioEncoderCapabilitiesItfMethods(*static_cast<SLAudioEncoderCapabilitiesItf*>(itf));
732 return;
733 }
734 if (isSLID(id, SL_IID_AUDIOIODEVICECAPABILITIES)) {
735 LOG_SLES("SL_IID_AUDIOIODEVICECAPABILITIES");
736 RegisterSLAudioIODeviceCapabilitiesItfMethods(
737 *static_cast<SLAudioIODeviceCapabilitiesItf*>(itf));
738 return;
739 }
740 if (isSLID(id, SL_IID_BASSBOOST)) {
741 LOG_SLES("SL_IID_BASSBOOST");
742 RegisterSLBassBoostItfMethods(*static_cast<SLBassBoostItf*>(itf));
743 return;
744 }
745 if (isSLID(id, SL_IID_BUFFERQUEUE)) {
746 LOG_SLES("SL_IID_BUFFERQUEUE");
747 RegisterSLBufferQueueItfMethods(*static_cast<SLBufferQueueItf*>(itf));
748 return;
749 }
750 if (isSLID(id, SL_IID_DEVICEVOLUME)) {
751 LOG_SLES("SL_IID_DEVICEVOLUME");
752 RegisterSLDeviceVolumeItfMethods(*static_cast<SLDeviceVolumeItf*>(itf));
753 return;
754 }
755 if (isSLID(id, SL_IID_DYNAMICINTERFACEMANAGEMENT)) {
756 LOG_SLES("SL_IID_DYNAMICINTERFACEMANAGEMENT");
757 RegisterSLDynamicInterfaceManagementItfMethods(
758 *static_cast<SLDynamicInterfaceManagementItf*>(itf));
759 return;
760 }
761 if (isSLID(id, SL_IID_DYNAMICSOURCE)) {
762 LOG_SLES("SL_IID_DYNAMICSOURCE");
763 RegisterSLDynamicSourceItfMethods(*static_cast<SLDynamicSourceItf*>(itf));
764 return;
765 }
766 if (isSLID(id, SL_IID_EFFECTSEND)) {
767 LOG_SLES("SL_IID_EFFECTSEND");
768 RegisterSLEffectSendItfMethods(*static_cast<SLEffectSendItf*>(itf));
769 return;
770 }
771 if (isSLID(id, SL_IID_ENGINE)) {
772 LOG_SLES("SL_IID_ENGINE");
773 RegisterSLEngineItfMethods(*static_cast<SLEngineItf*>(itf));
774 return;
775 }
776 if (isSLID(id, SL_IID_ENGINECAPABILITIES)) {
777 LOG_SLES("SL_IID_ENGINECAPABILITIES");
778 RegisterSLEngineCapabilitiesItfMethods(*static_cast<SLEngineCapabilitiesItf*>(itf));
779 return;
780 }
781 if (isSLID(id, SL_IID_ENVIRONMENTALREVERB)) {
782 LOG_SLES("SL_IID_ENVIRONMENTALREVERB");
783 RegisterSLEnvironmentalReverbItfMethods(*static_cast<SLEnvironmentalReverbItf*>(itf));
784 return;
785 }
786 if (isSLID(id, SL_IID_EQUALIZER)) {
787 LOG_SLES("SL_IID_EQUALIZER");
788 RegisterSLEqualizerItfMethods(*static_cast<SLEqualizerItf*>(itf));
789 return;
790 }
791 if (isSLID(id, SL_IID_LED)) {
792 LOG_SLES("SL_IID_LED");
793 RegisterSLLEDArrayItfMethods(*static_cast<SLLEDArrayItf*>(itf));
794 return;
795 }
796 if (isSLID(id, SL_IID_METADATAEXTRACTION)) {
797 LOG_SLES("SL_IID_METADATAEXTRACTION");
798 RegisterSLMetadataExtractionItfMethods(*static_cast<SLMetadataExtractionItf*>(itf));
799 return;
800 }
801 if (isSLID(id, SL_IID_METADATATRAVERSAL)) {
802 LOG_SLES("SL_IID_METADATATRAVERSAL");
803 RegisterSLMetadataTraversalItfMethods(*static_cast<SLMetadataTraversalItf*>(itf));
804 return;
805 }
806 if (isSLID(id, SL_IID_MIDIMESSAGE)) {
807 LOG_SLES("SL_IID_MIDIMESSAGE");
808 RegisterSLMIDIMessageItfMethods(*static_cast<SLMIDIMessageItf*>(itf));
809 return;
810 }
811 if (isSLID(id, SL_IID_MIDIMUTESOLO)) {
812 LOG_SLES("SL_IID_MIDIMUTESOLO");
813 RegisterSLMIDIMuteSoloItfMethods(*static_cast<SLMIDIMuteSoloItf*>(itf));
814 return;
815 }
816 if (isSLID(id, SL_IID_MIDITEMPO)) {
817 LOG_SLES("SL_IID_MIDITEMPO");
818 RegisterSLMIDITempoItfMethods(*static_cast<SLMIDITempoItf*>(itf));
819 return;
820 }
821 if (isSLID(id, SL_IID_MIDITIME)) {
822 LOG_SLES("SL_IID_MIDITIME");
823 RegisterSLMIDITimeItfMethods(*static_cast<SLMIDITimeItf*>(itf));
824 return;
825 }
826 if (isSLID(id, SL_IID_MUTESOLO)) {
827 LOG_SLES("SL_IID_MUTESOLO");
828 RegisterSLMuteSoloItfMethods(*static_cast<SLMuteSoloItf*>(itf));
829 return;
830 }
831 if (isSLID(id, SL_IID_OBJECT)) {
832 LOG_SLES("SL_IID_OBJECT");
833 RegisterSLObjectItfMethods(*static_cast<SLObjectItf*>(itf));
834 return;
835 }
836 if (isSLID(id, SL_IID_OUTPUTMIX)) {
837 LOG_SLES("SL_IID_OUTPUTMIX");
838 RegisterSLOutputMixItfMethods(*static_cast<SLOutputMixItf*>(itf));
839 return;
840 }
841 if (isSLID(id, SL_IID_PITCH)) {
842 LOG_SLES("SL_IID_PITCH");
843 RegisterSLPitchItfMethods(*static_cast<SLPitchItf*>(itf));
844 return;
845 }
846 if (isSLID(id, SL_IID_PLAY)) {
847 LOG_SLES("SL_IID_PLAY");
848 RegisterSLPlayItfMethods(*static_cast<SLPlayItf*>(itf));
849 return;
850 }
851 if (isSLID(id, SL_IID_PLAYBACKRATE)) {
852 LOG_SLES("SL_IID_PLAYBACKRATE");
853 RegisterSLPlaybackRateItfMethods(*static_cast<SLPlaybackRateItf*>(itf));
854 return;
855 }
856 if (isSLID(id, SL_IID_PREFETCHSTATUS)) {
857 LOG_SLES("SL_IID_PREFETCHSTATUS");
858 RegisterSLPrefetchStatusItfMethods(*static_cast<SLPrefetchStatusItf*>(itf));
859 return;
860 }
861 if (isSLID(id, SL_IID_PRESETREVERB)) {
862 LOG_SLES("SL_IID_PRESETREVERB");
863 RegisterSLPresetReverbItfMethods(*static_cast<SLPresetReverbItf*>(itf));
864 return;
865 }
866 if (isSLID(id, SL_IID_RATEPITCH)) {
867 LOG_SLES("SL_IID_RATEPITCH");
868 RegisterSLRatePitchItfMethods(*static_cast<SLRatePitchItf*>(itf));
869 return;
870 }
871 if (isSLID(id, SL_IID_RECORD)) {
872 LOG_SLES("SL_IID_RECORD");
873 RegisterSLRecordItfMethods(*static_cast<SLRecordItf*>(itf));
874 return;
875 }
876 if (isSLID(id, SL_IID_SEEK)) {
877 LOG_SLES("SL_IID_SEEK");
878 RegisterSLSeekItfMethods(*static_cast<SLSeekItf*>(itf));
879 return;
880 }
881 if (isSLID(id, SL_IID_THREADSYNC)) {
882 LOG_SLES("SL_IID_THREADSYNC");
883 RegisterSLThreadSyncItfMethods(*static_cast<SLThreadSyncItf*>(itf));
884 return;
885 }
886 if (isSLID(id, SL_IID_VIBRA)) {
887 LOG_SLES("SL_IID_VIBRA");
888 RegisterSLVibraItfMethods(*static_cast<SLVibraItf*>(itf));
889 return;
890 }
891 if (isSLID(id, SL_IID_VIRTUALIZER)) {
892 LOG_SLES("SL_IID_VIRTUALIZER");
893 RegisterSLVirtualizerItfMethods(*static_cast<SLVirtualizerItf*>(itf));
894 return;
895 }
896 if (isSLID(id, SL_IID_VISUALIZATION)) {
897 LOG_SLES("SL_IID_VISUALIZATION");
898 RegisterSLVisualizationItfMethods(*static_cast<SLVisualizationItf*>(itf));
899 return;
900 }
901 if (isSLID(id, SL_IID_VOLUME)) {
902 LOG_SLES("SL_IID_VOLUME");
903 RegisterSLVolumeItfMethods(*static_cast<SLVolumeItf*>(itf));
904 return;
905 }
906 LOG_ALWAYS_FATAL("Unknown id=%s", GetIDName(id));
907 }
908
DoCustomTrampoline_slCreateEngine(HostCode,ProcessState * state)909 void DoCustomTrampoline_slCreateEngine(HostCode /* callee */, ProcessState* state) {
910 auto [pEngine, numOptions, pEngineOptions, numInterfaces, pInterfaceIds, pInterfaceRequired] =
911 GuestParamsValues<decltype(slCreateEngine)>(state);
912 // Attention: we cannot write directly to ret here since we use pEngine param below.
913 auto&& [ret] = GuestReturnReference<decltype(slCreateEngine)>(state);
914 ret = slCreateEngine(
915 pEngine, numOptions, pEngineOptions, numInterfaces, pInterfaceIds, pInterfaceRequired);
916 if (ret == SL_RESULT_SUCCESS) {
917 RegisterSLObjectItfMethods(*pEngine);
918 }
919 }
920
921 #if defined(NATIVE_BRIDGE_GUEST_ARCH_ARM) && defined(__i386__)
922
923 #include "trampolines_arm_to_x86-inl.h" // generated file NOLINT [build/include]
924
925 #elif defined(NATIVE_BRIDGE_GUEST_ARCH_ARM64) && defined(__x86_64__)
926
927 #include "trampolines_arm64_to_x86_64-inl.h" // generated file NOLINT [build/include]
928
929 #elif defined(NATIVE_BRIDGE_GUEST_ARCH_RISCV64) && defined(__x86_64__)
930
931 #include "trampolines_riscv64_to_x86_64-inl.h" // generated file NOLINT [build/include]
932
933 #else
934
935 #error "Unknown guest/host arch combination"
936
937 #endif
938
939 // This function is used to log interfaces which we haven't wrapped yet.
940 // Interface names are prefixed with SL_IID_.
GetIDName(const SLInterfaceID & id)941 const char* GetIDName(const SLInterfaceID& id) {
942 for (size_t i = 0; i < std::size(kKnownVariables); i++) {
943 const char* name = kKnownVariables[i].name;
944 if (strncmp(name, "SL_IID_", 7) == 0) {
945 SLInterfaceID interface_id = *reinterpret_cast<SLInterfaceID*>(dlsym(RTLD_DEFAULT, name));
946 if (isSLID(id, interface_id)) {
947 return name;
948 }
949 }
950 }
951 return "Unknown";
952 }
953
954 DEFINE_INIT_PROXY_LIBRARY("libOpenSLES.so")
955
956 } // namespace
957
958 } // namespace berberis
959