Implementation of Bluetooth Audio HAL interface v2 (a0cb02ea) · Commits · e / os / android_hardware_interfaces

bluetooth/audio/2.0/default/A2dpOffloadAudioProvider.cpp

0 → 100644

+89 −0

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

		#define LOG_TAG "BTAudioProviderA2dpOffload"

		#include <android-base/logging.h>
		#include <fmq/MessageQueue.h>
		#include <hidl/MQDescriptor.h>

		#include "A2dpOffloadAudioProvider.h"
		#include "BluetoothAudioSessionReport.h"
		#include "BluetoothAudioSupportedCodecsDB.h"

		namespace android {
		namespace hardware {
		namespace bluetooth {
		namespace audio {
		namespace V2_0 {
		namespace implementation {

		using ::android::bluetooth::audio::BluetoothAudioSessionReport;
		using ::android::hardware::kSynchronizedReadWrite;
		using ::android::hardware::MessageQueue;
		using ::android::hardware::Void;

		using DataMQ = MessageQueue<uint8_t, kSynchronizedReadWrite>;

		A2dpOffloadAudioProvider::A2dpOffloadAudioProvider()
		: BluetoothAudioProvider() {
		session_type_ = SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH;
		}

		bool A2dpOffloadAudioProvider::isValid(const SessionType& sessionType) {
		return (sessionType == session_type_);
		}

		Return<void> A2dpOffloadAudioProvider::startSession(
		const sp<IBluetoothAudioPort>& hostIf,
		const AudioConfiguration& audioConfig, startSession_cb _hidl_cb) {
		/**
		* Initialize the audio platform if audioConfiguration is supported.
		* Save the the IBluetoothAudioPort interface, so that it can be used
		* later to send stream control commands to the HAL client, based on
		* interaction with Audio framework.
		*/
		if (audioConfig.getDiscriminator() !=
		AudioConfiguration::hidl_discriminator::codecConfig) {
		LOG(WARNING) << __func__
		<< " - Invalid Audio Configuration=" << toString(audioConfig);
		_hidl_cb(BluetoothAudioStatus::UNSUPPORTED_CODEC_CONFIGURATION,
		DataMQ::Descriptor());
		return Void();
		} else if (!android::bluetooth::audio::IsOffloadCodecConfigurationValid(
		session_type_, audioConfig.codecConfig())) {
		_hidl_cb(BluetoothAudioStatus::UNSUPPORTED_CODEC_CONFIGURATION,
		DataMQ::Descriptor());
		return Void();
		}

		return BluetoothAudioProvider::startSession(hostIf, audioConfig, _hidl_cb);
		}

		Return<void> A2dpOffloadAudioProvider::onSessionReady(
		startSession_cb _hidl_cb) {
		BluetoothAudioSessionReport::OnSessionStarted(session_type_, stack_iface_,
		nullptr, audio_config_);
		_hidl_cb(BluetoothAudioStatus::SUCCESS, DataMQ::Descriptor());
		return Void();
		}

		} // namespace implementation
		} // namespace V2_0
		} // namespace audio
		} // namespace bluetooth
		} // namespace hardware
		} // namespace android

bluetooth/audio/2.0/default/A2dpOffloadAudioProvider.h

0 → 100644

+47 −0

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

		#pragma once

		#include "BluetoothAudioProvider.h"

		namespace android {
		namespace hardware {
		namespace bluetooth {
		namespace audio {
		namespace V2_0 {
		namespace implementation {

		class A2dpOffloadAudioProvider : public BluetoothAudioProvider {
		public:
		A2dpOffloadAudioProvider();

		bool isValid(const SessionType& sessionType) override;

		Return<void> startSession(const sp<IBluetoothAudioPort>& hostIf,
		const AudioConfiguration& audioConfig,
		startSession_cb _hidl_cb) override;

		private:
		Return<void> onSessionReady(startSession_cb _hidl_cb) override;
		};

		} // namespace implementation
		} // namespace V2_0
		} // namespace audio
		} // namespace bluetooth
		} // namespace hardware
		} // namespace android

bluetooth/audio/2.0/default/A2dpSoftwareAudioProvider.cpp

0 → 100644

