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/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(OS_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=" << peer_address;
230 if (btif_a2dp_sink_cb.worker_thread.DoInThread(
231 FROM_HERE, base::BindOnce(btif_a2dp_sink_start_session_delayed,
232 std::move(peer_ready_promise)))) {
233 return true;
234 } else {
235 // cannot set promise but triggers crash
236 LOG(FATAL) << __func__ << ": peer_address=" << peer_address
237 << " fails to context switch";
238 return false;
239 }
240 }
241
btif_a2dp_sink_start_session_delayed(std::promise<void> peer_ready_promise)242 static void btif_a2dp_sink_start_session_delayed(
243 std::promise<void> peer_ready_promise) {
244 LOG(INFO) << __func__;
245 LockGuard lock(g_mutex);
246 peer_ready_promise.set_value();
247 // Nothing to do
248 }
249
btif_a2dp_sink_restart_session(const RawAddress & old_peer_address,const RawAddress & new_peer_address,std::promise<void> peer_ready_promise)250 bool btif_a2dp_sink_restart_session(const RawAddress& old_peer_address,
251 const RawAddress& new_peer_address,
252 std::promise<void> peer_ready_promise) {
253 LOG(INFO) << __func__ << ": old_peer_address=" << old_peer_address
254 << " new_peer_address=" << new_peer_address;
255
256 CHECK(!new_peer_address.IsEmpty());
257
258 if (!old_peer_address.IsEmpty()) {
259 btif_a2dp_sink_end_session(old_peer_address);
260 }
261
262 if (!bta_av_co_set_active_peer(new_peer_address)) {
263 LOG(ERROR) << __func__
264 << ": Cannot stream audio: cannot set active peer to "
265 << new_peer_address;
266 peer_ready_promise.set_value();
267 return false;
268 }
269
270 if (old_peer_address.IsEmpty()) {
271 btif_a2dp_sink_startup();
272 }
273 btif_a2dp_sink_start_session(new_peer_address, std::move(peer_ready_promise));
274
275 return true;
276 }
277
btif_a2dp_sink_end_session(const RawAddress & peer_address)278 bool btif_a2dp_sink_end_session(const RawAddress& peer_address) {
279 LOG_INFO("%s: peer_address=%s", __func__, peer_address.ToString().c_str());
280 btif_a2dp_sink_cb.worker_thread.DoInThread(
281 FROM_HERE, base::BindOnce(btif_a2dp_sink_end_session_delayed));
282 return true;
283 }
284
btif_a2dp_sink_end_session_delayed()285 static void btif_a2dp_sink_end_session_delayed() {
286 LOG_INFO("%s", __func__);
287 LockGuard lock(g_mutex);
288 // Nothing to do
289 }
290
btif_a2dp_sink_shutdown()291 void btif_a2dp_sink_shutdown() {
292 LOG_INFO("%s", __func__);
293 btif_a2dp_sink_cb.worker_thread.DoInThread(
294 FROM_HERE, base::BindOnce(btif_a2dp_sink_shutdown_delayed));
295 }
296
btif_a2dp_sink_shutdown_delayed()297 static void btif_a2dp_sink_shutdown_delayed() {
298 LOG_INFO("%s", __func__);
299 LockGuard lock(g_mutex);
300 // Nothing to do
301 }
302
btif_a2dp_sink_cleanup()303 void btif_a2dp_sink_cleanup() {
304 LOG_INFO("%s", __func__);
305
306 alarm_t* decode_alarm;
307
308 // Make sure the sink is shutdown
309 btif_a2dp_sink_shutdown();
310
311 {
312 LockGuard lock(g_mutex);
313 if ((btif_a2dp_sink_state == BTIF_A2DP_SINK_STATE_OFF) ||
314 (btif_a2dp_sink_state == BTIF_A2DP_SINK_STATE_SHUTTING_DOWN)) {
315 return;
316 }
317 // Make sure no channels are restarted while shutting down
318 btif_a2dp_sink_state = BTIF_A2DP_SINK_STATE_SHUTTING_DOWN;
319
320 decode_alarm = btif_a2dp_sink_cb.decode_alarm;
321 btif_a2dp_sink_cb.decode_alarm = nullptr;
322 }
323
324 // Stop the timer
325 alarm_free(decode_alarm);
326
327 // Exit the thread
328 btif_a2dp_sink_cb.worker_thread.DoInThread(
329 FROM_HERE, base::BindOnce(btif_a2dp_sink_cleanup_delayed));
330 btif_a2dp_sink_cb.worker_thread.ShutDown();
331 }
332
btif_a2dp_sink_cleanup_delayed()333 static void btif_a2dp_sink_cleanup_delayed() {
334 LOG_INFO("%s", __func__);
335 LockGuard lock(g_mutex);
336
337 fixed_queue_free(btif_a2dp_sink_cb.rx_audio_queue, nullptr);
338 btif_a2dp_sink_cb.rx_audio_queue = nullptr;
339 btif_a2dp_sink_state = BTIF_A2DP_SINK_STATE_OFF;
340 }
341
btif_a2dp_sink_get_sample_rate()342 tA2DP_SAMPLE_RATE btif_a2dp_sink_get_sample_rate() {
343 LockGuard lock(g_mutex);
344 return btif_a2dp_sink_cb.sample_rate;
345 }
346
btif_a2dp_sink_get_bits_per_sample()347 tA2DP_BITS_PER_SAMPLE btif_a2dp_sink_get_bits_per_sample() {
348 LockGuard lock(g_mutex);
349 return btif_a2dp_sink_cb.bits_per_sample;
350 }
351
btif_a2dp_sink_get_channel_count()352 tA2DP_CHANNEL_COUNT btif_a2dp_sink_get_channel_count() {
353 LockGuard lock(g_mutex);
354 return btif_a2dp_sink_cb.channel_count;
355 }
356
btif_a2dp_sink_command_ready(BT_HDR_RIGID * p_msg)357 static void btif_a2dp_sink_command_ready(BT_HDR_RIGID* p_msg) {
358 LOG_VERBOSE("%s: event %d %s", __func__, p_msg->event,
359 dump_media_event(p_msg->event));
360
361 switch (p_msg->event) {
362 case BTIF_MEDIA_SINK_DECODER_UPDATE:
363 btif_a2dp_sink_decoder_update_event(
364 (tBTIF_MEDIA_SINK_DECODER_UPDATE*)p_msg);
365 break;
366 case BTIF_MEDIA_SINK_CLEAR_TRACK:
367 btif_a2dp_sink_clear_track_event();
368 break;
369 case BTIF_MEDIA_SINK_SET_FOCUS_STATE: {
370 btif_a2dp_sink_focus_state_t state =
371 ((tBTIF_MEDIA_SINK_FOCUS_UPDATE*)p_msg)->focus_state;
372 btif_a2dp_sink_set_focus_state_event(state);
373 break;
374 }
375 case BTIF_MEDIA_SINK_AUDIO_RX_FLUSH:
376 btif_a2dp_sink_audio_rx_flush_event();
377 break;
378 case BTIF_MEDIA_SINK_START:
379 btif_a2dp_sink_on_start_event();
380 break;
381 case BTIF_MEDIA_SINK_SUSPEND:
382 btif_a2dp_sink_on_suspend_event();
383 break;
384 default:
385 LOG_ERROR("%s: unknown event %d", __func__, p_msg->event);
386 break;
387 }
388
389 LOG_VERBOSE("%s: %s DONE", __func__, dump_media_event(p_msg->event));
390 osi_free(p_msg);
391 }
392
btif_a2dp_sink_update_decoder(const uint8_t * p_codec_info)393 void btif_a2dp_sink_update_decoder(const uint8_t* p_codec_info) {
394 LOG_INFO("%s", __func__);
395 tBTIF_MEDIA_SINK_DECODER_UPDATE* p_buf =
396 reinterpret_cast<tBTIF_MEDIA_SINK_DECODER_UPDATE*>(
397 osi_malloc(sizeof(tBTIF_MEDIA_SINK_DECODER_UPDATE)));
398
399 APPL_TRACE_EVENT("%s: p_codec_info[%x:%x:%x:%x:%x:%x]", __func__,
400 p_codec_info[1], p_codec_info[2], p_codec_info[3],
401 p_codec_info[4], p_codec_info[5], p_codec_info[6]);
402
403 memcpy(p_buf->codec_info, p_codec_info, AVDT_CODEC_SIZE);
404 p_buf->hdr.event = BTIF_MEDIA_SINK_DECODER_UPDATE;
405
406 btif_a2dp_sink_cb.worker_thread.DoInThread(
407 FROM_HERE,
408 base::BindOnce(btif_a2dp_sink_command_ready, (BT_HDR_RIGID*)p_buf));
409 }
410
btif_a2dp_sink_on_idle()411 void btif_a2dp_sink_on_idle() {
412 LOG_INFO("%s", __func__);
413 BT_HDR_RIGID* p_buf =
414 reinterpret_cast<BT_HDR_RIGID*>(osi_malloc(sizeof(BT_HDR_RIGID)));
415 p_buf->event = BTIF_MEDIA_SINK_SUSPEND;
416 btif_a2dp_sink_cb.worker_thread.DoInThread(
417 FROM_HERE, base::BindOnce(btif_a2dp_sink_command_ready, p_buf));
418
419 if (btif_a2dp_sink_state == BTIF_A2DP_SINK_STATE_OFF) return;
420 btif_a2dp_sink_audio_handle_stop_decoding();
421 btif_a2dp_sink_clear_track_event_req();
422 }
423
btif_a2dp_sink_on_stopped(UNUSED_ATTR tBTA_AV_SUSPEND * p_av_suspend)424 void btif_a2dp_sink_on_stopped(UNUSED_ATTR tBTA_AV_SUSPEND* p_av_suspend) {
425 LOG_INFO("%s", __func__);
426 BT_HDR_RIGID* p_buf =
427 reinterpret_cast<BT_HDR_RIGID*>(osi_malloc(sizeof(BT_HDR_RIGID)));
428 p_buf->event = BTIF_MEDIA_SINK_SUSPEND;
429 btif_a2dp_sink_cb.worker_thread.DoInThread(
430 FROM_HERE, base::BindOnce(btif_a2dp_sink_command_ready, p_buf));
431
432 if (btif_a2dp_sink_state == BTIF_A2DP_SINK_STATE_OFF) return;
433 btif_a2dp_sink_audio_handle_stop_decoding();
434 }
435
btif_a2dp_sink_on_suspended(UNUSED_ATTR tBTA_AV_SUSPEND * p_av_suspend)436 void btif_a2dp_sink_on_suspended(UNUSED_ATTR tBTA_AV_SUSPEND* p_av_suspend) {
437 LOG_INFO("%s", __func__);
438 BT_HDR_RIGID* p_buf =
439 reinterpret_cast<BT_HDR_RIGID*>(osi_malloc(sizeof(BT_HDR_RIGID)));
440 p_buf->event = BTIF_MEDIA_SINK_SUSPEND;
441 btif_a2dp_sink_cb.worker_thread.DoInThread(
442 FROM_HERE, base::BindOnce(btif_a2dp_sink_command_ready, p_buf));
443
444 if (btif_a2dp_sink_state == BTIF_A2DP_SINK_STATE_OFF) return;
445 btif_a2dp_sink_audio_handle_stop_decoding();
446 }
447
btif_a2dp_sink_on_start()448 bool btif_a2dp_sink_on_start() {
449 LOG_INFO("%s", __func__);
450
451 BT_HDR_RIGID* p_buf =
452 reinterpret_cast<BT_HDR_RIGID*>(osi_malloc(sizeof(BT_HDR_RIGID)));
453 p_buf->event = BTIF_MEDIA_SINK_START;
454 btif_a2dp_sink_cb.worker_thread.DoInThread(
455 FROM_HERE, base::BindOnce(btif_a2dp_sink_command_ready, p_buf));
456
457 return true;
458 }
459
btif_a2dp_sink_audio_handle_stop_decoding()460 static void btif_a2dp_sink_audio_handle_stop_decoding() {
461 LOG_INFO("%s", __func__);
462 alarm_t* old_alarm;
463 {
464 LockGuard lock(g_mutex);
465 btif_a2dp_sink_cb.rx_flush = true;
466 btif_a2dp_sink_audio_rx_flush_req();
467 old_alarm = btif_a2dp_sink_cb.decode_alarm;
468 btif_a2dp_sink_cb.decode_alarm = nullptr;
469 }
470
471 // Drop the lock here, btif_decode_alarm_cb may in the process of being called
472 // while we alarm free leading to deadlock.
473 //
474 // alarm_free waits for btif_decode_alarm_cb which is waiting for g_mutex.
475 alarm_free(old_alarm);
476
477 {
478 LockGuard lock(g_mutex);
479 #ifndef OS_GENERIC
480 BtifAvrcpAudioTrackPause(btif_a2dp_sink_cb.audio_track);
481 #endif
482 }
483 }
484
btif_decode_alarm_cb(UNUSED_ATTR void * context)485 static void btif_decode_alarm_cb(UNUSED_ATTR void* context) {
486 LockGuard lock(g_mutex);
487 btif_a2dp_sink_cb.worker_thread.DoInThread(
488 FROM_HERE, base::BindOnce(btif_a2dp_sink_avk_handle_timer));
489 }
490
btif_a2dp_sink_clear_track_event()491 static void btif_a2dp_sink_clear_track_event() {
492 LOG_INFO("%s", __func__);
493 LockGuard lock(g_mutex);
494
495 #ifndef OS_GENERIC
496 BtifAvrcpAudioTrackStop(btif_a2dp_sink_cb.audio_track);
497 BtifAvrcpAudioTrackDelete(btif_a2dp_sink_cb.audio_track);
498 #endif
499 btif_a2dp_sink_cb.audio_track = nullptr;
500 }
501
502 // Must be called while locked.
btif_a2dp_sink_audio_handle_start_decoding()503 static void btif_a2dp_sink_audio_handle_start_decoding() {
504 LOG_INFO("%s", __func__);
505 if (btif_a2dp_sink_cb.decode_alarm != nullptr)
506 return; // Already started decoding
507
508 #ifndef OS_GENERIC
509 BtifAvrcpAudioTrackStart(btif_a2dp_sink_cb.audio_track);
510 #endif
511
512 btif_a2dp_sink_cb.decode_alarm = alarm_new_periodic("btif.a2dp_sink_decode");
513 if (btif_a2dp_sink_cb.decode_alarm == nullptr) {
514 LOG_ERROR("%s: unable to allocate decode alarm", __func__);
515 return;
516 }
517 alarm_set(btif_a2dp_sink_cb.decode_alarm, BTIF_SINK_MEDIA_TIME_TICK_MS,
518 btif_decode_alarm_cb, nullptr);
519 }
520
btif_a2dp_sink_on_decode_complete(uint8_t * data,uint32_t len)521 static void btif_a2dp_sink_on_decode_complete(uint8_t* data, uint32_t len) {
522 #ifndef OS_GENERIC
523 BtifAvrcpAudioTrackWriteData(btif_a2dp_sink_cb.audio_track,
524 reinterpret_cast<void*>(data), len);
525 #endif
526 }
527
528 // Must be called while locked.
btif_a2dp_sink_handle_inc_media(BT_HDR * p_msg)529 static void btif_a2dp_sink_handle_inc_media(BT_HDR* p_msg) {
530 if ((btif_av_get_peer_sep() == AVDT_TSEP_SNK) ||
531 (btif_a2dp_sink_cb.rx_flush)) {
532 APPL_TRACE_DEBUG("%s: state changed happened in this tick", __func__);
533 return;
534 }
535
536 CHECK(btif_a2dp_sink_cb.decoder_interface != nullptr);
537 if (!btif_a2dp_sink_cb.decoder_interface->decode_packet(p_msg)) {
538 LOG_ERROR("%s: decoding failed", __func__);
539 }
540 }
541
btif_a2dp_sink_avk_handle_timer()542 static void btif_a2dp_sink_avk_handle_timer() {
543 LockGuard lock(g_mutex);
544
545 BT_HDR* p_msg;
546 if (fixed_queue_is_empty(btif_a2dp_sink_cb.rx_audio_queue)) {
547 APPL_TRACE_DEBUG("%s: empty queue", __func__);
548 return;
549 }
550
551 /* Don't do anything in case of focus not granted */
552 if (btif_a2dp_sink_cb.rx_focus_state == BTIF_A2DP_SINK_FOCUS_NOT_GRANTED) {
553 APPL_TRACE_DEBUG("%s: skipping frames since focus is not present",
554 __func__);
555 return;
556 }
557 /* Play only in BTIF_A2DP_SINK_FOCUS_GRANTED case */
558 if (btif_a2dp_sink_cb.rx_flush) {
559 fixed_queue_flush(btif_a2dp_sink_cb.rx_audio_queue, osi_free);
560 return;
561 }
562
563 APPL_TRACE_DEBUG("%s: process frames begin", __func__);
564 while (true) {
565 p_msg = (BT_HDR*)fixed_queue_try_dequeue(btif_a2dp_sink_cb.rx_audio_queue);
566 if (p_msg == NULL) {
567 break;
568 }
569 APPL_TRACE_DEBUG("%s: number of packets in queue %zu", __func__,
570 fixed_queue_length(btif_a2dp_sink_cb.rx_audio_queue));
571
572 /* Queue packet has less frames */
573 btif_a2dp_sink_handle_inc_media(p_msg);
574 osi_free(p_msg);
575 }
576 APPL_TRACE_DEBUG("%s: process frames end", __func__);
577 }
578
579 /* when true media task discards any rx frames */
btif_a2dp_sink_set_rx_flush(bool enable)580 void btif_a2dp_sink_set_rx_flush(bool enable) {
581 LOG_INFO("%s: enable=%s", __func__, (enable) ? "true" : "false");
582 LockGuard lock(g_mutex);
583
584 btif_a2dp_sink_cb.rx_flush = enable;
585 }
586
btif_a2dp_sink_audio_rx_flush_event()587 static void btif_a2dp_sink_audio_rx_flush_event() {
588 LOG_INFO("%s", __func__);
589 LockGuard lock(g_mutex);
590 // Flush all received encoded audio buffers
591 fixed_queue_flush(btif_a2dp_sink_cb.rx_audio_queue, osi_free);
592 }
593
btif_a2dp_sink_decoder_update_event(tBTIF_MEDIA_SINK_DECODER_UPDATE * p_buf)594 static void btif_a2dp_sink_decoder_update_event(
595 tBTIF_MEDIA_SINK_DECODER_UPDATE* p_buf) {
596 LOG_INFO("%s", __func__);
597 LockGuard lock(g_mutex);
598 APPL_TRACE_DEBUG("%s: p_codec_info[%x:%x:%x:%x:%x:%x]", __func__,
599 p_buf->codec_info[1], p_buf->codec_info[2],
600 p_buf->codec_info[3], p_buf->codec_info[4],
601 p_buf->codec_info[5], p_buf->codec_info[6]);
602
603 int sample_rate = A2DP_GetTrackSampleRate(p_buf->codec_info);
604 if (sample_rate == -1) {
605 LOG_ERROR("%s: cannot get the track frequency", __func__);
606 return;
607 }
608 int bits_per_sample = A2DP_GetTrackBitsPerSample(p_buf->codec_info);
609 if (bits_per_sample == -1) {
610 LOG_ERROR("%s: cannot get the bits per sample", __func__);
611 return;
612 }
613 int channel_count = A2DP_GetTrackChannelCount(p_buf->codec_info);
614 if (channel_count == -1) {
615 LOG_ERROR("%s: cannot get the channel count", __func__);
616 return;
617 }
618 int channel_type = A2DP_GetSinkTrackChannelType(p_buf->codec_info);
619 if (channel_type == -1) {
620 LOG_ERROR("%s: cannot get the Sink channel type", __func__);
621 return;
622 }
623 btif_a2dp_sink_cb.sample_rate = sample_rate;
624 btif_a2dp_sink_cb.bits_per_sample = bits_per_sample;
625 btif_a2dp_sink_cb.channel_count = channel_count;
626
627 btif_a2dp_sink_cb.rx_flush = false;
628 APPL_TRACE_DEBUG("%s: reset to Sink role", __func__);
629
630 btif_a2dp_sink_cb.decoder_interface = bta_av_co_get_decoder_interface();
631 if (btif_a2dp_sink_cb.decoder_interface == nullptr) {
632 LOG_ERROR("%s: cannot stream audio: no source decoder interface", __func__);
633 return;
634 }
635
636 if (!btif_a2dp_sink_cb.decoder_interface->decoder_init(
637 btif_a2dp_sink_on_decode_complete)) {
638 LOG_ERROR("%s: failed to initialize decoder", __func__);
639 return;
640 }
641
642 if (btif_a2dp_sink_cb.decoder_interface->decoder_configure != nullptr) {
643 btif_a2dp_sink_cb.decoder_interface->decoder_configure(p_buf->codec_info);
644 }
645
646 APPL_TRACE_DEBUG("%s: create audio track", __func__);
647 btif_a2dp_sink_cb.audio_track =
648 #ifndef OS_GENERIC
649 BtifAvrcpAudioTrackCreate(sample_rate, bits_per_sample, channel_count);
650 #else
651 NULL;
652 #endif
653 if (btif_a2dp_sink_cb.audio_track == nullptr) {
654 LOG_ERROR("%s: track creation failed", __func__);
655 return;
656 }
657 }
658
btif_a2dp_sink_enqueue_buf(BT_HDR * p_pkt)659 uint8_t btif_a2dp_sink_enqueue_buf(BT_HDR* p_pkt) {
660 LockGuard lock(g_mutex);
661 if (btif_a2dp_sink_cb.rx_flush) /* Flush enabled, do not enqueue */
662 return fixed_queue_length(btif_a2dp_sink_cb.rx_audio_queue);
663
664 if (fixed_queue_length(btif_a2dp_sink_cb.rx_audio_queue) ==
665 MAX_INPUT_A2DP_FRAME_QUEUE_SZ) {
666 uint8_t ret = fixed_queue_length(btif_a2dp_sink_cb.rx_audio_queue);
667 osi_free(fixed_queue_try_dequeue(btif_a2dp_sink_cb.rx_audio_queue));
668 return ret;
669 }
670
671 BTIF_TRACE_VERBOSE("%s +", __func__);
672 /* Allocate and queue this buffer */
673 BT_HDR* p_msg =
674 reinterpret_cast<BT_HDR*>(osi_malloc(sizeof(*p_msg) + p_pkt->len));
675 memcpy(p_msg, p_pkt, sizeof(*p_msg));
676 p_msg->offset = 0;
677 memcpy(p_msg->data, p_pkt->data + p_pkt->offset, p_pkt->len);
678 fixed_queue_enqueue(btif_a2dp_sink_cb.rx_audio_queue, p_msg);
679 if (fixed_queue_length(btif_a2dp_sink_cb.rx_audio_queue) ==
680 MAX_A2DP_DELAYED_START_FRAME_COUNT) {
681 BTIF_TRACE_DEBUG("%s: Initiate decoding", __func__);
682 btif_a2dp_sink_audio_handle_start_decoding();
683 }
684
685 return fixed_queue_length(btif_a2dp_sink_cb.rx_audio_queue);
686 }
687
btif_a2dp_sink_audio_rx_flush_req()688 void btif_a2dp_sink_audio_rx_flush_req() {
689 LOG_INFO("%s", __func__);
690 if (fixed_queue_is_empty(btif_a2dp_sink_cb.rx_audio_queue)) {
691 /* Queue is already empty */
692 return;
693 }
694
695 BT_HDR_RIGID* p_buf =
696 reinterpret_cast<BT_HDR_RIGID*>(osi_malloc(sizeof(BT_HDR_RIGID)));
697 p_buf->event = BTIF_MEDIA_SINK_AUDIO_RX_FLUSH;
698 btif_a2dp_sink_cb.worker_thread.DoInThread(
699 FROM_HERE, base::BindOnce(btif_a2dp_sink_command_ready, p_buf));
700 }
701
btif_a2dp_sink_debug_dump(UNUSED_ATTR int fd)702 void btif_a2dp_sink_debug_dump(UNUSED_ATTR int fd) {
703 // Nothing to do
704 }
705
btif_a2dp_sink_set_focus_state_req(btif_a2dp_sink_focus_state_t state)706 void btif_a2dp_sink_set_focus_state_req(btif_a2dp_sink_focus_state_t state) {
707 LOG_INFO("%s", __func__);
708 tBTIF_MEDIA_SINK_FOCUS_UPDATE* p_buf =
709 reinterpret_cast<tBTIF_MEDIA_SINK_FOCUS_UPDATE*>(
710 osi_malloc(sizeof(tBTIF_MEDIA_SINK_FOCUS_UPDATE)));
711 p_buf->focus_state = state;
712 p_buf->hdr.event = BTIF_MEDIA_SINK_SET_FOCUS_STATE;
713 btif_a2dp_sink_cb.worker_thread.DoInThread(
714 FROM_HERE,
715 base::BindOnce(btif_a2dp_sink_command_ready, (BT_HDR_RIGID*)p_buf));
716 }
717
btif_a2dp_sink_set_focus_state_event(btif_a2dp_sink_focus_state_t state)718 static void btif_a2dp_sink_set_focus_state_event(
719 btif_a2dp_sink_focus_state_t state) {
720 LOG_INFO("%s: state=%d", __func__, state);
721 LockGuard lock(g_mutex);
722
723 APPL_TRACE_DEBUG("%s: setting focus state to %d", __func__, state);
724 btif_a2dp_sink_cb.rx_focus_state = state;
725 if (btif_a2dp_sink_cb.rx_focus_state == BTIF_A2DP_SINK_FOCUS_NOT_GRANTED) {
726 fixed_queue_flush(btif_a2dp_sink_cb.rx_audio_queue, osi_free);
727 btif_a2dp_sink_cb.rx_flush = true;
728 } else if (btif_a2dp_sink_cb.rx_focus_state == BTIF_A2DP_SINK_FOCUS_GRANTED) {
729 btif_a2dp_sink_cb.rx_flush = false;
730 }
731 }
732
btif_a2dp_sink_set_audio_track_gain(float gain)733 void btif_a2dp_sink_set_audio_track_gain(float gain) {
734 LOG_INFO("%s: set gain to %f", __func__, gain);
735 LockGuard lock(g_mutex);
736
737 #ifndef OS_GENERIC
738 BtifAvrcpSetAudioTrackGain(btif_a2dp_sink_cb.audio_track, gain);
739 #endif
740 }
741
btif_a2dp_sink_clear_track_event_req()742 static void btif_a2dp_sink_clear_track_event_req() {
743 LOG_INFO("%s", __func__);
744 BT_HDR_RIGID* p_buf =
745 reinterpret_cast<BT_HDR_RIGID*>(osi_malloc(sizeof(BT_HDR_RIGID)));
746
747 p_buf->event = BTIF_MEDIA_SINK_CLEAR_TRACK;
748 btif_a2dp_sink_cb.worker_thread.DoInThread(
749 FROM_HERE, base::BindOnce(btif_a2dp_sink_command_ready, p_buf));
750 }
751
btif_a2dp_sink_on_start_event()752 static void btif_a2dp_sink_on_start_event() {
753 LOG_INFO("%s", __func__);
754
755 if ((btif_a2dp_sink_cb.decoder_interface != nullptr) &&
756 (btif_a2dp_sink_cb.decoder_interface->decoder_start != nullptr)) {
757 btif_a2dp_sink_cb.decoder_interface->decoder_start();
758 }
759
760 return;
761 }
762
btif_a2dp_sink_on_suspend_event()763 static void btif_a2dp_sink_on_suspend_event() {
764 LOG_INFO("%s", __func__);
765
766 if ((btif_a2dp_sink_cb.decoder_interface != nullptr) &&
767 (btif_a2dp_sink_cb.decoder_interface->decoder_suspend != nullptr)) {
768 btif_a2dp_sink_cb.decoder_interface->decoder_suspend();
769 }
770
771 return;
772 }
773