Remove local and hybrid HALs (50e93468) · Commits · e / os / android_frameworks_av

media/libaudiohal/impl/Android.bp

+0 −4

Original line number	Diff line number	Diff line
		@@ -10,12 +10,8 @@ package {
		filegroup {
		name: "audio_core_hal_client_sources",
		srcs: [
		"DeviceHalLocal.cpp",
		"DevicesFactoryHalHybrid.cpp",
		"DevicesFactoryHalLocal.cpp",
		"DeviceHalHidl.cpp",
		"DevicesFactoryHalHidl.cpp",
		"StreamHalLocal.cpp",
		"StreamHalHidl.cpp",
		],
		}

media/libaudiohal/impl/DeviceHalLocal.cpp

deleted100644 → 0

+0 −256

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 <media/AudioParameter.h>
		#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 deviceType,
		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, deviceType, flags,
		config->sample_rate, config->format, config->channel_mask,
		address);
		int openResut = mDev->open_output_stream(
		mDev, handle, deviceType, 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,
		audio_devices_t /outputDevice/,
		const char /outputDeviceAddress*/,
		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::getAudioPort(struct audio_port_v7 *port) {
		#if MAJOR_VERSION >= 7
		if (version() >= AUDIO_DEVICE_API_VERSION_3_2) {
		// get_audio_port_v7 is mandatory if legacy HAL support this API version.
		return mDev->get_audio_port_v7(mDev, port);
		}
		#endif
		struct audio_port audioPort = {};
		audio_populate_audio_port(port, &audioPort);
		status_t status = getAudioPort(&audioPort);
		if (status == NO_ERROR) {
		audio_populate_audio_port_v7(&audioPort, port);
		}
		return status;
		}

		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;
		}

		#if MAJOR_VERSION == 2
		status_t DeviceHalLocal::getMicrophones(
		std::vector<media::MicrophoneInfo> *microphones __unused) {
		return INVALID_OPERATION;
		}
		#elif MAJOR_VERSION >= 4
		status_t DeviceHalLocal::getMicrophones(std::vector<media::MicrophoneInfo> *microphones) {
		if (mDev->get_microphones == NULL) return INVALID_OPERATION;
		size_t actual_mics = AUDIO_MICROPHONE_MAX_COUNT;
		audio_microphone_characteristic_t mic_array[AUDIO_MICROPHONE_MAX_COUNT];
		status_t status = mDev->get_microphones(mDev, &mic_array[0], &actual_mics);
		for (size_t i = 0; i < actual_mics; i++) {
		media::MicrophoneInfo microphoneInfo = media::MicrophoneInfo(mic_array[i]);
		microphones->push_back(microphoneInfo);
		}
		return status;
		}
		#endif

		// Local HAL implementation does not support effects
		status_t DeviceHalLocal::addDeviceEffect(
		audio_port_handle_t device __unused, sp<EffectHalInterface> effect __unused) {
		return INVALID_OPERATION;
		}

		status_t DeviceHalLocal::removeDeviceEffect(
		audio_port_handle_t device __unused, sp<EffectHalInterface> effect __unused) {
		return INVALID_OPERATION;
		}

		status_t DeviceHalLocal::setConnectedState(const struct audio_port_v7 *port, bool connected) {
		AudioParameter param(String8(port->ext.device.address));
		const String8 key(connected ?
		AudioParameter::keyDeviceConnect : AudioParameter::keyDeviceDisconnect);
		param.addInt(key, port->ext.device.type);
		return setParameters(param.toString());
		}

		status_t DeviceHalLocal::dump(int fd, const Vector<String16>& /* args */) {
		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/impl/DeviceHalLocal.h

deleted100644 → 0

+0 −154

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.
		*/

		#ifndef ANDROID_HARDWARE_DEVICE_HAL_LOCAL_H
		#define ANDROID_HARDWARE_DEVICE_HAL_LOCAL_H

		#include <hardware/audio.h>
		#include <media/audiohal/DeviceHalInterface.h>

		namespace android {

		class DeviceHalLocal : public DeviceHalInterface
		{
		public:
		// Sets the value of 'devices' to a bitmask of 1 or more values of audio_devices_t.
		virtual status_t getSupportedDevices(uint32_t *devices);

		// Check to see if the audio hardware interface has been initialized.
		virtual status_t initCheck();

		// Set the audio volume of a voice call. Range is between 0.0 and 1.0.
		virtual status_t setVoiceVolume(float volume);

		// Set the audio volume for all audio activities other than voice call.
		virtual status_t setMasterVolume(float volume);

		// Get the current master volume value for the HAL.
		virtual status_t getMasterVolume(float *volume);

		// Called when the audio mode changes.
		virtual status_t setMode(audio_mode_t mode);

		// Muting control.
		virtual status_t setMicMute(bool state);
		virtual status_t getMicMute(bool *state);
		virtual status_t setMasterMute(bool state);
		virtual status_t getMasterMute(bool *state);

		// Set global audio parameters.
		virtual status_t setParameters(const String8& kvPairs);

		// Get global audio parameters.
		virtual status_t getParameters(const String8& keys, String8 *values);

		// Returns audio input buffer size according to parameters passed.
		virtual status_t getInputBufferSize(const struct audio_config *config,
		size_t *size);

		// Creates and opens the audio hardware output stream. The stream is closed
		// by releasing all references to the returned object.
		virtual status_t 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);

		// Creates and opens the audio hardware input stream. The stream is closed
		// by releasing all references to the returned object.
		virtual status_t 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,
		audio_devices_t outputDevice,
		const char *outputDeviceAddress,
		sp<StreamInHalInterface> *inStream);

		// Returns whether createAudioPatch and releaseAudioPatch operations are supported.
		virtual status_t supportsAudioPatches(bool *supportsPatches);

		// Creates an audio patch between several source and sink ports.
		virtual status_t 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);

		// Releases an audio patch.
		virtual status_t releaseAudioPatch(audio_patch_handle_t patch);

		// Fills the list of supported attributes for a given audio port.
		virtual status_t getAudioPort(struct audio_port *port);

		// Fills the list of supported attributes for a given audio port.
		virtual status_t getAudioPort(struct audio_port_v7 *port);

		// Set audio port configuration.
		virtual status_t setAudioPortConfig(const struct audio_port_config *config);

		// List microphones
		virtual status_t getMicrophones(std::vector<media::MicrophoneInfo> *microphones);

		status_t addDeviceEffect(audio_port_handle_t device, sp<EffectHalInterface> effect) override;
		status_t removeDeviceEffect(audio_port_handle_t device, sp<EffectHalInterface> effect) override;

		status_t getMmapPolicyInfos(
		media::audio::common::AudioMMapPolicyType policyType __unused,
		std::vector<media::audio::common::AudioMMapPolicyInfo> *policyInfos __unused) override {
		// This function will only be available on AIDL HAL.
		return INVALID_OPERATION;
		}

		int32_t getAAudioMixerBurstCount() override {
		// This function will only be available on AIDL HAL.
		return INVALID_OPERATION;
		}

		int32_t getAAudioHardwareBurstMinUsec() override {
		// This function will only be available on AIDL HAL.
		return INVALID_OPERATION;
		}

		status_t setConnectedState(const struct audio_port_v7 *port, bool connected) override;

		status_t dump(int fd, const Vector<String16>& args) override;

		void closeOutputStream(struct audio_stream_out *stream_out);
		void closeInputStream(struct audio_stream_in *stream_in);

		uint32_t version() const { return mDev->common.version; }

		private:
		audio_hw_device_t *mDev;

		friend class DevicesFactoryHalLocal;

		// Can not be constructed directly by clients.
		explicit DeviceHalLocal(audio_hw_device_t *dev);

		// The destructor automatically closes the device.
		virtual ~DeviceHalLocal();
		};

		} // namespace android

		#endif // ANDROID_HARDWARE_DEVICE_HAL_LOCAL_H