+107 −0

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

		#define LOG_TAG "BTAudioProviderA2dpSoftware"

		#include <android-base/logging.h>

		#include "A2dpSoftwareAudioProvider.h"
		#include "BluetoothAudioSessionReport.h"
		#include "BluetoothAudioSupportedCodecsDB.h"

		namespace android {
		namespace hardware {
		namespace bluetooth {
		namespace audio {
		namespace V2_0 {
		namespace implementation {

		using ::android::bluetooth::audio::BluetoothAudioSessionReport;
		using ::android::hardware::Void;

		static constexpr uint32_t kPcmFrameSize = 4; // 16 bits per sample / stereo
		static constexpr uint32_t kPcmFrameCount = 128;
		static constexpr uint32_t kRtpFrameSize = kPcmFrameSize * kPcmFrameCount;
		static constexpr uint32_t kRtpFrameCount = 7; // max counts by 1 tick (20ms)
		static constexpr uint32_t kBufferSize = kRtpFrameSize * kRtpFrameCount;
		static constexpr uint32_t kBufferCount = 2; // double buffer
		static constexpr uint32_t kDataMqSize = kBufferSize * kBufferCount;

		A2dpSoftwareAudioProvider::A2dpSoftwareAudioProvider()
		: BluetoothAudioProvider(), mDataMQ(nullptr) {
		LOG(INFO) << __func__ << " - size of audio buffer " << kDataMqSize
		<< " byte(s)";
		std::unique_ptr<DataMQ> tempDataMQ(
		new DataMQ(kDataMqSize, /* EventFlag */ true));
		if (tempDataMQ && tempDataMQ->isValid()) {
		mDataMQ = std::move(tempDataMQ);
		session_type_ = SessionType::A2DP_SOFTWARE_ENCODING_DATAPATH;
		} else {
		ALOGE_IF(!tempDataMQ, "failed to allocate data MQ");
		ALOGE_IF(tempDataMQ && !tempDataMQ->isValid(), "data MQ is invalid");
		}
		}

		bool A2dpSoftwareAudioProvider::isValid(const SessionType& sessionType) {
		return (sessionType == session_type_ && mDataMQ && mDataMQ->isValid());
		}

		Return<void> A2dpSoftwareAudioProvider::startSession(
		const sp<IBluetoothAudioPort>& hostIf,
		const AudioConfiguration& audioConfig, startSession_cb _hidl_cb) {
		/**
		* Initialize the audio platform if audioConfiguration is supported.
		* Save the the IBluetoothAudioPort interface, so that it can be used
		* later to send stream control commands to the HAL client, based on
		* interaction with Audio framework.
		*/
		if (audioConfig.getDiscriminator() !=
		AudioConfiguration::hidl_discriminator::pcmConfig) {
		LOG(WARNING) << __func__
		<< " - Invalid Audio Configuration=" << toString(audioConfig);
		_hidl_cb(BluetoothAudioStatus::UNSUPPORTED_CODEC_CONFIGURATION,
		DataMQ::Descriptor());
		return Void();
		} else if (!android::bluetooth::audio::IsSoftwarePcmConfigurationValid(
		audioConfig.pcmConfig())) {
		LOG(WARNING) << __func__ << " - Unsupported PCM Configuration="
		<< toString(audioConfig.pcmConfig());
		_hidl_cb(BluetoothAudioStatus::UNSUPPORTED_CODEC_CONFIGURATION,
		DataMQ::Descriptor());
		return Void();
		}

		return BluetoothAudioProvider::startSession(hostIf, audioConfig, _hidl_cb);
		}

		Return<void> A2dpSoftwareAudioProvider::onSessionReady(
		startSession_cb _hidl_cb) {
		if (mDataMQ && mDataMQ->isValid()) {
		BluetoothAudioSessionReport::OnSessionStarted(
		session_type_, stack_iface_, mDataMQ->getDesc(), audio_config_);
		_hidl_cb(BluetoothAudioStatus::SUCCESS, *mDataMQ->getDesc());
		} else {
		_hidl_cb(BluetoothAudioStatus::FAILURE, DataMQ::Descriptor());
		}
		return Void();
		}

		} // namespace implementation
		} // namespace V2_0
		} // namespace audio
		} // namespace bluetooth
		} // namespace hardware
		} // namespace android

bluetooth/audio/2.0/default/A2dpSoftwareAudioProvider.h

0 → 100644

+58 −0

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

		#pragma once

		#include <fmq/MessageQueue.h>
		#include <hidl/MQDescriptor.h>

		#include "BluetoothAudioProvider.h"

		namespace android {
		namespace hardware {
		namespace bluetooth {
		namespace audio {
		namespace V2_0 {
		namespace implementation {

		using ::android::hardware::kSynchronizedReadWrite;
		using ::android::hardware::MessageQueue;

		using DataMQ = MessageQueue<uint8_t, kSynchronizedReadWrite>;

		class A2dpSoftwareAudioProvider : public BluetoothAudioProvider {
		public:
		A2dpSoftwareAudioProvider();

		bool isValid(const SessionType& sessionType) override;

		Return<void> startSession(const sp<IBluetoothAudioPort>& hostIf,
		const AudioConfiguration& audioConfig,
		startSession_cb _hidl_cb) override;

		private:
		// audio data queue for software encoding
		std::unique_ptr<DataMQ> mDataMQ;

		Return<void> onSessionReady(startSession_cb _hidl_cb) override;
		};

		} // namespace implementation
		} // namespace V2_0
		} // namespace audio
		} // namespace bluetooth
		} // namespace hardware
		} // namespace android

bluetooth/audio/2.0/default/Android.bp

0 → 100644

+48 −0

Original line number	Diff line number	Diff line
		cc_library_shared {
		name: "android.hardware.bluetooth.audio@2.0-impl",
		defaults: ["hidl_defaults"],
		vendor: true,
		relative_install_path: "hw",
		srcs: [
		"BluetoothAudioProvidersFactory.cpp",
		"BluetoothAudioProvider.cpp",
		"A2dpOffloadAudioProvider.cpp",
		"A2dpSoftwareAudioProvider.cpp",
		"HearingAidAudioProvider.cpp",
		],
		header_libs: ["libhardware_headers"],
		shared_libs: [
		"android.hardware.audio.common@5.0",
		"android.hardware.bluetooth.audio@2.0",
		"libbase",
		"libbluetooth_audio_session",
		"libcutils",
		"libfmq",
		"libhidlbase",
		"libhidltransport",
		"liblog",
		"libutils",
		],
		}

		cc_library_shared {
		name: "libbluetooth_audio_session",
		defaults: ["hidl_defaults"],
		vendor: true,
		srcs: [
		"session/BluetoothAudioSession.cpp",
		"session/BluetoothAudioSupportedCodecsDB.cpp",
		],
		export_include_dirs: ["session/"],
		header_libs: ["libhardware_headers"],
		shared_libs: [
		"android.hardware.bluetooth.audio@2.0",
		"libbase",
		"libcutils",
		"libfmq",
		"libhidlbase",
		"libhidltransport",
		"liblog",
		"libutils",
		],
		}