Merge changes If33c6d0b,Id713f8e6,I4e91e96a am: 18b3bee627 am: 677f624bad am:... (84ab6bb1) · Commits · e / os / android_packages_modules_Bluetooth

system/audio_hal_interface/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -46,6 +46,7 @@ cc_library_static {
		srcs: [
		"a2dp_encoding_host.cc",
		"hearing_aid_software_encoding_host.cc",
		"le_audio_software_host.cc",
		],
		},
		},

system/audio_hal_interface/codec_status.cc

+4 −3

Original line number	Diff line number	Diff line
		@@ -46,7 +46,7 @@ using ::android::hardware::bluetooth::audio::V2_0::SbcChannelMode;
		using ::android::hardware::bluetooth::audio::V2_0::SbcNumSubbands;
		using ::android::hardware::bluetooth::audio::V2_0::SbcParameters;

		// capabilities from BluetoothAudioClientInterface::GetAudioCapabilities()
		// capabilities from BluetoothAudioSinkClientInterface::GetAudioCapabilities()
		std::vector<AudioCapabilities> audio_hal_capabilities(0);
		// capabilities that audio HAL supports and frameworks / Bluetooth SoC / runtime
		// preference would like to use.
		@@ -472,7 +472,8 @@ bool A2dpLdacToHalConfig(CodecConfiguration* codec_config,

		bool UpdateOffloadingCapabilities(
		const std::vector<btav_a2dp_codec_config_t>& framework_preference) {
		audio_hal_capabilities = BluetoothAudioClientInterface::GetAudioCapabilities(
		audio_hal_capabilities =
		BluetoothAudioSinkClientInterface::GetAudioCapabilities(
		SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH);
		uint32_t codec_type_masks = static_cast<uint32_t>(CodecType::UNKNOWN);
		for (auto preference : framework_preference) {

system/audio_hal_interface/codec_status.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -16,9 +16,9 @@

		#pragma once

		#include <vector>
		#include <android/hardware/bluetooth/audio/2.1/types.h>

		#include <android/hardware/bluetooth/audio/2.0/types.h>
		#include <vector>

		#include "a2dp_codec_api.h"

system/audio_hal_interface/le_audio_software.cc

+107 −6

Original line number	Diff line number	Diff line
		@@ -58,13 +58,25 @@ class LeAudioTransport {
		remote_delay_report_ms_(0),
		total_bytes_processed_(0),
		data_position_({}),
		pcm_config_(std::move(pcm_config)){};
		pcm_config_(std::move(pcm_config)),
		is_pending_start_request_(false){};

		BluetoothAudioCtrlAck StartRequest() {
		LOG(INFO) << __func__;

		/*
		* Set successful state as initial, it may be overwritten with cancelation
		* during on_resume handling
		*/
		pending_start_request_state_ = BluetoothAudioCtrlAck::PENDING;

		if (stream_cb_.on_resume_(true)) {
		return BluetoothAudioCtrlAck::SUCCESS_FINISHED;
		if (pending_start_request_state_ == BluetoothAudioCtrlAck::PENDING)
		is_pending_start_request_ = true;

		return pending_start_request_state_;
		}

		return BluetoothAudioCtrlAck::FAILURE;
		}

		@@ -106,6 +118,22 @@ class LeAudioTransport {
		auto track_count = source_metadata.track_count;
		auto tracks = source_metadata.tracks;
		LOG(INFO) << __func__ << ": " << track_count << " track(s) received";

		if (track_count == 0) {
		LOG(WARNING) << ", invalid number of metadata changed tracks";
		return;
		}

		audio_usage_t usage = tracks->usage;
		audio_content_type_t content_type = tracks->content_type;

		/* TODO what stack should do with more than one track ? */
		if (track_count > 1) {
		LOG(WARNING) << __func__ << ", can't handle multiple tracks metadata, "
		<< "count: " << track_count << " track(s) received";
		return;
		}

		while (track_count) {
		VLOG(1) << __func__ << ": usage=" << tracks->usage
		<< ", content_type=" << tracks->content_type
		@@ -113,6 +141,8 @@ class LeAudioTransport {
		--track_count;
		++tracks;
		}

		stream_cb_.on_metadata_update_(usage, content_type);
		}

		void ResetPresentationPosition() {
		@@ -146,6 +176,15 @@ class LeAudioTransport {
		pcm_config_.dataIntervalUs = data_interval;
		}

		bool SetAudioCtrlAckStateAndResetPendingStartStreamFlag(
		BluetoothAudioCtrlAck state) {
		bool ret = is_pending_start_request_;
		is_pending_start_request_ = false;
		pending_start_request_state_ = state;

		return ret;
		}

		private:
		void (*flush_)(void);
		StreamCallbacks stream_cb_;
		@@ -153,6 +192,8 @@ class LeAudioTransport {
		uint64_t total_bytes_processed_;
		timespec data_position_;
		PcmParameters pcm_config_;
		bool is_pending_start_request_;
		BluetoothAudioCtrlAck pending_start_request_state_;
		};

		static void flush_sink() {
		@@ -221,6 +262,12 @@ class LeAudioSinkTransport
		channel_mode, data_interval);
		}

		bool SetAudioCtrlAckStateAndResetPendingStartStreamFlag(
		BluetoothAudioCtrlAck state = BluetoothAudioCtrlAck::PENDING) {
		return transport_->SetAudioCtrlAckStateAndResetPendingStartStreamFlag(
		state);
		}

		private:
		LeAudioTransport* transport_;
		};
		@@ -290,6 +337,12 @@ class LeAudioSourceTransport
		channel_mode, data_interval);
		}

		bool SetAudioCtrlAckStateAndResetPendingStartStreamFlag(
		BluetoothAudioCtrlAck state = BluetoothAudioCtrlAck::PENDING) {
		return transport_->SetAudioCtrlAckStateAndResetPendingStartStreamFlag(
		state);
		}

		private:
		LeAudioTransport* transport_;
		};
		@@ -365,7 +418,7 @@ static ChannelMode le_audio_channel_mode2audio_hal(uint8_t channels_count) {
		}

		void LeAudioClientInterface::Sink::Cleanup() {
		LOG(INFO) << __func__;
		LOG(INFO) << __func__ << " sink";
		StopSession();
		delete le_audio_sink_hal_clientinterface;
		le_audio_sink_hal_clientinterface = nullptr;
		@@ -399,8 +452,32 @@ void LeAudioClientInterface::Sink::StartSession() {
		le_audio_sink_hal_clientinterface->StartSession_2_1();
		}

		void LeAudioClientInterface::Sink::StopSession() {
		void LeAudioClientInterface::Sink::ConfirmStreamingRequest() {
		LOG(INFO) << __func__;
		if (!le_audio_sink->SetAudioCtrlAckStateAndResetPendingStartStreamFlag()) {
		LOG(WARNING) << ", no pending start stream request";
		return;
		}

		le_audio_sink_hal_clientinterface->StreamStarted(
		BluetoothAudioCtrlAck::SUCCESS_FINISHED);
		}

		void LeAudioClientInterface::Sink::CancelStreamingRequest() {
		LOG(INFO) << __func__;
		if (!le_audio_sink->SetAudioCtrlAckStateAndResetPendingStartStreamFlag(
		BluetoothAudioCtrlAck::FAILURE)) {
		LOG(WARNING) << ", no pending start stream request";
		return;
		}

		le_audio_sink_hal_clientinterface->StreamStarted(
		BluetoothAudioCtrlAck::FAILURE);
		}

		void LeAudioClientInterface::Sink::StopSession() {
		LOG(INFO) << __func__ << " sink";
		le_audio_sink->SetAudioCtrlAckStateAndResetPendingStartStreamFlag();
		le_audio_sink_hal_clientinterface->EndSession();
		}

		@@ -409,7 +486,7 @@ size_t LeAudioClientInterface::Sink::Read(uint8_t* p_buf, uint32_t len) {
		}

		void LeAudioClientInterface::Source::Cleanup() {
		LOG(INFO) << __func__;
		LOG(INFO) << __func__ << " source";
		StopSession();
		delete le_audio_source_hal_clientinterface;
		le_audio_source_hal_clientinterface = nullptr;
		@@ -444,8 +521,32 @@ void LeAudioClientInterface::Source::StartSession() {
		le_audio_source_hal_clientinterface->StartSession_2_1();
		}

		void LeAudioClientInterface::Source::StopSession() {
		void LeAudioClientInterface::Source::ConfirmStreamingRequest() {
		LOG(INFO) << __func__;
		if (!le_audio_source->SetAudioCtrlAckStateAndResetPendingStartStreamFlag()) {
		LOG(WARNING) << ", no pending start stream request";
		return;
		}

		le_audio_source_hal_clientinterface->StreamStarted(
		BluetoothAudioCtrlAck::SUCCESS_FINISHED);
		}

		void LeAudioClientInterface::Source::CancelStreamingRequest() {
		LOG(INFO) << __func__;
		if (!le_audio_source->SetAudioCtrlAckStateAndResetPendingStartStreamFlag(
		BluetoothAudioCtrlAck::FAILURE)) {
		LOG(WARNING) << ", no pending start stream request";
		return;
		}

		le_audio_source_hal_clientinterface->StreamStarted(
		BluetoothAudioCtrlAck::FAILURE);
		}

		void LeAudioClientInterface::Source::StopSession() {
		LOG(INFO) << __func__ << " source";
		le_audio_source->SetAudioCtrlAckStateAndResetPendingStartStreamFlag();
		le_audio_source_hal_clientinterface->EndSession();
		}

system/audio_hal_interface/le_audio_software.h

+23 −0

Original line number	Diff line number	Diff line
		@@ -16,6 +16,8 @@

		#pragma once

		#include <hardware/audio.h>

		#include <functional>

		#include "common/message_loop_thread.h"
		@@ -24,9 +26,24 @@ namespace bluetooth {
		namespace audio {
		namespace le_audio {

		constexpr uint8_t kChannelNumberMono = 1;
		constexpr uint8_t kChannelNumberStereo = 2;

		constexpr uint32_t kSampleRate48000 = 48000;
		constexpr uint32_t kSampleRate44100 = 44100;
		constexpr uint32_t kSampleRate32000 = 32000;
		constexpr uint32_t kSampleRate24000 = 24000;
		constexpr uint32_t kSampleRate16000 = 16000;
		constexpr uint32_t kSampleRate8000 = 8000;

		constexpr uint8_t kBitsPerSample16 = 16;
		constexpr uint8_t kBitsPerSample24 = 24;
		constexpr uint8_t kBitsPerSample32 = 32;

		struct StreamCallbacks {
		std::function<bool(bool start_media_task)> on_resume_;
		std::function<bool(void)> on_suspend_;
		std::function<bool(audio_usage_t, audio_content_type_t)> on_metadata_update_;
		};

		class LeAudioClientInterface {
		@@ -47,6 +64,8 @@ class LeAudioClientInterface {
		virtual void SetRemoteDelay(uint16_t delay_report_ms) = 0;
		virtual void StartSession() = 0;
		virtual void StopSession() = 0;
		virtual void ConfirmStreamingRequest() = 0;
		virtual void CancelStreamingRequest() = 0;
		};

		public:
		@@ -59,6 +78,8 @@ class LeAudioClientInterface {
		void SetRemoteDelay(uint16_t delay_report_ms) override;
		void StartSession() override;
		void StopSession() override;
		void ConfirmStreamingRequest() override;
		void CancelStreamingRequest() override;

		// Read the stream of bytes sinked to us by the upper layers
		size_t Read(uint8_t* p_buf, uint32_t len);
		@@ -72,6 +93,8 @@ class LeAudioClientInterface {
		void SetRemoteDelay(uint16_t delay_report_ms) override;
		void StartSession() override;
		void StopSession() override;
		void ConfirmStreamingRequest() override;
		void CancelStreamingRequest() override;

		// Source the given stream of bytes to be sinked into the upper layers
		size_t Write(const uint8_t* p_buf, uint32_t len);