/******************************************************************************
|
*
|
* Copyright 2016 The Android Open Source Project
|
* Copyright 2009-2012 Broadcom Corporation
|
*
|
* 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 "bt_btif_a2dp_control"
|
|
#include <base/logging.h>
|
#include <stdbool.h>
|
#include <stdint.h>
|
|
#include "audio_a2dp_hw/include/audio_a2dp_hw.h"
|
#include "bt_common.h"
|
#include "btif_a2dp.h"
|
#include "btif_a2dp_control.h"
|
#include "btif_a2dp_sink.h"
|
#include "btif_a2dp_source.h"
|
#include "btif_av.h"
|
#include "btif_av_co.h"
|
#include "btif_hf.h"
|
#include "osi/include/osi.h"
|
#include "uipc.h"
|
|
#define A2DP_DATA_READ_POLL_MS 10
|
|
struct {
|
uint64_t total_bytes_read = 0;
|
uint16_t audio_delay = 0;
|
struct timespec timestamp = {};
|
} delay_report_stats;
|
|
static void btif_a2dp_data_cb(tUIPC_CH_ID ch_id, tUIPC_EVENT event);
|
static void btif_a2dp_ctrl_cb(tUIPC_CH_ID ch_id, tUIPC_EVENT event);
|
|
/* We can have max one command pending */
|
static tA2DP_CTRL_CMD a2dp_cmd_pending = A2DP_CTRL_CMD_NONE;
|
std::unique_ptr<tUIPC_STATE> a2dp_uipc = nullptr;
|
|
void btif_a2dp_control_init(void) {
|
a2dp_uipc = UIPC_Init();
|
UIPC_Open(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, btif_a2dp_ctrl_cb, A2DP_CTRL_PATH);
|
}
|
|
void btif_a2dp_control_cleanup(void) {
|
/* This calls blocks until UIPC is fully closed */
|
if (a2dp_uipc != nullptr) {
|
UIPC_Close(*a2dp_uipc, UIPC_CH_ID_ALL);
|
}
|
}
|
|
static void btif_a2dp_recv_ctrl_data(void) {
|
tA2DP_CTRL_CMD cmd = A2DP_CTRL_CMD_NONE;
|
int n;
|
|
uint8_t read_cmd = 0; /* The read command size is one octet */
|
n = UIPC_Read(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, NULL, &read_cmd, 1);
|
cmd = static_cast<tA2DP_CTRL_CMD>(read_cmd);
|
|
/* detach on ctrl channel means audioflinger process was terminated */
|
if (n == 0) {
|
APPL_TRACE_WARNING("%s: CTRL CH DETACHED", __func__);
|
UIPC_Close(*a2dp_uipc, UIPC_CH_ID_AV_CTRL);
|
return;
|
}
|
|
// Don't log A2DP_CTRL_GET_PRESENTATION_POSITION by default, because it
|
// could be very chatty when audio is streaming.
|
if (cmd == A2DP_CTRL_GET_PRESENTATION_POSITION) {
|
APPL_TRACE_DEBUG("%s: a2dp-ctrl-cmd : %s", __func__,
|
audio_a2dp_hw_dump_ctrl_event(cmd));
|
} else {
|
APPL_TRACE_WARNING("%s: a2dp-ctrl-cmd : %s", __func__,
|
audio_a2dp_hw_dump_ctrl_event(cmd));
|
}
|
|
a2dp_cmd_pending = cmd;
|
switch (cmd) {
|
case A2DP_CTRL_CMD_CHECK_READY:
|
if (btif_a2dp_source_media_task_is_shutting_down()) {
|
APPL_TRACE_WARNING("%s: A2DP command %s while media task shutting down",
|
__func__, audio_a2dp_hw_dump_ctrl_event(cmd));
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE);
|
return;
|
}
|
|
/* check whether AV is ready to setup A2DP datapath */
|
if (btif_av_stream_ready() || btif_av_stream_started_ready()) {
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS);
|
} else {
|
APPL_TRACE_WARNING("%s: A2DP command %s while AV stream is not ready",
|
__func__, audio_a2dp_hw_dump_ctrl_event(cmd));
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE);
|
}
|
break;
|
|
case A2DP_CTRL_CMD_START:
|
/*
|
* Don't send START request to stack while we are in a call.
|
* Some headsets such as "Sony MW600", don't allow AVDTP START
|
* while in a call, and respond with BAD_STATE.
|
*/
|
if (!bluetooth::headset::IsCallIdle()) {
|
APPL_TRACE_WARNING("%s: A2DP command %s while call state is busy",
|
__func__, audio_a2dp_hw_dump_ctrl_event(cmd));
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_INCALL_FAILURE);
|
break;
|
}
|
|
if (btif_a2dp_source_is_streaming()) {
|
APPL_TRACE_WARNING("%s: A2DP command %s while source is streaming",
|
__func__, audio_a2dp_hw_dump_ctrl_event(cmd));
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE);
|
break;
|
}
|
|
if (btif_av_stream_ready()) {
|
/* Setup audio data channel listener */
|
UIPC_Open(*a2dp_uipc, UIPC_CH_ID_AV_AUDIO, btif_a2dp_data_cb,
|
A2DP_DATA_PATH);
|
|
/*
|
* Post start event and wait for audio path to open.
|
* If we are the source, the ACK will be sent after the start
|
* procedure is completed, othewise send it now.
|
*/
|
btif_av_stream_start();
|
if (btif_av_get_peer_sep() == AVDT_TSEP_SRC)
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS);
|
break;
|
}
|
|
if (btif_av_stream_started_ready()) {
|
/*
|
* Already started, setup audio data channel listener and ACK
|
* back immediately.
|
*/
|
UIPC_Open(*a2dp_uipc, UIPC_CH_ID_AV_AUDIO, btif_a2dp_data_cb,
|
A2DP_DATA_PATH);
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS);
|
break;
|
}
|
APPL_TRACE_WARNING("%s: A2DP command %s while AV stream is not ready",
|
__func__, audio_a2dp_hw_dump_ctrl_event(cmd));
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE);
|
break;
|
|
case A2DP_CTRL_CMD_STOP:
|
if (btif_av_get_peer_sep() == AVDT_TSEP_SNK &&
|
!btif_a2dp_source_is_streaming()) {
|
/* We are already stopped, just ack back */
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS);
|
break;
|
}
|
btif_av_stream_stop(RawAddress::kEmpty);
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS);
|
break;
|
|
case A2DP_CTRL_CMD_SUSPEND:
|
/* Local suspend */
|
if (btif_av_stream_started_ready()) {
|
btif_av_stream_suspend();
|
break;
|
}
|
/* If we are not in started state, just ack back ok and let
|
* audioflinger close the channel. This can happen if we are
|
* remotely suspended, clear REMOTE SUSPEND flag.
|
*/
|
btif_av_clear_remote_suspend_flag();
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS);
|
break;
|
|
case A2DP_CTRL_GET_INPUT_AUDIO_CONFIG: {
|
tA2DP_SAMPLE_RATE sample_rate = btif_a2dp_sink_get_sample_rate();
|
tA2DP_CHANNEL_COUNT channel_count = btif_a2dp_sink_get_channel_count();
|
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS);
|
UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,
|
reinterpret_cast<uint8_t*>(&sample_rate),
|
sizeof(tA2DP_SAMPLE_RATE));
|
UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0, &channel_count,
|
sizeof(tA2DP_CHANNEL_COUNT));
|
break;
|
}
|
|
case A2DP_CTRL_GET_OUTPUT_AUDIO_CONFIG: {
|
btav_a2dp_codec_config_t codec_config;
|
btav_a2dp_codec_config_t codec_capability;
|
codec_config.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_NONE;
|
codec_config.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE;
|
codec_config.channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_NONE;
|
codec_capability.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_NONE;
|
codec_capability.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE;
|
codec_capability.channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_NONE;
|
|
A2dpCodecConfig* current_codec = bta_av_get_a2dp_current_codec();
|
if (current_codec != nullptr) {
|
codec_config = current_codec->getCodecConfig();
|
codec_capability = current_codec->getCodecCapability();
|
}
|
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS);
|
// Send the current codec config
|
UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,
|
reinterpret_cast<const uint8_t*>(&codec_config.sample_rate),
|
sizeof(btav_a2dp_codec_sample_rate_t));
|
UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,
|
reinterpret_cast<const uint8_t*>(&codec_config.bits_per_sample),
|
sizeof(btav_a2dp_codec_bits_per_sample_t));
|
UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,
|
reinterpret_cast<const uint8_t*>(&codec_config.channel_mode),
|
sizeof(btav_a2dp_codec_channel_mode_t));
|
// Send the current codec capability
|
UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,
|
reinterpret_cast<const uint8_t*>(&codec_capability.sample_rate),
|
sizeof(btav_a2dp_codec_sample_rate_t));
|
UIPC_Send(
|
*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,
|
reinterpret_cast<const uint8_t*>(&codec_capability.bits_per_sample),
|
sizeof(btav_a2dp_codec_bits_per_sample_t));
|
UIPC_Send(
|
*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,
|
reinterpret_cast<const uint8_t*>(&codec_capability.channel_mode),
|
sizeof(btav_a2dp_codec_channel_mode_t));
|
break;
|
}
|
|
case A2DP_CTRL_SET_OUTPUT_AUDIO_CONFIG: {
|
btav_a2dp_codec_config_t codec_config;
|
codec_config.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_NONE;
|
codec_config.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE;
|
codec_config.channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_NONE;
|
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS);
|
// Send the current codec config
|
if (UIPC_Read(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,
|
reinterpret_cast<uint8_t*>(&codec_config.sample_rate),
|
sizeof(btav_a2dp_codec_sample_rate_t)) !=
|
sizeof(btav_a2dp_codec_sample_rate_t)) {
|
APPL_TRACE_ERROR("%s: Error reading sample rate from audio HAL",
|
__func__);
|
break;
|
}
|
if (UIPC_Read(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,
|
reinterpret_cast<uint8_t*>(&codec_config.bits_per_sample),
|
sizeof(btav_a2dp_codec_bits_per_sample_t)) !=
|
sizeof(btav_a2dp_codec_bits_per_sample_t)) {
|
APPL_TRACE_ERROR("%s: Error reading bits per sample from audio HAL",
|
__func__);
|
break;
|
}
|
if (UIPC_Read(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,
|
reinterpret_cast<uint8_t*>(&codec_config.channel_mode),
|
sizeof(btav_a2dp_codec_channel_mode_t)) !=
|
sizeof(btav_a2dp_codec_channel_mode_t)) {
|
APPL_TRACE_ERROR("%s: Error reading channel mode from audio HAL",
|
__func__);
|
break;
|
}
|
APPL_TRACE_DEBUG(
|
"%s: A2DP_CTRL_SET_OUTPUT_AUDIO_CONFIG: "
|
"sample_rate=0x%x bits_per_sample=0x%x "
|
"channel_mode=0x%x",
|
__func__, codec_config.sample_rate, codec_config.bits_per_sample,
|
codec_config.channel_mode);
|
btif_a2dp_source_feeding_update_req(codec_config);
|
break;
|
}
|
|
case A2DP_CTRL_CMD_OFFLOAD_START:
|
btif_av_stream_start_offload();
|
break;
|
|
case A2DP_CTRL_GET_PRESENTATION_POSITION: {
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS);
|
|
UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,
|
(uint8_t*)&(delay_report_stats.total_bytes_read),
|
sizeof(uint64_t));
|
UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0,
|
(uint8_t*)&(delay_report_stats.audio_delay), sizeof(uint16_t));
|
|
uint32_t seconds = delay_report_stats.timestamp.tv_sec;
|
UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0, (uint8_t*)&seconds,
|
sizeof(seconds));
|
|
uint32_t nsec = delay_report_stats.timestamp.tv_nsec;
|
UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0, (uint8_t*)&nsec,
|
sizeof(nsec));
|
break;
|
}
|
default:
|
APPL_TRACE_ERROR("%s: UNSUPPORTED CMD (%d)", __func__, cmd);
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE);
|
break;
|
}
|
|
// Don't log A2DP_CTRL_GET_PRESENTATION_POSITION by default, because it
|
// could be very chatty when audio is streaming.
|
if (cmd == A2DP_CTRL_GET_PRESENTATION_POSITION) {
|
APPL_TRACE_DEBUG("%s: a2dp-ctrl-cmd : %s DONE", __func__,
|
audio_a2dp_hw_dump_ctrl_event(cmd));
|
} else {
|
APPL_TRACE_WARNING("%s: a2dp-ctrl-cmd : %s DONE", __func__,
|
audio_a2dp_hw_dump_ctrl_event(cmd));
|
}
|
}
|
|
static void btif_a2dp_ctrl_cb(UNUSED_ATTR tUIPC_CH_ID ch_id,
|
tUIPC_EVENT event) {
|
// Don't log UIPC_RX_DATA_READY_EVT by default, because it
|
// could be very chatty when audio is streaming.
|
if (event == UIPC_RX_DATA_READY_EVT) {
|
APPL_TRACE_DEBUG("%s: A2DP-CTRL-CHANNEL EVENT %s", __func__,
|
dump_uipc_event(event));
|
} else {
|
APPL_TRACE_WARNING("%s: A2DP-CTRL-CHANNEL EVENT %s", __func__,
|
dump_uipc_event(event));
|
}
|
|
switch (event) {
|
case UIPC_OPEN_EVT:
|
break;
|
|
case UIPC_CLOSE_EVT:
|
/* restart ctrl server unless we are shutting down */
|
if (btif_a2dp_source_media_task_is_running())
|
UIPC_Open(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, btif_a2dp_ctrl_cb,
|
A2DP_CTRL_PATH);
|
break;
|
|
case UIPC_RX_DATA_READY_EVT:
|
btif_a2dp_recv_ctrl_data();
|
break;
|
|
default:
|
APPL_TRACE_ERROR("%s: ### A2DP-CTRL-CHANNEL EVENT %d NOT HANDLED ###",
|
__func__, event);
|
break;
|
}
|
}
|
|
static void btif_a2dp_data_cb(UNUSED_ATTR tUIPC_CH_ID ch_id,
|
tUIPC_EVENT event) {
|
APPL_TRACE_WARNING("%s: BTIF MEDIA (A2DP-DATA) EVENT %s", __func__,
|
dump_uipc_event(event));
|
|
switch (event) {
|
case UIPC_OPEN_EVT:
|
/*
|
* Read directly from media task from here on (keep callback for
|
* connection events.
|
*/
|
UIPC_Ioctl(*a2dp_uipc, UIPC_CH_ID_AV_AUDIO,
|
UIPC_REG_REMOVE_ACTIVE_READSET, NULL);
|
UIPC_Ioctl(*a2dp_uipc, UIPC_CH_ID_AV_AUDIO, UIPC_SET_READ_POLL_TMO,
|
reinterpret_cast<void*>(A2DP_DATA_READ_POLL_MS));
|
|
if (btif_av_get_peer_sep() == AVDT_TSEP_SNK) {
|
/* Start the media task to encode the audio */
|
btif_a2dp_source_start_audio_req();
|
}
|
|
/* ACK back when media task is fully started */
|
break;
|
|
case UIPC_CLOSE_EVT:
|
APPL_TRACE_EVENT("%s: ## AUDIO PATH DETACHED ##", __func__);
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_SUCCESS);
|
/*
|
* Send stop request only if we are actively streaming and haven't
|
* received a stop request. Potentially, the audioflinger detached
|
* abnormally.
|
*/
|
if (btif_a2dp_source_is_streaming()) {
|
/* Post stop event and wait for audio path to stop */
|
btif_av_stream_stop(RawAddress::kEmpty);
|
}
|
break;
|
|
default:
|
APPL_TRACE_ERROR("%s: ### A2DP-DATA EVENT %d NOT HANDLED ###", __func__,
|
event);
|
break;
|
}
|
}
|
|
void btif_a2dp_command_ack(tA2DP_CTRL_ACK status) {
|
uint8_t ack = status;
|
|
// Don't log A2DP_CTRL_GET_PRESENTATION_POSITION by default, because it
|
// could be very chatty when audio is streaming.
|
if (a2dp_cmd_pending == A2DP_CTRL_GET_PRESENTATION_POSITION) {
|
APPL_TRACE_DEBUG("%s: ## a2dp ack : %s, status %d ##", __func__,
|
audio_a2dp_hw_dump_ctrl_event(a2dp_cmd_pending), status);
|
} else {
|
APPL_TRACE_WARNING("%s: ## a2dp ack : %s, status %d ##", __func__,
|
audio_a2dp_hw_dump_ctrl_event(a2dp_cmd_pending), status);
|
}
|
|
/* Sanity check */
|
if (a2dp_cmd_pending == A2DP_CTRL_CMD_NONE) {
|
APPL_TRACE_ERROR("%s: warning : no command pending, ignore ack", __func__);
|
return;
|
}
|
|
/* Clear pending */
|
a2dp_cmd_pending = A2DP_CTRL_CMD_NONE;
|
|
/* Acknowledge start request */
|
if (a2dp_uipc != nullptr) {
|
UIPC_Send(*a2dp_uipc, UIPC_CH_ID_AV_CTRL, 0, &ack, sizeof(ack));
|
}
|
}
|
|
void btif_a2dp_control_log_bytes_read(uint32_t bytes_read) {
|
delay_report_stats.total_bytes_read += bytes_read;
|
clock_gettime(CLOCK_MONOTONIC, &delay_report_stats.timestamp);
|
}
|
|
void btif_a2dp_control_set_audio_delay(uint16_t delay) {
|
APPL_TRACE_DEBUG("%s: DELAY: %.1f ms", __func__, (float)delay / 10);
|
delay_report_stats.audio_delay = delay;
|
}
|
|
void btif_a2dp_control_reset_audio_delay(void) {
|
APPL_TRACE_DEBUG("%s", __func__);
|
delay_report_stats.audio_delay = 0;
|
delay_report_stats.total_bytes_read = 0;
|
delay_report_stats.timestamp = {};
|
}
|
