Merge changes from topic "audio-hal-v4" (e84d9ca0) · Commits · e / os / android_frameworks_av

media/libaudiohal/4.0/Android.bp

0 → 100644

+57 −0

Original line number	Original line	Diff line number	Diff line
			cc_library_shared {
			name: "libaudiohal@4.0",

			srcs: [
			"DeviceHalLocal.cpp",
			"DevicesFactoryHalHybrid.cpp",
			"DevicesFactoryHalLocal.cpp",
			"StreamHalLocal.cpp",

			"ConversionHelperHidl.cpp",
			"DeviceHalHidl.cpp",
			"DevicesFactoryHalHidl.cpp",
			"EffectBufferHalHidl.cpp",
			"EffectHalHidl.cpp",
			"EffectsFactoryHalHidl.cpp",
			"StreamHalHidl.cpp",
			],

			export_include_dirs: ["include"],

			cflags: [
			"-Wall",
			"-Wextra",
			"-Werror",
			],
			shared_libs: [
			"libaudiohal_deathhandler",
			"libaudioutils",
			"libcutils",
			"liblog",
			"libutils",
			"libhardware",
			"libbase",
			"libfmq",
			"libhwbinder",
			"libhidlbase",
			"libhidlmemory",
			"libhidltransport",
			"android.hardware.audio@4.0",
			"android.hardware.audio.common-util",
			"android.hardware.audio.common@4.0",
			"android.hardware.audio.common@4.0-util",
			"android.hardware.audio.effect@4.0",
			"android.hidl.allocator@1.0",
			"android.hidl.memory@1.0",
			"libmedia_helper",
			"libmediautils",
			],
			header_libs: [
			"android.hardware.audio.common.util@all-versions",
			"libaudiohal_headers"
			],

			export_shared_lib_headers: [
			"libfmq",
			],
			}

media/libaudiohal/4.0/ConversionHelperHidl.cpp

0 → 100644

+105 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2016 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 <string.h>

			#define LOG_TAG "HalHidl"
			#include <media/AudioParameter.h>
			#include <utils/Log.h>

			#include "ConversionHelperHidl.h"

			using ::android::hardware::audio::V4_0::Result;

			namespace android {
			namespace V4_0 {

			// static
			status_t ConversionHelperHidl::keysFromHal(const String8& keys, hidl_vec<hidl_string> *hidlKeys) {
			AudioParameter halKeys(keys);
			if (halKeys.size() == 0) return BAD_VALUE;
			hidlKeys->resize(halKeys.size());
			//FIXME: keyStreamSupportedChannels and keyStreamSupportedSamplingRates come with a
			// "keyFormat=<value>" pair. We need to transform it into a single key string so that it is
			// carried over to the legacy HAL via HIDL.
			String8 value;
			bool keepFormatValue = halKeys.size() == 2 &&
			(halKeys.get(String8(AudioParameter::keyStreamSupportedChannels), value) == NO_ERROR \|\|
			halKeys.get(String8(AudioParameter::keyStreamSupportedSamplingRates), value) == NO_ERROR);

			for (size_t i = 0; i < halKeys.size(); ++i) {
			String8 key;
			status_t status = halKeys.getAt(i, key);
			if (status != OK) return status;
			if (keepFormatValue && key == AudioParameter::keyFormat) {
			AudioParameter formatParam;
			halKeys.getAt(i, key, value);
			formatParam.add(key, value);
			key = formatParam.toString();
			}
			(*hidlKeys)[i] = key.string();
			}
			return OK;
			}

			// static
			status_t ConversionHelperHidl::parametersFromHal(
			const String8& kvPairs, hidl_vec<ParameterValue> *hidlParams) {
			AudioParameter params(kvPairs);
			if (params.size() == 0) return BAD_VALUE;
			hidlParams->resize(params.size());
			for (size_t i = 0; i < params.size(); ++i) {
			String8 key, value;
			status_t status = params.getAt(i, key, value);
			if (status != OK) return status;
			(*hidlParams)[i].key = key.string();
			(*hidlParams)[i].value = value.string();
			}
			return OK;
			}

			// static
			void ConversionHelperHidl::parametersToHal(
			const hidl_vec<ParameterValue>& parameters, String8 *values) {
			AudioParameter params;
			for (size_t i = 0; i < parameters.size(); ++i) {
			params.add(String8(parameters[i].key.c_str()), String8(parameters[i].value.c_str()));
			}
			values->setTo(params.toString());
			}

			ConversionHelperHidl::ConversionHelperHidl(const char* className)
			: mClassName(className) {
			}

			// static
			status_t ConversionHelperHidl::analyzeResult(const Result& result) {
			switch (result) {
			case Result::OK: return OK;
			case Result::INVALID_ARGUMENTS: return BAD_VALUE;
			case Result::INVALID_STATE: return NOT_ENOUGH_DATA;
			case Result::NOT_INITIALIZED: return NO_INIT;
			case Result::NOT_SUPPORTED: return INVALID_OPERATION;
			default: return NO_INIT;
			}
			}

			void ConversionHelperHidl::emitError(const char* funcName, const char* description) {
			ALOGE("%s %p %s: %s (from rpc)", mClassName, this, funcName, description);
			}

			} // namespace V4_0
			} // namespace android

