1 /*
2  * Copyright 2021 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #pragma once
18 
19 #include "../le_audio_software.h"
20 #include "audio_aidl_interfaces.h"
21 #include "bta/le_audio/le_audio_types.h"
22 #include "client_interface_aidl.h"
23 
24 namespace bluetooth {
25 namespace audio {
26 namespace aidl {
27 namespace le_audio {
28 
29 using ::aidl::android::hardware::bluetooth::audio::BroadcastCapability;
30 using ::aidl::android::hardware::bluetooth::audio::LeAudioBroadcastConfiguration;
31 using ::aidl::android::hardware::bluetooth::audio::LeAudioConfiguration;
32 using ::aidl::android::hardware::bluetooth::audio::PcmConfiguration;
33 using ::aidl::android::hardware::bluetooth::audio::SessionType;
34 using ::aidl::android::hardware::bluetooth::audio::UnicastCapability;
35 using ::bluetooth::audio::aidl::BluetoothAudioCtrlAck;
36 using ::bluetooth::audio::aidl::LatencyMode;
37 using ::bluetooth::audio::le_audio::StartRequestState;
38 using ::bluetooth::le_audio::DsaMode;
39 using ::bluetooth::le_audio::set_configurations::AudioSetConfiguration;
40 using ::bluetooth::le_audio::set_configurations::CodecConfigSetting;
41 
42 constexpr uint8_t kChannelNumberMono = 1;
43 constexpr uint8_t kChannelNumberStereo = 2;
44 
45 constexpr uint32_t kSampleRate48000 = 48000;
46 constexpr uint32_t kSampleRate44100 = 44100;
47 constexpr uint32_t kSampleRate32000 = 32000;
48 constexpr uint32_t kSampleRate24000 = 24000;
49 constexpr uint32_t kSampleRate16000 = 16000;
50 constexpr uint32_t kSampleRate8000 = 8000;
51 
52 constexpr uint8_t kBitsPerSample16 = 16;
53 constexpr uint8_t kBitsPerSample24 = 24;
54 constexpr uint8_t kBitsPerSample32 = 32;
55 
56 using ::bluetooth::audio::le_audio::StreamCallbacks;
57 
58 void flush_source();
59 bool hal_ucast_capability_to_stack_format(const UnicastCapability& ucast_capability,
60                                           CodecConfigSetting& stack_capability);
61 AudioConfiguration offload_config_to_hal_audio_config(
62         const ::bluetooth::le_audio::offload_config& offload_config);
63 AudioConfiguration broadcast_config_to_hal_audio_config(
64         const LeAudioBroadcastConfiguration& bcast_config);
65 
66 bluetooth::audio::le_audio::OffloadCapabilities get_offload_capabilities();
67 
68 class LeAudioTransport {
69 public:
70   LeAudioTransport(void (*flush)(void), StreamCallbacks stream_cb, PcmConfiguration pcm_config);
71   ~LeAudioTransport();
72 
73   BluetoothAudioCtrlAck StartRequest(bool is_low_latency);
74 
75   BluetoothAudioCtrlAck SuspendRequest();
76 
77   void StopRequest();
78 
79   void SetLatencyMode(LatencyMode latency_mode);
80 
81   bool GetPresentationPosition(uint64_t* remote_delay_report_ns, uint64_t* total_bytes_processed,
82                                timespec* data_position);
83 
84   void SourceMetadataChanged(const source_metadata_v7_t& source_metadata);
85 
86   void SinkMetadataChanged(const sink_metadata_v7_t& sink_metadata);
87 
88   void ResetPresentationPosition();
89 
90   void LogBytesProcessed(size_t bytes_processed);
91 
92   void SetRemoteDelay(uint16_t delay_report_ms);
93 
94   const PcmConfiguration& LeAudioGetSelectedHalPcmConfig();
95 
96   void LeAudioSetSelectedHalPcmConfig(uint32_t sample_rate_hz, uint8_t bit_rate,
97                                       uint8_t channels_count, uint32_t data_interval);
98 
99   void LeAudioSetBroadcastConfig(
100           const ::bluetooth::le_audio::broadcast_offload_config& offload_config);
101 
102   const LeAudioBroadcastConfiguration& LeAudioGetBroadcastConfig();
103 
104   bool IsRequestCompletedAfterUpdate(
105           const std::function<std::pair<StartRequestState, bool>(StartRequestState)>& lambda);
106   StartRequestState GetStartRequestState(void);
107   void ClearStartRequestState(void);
108   void SetStartRequestState(StartRequestState state);
109 
110 private:
111   void (*flush_)(void);
112   StreamCallbacks stream_cb_;
113   uint16_t remote_delay_report_ms_;
114   uint64_t total_bytes_processed_;
115   timespec data_position_;
116   PcmConfiguration pcm_config_;
117   LeAudioBroadcastConfiguration broadcast_config_;
118   mutable std::mutex start_request_state_mutex_;
119   std::atomic<StartRequestState> start_request_state_;
120   DsaMode dsa_mode_;
121   source_metadata_v7_t cached_source_metadata_;
122 };
123 
124 // Sink transport implementation for Le Audio
125 class LeAudioSinkTransport : public ::bluetooth::audio::aidl::IBluetoothSinkTransportInstance {
126 public:
127   LeAudioSinkTransport(SessionType session_type, StreamCallbacks stream_cb);
128 
129   ~LeAudioSinkTransport();
130 
131   BluetoothAudioCtrlAck StartRequest(bool is_low_latency);
132 
133   BluetoothAudioCtrlAck SuspendRequest() override;
134 
135   void StopRequest() override;
136 
137   void SetLatencyMode(LatencyMode latency_mode) override;
138 
139   bool GetPresentationPosition(uint64_t* remote_delay_report_ns, uint64_t* total_bytes_read,
140                                timespec* data_position) override;
141 
142   void SourceMetadataChanged(const source_metadata_v7_t& source_metadata) override;
143 
144   void SinkMetadataChanged(const sink_metadata_v7_t& sink_metadata) override;
145 
146   void ResetPresentationPosition() override;
147 
148   void LogBytesRead(size_t bytes_read) override;
149 
150   void SetRemoteDelay(uint16_t delay_report_ms);
151 
152   const PcmConfiguration& LeAudioGetSelectedHalPcmConfig();
153 
154   void LeAudioSetSelectedHalPcmConfig(uint32_t sample_rate_hz, uint8_t bit_rate,
155                                       uint8_t channels_count, uint32_t data_interval);
156 
157   void LeAudioSetBroadcastConfig(
158           const ::bluetooth::le_audio::broadcast_offload_config& offload_config);
159 
160   const LeAudioBroadcastConfiguration& LeAudioGetBroadcastConfig();
161 
162   bool IsRequestCompletedAfterUpdate(
163           const std::function<std::pair<StartRequestState, bool>(StartRequestState)>& lambda);
164   StartRequestState GetStartRequestState(void);
165   void ClearStartRequestState(void);
166   void SetStartRequestState(StartRequestState state);
167 
168   static inline LeAudioSinkTransport* instance_unicast_ = nullptr;
169   static inline LeAudioSinkTransport* instance_broadcast_ = nullptr;
170 
171   static inline BluetoothAudioSinkClientInterface* interface_unicast_ = nullptr;
172   static inline BluetoothAudioSinkClientInterface* interface_broadcast_ = nullptr;
173 
174 private:
175   LeAudioTransport* transport_;
176 };
177 
178 class LeAudioSourceTransport : public ::bluetooth::audio::aidl::IBluetoothSourceTransportInstance {
179 public:
180   LeAudioSourceTransport(SessionType session_type, StreamCallbacks stream_cb);
181 
182   ~LeAudioSourceTransport();
183 
184   BluetoothAudioCtrlAck StartRequest(bool is_low_latency);
185 
186   BluetoothAudioCtrlAck SuspendRequest() override;
187 
188   void StopRequest() override;
189 
190   void SetLatencyMode(LatencyMode latency_mode) override;
191 
192   bool GetPresentationPosition(uint64_t* remote_delay_report_ns, uint64_t* total_bytes_written,
193                                timespec* data_position) override;
194 
195   void SourceMetadataChanged(const source_metadata_v7_t& source_metadata) override;
196 
197   void SinkMetadataChanged(const sink_metadata_v7_t& sink_metadata) override;
198 
199   void ResetPresentationPosition() override;
200 
201   void LogBytesWritten(size_t bytes_written) override;
202 
203   void SetRemoteDelay(uint16_t delay_report_ms);
204 
205   const PcmConfiguration& LeAudioGetSelectedHalPcmConfig();
206 
207   void LeAudioSetSelectedHalPcmConfig(uint32_t sample_rate_hz, uint8_t bit_rate,
208                                       uint8_t channels_count, uint32_t data_interval);
209 
210   bool IsRequestCompletedAfterUpdate(
211           const std::function<std::pair<StartRequestState, bool>(StartRequestState)>& lambda);
212 
213   StartRequestState GetStartRequestState(void);
214   void ClearStartRequestState(void);
215   void SetStartRequestState(StartRequestState state);
216 
217   static inline LeAudioSourceTransport* instance = nullptr;
218   static inline BluetoothAudioSourceClientInterface* interface = nullptr;
219 
220 private:
221   LeAudioTransport* transport_;
222 };
223 
224 }  // namespace le_audio
225 }  // namespace aidl
226 }  // namespace audio
227 }  // namespace bluetooth
228