[automerger skipped] Use service fuzzer defaults in fuzzers am: a0eeb39c2c am: 1d9e66a1ec -s ours
am skip reason: Merged-In I0e97edf557aa77033797da1c4973478120638c2e with SHA-1 a0eeb39c2c is already in history
Original change: https://android-review.googlesource.com/c/platform/frameworks/av/+/2819422
Change-Id: I69c232c57bf773d5c31cd5040f0bb253aeef8551
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
diff --git a/Android.bp b/Android.bp
index 302e250..7a2bb9b 100644
--- a/Android.bp
+++ b/Android.bp
@@ -52,8 +52,8 @@
"aidl/android/media/VolumeShaperOperationFlag.aidl",
"aidl/android/media/VolumeShaperState.aidl",
],
- imports: [
- "android.media.audio.common.types-V2",
+ defaults: [
+ "latest_android_media_audio_common_types_import_interface",
],
backend: {
cpp: {
@@ -113,8 +113,8 @@
srcs: [
"aidl/android/media/audio/IHalAdapterVendorExtension.aidl",
],
- imports: [
- "android.hardware.audio.core-V1",
+ defaults: [
+ "latest_android_hardware_audio_core_import_interface",
],
backend: {
// The C++ backend is disabled transitively due to use of FMQ by the audio core HAL.
diff --git a/media/codec2/sfplugin/utils/Codec2BufferUtils.cpp b/media/codec2/sfplugin/utils/Codec2BufferUtils.cpp
index 9004bcf..261fd05 100644
--- a/media/codec2/sfplugin/utils/Codec2BufferUtils.cpp
+++ b/media/codec2/sfplugin/utils/Codec2BufferUtils.cpp
@@ -621,8 +621,8 @@
uint8_t maxLvlChroma = colorRange == C2Color::RANGE_FULL ? 255 : 240;
#define CLIP3(min,v,max) (((v) < (min)) ? (min) : (((max) > (v)) ? (v) : (max)))
- for (size_t y = 0; y < src.height(); ++y) {
- for (size_t x = 0; x < src.width(); ++x) {
+ for (size_t y = 0; y < src.crop().height; ++y) {
+ for (size_t x = 0; x < src.crop().width; ++x) {
uint8_t r = *pRed;
uint8_t g = *pGreen;
uint8_t b = *pBlue;
diff --git a/media/libaaudio/src/Android.bp b/media/libaaudio/src/Android.bp
index 30f451a..7882951 100644
--- a/media/libaaudio/src/Android.bp
+++ b/media/libaaudio/src/Android.bp
@@ -254,6 +254,9 @@
name: "aaudio-aidl",
unstable: true,
local_include_dir: "binding/aidl",
+ defaults: [
+ "latest_android_media_audio_common_types_import_interface",
+ ],
srcs: [
"binding/aidl/aaudio/Endpoint.aidl",
"binding/aidl/aaudio/RingBuffer.aidl",
@@ -264,7 +267,6 @@
"binding/aidl/aaudio/IAAudioService.aidl",
],
imports: [
- "android.media.audio.common.types-V2",
"audioclient-types-aidl",
"shared-file-region-aidl",
"framework-permission-aidl",
diff --git a/media/libaudioclient/Android.bp b/media/libaudioclient/Android.bp
index 01e3d53..2c9e173 100644
--- a/media/libaudioclient/Android.bp
+++ b/media/libaudioclient/Android.bp
@@ -255,8 +255,10 @@
"aidl/android/media/IEffect.aidl",
"aidl/android/media/IEffectClient.aidl",
],
+ defaults: [
+ "latest_android_media_audio_common_types_import_interface",
+ ],
imports: [
- "android.media.audio.common.types-V2",
"shared-file-region-aidl",
],
backend: {
@@ -309,8 +311,10 @@
"aidl/android/media/TrackSecondaryOutputInfo.aidl",
"aidl/android/media/SurroundSoundConfig.aidl",
],
+ defaults: [
+ "latest_android_media_audio_common_types_import_interface",
+ ],
imports: [
- "android.media.audio.common.types-V2",
"framework-permission-aidl",
],
backend: {
@@ -351,12 +355,11 @@
"aidl/android/media/AudioVolumeGroup.aidl",
"aidl/android/media/DeviceRole.aidl",
"aidl/android/media/SoundTriggerSession.aidl",
- "aidl/android/media/SpatializationLevel.aidl",
- "aidl/android/media/SpatializationMode.aidl",
- "aidl/android/media/SpatializerHeadTrackingMode.aidl",
+ ],
+ defaults: [
+ "latest_android_media_audio_common_types_import_interface",
],
imports: [
- "android.media.audio.common.types-V2",
"audioclient-types-aidl",
],
backend: {
@@ -402,8 +405,10 @@
"aidl/android/media/ISoundDoseCallback.aidl",
"aidl/android/media/SoundDoseRecord.aidl",
],
+ defaults: [
+ "latest_android_media_audio_common_types_import_interface",
+ ],
imports: [
- "android.media.audio.common.types-V2",
"audioclient-types-aidl",
"av-types-aidl",
"effect-aidl",
@@ -439,8 +444,10 @@
"aidl/android/media/IAudioPolicyService.aidl",
"aidl/android/media/IAudioPolicyServiceClient.aidl",
],
+ defaults: [
+ "latest_android_media_audio_common_types_import_interface",
+ ],
imports: [
- "android.media.audio.common.types-V2",
"audioclient-types-aidl",
"audiopolicy-types-aidl",
"capture_state_listener-aidl",
@@ -474,6 +481,9 @@
"aidl/android/media/ISpatializer.aidl",
"aidl/android/media/ISpatializerHeadTrackingCallback.aidl",
],
+ defaults: [
+ "latest_android_media_audio_common_types_import_interface",
+ ],
imports: [
"audiopolicy-types-aidl",
],
diff --git a/media/libaudioclient/aidl/android/media/INativeSpatializerCallback.aidl b/media/libaudioclient/aidl/android/media/INativeSpatializerCallback.aidl
index 88b8108..8b30b29 100644
--- a/media/libaudioclient/aidl/android/media/INativeSpatializerCallback.aidl
+++ b/media/libaudioclient/aidl/android/media/INativeSpatializerCallback.aidl
@@ -16,8 +16,7 @@
package android.media;
-import android.media.SpatializationLevel;
-import android.media.SpatializerHeadTrackingMode;
+import android.media.audio.common.Spatialization;
/**
* The INativeSpatializerCallback interface is a callback associated to the
@@ -30,7 +29,7 @@
/** Called when the spatialization level applied by the spatializer changes
* (e.g. when the spatializer is enabled or disabled)
*/
- void onLevelChanged(SpatializationLevel level);
+ void onLevelChanged(Spatialization.Level level);
/** Called when the output stream the Spatializer is attached to changes.
* Indicates the IO Handle of the new output.
diff --git a/media/libaudioclient/aidl/android/media/ISpatializer.aidl b/media/libaudioclient/aidl/android/media/ISpatializer.aidl
index 250c450..37dd776 100644
--- a/media/libaudioclient/aidl/android/media/ISpatializer.aidl
+++ b/media/libaudioclient/aidl/android/media/ISpatializer.aidl
@@ -16,11 +16,9 @@
package android.media;
+import android.media.audio.common.HeadTracking;
+import android.media.audio.common.Spatialization;
import android.media.ISpatializerHeadTrackingCallback;
-import android.media.SpatializationLevel;
-import android.media.SpatializationMode;
-import android.media.SpatializerHeadTrackingMode;
-
/**
* The ISpatializer interface is used to control the native audio service implementation
@@ -34,21 +32,25 @@
/** Releases a ISpatializer interface previously acquired. */
void release();
- /** Reports the list of supported spatialization levels (see SpatializationLevel.aidl).
+ /**
+ * Reports the list of supported spatialization levels.
* The list should never be empty if an ISpatializer interface was successfully
* retrieved with IAudioPolicyService.getSpatializer().
*/
- SpatializationLevel[] getSupportedLevels();
+ Spatialization.Level[] getSupportedLevels();
- /** Selects the desired spatialization level (see SpatializationLevel.aidl). Selecting a level
- * different from SpatializationLevel.NONE with create the specialized multichannel output
+ /**
+ * Selects the desired spatialization level. Selecting a level
+ * different from Spatializer.Level.NONE with create the specialized multichannel output
* mixer, create and enable the spatializer effect and let the audio policy attach eligible
* AudioTrack to this output stream.
*/
- void setLevel(SpatializationLevel level);
+ void setLevel(Spatialization.Level level);
- /** Gets the selected spatialization level (see SpatializationLevel.aidl) */
- SpatializationLevel getLevel();
+ /**
+ * Gets the selected spatialization level.
+ */
+ Spatialization.Level getLevel();
/** Reports if the spatializer engine supports head tracking or not.
* This is a pre condition independent of the fact that a head tracking sensor is
@@ -56,26 +58,33 @@
*/
boolean isHeadTrackingSupported();
- /** Reports the list of supported head tracking modes (see SpatializerHeadTrackingMode.aidl).
+ /**
+ * Reports the list of supported head tracking modes.
* The list always contains SpatializerHeadTrackingMode.DISABLED and can include other modes
* if the spatializer effect implementation supports head tracking.
* The result does not depend on currently connected sensors but reflects the capabilities
* when sensors are available.
*/
- SpatializerHeadTrackingMode[] getSupportedHeadTrackingModes();
+ HeadTracking.Mode[] getSupportedHeadTrackingModes();
- /** Selects the desired head tracking mode (see SpatializerHeadTrackingMode.aidl) */
- void setDesiredHeadTrackingMode(SpatializerHeadTrackingMode mode);
+ /**
+ * Selects the desired head tracking mode.
+ */
+ void setDesiredHeadTrackingMode(HeadTracking.Mode mode);
- /** Gets the actual head tracking mode. Can be different from the desired mode if conditions to
+ /**
+ * Gets the actual head tracking mode. Can be different from the desired mode if conditions to
* enable the desired mode are not met (e.g if the head tracking device was removed)
*/
- SpatializerHeadTrackingMode getActualHeadTrackingMode();
+ HeadTracking.Mode getActualHeadTrackingMode();
- /** Reset the head tracking algorithm to consider current head pose as neutral */
+ /**
+ * Reset the head tracking algorithm to consider current head pose as neutral
+ */
void recenterHeadTracker();
- /** Set the screen to stage transform to use by the head tracking algorithm
+ /**
+ * Set the screen to stage transform to use by the head tracking algorithm
* The screen to stage transform is conveyed as a vector of 6 elements,
* where the first three are a translation vector and
* the last three are a rotation vector.
@@ -123,11 +132,12 @@
*/
void setFoldState(boolean folded);
- /** Reports the list of supported spatialization modess (see SpatializationMode.aidl).
+ /**
+ * Reports the list of supported spatialization modess.
* The list should never be empty if an ISpatializer interface was successfully
* retrieved with IAudioPolicyService.getSpatializer().
*/
- SpatializationMode[] getSupportedModes();
+ Spatialization.Mode[] getSupportedModes();
/**
* Registers a callback to monitor head tracking functions.
diff --git a/media/libaudioclient/aidl/android/media/ISpatializerHeadTrackingCallback.aidl b/media/libaudioclient/aidl/android/media/ISpatializerHeadTrackingCallback.aidl
index 23d5e13..615b971 100644
--- a/media/libaudioclient/aidl/android/media/ISpatializerHeadTrackingCallback.aidl
+++ b/media/libaudioclient/aidl/android/media/ISpatializerHeadTrackingCallback.aidl
@@ -16,8 +16,7 @@
package android.media;
-import android.media.SpatializationLevel;
-import android.media.SpatializerHeadTrackingMode;
+import android.media.audio.common.HeadTracking;
/**
* The ISpatializerHeadTrackingCallback interface is a callback associated to the
@@ -28,7 +27,7 @@
oneway interface ISpatializerHeadTrackingCallback {
/** Called when the head tracking mode has changed
*/
- void onHeadTrackingModeChanged(SpatializerHeadTrackingMode mode);
+ void onHeadTrackingModeChanged(HeadTracking.Mode mode);
/** Called when the head to stage pose hase been updated
* The head to stage pose is conveyed as a vector of 6 elements,
diff --git a/media/libaudioclient/aidl/android/media/SpatializationLevel.aidl b/media/libaudioclient/aidl/android/media/SpatializationLevel.aidl
deleted file mode 100644
index 961c5a1..0000000
--- a/media/libaudioclient/aidl/android/media/SpatializationLevel.aidl
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.media;
-
-/**
- * The spatialization level supported by the spatializer stage effect implementation.
- * Used by methods of the ISpatializer interface.
- * {@hide}
- */
-@Backing(type="byte")
-enum SpatializationLevel {
- /** Spatialization is disabled. */
- NONE = 0,
- /** The spatializer accepts audio with positional multichannel masks (e.g 5.1). */
- SPATIALIZER_MULTICHANNEL = 1,
- /** The spatializer accepts audio made of a channel bed of positional multichannels (e.g 5.1)
- * and audio objects positioned independently via meta data.
- */
- SPATIALIZER_MCHAN_BED_PLUS_OBJECTS = 2,
-}
diff --git a/media/libaudioclient/aidl/android/media/SpatializationMode.aidl b/media/libaudioclient/aidl/android/media/SpatializationMode.aidl
deleted file mode 100644
index eaaff37..0000000
--- a/media/libaudioclient/aidl/android/media/SpatializationMode.aidl
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.media;
-
-/**
- * The spatialization mode supported by the spatializer stage effect implementation.
- * Used by methods of the ISpatializer interface.
- * {@hide}
- */
-@Backing(type="byte")
-enum SpatializationMode {
- /** The spatializer supports binaural mode (over headphones type devices). */
- SPATIALIZER_BINAURAL = 0,
- /** The spatializer supports transaural mode (over speaker type devices). */
- SPATIALIZER_TRANSAURAL = 1,
-}
diff --git a/media/libaudioclient/aidl/android/media/SpatializerHeadTrackingMode.aidl b/media/libaudioclient/aidl/android/media/SpatializerHeadTrackingMode.aidl
deleted file mode 100644
index 58e0f61..0000000
--- a/media/libaudioclient/aidl/android/media/SpatializerHeadTrackingMode.aidl
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.media;
-
-
-/**
- * The head tracking mode supported by the spatializer effect implementation.
- * Used by methods of the ISpatializer interface.
- * {@hide}
- */
-@Backing(type="byte")
-enum SpatializerHeadTrackingMode {
- /** Head tracking is active in a mode not listed below (forward compatibility) */
- OTHER = 0,
- /** Head tracking is disabled */
- DISABLED = 1,
- /** Head tracking is performed relative to the real work environment */
- RELATIVE_WORLD = 2,
- /** Head tracking is performed relative to the device's screen */
- RELATIVE_SCREEN = 3,
-}
diff --git a/media/libaudioclient/aidl/fuzzer/Android.bp b/media/libaudioclient/aidl/fuzzer/Android.bp
index 67258d9..6093933 100644
--- a/media/libaudioclient/aidl/fuzzer/Android.bp
+++ b/media/libaudioclient/aidl/fuzzer/Android.bp
@@ -19,63 +19,57 @@
static_libs: [
"android.hardware.audio.common@7.0-enums",
"effect-aidl-cpp",
- "liblog",
"libcgrouprc",
"libcgrouprc_format",
+ "libfakeservicemanager",
"libjsoncpp",
+ "liblog",
"libmediametricsservice",
"libmedia_helper",
"libprocessgroup",
"shared-file-region-aidl-cpp",
- "libfakeservicemanager"
],
shared_libs: [
- "libaudioclient",
- "libaudioflinger",
- "libmediautils",
- "libnblog",
- "libaudioprocessing",
- "libnbaio",
- "libpowermanager",
- "libvibrator",
- "packagemanager_aidl-cpp",
"android.hardware.audio.common-util",
"audioclient-types-aidl-cpp",
- "audioflinger-aidl-cpp",
"audiopolicy-aidl-cpp",
"audiopolicy-types-aidl-cpp",
"av-types-aidl-cpp",
"capture_state_listener-aidl-cpp",
+ "framework-permission-aidl-cpp",
+ "libaudioclient",
+ "audioflinger-aidl-cpp",
+ "libaudioflinger",
"libaudioclient_aidl_conversion",
"libaudiofoundation",
"libaudiomanager",
"libaudiopolicy",
"libaudioutils",
- "libdl",
- "libxml2",
- "mediametricsservice-aidl-cpp",
- "framework-permission-aidl-cpp",
- "libvndksupport",
- "libmediametrics",
- "libfakeservicemanager",
- "libactivitymanager_aidl",
- "libheadtracking",
"libaudiopolicyservice",
- "libsensorprivacy",
"libaudiopolicymanagerdefault",
"libaudiohal",
- "libhidlbase",
- "libpermission",
- "libaudiohal@7.0",
+ "libaudioprocessing",
+ "libactivitymanager_aidl",
+ "libdl",
+ "libheadtracking",
+ "libmediautils",
+ "libmediametrics",
+ "libnblog",
+ "libnbaio",
+ "libpowermanager",
+ "libvibrator",
+ "libvndksupport",
+ "libxml2",
+ "mediametricsservice-aidl-cpp",
+ "packagemanager_aidl-cpp",
],
header_libs: [
"libaudiopolicymanager_interface_headers",
- "libbinder_headers",
"libaudiofoundation_headers",
- "libmedia_headers",
"libaudiohal_headers",
"libaudioflinger_headers",
- "mediautils_headers",
+ "libbinder_headers",
+ "libmedia_headers",
],
fuzz_config: {
cc: [
diff --git a/media/libaudioclient/aidl/fuzzer/audioflinger_aidl_fuzzer.cpp b/media/libaudioclient/aidl/fuzzer/audioflinger_aidl_fuzzer.cpp
index fac5f53..f99cc3b 100644
--- a/media/libaudioclient/aidl/fuzzer/audioflinger_aidl_fuzzer.cpp
+++ b/media/libaudioclient/aidl/fuzzer/audioflinger_aidl_fuzzer.cpp
@@ -15,204 +15,74 @@
*
*/
#include <AudioFlinger.h>
-#include <ISchedulingPolicyService.h>
-#include <fakeservicemanager/FakeServiceManager.h>
#include <android-base/logging.h>
#include <android/binder_interface_utils.h>
#include <android/binder_process.h>
#include <android/media/IAudioPolicyService.h>
-#include <binder/IActivityManager.h>
-#include <binder/IPermissionController.h>
-#include <binder/IServiceManager.h>
-#include <binder/PermissionController.h>
+#include <fakeservicemanager/FakeServiceManager.h>
#include <fuzzbinder/libbinder_driver.h>
+#include <fuzzbinder/random_binder.h>
#include <fuzzer/FuzzedDataProvider.h>
#include <media/IAudioFlinger.h>
-#include <mediautils/SchedulingPolicyService.h>
-#include <sensorprivacy/SensorPrivacyManager.h>
#include <service/AudioPolicyService.h>
using namespace android;
using namespace android::binder;
using android::fuzzService;
-static sp<media::IAudioFlingerService> gAudioFlingerService;
+[[clang::no_destroy]] static std::once_flag gSmOnce;
+sp<FakeServiceManager> gFakeServiceManager;
-class FuzzerSchedulingPolicyService : public BnInterface<ISchedulingPolicyService> {
- int32_t requestPriority(int32_t /*pid_t*/, int32_t /*tid*/, int32_t /*prio*/, bool /*isForApp*/,
- bool /*asynchronous*/) {
- return 0;
+bool addService(const String16& serviceName, const sp<FakeServiceManager>& fakeServiceManager,
+ FuzzedDataProvider& fdp) {
+ sp<IBinder> binder = getRandomBinder(&fdp);
+ if (binder == nullptr) {
+ return false;
}
-
- int32_t requestCpusetBoost(bool /*enable*/, const sp<IBinder>& /*client*/) { return 0; }
-};
-
-class FuzzerPermissionController : public BnInterface<IPermissionController> {
- public:
- bool checkPermission(const String16& /*permission*/, int32_t /*pid*/, int32_t /*uid*/) {
- return true;
- }
- int32_t noteOp(const String16& /*op*/, int32_t /*uid*/, const String16& /*packageName*/) {
- return 0;
- }
- void getPackagesForUid(const uid_t /*uid*/, Vector<String16>& /*packages*/) {}
- bool isRuntimePermission(const String16& /*permission*/) { return true; }
- int32_t getPackageUid(const String16& /*package*/, int /*flags*/) { return 0; }
-};
-
-class FuzzerSensorPrivacyManager : public BnInterface<hardware::ISensorPrivacyManager> {
- public:
- Status supportsSensorToggle(int32_t /*toggleType*/, int32_t /*sensor*/,
- bool* /*_aidl_return*/) override {
- return Status::fromStatusT(UNKNOWN_TRANSACTION);
- }
- Status addSensorPrivacyListener(
- const sp<hardware::ISensorPrivacyListener>& /*listener*/) override {
- return Status::fromStatusT(::android::UNKNOWN_TRANSACTION);
- }
- Status addToggleSensorPrivacyListener(
- const sp<hardware::ISensorPrivacyListener>& /*listener*/) override {
- return Status::fromStatusT(UNKNOWN_TRANSACTION);
- }
- Status removeSensorPrivacyListener(
- const sp<hardware::ISensorPrivacyListener>& /*listener*/) override {
- return Status::fromStatusT(::android::UNKNOWN_TRANSACTION);
- }
- Status removeToggleSensorPrivacyListener(
- const sp<hardware::ISensorPrivacyListener>& /*listener*/) override {
- return Status::fromStatusT(::android::UNKNOWN_TRANSACTION);
- }
- Status isSensorPrivacyEnabled(bool* /*_aidl_return*/) override {
- return Status::fromStatusT(UNKNOWN_TRANSACTION);
- }
- Status isCombinedToggleSensorPrivacyEnabled(int32_t /*sensor*/,
- bool* /*_aidl_return*/) override {
- return Status::fromStatusT(UNKNOWN_TRANSACTION);
- }
- Status isToggleSensorPrivacyEnabled(int32_t /*toggleType*/, int32_t /*sensor*/,
- bool* /*_aidl_return*/) override {
- return Status::fromStatusT(UNKNOWN_TRANSACTION);
- }
- Status setSensorPrivacy(bool /*enable*/) override {
- return Status::fromStatusT(UNKNOWN_TRANSACTION);
- }
- Status setToggleSensorPrivacy(int32_t /*userId*/, int32_t /*source*/, int32_t /*sensor*/,
- bool /*enable*/) override {
- return Status::fromStatusT(UNKNOWN_TRANSACTION);
- }
- Status setToggleSensorPrivacyForProfileGroup(int32_t /*userId*/, int32_t /*source*/,
- int32_t /*sensor*/, bool /*enable*/) override {
- return Status::fromStatusT(UNKNOWN_TRANSACTION);
- }
-};
-
-class FuzzerActivityManager : public BnInterface<IActivityManager> {
- public:
- int32_t openContentUri(const String16& /*stringUri*/) override { return 0; }
-
- status_t registerUidObserver(const sp<IUidObserver>& /*observer*/, const int32_t /*event*/,
- const int32_t /*cutpoint*/,
- const String16& /*callingPackage*/) override {
- return OK;
- }
-
- status_t unregisterUidObserver(const sp<IUidObserver>& /*observer*/) override { return OK; }
-
- bool isUidActive(const uid_t /*uid*/, const String16& /*callingPackage*/) override {
- return true;
- }
-
- int32_t getUidProcessState(const uid_t /*uid*/, const String16& /*callingPackage*/) override {
- return ActivityManager::PROCESS_STATE_UNKNOWN;
- }
-
- status_t checkPermission(const String16& /*permission*/, const pid_t /*pid*/,
- const uid_t /*uid*/, int32_t* /*outResult*/) override {
- return NO_ERROR;
- }
-
- status_t registerUidObserverForUids(const sp<IUidObserver>& /*observer*/ ,
- const int32_t /*event*/ ,
- const int32_t /*cutpoint*/ ,
- const String16& /*callingPackage*/ ,
- const int32_t uids[] ,
- size_t /*nUids*/ ,
- /*out*/ sp<IBinder>& /*observerToken*/ ) {
- (void)uids;
- return OK;
- }
-
- status_t addUidToObserver(const sp<IBinder>& /*observerToken*/ ,
- const String16& /*callingPackage*/ ,
- int32_t /*uid*/ ) override {
- return NO_ERROR;
- }
-
- status_t removeUidFromObserver(const sp<IBinder>& /*observerToken*/ ,
- const String16& /*callingPackage*/ ,
- int32_t /*uid*/ ) override {
- return NO_ERROR;
- }
-
- status_t logFgsApiBegin(int32_t /*apiType*/ , int32_t /*appUid*/ ,
- int32_t /*appPid*/ ) override {
- return NO_ERROR;
- }
- status_t logFgsApiEnd(int32_t /*apiType*/ , int32_t /*appUid*/ ,
- int32_t /*appPid*/ ) override {
- return NO_ERROR;
- }
- status_t logFgsApiStateChanged(int32_t /*apiType*/ , int32_t /*state*/ ,
- int32_t /*appUid*/ ,
- int32_t /*appPid*/ ) override {
- return NO_ERROR;
- }
-};
-
-extern "C" int LLVMFuzzerInitialize(int* /* argc */, char*** /* argv */) {
- /* Create a FakeServiceManager instance and add required services */
- sp<FakeServiceManager> fakeServiceManager = new FakeServiceManager();
- setDefaultServiceManager(fakeServiceManager);
- ABinderProcess_setThreadPoolMaxThreadCount(0);
- sp<FuzzerActivityManager> am = new FuzzerActivityManager();
- fakeServiceManager->addService(String16("activity"), IInterface::asBinder(am));
-
- sp<FuzzerSensorPrivacyManager> sensorPrivacyManager = new FuzzerSensorPrivacyManager();
- fakeServiceManager->addService(String16("sensor_privacy"),
- IInterface::asBinder(sensorPrivacyManager));
- sp<FuzzerPermissionController> permissionController = new FuzzerPermissionController();
- fakeServiceManager->addService(String16("permission"),
- IInterface::asBinder(permissionController));
-
- sp<FuzzerSchedulingPolicyService> schedulingService = new FuzzerSchedulingPolicyService();
- fakeServiceManager->addService(String16("scheduling_policy"),
- IInterface::asBinder(schedulingService));
-
- const auto audioFlingerObj = sp<AudioFlinger>::make();
- const auto afAdapter = sp<AudioFlingerServerAdapter>::make(audioFlingerObj);
-
- fakeServiceManager->addService(String16(IAudioFlinger::DEFAULT_SERVICE_NAME),
- IInterface::asBinder(afAdapter), false /* allowIsolated */,
- IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT);
-
- const auto audioPolicyService = sp<AudioPolicyService>::make();
- fakeServiceManager->addService(String16("media.audio_policy"), audioPolicyService,
- false /* allowIsolated */,
- IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT);
-
- sp<IBinder> binder =
- fakeServiceManager->getService(String16(IAudioFlinger::DEFAULT_SERVICE_NAME));
- gAudioFlingerService = interface_cast<media::IAudioFlingerService>(binder);
- return 0;
+ CHECK_EQ(NO_ERROR, fakeServiceManager->addService(serviceName, binder));
+ return true;
}
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
- if (!gAudioFlingerService) {
- return 0;
+ FuzzedDataProvider fdp(data, size);
+
+ std::call_once(gSmOnce, [&] {
+ /* Create a FakeServiceManager instance and add required services */
+ gFakeServiceManager = sp<FakeServiceManager>::make();
+ setDefaultServiceManager(gFakeServiceManager);
+ });
+ gFakeServiceManager->clear();
+
+ for (const char* service :
+ {"activity", "sensor_privacy", "permission", "scheduling_policy",
+ "android.hardware.audio.core.IConfig", "batterystats", "media.metrics"}) {
+ if (!addService(String16(service), gFakeServiceManager, fdp)) {
+ return 0;
+ }
}
- fuzzService(media::IAudioFlingerService::asBinder(gAudioFlingerService),
- FuzzedDataProvider(data, size));
+ const auto audioFlinger = sp<AudioFlinger>::make();
+ const auto afAdapter = sp<AudioFlingerServerAdapter>::make(audioFlinger);
+
+ CHECK_EQ(NO_ERROR,
+ gFakeServiceManager->addService(
+ String16(IAudioFlinger::DEFAULT_SERVICE_NAME), IInterface::asBinder(afAdapter),
+ false /* allowIsolated */, IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT));
+
+ AudioSystem::get_audio_flinger_for_fuzzer();
+ const auto audioPolicyService = sp<AudioPolicyService>::make();
+
+ CHECK_EQ(NO_ERROR,
+ gFakeServiceManager->addService(String16("media.audio_policy"), audioPolicyService,
+ false /* allowIsolated */,
+ IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT));
+
+ sp<IBinder> audioFlingerServiceBinder =
+ gFakeServiceManager->getService(String16(IAudioFlinger::DEFAULT_SERVICE_NAME));
+ sp<media::IAudioFlingerService> audioFlingerService =
+ interface_cast<media::IAudioFlingerService>(audioFlingerServiceBinder);
+
+ fuzzService(media::IAudioFlingerService::asBinder(audioFlingerService), std::move(fdp));
return 0;
}
diff --git a/media/libstagefright/colorconversion/ColorConverter.cpp b/media/libstagefright/colorconversion/ColorConverter.cpp
index 6c26c28..e079765 100644
--- a/media/libstagefright/colorconversion/ColorConverter.cpp
+++ b/media/libstagefright/colorconversion/ColorConverter.cpp
@@ -1550,7 +1550,8 @@
uint32_t u01, v01, y01, y23, y45, y67, uv0, uv1;
size_t x = 0;
- for (; x < src.cropWidth() - 3; x += 4) {
+ // x % 4 is always 0 so x + 3 will never overflow.
+ for (; x + 3 < src.cropWidth(); x += 4) {
u01 = *((uint32_t*)ptr_u); ptr_u += 2;
v01 = *((uint32_t*)ptr_v); ptr_v += 2;
diff --git a/services/audioflinger/Android.bp b/services/audioflinger/Android.bp
index 0cd6243..0c878c9 100644
--- a/services/audioflinger/Android.bp
+++ b/services/audioflinger/Android.bp
@@ -142,9 +142,10 @@
name: "libaudioflinger",
defaults: [
- "latest_android_media_audio_common_types_cpp_shared",
- "latest_android_hardware_audio_core_sounddose_ndk_shared",
"audioflinger_flags_defaults",
+ "latest_android_hardware_audio_core_sounddose_ndk_export_shared_lib_header",
+ "latest_android_hardware_audio_core_sounddose_ndk_shared",
+ "latest_android_media_audio_common_types_cpp_shared",
],
srcs: [
@@ -217,7 +218,6 @@
export_shared_lib_headers: [
"libpermission",
- "android.hardware.audio.core.sounddose-V1-ndk",
],
cflags: [
diff --git a/services/audiopolicy/service/AudioPolicyService.cpp b/services/audiopolicy/service/AudioPolicyService.cpp
index 041aa1c..5fbbc30 100644
--- a/services/audiopolicy/service/AudioPolicyService.cpp
+++ b/services/audiopolicy/service/AudioPolicyService.cpp
@@ -52,6 +52,7 @@
namespace android {
using binder::Status;
+using media::audio::common::Spatialization;
static const char kDeadlockedString[] = "AudioPolicyService may be deadlocked\n";
static const char kCmdDeadlockedString[] = "AudioPolicyService command thread may be deadlocked\n";
@@ -574,7 +575,7 @@
if (mSpatializer != nullptr) {
// Note: mSpatializer != nullptr => mAudioPolicyManager != nullptr
- if (mSpatializer->getLevel() != media::SpatializationLevel::NONE) {
+ if (mSpatializer->getLevel() != Spatialization::Level::NONE) {
audio_io_handle_t currentOutput = mSpatializer->getOutput();
audio_io_handle_t newOutput;
const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
@@ -599,8 +600,8 @@
if (status != NO_ERROR) {
mAudioPolicyManager->releaseSpatializerOutput(newOutput);
}
- } else if (mSpatializer->getLevel() == media::SpatializationLevel::NONE
- && mSpatializer->getOutput() != AUDIO_IO_HANDLE_NONE) {
+ } else if (mSpatializer->getLevel() == Spatialization::Level::NONE &&
+ mSpatializer->getOutput() != AUDIO_IO_HANDLE_NONE) {
audio_io_handle_t output = mSpatializer->detachOutput();
if (output != AUDIO_IO_HANDLE_NONE) {
diff --git a/services/audiopolicy/service/Spatializer.cpp b/services/audiopolicy/service/Spatializer.cpp
index 1245b1e..7859c2c 100644
--- a/services/audiopolicy/service/Spatializer.cpp
+++ b/services/audiopolicy/service/Spatializer.cpp
@@ -43,16 +43,16 @@
namespace android {
-using aidl_utils::statusTFromBinderStatus;
using aidl_utils::binderStatusFromStatusT;
+using aidl_utils::statusTFromBinderStatus;
using android::content::AttributionSourceState;
using binder::Status;
using media::HeadTrackingMode;
using media::Pose3f;
-using media::SpatializationLevel;
-using media::SpatializationMode;
-using media::SpatializerHeadTrackingMode;
using media::SensorPoseProvider;
+using media::audio::common::HeadTracking;
+using media::audio::common::Spatialization;
+using ::android::internal::ToString;
using namespace std::chrono_literals;
@@ -302,7 +302,7 @@
}
mSupportsHeadTracking = supportsHeadTracking[0];
- std::vector<media::SpatializationLevel> spatializationLevels;
+ std::vector<Spatialization::Level> spatializationLevels;
status = getHalParameter<true>(effect, SPATIALIZER_PARAM_SUPPORTED_LEVELS,
&spatializationLevels);
if (status != NO_ERROR) {
@@ -316,7 +316,7 @@
ALOGW("%s: ignoring spatializationLevel:%d", __func__, (int)spatializationLevel);
continue;
}
- if (spatializationLevel == media::SpatializationLevel::NONE) {
+ if (spatializationLevel == Spatialization::Level::NONE) {
noneLevelFound = true;
} else {
activeLevelFound = true;
@@ -330,7 +330,7 @@
return BAD_VALUE;
}
- std::vector<media::SpatializationMode> spatializationModes;
+ std::vector<Spatialization::Mode> spatializationModes;
status = getHalParameter<true>(effect, SPATIALIZER_PARAM_SUPPORTED_SPATIALIZATION_MODES,
&spatializationModes);
if (status != NO_ERROR) {
@@ -373,9 +373,9 @@
// Currently we expose only RELATIVE_WORLD.
// This is a limitation of the head tracking library based on a UX choice.
- mHeadTrackingModes.push_back(SpatializerHeadTrackingMode::DISABLED);
+ mHeadTrackingModes.push_back(HeadTracking::Mode::DISABLED);
if (mSupportsHeadTracking) {
- mHeadTrackingModes.push_back(SpatializerHeadTrackingMode::RELATIVE_WORLD);
+ mHeadTrackingModes.push_back(HeadTracking::Mode::RELATIVE_WORLD);
}
mediametrics::LogItem(mMetricsId)
.set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CREATE)
@@ -440,7 +440,7 @@
void Spatializer::binderDied(__unused const wp<IBinder> &who) {
{
std::lock_guard lock(mLock);
- mLevel = SpatializationLevel::NONE;
+ mLevel = Spatialization::Level::NONE;
mSpatializerCallback.clear();
}
ALOGV("%s", __func__);
@@ -448,20 +448,20 @@
}
// ISpatializer
-Status Spatializer::getSupportedLevels(std::vector<SpatializationLevel> *levels) {
+Status Spatializer::getSupportedLevels(std::vector<Spatialization::Level> *levels) {
ALOGV("%s", __func__);
if (levels == nullptr) {
return binderStatusFromStatusT(BAD_VALUE);
}
- // SpatializationLevel::NONE is already required from the effect or we don't load it.
+ // Spatialization::Level::NONE is already required from the effect or we don't load it.
levels->insert(levels->end(), mLevels.begin(), mLevels.end());
return Status::ok();
}
-Status Spatializer::setLevel(SpatializationLevel level) {
- ALOGV("%s level %s", __func__, media::toString(level).c_str());
- mLocalLog.log("%s with %s", __func__, media::toString(level).c_str());
- if (level != SpatializationLevel::NONE
+Status Spatializer::setLevel(Spatialization::Level level) {
+ ALOGV("%s level %s", __func__, ToString(level).c_str());
+ mLocalLog.log("%s with %s", __func__, ToString(level).c_str());
+ if (level != Spatialization::Level::NONE
&& std::find(mLevels.begin(), mLevels.end(), level) == mLevels.end()) {
return binderStatusFromStatusT(BAD_VALUE);
}
@@ -488,7 +488,7 @@
return Status::ok();
}
-Status Spatializer::getLevel(SpatializationLevel *level) {
+Status Spatializer::getLevel(Spatialization::Level *level) {
if (level == nullptr) {
return binderStatusFromStatusT(BAD_VALUE);
}
@@ -509,7 +509,7 @@
}
Status Spatializer::getSupportedHeadTrackingModes(
- std::vector<SpatializerHeadTrackingMode>* modes) {
+ std::vector<HeadTracking::Mode>* modes) {
std::lock_guard lock(mLock);
ALOGV("%s", __func__);
if (modes == nullptr) {
@@ -519,24 +519,24 @@
return Status::ok();
}
-Status Spatializer::setDesiredHeadTrackingMode(SpatializerHeadTrackingMode mode) {
- ALOGV("%s mode %s", __func__, media::toString(mode).c_str());
+Status Spatializer::setDesiredHeadTrackingMode(HeadTracking::Mode mode) {
+ ALOGV("%s mode %s", __func__, ToString(mode).c_str());
if (!mSupportsHeadTracking) {
return binderStatusFromStatusT(INVALID_OPERATION);
}
- mLocalLog.log("%s with %s", __func__, media::toString(mode).c_str());
+ mLocalLog.log("%s with %s", __func__, ToString(mode).c_str());
std::lock_guard lock(mLock);
switch (mode) {
- case SpatializerHeadTrackingMode::OTHER:
+ case HeadTracking::Mode::OTHER:
return binderStatusFromStatusT(BAD_VALUE);
- case SpatializerHeadTrackingMode::DISABLED:
+ case HeadTracking::Mode::DISABLED:
mDesiredHeadTrackingMode = HeadTrackingMode::STATIC;
break;
- case SpatializerHeadTrackingMode::RELATIVE_WORLD:
+ case HeadTracking::Mode::RELATIVE_WORLD:
mDesiredHeadTrackingMode = HeadTrackingMode::WORLD_RELATIVE;
break;
- case SpatializerHeadTrackingMode::RELATIVE_SCREEN:
+ case HeadTracking::Mode::RELATIVE_SCREEN:
mDesiredHeadTrackingMode = HeadTrackingMode::SCREEN_RELATIVE;
break;
}
@@ -547,7 +547,7 @@
return Status::ok();
}
-Status Spatializer::getActualHeadTrackingMode(SpatializerHeadTrackingMode *mode) {
+Status Spatializer::getActualHeadTrackingMode(HeadTracking::Mode *mode) {
if (mode == nullptr) {
return binderStatusFromStatusT(BAD_VALUE);
}
@@ -600,8 +600,8 @@
binder->unlinkToDeath(this);
mSpatializerCallback.clear();
- levelChanged = mLevel != SpatializationLevel::NONE;
- mLevel = SpatializationLevel::NONE;
+ levelChanged = mLevel != Spatialization::Level::NONE;
+ mLevel = Spatialization::Level::NONE;
}
if (levelChanged) {
@@ -690,7 +690,7 @@
return Status::ok();
}
-Status Spatializer::getSupportedModes(std::vector<SpatializationMode> *modes) {
+Status Spatializer::getSupportedModes(std::vector<Spatialization::Mode> *modes) {
ALOGV("%s", __func__);
if (modes == nullptr) {
return binderStatusFromStatusT(BAD_VALUE);
@@ -771,7 +771,7 @@
const std::vector<float> headToStage(6, 0.0);
setEffectParameter_l(SPATIALIZER_PARAM_HEAD_TO_STAGE, headToStage);
setEffectParameter_l(SPATIALIZER_PARAM_HEADTRACKING_MODE,
- std::vector<SpatializerHeadTrackingMode>{SpatializerHeadTrackingMode::DISABLED});
+ std::vector<HeadTracking::Mode>{HeadTracking::Mode::DISABLED});
}
void Spatializer::onHeadToStagePoseMsg(const std::vector<float>& headToStage) {
@@ -804,21 +804,21 @@
void Spatializer::onActualModeChangeMsg(HeadTrackingMode mode) {
ALOGV("%s(%d)", __func__, (int) mode);
sp<media::ISpatializerHeadTrackingCallback> callback;
- SpatializerHeadTrackingMode spatializerMode;
+ HeadTracking::Mode spatializerMode;
{
std::lock_guard lock(mLock);
if (!mSupportsHeadTracking) {
- spatializerMode = SpatializerHeadTrackingMode::DISABLED;
+ spatializerMode = HeadTracking::Mode::DISABLED;
} else {
switch (mode) {
case HeadTrackingMode::STATIC:
- spatializerMode = SpatializerHeadTrackingMode::DISABLED;
+ spatializerMode = HeadTracking::Mode::DISABLED;
break;
case HeadTrackingMode::WORLD_RELATIVE:
- spatializerMode = SpatializerHeadTrackingMode::RELATIVE_WORLD;
+ spatializerMode = HeadTracking::Mode::RELATIVE_WORLD;
break;
case HeadTrackingMode::SCREEN_RELATIVE:
- spatializerMode = SpatializerHeadTrackingMode::RELATIVE_SCREEN;
+ spatializerMode = HeadTracking::Mode::RELATIVE_SCREEN;
break;
default:
LOG_ALWAYS_FATAL("Unknown mode: %d", mode);
@@ -826,11 +826,11 @@
}
mActualHeadTrackingMode = spatializerMode;
if (mEngine != nullptr) {
- if (spatializerMode == SpatializerHeadTrackingMode::DISABLED) {
+ if (spatializerMode == HeadTracking::Mode::DISABLED) {
resetEngineHeadPose_l();
} else {
setEffectParameter_l(SPATIALIZER_PARAM_HEADTRACKING_MODE,
- std::vector<SpatializerHeadTrackingMode>{spatializerMode});
+ std::vector<HeadTracking::Mode>{spatializerMode});
}
}
callback = mHeadTrackingCallback;
@@ -974,12 +974,12 @@
if (mPoseController != nullptr) {
// TODO(b/253297301, b/255433067) reenable low latency condition check
// for Head Tracking after Bluetooth HAL supports it correctly.
- if (mNumActiveTracks > 0 && mLevel != SpatializationLevel::NONE
+ if (mNumActiveTracks > 0 && mLevel != Spatialization::Level::NONE
&& mDesiredHeadTrackingMode != HeadTrackingMode::STATIC
&& mHeadSensor != SpatializerPoseController::INVALID_SENSOR) {
if (mEngine != nullptr) {
setEffectParameter_l(SPATIALIZER_PARAM_HEADTRACKING_MODE,
- std::vector<SpatializerHeadTrackingMode>{mActualHeadTrackingMode});
+ std::vector<HeadTracking::Mode>{mActualHeadTrackingMode});
}
mPoseController->setHeadSensor(mHeadSensor);
mPoseController->setScreenSensor(mScreenSensor);
@@ -996,20 +996,20 @@
if (mOutput != AUDIO_IO_HANDLE_NONE && supportsSetLatencyMode) {
const status_t status =
AudioSystem::setRequestedLatencyMode(mOutput, requestedLatencyMode);
- ALOGD("%s: setRequestedLatencyMode for output thread(%d) to %s returned %d",
- __func__, mOutput, toString(requestedLatencyMode).c_str(), status);
+ ALOGD("%s: setRequestedLatencyMode for output thread(%d) to %s returned %d", __func__,
+ mOutput, toString(requestedLatencyMode).c_str(), status);
}
}
void Spatializer::checkEngineState_l() {
if (mEngine != nullptr) {
- if (mLevel != SpatializationLevel::NONE && mNumActiveTracks > 0) {
+ if (mLevel != Spatialization::Level::NONE && mNumActiveTracks > 0) {
mEngine->setEnabled(true);
setEffectParameter_l(SPATIALIZER_PARAM_LEVEL,
- std::vector<SpatializationLevel>{mLevel});
+ std::vector<Spatialization::Level>{mLevel});
} else {
setEffectParameter_l(SPATIALIZER_PARAM_LEVEL,
- std::vector<SpatializationLevel>{SpatializationLevel::NONE});
+ std::vector<Spatialization::Level>{Spatialization::Level::NONE});
mEngine->setEnabled(false);
}
}
@@ -1067,21 +1067,21 @@
// 1. Capabilities (mLevels, mHeadTrackingModes, mSpatializationModes, mChannelMasks, etc)
ss.append(prefixSpace).append("Supported levels: [");
for (auto& level : mLevels) {
- base::StringAppendF(&ss, " %s", media::toString(level).c_str());
+ base::StringAppendF(&ss, " %s", ToString(level).c_str());
}
- base::StringAppendF(&ss, "], mLevel: %s", media::toString(mLevel).c_str());
+ base::StringAppendF(&ss, "], mLevel: %s", ToString(mLevel).c_str());
base::StringAppendF(&ss, "\n%smHeadTrackingModes: [", prefixSpace.c_str());
for (auto& mode : mHeadTrackingModes) {
- base::StringAppendF(&ss, " %s", media::toString(mode).c_str());
+ base::StringAppendF(&ss, " %s", ToString(mode).c_str());
}
base::StringAppendF(&ss, "], Desired: %s, Actual %s\n",
media::toString(mDesiredHeadTrackingMode).c_str(),
- media::toString(mActualHeadTrackingMode).c_str());
+ ToString(mActualHeadTrackingMode).c_str());
base::StringAppendF(&ss, "%smSpatializationModes: [", prefixSpace.c_str());
for (auto& mode : mSpatializationModes) {
- base::StringAppendF(&ss, " %s", media::toString(mode).c_str());
+ base::StringAppendF(&ss, " %s", ToString(mode).c_str());
}
ss += "]\n";
diff --git a/services/audiopolicy/service/Spatializer.h b/services/audiopolicy/service/Spatializer.h
index 0d4d3f6..4ef07ce 100644
--- a/services/audiopolicy/service/Spatializer.h
+++ b/services/audiopolicy/service/Spatializer.h
@@ -20,10 +20,9 @@
#include <android-base/stringprintf.h>
#include <android/media/BnEffect.h>
#include <android/media/BnSpatializer.h>
-#include <android/media/SpatializationLevel.h>
-#include <android/media/SpatializationMode.h>
-#include <android/media/SpatializerHeadTrackingMode.h>
#include <android/media/audio/common/AudioLatencyMode.h>
+#include <android/media/audio/common/HeadTracking.h>
+#include <android/media/audio/common/Spatialization.h>
#include <audio_utils/SimpleLog.h>
#include <math.h>
#include <media/AudioEffect.h>
@@ -106,16 +105,17 @@
/** ISpatializer, see ISpatializer.aidl */
binder::Status release() override;
- binder::Status getSupportedLevels(std::vector<media::SpatializationLevel>* levels) override;
- binder::Status setLevel(media::SpatializationLevel level) override;
- binder::Status getLevel(media::SpatializationLevel *level) override;
+ binder::Status getSupportedLevels(
+ std::vector<media::audio::common::Spatialization::Level>* levels) override;
+ binder::Status setLevel(media::audio::common::Spatialization::Level level) override;
+ binder::Status getLevel(media::audio::common::Spatialization::Level *level) override;
binder::Status isHeadTrackingSupported(bool *supports);
binder::Status getSupportedHeadTrackingModes(
- std::vector<media::SpatializerHeadTrackingMode>* modes) override;
+ std::vector<media::audio::common::HeadTracking::Mode>* modes) override;
binder::Status setDesiredHeadTrackingMode(
- media::SpatializerHeadTrackingMode mode) override;
+ media::audio::common::HeadTracking::Mode mode) override;
binder::Status getActualHeadTrackingMode(
- media::SpatializerHeadTrackingMode* mode) override;
+ media::audio::common::HeadTracking::Mode* mode) override;
binder::Status recenterHeadTracker() override;
binder::Status setGlobalTransform(const std::vector<float>& screenToStage) override;
binder::Status setHeadSensor(int sensorHandle) override;
@@ -123,7 +123,8 @@
binder::Status setDisplayOrientation(float physicalToLogicalAngle) override;
binder::Status setHingeAngle(float hingeAngle) override;
binder::Status setFoldState(bool folded) override;
- binder::Status getSupportedModes(std::vector<media::SpatializationMode>* modes) override;
+ binder::Status getSupportedModes(
+ std::vector<media::audio::common::Spatialization::Mode>* modes) override;
binder::Status registerHeadTrackingCallback(
const sp<media::ISpatializerHeadTrackingCallback>& callback) override;
binder::Status setParameter(int key, const std::vector<unsigned char>& value) override;
@@ -145,7 +146,10 @@
status_t loadEngineConfiguration(sp<EffectHalInterface> effect);
/** Level getter for use by local classes. */
- media::SpatializationLevel getLevel() const { std::lock_guard lock(mLock); return mLevel; }
+ media::audio::common::Spatialization::Level getLevel() const {
+ std::lock_guard lock(mLock);
+ return mLevel;
+ }
/** Called by audio policy service when the special output mixer dedicated to spatialization
* is opened and the spatializer engine must be created.
@@ -360,7 +364,8 @@
sp<media::ISpatializerHeadTrackingCallback> mHeadTrackingCallback GUARDED_BY(mLock);
/** Requested spatialization level */
- media::SpatializationLevel mLevel GUARDED_BY(mLock) = media::SpatializationLevel::NONE;
+ media::audio::common::Spatialization::Level mLevel GUARDED_BY(mLock) =
+ media::audio::common::Spatialization::Level::NONE;
/** Control logic for head-tracking, etc. */
std::shared_ptr<SpatializerPoseController> mPoseController GUARDED_BY(mLock);
@@ -370,8 +375,8 @@
= media::HeadTrackingMode::STATIC;
/** Last-reported actual head-tracking mode. */
- media::SpatializerHeadTrackingMode mActualHeadTrackingMode GUARDED_BY(mLock)
- = media::SpatializerHeadTrackingMode::DISABLED;
+ media::audio::common::HeadTracking::Mode mActualHeadTrackingMode GUARDED_BY(mLock)
+ = media::audio::common::HeadTracking::Mode::DISABLED;
/** Selected Head pose sensor */
int32_t mHeadSensor GUARDED_BY(mLock) = SpatializerPoseController::INVALID_SENSOR;
@@ -388,9 +393,9 @@
/** Last hinge angle */
float mHingeAngle GUARDED_BY(mLock) = 0.f; // foldable: 0.f is closed, M_PI flat open.
- std::vector<media::SpatializationLevel> mLevels;
- std::vector<media::SpatializerHeadTrackingMode> mHeadTrackingModes;
- std::vector<media::SpatializationMode> mSpatializationModes;
+ std::vector<media::audio::common::Spatialization::Level> mLevels;
+ std::vector<media::audio::common::HeadTracking::Mode> mHeadTrackingModes;
+ std::vector<media::audio::common::Spatialization::Mode> mSpatializationModes;
std::vector<audio_channel_mask_t> mChannelMasks;
bool mSupportsHeadTracking;