media/libaudiohal/4.0/ConversionHelperHidl.h

0 → 100644

+85 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2016 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_HARDWARE_CONVERSION_HELPER_HIDL_4_0_H
			#define ANDROID_HARDWARE_CONVERSION_HELPER_HIDL_4_0_H

			#include <android/hardware/audio/4.0/types.h>
			#include <hidl/HidlSupport.h>
			#include <utils/String8.h>

			using ::android::hardware::audio::V4_0::ParameterValue;
			using ::android::hardware::Return;
			using ::android::hardware::hidl_string;
			using ::android::hardware::hidl_vec;

			namespace android {
			namespace V4_0 {

			class ConversionHelperHidl {
			protected:
			static status_t keysFromHal(const String8& keys, hidl_vec<hidl_string> *hidlKeys);
			static status_t parametersFromHal(const String8& kvPairs, hidl_vec<ParameterValue> *hidlParams);
			static void parametersToHal(const hidl_vec<ParameterValue>& parameters, String8 *values);

			ConversionHelperHidl(const char* className);

			template<typename R, typename T>
			status_t processReturn(const char* funcName, const Return<R>& ret, T *retval) {
			if (ret.isOk()) {
			// This way it also works for enum class to unscoped enum conversion.
			*retval = static_cast<T>(static_cast<R>(ret));
			return OK;
			}
			return processReturn(funcName, ret);
			}

			template<typename T>
			status_t processReturn(const char* funcName, const Return<T>& ret) {
			if (!ret.isOk()) {
			emitError(funcName, ret.description().c_str());
			}
			return ret.isOk() ? OK : FAILED_TRANSACTION;
			}

			status_t processReturn(const char* funcName, const Return<hardware::audio::V4_0::Result>& ret) {
			if (!ret.isOk()) {
			emitError(funcName, ret.description().c_str());
			}
			return ret.isOk() ? analyzeResult(ret) : FAILED_TRANSACTION;
			}

			template<typename T>
			status_t processReturn(
			const char* funcName, const Return<T>& ret, hardware::audio::V4_0::Result retval) {
			if (!ret.isOk()) {
			emitError(funcName, ret.description().c_str());
			}
			return ret.isOk() ? analyzeResult(retval) : FAILED_TRANSACTION;
			}

			private:
			const char* mClassName;

			static status_t analyzeResult(const hardware::audio::V4_0::Result& result);

			void emitError(const char* funcName, const char* description);
			};

			} // namespace V4_0
			} // namespace android

			#endif // ANDROID_HARDWARE_CONVERSION_HELPER_HIDL_4_0_H

media/libaudiohal/4.0/DeviceHalHidl.cpp

0 → 100644

