Merge changes I750f5d18,If517cc3f (250300e6) · Commits · e / os / android_frameworks_av

media/libaudiohal/2.0/Android.bp

deleted100644 → 0

+0 −54

Original line number	Diff line number	Diff line
		cc_library_shared {
		name: "libaudiohal@2.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: ["."],

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

		export_shared_lib_headers: [
		"libfmq",
		],
		}

media/libaudiohal/2.0/ConversionHelperHidl.cpp

deleted100644 → 0

+0 −103

Original line number	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::V2_0::Result;

		namespace android {

		// 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 android

media/libaudiohal/2.0/DeviceHalHidl.cpp

deleted100644 → 0

+0 −364

Original line number	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/2.0/IPrimaryDevice.h>
		#include <cutils/native_handle.h>
		#include <hwbinder/IPCThreadState.h>
		#include <utils/Log.h>

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

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

		namespace android {

		namespace {

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

		if (halAddress == 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;
		return processReturn("setParameters", mDevice->setParameters(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 = mDevice->getParameters(
		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,
		AudioOutputFlag(flags),
		[&](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;
		Return<void> ret = mDevice->openInputStream(
		handle,
		hidlDevice,
		hidlConfig,
		AudioInputFlag(flags),
		AudioSource(source),
		[&](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::getMicrophones(
		std::vector<media::MicrophoneInfo> *microphonesInfo __unused) {
		if (mDevice == 0) return NO_INIT;
		return INVALID_OPERATION;
		}

		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->debugDump(hidlHandle);
		native_handle_delete(hidlHandle);
		return processReturn("dump", ret);
		}

		} // namespace android

media/libaudiohal/2.0/DeviceHalLocal.cpp

deleted100644 → 0

+0 −204

Original line number	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.
		*/

		#define LOG_TAG "DeviceHalLocal"
		//#define LOG_NDEBUG 0

		#include <utils/Log.h>

		#include "DeviceHalLocal.h"
		#include "StreamHalLocal.h"

		namespace android {

		DeviceHalLocal::DeviceHalLocal(audio_hw_device_t *dev)
		: mDev(dev) {
		}

		DeviceHalLocal::~DeviceHalLocal() {
		int status = audio_hw_device_close(mDev);
		ALOGW_IF(status, "Error closing audio hw device %p: %s", mDev, strerror(-status));
		mDev = 0;
		}

		status_t DeviceHalLocal::getSupportedDevices(uint32_t *devices) {
		if (mDev->get_supported_devices == NULL) return INVALID_OPERATION;
		*devices = mDev->get_supported_devices(mDev);
		return OK;
		}

		status_t DeviceHalLocal::initCheck() {
		return mDev->init_check(mDev);
		}

		status_t DeviceHalLocal::setVoiceVolume(float volume) {
		return mDev->set_voice_volume(mDev, volume);
		}

		status_t DeviceHalLocal::setMasterVolume(float volume) {
		if (mDev->set_master_volume == NULL) return INVALID_OPERATION;
		return mDev->set_master_volume(mDev, volume);
		}

		status_t DeviceHalLocal::getMasterVolume(float *volume) {
		if (mDev->get_master_volume == NULL) return INVALID_OPERATION;
		return mDev->get_master_volume(mDev, volume);
		}

		status_t DeviceHalLocal::setMode(audio_mode_t mode) {
		return mDev->set_mode(mDev, mode);
		}

		status_t DeviceHalLocal::setMicMute(bool state) {
		return mDev->set_mic_mute(mDev, state);
		}

		status_t DeviceHalLocal::getMicMute(bool *state) {
		return mDev->get_mic_mute(mDev, state);
		}

		status_t DeviceHalLocal::setMasterMute(bool state) {
		if (mDev->set_master_mute == NULL) return INVALID_OPERATION;
		return mDev->set_master_mute(mDev, state);
		}

		status_t DeviceHalLocal::getMasterMute(bool *state) {
		if (mDev->get_master_mute == NULL) return INVALID_OPERATION;
		return mDev->get_master_mute(mDev, state);
		}

		status_t DeviceHalLocal::setParameters(const String8& kvPairs) {
		return mDev->set_parameters(mDev, kvPairs.string());
		}

		status_t DeviceHalLocal::getParameters(const String8& keys, String8 *values) {
		char *halValues = mDev->get_parameters(mDev, keys.string());
		if (halValues != NULL) {
		values->setTo(halValues);
		free(halValues);
		} else {
		values->clear();
		}
		return OK;
		}

		status_t DeviceHalLocal::getInputBufferSize(
		const struct audio_config config, size_t size) {
		*size = mDev->get_input_buffer_size(mDev, config);
		return OK;
		}

		status_t DeviceHalLocal::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) {
		audio_stream_out_t *halStream;
		ALOGV("open_output_stream handle: %d devices: %x flags: %#x"
		"srate: %d format %#x channels %x address %s",
		handle, devices, flags,
		config->sample_rate, config->format, config->channel_mask,
		address);
		int openResut = mDev->open_output_stream(
		mDev, handle, devices, flags, config, &halStream, address);
		if (openResut == OK) {
		*outStream = new StreamOutHalLocal(halStream, this);
		}
		ALOGV("open_output_stream status %d stream %p", openResut, halStream);
		return openResut;
		}

		status_t DeviceHalLocal::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) {
		audio_stream_in_t *halStream;
		ALOGV("open_input_stream handle: %d devices: %x flags: %#x "
		"srate: %d format %#x channels %x address %s source %d",
		handle, devices, flags,
		config->sample_rate, config->format, config->channel_mask,
		address, source);
		int openResult = mDev->open_input_stream(
		mDev, handle, devices, config, &halStream, flags, address, source);
		if (openResult == OK) {
		*inStream = new StreamInHalLocal(halStream, this);
		}
		ALOGV("open_input_stream status %d stream %p", openResult, inStream);
		return openResult;
		}

		status_t DeviceHalLocal::supportsAudioPatches(bool *supportsPatches) {
		*supportsPatches = version() >= AUDIO_DEVICE_API_VERSION_3_0;
		return OK;
		}

		status_t DeviceHalLocal::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 (version() >= AUDIO_DEVICE_API_VERSION_3_0) {
		return mDev->create_audio_patch(
		mDev, num_sources, sources, num_sinks, sinks, patch);
		} else {
		return INVALID_OPERATION;
		}
		}

		status_t DeviceHalLocal::releaseAudioPatch(audio_patch_handle_t patch) {
		if (version() >= AUDIO_DEVICE_API_VERSION_3_0) {
		return mDev->release_audio_patch(mDev, patch);
		} else {
		return INVALID_OPERATION;
		}
		}

		status_t DeviceHalLocal::getAudioPort(struct audio_port *port) {
		return mDev->get_audio_port(mDev, port);
		}

		status_t DeviceHalLocal::setAudioPortConfig(const struct audio_port_config *config) {
		if (version() >= AUDIO_DEVICE_API_VERSION_3_0)
		return mDev->set_audio_port_config(mDev, config);
		else
		return INVALID_OPERATION;
		}

		status_t DeviceHalLocal::getMicrophones(
		std::vector<media::MicrophoneInfo> *microphones __unused) {
		return INVALID_OPERATION;
		}

		status_t DeviceHalLocal::dump(int fd) {
		return mDev->dump(mDev, fd);
		}

		void DeviceHalLocal::closeOutputStream(struct audio_stream_out *stream_out) {
		mDev->close_output_stream(mDev, stream_out);
		}

		void DeviceHalLocal::closeInputStream(struct audio_stream_in *stream_in) {
		mDev->close_input_stream(mDev, stream_in);
		}

		} // namespace android

media/libaudiohal/2.0/DevicesFactoryHalHidl.cpp

deleted100644 → 0

+0 −95

File deleted.

Preview size limit exceeded, changes collapsed.