1 /******************************************************************************
2 *
3 * Copyright 2016 The Android Open Source Project
4 * Copyright 2009-2012 Broadcom Corporation
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 ******************************************************************************/
19
20 #define LOG_TAG "bt_btif_a2dp_sink"
21
22 #include "btif/include/btif_a2dp_sink.h"
23
24 #include <base/functional/bind.h>
25 #include <base/logging.h>
26
27 #include <atomic>
28 #include <mutex>
29 #include <string>
30
31 #include "bt_target.h" // Must be first to define build configuration
32 #include "btif/include/btif_av.h"
33 #include "btif/include/btif_av_co.h"
34 #include "btif/include/btif_avrcp_audio_track.h"
35 #include "btif/include/btif_util.h" // CASE_RETURN_STR
36 #include "common/message_loop_thread.h"
37 #include "osi/include/alarm.h"
38 #include "osi/include/allocator.h"
39 #include "osi/include/fixed_queue.h"
40 #include "osi/include/log.h"
41 #include "osi/include/osi.h" // UNUSED_ATTR
42 #include "stack/include/bt_hdr.h"
43 #include "stack/include/bt_types.h"
44 #include "types/raw_address.h"
45
46 using bluetooth::common::MessageLoopThread;
47 using LockGuard = std::lock_guard<std::mutex>;
48
49 /**
50 * The receiving queue buffer size.
51 */
52 #define MAX_INPUT_A2DP_FRAME_QUEUE_SZ (MAX_PCM_FRAME_NUM_PER_TICK * 2)
53
54 #define BTIF_SINK_MEDIA_TIME_TICK_MS 20
55
56 /* In case of A2DP Sink, we will delay start by 5 AVDTP Packets */
57 #define MAX_A2DP_DELAYED_START_FRAME_COUNT 5
58
59 enum {
60 BTIF_A2DP_SINK_STATE_OFF,
61 BTIF_A2DP_SINK_STATE_STARTING_UP,
62 BTIF_A2DP_SINK_STATE_RUNNING,
63 BTIF_A2DP_SINK_STATE_SHUTTING_DOWN
64 };
65
66 /* BTIF Media Sink command event definition */
67 enum {
68 BTIF_MEDIA_SINK_DECODER_UPDATE = 1,
69 BTIF_MEDIA_SINK_CLEAR_TRACK,
70 BTIF_MEDIA_SINK_SET_FOCUS_STATE,
71 BTIF_MEDIA_SINK_AUDIO_RX_FLUSH,
72 BTIF_MEDIA_SINK_START,
73 BTIF_MEDIA_SINK_SUSPEND
74 };
75
76 typedef struct {
77 BT_HDR_RIGID hdr;
78 uint8_t codec_info[AVDT_CODEC_SIZE];
79 } tBTIF_MEDIA_SINK_DECODER_UPDATE;
80
81 typedef struct {
82 BT_HDR_RIGID hdr;
83 btif_a2dp_sink_focus_state_t focus_state;
84 } tBTIF_MEDIA_SINK_FOCUS_UPDATE;
85
86 /* BTIF A2DP Sink control block */
87 class BtifA2dpSinkControlBlock {
88 public:
BtifA2dpSinkControlBlock(const std::string & thread_name)89 explicit BtifA2dpSinkControlBlock(const std::string& thread_name)
90 : worker_thread(thread_name),
91 rx_audio_queue(nullptr),
92 rx_flush(false),
93 decode_alarm(nullptr),
94 sample_rate(0),
95 channel_count(0),
96 rx_focus_state(BTIF_A2DP_SINK_FOCUS_NOT_GRANTED),
97 audio_track(nullptr),
98 decoder_interface(nullptr) {}
99
Reset()100 void Reset() {
101 if (audio_track != nullptr) {
102 BtifAvrcpAudioTrackStop(audio_track);
103 BtifAvrcpAudioTrackDelete(audio_track);
104 }
105 audio_track = nullptr;
106 fixed_queue_free(rx_audio_queue, nullptr);
107 rx_audio_queue = nullptr;
108 alarm_free(decode_alarm);
109 decode_alarm = nullptr;
110 rx_flush = false;
111 rx_focus_state = BTIF_A2DP_SINK_FOCUS_NOT_GRANTED;
112 sample_rate = 0;
113 channel_count = 0;
114 decoder_interface = nullptr;
115 }
116
117 MessageLoopThread worker_thread;
118 fixed_queue_t* rx_audio_queue;
119 bool rx_flush; /* discards any incoming data when true */
120 alarm_t* decode_alarm;
121 tA2DP_SAMPLE_RATE sample_rate;
122 tA2DP_BITS_PER_SAMPLE bits_per_sample;
123 tA2DP_CHANNEL_COUNT channel_count;
124 btif_a2dp_sink_focus_state_t rx_focus_state; /* audio focus state */
125 void* audio_track;
126 const tA2DP_DECODER_INTERFACE* decoder_interface;
127 };
128
129 // Mutex for below data structures.
130 static std::mutex g_mutex;
131
132 static BtifA2dpSinkControlBlock btif_a2dp_sink_cb("bt_a2dp_sink_worker_thread");
133
134 static std::atomic<int> btif_a2dp_sink_state{BTIF_A2DP_SINK_STATE_OFF};
135
136 static void btif_a2dp_sink_init_delayed();
137 static void btif_a2dp_sink_startup_delayed();
138 static void btif_a2dp_sink_start_session_delayed(
139 std::promise<void> peer_ready_promise);
140 static void btif_a2dp_sink_end_session_delayed();
141 static void btif_a2dp_sink_shutdown_delayed();
142 static void btif_a2dp_sink_cleanup_delayed();
143 static void btif_a2dp_sink_command_ready(BT_HDR_RIGID* p_msg);
144 static void btif_a2dp_sink_audio_handle_stop_decoding();
145 static void btif_decode_alarm_cb(void* context);
146 static void btif_a2dp_sink_audio_handle_start_decoding();
147 static void btif_a2dp_sink_avk_handle_timer();
148 static void btif_a2dp_sink_audio_rx_flush_req();
149 /* Handle incoming media packets A2DP SINK streaming */
150 static void btif_a2dp_sink_handle_inc_media(BT_HDR* p_msg);
151 static void btif_a2dp_sink_decoder_update_event(
152 tBTIF_MEDIA_SINK_DECODER_UPDATE* p_buf);
153 static void btif_a2dp_sink_clear_track_event();
154 static void btif_a2dp_sink_set_focus_state_event(
155 btif_a2dp_sink_focus_state_t state);
156 static void btif_a2dp_sink_audio_rx_flush_event();
157 static void btif_a2dp_sink_clear_track_event_req();
158 static void btif_a2dp_sink_on_start_event();
159 static void btif_a2dp_sink_on_suspend_event();
160
dump_media_event(uint16_t event)161 UNUSED_ATTR static const char* dump_media_event(uint16_t event) {
162 switch (event) {
163 CASE_RETURN_STR(BTIF_MEDIA_SINK_DECODER_UPDATE)
164 CASE_RETURN_STR(BTIF_MEDIA_SINK_CLEAR_TRACK)
165 CASE_RETURN_STR(BTIF_MEDIA_SINK_SET_FOCUS_STATE)
166 CASE_RETURN_STR(BTIF_MEDIA_SINK_AUDIO_RX_FLUSH)
167 CASE_RETURN_STR(BTIF_MEDIA_SINK_START)
168 CASE_RETURN_STR(BTIF_MEDIA_SINK_SUSPEND)
169 default:
170 break;
171 }
172 return "UNKNOWN A2DP SINK EVENT";
173 }
174
btif_a2dp_sink_init()175 bool btif_a2dp_sink_init() {
176 LOG_INFO("%s", __func__);
177 LockGuard lock(g_mutex);
178
179 if (btif_a2dp_sink_state != BTIF_A2DP_SINK_STATE_OFF) {
180 LOG_ERROR("%s: A2DP Sink media task already running", __func__);
181 return false;
182 }
183
184 btif_a2dp_sink_cb.Reset();
185 btif_a2dp_sink_state = BTIF_A2DP_SINK_STATE_STARTING_UP;
186
187 /* Start A2DP Sink media task */
188 btif_a2dp_sink_cb.worker_thread.StartUp();
189 if (!btif_a2dp_sink_cb.worker_thread.IsRunning()) {
190 LOG_ERROR("%s: unable to start up media thread", __func__);
191 btif_a2dp_sink_state = BTIF_A2DP_SINK_STATE_OFF;
192 return false;
193 }
194
195 btif_a2dp_sink_cb.rx_audio_queue = fixed_queue_new(SIZE_MAX);
196
197 /* Schedule the rest of the operations */
198 if (!btif_a2dp_sink_cb.worker_thread.EnableRealTimeScheduling()) {
199 #if defined(__ANDROID__)
200 LOG(FATAL) << __func__
201 << ": Failed to increase A2DP decoder thread priority";
202 #endif
203 }
204 btif_a2dp_sink_cb.worker_thread.DoInThread(
205 FROM_HERE, base::BindOnce(btif_a2dp_sink_init_delayed));
206 return true;
207 }
208
btif_a2dp_sink_init_delayed()209 static void btif_a2dp_sink_init_delayed() {
210 LOG_INFO("%s", __func__);
211 btif_a2dp_sink_state = BTIF_A2DP_SINK_STATE_RUNNING;
212 }
213
btif_a2dp_sink_startup()214 bool btif_a2dp_sink_startup() {
215 LOG_INFO("%s", __func__);
216 btif_a2dp_sink_cb.worker_thread.DoInThread(
217 FROM_HERE, base::BindOnce(btif_a2dp_sink_startup_delayed));
218 return true;
219 }
220
btif_a2dp_sink_startup_delayed()221 static void btif_a2dp_sink_startup_delayed() {
222 LOG_INFO("%s", __func__);
223 LockGuard lock(g_mutex);
224 // Nothing to do
225 }
226
btif_a2dp_sink_start_session(const RawAddress & peer_address,std::promise<void> peer_ready_promise)227 bool btif_a2dp_sink_start_session(const RawAddress& peer_address,
228 std::promise<void> peer_ready_promise) {
229 LOG(INFO) << __func__ << ": peer_address="
230 << ADDRESS_TO_LOGGABLE_STR(peer_address);
231 if (btif_a2dp_sink_cb.worker_thread.DoInThread(
232 FROM_HERE, base::BindOnce(btif_a2dp_sink_start_session_delayed,
233 std::move(peer_ready_promise)))) {
234 return true;
235 } else {
236 // cannot set promise but triggers crash
237 LOG(FATAL) << __func__ << ": peer_address="
238 << ADDRESS_TO_LOGGABLE_STR(peer_address)
239 << " fails to context switch";
240 return false;
241 }
242 }
243
btif_a2dp_sink_start_session_delayed(std::promise<void> peer_ready_promise)244 static void btif_a2dp_sink_start_session_delayed(
245 std::promise<void> peer_ready_promise) {
246 LOG(INFO) << __func__;
247 LockGuard lock(g_mutex);
248 peer_ready_promise.set_value();
249 // Nothing to do
250 }
251
btif_a2dp_sink_restart_session(const RawAddress & old_peer_address,const RawAddress & new_peer_address,std::promise<void> peer_ready_promise)252 bool btif_a2dp_sink_restart_session(const RawAddress& old_peer_address,
253 const RawAddress& new_peer_address,
254 std::promise<void> peer_ready_promise) {
255 LOG(INFO) << __func__ << ": old_peer_address="
256 << ADDRESS_TO_LOGGABLE_STR(old_peer_address)
257 << " new_peer_address=" << ADDRESS_TO_LOGGABLE_STR(new_peer_address);
258
259 CHECK(!new_peer_address.IsEmpty());
260
261 if (!old_peer_address.IsEmpty()) {
262 btif_a2dp_sink_end_session(old_peer_address);
263 }
264
265 if (!bta_av_co_set_active_peer(new_peer_address)) {
266 LOG(ERROR) << __func__
267 << ": Cannot stream audio: cannot set active peer to "
268 << ADDRESS_TO_LOGGABLE_STR(new_peer_address);
269 peer_ready_promise.set_value();
270 return false;
271 }
272
273 if (old_peer_address.IsEmpty()) {
274 btif_a2dp_sink_startup();
275 }
276 btif_a2dp_sink_start_session(new_peer_address, std::move(peer_ready_promise));
277
278 return true;
279 }
280
btif_a2dp_sink_end_session(const RawAddress & peer_address)281 bool btif_a2dp_sink_end_session(const RawAddress& peer_address) {
282 LOG_INFO("%s: peer_address=%s", __func__,
283 ADDRESS_TO_LOGGABLE_CSTR(peer_address));
284 btif_a2dp_sink_cb.worker_thread.DoInThread(
285 FROM_HERE, base::BindOnce(btif_a2dp_sink_end_session_delayed));
286 return true;
287 }
288
btif_a2dp_sink_end_session_delayed()289 static void btif_a2dp_sink_end_session_delayed() {
290 LOG_INFO("%s", __func__);
291 LockGuard lock(g_mutex);
292 // Nothing to do
293 }
294
btif_a2dp_sink_shutdown()295 void btif_a2dp_sink_shutdown() {
296 LOG_INFO("%s", __func__);
297 btif_a2dp_sink_cb.worker_thread.DoInThread(
298 FROM_HERE, base::BindOnce(btif_a2dp_sink_shutdown_delayed));
299 }
300
btif_a2dp_sink_shutdown_delayed()301 static void btif_a2dp_sink_shutdown_delayed() {
302 LOG_INFO("%s", __func__);
303 LockGuard lock(g_mutex);
304 // Nothing to do
305 }
306
btif_a2dp_sink_cleanup()307 void btif_a2dp_sink_cleanup() {
308 LOG_INFO("%s", __func__);
309
310 alarm_t* decode_alarm;
311
312 // Make sure the sink is shutdown
313 btif_a2dp_sink_shutdown();
314
315 {
316 LockGuard lock(g_mutex);
317 if ((btif_a2dp_sink_state == BTIF_A2DP_SINK_STATE_OFF) ||
318 (btif_a2dp_sink_state == BTIF_A2DP_SINK_STATE_SHUTTING_DOWN)) {
319 return;
320 }
321 // Make sure no channels are restarted while shutting down
322 btif_a2dp_sink_state = BTIF_A2DP_SINK_STATE_SHUTTING_DOWN;
323
324 decode_alarm = btif_a2dp_sink_cb.decode_alarm;
325 btif_a2dp_sink_cb.decode_alarm = nullptr;
326 }
327
328 // Stop the timer
329 alarm_free(decode_alarm);
330
331 // Exit the thread
332 btif_a2dp_sink_cb.worker_thread.DoInThread(
333 FROM_HERE, base::BindOnce(btif_a2dp_sink_cleanup_delayed));
334 btif_a2dp_sink_cb.worker_thread.ShutDown();
335 }
336
btif_a2dp_sink_cleanup_delayed()337 static void btif_a2dp_sink_cleanup_delayed() {
338 LOG_INFO("%s", __func__);
339 LockGuard lock(g_mutex);
340
341 fixed_queue_free(btif_a2dp_sink_cb.rx_audio_queue, nullptr);
342 btif_a2dp_sink_cb.rx_audio_queue = nullptr;
343 btif_a2dp_sink_state = BTIF_A2DP_SINK_STATE_OFF;
344 }
345
btif_a2dp_sink_get_sample_rate()346 tA2DP_SAMPLE_RATE btif_a2dp_sink_get_sample_rate() {
347 LockGuard lock(g_mutex);
348 return btif_a2dp_sink_cb.sample_rate;
349 }
350
btif_a2dp_sink_get_bits_per_sample()351 tA2DP_BITS_PER_SAMPLE btif_a2dp_sink_get_bits_per_sample() {
352 LockGuard lock(g_mutex);
353 return btif_a2dp_sink_cb.bits_per_sample;
354 }
355
btif_a2dp_sink_get_channel_count()356 tA2DP_CHANNEL_COUNT btif_a2dp_sink_get_channel_count() {
357 LockGuard lock(g_mutex);
358 return btif_a2dp_sink_cb.channel_count;
359 }
360
btif_a2dp_sink_command_ready(BT_HDR_RIGID * p_msg)361 static void btif_a2dp_sink_command_ready(BT_HDR_RIGID* p_msg) {
362 LOG_VERBOSE("%s: event %d %s", __func__, p_msg->event,
363 dump_media_event(p_msg->event));
364
365 switch (p_msg->event) {
366 case BTIF_MEDIA_SINK_DECODER_UPDATE:
367 btif_a2dp_sink_decoder_update_event(
368 (tBTIF_MEDIA_SINK_DECODER_UPDATE*)p_msg);
369 break;
370 case BTIF_MEDIA_SINK_CLEAR_TRACK:
371 btif_a2dp_sink_clear_track_event();
372 break;
373 case BTIF_MEDIA_SINK_SET_FOCUS_STATE: {
374 btif_a2dp_sink_focus_state_t state =
375 ((tBTIF_MEDIA_SINK_FOCUS_UPDATE*)p_msg)->focus_state;
376 btif_a2dp_sink_set_focus_state_event(state);
377 break;
378 }
379 case BTIF_MEDIA_SINK_AUDIO_RX_FLUSH:
380 btif_a2dp_sink_audio_rx_flush_event();
381 break;
382 case BTIF_MEDIA_SINK_START:
383 btif_a2dp_sink_on_start_event();
384 break;
385 case BTIF_MEDIA_SINK_SUSPEND:
386 btif_a2dp_sink_on_suspend_event();
387 break;
388 default:
389 LOG_ERROR("%s: unknown event %d", __func__, p_msg->event);
390 break;
391 }
392
393 LOG_VERBOSE("%s: %s DONE", __func__, dump_media_event(p_msg->event));
394 osi_free(p_msg);
395 }
396
btif_a2dp_sink_update_decoder(const uint8_t * p_codec_info)397 void btif_a2dp_sink_update_decoder(const uint8_t* p_codec_info) {
398 LOG_INFO("%s", __func__);
399 tBTIF_MEDIA_SINK_DECODER_UPDATE* p_buf =
400 reinterpret_cast<tBTIF_MEDIA_SINK_DECODER_UPDATE*>(
401 osi_malloc(sizeof(tBTIF_MEDIA_SINK_DECODER_UPDATE)));
402
403 APPL_TRACE_EVENT("%s: p_codec_info[%x:%x:%x:%x:%x:%x]", __func__,
404 p_codec_info[1], p_codec_info[2], p_codec_info[3],
405 p_codec_info[4], p_codec_info[5], p_codec_info[6]);
406
407 memcpy(p_buf->codec_info, p_codec_info, AVDT_CODEC_SIZE);
408 p_buf->hdr.event = BTIF_MEDIA_SINK_DECODER_UPDATE;
409
410 btif_a2dp_sink_cb.worker_thread.DoInThread(
411 FROM_HERE,
412 base::BindOnce(btif_a2dp_sink_command_ready, (BT_HDR_RIGID*)p_buf));
413 }
414
btif_a2dp_sink_on_idle()415 void btif_a2dp_sink_on_idle() {
416 LOG_INFO("%s", __func__);
417 BT_HDR_RIGID* p_buf =
418 reinterpret_cast<BT_HDR_RIGID*>(osi_malloc(sizeof(BT_HDR_RIGID)));
419 p_buf->event = BTIF_MEDIA_SINK_SUSPEND;
420 btif_a2dp_sink_cb.worker_thread.DoInThread(
421 FROM_HERE, base::BindOnce(btif_a2dp_sink_command_ready, p_buf));
422
423 if (btif_a2dp_sink_state == BTIF_A2DP_SINK_STATE_OFF) return;
424 btif_a2dp_sink_audio_handle_stop_decoding();
425 btif_a2dp_sink_clear_track_event_req();
426 }
427
btif_a2dp_sink_on_stopped(UNUSED_ATTR tBTA_AV_SUSPEND * p_av_suspend)428 void btif_a2dp_sink_on_stopped(UNUSED_ATTR tBTA_AV_SUSPEND* p_av_suspend) {
429 LOG_INFO("%s", __func__);
430 BT_HDR_RIGID* p_buf =
431 reinterpret_cast<BT_HDR_RIGID*>(osi_malloc(sizeof(BT_HDR_RIGID)));
432 p_buf->event = BTIF_MEDIA_SINK_SUSPEND;
433 btif_a2dp_sink_cb.worker_thread.DoInThread(
434 FROM_HERE, base::BindOnce(btif_a2dp_sink_command_ready, p_buf));
435
436 if (btif_a2dp_sink_state == BTIF_A2DP_SINK_STATE_OFF) return;
437 btif_a2dp_sink_audio_handle_stop_decoding();
438 }
439
btif_a2dp_sink_on_suspended(UNUSED_ATTR tBTA_AV_SUSPEND * p_av_suspend)440 void btif_a2dp_sink_on_suspended(UNUSED_ATTR tBTA_AV_SUSPEND* p_av_suspend) {
441 LOG_INFO("%s", __func__);
442 BT_HDR_RIGID* p_buf =
443 reinterpret_cast<BT_HDR_RIGID*>(osi_malloc(sizeof(BT_HDR_RIGID)));
444 p_buf->event = BTIF_MEDIA_SINK_SUSPEND;
445 btif_a2dp_sink_cb.worker_thread.DoInThread(
446 FROM_HERE, base::BindOnce(btif_a2dp_sink_command_ready, p_buf));
447
448 if (btif_a2dp_sink_state == BTIF_A2DP_SINK_STATE_OFF) return;
449 btif_a2dp_sink_audio_handle_stop_decoding();
450 }
451
btif_a2dp_sink_on_start()452 bool btif_a2dp_sink_on_start() {
453 LOG_INFO("%s", __func__);
454
455 BT_HDR_RIGID* p_buf =
456 reinterpret_cast<BT_HDR_RIGID*>(osi_malloc(sizeof(BT_HDR_RIGID)));
457 p_buf->event = BTIF_MEDIA_SINK_START;
458 btif_a2dp_sink_cb.worker_thread.DoInThread(
459 FROM_HERE, base::BindOnce(btif_a2dp_sink_command_ready, p_buf));
460
461 return true;
462 }
463
btif_a2dp_sink_audio_handle_stop_decoding()464 static void btif_a2dp_sink_audio_handle_stop_decoding() {
465 LOG_INFO("%s", __func__);
466 alarm_t* old_alarm;
467 {
468 LockGuard lock(g_mutex);
469 btif_a2dp_sink_cb.rx_flush = true;
470 btif_a2dp_sink_audio_rx_flush_req();
471 old_alarm = btif_a2dp_sink_cb.decode_alarm;
472 btif_a2dp_sink_cb.decode_alarm = nullptr;
473 }
474
475 // Drop the lock here, btif_decode_alarm_cb may in the process of being called
476 // while we alarm free leading to deadlock.
477 //
478 // alarm_free waits for btif_decode_alarm_cb which is waiting for g_mutex.
479 alarm_free(old_alarm);
480
481 {
482 LockGuard lock(g_mutex);
483 #ifdef __ANDROID__
484 BtifAvrcpAudioTrackPause(btif_a2dp_sink_cb.audio_track);
485 #endif
486 }
487 }
488
btif_decode_alarm_cb(UNUSED_ATTR void * context)489 static void btif_decode_alarm_cb(UNUSED_ATTR void* context) {
490 LockGuard lock(g_mutex);
491 btif_a2dp_sink_cb.worker_thread.DoInThread(
492 FROM_HERE, base::BindOnce(btif_a2dp_sink_avk_handle_timer));
493 }
494
btif_a2dp_sink_clear_track_event()495 static void btif_a2dp_sink_clear_track_event() {
496 LOG_INFO("%s", __func__);
497 LockGuard lock(g_mutex);
498
499 #ifdef __ANDROID__
500 BtifAvrcpAudioTrackStop(btif_a2dp_sink_cb.audio_track);
501 BtifAvrcpAudioTrackDelete(btif_a2dp_sink_cb.audio_track);
502 #endif
503 btif_a2dp_sink_cb.audio_track = nullptr;
504 }
505
506 // Must be called while locked.
btif_a2dp_sink_audio_handle_start_decoding()507 static void btif_a2dp_sink_audio_handle_start_decoding() {
508 LOG_INFO("%s", __func__);
509 if (btif_a2dp_sink_cb.decode_alarm != nullptr)
510 return; // Already started decoding
511
512 #ifdef __ANDROID__
513 BtifAvrcpAudioTrackStart(btif_a2dp_sink_cb.audio_track);
514 #endif
515
516 btif_a2dp_sink_cb.decode_alarm = alarm_new_periodic("btif.a2dp_sink_decode");
517 if (btif_a2dp_sink_cb.decode_alarm == nullptr) {
518 LOG_ERROR("%s: unable to allocate decode alarm", __func__);
519 return;
520 }
521 alarm_set(btif_a2dp_sink_cb.decode_alarm, BTIF_SINK_MEDIA_TIME_TICK_MS,
522 btif_decode_alarm_cb, nullptr);
523 }
524
btif_a2dp_sink_on_decode_complete(uint8_t * data,uint32_t len)525 static void btif_a2dp_sink_on_decode_complete(uint8_t* data, uint32_t len) {
526 #ifdef __ANDROID__
527 BtifAvrcpAudioTrackWriteData(btif_a2dp_sink_cb.audio_track,
528 reinterpret_cast<void*>(data), len);
529 #endif
530 }
531
532 // Must be called while locked.
btif_a2dp_sink_handle_inc_media(BT_HDR * p_msg)533 static void btif_a2dp_sink_handle_inc_media(BT_HDR* p_msg) {
534 if ((btif_av_get_peer_sep() == AVDT_TSEP_SNK) ||
535 (btif_a2dp_sink_cb.rx_flush)) {
536 APPL_TRACE_DEBUG("%s: state changed happened in this tick", __func__);
537 return;
538 }
539
540 CHECK(btif_a2dp_sink_cb.decoder_interface != nullptr);
541 if (!btif_a2dp_sink_cb.decoder_interface->decode_packet(p_msg)) {
542 LOG_ERROR("%s: decoding failed", __func__);
543 }
544 }
545
btif_a2dp_sink_avk_handle_timer()546 static void btif_a2dp_sink_avk_handle_timer() {
547 LockGuard lock(g_mutex);
548
549 BT_HDR* p_msg;
550 if (fixed_queue_is_empty(btif_a2dp_sink_cb.rx_audio_queue)) {
551 APPL_TRACE_DEBUG("%s: empty queue", __func__);
552 return;
553 }
554
555 /* Don't do anything in case of focus not granted */
556 if (btif_a2dp_sink_cb.rx_focus_state == BTIF_A2DP_SINK_FOCUS_NOT_GRANTED) {
557 APPL_TRACE_DEBUG("%s: skipping frames since focus is not present",
558 __func__);
559 return;
560 }
561 /* Play only in BTIF_A2DP_SINK_FOCUS_GRANTED case */
562 if (btif_a2dp_sink_cb.rx_flush) {
563 fixed_queue_flush(btif_a2dp_sink_cb.rx_audio_queue, osi_free);
564 return;
565 }
566
567 APPL_TRACE_DEBUG("%s: process frames begin", __func__);
568 while (true) {
569 p_msg = (BT_HDR*)fixed_queue_try_dequeue(btif_a2dp_sink_cb.rx_audio_queue);
570 if (p_msg == NULL) {
571 break;
572 }
573 APPL_TRACE_DEBUG("%s: number of packets in queue %zu", __func__,
574 fixed_queue_length(btif_a2dp_sink_cb.rx_audio_queue));
575
576 /* Queue packet has less frames */
577 btif_a2dp_sink_handle_inc_media(p_msg);
578 osi_free(p_msg);
579 }
580 APPL_TRACE_DEBUG("%s: process frames end", __func__);
581 }
582
583 /* when true media task discards any rx frames */
btif_a2dp_sink_set_rx_flush(bool enable)584 void btif_a2dp_sink_set_rx_flush(bool enable) {
585 LOG_INFO("%s: enable=%s", __func__, (enable) ? "true" : "false");
586 LockGuard lock(g_mutex);
587
588 btif_a2dp_sink_cb.rx_flush = enable;
589 }
590
btif_a2dp_sink_audio_rx_flush_event()591 static void btif_a2dp_sink_audio_rx_flush_event() {
592 LOG_INFO("%s", __func__);
593 LockGuard lock(g_mutex);
594 // Flush all received encoded audio buffers
595 fixed_queue_flush(btif_a2dp_sink_cb.rx_audio_queue, osi_free);
596 }
597
btif_a2dp_sink_decoder_update_event(tBTIF_MEDIA_SINK_DECODER_UPDATE * p_buf)598 static void btif_a2dp_sink_decoder_update_event(
599 tBTIF_MEDIA_SINK_DECODER_UPDATE* p_buf) {
600 LOG_INFO("%s", __func__);
601 LockGuard lock(g_mutex);
602 APPL_TRACE_DEBUG("%s: p_codec_info[%x:%x:%x:%x:%x:%x]", __func__,
603 p_buf->codec_info[1], p_buf->codec_info[2],
604 p_buf->codec_info[3], p_buf->codec_info[4],
605 p_buf->codec_info[5], p_buf->codec_info[6]);
606
607 int sample_rate = A2DP_GetTrackSampleRate(p_buf->codec_info);
608 if (sample_rate == -1) {
609 LOG_ERROR("%s: cannot get the track frequency", __func__);
610 return;
611 }
612 int bits_per_sample = A2DP_GetTrackBitsPerSample(p_buf->codec_info);
613 if (bits_per_sample == -1) {
614 LOG_ERROR("%s: cannot get the bits per sample", __func__);
615 return;
616 }
617 int channel_count = A2DP_GetTrackChannelCount(p_buf->codec_info);
618 if (channel_count == -1) {
619 LOG_ERROR("%s: cannot get the channel count", __func__);
620 return;
621 }
622 int channel_type = A2DP_GetSinkTrackChannelType(p_buf->codec_info);
623 if (channel_type == -1) {
624 LOG_ERROR("%s: cannot get the Sink channel type", __func__);
625 return;
626 }
627 btif_a2dp_sink_cb.sample_rate = sample_rate;
628 btif_a2dp_sink_cb.bits_per_sample = bits_per_sample;
629 btif_a2dp_sink_cb.channel_count = channel_count;
630
631 btif_a2dp_sink_cb.rx_flush = false;
632 APPL_TRACE_DEBUG("%s: reset to Sink role", __func__);
633
634 btif_a2dp_sink_cb.decoder_interface = bta_av_co_get_decoder_interface();
635 if (btif_a2dp_sink_cb.decoder_interface == nullptr) {
636 LOG_ERROR("%s: cannot stream audio: no source decoder interface", __func__);
637 return;
638 }
639
640 if (!btif_a2dp_sink_cb.decoder_interface->decoder_init(
641 btif_a2dp_sink_on_decode_complete)) {
642 LOG_ERROR("%s: failed to initialize decoder", __func__);
643 return;
644 }
645
646 if (btif_a2dp_sink_cb.decoder_interface->decoder_configure != nullptr) {
647 btif_a2dp_sink_cb.decoder_interface->decoder_configure(p_buf->codec_info);
648 }
649
650 APPL_TRACE_DEBUG("%s: create audio track", __func__);
651 btif_a2dp_sink_cb.audio_track =
652 #ifdef __ANDROID__
653 BtifAvrcpAudioTrackCreate(sample_rate, bits_per_sample, channel_count);
654 #else
655 NULL;
656 #endif
657 if (btif_a2dp_sink_cb.audio_track == nullptr) {
658 LOG_ERROR("%s: track creation failed", __func__);
659 return;
660 }
661 }
662
btif_a2dp_sink_enqueue_buf(BT_HDR * p_pkt)663 uint8_t btif_a2dp_sink_enqueue_buf(BT_HDR* p_pkt) {
664 LockGuard lock(g_mutex);
665 if (btif_a2dp_sink_cb.rx_flush) /* Flush enabled, do not enqueue */
666 return fixed_queue_length(btif_a2dp_sink_cb.rx_audio_queue);
667
668 if (fixed_queue_length(btif_a2dp_sink_cb.rx_audio_queue) ==
669 MAX_INPUT_A2DP_FRAME_QUEUE_SZ) {
670 uint8_t ret = fixed_queue_length(btif_a2dp_sink_cb.rx_audio_queue);
671 osi_free(fixed_queue_try_dequeue(btif_a2dp_sink_cb.rx_audio_queue));
672 return ret;
673 }
674
675 BTIF_TRACE_VERBOSE("%s +", __func__);
676 /* Allocate and queue this buffer */
677 BT_HDR* p_msg =
678 reinterpret_cast<BT_HDR*>(osi_malloc(sizeof(*p_msg) + p_pkt->len));
679 memcpy(p_msg, p_pkt, sizeof(*p_msg));
680 p_msg->offset = 0;
681 memcpy(p_msg->data, p_pkt->data + p_pkt->offset, p_pkt->len);
682 fixed_queue_enqueue(btif_a2dp_sink_cb.rx_audio_queue, p_msg);
683 if (fixed_queue_length(btif_a2dp_sink_cb.rx_audio_queue) ==
684 MAX_A2DP_DELAYED_START_FRAME_COUNT) {
685 BTIF_TRACE_DEBUG("%s: Initiate decoding. Current focus state:%d", __func__,
686 btif_a2dp_sink_cb.rx_focus_state);
687 if (btif_a2dp_sink_cb.rx_focus_state == BTIF_A2DP_SINK_FOCUS_GRANTED) {
688 btif_a2dp_sink_audio_handle_start_decoding();
689 }
690 }
691
692 return fixed_queue_length(btif_a2dp_sink_cb.rx_audio_queue);
693 }
694
btif_a2dp_sink_audio_rx_flush_req()695 void btif_a2dp_sink_audio_rx_flush_req() {
696 LOG_INFO("%s", __func__);
697 if (fixed_queue_is_empty(btif_a2dp_sink_cb.rx_audio_queue)) {
698 /* Queue is already empty */
699 return;
700 }
701
702 BT_HDR_RIGID* p_buf =
703 reinterpret_cast<BT_HDR_RIGID*>(osi_malloc(sizeof(BT_HDR_RIGID)));
704 p_buf->event = BTIF_MEDIA_SINK_AUDIO_RX_FLUSH;
705 btif_a2dp_sink_cb.worker_thread.DoInThread(
706 FROM_HERE, base::BindOnce(btif_a2dp_sink_command_ready, p_buf));
707 }
708
btif_a2dp_sink_debug_dump(UNUSED_ATTR int fd)709 void btif_a2dp_sink_debug_dump(UNUSED_ATTR int fd) {
710 // Nothing to do
711 }
712
btif_a2dp_sink_set_focus_state_req(btif_a2dp_sink_focus_state_t state)713 void btif_a2dp_sink_set_focus_state_req(btif_a2dp_sink_focus_state_t state) {
714 LOG_INFO("%s", __func__);
715 tBTIF_MEDIA_SINK_FOCUS_UPDATE* p_buf =
716 reinterpret_cast<tBTIF_MEDIA_SINK_FOCUS_UPDATE*>(
717 osi_malloc(sizeof(tBTIF_MEDIA_SINK_FOCUS_UPDATE)));
718 p_buf->focus_state = state;
719 p_buf->hdr.event = BTIF_MEDIA_SINK_SET_FOCUS_STATE;
720 btif_a2dp_sink_cb.worker_thread.DoInThread(
721 FROM_HERE,
722 base::BindOnce(btif_a2dp_sink_command_ready, (BT_HDR_RIGID*)p_buf));
723 }
724
btif_a2dp_sink_set_focus_state_event(btif_a2dp_sink_focus_state_t state)725 static void btif_a2dp_sink_set_focus_state_event(
726 btif_a2dp_sink_focus_state_t state) {
727 LOG_INFO("%s: state=%d", __func__, state);
728 LockGuard lock(g_mutex);
729
730 APPL_TRACE_DEBUG("%s: setting focus state to %d", __func__, state);
731 btif_a2dp_sink_cb.rx_focus_state = state;
732 if (btif_a2dp_sink_cb.rx_focus_state == BTIF_A2DP_SINK_FOCUS_NOT_GRANTED) {
733 fixed_queue_flush(btif_a2dp_sink_cb.rx_audio_queue, osi_free);
734 btif_a2dp_sink_cb.rx_flush = true;
735 } else if (btif_a2dp_sink_cb.rx_focus_state == BTIF_A2DP_SINK_FOCUS_GRANTED) {
736 btif_a2dp_sink_cb.rx_flush = false;
737 }
738 }
739
btif_a2dp_sink_set_audio_track_gain(float gain)740 void btif_a2dp_sink_set_audio_track_gain(float gain) {
741 LOG_DEBUG("%s: set gain to %f", __func__, gain);
742 LockGuard lock(g_mutex);
743
744 #ifdef __ANDROID__
745 BtifAvrcpSetAudioTrackGain(btif_a2dp_sink_cb.audio_track, gain);
746 #endif
747 }
748
btif_a2dp_sink_clear_track_event_req()749 static void btif_a2dp_sink_clear_track_event_req() {
750 LOG_INFO("%s", __func__);
751 BT_HDR_RIGID* p_buf =
752 reinterpret_cast<BT_HDR_RIGID*>(osi_malloc(sizeof(BT_HDR_RIGID)));
753
754 p_buf->event = BTIF_MEDIA_SINK_CLEAR_TRACK;
755 btif_a2dp_sink_cb.worker_thread.DoInThread(
756 FROM_HERE, base::BindOnce(btif_a2dp_sink_command_ready, p_buf));
757 }
758
btif_a2dp_sink_on_start_event()759 static void btif_a2dp_sink_on_start_event() {
760 LOG_INFO("%s", __func__);
761
762 if ((btif_a2dp_sink_cb.decoder_interface != nullptr) &&
763 (btif_a2dp_sink_cb.decoder_interface->decoder_start != nullptr)) {
764 btif_a2dp_sink_cb.decoder_interface->decoder_start();
765 }
766
767 return;
768 }
769
btif_a2dp_sink_on_suspend_event()770 static void btif_a2dp_sink_on_suspend_event() {
771 LOG_INFO("%s", __func__);
772
773 if ((btif_a2dp_sink_cb.decoder_interface != nullptr) &&
774 (btif_a2dp_sink_cb.decoder_interface->decoder_suspend != nullptr)) {
775 btif_a2dp_sink_cb.decoder_interface->decoder_suspend();
776 }
777
778 return;
779 }
780