+372 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2016 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 <stdio.h>

			#define LOG_TAG "DeviceHalHidl"
			//#define LOG_NDEBUG 0

			#include <android/hardware/audio/4.0/IPrimaryDevice.h>
			#include <cutils/native_handle.h>
			#include <hwbinder/IPCThreadState.h>
			#include <utils/Log.h>

			#include <common/all-versions/VersionUtils.h>

			#include "DeviceHalHidl.h"
			#include "HidlUtils.h"
			#include "StreamHalHidl.h"
			#include "VersionUtils.h"

			using ::android::hardware::audio::common::V4_0::AudioConfig;
			using ::android::hardware::audio::common::V4_0::AudioDevice;
			using ::android::hardware::audio::common::V4_0::AudioInputFlag;
			using ::android::hardware::audio::common::V4_0::AudioOutputFlag;
			using ::android::hardware::audio::common::V4_0::AudioPatchHandle;
			using ::android::hardware::audio::common::V4_0::AudioPort;
			using ::android::hardware::audio::common::V4_0::AudioPortConfig;
			using ::android::hardware::audio::common::V4_0::AudioMode;
			using ::android::hardware::audio::common::V4_0::AudioSource;
			using ::android::hardware::audio::common::V4_0::HidlUtils;
			using ::android::hardware::audio::common::utils::mkEnumConverter;
			using ::android::hardware::audio::V4_0::DeviceAddress;
			using ::android::hardware::audio::V4_0::IPrimaryDevice;
			using ::android::hardware::audio::V4_0::ParameterValue;
			using ::android::hardware::audio::V4_0::Result;
			using ::android::hardware::audio::V4_0::SinkMetadata;
			using ::android::hardware::hidl_string;
			using ::android::hardware::hidl_vec;

			namespace android {
			namespace V4_0 {

			namespace {

			status_t deviceAddressFromHal(
			audio_devices_t device, const char* halAddress, DeviceAddress* address) {
			address->device = AudioDevice(device);

			if (address == nullptr \|\| strnlen(halAddress, AUDIO_DEVICE_MAX_ADDRESS_LEN) == 0) {
			return OK;
			}
			const bool isInput = (device & AUDIO_DEVICE_BIT_IN) != 0;
			if (isInput) device &= ~AUDIO_DEVICE_BIT_IN;
			if ((!isInput && (device & AUDIO_DEVICE_OUT_ALL_A2DP) != 0)
			\|\| (isInput && (device & AUDIO_DEVICE_IN_BLUETOOTH_A2DP) != 0)) {
			int status = sscanf(halAddress,
			"%hhX:%hhX:%hhX:%hhX:%hhX:%hhX",
			&address->address.mac[0], &address->address.mac[1], &address->address.mac[2],
			&address->address.mac[3], &address->address.mac[4], &address->address.mac[5]);
			return status == 6 ? OK : BAD_VALUE;
			} else if ((!isInput && (device & AUDIO_DEVICE_OUT_IP) != 0)
			\|\| (isInput && (device & AUDIO_DEVICE_IN_IP) != 0)) {
			int status = sscanf(halAddress,
			"%hhu.%hhu.%hhu.%hhu",
			&address->address.ipv4[0], &address->address.ipv4[1],
			&address->address.ipv4[2], &address->address.ipv4[3]);
			return status == 4 ? OK : BAD_VALUE;
			} else if ((!isInput && (device & AUDIO_DEVICE_OUT_ALL_USB)) != 0
			\|\| (isInput && (device & AUDIO_DEVICE_IN_ALL_USB)) != 0) {
			int status = sscanf(halAddress,
			"card=%d;device=%d",
			&address->address.alsa.card, &address->address.alsa.device);
			return status == 2 ? OK : BAD_VALUE;
			} else if ((!isInput && (device & AUDIO_DEVICE_OUT_BUS) != 0)
			\|\| (isInput && (device & AUDIO_DEVICE_IN_BUS) != 0)) {
			if (halAddress != NULL) {
			address->busAddress = halAddress;
			return OK;
			}
			return BAD_VALUE;
			} else if ((!isInput && (device & AUDIO_DEVICE_OUT_REMOTE_SUBMIX)) != 0
			\|\| (isInput && (device & AUDIO_DEVICE_IN_REMOTE_SUBMIX) != 0)) {
			if (halAddress != NULL) {
			address->rSubmixAddress = halAddress;
			return OK;
			}
			return BAD_VALUE;
			}
			return OK;
			}

			} // namespace

			DeviceHalHidl::DeviceHalHidl(const sp<IDevice>& device)
			: ConversionHelperHidl("Device"), mDevice(device),
			mPrimaryDevice(IPrimaryDevice::castFrom(device)) {
			}

			DeviceHalHidl::~DeviceHalHidl() {
			if (mDevice != 0) {
			mDevice.clear();
			hardware::IPCThreadState::self()->flushCommands();
			}
			}

			status_t DeviceHalHidl::getSupportedDevices(uint32_t*) {
			// Obsolete.
			return INVALID_OPERATION;
			}

			status_t DeviceHalHidl::initCheck() {
			if (mDevice == 0) return NO_INIT;
			return processReturn("initCheck", mDevice->initCheck());
			}

			status_t DeviceHalHidl::setVoiceVolume(float volume) {
			if (mDevice == 0) return NO_INIT;
			if (mPrimaryDevice == 0) return INVALID_OPERATION;
			return processReturn("setVoiceVolume", mPrimaryDevice->setVoiceVolume(volume));
			}

			status_t DeviceHalHidl::setMasterVolume(float volume) {
			if (mDevice == 0) return NO_INIT;
			if (mPrimaryDevice == 0) return INVALID_OPERATION;
			return processReturn("setMasterVolume", mPrimaryDevice->setMasterVolume(volume));
			}

			status_t DeviceHalHidl::getMasterVolume(float *volume) {
			if (mDevice == 0) return NO_INIT;
			if (mPrimaryDevice == 0) return INVALID_OPERATION;
			Result retval;
			Return<void> ret = mPrimaryDevice->getMasterVolume(
			[&](Result r, float v) {
			retval = r;
			if (retval == Result::OK) {
			*volume = v;
			}
			});
			return processReturn("getMasterVolume", ret, retval);
			}

			status_t DeviceHalHidl::setMode(audio_mode_t mode) {
			if (mDevice == 0) return NO_INIT;
			if (mPrimaryDevice == 0) return INVALID_OPERATION;
			return processReturn("setMode", mPrimaryDevice->setMode(AudioMode(mode)));
			}

			status_t DeviceHalHidl::setMicMute(bool state) {
			if (mDevice == 0) return NO_INIT;
			return processReturn("setMicMute", mDevice->setMicMute(state));
			}

			status_t DeviceHalHidl::getMicMute(bool *state) {
			if (mDevice == 0) return NO_INIT;
			Result retval;
			Return<void> ret = mDevice->getMicMute(
			[&](Result r, bool mute) {
			retval = r;
			if (retval == Result::OK) {
			*state = mute;
			}
			});
			return processReturn("getMicMute", ret, retval);
			}

			status_t DeviceHalHidl::setMasterMute(bool state) {
			if (mDevice == 0) return NO_INIT;
			return processReturn("setMasterMute", mDevice->setMasterMute(state));
			}

			status_t DeviceHalHidl::getMasterMute(bool *state) {
			if (mDevice == 0) return NO_INIT;
			Result retval;
			Return<void> ret = mDevice->getMasterMute(
			[&](Result r, bool mute) {
			retval = r;
			if (retval == Result::OK) {
			*state = mute;
			}
			});
			return processReturn("getMasterMute", ret, retval);
			}

			status_t DeviceHalHidl::setParameters(const String8& kvPairs) {
			if (mDevice == 0) return NO_INIT;
			hidl_vec<ParameterValue> hidlParams;
			status_t status = parametersFromHal(kvPairs, &hidlParams);
			if (status != OK) return status;
			// TODO: change the API so that context and kvPairs are separated
			return processReturn("setParameters",
			utils::setParameters(mDevice, {} /* context */, hidlParams));
			}

			status_t DeviceHalHidl::getParameters(const String8& keys, String8 *values) {
			values->clear();
			if (mDevice == 0) return NO_INIT;
			hidl_vec<hidl_string> hidlKeys;
			status_t status = keysFromHal(keys, &hidlKeys);
			if (status != OK) return status;
			Result retval;
			Return<void> ret = utils::getParameters(mDevice,
			{} /* context */,
			hidlKeys,
			[&](Result r, const hidl_vec<ParameterValue>& parameters) {
			retval = r;
			if (retval == Result::OK) {
			parametersToHal(parameters, values);
			}
			});
			return processReturn("getParameters", ret, retval);
			}

			status_t DeviceHalHidl::getInputBufferSize(
			const struct audio_config config, size_t size) {
			if (mDevice == 0) return NO_INIT;
			AudioConfig hidlConfig;
			HidlUtils::audioConfigFromHal(*config, &hidlConfig);
			Result retval;
			Return<void> ret = mDevice->getInputBufferSize(
			hidlConfig,
			[&](Result r, uint64_t bufferSize) {
			retval = r;
			if (retval == Result::OK) {
			*size = static_cast<size_t>(bufferSize);
			}
			});
			return processReturn("getInputBufferSize", ret, retval);
			}

			status_t DeviceHalHidl::openOutputStream(
			audio_io_handle_t handle,
			audio_devices_t devices,
			audio_output_flags_t flags,
			struct audio_config *config,
			const char *address,
			sp<StreamOutHalInterface> *outStream) {
			if (mDevice == 0) return NO_INIT;
			DeviceAddress hidlDevice;
			status_t status = deviceAddressFromHal(devices, address, &hidlDevice);
			if (status != OK) return status;
			AudioConfig hidlConfig;
			HidlUtils::audioConfigFromHal(*config, &hidlConfig);
			Result retval = Result::NOT_INITIALIZED;
			Return<void> ret = mDevice->openOutputStream(
			handle,
			hidlDevice,
			hidlConfig,
			mkEnumConverter<AudioOutputFlag>(flags),
			{} /* metadata */,
			[&](Result r, const sp<IStreamOut>& result, const AudioConfig& suggestedConfig) {
			retval = r;
			if (retval == Result::OK) {
			*outStream = new StreamOutHalHidl(result);
			}
			HidlUtils::audioConfigToHal(suggestedConfig, config);
			});
			return processReturn("openOutputStream", ret, retval);
			}

			status_t DeviceHalHidl::openInputStream(
			audio_io_handle_t handle,
			audio_devices_t devices,
			struct audio_config *config,
			audio_input_flags_t flags,
			const char *address,
			audio_source_t source,
			sp<StreamInHalInterface> *inStream) {
			if (mDevice == 0) return NO_INIT;
			DeviceAddress hidlDevice;
			status_t status = deviceAddressFromHal(devices, address, &hidlDevice);
			if (status != OK) return status;
			AudioConfig hidlConfig;
			HidlUtils::audioConfigFromHal(*config, &hidlConfig);
			Result retval = Result::NOT_INITIALIZED;
			// TODO: correctly propagate the tracks sources and volume
			// for now, only send the main source at 1dbfs
			SinkMetadata metadata = {{{AudioSource(source), 1}}};
			Return<void> ret = mDevice->openInputStream(
			handle,
			hidlDevice,
			hidlConfig,
			flags,
			metadata,
			[&](Result r, const sp<IStreamIn>& result, const AudioConfig& suggestedConfig) {
			retval = r;
			if (retval == Result::OK) {
			*inStream = new StreamInHalHidl(result);
			}
			HidlUtils::audioConfigToHal(suggestedConfig, config);
			});
			return processReturn("openInputStream", ret, retval);
			}

			status_t DeviceHalHidl::supportsAudioPatches(bool *supportsPatches) {
			if (mDevice == 0) return NO_INIT;
			return processReturn("supportsAudioPatches", mDevice->supportsAudioPatches(), supportsPatches);
			}

			status_t DeviceHalHidl::createAudioPatch(
			unsigned int num_sources,
			const struct audio_port_config *sources,
			unsigned int num_sinks,
			const struct audio_port_config *sinks,
			audio_patch_handle_t *patch) {
			if (mDevice == 0) return NO_INIT;
			hidl_vec<AudioPortConfig> hidlSources, hidlSinks;
			HidlUtils::audioPortConfigsFromHal(num_sources, sources, &hidlSources);
			HidlUtils::audioPortConfigsFromHal(num_sinks, sinks, &hidlSinks);
			Result retval;
			Return<void> ret = mDevice->createAudioPatch(
			hidlSources, hidlSinks,
			[&](Result r, AudioPatchHandle hidlPatch) {
			retval = r;
			if (retval == Result::OK) {
			*patch = static_cast<audio_patch_handle_t>(hidlPatch);
			}
			});
			return processReturn("createAudioPatch", ret, retval);
			}

			status_t DeviceHalHidl::releaseAudioPatch(audio_patch_handle_t patch) {
			if (mDevice == 0) return NO_INIT;
			return processReturn("releaseAudioPatch", mDevice->releaseAudioPatch(patch));
			}

			status_t DeviceHalHidl::getAudioPort(struct audio_port *port) {
			if (mDevice == 0) return NO_INIT;
			AudioPort hidlPort;
			HidlUtils::audioPortFromHal(*port, &hidlPort);
			Result retval;
			Return<void> ret = mDevice->getAudioPort(
			hidlPort,
			[&](Result r, const AudioPort& p) {
			retval = r;
			if (retval == Result::OK) {
			HidlUtils::audioPortToHal(p, port);
			}
			});
			return processReturn("getAudioPort", ret, retval);
			}

			status_t DeviceHalHidl::setAudioPortConfig(const struct audio_port_config *config) {
			if (mDevice == 0) return NO_INIT;
			AudioPortConfig hidlConfig;
			HidlUtils::audioPortConfigFromHal(*config, &hidlConfig);
			return processReturn("setAudioPortConfig", mDevice->setAudioPortConfig(hidlConfig));
			}

			status_t DeviceHalHidl::dump(int fd) {
			if (mDevice == 0) return NO_INIT;
			native_handle_t* hidlHandle = native_handle_create(1, 0);
			hidlHandle->data[0] = fd;
			Return<void> ret = mDevice->debug(hidlHandle, {} /* options */);
			native_handle_delete(hidlHandle);
			return processReturn("dump", ret);
			}

			} // namespace V4_0
			} // namespace android

media/libaudiohal/4.0/DeviceHalHidl.h

0 → 100644

+128 −0

File added.

Preview size limit exceeded, changes collapsed.