media/libaudiohal/impl/DevicesFactoryHalHidl.cpp

+6 −0

Original line number	Diff line number	Diff line
		@@ -227,4 +227,10 @@ std::vector<sp<::android::hardware::audio::CPP_VERSION::IDevicesFactory>>
		return mDeviceFactories;
		}

		// Main entry-point to the shared library.
		extern "C" __attribute__((visibility("default"))) void* createIDevicesFactory() {
		auto service = hardware::audio::CPP_VERSION::IDevicesFactory::getService();
		return service ? new DevicesFactoryHalHidl(service) : nullptr;
		}

		} // namespace android

media/libaudiohal/impl/DevicesFactoryHalHybrid.cpp

deleted100644 → 0

+0 −58

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2017 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 "DevicesFactoryHalHybrid"
		//#define LOG_NDEBUG 0

		#include "DevicesFactoryHalHidl.h"
		#include "DevicesFactoryHalHybrid.h"
		#include "DevicesFactoryHalLocal.h"

		namespace android {

		DevicesFactoryHalHybrid::DevicesFactoryHalHybrid(sp<IDevicesFactory> hidlFactory)
		: mLocalFactory(new DevicesFactoryHalLocal()),
		mHidlFactory(new DevicesFactoryHalHidl(hidlFactory)) {
		}

		status_t DevicesFactoryHalHybrid::openDevice(const char name, sp<DeviceHalInterface> device) {
		if (mHidlFactory != 0 && strcmp(AUDIO_HARDWARE_MODULE_ID_A2DP, name) != 0 &&
		strcmp(AUDIO_HARDWARE_MODULE_ID_HEARING_AID, name) != 0) {
		return mHidlFactory->openDevice(name, device);
		}
		return mLocalFactory->openDevice(name, device);
		}

		status_t DevicesFactoryHalHybrid::getHalPids(std::vector<pid_t> *pids) {
		if (mHidlFactory != 0) {
		return mHidlFactory->getHalPids(pids);
		}
		return INVALID_OPERATION;
		}

		status_t DevicesFactoryHalHybrid::setCallbackOnce(sp<DevicesFactoryHalCallback> callback) {
		if (mHidlFactory) {
		return mHidlFactory->setCallbackOnce(callback);
		}
		return INVALID_OPERATION;
		}

		extern "C" __attribute__((visibility("default"))) void* createIDevicesFactory() {
		auto service = hardware::audio::CPP_VERSION::IDevicesFactory::getService();
		return service ? new DevicesFactoryHalHybrid(service) : nullptr;
		}

		} // namespace android