Merge changes from topic "ndk-prepare-surface"
* changes:
Fix map key in PreparerThread pending streams.
camera2 (v)ndk: Add APIs for pre-allocation of surface buffers.
diff --git a/Android.bp b/Android.bp
index 5aa2029..37f6457 100644
--- a/Android.bp
+++ b/Android.bp
@@ -44,7 +44,7 @@
srcs: [
"aidl/android/media/InterpolatorConfig.aidl",
"aidl/android/media/InterpolatorType.aidl",
- "aidl/android/media/MicrophoneInfoData.aidl",
+ "aidl/android/media/MicrophoneInfoFw.aidl",
"aidl/android/media/VolumeShaperConfiguration.aidl",
"aidl/android/media/VolumeShaperConfigurationOptionFlag.aidl",
"aidl/android/media/VolumeShaperConfigurationType.aidl",
@@ -52,6 +52,9 @@
"aidl/android/media/VolumeShaperOperationFlag.aidl",
"aidl/android/media/VolumeShaperState.aidl",
],
+ imports: [
+ "android.media.audio.common.types-V2",
+ ],
backend: {
cpp: {
min_sdk_version: "29",
@@ -62,6 +65,9 @@
"com.android.media.swcodec",
],
},
+ java: {
+ sdk_version: "module_current",
+ },
},
}
diff --git a/aidl/android/media/MicrophoneInfoData.aidl b/aidl/android/media/MicrophoneInfoFw.aidl
similarity index 62%
rename from aidl/android/media/MicrophoneInfoData.aidl
rename to aidl/android/media/MicrophoneInfoFw.aidl
index 747bfa5..bad0e0a 100644
--- a/aidl/android/media/MicrophoneInfoData.aidl
+++ b/aidl/android/media/MicrophoneInfoFw.aidl
@@ -16,24 +16,14 @@
package android.media;
+import android.media.audio.common.MicrophoneDynamicInfo;
+import android.media.audio.common.MicrophoneInfo;
+
/**
* {@hide}
*/
-parcelable MicrophoneInfoData {
- @utf8InCpp String deviceId;
+parcelable MicrophoneInfoFw {
+ MicrophoneInfo info;
+ MicrophoneDynamicInfo dynamic;
int portId;
- int type;
- @utf8InCpp String address;
- int deviceLocation;
- int deviceGroup;
- int indexInTheGroup;
- float[] geometricLocation;
- float[] orientation;
- float[] frequencies;
- float[] frequencyResponses;
- int[] channelMapping;
- float sensitivity;
- float maxSpl;
- float minSpl;
- int directionality;
}
diff --git a/drm/drmserver/Android.bp b/drm/drmserver/Android.bp
index df3a6a2..ab25c65 100644
--- a/drm/drmserver/Android.bp
+++ b/drm/drmserver/Android.bp
@@ -63,3 +63,39 @@
init_rc: ["drmserver.rc"],
}
+
+cc_fuzz {
+ name: "drmserver_fuzzer",
+
+ defaults: [
+ "service_fuzzer_defaults",
+ ],
+
+ srcs: [
+ "fuzzer/DrmFuzzer.cpp",
+ "DrmManagerService.cpp",
+ "DrmManager.cpp",
+ ],
+
+ static_libs: [
+ "libmediautils",
+ "liblog",
+ "libdl",
+ "libdrmframeworkcommon",
+ "libselinux",
+ "libstagefright_foundation",
+ ],
+
+ shared_libs: [
+ "libmediametrics",
+ ],
+
+ fuzz_config: {
+ libfuzzer_options: [
+ "max_len=50000",
+ ],
+ cc: [
+ "android-drm-team@google.com",
+ ],
+ },
+}
\ No newline at end of file
diff --git a/drm/drmserver/DrmManagerService.h b/drm/drmserver/DrmManagerService.h
index f9b8bef..56201d9 100644
--- a/drm/drmserver/DrmManagerService.h
+++ b/drm/drmserver/DrmManagerService.h
@@ -141,6 +141,8 @@
virtual status_t dump(int fd, const Vector<String16>& args);
+ friend class DrmManagerServiceFuzzer;
+
private:
sp<DrmManager> mDrmManager;
};
diff --git a/drm/drmserver/fuzzer/DrmFuzzer.cpp b/drm/drmserver/fuzzer/DrmFuzzer.cpp
new file mode 100644
index 0000000..4b23679
--- /dev/null
+++ b/drm/drmserver/fuzzer/DrmFuzzer.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2023 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.
+ */
+
+#include <fuzzbinder/libbinder_driver.h>
+#include <fuzzer/FuzzedDataProvider.h>
+
+#include "DrmManagerService.h"
+
+namespace android {
+class DrmManagerServiceFuzzer {
+public:
+ DrmManagerServiceFuzzer() {}
+
+ void fuzz(const uint8_t* data, size_t size) {
+ auto drmService = new DrmManagerService();
+ fuzzService(drmService, FuzzedDataProvider(data, size));
+ }
+};
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+ android::DrmManagerServiceFuzzer serviceFuzzer;
+ serviceFuzzer.fuzz(data, size);
+ return 0;
+}
\ No newline at end of file
diff --git a/include/media/MicrophoneInfo.h b/include/media/MicrophoneInfo.h
deleted file mode 100644
index 6d6c594..0000000
--- a/include/media/MicrophoneInfo.h
+++ /dev/null
@@ -1,239 +0,0 @@
-/*
- * Copyright (C) 2018 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.
- */
-
-#ifndef ANDROID_MICROPHONE_INFO_H
-#define ANDROID_MICROPHONE_INFO_H
-
-#include <android/media/MicrophoneInfoData.h>
-#include <binder/Parcel.h>
-#include <binder/Parcelable.h>
-#include <media/AidlConversionUtil.h>
-#include <system/audio.h>
-
-namespace android {
-namespace media {
-
-class MicrophoneInfo : public Parcelable {
-public:
- MicrophoneInfo() = default;
- MicrophoneInfo(const MicrophoneInfo& microphoneInfo) = default;
- MicrophoneInfo(audio_microphone_characteristic_t& characteristic) {
- mDeviceId = std::string(&characteristic.device_id[0]);
- mPortId = characteristic.id;
- mType = characteristic.device;
- mAddress = std::string(&characteristic.address[0]);
- mDeviceLocation = characteristic.location;
- mDeviceGroup = characteristic.group;
- mIndexInTheGroup = characteristic.index_in_the_group;
- mGeometricLocation.push_back(characteristic.geometric_location.x);
- mGeometricLocation.push_back(characteristic.geometric_location.y);
- mGeometricLocation.push_back(characteristic.geometric_location.z);
- mOrientation.push_back(characteristic.orientation.x);
- mOrientation.push_back(characteristic.orientation.y);
- mOrientation.push_back(characteristic.orientation.z);
- std::vector<float> frequencies;
- std::vector<float> responses;
- for (size_t i = 0; i < characteristic.num_frequency_responses; i++) {
- frequencies.push_back(characteristic.frequency_responses[0][i]);
- responses.push_back(characteristic.frequency_responses[1][i]);
- }
- mFrequencyResponses.push_back(frequencies);
- mFrequencyResponses.push_back(responses);
- for (size_t i = 0; i < AUDIO_CHANNEL_COUNT_MAX; i++) {
- mChannelMapping.push_back(characteristic.channel_mapping[i]);
- }
- mSensitivity = characteristic.sensitivity;
- mMaxSpl = characteristic.max_spl;
- mMinSpl = characteristic.min_spl;
- mDirectionality = characteristic.directionality;
- }
-
- virtual ~MicrophoneInfo() = default;
-
- virtual status_t writeToParcel(Parcel* parcel) const {
- MicrophoneInfoData parcelable;
- return writeToParcelable(&parcelable)
- ?: parcelable.writeToParcel(parcel);
- }
-
- virtual status_t writeToParcelable(MicrophoneInfoData* parcelable) const {
-#if defined(BACKEND_NDK)
- using ::aidl::android::convertReinterpret;
-#endif
- parcelable->deviceId = mDeviceId;
- parcelable->portId = mPortId;
- parcelable->type = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(mType));
- parcelable->address = mAddress;
- parcelable->deviceGroup = mDeviceGroup;
- parcelable->indexInTheGroup = mIndexInTheGroup;
- parcelable->geometricLocation = mGeometricLocation;
- parcelable->orientation = mOrientation;
- if (mFrequencyResponses.size() != 2) {
- return BAD_VALUE;
- }
- parcelable->frequencies = mFrequencyResponses[0];
- parcelable->frequencyResponses = mFrequencyResponses[1];
- parcelable->channelMapping = mChannelMapping;
- parcelable->sensitivity = mSensitivity;
- parcelable->maxSpl = mMaxSpl;
- parcelable->minSpl = mMinSpl;
- parcelable->directionality = mDirectionality;
- return OK;
- }
-
- virtual status_t readFromParcel(const Parcel* parcel) {
- MicrophoneInfoData data;
- return data.readFromParcel(parcel)
- ?: readFromParcelable(data);
- }
-
- virtual status_t readFromParcelable(const MicrophoneInfoData& parcelable) {
-#if defined(BACKEND_NDK)
- using ::aidl::android::convertReinterpret;
-#endif
- mDeviceId = parcelable.deviceId;
- mPortId = parcelable.portId;
- mType = VALUE_OR_RETURN_STATUS(convertReinterpret<uint32_t>(parcelable.type));
- mAddress = parcelable.address;
- mDeviceLocation = parcelable.deviceLocation;
- mDeviceGroup = parcelable.deviceGroup;
- mIndexInTheGroup = parcelable.indexInTheGroup;
- if (parcelable.geometricLocation.size() != 3) {
- return BAD_VALUE;
- }
- mGeometricLocation = parcelable.geometricLocation;
- if (parcelable.orientation.size() != 3) {
- return BAD_VALUE;
- }
- mOrientation = parcelable.orientation;
- if (parcelable.frequencies.size() != parcelable.frequencyResponses.size()) {
- return BAD_VALUE;
- }
-
- mFrequencyResponses.push_back(parcelable.frequencies);
- mFrequencyResponses.push_back(parcelable.frequencyResponses);
- if (parcelable.channelMapping.size() != AUDIO_CHANNEL_COUNT_MAX) {
- return BAD_VALUE;
- }
- mChannelMapping = parcelable.channelMapping;
- mSensitivity = parcelable.sensitivity;
- mMaxSpl = parcelable.maxSpl;
- mMinSpl = parcelable.minSpl;
- mDirectionality = parcelable.directionality;
- return OK;
- }
-
- std::string getDeviceId() const {
- return mDeviceId;
- }
-
- int getPortId() const {
- return mPortId;
- }
-
- unsigned int getType() const {
- return mType;
- }
-
- std::string getAddress() const {
- return mAddress;
- }
-
- int getDeviceLocation() const {
- return mDeviceLocation;
- }
-
- int getDeviceGroup() const {
- return mDeviceGroup;
- }
-
- int getIndexInTheGroup() const {
- return mIndexInTheGroup;
- }
-
- const std::vector<float>& getGeometricLocation() const {
- return mGeometricLocation;
- }
-
- const std::vector<float>& getOrientation() const {
- return mOrientation;
- }
-
- const std::vector<std::vector<float>>& getFrequencyResponses() const {
- return mFrequencyResponses;
- }
-
- const std::vector<int>& getChannelMapping() const {
- return mChannelMapping;
- }
-
- float getSensitivity() const {
- return mSensitivity;
- }
-
- float getMaxSpl() const {
- return mMaxSpl;
- }
-
- float getMinSpl() const {
- return mMinSpl;
- }
-
- int getDirectionality() const {
- return mDirectionality;
- }
-
-private:
- std::string mDeviceId;
- int32_t mPortId;
- uint32_t mType;
- std::string mAddress;
- int32_t mDeviceLocation;
- int32_t mDeviceGroup;
- int32_t mIndexInTheGroup;
- std::vector<float> mGeometricLocation;
- std::vector<float> mOrientation;
- std::vector<std::vector<float>> mFrequencyResponses;
- std::vector<int> mChannelMapping;
- float mSensitivity;
- float mMaxSpl;
- float mMinSpl;
- int32_t mDirectionality;
-};
-
-#if defined(BACKEND_NDK)
-using ::aidl::ConversionResult;
-#endif
-
-// Conversion routines, according to AidlConversion.h conventions.
-inline ConversionResult<MicrophoneInfo>
-aidl2legacy_MicrophoneInfo(const media::MicrophoneInfoData& aidl) {
- MicrophoneInfo legacy;
- RETURN_IF_ERROR(legacy.readFromParcelable(aidl));
- return legacy;
-}
-
-inline ConversionResult<media::MicrophoneInfoData>
-legacy2aidl_MicrophoneInfo(const MicrophoneInfo& legacy) {
- media::MicrophoneInfoData aidl;
- RETURN_IF_ERROR(legacy.writeToParcelable(&aidl));
- return aidl;
-}
-
-} // namespace media
-} // namespace android
-
-#endif
diff --git a/media/audioaidlconversion/AidlConversionCppNdk.cpp b/media/audioaidlconversion/AidlConversionCppNdk.cpp
index d0ff091..be80055 100644
--- a/media/audioaidlconversion/AidlConversionCppNdk.cpp
+++ b/media/audioaidlconversion/AidlConversionCppNdk.cpp
@@ -83,6 +83,8 @@
using media::audio::common::AudioUuid;
using media::audio::common::ExtraAudioDescriptor;
using media::audio::common::Int;
+using media::audio::common::MicrophoneDynamicInfo;
+using media::audio::common::MicrophoneInfo;
using media::audio::common::PcmType;
////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -2727,6 +2729,280 @@
return unexpected(BAD_VALUE);
}
+ConversionResult<audio_microphone_location_t>
+aidl2legacy_MicrophoneInfoLocation_audio_microphone_location_t(MicrophoneInfo::Location aidl) {
+ switch (aidl) {
+ case MicrophoneInfo::Location::UNKNOWN:
+ return AUDIO_MICROPHONE_LOCATION_UNKNOWN;
+ case MicrophoneInfo::Location::MAINBODY:
+ return AUDIO_MICROPHONE_LOCATION_MAINBODY;
+ case MicrophoneInfo::Location::MAINBODY_MOVABLE:
+ return AUDIO_MICROPHONE_LOCATION_MAINBODY_MOVABLE;
+ case MicrophoneInfo::Location::PERIPHERAL:
+ return AUDIO_MICROPHONE_LOCATION_PERIPHERAL;
+ }
+ return unexpected(BAD_VALUE);
+}
+ConversionResult<MicrophoneInfo::Location>
+legacy2aidl_audio_microphone_location_t_MicrophoneInfoLocation(audio_microphone_location_t legacy) {
+ switch (legacy) {
+ case AUDIO_MICROPHONE_LOCATION_UNKNOWN:
+ return MicrophoneInfo::Location::UNKNOWN;
+ case AUDIO_MICROPHONE_LOCATION_MAINBODY:
+ return MicrophoneInfo::Location::MAINBODY;
+ case AUDIO_MICROPHONE_LOCATION_MAINBODY_MOVABLE:
+ return MicrophoneInfo::Location::MAINBODY_MOVABLE;
+ case AUDIO_MICROPHONE_LOCATION_PERIPHERAL:
+ return MicrophoneInfo::Location::PERIPHERAL;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_microphone_group_t> aidl2legacy_int32_t_audio_microphone_group_t(
+ int32_t aidl) {
+ return convertReinterpret<audio_microphone_group_t>(aidl);
+}
+
+ConversionResult<int32_t> legacy2aidl_audio_microphone_group_t_int32_t(
+ audio_microphone_group_t legacy) {
+ return convertReinterpret<int32_t>(legacy);
+}
+
+ConversionResult<audio_microphone_directionality_t>
+aidl2legacy_MicrophoneInfoDirectionality_audio_microphone_directionality_t(
+ MicrophoneInfo::Directionality aidl) {
+ switch (aidl) {
+ case MicrophoneInfo::Directionality::UNKNOWN:
+ return AUDIO_MICROPHONE_DIRECTIONALITY_UNKNOWN;
+ case MicrophoneInfo::Directionality::OMNI:
+ return AUDIO_MICROPHONE_DIRECTIONALITY_OMNI;
+ case MicrophoneInfo::Directionality::BI_DIRECTIONAL:
+ return AUDIO_MICROPHONE_DIRECTIONALITY_BI_DIRECTIONAL;
+ case MicrophoneInfo::Directionality::CARDIOID:
+ return AUDIO_MICROPHONE_DIRECTIONALITY_CARDIOID;
+ case MicrophoneInfo::Directionality::HYPER_CARDIOID:
+ return AUDIO_MICROPHONE_DIRECTIONALITY_HYPER_CARDIOID;
+ case MicrophoneInfo::Directionality::SUPER_CARDIOID:
+ return AUDIO_MICROPHONE_DIRECTIONALITY_SUPER_CARDIOID;
+ }
+ return unexpected(BAD_VALUE);
+}
+ConversionResult<MicrophoneInfo::Directionality>
+legacy2aidl_audio_microphone_directionality_t_MicrophoneInfoDirectionality(
+ audio_microphone_directionality_t legacy) {
+ switch (legacy) {
+ case AUDIO_MICROPHONE_DIRECTIONALITY_UNKNOWN:
+ return MicrophoneInfo::Directionality::UNKNOWN;
+ case AUDIO_MICROPHONE_DIRECTIONALITY_OMNI:
+ return MicrophoneInfo::Directionality::OMNI;
+ case AUDIO_MICROPHONE_DIRECTIONALITY_BI_DIRECTIONAL:
+ return MicrophoneInfo::Directionality::BI_DIRECTIONAL;
+ case AUDIO_MICROPHONE_DIRECTIONALITY_CARDIOID:
+ return MicrophoneInfo::Directionality::CARDIOID;
+ case AUDIO_MICROPHONE_DIRECTIONALITY_HYPER_CARDIOID:
+ return MicrophoneInfo::Directionality::HYPER_CARDIOID;
+ case AUDIO_MICROPHONE_DIRECTIONALITY_SUPER_CARDIOID:
+ return MicrophoneInfo::Directionality::SUPER_CARDIOID;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_microphone_coordinate>
+aidl2legacy_MicrophoneInfoCoordinate_audio_microphone_coordinate(
+ const MicrophoneInfo::Coordinate& aidl) {
+ audio_microphone_coordinate legacy;
+ legacy.x = aidl.x;
+ legacy.y = aidl.y;
+ legacy.z = aidl.z;
+ return legacy;
+}
+ConversionResult<MicrophoneInfo::Coordinate>
+legacy2aidl_audio_microphone_coordinate_MicrophoneInfoCoordinate(
+ const audio_microphone_coordinate& legacy) {
+ MicrophoneInfo::Coordinate aidl;
+ aidl.x = legacy.x;
+ aidl.y = legacy.y;
+ aidl.z = legacy.z;
+ return aidl;
+}
+
+ConversionResult<audio_microphone_channel_mapping_t>
+aidl2legacy_MicrophoneDynamicInfoChannelMapping_audio_microphone_channel_mapping_t(
+ MicrophoneDynamicInfo::ChannelMapping aidl) {
+ switch (aidl) {
+ case MicrophoneDynamicInfo::ChannelMapping::UNUSED:
+ return AUDIO_MICROPHONE_CHANNEL_MAPPING_UNUSED;
+ case MicrophoneDynamicInfo::ChannelMapping::DIRECT:
+ return AUDIO_MICROPHONE_CHANNEL_MAPPING_DIRECT;
+ case MicrophoneDynamicInfo::ChannelMapping::PROCESSED:
+ return AUDIO_MICROPHONE_CHANNEL_MAPPING_PROCESSED;
+ }
+ return unexpected(BAD_VALUE);
+}
+ConversionResult<MicrophoneDynamicInfo::ChannelMapping>
+legacy2aidl_audio_microphone_channel_mapping_t_MicrophoneDynamicInfoChannelMapping(
+ audio_microphone_channel_mapping_t legacy) {
+ switch (legacy) {
+ case AUDIO_MICROPHONE_CHANNEL_MAPPING_UNUSED:
+ return MicrophoneDynamicInfo::ChannelMapping::UNUSED;
+ case AUDIO_MICROPHONE_CHANNEL_MAPPING_DIRECT:
+ return MicrophoneDynamicInfo::ChannelMapping::DIRECT;
+ case AUDIO_MICROPHONE_CHANNEL_MAPPING_PROCESSED:
+ return MicrophoneDynamicInfo::ChannelMapping::PROCESSED;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_microphone_characteristic_t>
+aidl2legacy_MicrophoneInfos_audio_microphone_characteristic_t(
+ const MicrophoneInfo& aidlInfo, const MicrophoneDynamicInfo& aidlDynamic) {
+ static const audio_microphone_coordinate kCoordinateUnknown = {
+ AUDIO_MICROPHONE_COORDINATE_UNKNOWN, AUDIO_MICROPHONE_COORDINATE_UNKNOWN,
+ AUDIO_MICROPHONE_COORDINATE_UNKNOWN };
+ audio_microphone_characteristic_t legacy{};
+ if (aidlInfo.id != aidlDynamic.id) {
+ return unexpected(BAD_VALUE);
+ }
+ // Note: in the legacy structure, 'device_id' is the mic's ID, 'id' is APM port id.
+ RETURN_IF_ERROR(aidl2legacy_string(aidlInfo.id, legacy.device_id, AUDIO_MICROPHONE_ID_MAX_LEN));
+ RETURN_IF_ERROR(aidl2legacy_AudioDevice_audio_device(
+ aidlInfo.device, &legacy.device, legacy.address));
+ legacy.location = VALUE_OR_RETURN(
+ aidl2legacy_MicrophoneInfoLocation_audio_microphone_location_t(aidlInfo.location));
+ legacy.group = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_microphone_group_t(aidlInfo.group));
+ // For some reason, the legacy field is unsigned, however in the SDK layer it is signed,
+ // as it is in AIDL. So, use UINT_MAX for INDEX_IN_THE_GROUP_UNKNOWN which is -1.
+ if (aidlInfo.indexInTheGroup != MicrophoneInfo::INDEX_IN_THE_GROUP_UNKNOWN) {
+ legacy.index_in_the_group = VALUE_OR_RETURN(
+ convertReinterpret<unsigned int>(aidlInfo.indexInTheGroup));
+ } else {
+ legacy.index_in_the_group = UINT_MAX;
+ }
+ if (aidlInfo.sensitivity.has_value()) {
+ legacy.sensitivity = aidlInfo.sensitivity.value().leveldBFS;
+ legacy.max_spl = aidlInfo.sensitivity.value().maxSpldB;
+ legacy.min_spl = aidlInfo.sensitivity.value().minSpldB;
+ } else {
+ legacy.sensitivity = AUDIO_MICROPHONE_SENSITIVITY_UNKNOWN;
+ legacy.max_spl = AUDIO_MICROPHONE_SPL_UNKNOWN;
+ legacy.min_spl = AUDIO_MICROPHONE_SPL_UNKNOWN;
+ }
+ legacy.directionality = VALUE_OR_RETURN(
+ aidl2legacy_MicrophoneInfoDirectionality_audio_microphone_directionality_t(
+ aidlInfo.directionality));
+ if (aidlInfo.frequencyResponse.size() > AUDIO_MICROPHONE_MAX_FREQUENCY_RESPONSES) {
+ return unexpected(BAD_VALUE);
+ }
+ legacy.num_frequency_responses = 0;
+ for (const auto& p: aidlInfo.frequencyResponse) {
+ legacy.frequency_responses[0][legacy.num_frequency_responses] = p.frequencyHz;
+ legacy.frequency_responses[1][legacy.num_frequency_responses++] = p.leveldB;
+ }
+ if (aidlInfo.position.has_value()) {
+ legacy.geometric_location = VALUE_OR_RETURN(
+ aidl2legacy_MicrophoneInfoCoordinate_audio_microphone_coordinate(
+ aidlInfo.position.value()));
+ } else {
+ legacy.geometric_location = kCoordinateUnknown;
+ }
+ if (aidlInfo.orientation.has_value()) {
+ legacy.orientation = VALUE_OR_RETURN(
+ aidl2legacy_MicrophoneInfoCoordinate_audio_microphone_coordinate(
+ aidlInfo.orientation.value()));
+ } else {
+ legacy.orientation = kCoordinateUnknown;
+ }
+ if (aidlDynamic.channelMapping.size() > AUDIO_CHANNEL_COUNT_MAX) {
+ return unexpected(BAD_VALUE);
+ }
+ size_t i = 0;
+ for (; i < aidlDynamic.channelMapping.size(); ++i) {
+ legacy.channel_mapping[i] = VALUE_OR_RETURN(
+ aidl2legacy_MicrophoneDynamicInfoChannelMapping_audio_microphone_channel_mapping_t(
+ aidlDynamic.channelMapping[i]));
+ }
+ for (; i < AUDIO_CHANNEL_COUNT_MAX; ++i) {
+ legacy.channel_mapping[i] = AUDIO_MICROPHONE_CHANNEL_MAPPING_UNUSED;
+ }
+ return legacy;
+}
+
+status_t
+legacy2aidl_audio_microphone_characteristic_t_MicrophoneInfos(
+ const audio_microphone_characteristic_t& legacy,
+ MicrophoneInfo* aidlInfo, MicrophoneDynamicInfo* aidlDynamic) {
+ aidlInfo->id = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_string(legacy.device_id, AUDIO_MICROPHONE_ID_MAX_LEN));
+ aidlDynamic->id = aidlInfo->id;
+ aidlInfo->device = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_device_AudioDevice(
+ legacy.device, legacy.address));
+ aidlInfo->location = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_microphone_location_t_MicrophoneInfoLocation(legacy.location));
+ aidlInfo->group = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_microphone_group_t_int32_t(legacy.group));
+ // For some reason, the legacy field is unsigned, however in the SDK layer it is signed,
+ // as it is in AIDL. So, use UINT_MAX for INDEX_IN_THE_GROUP_UNKNOWN which is -1.
+ if (legacy.index_in_the_group != UINT_MAX) {
+ aidlInfo->indexInTheGroup = VALUE_OR_RETURN_STATUS(
+ convertReinterpret<int32_t>(legacy.index_in_the_group));
+ } else {
+ aidlInfo->indexInTheGroup = MicrophoneInfo::INDEX_IN_THE_GROUP_UNKNOWN;
+ }
+ if (legacy.sensitivity != AUDIO_MICROPHONE_SENSITIVITY_UNKNOWN &&
+ legacy.max_spl != AUDIO_MICROPHONE_SPL_UNKNOWN &&
+ legacy.min_spl != AUDIO_MICROPHONE_SPL_UNKNOWN) {
+ MicrophoneInfo::Sensitivity sensitivity;
+ sensitivity.leveldBFS = legacy.sensitivity;
+ sensitivity.maxSpldB = legacy.max_spl;
+ sensitivity.minSpldB = legacy.min_spl;
+ aidlInfo->sensitivity = std::move(sensitivity);
+ } else {
+ aidlInfo->sensitivity = {};
+ }
+ aidlInfo->directionality = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_microphone_directionality_t_MicrophoneInfoDirectionality(
+ legacy.directionality));
+ if (legacy.num_frequency_responses > AUDIO_MICROPHONE_MAX_FREQUENCY_RESPONSES) {
+ return BAD_VALUE;
+ }
+ aidlInfo->frequencyResponse.resize(legacy.num_frequency_responses);
+ for (size_t i = 0; i < legacy.num_frequency_responses; ++i) {
+ aidlInfo->frequencyResponse[i].frequencyHz = legacy.frequency_responses[0][i];
+ aidlInfo->frequencyResponse[i].leveldB = legacy.frequency_responses[1][i];
+ }
+ if (legacy.geometric_location.x != AUDIO_MICROPHONE_COORDINATE_UNKNOWN &&
+ legacy.geometric_location.y != AUDIO_MICROPHONE_COORDINATE_UNKNOWN &&
+ legacy.geometric_location.z != AUDIO_MICROPHONE_COORDINATE_UNKNOWN) {
+ aidlInfo->position = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_microphone_coordinate_MicrophoneInfoCoordinate(
+ legacy.geometric_location));
+ } else {
+ aidlInfo->position = {};
+ }
+ if (legacy.orientation.x != AUDIO_MICROPHONE_COORDINATE_UNKNOWN &&
+ legacy.orientation.y != AUDIO_MICROPHONE_COORDINATE_UNKNOWN &&
+ legacy.orientation.z != AUDIO_MICROPHONE_COORDINATE_UNKNOWN) {
+ aidlInfo->orientation = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_microphone_coordinate_MicrophoneInfoCoordinate(
+ legacy.orientation));
+ } else {
+ aidlInfo->orientation = {};
+ }
+ size_t channelsUsed = AUDIO_CHANNEL_COUNT_MAX;
+ while (channelsUsed != 0 &&
+ legacy.channel_mapping[--channelsUsed] == AUDIO_MICROPHONE_CHANNEL_MAPPING_UNUSED) {}
+ // Doing an increment is correct even when channel 0 is 'UNUSED',
+ // that's because AIDL requires to have at least 1 element in the mapping.
+ ++channelsUsed;
+ aidlDynamic->channelMapping.resize(channelsUsed);
+ for (size_t i = 0; i < channelsUsed; ++i) {
+ aidlDynamic->channelMapping[i] = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_microphone_channel_mapping_t_MicrophoneDynamicInfoChannelMapping(
+ legacy.channel_mapping[i]));
+ }
+ return OK;
+}
+
} // namespace android
#if defined(BACKEND_NDK)
diff --git a/media/audioaidlconversion/AidlConversionEffect.cpp b/media/audioaidlconversion/AidlConversionEffect.cpp
index ad27c64..2df97d1 100644
--- a/media/audioaidlconversion/AidlConversionEffect.cpp
+++ b/media/audioaidlconversion/AidlConversionEffect.cpp
@@ -30,7 +30,7 @@
namespace android {
using ::aidl::android::hardware::audio::effect::AcousticEchoCanceler;
-using ::aidl::android::hardware::audio::effect::AutomaticGainControl;
+using ::aidl::android::hardware::audio::effect::AutomaticGainControlV2;
using ::aidl::android::hardware::audio::effect::BassBoost;
using ::aidl::android::hardware::audio::effect::Descriptor;
using ::aidl::android::hardware::audio::effect::Downmix;
@@ -260,46 +260,47 @@
ConversionResult<uint32_t> aidl2legacy_Parameter_agc_uint32_fixedDigitalGain(
const Parameter& aidl) {
int gain = VALUE_OR_RETURN(
- GET_PARAMETER_SPECIFIC_FIELD(aidl, AutomaticGainControl, automaticGainControl,
- AutomaticGainControl::fixedDigitalGainMb, int));
+ GET_PARAMETER_SPECIFIC_FIELD(aidl, AutomaticGainControlV2, automaticGainControlV2,
+ AutomaticGainControlV2::fixedDigitalGainMb, int));
return VALUE_OR_RETURN(convertReinterpret<uint32_t>(gain));
}
ConversionResult<Parameter> legacy2aidl_uint32_fixedDigitalGain_Parameter_agc(uint32_t legacy) {
int gain = VALUE_OR_RETURN(convertReinterpret<int>(legacy));
- return MAKE_SPECIFIC_PARAMETER(AutomaticGainControl, automaticGainControl, fixedDigitalGainMb,
- gain);
+ return MAKE_SPECIFIC_PARAMETER(AutomaticGainControlV2, automaticGainControlV2,
+ fixedDigitalGainMb, gain);
}
ConversionResult<uint32_t> aidl2legacy_Parameter_agc_uint32_levelEstimator(
const Parameter& aidl) {
const auto& le = VALUE_OR_RETURN(GET_PARAMETER_SPECIFIC_FIELD(
- aidl, AutomaticGainControl, automaticGainControl, AutomaticGainControl::levelEstimator,
- AutomaticGainControl::LevelEstimator));
+ aidl, AutomaticGainControlV2, automaticGainControlV2,
+ AutomaticGainControlV2::levelEstimator, AutomaticGainControlV2::LevelEstimator));
return static_cast<uint32_t>(le);
}
ConversionResult<Parameter> legacy2aidl_uint32_levelEstimator_Parameter_agc(uint32_t legacy) {
- if (legacy > (uint32_t) AutomaticGainControl::LevelEstimator::PEAK) {
+ if (legacy > (uint32_t)AutomaticGainControlV2::LevelEstimator::PEAK) {
return unexpected(BAD_VALUE);
}
- AutomaticGainControl::LevelEstimator le =
- static_cast<AutomaticGainControl::LevelEstimator>(legacy);
- return MAKE_SPECIFIC_PARAMETER(AutomaticGainControl, automaticGainControl, levelEstimator, le);
+ AutomaticGainControlV2::LevelEstimator le =
+ static_cast<AutomaticGainControlV2::LevelEstimator>(legacy);
+ return MAKE_SPECIFIC_PARAMETER(AutomaticGainControlV2, automaticGainControlV2, levelEstimator,
+ le);
}
ConversionResult<uint32_t> aidl2legacy_Parameter_agc_uint32_saturationMargin(
const Parameter& aidl) {
int saturationMargin = VALUE_OR_RETURN(
- GET_PARAMETER_SPECIFIC_FIELD(aidl, AutomaticGainControl, automaticGainControl,
- AutomaticGainControl::saturationMarginMb, int));
+ GET_PARAMETER_SPECIFIC_FIELD(aidl, AutomaticGainControlV2, automaticGainControlV2,
+ AutomaticGainControlV2::saturationMarginMb, int));
return VALUE_OR_RETURN(convertIntegral<uint32_t>(saturationMargin));
}
ConversionResult<Parameter> legacy2aidl_uint32_saturationMargin_Parameter_agc(uint32_t legacy) {
int saturationMargin = VALUE_OR_RETURN(convertIntegral<int>(legacy));
- return MAKE_SPECIFIC_PARAMETER(AutomaticGainControl, automaticGainControl, saturationMarginMb,
- saturationMargin);
+ return MAKE_SPECIFIC_PARAMETER(AutomaticGainControlV2, automaticGainControlV2,
+ saturationMarginMb, saturationMargin);
}
ConversionResult<uint16_t> aidl2legacy_Parameter_BassBoost_uint16_strengthPm(
diff --git a/media/audioaidlconversion/include/media/AidlConversionCppNdk.h b/media/audioaidlconversion/include/media/AidlConversionCppNdk.h
index c412238..abf0231 100644
--- a/media/audioaidlconversion/include/media/AidlConversionCppNdk.h
+++ b/media/audioaidlconversion/include/media/AidlConversionCppNdk.h
@@ -61,6 +61,8 @@
#include PREFIX(android/media/audio/common/AudioUuid.h)
#include PREFIX(android/media/audio/common/ExtraAudioDescriptor.h)
#include PREFIX(android/media/audio/common/Int.h)
+#include PREFIX(android/media/audio/common/MicrophoneDynamicInfo.h)
+#include PREFIX(android/media/audio/common/MicrophoneInfo.h)
#undef PREFIX
#include <media/AidlConversionUtil.h>
@@ -371,6 +373,48 @@
ConversionResult<media::audio::common::AudioLatencyMode>
legacy2aidl_audio_latency_mode_t_AudioLatencyMode(audio_latency_mode_t legacy);
+ConversionResult<audio_microphone_location_t>
+aidl2legacy_MicrophoneInfoLocation_audio_microphone_location_t(
+ media::audio::common::MicrophoneInfo::Location aidl);
+ConversionResult<media::audio::common::MicrophoneInfo::Location>
+legacy2aidl_audio_microphone_location_t_MicrophoneInfoLocation(audio_microphone_location_t legacy);
+
+ConversionResult<audio_microphone_group_t> aidl2legacy_int32_t_audio_microphone_group_t(
+ int32_t aidl);
+ConversionResult<int32_t> legacy2aidl_audio_microphone_group_t_int32_t(
+ audio_microphone_group_t legacy);
+
+ConversionResult<audio_microphone_directionality_t>
+aidl2legacy_MicrophoneInfoDirectionality_audio_microphone_directionality_t(
+ media::audio::common::MicrophoneInfo::Directionality aidl);
+ConversionResult<media::audio::common::MicrophoneInfo::Directionality>
+legacy2aidl_audio_microphone_directionality_t_MicrophoneInfoDirectionality(
+ audio_microphone_directionality_t legacy);
+
+ConversionResult<audio_microphone_coordinate>
+aidl2legacy_MicrophoneInfoCoordinate_audio_microphone_coordinate(
+ const media::audio::common::MicrophoneInfo::Coordinate& aidl);
+ConversionResult<media::audio::common::MicrophoneInfo::Coordinate>
+legacy2aidl_audio_microphone_coordinate_MicrophoneInfoCoordinate(
+ const audio_microphone_coordinate& legacy);
+
+ConversionResult<audio_microphone_channel_mapping_t>
+aidl2legacy_MicrophoneDynamicInfoChannelMapping_audio_microphone_channel_mapping_t(
+ media::audio::common::MicrophoneDynamicInfo::ChannelMapping aidl);
+ConversionResult<media::audio::common::MicrophoneDynamicInfo::ChannelMapping>
+legacy2aidl_audio_microphone_channel_mapping_t_MicrophoneDynamicInfoChannelMapping(
+ audio_microphone_channel_mapping_t legacy);
+
+ConversionResult<audio_microphone_characteristic_t>
+aidl2legacy_MicrophoneInfos_audio_microphone_characteristic_t(
+ const media::audio::common::MicrophoneInfo& aidlInfo,
+ const media::audio::common::MicrophoneDynamicInfo& aidlDynamic);
+status_t
+legacy2aidl_audio_microphone_characteristic_t_MicrophoneInfos(
+ const audio_microphone_characteristic_t& legacy,
+ media::audio::common::MicrophoneInfo* aidlInfo,
+ media::audio::common::MicrophoneDynamicInfo* aidlDynamic);
+
} // namespace android
#if defined(BACKEND_NDK)
diff --git a/media/codec2/hal/client/Android.bp b/media/codec2/hal/client/Android.bp
index d2ef58c..31244fe 100644
--- a/media/codec2/hal/client/Android.bp
+++ b/media/codec2/hal/client/Android.bp
@@ -43,7 +43,6 @@
"android.hardware.media.c2@1.0",
"android.hardware.media.c2@1.1",
"android.hardware.media.c2@1.2",
- "android.hardware.media.c2-V1-ndk",
"libbase",
"libbinder",
"libbinder_ndk",
diff --git a/media/codec2/hal/client/client.cpp b/media/codec2/hal/client/client.cpp
index f5128ca..7f75a91 100644
--- a/media/codec2/hal/client/client.cpp
+++ b/media/codec2/hal/client/client.cpp
@@ -33,15 +33,6 @@
#include <android/hardware/media/c2/1.0/IConfigurable.h>
#include <android/hidl/manager/1.2/IServiceManager.h>
-#include <aidl/android/hardware/media/c2/FieldSupportedValues.h>
-#include <aidl/android/hardware/media/c2/FieldSupportedValuesQuery.h>
-#include <aidl/android/hardware/media/c2/FieldSupportedValuesQueryResult.h>
-#include <aidl/android/hardware/media/c2/IComponent.h>
-#include <aidl/android/hardware/media/c2/IComponentInterface.h>
-#include <aidl/android/hardware/media/c2/IComponentStore.h>
-#include <aidl/android/hardware/media/c2/IConfigurable.h>
-#include <aidl/android/hardware/media/c2/ParamDescriptor.h>
-
#include <android-base/properties.h>
#include <bufferpool/ClientManager.h>
#include <codec2/hidl/1.0/types.h>
@@ -85,7 +76,6 @@
using ::android::hardware::media::c2::V1_2::SurfaceSyncObj;
namespace bufferpool_hidl = ::android::hardware::media::bufferpool::V2_0;
-namespace c2_aidl = ::aidl::android::hardware::media::c2;
namespace c2_hidl_base = ::android::hardware::media::c2;
namespace c2_hidl = ::android::hardware::media::c2::V1_2;
@@ -537,7 +527,8 @@
// Codec2ConfigurableClient::AidlImpl
struct Codec2ConfigurableClient::AidlImpl : public Codec2ConfigurableClient::ImplBase {
- typedef c2_aidl::IConfigurable Base;
+ // TODO: C2AIDL was not landed yet, use c2_aidl when it is landed.
+ typedef c2_hidl::IConfigurable Base;
// base cannot be null.
explicit AidlImpl(const std::shared_ptr<Base>& base);
@@ -573,9 +564,9 @@
Codec2ConfigurableClient::AidlImpl::AidlImpl(const std::shared_ptr<Base>& base)
: mBase{base},
mName{[base]() -> C2String {
- std::string outName;
- ndk::ScopedAStatus status = base->getName(&outName);
- return status.isOk() ? outName : "";
+ // TODO: implementation
+ (void)base;
+ return "";
}()} {
}
@@ -619,11 +610,6 @@
: mImpl(new Codec2ConfigurableClient::HidlImpl(hidlBase)) {
}
-Codec2ConfigurableClient::Codec2ConfigurableClient(
- const std::shared_ptr<AidlBase> &aidlBase)
- : mImpl(new Codec2ConfigurableClient::AidlImpl(aidlBase)) {
-}
-
const C2String& Codec2ConfigurableClient::getName() const {
return mImpl->getName();
}
diff --git a/media/codec2/hal/client/include/codec2/hidl/client.h b/media/codec2/hal/client/include/codec2/hidl/client.h
index 11f5911..6a71f91 100644
--- a/media/codec2/hal/client/include/codec2/hidl/client.h
+++ b/media/codec2/hal/client/include/codec2/hidl/client.h
@@ -113,7 +113,6 @@
struct Codec2ConfigurableClient {
typedef ::android::hardware::media::c2::V1_0::IConfigurable HidlBase;
- typedef ::aidl::android::hardware::media::c2::IConfigurable AidlBase;
struct ImplBase {
virtual ~ImplBase() = default;
@@ -141,7 +140,6 @@
};
explicit Codec2ConfigurableClient(const sp<HidlBase> &hidlBase);
- explicit Codec2ConfigurableClient(const std::shared_ptr<AidlBase> &aidlBase);
const C2String& getName() const;
diff --git a/media/libaudioclient/AidlConversion.cpp b/media/libaudioclient/AidlConversion.cpp
index b3c8643..3a5ba78 100644
--- a/media/libaudioclient/AidlConversion.cpp
+++ b/media/libaudioclient/AidlConversion.cpp
@@ -990,4 +990,24 @@
indexToEnum_bitmask<audio_direct_mode_t>,
enumToMask_index<int32_t, media::AudioDirectMode>);
}
+
+ConversionResult<audio_microphone_characteristic_t>
+aidl2legacy_MicrophoneInfoFw_audio_microphone_characteristic_t(
+ const media::MicrophoneInfoFw& aidl) {
+ audio_microphone_characteristic_t legacy =
+ VALUE_OR_RETURN(aidl2legacy_MicrophoneInfos_audio_microphone_characteristic_t(
+ aidl.info, aidl.dynamic));
+ legacy.id = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.portId));
+ return legacy;
+}
+ConversionResult<media::MicrophoneInfoFw>
+legacy2aidl_audio_microphone_characteristic_t_MicrophoneInfoFw(
+ const audio_microphone_characteristic_t& legacy) {
+ media::MicrophoneInfoFw aidl;
+ RETURN_IF_ERROR(legacy2aidl_audio_microphone_characteristic_t_MicrophoneInfos(
+ legacy, &aidl.info, &aidl.dynamic));
+ aidl.portId = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy.id));
+ return aidl;
+}
+
} // namespace android
diff --git a/media/libaudioclient/Android.bp b/media/libaudioclient/Android.bp
index 50e9ea7..2bbfb76 100644
--- a/media/libaudioclient/Android.bp
+++ b/media/libaudioclient/Android.bp
@@ -199,6 +199,7 @@
srcs: ["AidlConversion.cpp"],
shared_libs: [
"audioclient-types-aidl-cpp",
+ "av-types-aidl-cpp",
],
static_libs: [
"libaudio_aidl_conversion_common_cpp",
@@ -212,6 +213,7 @@
],
export_shared_lib_headers: [
"audioclient-types-aidl-cpp",
+ "av-types-aidl-cpp",
],
defaults: [
"audio_aidl_conversion_common_default",
diff --git a/media/libaudioclient/AudioRecord.cpp b/media/libaudioclient/AudioRecord.cpp
index 12bcec6..f07ea1d 100644
--- a/media/libaudioclient/AudioRecord.cpp
+++ b/media/libaudioclient/AudioRecord.cpp
@@ -1635,16 +1635,10 @@
// -------------------------------------------------------------------------
-status_t AudioRecord::getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones)
+status_t AudioRecord::getActiveMicrophones(std::vector<media::MicrophoneInfoFw>* activeMicrophones)
{
AutoMutex lock(mLock);
- std::vector<media::MicrophoneInfoData> mics;
- status_t status = statusTFromBinderStatus(mAudioRecord->getActiveMicrophones(&mics));
- activeMicrophones->resize(mics.size());
- for (size_t i = 0; status == OK && i < mics.size(); ++i) {
- status = activeMicrophones->at(i).readFromParcelable(mics[i]);
- }
- return status;
+ return statusTFromBinderStatus(mAudioRecord->getActiveMicrophones(activeMicrophones));
}
status_t AudioRecord::setPreferredMicrophoneDirection(audio_microphone_direction_t direction)
diff --git a/media/libaudioclient/AudioSystem.cpp b/media/libaudioclient/AudioSystem.cpp
index 59016ad..706f51f 100644
--- a/media/libaudioclient/AudioSystem.cpp
+++ b/media/libaudioclient/AudioSystem.cpp
@@ -1936,7 +1936,7 @@
return result.value_or(NAN);
}
-status_t AudioSystem::getMicrophones(std::vector<media::MicrophoneInfo>* microphones) {
+status_t AudioSystem::getMicrophones(std::vector<media::MicrophoneInfoFw>* microphones) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
return af->getMicrophones(microphones);
diff --git a/media/libaudioclient/IAudioFlinger.cpp b/media/libaudioclient/IAudioFlinger.cpp
index 1c634e7..bbc39e8 100644
--- a/media/libaudioclient/IAudioFlinger.cpp
+++ b/media/libaudioclient/IAudioFlinger.cpp
@@ -753,14 +753,11 @@
}
status_t
-AudioFlingerClientAdapter::getMicrophones(std::vector<media::MicrophoneInfo>* microphones) {
- std::vector<media::MicrophoneInfoData> aidlRet;
- RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
- mDelegate->getMicrophones(&aidlRet)));
+AudioFlingerClientAdapter::getMicrophones(std::vector<media::MicrophoneInfoFw>* microphones) {
+ std::vector<media::MicrophoneInfoFw> aidlRet;
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mDelegate->getMicrophones(&aidlRet)));
if (microphones != nullptr) {
- *microphones = VALUE_OR_RETURN_STATUS(
- convertContainer<std::vector<media::MicrophoneInfo>>(aidlRet,
- media::aidl2legacy_MicrophoneInfo));
+ *microphones = std::move(aidlRet);
}
return OK;
}
@@ -1324,11 +1321,8 @@
}
Status AudioFlingerServerAdapter::getMicrophones(
- std::vector<media::MicrophoneInfoData>* _aidl_return) {
- std::vector<media::MicrophoneInfo> resultLegacy;
- RETURN_BINDER_IF_ERROR(mDelegate->getMicrophones(&resultLegacy));
- *_aidl_return = VALUE_OR_RETURN_BINDER(convertContainer<std::vector<media::MicrophoneInfoData>>(
- resultLegacy, media::legacy2aidl_MicrophoneInfo));
+ std::vector<media::MicrophoneInfoFw>* _aidl_return) {
+ RETURN_BINDER_IF_ERROR(mDelegate->getMicrophones(_aidl_return));
return Status::ok();
}
diff --git a/media/libaudioclient/aidl/android/media/IAudioFlingerService.aidl b/media/libaudioclient/aidl/android/media/IAudioFlingerService.aidl
index 69810c0..568c865 100644
--- a/media/libaudioclient/aidl/android/media/IAudioFlingerService.aidl
+++ b/media/libaudioclient/aidl/android/media/IAudioFlingerService.aidl
@@ -37,7 +37,7 @@
import android.media.IAudioTrack;
import android.media.ISoundDose;
import android.media.ISoundDoseCallback;
-import android.media.MicrophoneInfoData;
+import android.media.MicrophoneInfoFw;
import android.media.RenderPosition;
import android.media.TrackSecondaryOutputInfo;
import android.media.audio.common.AudioChannelLayout;
@@ -208,7 +208,7 @@
long frameCountHAL(int /* audio_io_handle_t */ ioHandle);
/* List available microphones and their characteristics */
- MicrophoneInfoData[] getMicrophones();
+ MicrophoneInfoFw[] getMicrophones();
void setAudioHalPids(in int[] /* pid_t[] */ pids);
diff --git a/media/libaudioclient/aidl/android/media/IAudioRecord.aidl b/media/libaudioclient/aidl/android/media/IAudioRecord.aidl
index 44ef80b..1ea4156 100644
--- a/media/libaudioclient/aidl/android/media/IAudioRecord.aidl
+++ b/media/libaudioclient/aidl/android/media/IAudioRecord.aidl
@@ -16,7 +16,7 @@
package android.media;
-import android.media.MicrophoneInfoData;
+import android.media.MicrophoneInfoFw;
/**
* Native code must specify namespace media (media::IAudioRecord) when referring to this class.
@@ -39,7 +39,7 @@
/* Get a list of current active microphones.
*/
- void getActiveMicrophones(out MicrophoneInfoData[] activeMicrophones);
+ void getActiveMicrophones(out MicrophoneInfoFw[] activeMicrophones);
/* Set the microphone direction (for processing).
*/
diff --git a/media/libaudioclient/fuzzer/audioflinger_fuzzer.cpp b/media/libaudioclient/fuzzer/audioflinger_fuzzer.cpp
index 47fe0f6..dfdb4cf 100644
--- a/media/libaudioclient/fuzzer/audioflinger_fuzzer.cpp
+++ b/media/libaudioclient/fuzzer/audioflinger_fuzzer.cpp
@@ -385,7 +385,7 @@
record->getInputFramesLost();
record->getFlags();
- std::vector<media::MicrophoneInfo> activeMicrophones;
+ std::vector<media::MicrophoneInfoFw> activeMicrophones;
record->getActiveMicrophones(&activeMicrophones);
record->releaseBuffer(&audioBuffer);
@@ -567,7 +567,7 @@
AudioSystem::getPrimaryOutputFrameCount();
AudioSystem::setLowRamDevice(mFdp.ConsumeBool(), mFdp.ConsumeIntegral<int64_t>());
- std::vector<media::MicrophoneInfo> microphones;
+ std::vector<media::MicrophoneInfoFw> microphones;
AudioSystem::getMicrophones(µphones);
std::vector<pid_t> pids;
diff --git a/media/libaudioclient/include/media/AidlConversion.h b/media/libaudioclient/include/media/AidlConversion.h
index f0e58ae..5bd0114 100644
--- a/media/libaudioclient/include/media/AidlConversion.h
+++ b/media/libaudioclient/include/media/AidlConversion.h
@@ -33,6 +33,7 @@
#include <android/media/AudioTimestampInternal.h>
#include <android/media/AudioUniqueIdUse.h>
#include <android/media/EffectDescriptor.h>
+#include <android/media/MicrophoneInfoFw.h>
#include <android/media/TrackSecondaryOutputInfo.h>
#include <android/media/SharedFileRegion.h>
@@ -198,4 +199,11 @@
ConversionResult<audio_direct_mode_t> aidl2legacy_int32_t_audio_direct_mode_t_mask(int32_t aidl);
ConversionResult<int32_t> legacy2aidl_audio_direct_mode_t_int32_t_mask(audio_direct_mode_t legacy);
+ConversionResult<audio_microphone_characteristic_t>
+aidl2legacy_MicrophoneInfoFw_audio_microphone_characteristic_t(
+ const media::MicrophoneInfoFw& aidl);
+ConversionResult<media::MicrophoneInfoFw>
+legacy2aidl_audio_microphone_characteristic_t_MicrophoneInfoFw(
+ const audio_microphone_characteristic_t& legacy);
+
} // namespace android
diff --git a/media/libaudioclient/include/media/AudioRecord.h b/media/libaudioclient/include/media/AudioRecord.h
index 3f33d7a..00f2c7a 100644
--- a/media/libaudioclient/include/media/AudioRecord.h
+++ b/media/libaudioclient/include/media/AudioRecord.h
@@ -26,7 +26,6 @@
#include <media/AudioTimestamp.h>
#include <media/MediaMetricsItem.h>
#include <media/Modulo.h>
-#include <media/MicrophoneInfo.h>
#include <media/RecordingActivityTracker.h>
#include <utils/RefBase.h>
#include <utils/threads.h>
@@ -584,10 +583,11 @@
/* Get the flags */
audio_input_flags_t getFlags() const { AutoMutex _l(mLock); return mFlags; }
- /* Get active microphones. A empty vector of MicrophoneInfo will be passed as a parameter,
+ /* Get active microphones. A empty vector of MicrophoneInfoFw will be passed as a parameter,
* the data will be filled when querying the hal.
*/
- status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones);
+ status_t getActiveMicrophones(
+ std::vector<media::MicrophoneInfoFw>* activeMicrophones);
/* Set the Microphone direction (for processing purposes).
*/
diff --git a/media/libaudioclient/include/media/AudioSystem.h b/media/libaudioclient/include/media/AudioSystem.h
index 23b0340..d033d4f 100644
--- a/media/libaudioclient/include/media/AudioSystem.h
+++ b/media/libaudioclient/include/media/AudioSystem.h
@@ -31,6 +31,7 @@
#include <android/media/ISoundDose.h>
#include <android/media/ISoundDoseCallback.h>
#include <android/media/ISpatializer.h>
+#include <android/media/MicrophoneInfoFw.h>
#include <android/media/RecordClientInfo.h>
#include <android/media/audio/common/AudioConfigBase.h>
#include <android/media/audio/common/AudioMMapPolicyInfo.h>
@@ -43,7 +44,6 @@
#include <media/AudioProductStrategy.h>
#include <media/AudioVolumeGroup.h>
#include <media/AudioIoDescriptor.h>
-#include <media/MicrophoneInfo.h>
#include <system/audio.h>
#include <system/audio_effect.h>
#include <system/audio_policy.h>
@@ -475,7 +475,7 @@
static float getStreamVolumeDB(
audio_stream_type_t stream, int index, audio_devices_t device);
- static status_t getMicrophones(std::vector<media::MicrophoneInfo> *microphones);
+ static status_t getMicrophones(std::vector<media::MicrophoneInfoFw> *microphones);
static status_t getHwOffloadFormatsSupportedForBluetoothMedia(
audio_devices_t device, std::vector<audio_format_t> *formats);
diff --git a/media/libaudioclient/include/media/IAudioFlinger.h b/media/libaudioclient/include/media/IAudioFlinger.h
index 6b6c407..02d0511 100644
--- a/media/libaudioclient/include/media/IAudioFlinger.h
+++ b/media/libaudioclient/include/media/IAudioFlinger.h
@@ -32,7 +32,6 @@
#include <system/audio_effect.h>
#include <system/audio_policy.h>
#include <utils/String8.h>
-#include <media/MicrophoneInfo.h>
#include <map>
#include <string>
#include <vector>
@@ -342,7 +341,7 @@
virtual size_t frameCountHAL(audio_io_handle_t ioHandle) const = 0;
/* List available microphones and their characteristics */
- virtual status_t getMicrophones(std::vector<media::MicrophoneInfo> *microphones) = 0;
+ virtual status_t getMicrophones(std::vector<media::MicrophoneInfoFw> *microphones) = 0;
virtual status_t setAudioHalPids(const std::vector<pid_t>& pids) = 0;
@@ -470,7 +469,7 @@
status_t audioPolicyReady() override;
size_t frameCountHAL(audio_io_handle_t ioHandle) const override;
- status_t getMicrophones(std::vector<media::MicrophoneInfo>* microphones) override;
+ status_t getMicrophones(std::vector<media::MicrophoneInfoFw>* microphones) override;
status_t setAudioHalPids(const std::vector<pid_t>& pids) override;
status_t setVibratorInfos(const std::vector<media::AudioVibratorInfo>& vibratorInfos) override;
status_t updateSecondaryOutputs(
@@ -698,7 +697,7 @@
Status systemReady() override;
Status audioPolicyReady() override;
Status frameCountHAL(int32_t ioHandle, int64_t* _aidl_return) override;
- Status getMicrophones(std::vector<media::MicrophoneInfoData>* _aidl_return) override;
+ Status getMicrophones(std::vector<media::MicrophoneInfoFw>* _aidl_return) override;
Status setAudioHalPids(const std::vector<int32_t>& pids) override;
Status setVibratorInfos(const std::vector<media::AudioVibratorInfo>& vibratorInfos) override;
Status updateSecondaryOutputs(
diff --git a/media/libaudioclient/tests/Android.bp b/media/libaudioclient/tests/Android.bp
index dcb6c25..2189521 100644
--- a/media/libaudioclient/tests/Android.bp
+++ b/media/libaudioclient/tests/Android.bp
@@ -39,6 +39,7 @@
"libaudioclient_aidl_conversion",
"libaudio_aidl_conversion_common_cpp",
"audioclient-types-aidl-cpp",
+ "av-types-aidl-cpp",
"libstagefright_foundation",
],
}
diff --git a/media/libaudioclient/tests/audio_aidl_legacy_conversion_tests.cpp b/media/libaudioclient/tests/audio_aidl_legacy_conversion_tests.cpp
index 5cd17e1..f651a37 100644
--- a/media/libaudioclient/tests/audio_aidl_legacy_conversion_tests.cpp
+++ b/media/libaudioclient/tests/audio_aidl_legacy_conversion_tests.cpp
@@ -47,6 +47,8 @@
using media::audio::common::AudioStandard;
using media::audio::common::ExtraAudioDescriptor;
using media::audio::common::Int;
+using media::audio::common::MicrophoneDynamicInfo;
+using media::audio::common::MicrophoneInfo;
using media::audio::common::PcmType;
// Provide value printers for types generated from AIDL
@@ -668,3 +670,73 @@
}
}
INSTANTIATE_TEST_SUITE_P(AudioGain, AudioGainTest, testing::Values(true, false));
+
+TEST(AudioMicrophoneInfoFw, Aidl2Legacy2Aidl) {
+ media::MicrophoneInfoFw initial{};
+ // HALs must return at least 1 element in channelMapping. The zero value is 'UNUSED'.
+ initial.dynamic.channelMapping.resize(1);
+ auto conv = aidl2legacy_MicrophoneInfoFw_audio_microphone_characteristic_t(initial);
+ ASSERT_TRUE(conv.ok());
+ auto convBack = legacy2aidl_audio_microphone_characteristic_t_MicrophoneInfoFw(conv.value());
+ ASSERT_TRUE(convBack.ok());
+ EXPECT_EQ(initial, convBack.value());
+}
+
+TEST(AudioMicrophoneInfoFw, UnknownValues) {
+ {
+ media::MicrophoneInfoFw initial;
+ initial.dynamic.channelMapping.resize(1);
+ initial.info.indexInTheGroup = MicrophoneInfo::INDEX_IN_THE_GROUP_UNKNOWN;
+ auto conv = aidl2legacy_MicrophoneInfoFw_audio_microphone_characteristic_t(initial);
+ ASSERT_TRUE(conv.ok());
+ auto convBack =
+ legacy2aidl_audio_microphone_characteristic_t_MicrophoneInfoFw(conv.value());
+ ASSERT_TRUE(convBack.ok());
+ EXPECT_EQ(initial, convBack.value());
+ }
+ for (const auto f : {&audio_microphone_characteristic_t::sensitivity,
+ &audio_microphone_characteristic_t::max_spl,
+ &audio_microphone_characteristic_t::min_spl}) {
+ audio_microphone_characteristic_t mic{};
+ if (f == &audio_microphone_characteristic_t::sensitivity) {
+ mic.*f = AUDIO_MICROPHONE_SENSITIVITY_UNKNOWN;
+ } else {
+ mic.*f = AUDIO_MICROPHONE_SPL_UNKNOWN;
+ }
+ auto aidl = legacy2aidl_audio_microphone_characteristic_t_MicrophoneInfoFw(mic);
+ ASSERT_TRUE(aidl.ok());
+ EXPECT_FALSE(aidl.value().info.sensitivity.has_value());
+ }
+ for (const auto f : {&audio_microphone_characteristic_t::geometric_location,
+ &audio_microphone_characteristic_t::orientation}) {
+ for (const auto c : {&audio_microphone_coordinate::x, &audio_microphone_coordinate::y,
+ &audio_microphone_coordinate::z}) {
+ audio_microphone_characteristic_t mic{};
+ mic.*f.*c = AUDIO_MICROPHONE_COORDINATE_UNKNOWN;
+ auto conv = legacy2aidl_audio_microphone_characteristic_t_MicrophoneInfoFw(mic);
+ ASSERT_TRUE(conv.ok());
+ const auto& aidl = conv.value();
+ if (f == &audio_microphone_characteristic_t::geometric_location) {
+ EXPECT_FALSE(aidl.info.position.has_value());
+ EXPECT_TRUE(aidl.info.orientation.has_value());
+ } else {
+ EXPECT_TRUE(aidl.info.position.has_value());
+ EXPECT_FALSE(aidl.info.orientation.has_value());
+ }
+ }
+ }
+}
+
+TEST(AudioMicrophoneInfoFw, ChannelMapping) {
+ audio_microphone_characteristic_t mic{};
+ mic.channel_mapping[1] = AUDIO_MICROPHONE_CHANNEL_MAPPING_DIRECT;
+ mic.channel_mapping[3] = AUDIO_MICROPHONE_CHANNEL_MAPPING_PROCESSED;
+ auto conv = legacy2aidl_audio_microphone_characteristic_t_MicrophoneInfoFw(mic);
+ ASSERT_TRUE(conv.ok());
+ const auto& aidl = conv.value();
+ EXPECT_EQ(4, aidl.dynamic.channelMapping.size());
+ EXPECT_EQ(MicrophoneDynamicInfo::ChannelMapping::UNUSED, aidl.dynamic.channelMapping[0]);
+ EXPECT_EQ(MicrophoneDynamicInfo::ChannelMapping::DIRECT, aidl.dynamic.channelMapping[1]);
+ EXPECT_EQ(MicrophoneDynamicInfo::ChannelMapping::UNUSED, aidl.dynamic.channelMapping[2]);
+ EXPECT_EQ(MicrophoneDynamicInfo::ChannelMapping::PROCESSED, aidl.dynamic.channelMapping[3]);
+}
diff --git a/media/libaudiohal/impl/Android.bp b/media/libaudiohal/impl/Android.bp
index 17993f5..0e98856 100644
--- a/media/libaudiohal/impl/Android.bp
+++ b/media/libaudiohal/impl/Android.bp
@@ -55,6 +55,7 @@
shared_libs: [
"audioclient-types-aidl-cpp",
"av-types-aidl-cpp",
+ "libaudioclient_aidl_conversion",
"libaudiofoundation",
"libaudioutils",
"libbase",
@@ -71,6 +72,9 @@
"libaudioclient_headers",
"libaudiohal_headers"
],
+ defaults: [
+ "latest_android_media_audio_common_types_cpp_export_shared",
+ ],
export_shared_lib_headers: [
"libfmq",
@@ -247,7 +251,7 @@
"latest_android_hardware_audio_common_ndk_shared",
"latest_android_hardware_audio_core_ndk_shared",
"latest_android_hardware_audio_core_sounddose_ndk_shared",
- "latest_android_hardware_audio_effect_ndk_static",
+ "latest_android_hardware_audio_effect_ndk_shared",
"latest_android_media_audio_common_types_ndk_shared",
],
srcs: [
@@ -287,7 +291,6 @@
"libaudioaidlcommon",
],
header_libs: [
- "libaudio_aidl_conversion_common_util_ndk",
"libaudio_system_headers",
],
cflags: [
diff --git a/media/libaudiohal/impl/StreamHalAidl.cpp b/media/libaudiohal/impl/StreamHalAidl.cpp
index 17b3c2e..7aa8231 100644
--- a/media/libaudiohal/impl/StreamHalAidl.cpp
+++ b/media/libaudiohal/impl/StreamHalAidl.cpp
@@ -701,7 +701,7 @@
}
status_t StreamInHalAidl::getActiveMicrophones(
- std::vector<media::MicrophoneInfo> *microphones __unused) {
+ std::vector<media::MicrophoneInfoFw> *microphones __unused) {
TIME_CHECK();
if (!mStream) return NO_INIT;
ALOGE("%s not implemented yet", __func__);
diff --git a/media/libaudiohal/impl/StreamHalAidl.h b/media/libaudiohal/impl/StreamHalAidl.h
index 162c7bc..f43c8e2 100644
--- a/media/libaudiohal/impl/StreamHalAidl.h
+++ b/media/libaudiohal/impl/StreamHalAidl.h
@@ -328,7 +328,7 @@
status_t getCapturePosition(int64_t *frames, int64_t *time) override;
// Get active microphones
- status_t getActiveMicrophones(std::vector<media::MicrophoneInfo> *microphones) override;
+ status_t getActiveMicrophones(std::vector<media::MicrophoneInfoFw> *microphones) override;
// Set microphone direction (for processing)
status_t setPreferredMicrophoneDirection(
diff --git a/media/libaudiohal/impl/StreamHalHidl.cpp b/media/libaudiohal/impl/StreamHalHidl.cpp
index 2c289e1..07c6df5 100644
--- a/media/libaudiohal/impl/StreamHalHidl.cpp
+++ b/media/libaudiohal/impl/StreamHalHidl.cpp
@@ -24,6 +24,9 @@
#include <mediautils/SchedulingPolicyService.h>
#include <mediautils/TimeCheck.h>
#include <utils/Log.h>
+#if MAJOR_VERSION >= 4
+#include <media/AidlConversion.h>
+#endif
#include PATH(android/hardware/audio/CORE_TYPES_FILE_VERSION/IStreamOutCallback.h)
#include <HidlUtils.h>
@@ -1169,7 +1172,7 @@
#if MAJOR_VERSION == 2
status_t StreamInHalHidl::getActiveMicrophones(
- std::vector<media::MicrophoneInfo> *microphones __unused) {
+ std::vector<media::MicrophoneInfoFw> *microphones __unused) {
if (mStream == 0) return NO_INIT;
return INVALID_OPERATION;
}
@@ -1182,7 +1185,7 @@
#elif MAJOR_VERSION >= 4
status_t StreamInHalHidl::getActiveMicrophones(
- std::vector<media::MicrophoneInfo> *microphonesInfo) {
+ std::vector<media::MicrophoneInfoFw> *microphonesInfo) {
TIME_CHECK();
if (!mStream) return NO_INIT;
Result retval;
@@ -1190,11 +1193,17 @@
[&](Result r, hidl_vec<MicrophoneInfo> micArrayHal) {
retval = r;
for (size_t k = 0; k < micArrayHal.size(); k++) {
+ // Convert via legacy.
audio_microphone_characteristic_t dst;
- // convert
(void)CoreUtils::microphoneInfoToHal(micArrayHal[k], &dst);
- media::MicrophoneInfo microphone = media::MicrophoneInfo(dst);
- microphonesInfo->push_back(microphone);
+ auto conv = legacy2aidl_audio_microphone_characteristic_t_MicrophoneInfoFw(dst);
+ if (conv.ok()) {
+ microphonesInfo->push_back(conv.value());
+ } else {
+ ALOGW("getActiveMicrophones: could not convert %s to AIDL: %d",
+ toString(micArrayHal[k]).c_str(), conv.error());
+ microphonesInfo->push_back(media::MicrophoneInfoFw{});
+ }
}
});
return processReturn("getActiveMicrophones", ret, retval);
diff --git a/media/libaudiohal/impl/StreamHalHidl.h b/media/libaudiohal/impl/StreamHalHidl.h
index 54fbefe..5361047 100644
--- a/media/libaudiohal/impl/StreamHalHidl.h
+++ b/media/libaudiohal/impl/StreamHalHidl.h
@@ -253,7 +253,7 @@
virtual status_t getCapturePosition(int64_t *frames, int64_t *time);
// Get active microphones
- virtual status_t getActiveMicrophones(std::vector<media::MicrophoneInfo> *microphones);
+ status_t getActiveMicrophones(std::vector<media::MicrophoneInfoFw> *microphones) override;
// Set microphone direction (for processing)
virtual status_t setPreferredMicrophoneDirection(
diff --git a/media/libaudiohal/impl/effectsAidlConversion/AidlConversionAgc2.cpp b/media/libaudiohal/impl/effectsAidlConversion/AidlConversionAgc2.cpp
index 80df2b8..b736936 100644
--- a/media/libaudiohal/impl/effectsAidlConversion/AidlConversionAgc2.cpp
+++ b/media/libaudiohal/impl/effectsAidlConversion/AidlConversionAgc2.cpp
@@ -34,7 +34,7 @@
namespace effect {
using ::aidl::android::aidl_utils::statusTFromBinderStatus;
-using ::aidl::android::hardware::audio::effect::AutomaticGainControl;
+using ::aidl::android::hardware::audio::effect::AutomaticGainControlV2;
using ::aidl::android::hardware::audio::effect::Parameter;
using ::android::status_t;
using utils::EffectParamReader;
@@ -84,8 +84,8 @@
switch (type) {
case AGC2_PARAM_FIXED_DIGITAL_GAIN: {
Parameter::Id id =
- MAKE_SPECIFIC_PARAMETER_ID(AutomaticGainControl, automaticGainControlTag,
- AutomaticGainControl::fixedDigitalGainMb);
+ MAKE_SPECIFIC_PARAMETER_ID(AutomaticGainControlV2, automaticGainControlV2Tag,
+ AutomaticGainControlV2::fixedDigitalGainMb);
RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->getParameter(id, &aidlParam)));
value = VALUE_OR_RETURN_STATUS(
aidl::android::aidl2legacy_Parameter_agc_uint32_fixedDigitalGain(aidlParam));
@@ -93,8 +93,8 @@
}
case AGC2_PARAM_ADAPT_DIGI_LEVEL_ESTIMATOR: {
Parameter::Id id =
- MAKE_SPECIFIC_PARAMETER_ID(AutomaticGainControl, automaticGainControlTag,
- AutomaticGainControl::levelEstimator);
+ MAKE_SPECIFIC_PARAMETER_ID(AutomaticGainControlV2, automaticGainControlV2Tag,
+ AutomaticGainControlV2::levelEstimator);
RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->getParameter(id, &aidlParam)));
value = VALUE_OR_RETURN_STATUS(
aidl::android::aidl2legacy_Parameter_agc_uint32_levelEstimator(aidlParam));
@@ -102,8 +102,8 @@
}
case AGC2_PARAM_ADAPT_DIGI_EXTRA_SATURATION_MARGIN: {
Parameter::Id id =
- MAKE_SPECIFIC_PARAMETER_ID(AutomaticGainControl, automaticGainControlTag,
- AutomaticGainControl::saturationMarginMb);
+ MAKE_SPECIFIC_PARAMETER_ID(AutomaticGainControlV2, automaticGainControlV2Tag,
+ AutomaticGainControlV2::saturationMarginMb);
RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->getParameter(id, &aidlParam)));
value = VALUE_OR_RETURN_STATUS(
aidl::android::aidl2legacy_Parameter_agc_uint32_saturationMargin(aidlParam));
diff --git a/media/libaudiohal/impl/effectsAidlConversion/AidlConversionBassBoost.cpp b/media/libaudiohal/impl/effectsAidlConversion/AidlConversionBassBoost.cpp
index 038b7df..91c3dea 100644
--- a/media/libaudiohal/impl/effectsAidlConversion/AidlConversionBassBoost.cpp
+++ b/media/libaudiohal/impl/effectsAidlConversion/AidlConversionBassBoost.cpp
@@ -24,6 +24,7 @@
#include <media/AidlConversionNdk.h>
#include <media/AidlConversionEffect.h>
#include <media/audiohal/AudioEffectUuid.h>
+#include <system/audio_effects/aidl_effects_utils.h>
#include <system/audio_effects/effect_bassboost.h>
#include <utils/Log.h>
@@ -37,6 +38,7 @@
using ::aidl::android::aidl_utils::statusTFromBinderStatus;
using ::aidl::android::hardware::audio::effect::BassBoost;
using ::aidl::android::hardware::audio::effect::Parameter;
+using ::aidl::android::hardware::audio::effect::Range;
using ::android::status_t;
using utils::EffectParamReader;
using utils::EffectParamWriter;
@@ -89,10 +91,10 @@
return param.writeToValue(&value);
}
case BASSBOOST_PARAM_STRENGTH_SUPPORTED: {
- uint16_t value;
- const auto& cap =
- VALUE_OR_RETURN_STATUS(aidl::android::UNION_GET(mDesc.capability, bassBoost));
- value = VALUE_OR_RETURN_STATUS(convertIntegral<uint32_t>(cap.strengthSupported));
+ // an invalid range indicates not setting support for this parameter
+ uint16_t value =
+ ::aidl::android::hardware::audio::effect::isRangeValid<Range::Tag::bassBoost>(
+ BassBoost::strengthPm, mDesc.capability);
return param.writeToValue(&value);
}
default: {
diff --git a/media/libaudiohal/impl/effectsAidlConversion/AidlConversionDynamicsProcessing.cpp b/media/libaudiohal/impl/effectsAidlConversion/AidlConversionDynamicsProcessing.cpp
index 4ecaa07..4555c9f 100644
--- a/media/libaudiohal/impl/effectsAidlConversion/AidlConversionDynamicsProcessing.cpp
+++ b/media/libaudiohal/impl/effectsAidlConversion/AidlConversionDynamicsProcessing.cpp
@@ -147,8 +147,6 @@
DynamicsProcessing::inputGain);
RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->getParameter(id, &aidlParam)));
- DynamicsProcessing::Capability cap =
- mDesc.capability.get<Capability::dynamicsProcessing>();
std::vector<DynamicsProcessing::InputGain> gains =
VALUE_OR_RETURN_STATUS(aidl::android::GET_PARAMETER_SPECIFIC_FIELD(
aidlParam, DynamicsProcessing, dynamicsProcessing,
diff --git a/media/libaudiohal/impl/effectsAidlConversion/AidlConversionNoiseSuppression.cpp b/media/libaudiohal/impl/effectsAidlConversion/AidlConversionNoiseSuppression.cpp
index 5faf645..69184cf 100644
--- a/media/libaudiohal/impl/effectsAidlConversion/AidlConversionNoiseSuppression.cpp
+++ b/media/libaudiohal/impl/effectsAidlConversion/AidlConversionNoiseSuppression.cpp
@@ -34,33 +34,77 @@
namespace effect {
using ::aidl::android::aidl_utils::statusTFromBinderStatus;
+using ::aidl::android::getParameterSpecificField;
using ::aidl::android::hardware::audio::effect::Parameter;
+using ::aidl::android::hardware::audio::effect::NoiseSuppression;
using ::android::status_t;
using utils::EffectParamReader;
using utils::EffectParamWriter;
status_t AidlConversionNoiseSuppression::setParameter(EffectParamReader& param) {
- uint32_t type = 0;
- uint16_t value = 0;
+ uint32_t type = 0, value = 0;
if (!param.validateParamValueSize(sizeof(uint32_t), sizeof(uint16_t)) ||
OK != param.readFromParameter(&type) || OK != param.readFromValue(&value)) {
ALOGE("%s invalid param %s", __func__, param.toString().c_str());
return BAD_VALUE;
}
Parameter aidlParam;
- // TODO
+ switch (type) {
+ case NS_PARAM_LEVEL: {
+ aidlParam = MAKE_SPECIFIC_PARAMETER(NoiseSuppression, noiseSuppression, level,
+ static_cast<NoiseSuppression::Level>(value));
+ break;
+ }
+ case NS_PARAM_TYPE: {
+ aidlParam = MAKE_SPECIFIC_PARAMETER(NoiseSuppression, noiseSuppression, type,
+ static_cast<NoiseSuppression::Type>(value));
+ break;
+ }
+ default: {
+ // TODO: implement vendor extension parameters
+ ALOGW("%s unknown param %s", __func__, param.toString().c_str());
+ return BAD_VALUE;
+ }
+ }
return statusTFromBinderStatus(mEffect->setParameter(aidlParam));
}
status_t AidlConversionNoiseSuppression::getParameter(EffectParamWriter& param) {
- uint32_t type = 0, value = 0;
+ uint32_t paramType = 0, value = 0;
if (!param.validateParamValueSize(sizeof(uint32_t), sizeof(uint32_t)) ||
- OK != param.readFromParameter(&type)) {
+ OK != param.readFromParameter(¶mType)) {
ALOGE("%s invalid param %s", __func__, param.toString().c_str());
param.setStatus(BAD_VALUE);
return BAD_VALUE;
}
- // TODO
+ Parameter aidlParam;
+ switch (paramType) {
+ case NS_PARAM_LEVEL: {
+ Parameter::Id id = MAKE_SPECIFIC_PARAMETER_ID(NoiseSuppression, noiseSuppressionTag,
+ NoiseSuppression::level);
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->getParameter(id, &aidlParam)));
+ NoiseSuppression::Level level = VALUE_OR_RETURN_STATUS(
+ GET_PARAMETER_SPECIFIC_FIELD(aidlParam, NoiseSuppression, noiseSuppression,
+ NoiseSuppression::level, NoiseSuppression::Level));
+ value = static_cast<uint32_t>(level);
+ break;
+ }
+ case NS_PARAM_TYPE: {
+ Parameter::Id id = MAKE_SPECIFIC_PARAMETER_ID(NoiseSuppression, noiseSuppressionTag,
+ NoiseSuppression::type);
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->getParameter(id, &aidlParam)));
+ NoiseSuppression::Type nsType = VALUE_OR_RETURN_STATUS(
+ GET_PARAMETER_SPECIFIC_FIELD(aidlParam, NoiseSuppression, noiseSuppression,
+ NoiseSuppression::type, NoiseSuppression::Type));
+ value = static_cast<uint32_t>(nsType);
+ break;
+ }
+ default: {
+ // TODO: implement vendor extension parameters
+ ALOGW("%s unknown param %s", __func__, param.toString().c_str());
+ return BAD_VALUE;
+ }
+ }
return param.writeToValue(&value);
}
diff --git a/media/libaudiohal/impl/effectsAidlConversion/AidlConversionVendorExtension.cpp b/media/libaudiohal/impl/effectsAidlConversion/AidlConversionVendorExtension.cpp
index a035614..3baf72e 100644
--- a/media/libaudiohal/impl/effectsAidlConversion/AidlConversionVendorExtension.cpp
+++ b/media/libaudiohal/impl/effectsAidlConversion/AidlConversionVendorExtension.cpp
@@ -17,9 +17,11 @@
#include <cstdint>
#include <cstring>
#include <optional>
+#include <type_traits>
#define LOG_TAG "AidlConversionVendorExtension"
//#define LOG_NDEBUG 0
+#include <aidl/android/hardware/audio/effect/DefaultExtension.h>
#include <error/expected_utils.h>
#include <media/AidlConversionNdk.h>
#include <media/AidlConversionEffect.h>
@@ -32,34 +34,64 @@
namespace effect {
using ::aidl::android::aidl_utils::statusTFromBinderStatus;
+using ::aidl::android::hardware::audio::effect::DefaultExtension;
using ::aidl::android::hardware::audio::effect::Parameter;
+using ::aidl::android::hardware::audio::effect::VendorExtension;
using ::android::status_t;
using utils::EffectParamReader;
using utils::EffectParamWriter;
+/**
+ * For all effect types we currently don't support, add a default extension implementation to use
+ * std::vector<uint8_t> to pass through all data in the format of effect_param_t (the data we got
+ * from libaudioclient for now).
+ * This logic will be removed after we adopt to same AIDL parameter union AIDL in libaudioclient,
+ * after that framework doesn't need to do any AIDL conversion, and the vendor extension can be
+ * pass down in Parameter as is.
+ */
status_t AidlConversionVendorExtension::setParameter(EffectParamReader& param) {
- uint32_t type = 0;
- uint16_t value = 0;
- if (!param.validateParamValueSize(sizeof(uint32_t), sizeof(uint16_t)) ||
- OK != param.readFromParameter(&type) || OK != param.readFromValue(&value)) {
- ALOGE("%s invalid param %s", __func__, param.toString().c_str());
+ size_t len = param.getValueSize();
+ DefaultExtension ext;
+ ext.bytes.resize(len);
+ if (OK != param.readFromValue(ext.bytes.data(), len)) {
+ ALOGE("%s read value from param %s failed", __func__, param.toString().c_str());
return BAD_VALUE;
}
- Parameter aidlParam;
- // TODO
+ VendorExtension effectParam;
+ effectParam.extension.setParcelable(ext);
+ Parameter aidlParam = UNION_MAKE(Parameter, specific,
+ UNION_MAKE(Parameter::Specific, vendorEffect, effectParam));
return statusTFromBinderStatus(mEffect->setParameter(aidlParam));
}
status_t AidlConversionVendorExtension::getParameter(EffectParamWriter& param) {
- uint32_t type = 0, value = 0;
- if (!param.validateParamValueSize(sizeof(uint32_t), sizeof(uint32_t)) ||
- OK != param.readFromParameter(&type)) {
+ int32_t tag;
+ if (OK != param.readFromParameter(&tag)) {
ALOGE("%s invalid param %s", __func__, param.toString().c_str());
param.setStatus(BAD_VALUE);
return BAD_VALUE;
}
- // TODO
- return param.writeToValue(&value);
+
+ Parameter aidlParam;
+ Parameter::Id id = UNION_MAKE(Parameter::Id, vendorEffectTag, tag /* parameter tag */);
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->getParameter(id, &aidlParam)));
+ VendorExtension effectParam = VALUE_OR_RETURN_STATUS(
+ (::aidl::android::getParameterSpecific<Parameter, VendorExtension,
+ Parameter::Specific::vendorEffect>(aidlParam)));
+ std::optional<DefaultExtension> ext;
+ if (STATUS_OK != effectParam.extension.getParcelable(&ext) || !ext.has_value()) {
+ ALOGE("%s get extension parcelable failed", __func__);
+ param.setStatus(BAD_VALUE);
+ return BAD_VALUE;
+ }
+ const auto& extBytes = ext.value().bytes;
+ if (param.getValueSize() < extBytes.size()) {
+ ALOGE("%s extension return data %zu exceed vsize %zu", __func__, extBytes.size(),
+ param.getValueSize());
+ param.setStatus(BAD_VALUE);
+ return BAD_VALUE;
+ }
+ return param.writeToValue(extBytes.data(), extBytes.size());
}
} // namespace effect
diff --git a/media/libaudiohal/include/media/audiohal/StreamHalInterface.h b/media/libaudiohal/include/media/audiohal/StreamHalInterface.h
index a651d9b..a780a17 100644
--- a/media/libaudiohal/include/media/audiohal/StreamHalInterface.h
+++ b/media/libaudiohal/include/media/audiohal/StreamHalInterface.h
@@ -19,8 +19,8 @@
#include <vector>
+#include <android/media/MicrophoneInfoFw.h>
#include <media/audiohal/EffectHalInterface.h>
-#include <media/MicrophoneInfo.h>
#include <system/audio.h>
#include <utils/Errors.h>
#include <utils/RefBase.h>
@@ -273,7 +273,7 @@
virtual status_t getCapturePosition(int64_t *frames, int64_t *time) = 0;
// Get active microphones
- virtual status_t getActiveMicrophones(std::vector<media::MicrophoneInfo> *microphones) = 0;
+ virtual status_t getActiveMicrophones(std::vector<media::MicrophoneInfoFw> *microphones) = 0;
// Set direction for capture processing
virtual status_t setPreferredMicrophoneDirection(audio_microphone_direction_t) = 0;
diff --git a/media/libaudiohal/tests/EffectsFactoryHalInterface_test.cpp b/media/libaudiohal/tests/EffectsFactoryHalInterface_test.cpp
index dda608b..71c7586 100644
--- a/media/libaudiohal/tests/EffectsFactoryHalInterface_test.cpp
+++ b/media/libaudiohal/tests/EffectsFactoryHalInterface_test.cpp
@@ -33,6 +33,7 @@
#include <system/audio_effects/effect_dynamicsprocessing.h>
#include <system/audio_effects/effect_hapticgenerator.h>
#include <system/audio_effects/effect_loudnessenhancer.h>
+#include <system/audio_effects/effect_ns.h>
#include <system/audio_effect.h>
#include <gtest/gtest.h>
@@ -149,6 +150,9 @@
using EffectParamTestTuple =
std::tuple<const effect_uuid_t* /* type UUID */, std::shared_ptr<EffectParamCombination>>;
+static const effect_uuid_t EXTEND_EFFECT_TYPE_UUID = {
+ 0xfa81dbde, 0x588b, 0x11ed, 0x9b6a, {0x02, 0x42, 0xac, 0x12, 0x00, 0x02}};
+
std::vector<EffectParamTestTuple> testPairs = {
std::make_tuple(FX_IID_AEC,
createEffectParamCombination(AEC_PARAM_ECHO_DELAY, 0xff /* echoDelayMs */,
@@ -176,7 +180,12 @@
std::make_tuple(
FX_IID_LOUDNESS_ENHANCER,
createEffectParamCombination(LOUDNESS_ENHANCER_PARAM_TARGET_GAIN_MB, 5 /* gain */,
- sizeof(int32_t) /* returnValueSize */))};
+ sizeof(int32_t) /* returnValueSize */)),
+ std::make_tuple(FX_IID_NS,
+ createEffectParamCombination(NS_PARAM_LEVEL, 1 /* level */,
+ sizeof(int32_t) /* returnValueSize */)),
+ std::make_tuple(&EXTEND_EFFECT_TYPE_UUID,
+ createEffectParamCombination(1, 0xbead, sizeof(int32_t)))};
class libAudioHalEffectParamTest : public ::testing::TestWithParam<EffectParamTestTuple> {
public:
@@ -200,6 +209,7 @@
}()) {}
void SetUp() override {
+ ASSERT_NE(0ul, mDescs.size());
for (const auto& desc : mDescs) {
sp<EffectHalInterface> interface = createEffectHal(desc);
ASSERT_NE(nullptr, interface);
diff --git a/media/libeffects/dynamicsproc/aidl/DynamicsProcessing.cpp b/media/libeffects/dynamicsproc/aidl/DynamicsProcessing.cpp
index 203a27b..4af5fd8 100644
--- a/media/libeffects/dynamicsproc/aidl/DynamicsProcessing.cpp
+++ b/media/libeffects/dynamicsproc/aidl/DynamicsProcessing.cpp
@@ -59,8 +59,34 @@
namespace aidl::android::hardware::audio::effect {
const std::string DynamicsProcessingImpl::kEffectName = "DynamicsProcessing";
-const DynamicsProcessing::Capability DynamicsProcessingImpl::kCapability = {.minCutOffFreq = 220,
- .maxCutOffFreq = 20000};
+
+const DynamicsProcessing::EqBandConfig DynamicsProcessingImpl::kEqBandConfigMin =
+ DynamicsProcessing::EqBandConfig({.channel = 0,
+ .band = 0,
+ .enable = false,
+ .cutoffFrequencyHz = 220,
+ .gainDb = std::numeric_limits<float>::min()});
+const DynamicsProcessing::EqBandConfig DynamicsProcessingImpl::kEqBandConfigMax =
+ DynamicsProcessing::EqBandConfig({.channel = std::numeric_limits<int>::max(),
+ .band = std::numeric_limits<int>::max(),
+ .enable = true,
+ .cutoffFrequencyHz = 20000,
+ .gainDb = std::numeric_limits<float>::max()});
+const Range::DynamicsProcessingRange DynamicsProcessingImpl::kPreEqBandRange = {
+ .min = DynamicsProcessing::make<DynamicsProcessing::preEqBand>(
+ {DynamicsProcessingImpl::kEqBandConfigMin}),
+ .max = DynamicsProcessing::make<DynamicsProcessing::preEqBand>(
+ {DynamicsProcessingImpl::kEqBandConfigMax})};
+const Range::DynamicsProcessingRange DynamicsProcessingImpl::kPostEqBandRange = {
+ .min = DynamicsProcessing::make<DynamicsProcessing::postEqBand>(
+ {DynamicsProcessingImpl::kEqBandConfigMin}),
+ .max = DynamicsProcessing::make<DynamicsProcessing::postEqBand>(
+ {DynamicsProcessingImpl::kEqBandConfigMax})};
+const Range DynamicsProcessingImpl::kRange =
+ Range::make<Range::dynamicsProcessing>({DynamicsProcessingImpl::kPreEqBandRange});
+
+const Capability DynamicsProcessingImpl::kCapability = {.range = {DynamicsProcessingImpl::kRange}};
+
const Descriptor DynamicsProcessingImpl::kDescriptor = {
.common = {.id = {.type = kDynamicsProcessingTypeUUID,
.uuid = kDynamicsProcessingImplUUID,
@@ -70,8 +96,7 @@
.volume = Flags::Volume::CTRL},
.name = DynamicsProcessingImpl::kEffectName,
.implementor = "The Android Open Source Project"},
- .capability = Capability::make<Capability::dynamicsProcessing>(
- DynamicsProcessingImpl::kCapability)};
+ .capability = DynamicsProcessingImpl::kCapability};
ndk::ScopedAStatus DynamicsProcessingImpl::open(const Parameter::Common& common,
const std::optional<Parameter::Specific>& specific,
@@ -138,6 +163,7 @@
RETURN_IF(!mContext, EX_NULL_POINTER, "nullContext");
auto& param = specific.get<Parameter::Specific::dynamicsProcessing>();
+ // TODO: check range here, dynamicsProcessing need customized method for nested parameters.
auto tag = param.getTag();
switch (tag) {
diff --git a/media/libeffects/dynamicsproc/aidl/DynamicsProcessing.h b/media/libeffects/dynamicsproc/aidl/DynamicsProcessing.h
index 824ebea..26b6ead 100644
--- a/media/libeffects/dynamicsproc/aidl/DynamicsProcessing.h
+++ b/media/libeffects/dynamicsproc/aidl/DynamicsProcessing.h
@@ -28,7 +28,7 @@
public:
static const std::string kEffectName;
static const Descriptor kDescriptor;
- static const DynamicsProcessing::Capability kCapability;
+ static const Capability kCapability;
DynamicsProcessingImpl() { LOG(DEBUG) << __func__; }
~DynamicsProcessingImpl() {
@@ -52,6 +52,11 @@
std::string getEffectName() override { return kEffectName; }
private:
+ static const DynamicsProcessing::EqBandConfig kEqBandConfigMin;
+ static const DynamicsProcessing::EqBandConfig kEqBandConfigMax;
+ static const Range::DynamicsProcessingRange kPreEqBandRange;
+ static const Range::DynamicsProcessingRange kPostEqBandRange;
+ static const Range kRange;
std::shared_ptr<DynamicsProcessingContext> mContext;
ndk::ScopedAStatus getParameterDynamicsProcessing(const DynamicsProcessing::Tag& tag,
Parameter::Specific* specific);
diff --git a/media/libeffects/dynamicsproc/aidl/DynamicsProcessingContext.cpp b/media/libeffects/dynamicsproc/aidl/DynamicsProcessingContext.cpp
index 57a2be9..7978cc5 100644
--- a/media/libeffects/dynamicsproc/aidl/DynamicsProcessingContext.cpp
+++ b/media/libeffects/dynamicsproc/aidl/DynamicsProcessingContext.cpp
@@ -420,24 +420,18 @@
validateStageEnablement(engine.postEqStage) && validateStageEnablement(engine.mbcStage);
}
-inline bool DynamicsProcessingContext::validateCutoffFrequency(float freq) {
- return freq >= DynamicsProcessingImpl::kCapability.minCutOffFreq &&
- freq <= DynamicsProcessingImpl::kCapability.maxCutOffFreq;
-}
-
bool DynamicsProcessingContext::validateEqBandConfig(const DynamicsProcessing::EqBandConfig& band,
int maxChannel, int maxBand) {
- return validateChannel(band.channel, maxChannel) && validateBand(band.band, maxBand) &&
- validateCutoffFrequency(band.cutoffFrequencyHz);
+ return validateChannel(band.channel, maxChannel) && validateBand(band.band, maxBand);
}
bool DynamicsProcessingContext::validateMbcBandConfig(const DynamicsProcessing::MbcBandConfig& band,
int maxChannel, int maxBand) {
return validateChannel(band.channel, maxChannel) && validateBand(band.band, maxBand) &&
- validateCutoffFrequency(band.cutoffFrequencyHz) && validateTime(band.attackTimeMs) &&
- validateTime(band.releaseTimeMs) && validateRatio(band.ratio) &&
- validateBandDb(band.thresholdDb) && validateBandDb(band.kneeWidthDb) &&
- validateBandDb(band.noiseGateThresholdDb) && validateRatio(band.expanderRatio);
+ validateTime(band.attackTimeMs) && validateTime(band.releaseTimeMs) &&
+ validateRatio(band.ratio) && validateBandDb(band.thresholdDb) &&
+ validateBandDb(band.kneeWidthDb) && validateBandDb(band.noiseGateThresholdDb) &&
+ validateRatio(band.expanderRatio);
}
bool DynamicsProcessingContext::validateLimiterConfig(
diff --git a/media/libeffects/lvm/wrapper/Aidl/BundleContext.cpp b/media/libeffects/lvm/wrapper/Aidl/BundleContext.cpp
index e303efd..6124356 100644
--- a/media/libeffects/lvm/wrapper/Aidl/BundleContext.cpp
+++ b/media/libeffects/lvm/wrapper/Aidl/BundleContext.cpp
@@ -531,11 +531,6 @@
}
RetCode BundleContext::setBassBoostStrength(int strength) {
- if (strength < 0 || strength > lvm::kBassBoostCap.maxStrengthPm) {
- LOG(ERROR) << __func__ << " invalid strength: " << strength;
- return RetCode::ERROR_ILLEGAL_PARAMETER;
- }
-
// Update Control Parameter
LVM_ControlParams_t params;
{
@@ -555,10 +550,6 @@
}
RetCode BundleContext::setVolumeLevel(int level) {
- if (level < lvm::kVolumeCap.minLevelDb || level > lvm::kVolumeCap.maxLevelDb) {
- return RetCode::ERROR_ILLEGAL_PARAMETER;
- }
-
if (mMuteEnabled) {
mLevelSaved = level / 100;
} else {
@@ -584,10 +575,6 @@
}
RetCode BundleContext::setVirtualizerStrength(int strength) {
- if (strength < 0 || strength > lvm::kVirtualizerCap.maxStrengthPm) {
- return RetCode::ERROR_ILLEGAL_PARAMETER;
- }
-
// Update Control Parameter
LVM_ControlParams_t params;
{
diff --git a/media/libeffects/lvm/wrapper/Aidl/BundleTypes.h b/media/libeffects/lvm/wrapper/Aidl/BundleTypes.h
index 1996240..4652d8d 100644
--- a/media/libeffects/lvm/wrapper/Aidl/BundleTypes.h
+++ b/media/libeffects/lvm/wrapper/Aidl/BundleTypes.h
@@ -67,46 +67,53 @@
{0, "Normal"}, {1, "Classical"}, {2, "Dance"}, {3, "Flat"}, {4, "Folk"},
{5, "Heavy Metal"}, {6, "Hip Hop"}, {7, "Jazz"}, {8, "Pop"}, {9, "Rock"}};
-static const Equalizer::Capability kEqCap = {.bandFrequencies = kEqBandFrequency,
- .presets = kEqPresets};
+const std::vector<Range::EqualizerRange> kEqRanges = {
+ MAKE_RANGE(Equalizer, preset, 0, MAX_NUM_PRESETS - 1),
+ MAKE_RANGE(
+ Equalizer, bandLevels,
+ std::vector<Equalizer::BandLevel>{Equalizer::BandLevel(
+ {.index = 0, .levelMb = std::numeric_limits<int>::min()})},
+ std::vector<Equalizer::BandLevel>{Equalizer::BandLevel(
+ {.index = MAX_NUM_BANDS - 1, .levelMb = std::numeric_limits<int>::max()})}),
+ /* capability definition */
+ MAKE_RANGE(Equalizer, bandFrequencies, kEqBandFrequency, kEqBandFrequency),
+ MAKE_RANGE(Equalizer, presets, kEqPresets, kEqPresets),
+ /* get only parameters with range min > max */
+ MAKE_RANGE(Equalizer, centerFreqMh, std::vector<int>({1}), std::vector<int>({}))};
+static const Capability kEqCap = {.range = kEqRanges};
static const std::string kEqualizerEffectName = "EqualizerBundle";
+static const Descriptor kEqualizerDesc = {.common = {.id = {.type = kEqualizerTypeUUID,
+ .uuid = kEqualizerBundleImplUUID,
+ .proxy = kEqualizerProxyUUID},
+ .flags = {.type = Flags::Type::INSERT,
+ .insert = Flags::Insert::FIRST,
+ .volume = Flags::Volume::CTRL},
+ .name = kEqualizerEffectName,
+ .implementor = "NXP Software Ltd."},
+ .capability = kEqCap};
-static const Descriptor kEqualizerDesc = {
- .common = {.id = {.type = kEqualizerTypeUUID,
- .uuid = kEqualizerBundleImplUUID,
- .proxy = kEqualizerProxyUUID},
- .flags = {.type = Flags::Type::INSERT,
- .insert = Flags::Insert::FIRST,
- .volume = Flags::Volume::CTRL},
- .name = kEqualizerEffectName,
- .implementor = "NXP Software Ltd."},
- .capability = Capability::make<Capability::equalizer>(kEqCap)};
-
-static const bool mStrengthSupported = true;
-
-static const BassBoost::Capability kBassBoostCap = {.maxStrengthPm = 1000,
- .strengthSupported = mStrengthSupported};
-
+static const int mMaxStrengthSupported = 1000;
+static const std::vector<Range::BassBoostRange> kBassBoostRanges = {
+ MAKE_RANGE(BassBoost, strengthPm, 0, mMaxStrengthSupported)};
+static const Capability kBassBoostCap = {.range = kBassBoostRanges};
static const std::string kBassBoostEffectName = "Dynamic Bass Boost";
+static const Descriptor kBassBoostDesc = {.common = {.id = {.type = kBassBoostTypeUUID,
+ .uuid = kBassBoostBundleImplUUID,
+ .proxy = kBassBoostProxyUUID},
+ .flags = {.type = Flags::Type::INSERT,
+ .insert = Flags::Insert::FIRST,
+ .volume = Flags::Volume::CTRL,
+ .deviceIndication = true},
+ .cpuLoad = BASS_BOOST_CUP_LOAD_ARM9E,
+ .memoryUsage = BUNDLE_MEM_USAGE,
+ .name = kBassBoostEffectName,
+ .implementor = "NXP Software Ltd."},
+ .capability = kBassBoostCap};
-static const Descriptor kBassBoostDesc = {
- .common = {.id = {.type = kBassBoostTypeUUID,
- .uuid = kBassBoostBundleImplUUID,
- .proxy = kBassBoostProxyUUID},
- .flags = {.type = Flags::Type::INSERT,
- .insert = Flags::Insert::FIRST,
- .volume = Flags::Volume::CTRL,
- .deviceIndication = true},
- .cpuLoad = BASS_BOOST_CUP_LOAD_ARM9E,
- .memoryUsage = BUNDLE_MEM_USAGE,
- .name = kBassBoostEffectName,
- .implementor = "NXP Software Ltd."},
- .capability = Capability::make<Capability::bassBoost>(kBassBoostCap)};
-
-static const Virtualizer::Capability kVirtualizerCap = {.maxStrengthPm = 1000,
- .strengthSupported = mStrengthSupported};
-
+static const std::vector<Range::VirtualizerRange> kVirtualizerRanges = {
+ MAKE_RANGE(Virtualizer, strengthPm, 0, mMaxStrengthSupported)};
+static const Capability kVirtualizerCap = {.range = kVirtualizerRanges};
static const std::string kVirtualizerEffectName = "Virtualizer";
static const Descriptor kVirtualizerDesc = {
@@ -121,24 +128,23 @@
.memoryUsage = BUNDLE_MEM_USAGE,
.name = kVirtualizerEffectName,
.implementor = "NXP Software Ltd."},
- .capability = Capability::make<Capability::virtualizer>(kVirtualizerCap)};
+ .capability = kVirtualizerCap};
-static const Volume::Capability kVolumeCap = {.minLevelDb = -9600, .maxLevelDb = 0};
-
+static const std::vector<Range::VolumeRange> kVolumeRanges = {
+ MAKE_RANGE(Volume, levelDb, -9600, 0)};
+static const Capability kVolumeCap = {.range = kVolumeRanges};
static const std::string kVolumeEffectName = "Volume";
-
-static const Descriptor kVolumeDesc = {
- .common = {.id = {.type = kVolumeTypeUUID,
- .uuid = kVolumeBundleImplUUID,
- .proxy = std::nullopt},
- .flags = {.type = Flags::Type::INSERT,
- .insert = Flags::Insert::LAST,
- .volume = Flags::Volume::CTRL},
- .cpuLoad = VOLUME_CUP_LOAD_ARM9E,
- .memoryUsage = BUNDLE_MEM_USAGE,
- .name = kVolumeEffectName,
- .implementor = "NXP Software Ltd."},
- .capability = Capability::make<Capability::volume>(kVolumeCap)};
+static const Descriptor kVolumeDesc = {.common = {.id = {.type = kVolumeTypeUUID,
+ .uuid = kVolumeBundleImplUUID,
+ .proxy = std::nullopt},
+ .flags = {.type = Flags::Type::INSERT,
+ .insert = Flags::Insert::LAST,
+ .volume = Flags::Volume::CTRL},
+ .cpuLoad = VOLUME_CUP_LOAD_ARM9E,
+ .memoryUsage = BUNDLE_MEM_USAGE,
+ .name = kVolumeEffectName,
+ .implementor = "NXP Software Ltd."},
+ .capability = kVolumeCap};
/* The following tables have been computed using the actual levels measured by the output of
* white noise or pink noise (IEC268-1) for the EQ and BassBoost Effects. These are estimates of
diff --git a/media/libeffects/lvm/wrapper/Aidl/EffectBundleAidl.cpp b/media/libeffects/lvm/wrapper/Aidl/EffectBundleAidl.cpp
index fd9f3dc..dc52c16 100644
--- a/media/libeffects/lvm/wrapper/Aidl/EffectBundleAidl.cpp
+++ b/media/libeffects/lvm/wrapper/Aidl/EffectBundleAidl.cpp
@@ -14,6 +14,7 @@
* limitations under the License.
*/
+#include "BundleTypes.h"
#define LOG_TAG "EffectBundleAidl"
#include <Utils.h>
#include <algorithm>
@@ -173,6 +174,7 @@
ndk::ScopedAStatus EffectBundleAidl::setParameterEqualizer(const Parameter::Specific& specific) {
auto& eq = specific.get<Parameter::Specific::equalizer>();
+ RETURN_IF(!inRange(eq, lvm::kEqRanges), EX_ILLEGAL_ARGUMENT, "outOfRange");
auto eqTag = eq.getTag();
switch (eqTag) {
case Equalizer::preset:
@@ -193,6 +195,7 @@
ndk::ScopedAStatus EffectBundleAidl::setParameterBassBoost(const Parameter::Specific& specific) {
auto& bb = specific.get<Parameter::Specific::bassBoost>();
+ RETURN_IF(!inRange(bb, lvm::kBassBoostRanges), EX_ILLEGAL_ARGUMENT, "outOfRange");
auto bbTag = bb.getTag();
switch (bbTag) {
case BassBoost::strengthPm: {
@@ -210,6 +213,7 @@
ndk::ScopedAStatus EffectBundleAidl::setParameterVirtualizer(const Parameter::Specific& specific) {
auto& vr = specific.get<Parameter::Specific::virtualizer>();
+ RETURN_IF(!inRange(vr, lvm::kVirtualizerRanges), EX_ILLEGAL_ARGUMENT, "outOfRange");
auto vrTag = vr.getTag();
switch (vrTag) {
case Virtualizer::strengthPm: {
@@ -235,6 +239,7 @@
ndk::ScopedAStatus EffectBundleAidl::setParameterVolume(const Parameter::Specific& specific) {
auto& vol = specific.get<Parameter::Specific::volume>();
+ RETURN_IF(!inRange(vol, lvm::kVolumeRanges), EX_ILLEGAL_ARGUMENT, "outOfRange");
auto volTag = vol.getTag();
switch (volTag) {
case Volume::levelDb: {
diff --git a/media/libeffects/lvm/wrapper/Reverb/aidl/EffectReverb.cpp b/media/libeffects/lvm/wrapper/Reverb/aidl/EffectReverb.cpp
index 51825ca..018f3bc 100644
--- a/media/libeffects/lvm/wrapper/Reverb/aidl/EffectReverb.cpp
+++ b/media/libeffects/lvm/wrapper/Reverb/aidl/EffectReverb.cpp
@@ -14,6 +14,7 @@
* limitations under the License.
*/
+#include "ReverbTypes.h"
#define LOG_TAG "EffectReverb"
#include <Utils.h>
#include <algorithm>
@@ -132,6 +133,7 @@
ndk::ScopedAStatus EffectReverb::setParameterPresetReverb(const Parameter::Specific& specific) {
auto& prParam = specific.get<Parameter::Specific::presetReverb>();
+ RETURN_IF(!inRange(prParam, lvm::kPresetReverbRanges), EX_ILLEGAL_ARGUMENT, "outOfRange");
auto tag = prParam.getTag();
switch (tag) {
@@ -152,6 +154,7 @@
ndk::ScopedAStatus EffectReverb::setParameterEnvironmentalReverb(
const Parameter::Specific& specific) {
auto& erParam = specific.get<Parameter::Specific::environmentalReverb>();
+ RETURN_IF(!inRange(erParam, lvm::kEnvReverbRanges), EX_ILLEGAL_ARGUMENT, "outOfRange");
auto tag = erParam.getTag();
switch (tag) {
diff --git a/media/libeffects/lvm/wrapper/Reverb/aidl/ReverbContext.cpp b/media/libeffects/lvm/wrapper/Reverb/aidl/ReverbContext.cpp
index d35c22b..87aa12b 100644
--- a/media/libeffects/lvm/wrapper/Reverb/aidl/ReverbContext.cpp
+++ b/media/libeffects/lvm/wrapper/Reverb/aidl/ReverbContext.cpp
@@ -139,12 +139,6 @@
}
RetCode ReverbContext::setEnvironmentalReverbRoomLevel(int roomLevel) {
- if (roomLevel < lvm::kEnvReverbCap.minRoomLevelMb ||
- roomLevel > lvm::kEnvReverbCap.maxRoomLevelMb) {
- LOG(ERROR) << __func__ << " invalid roomLevel: " << roomLevel;
- return RetCode::ERROR_ILLEGAL_PARAMETER;
- }
-
// Update Control Parameter
LVREV_ControlParams_st params;
{
@@ -165,12 +159,6 @@
}
RetCode ReverbContext::setEnvironmentalReverbRoomHfLevel(int roomHfLevel) {
- if (roomHfLevel < lvm::kEnvReverbCap.minRoomHfLevelMb ||
- roomHfLevel > lvm::kEnvReverbCap.maxRoomHfLevelMb) {
- LOG(ERROR) << __func__ << " invalid roomHfLevel: " << roomHfLevel;
- return RetCode::ERROR_ILLEGAL_PARAMETER;
- }
-
// Update Control Parameter
LVREV_ControlParams_st params;
{
@@ -188,10 +176,6 @@
}
RetCode ReverbContext::setEnvironmentalReverbDecayTime(int decayTime) {
- if (decayTime < 0 || decayTime > lvm::kEnvReverbCap.maxDecayTimeMs) {
- LOG(ERROR) << __func__ << " invalid decayTime: " << decayTime;
- return RetCode::ERROR_ILLEGAL_PARAMETER;
- }
int time = decayTime;
if (time > lvm::kMaxT60) {
time = lvm::kMaxT60;
@@ -215,12 +199,6 @@
}
RetCode ReverbContext::setEnvironmentalReverbDecayHfRatio(int decayHfRatio) {
- if (decayHfRatio < lvm::kEnvReverbCap.minDecayHfRatioPm ||
- decayHfRatio > lvm::kEnvReverbCap.maxDecayHfRatioPm) {
- LOG(ERROR) << __func__ << " invalid decayHfRatio: " << decayHfRatio;
- return RetCode::ERROR_ILLEGAL_PARAMETER;
- }
-
// Update Control Parameter
LVREV_ControlParams_st params;
{
@@ -238,11 +216,6 @@
}
RetCode ReverbContext::setEnvironmentalReverbLevel(int level) {
- if (level < lvm::kEnvReverbCap.minLevelMb || level > lvm::kEnvReverbCap.maxLevelMb) {
- LOG(ERROR) << __func__ << " invalid level: " << level;
- return RetCode::ERROR_ILLEGAL_PARAMETER;
- }
-
// Update Control Parameter
LVREV_ControlParams_st params;
{
@@ -263,20 +236,11 @@
}
RetCode ReverbContext::setEnvironmentalReverbDelay(int delay) {
- if (delay < 0 || delay > lvm::kEnvReverbCap.maxDelayMs) {
- LOG(ERROR) << __func__ << " invalid delay: " << delay;
- return RetCode::ERROR_ILLEGAL_PARAMETER;
- }
mDelay = delay;
return RetCode::SUCCESS;
}
RetCode ReverbContext::setEnvironmentalReverbDiffusion(int diffusion) {
- if (diffusion < 0 || diffusion > lvm::kEnvReverbCap.maxDiffusionPm) {
- LOG(ERROR) << __func__ << " invalid diffusion: " << diffusion;
- return RetCode::ERROR_ILLEGAL_PARAMETER;
- }
-
// Update Control Parameter
LVREV_ControlParams_st params;
{
@@ -294,11 +258,6 @@
}
RetCode ReverbContext::setEnvironmentalReverbDensity(int density) {
- if (density < 0 || density > lvm::kEnvReverbCap.maxDensityPm) {
- LOG(ERROR) << __func__ << " invalid density: " << density;
- return RetCode::ERROR_ILLEGAL_PARAMETER;
- }
-
// Update Control Parameter
LVREV_ControlParams_st params;
{
diff --git a/media/libeffects/lvm/wrapper/Reverb/aidl/ReverbTypes.h b/media/libeffects/lvm/wrapper/Reverb/aidl/ReverbTypes.h
index e37602c..8dcda87 100644
--- a/media/libeffects/lvm/wrapper/Reverb/aidl/ReverbTypes.h
+++ b/media/libeffects/lvm/wrapper/Reverb/aidl/ReverbTypes.h
@@ -21,6 +21,7 @@
#include <audio_effects/effect_environmentalreverb.h>
#include <audio_effects/effect_presetreverb.h>
#include "effect-impl/EffectUUID.h"
+#include "effect-impl/EffectTypes.h"
// from Reverb/lib
#include "LVREV.h"
@@ -35,51 +36,51 @@
constexpr inline int kCpuLoadARM9E = 470; // Expressed in 0.1 MIPS
constexpr inline int kMemUsage = (71 + (kMaxFrameSize >> 7)); // Expressed in kB
-static const EnvironmentalReverb::Capability kEnvReverbCap = {.minRoomLevelMb = lvm::kMinLevel,
- .maxRoomLevelMb = 0,
- .minRoomHfLevelMb = -4000,
- .maxRoomHfLevelMb = 0,
- .maxDecayTimeMs = lvm::kMaxT60,
- .minDecayHfRatioPm = 100,
- .maxDecayHfRatioPm = 2000,
- .minLevelMb = lvm::kMinLevel,
- .maxLevelMb = 0,
- .maxDelayMs = 65,
- .maxDiffusionPm = 1000,
- .maxDensityPm = 1000};
+static const std::vector<Range::EnvironmentalReverbRange> kEnvReverbRanges = {
+ MAKE_RANGE(EnvironmentalReverb, roomLevelMb, lvm::kMinLevel, 0),
+ MAKE_RANGE(EnvironmentalReverb, roomHfLevelMb, -4000, 0),
+ MAKE_RANGE(EnvironmentalReverb, decayTimeMs, 0, lvm::kMaxT60),
+ MAKE_RANGE(EnvironmentalReverb, decayHfRatioPm, 100, 2000),
+ MAKE_RANGE(EnvironmentalReverb, levelMb, lvm::kMinLevel, 0),
+ MAKE_RANGE(EnvironmentalReverb, delayMs, 0, 65),
+ MAKE_RANGE(EnvironmentalReverb, diffusionPm, 0, 1000),
+ MAKE_RANGE(EnvironmentalReverb, densityPm, 0, 1000)};
+static const Capability kEnvReverbCap = {
+ .range = Range::make<Range::environmentalReverb>(kEnvReverbRanges)};
// NXP SW auxiliary environmental reverb
static const std::string kAuxEnvReverbEffectName = "Auxiliary Environmental Reverb";
-static const Descriptor kAuxEnvReverbDesc = {
- .common = {.id = {.type = kEnvReverbTypeUUID,
- .uuid = kAuxEnvReverbImplUUID,
- .proxy = std::nullopt},
- .flags = {.type = Flags::Type::AUXILIARY},
- .cpuLoad = kCpuLoadARM9E,
- .memoryUsage = kMemUsage,
- .name = kAuxEnvReverbEffectName,
- .implementor = "NXP Software Ltd."},
- .capability = Capability::make<Capability::environmentalReverb>(kEnvReverbCap)};
+static const Descriptor kAuxEnvReverbDesc = {.common = {.id = {.type = kEnvReverbTypeUUID,
+ .uuid = kAuxEnvReverbImplUUID,
+ .proxy = std::nullopt},
+ .flags = {.type = Flags::Type::AUXILIARY},
+ .cpuLoad = kCpuLoadARM9E,
+ .memoryUsage = kMemUsage,
+ .name = kAuxEnvReverbEffectName,
+ .implementor = "NXP Software Ltd."},
+ .capability = kEnvReverbCap};
// NXP SW insert environmental reverb
static const std::string kInsertEnvReverbEffectName = "Insert Environmental Reverb";
-static const Descriptor kInsertEnvReverbDesc = {
- .common = {.id = {.type = kEnvReverbTypeUUID,
- .uuid = kInsertEnvReverbImplUUID,
- .proxy = std::nullopt},
- .flags = {.type = Flags::Type::INSERT,
- .insert = Flags::Insert::FIRST,
- .volume = Flags::Volume::CTRL},
- .cpuLoad = kCpuLoadARM9E,
- .memoryUsage = kMemUsage,
- .name = kInsertEnvReverbEffectName,
- .implementor = "NXP Software Ltd."},
- .capability = Capability::make<Capability::environmentalReverb>(kEnvReverbCap)};
+static const Descriptor kInsertEnvReverbDesc = {.common = {.id = {.type = kEnvReverbTypeUUID,
+ .uuid = kInsertEnvReverbImplUUID,
+ .proxy = std::nullopt},
+ .flags = {.type = Flags::Type::INSERT,
+ .insert = Flags::Insert::FIRST,
+ .volume = Flags::Volume::CTRL},
+ .cpuLoad = kCpuLoadARM9E,
+ .memoryUsage = kMemUsage,
+ .name = kInsertEnvReverbEffectName,
+ .implementor = "NXP Software Ltd."},
+ .capability = kEnvReverbCap};
static const std::vector<PresetReverb::Presets> kSupportedPresets{
ndk::enum_range<PresetReverb::Presets>().begin(),
ndk::enum_range<PresetReverb::Presets>().end()};
-static const PresetReverb::Capability kPresetReverbCap = {.supportedPresets = kSupportedPresets};
+static const std::vector<Range::PresetReverbRange> kPresetReverbRanges = {
+ MAKE_RANGE(PresetReverb, supportedPresets, kSupportedPresets, kSupportedPresets)};
+static const Capability kPresetReverbCap = {
+ .range = Range::make<Range::presetReverb>(kPresetReverbRanges)};
// NXP SW auxiliary preset reverb
static const std::string kAuxPresetReverbEffectName = "Auxiliary Preset Reverb";
@@ -92,7 +93,7 @@
.memoryUsage = kMemUsage,
.name = kAuxPresetReverbEffectName,
.implementor = "NXP Software Ltd."},
- .capability = Capability::make<Capability::presetReverb>(kPresetReverbCap)};
+ .capability = kPresetReverbCap};
// NXP SW insert preset reverb
static const std::string kInsertPresetReverbEffectName = "Insert Preset Reverb";
@@ -107,7 +108,7 @@
.memoryUsage = kMemUsage,
.name = kInsertPresetReverbEffectName,
.implementor = "NXP Software Ltd."},
- .capability = Capability::make<Capability::presetReverb>(kPresetReverbCap)};
+ .capability = kPresetReverbCap};
enum class ReverbEffectType {
AUX_ENV,
diff --git a/media/libeffects/visualizer/aidl/Visualizer.cpp b/media/libeffects/visualizer/aidl/Visualizer.cpp
index 28a7287..6e7833c 100644
--- a/media/libeffects/visualizer/aidl/Visualizer.cpp
+++ b/media/libeffects/visualizer/aidl/Visualizer.cpp
@@ -54,9 +54,16 @@
namespace aidl::android::hardware::audio::effect {
const std::string VisualizerImpl::kEffectName = "Visualizer";
-const Visualizer::Capability VisualizerImpl::kCapability = {
- .maxLatencyMs = VisualizerContext::kMaxLatencyMs,
- .captureSampleRange = {.min = 0, .max = VisualizerContext::kMaxCaptureBufSize}};
+const std::vector<Range::VisualizerRange> VisualizerImpl::kRanges = {
+ MAKE_RANGE(Visualizer, latencyMs, 0, VisualizerContext::kMaxLatencyMs),
+ MAKE_RANGE(Visualizer, captureSamples, 0, VisualizerContext::kMaxCaptureBufSize),
+ /* get only parameters, set invalid range (min > max) to indicate not support set */
+ MAKE_RANGE(Visualizer, measurement, Visualizer::Measurement({.peak = 1, .rms = 1}),
+ Visualizer::Measurement({.peak = 0, .rms = 0})),
+ MAKE_RANGE(Visualizer, captureSampleBuffer, std::vector<uint8_t>({1}),
+ std::vector<uint8_t>({0}))};
+const Capability VisualizerImpl::kCapability = {
+ .range = Range::make<Range::visualizer>(VisualizerImpl::kRanges)};
const Descriptor VisualizerImpl::kDescriptor = {
.common = {.id = {.type = kVisualizerTypeUUID,
.uuid = kVisualizerImplUUID,
@@ -66,7 +73,7 @@
.volume = Flags::Volume::CTRL},
.name = VisualizerImpl::kEffectName,
.implementor = "The Android Open Source Project"},
- .capability = Capability::make<Capability::visualizer>(VisualizerImpl::kCapability)};
+ .capability = VisualizerImpl::kCapability};
ndk::ScopedAStatus VisualizerImpl::getDescriptor(Descriptor* _aidl_return) {
RETURN_IF(!_aidl_return, EX_ILLEGAL_ARGUMENT, "Parameter:nullptr");
@@ -96,32 +103,13 @@
return ndk::ScopedAStatus::ok();
}
-ndk::ScopedAStatus VisualizerImpl::setOnlyParameter(
- const Visualizer::SetOnlyParameters& param) {
- auto tag = param.getTag();
- switch (tag) {
- case Visualizer::SetOnlyParameters::latencyMs: {
- RETURN_IF(mContext->setDownstreamLatency(
- param.get<Visualizer::SetOnlyParameters::latencyMs>()) !=
- RetCode::SUCCESS,
- EX_ILLEGAL_ARGUMENT, "setLatencyFailed");
- break;
- }
- default: {
- LOG(ERROR) << __func__ << " unsupported tag: " << toString(tag);
- return ndk::ScopedAStatus::fromExceptionCodeWithMessage(
- EX_ILLEGAL_ARGUMENT, "setOnlyParameterTagNotSupported");
- }
- }
- return ndk::ScopedAStatus::ok();
-}
-
ndk::ScopedAStatus VisualizerImpl::setParameterSpecific(const Parameter::Specific& specific) {
RETURN_IF(Parameter::Specific::visualizer != specific.getTag(), EX_ILLEGAL_ARGUMENT,
"EffectNotSupported");
RETURN_IF(!mContext, EX_NULL_POINTER, "nullContext");
auto& param = specific.get<Parameter::Specific::visualizer>();
+ RETURN_IF(!inRange(param, kRanges), EX_ILLEGAL_ARGUMENT, "outOfRange");
const auto tag = param.getTag();
switch (tag) {
case Visualizer::captureSamples: {
@@ -142,8 +130,11 @@
EX_ILLEGAL_ARGUMENT, "setMeasurementModeFailed");
return ndk::ScopedAStatus::ok();
}
- case Visualizer::setOnlyParameters: {
- return setOnlyParameter(param.get<Visualizer::setOnlyParameters>());
+ case Visualizer::latencyMs: {
+ RETURN_IF(mContext->setDownstreamLatency(param.get<Visualizer::latencyMs>()) !=
+ RetCode::SUCCESS,
+ EX_ILLEGAL_ARGUMENT, "setLatencyFailed");
+ return ndk::ScopedAStatus::ok();
}
default: {
LOG(ERROR) << __func__ << " unsupported tag: " << toString(tag);
@@ -153,30 +144,6 @@
}
}
-ndk::ScopedAStatus VisualizerImpl::getOnlyParameter(const Visualizer::GetOnlyParameters::Tag tag,
- Parameter::Specific* specific) {
- Visualizer visualizer;
- Visualizer::GetOnlyParameters param;
- switch (tag) {
- case Visualizer::GetOnlyParameters::measurement: {
- param.set<Visualizer::GetOnlyParameters::measurement>(mContext->getMeasure());
- break;
- }
- case Visualizer::GetOnlyParameters::captureSampleBuffer: {
- param.set<Visualizer::GetOnlyParameters::captureSampleBuffer>(mContext->capture());
- break;
- }
- default: {
- LOG(ERROR) << __func__ << " unsupported tag: " << toString(tag);
- return ndk::ScopedAStatus::fromExceptionCodeWithMessage(
- EX_ILLEGAL_ARGUMENT, "setOnlyParameterTagNotSupported");
- }
- }
- visualizer.set<Visualizer::getOnlyParameters>(param);
- specific->set<Parameter::Specific::visualizer>(visualizer);
- return ndk::ScopedAStatus::ok();
-}
-
ndk::ScopedAStatus VisualizerImpl::getParameterSpecific(const Parameter::Id& id,
Parameter::Specific* specific) {
RETURN_IF(!specific, EX_NULL_POINTER, "nullPtr");
@@ -188,9 +155,6 @@
case Visualizer::Id::commonTag: {
return getParameterVisualizer(specificId.get<Visualizer::Id::commonTag>(), specific);
}
- case Visualizer::Id::getOnlyParamTag: {
- return getOnlyParameter(specificId.get<Visualizer::Id::getOnlyParamTag>(), specific);
- }
default: {
LOG(ERROR) << __func__ << " unsupported tag: " << toString(specificTag);
return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
@@ -218,6 +182,18 @@
param.set<Visualizer::measurementMode>(mContext->getMeasurementMode());
break;
}
+ case Visualizer::measurement: {
+ param.set<Visualizer::measurement>(mContext->getMeasure());
+ break;
+ }
+ case Visualizer::captureSampleBuffer: {
+ param.set<Visualizer::captureSampleBuffer>(mContext->capture());
+ break;
+ }
+ case Visualizer::latencyMs: {
+ param.set<Visualizer::latencyMs>(mContext->getDownstreamLatency());
+ break;
+ }
default: {
LOG(ERROR) << __func__ << " unsupported tag: " << toString(tag);
return ndk::ScopedAStatus::fromExceptionCodeWithMessage(
diff --git a/media/libeffects/visualizer/aidl/Visualizer.h b/media/libeffects/visualizer/aidl/Visualizer.h
index 5908d9a..f6e1d6d 100644
--- a/media/libeffects/visualizer/aidl/Visualizer.h
+++ b/media/libeffects/visualizer/aidl/Visualizer.h
@@ -28,7 +28,7 @@
class VisualizerImpl final : public EffectImpl {
public:
static const std::string kEffectName;
- static const Visualizer::Capability kCapability;
+ static const Capability kCapability;
static const Descriptor kDescriptor;
VisualizerImpl() { LOG(DEBUG) << __func__; }
~VisualizerImpl() {
@@ -49,12 +49,10 @@
std::string getEffectName() override { return kEffectName; }
private:
+ static const std::vector<Range::VisualizerRange> kRanges;
std::shared_ptr<VisualizerContext> mContext;
ndk::ScopedAStatus getParameterVisualizer(const Visualizer::Tag& tag,
Parameter::Specific* specific);
- ndk::ScopedAStatus setOnlyParameter(const Visualizer::SetOnlyParameters& param);
- ndk::ScopedAStatus getOnlyParameter(const Visualizer::GetOnlyParameters::Tag tag,
- Parameter::Specific* specific);
};
} // namespace aidl::android::hardware::audio::effect
diff --git a/media/libeffects/visualizer/aidl/VisualizerContext.cpp b/media/libeffects/visualizer/aidl/VisualizerContext.cpp
index 1965e0e..4405407 100644
--- a/media/libeffects/visualizer/aidl/VisualizerContext.cpp
+++ b/media/libeffects/visualizer/aidl/VisualizerContext.cpp
@@ -88,11 +88,6 @@
RetCode VisualizerContext::setCaptureSamples(int samples) {
std::lock_guard lg(mMutex);
- if (samples < 0 || (unsigned)samples > kMaxCaptureBufSize) {
- LOG(ERROR) << __func__ << " captureSamples " << samples << " exceed valid range: 0 - "
- << kMaxCaptureBufSize;
- return RetCode::ERROR_ILLEGAL_PARAMETER;
- }
mCaptureSamples = samples;
return RetCode::SUCCESS;
}
@@ -122,16 +117,16 @@
}
RetCode VisualizerContext::setDownstreamLatency(int latency) {
- if (latency < 0 || (unsigned)latency > kMaxLatencyMs) {
- LOG(ERROR) << __func__ << " latency " << latency << " exceed valid range: 0 - "
- << kMaxLatencyMs;
- return RetCode::ERROR_ILLEGAL_PARAMETER;
- }
std::lock_guard lg(mMutex);
mDownstreamLatency = latency;
return RetCode::SUCCESS;
}
+int VisualizerContext::getDownstreamLatency() {
+ std::lock_guard lg(mMutex);
+ return mDownstreamLatency;
+}
+
uint32_t VisualizerContext::getDeltaTimeMsFromUpdatedTime_l() {
uint32_t deltaMs = 0;
if (mBufferUpdateTime.tv_sec != 0) {
@@ -149,7 +144,7 @@
return deltaMs;
}
-Visualizer::GetOnlyParameters::Measurement VisualizerContext::getMeasure() {
+Visualizer::Measurement VisualizerContext::getMeasure() {
uint16_t peakU16 = 0;
float sumRmsSquared = 0.0f;
uint8_t nbValidMeasurements = 0;
@@ -184,7 +179,7 @@
}
float rms = nbValidMeasurements == 0 ? 0.0f : sqrtf(sumRmsSquared / nbValidMeasurements);
- Visualizer::GetOnlyParameters::Measurement measure;
+ Visualizer::Measurement measure;
// convert from I16 sample values to mB and write results
measure.rms = (rms < 0.000016f) ? -9600 : (int32_t)(2000 * log10(rms / 32767.0f));
measure.peak = (peakU16 == 0) ? -9600 : (int32_t)(2000 * log10(peakU16 / 32767.0f));
diff --git a/media/libeffects/visualizer/aidl/VisualizerContext.h b/media/libeffects/visualizer/aidl/VisualizerContext.h
index bfda0b9..3cb711e 100644
--- a/media/libeffects/visualizer/aidl/VisualizerContext.h
+++ b/media/libeffects/visualizer/aidl/VisualizerContext.h
@@ -45,10 +45,11 @@
RetCode setScalingMode(Visualizer::ScalingMode mode);
Visualizer::ScalingMode getScalingMode();
RetCode setDownstreamLatency(int latency);
+ int getDownstreamLatency();
IEffect::Status process(float* in, float* out, int samples);
// Gets the current measurements, measured by process() and consumed by getParameter()
- Visualizer::GetOnlyParameters::Measurement getMeasure();
+ Visualizer::Measurement getMeasure();
// Gets the latest PCM capture, data captured by process() and consumed by getParameter()
std::vector<uint8_t> capture();
diff --git a/media/libmedia/IMediaRecorder.cpp b/media/libmedia/IMediaRecorder.cpp
index 154988d..e191999 100644
--- a/media/libmedia/IMediaRecorder.cpp
+++ b/media/libmedia/IMediaRecorder.cpp
@@ -428,7 +428,7 @@
return reply.readInt32();
}
- status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones)
+ status_t getActiveMicrophones(std::vector<media::MicrophoneInfoFw>* activeMicrophones)
{
ALOGV("getActiveMicrophones");
Parcel data, reply;
@@ -756,7 +756,7 @@
case GET_ACTIVE_MICROPHONES: {
ALOGV("GET_ACTIVE_MICROPHONES");
CHECK_INTERFACE(IMediaRecorder, data, reply);
- std::vector<media::MicrophoneInfo> activeMicrophones;
+ std::vector<media::MicrophoneInfoFw> activeMicrophones;
status_t status = getActiveMicrophones(&activeMicrophones);
reply->writeInt32(status);
if (status != NO_ERROR) {
diff --git a/media/libmedia/include/media/IMediaRecorder.h b/media/libmedia/include/media/IMediaRecorder.h
index 6e69782..05da5c2 100644
--- a/media/libmedia/include/media/IMediaRecorder.h
+++ b/media/libmedia/include/media/IMediaRecorder.h
@@ -18,8 +18,8 @@
#ifndef ANDROID_IMEDIARECORDER_H
#define ANDROID_IMEDIARECORDER_H
+#include <android/media/MicrophoneInfoFw.h>
#include <binder/IInterface.h>
-#include <media/MicrophoneInfo.h>
#include <system/audio.h>
#include <vector>
@@ -74,7 +74,7 @@
virtual status_t getRoutedDeviceId(audio_port_handle_t *deviceId) = 0;
virtual status_t enableAudioDeviceCallback(bool enabled) = 0;
virtual status_t getActiveMicrophones(
- std::vector<media::MicrophoneInfo>* activeMicrophones) = 0;
+ std::vector<media::MicrophoneInfoFw>* activeMicrophones) = 0;
virtual status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction) = 0;
virtual status_t setPreferredMicrophoneFieldDimension(float zoom) = 0;
virtual status_t getPortId(audio_port_handle_t *portId) = 0;
diff --git a/media/libmedia/include/media/MediaRecorderBase.h b/media/libmedia/include/media/MediaRecorderBase.h
index 2b7818d..82ec9c5 100644
--- a/media/libmedia/include/media/MediaRecorderBase.h
+++ b/media/libmedia/include/media/MediaRecorderBase.h
@@ -19,7 +19,6 @@
#define MEDIA_RECORDER_BASE_H_
#include <media/AudioSystem.h>
-#include <media/MicrophoneInfo.h>
#include <media/mediarecorder.h>
#include <android/content/AttributionSourceState.h>
@@ -74,7 +73,7 @@
virtual void setAudioDeviceCallback(const sp<AudioSystem::AudioDeviceCallback>& callback) = 0;
virtual status_t enableAudioDeviceCallback(bool enabled) = 0;
virtual status_t getActiveMicrophones(
- std::vector<media::MicrophoneInfo>* activeMicrophones) = 0;
+ std::vector<media::MicrophoneInfoFw>* activeMicrophones) = 0;
virtual status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction) = 0;
virtual status_t setPreferredMicrophoneFieldDimension(float zoom) = 0;
virtual status_t getPortId(audio_port_handle_t *portId) const = 0;
diff --git a/media/libmedia/include/media/mediarecorder.h b/media/libmedia/include/media/mediarecorder.h
index dd18144..602f72e 100644
--- a/media/libmedia/include/media/mediarecorder.h
+++ b/media/libmedia/include/media/mediarecorder.h
@@ -24,7 +24,7 @@
#include <utils/Errors.h>
#include <media/IMediaRecorderClient.h>
#include <media/IMediaDeathNotifier.h>
-#include <media/MicrophoneInfo.h>
+#include <android/media/MicrophoneInfoFw.h>
#include <android/content/AttributionSourceState.h>
namespace android {
@@ -268,7 +268,7 @@
status_t setInputDevice(audio_port_handle_t deviceId);
status_t getRoutedDeviceId(audio_port_handle_t *deviceId);
status_t enableAudioDeviceCallback(bool enabled);
- status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones);
+ status_t getActiveMicrophones(std::vector<media::MicrophoneInfoFw>* activeMicrophones);
status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
status_t setPreferredMicrophoneFieldDimension(float zoom);
diff --git a/media/libmedia/mediarecorder.cpp b/media/libmedia/mediarecorder.cpp
index cf12c36..bd06fb6 100644
--- a/media/libmedia/mediarecorder.cpp
+++ b/media/libmedia/mediarecorder.cpp
@@ -884,7 +884,8 @@
return mMediaRecorder->enableAudioDeviceCallback(enabled);
}
-status_t MediaRecorder::getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones)
+status_t MediaRecorder::getActiveMicrophones(
+ std::vector<media::MicrophoneInfoFw>* activeMicrophones)
{
ALOGV("getActiveMicrophones");
diff --git a/media/libmediaplayerservice/MediaRecorderClient.cpp b/media/libmediaplayerservice/MediaRecorderClient.cpp
index 4aa80be..58fc06d 100644
--- a/media/libmediaplayerservice/MediaRecorderClient.cpp
+++ b/media/libmediaplayerservice/MediaRecorderClient.cpp
@@ -563,7 +563,7 @@
}
status_t MediaRecorderClient::getActiveMicrophones(
- std::vector<media::MicrophoneInfo>* activeMicrophones) {
+ std::vector<media::MicrophoneInfoFw>* activeMicrophones) {
ALOGV("getActiveMicrophones");
Mutex::Autolock lock(mLock);
if (mRecorder != NULL) {
diff --git a/media/libmediaplayerservice/MediaRecorderClient.h b/media/libmediaplayerservice/MediaRecorderClient.h
index dcb9f82..dec0c99 100644
--- a/media/libmediaplayerservice/MediaRecorderClient.h
+++ b/media/libmediaplayerservice/MediaRecorderClient.h
@@ -83,7 +83,7 @@
virtual status_t getRoutedDeviceId(audio_port_handle_t* deviceId);
virtual status_t enableAudioDeviceCallback(bool enabled);
virtual status_t getActiveMicrophones(
- std::vector<media::MicrophoneInfo>* activeMicrophones);
+ std::vector<media::MicrophoneInfoFw>* activeMicrophones);
virtual status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
virtual status_t setPreferredMicrophoneFieldDimension(float zoom);
status_t getPortId(audio_port_handle_t *portId) override;
diff --git a/media/libmediaplayerservice/StagefrightRecorder.cpp b/media/libmediaplayerservice/StagefrightRecorder.cpp
index 6497b58..ec79b99 100644
--- a/media/libmediaplayerservice/StagefrightRecorder.cpp
+++ b/media/libmediaplayerservice/StagefrightRecorder.cpp
@@ -2576,7 +2576,7 @@
}
status_t StagefrightRecorder::getActiveMicrophones(
- std::vector<media::MicrophoneInfo>* activeMicrophones) {
+ std::vector<media::MicrophoneInfoFw>* activeMicrophones) {
if (mAudioSourceNode != 0) {
return mAudioSourceNode->getActiveMicrophones(activeMicrophones);
}
diff --git a/media/libmediaplayerservice/StagefrightRecorder.h b/media/libmediaplayerservice/StagefrightRecorder.h
index 0801101..0b6a5bb 100644
--- a/media/libmediaplayerservice/StagefrightRecorder.h
+++ b/media/libmediaplayerservice/StagefrightRecorder.h
@@ -83,7 +83,7 @@
virtual status_t getRoutedDeviceId(audio_port_handle_t* deviceId);
virtual void setAudioDeviceCallback(const sp<AudioSystem::AudioDeviceCallback>& callback);
virtual status_t enableAudioDeviceCallback(bool enabled);
- virtual status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones);
+ virtual status_t getActiveMicrophones(std::vector<media::MicrophoneInfoFw>* activeMicrophones);
virtual status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
virtual status_t setPreferredMicrophoneFieldDimension(float zoom);
status_t getPortId(audio_port_handle_t *portId) const override;
diff --git a/media/libmediaplayerservice/fuzzer/mediarecorder_fuzzer.cpp b/media/libmediaplayerservice/fuzzer/mediarecorder_fuzzer.cpp
index 4f2da67..b197042 100644
--- a/media/libmediaplayerservice/fuzzer/mediarecorder_fuzzer.cpp
+++ b/media/libmediaplayerservice/fuzzer/mediarecorder_fuzzer.cpp
@@ -198,7 +198,7 @@
mStfRecorder->setInputDevice(deviceId);
mStfRecorder->getRoutedDeviceId(&deviceId);
- vector<android::media::MicrophoneInfo> activeMicrophones{};
+ vector<android::media::MicrophoneInfoFw> activeMicrophones{};
mStfRecorder->getActiveMicrophones(&activeMicrophones);
int32_t portId;
diff --git a/media/libmediaplayerservice/tests/stagefrightRecorder/StagefrightRecorderTest.cpp b/media/libmediaplayerservice/tests/stagefrightRecorder/StagefrightRecorderTest.cpp
index 162c187..9514021 100644
--- a/media/libmediaplayerservice/tests/stagefrightRecorder/StagefrightRecorderTest.cpp
+++ b/media/libmediaplayerservice/tests/stagefrightRecorder/StagefrightRecorderTest.cpp
@@ -286,7 +286,7 @@
// Record media for 4 secs
std::this_thread::sleep_for(std::chrono::seconds(kClipDurationInSec));
- std::vector<media::MicrophoneInfo> activeMicrophones{};
+ std::vector<media::MicrophoneInfoFw> activeMicrophones{};
status = mStfRecorder->getActiveMicrophones(&activeMicrophones);
ASSERT_EQ(status, OK) << "Failed to get Active Microphones";
ASSERT_GT(activeMicrophones.size(), 0) << "No active microphones are found";
diff --git a/media/libstagefright/AudioSource.cpp b/media/libstagefright/AudioSource.cpp
index bfe8538..584dad6 100644
--- a/media/libstagefright/AudioSource.cpp
+++ b/media/libstagefright/AudioSource.cpp
@@ -522,7 +522,7 @@
}
status_t AudioSource::getActiveMicrophones(
- std::vector<media::MicrophoneInfo>* activeMicrophones) {
+ std::vector<media::MicrophoneInfoFw>* activeMicrophones) {
if (mRecord != 0) {
return mRecord->getActiveMicrophones(activeMicrophones);
}
diff --git a/media/libstagefright/include/media/stagefright/AudioSource.h b/media/libstagefright/include/media/stagefright/AudioSource.h
index 5e84977..65d5246 100644
--- a/media/libstagefright/include/media/stagefright/AudioSource.h
+++ b/media/libstagefright/include/media/stagefright/AudioSource.h
@@ -21,7 +21,6 @@
#include <media/AudioRecord.h>
#include <media/AudioSystem.h>
#include <media/stagefright/MediaSource.h>
-#include <media/MicrophoneInfo.h>
#include <media/stagefright/MediaBuffer.h>
#include <utils/List.h>
@@ -83,7 +82,7 @@
status_t addAudioDeviceCallback(const sp<AudioSystem::AudioDeviceCallback>& callback);
status_t removeAudioDeviceCallback(const sp<AudioSystem::AudioDeviceCallback>& callback);
- status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones);
+ status_t getActiveMicrophones(std::vector<media::MicrophoneInfoFw>* activeMicrophones);
status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
status_t setPreferredMicrophoneFieldDimension(float zoom);
diff --git a/services/audioflinger/AudioFlinger.cpp b/services/audioflinger/AudioFlinger.cpp
index 7bb0fd3..3b73333 100644
--- a/services/audioflinger/AudioFlinger.cpp
+++ b/services/audioflinger/AudioFlinger.cpp
@@ -2857,7 +2857,7 @@
return mAudioManager.load();
}
-status_t AudioFlinger::getMicrophones(std::vector<media::MicrophoneInfo> *microphones)
+status_t AudioFlinger::getMicrophones(std::vector<media::MicrophoneInfoFw> *microphones)
{
AutoMutex lock(mHardwareLock);
status_t status = INVALID_OPERATION;
@@ -2870,8 +2870,12 @@
mHardwareStatus = AUDIO_HW_IDLE;
if (devStatus == NO_ERROR) {
// report success if at least one HW module supports the function.
- std::transform(mics.begin(), mics.end(), std::back_inserter(*microphones),
- [](auto& mic) { return media::MicrophoneInfo(mic); });
+ std::transform(mics.begin(), mics.end(), std::back_inserter(*microphones), [](auto& mic)
+ {
+ auto microphone =
+ legacy2aidl_audio_microphone_characteristic_t_MicrophoneInfoFw(mic);
+ return microphone.ok() ? microphone.value() : media::MicrophoneInfoFw{};
+ });
status = NO_ERROR;
}
}
diff --git a/services/audioflinger/AudioFlinger.h b/services/audioflinger/AudioFlinger.h
index e8133d9..9fc503b 100644
--- a/services/audioflinger/AudioFlinger.h
+++ b/services/audioflinger/AudioFlinger.h
@@ -281,7 +281,7 @@
bool isAudioPolicyReady() const { return mAudioPolicyReady.load(); }
- virtual status_t getMicrophones(std::vector<media::MicrophoneInfo> *microphones);
+ virtual status_t getMicrophones(std::vector<media::MicrophoneInfoFw> *microphones);
virtual status_t setAudioHalPids(const std::vector<pid_t>& pids);
@@ -726,7 +726,7 @@
int /*audio_session_t*/ triggerSession);
virtual binder::Status stop();
virtual binder::Status getActiveMicrophones(
- std::vector<media::MicrophoneInfoData>* activeMicrophones);
+ std::vector<media::MicrophoneInfoFw>* activeMicrophones);
virtual binder::Status setPreferredMicrophoneDirection(
int /*audio_microphone_direction_t*/ direction);
virtual binder::Status setPreferredMicrophoneFieldDimension(float zoom);
diff --git a/services/audioflinger/RecordTracks.h b/services/audioflinger/RecordTracks.h
index daec57e..f0a5f76 100644
--- a/services/audioflinger/RecordTracks.h
+++ b/services/audioflinger/RecordTracks.h
@@ -73,7 +73,8 @@
void setSilenced(bool silenced) { if (!isPatchTrack()) mSilenced = silenced; }
bool isSilenced() const { return mSilenced; }
- status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones);
+ status_t getActiveMicrophones(
+ std::vector<media::MicrophoneInfoFw>* activeMicrophones);
status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
status_t setPreferredMicrophoneFieldDimension(float zoom);
diff --git a/services/audioflinger/Threads.cpp b/services/audioflinger/Threads.cpp
index 4ca8a8e..fdf3306 100644
--- a/services/audioflinger/Threads.cpp
+++ b/services/audioflinger/Threads.cpp
@@ -8949,7 +8949,7 @@
}
status_t AudioFlinger::RecordThread::getActiveMicrophones(
- std::vector<media::MicrophoneInfo>* activeMicrophones)
+ std::vector<media::MicrophoneInfoFw>* activeMicrophones)
{
ALOGV("RecordThread::getActiveMicrophones");
AutoMutex _l(mLock);
diff --git a/services/audioflinger/Threads.h b/services/audioflinger/Threads.h
index f829efc..ddae7ae 100644
--- a/services/audioflinger/Threads.h
+++ b/services/audioflinger/Threads.h
@@ -1982,7 +1982,8 @@
// Sets the UID records silence
void setRecordSilenced(audio_port_handle_t portId, bool silenced);
- status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones);
+ status_t getActiveMicrophones(
+ std::vector<media::MicrophoneInfoFw>* activeMicrophones);
status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
status_t setPreferredMicrophoneFieldDimension(float zoom);
diff --git a/services/audioflinger/Tracks.cpp b/services/audioflinger/Tracks.cpp
index 382e4f9..1fbf720 100644
--- a/services/audioflinger/Tracks.cpp
+++ b/services/audioflinger/Tracks.cpp
@@ -2391,15 +2391,9 @@
}
binder::Status AudioFlinger::RecordHandle::getActiveMicrophones(
- std::vector<media::MicrophoneInfoData>* activeMicrophones) {
+ std::vector<media::MicrophoneInfoFw>* activeMicrophones) {
ALOGV("%s()", __func__);
- std::vector<media::MicrophoneInfo> mics;
- status_t status = mRecordTrack->getActiveMicrophones(&mics);
- activeMicrophones->resize(mics.size());
- for (size_t i = 0; status == OK && i < mics.size(); ++i) {
- status = mics[i].writeToParcelable(&activeMicrophones->at(i));
- }
- return binderStatusFromStatusT(status);
+ return binderStatusFromStatusT(mRecordTrack->getActiveMicrophones(activeMicrophones));
}
binder::Status AudioFlinger::RecordHandle::setPreferredMicrophoneDirection(
@@ -2719,7 +2713,7 @@
}
status_t AudioFlinger::RecordThread::RecordTrack::getActiveMicrophones(
- std::vector<media::MicrophoneInfo>* activeMicrophones)
+ std::vector<media::MicrophoneInfoFw>* activeMicrophones)
{
sp<ThreadBase> thread = mThread.promote();
if (thread != 0) {
diff --git a/services/camera/libcameraservice/device3/hidl/HidlCamera3Device.h b/services/camera/libcameraservice/device3/hidl/HidlCamera3Device.h
index 205a899..15bd5ba 100644
--- a/services/camera/libcameraservice/device3/hidl/HidlCamera3Device.h
+++ b/services/camera/libcameraservice/device3/hidl/HidlCamera3Device.h
@@ -84,9 +84,6 @@
const hardware::hidl_vec<
hardware::camera::device::V3_2::StreamBuffer>& buffers) override;
- // Handle one notify message
- void notify(const hardware::camera::device::V3_2::NotifyMsg& msg);
-
status_t switchToOffline(const std::vector<int32_t>& streamsToKeep,
/*out*/ sp<CameraOfflineSessionBase>* session) override;