rudism/pinebuds
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
pinebuds/services/bt_app/app_bt_media_manager.cpp
Ben V. Brown 75381150fd Formatting 
Formatting Pass 1

Lots of fixups to adding stdint and stdbool all over the place

Formatting Pass 2
Formatting Pass 3
Formatting Pass 4

Update app_bt_stream.cpp
2023-02-02 07:56:49 +11:00

2296 lines
78 KiB
C++
Raw Blame History

/***************************************************************************
*
* Copyright 2015-2019 BES.
* All rights reserved. All unpublished rights reserved.
*
* No part of this work may be used or reproduced in any form or by any
* means, or stored in a database or retrieval system, without prior written
* permission of BES.
*
* Use of this work is governed by a license granted by BES.
* This work contains confidential and proprietary information of
* BES. which is protected by copyright, trade secret,
* trademark and other intellectual property rights.
*
****************************************************************************/
#include <assert.h>
#include <stdio.h>
#include "analog.h"
#include "app_audio.h"
#include "app_bt_stream.h"
#include "app_bt_trace.h"
#include "app_overlay.h"
#include "app_utils.h"
#include "audioflinger.h"
#include "cmsis.h"
#include "cmsis_os.h"
#include "hal_chipid.h"
#include "hal_cmu.h"
#include "hal_timer.h"
#include "hal_trace.h"
#include "hal_uart.h"
#include "lockcqueue.h"
#include "nvrecord.h"
#if defined(IBRT)
#include "app_ibrt_if.h"
#else
#include "app_media_player.h"
#endif
#include "resources.h"
#ifdef MEDIA_PLAYER_SUPPORT
#include "app_media_player.h"
#endif
#include "app_bt_func.h"
#include "apps.h"
#include "bt_drv.h"
#include "besbt.h"
#include "app_hfp.h"
#include "btapp.h"
#include "cqueue.h"
#include "app_bt_media_manager.h"
#include "app_thread.h"
#include "app_ai_if.h"
#include "app_ring_merge.h"
#include "audio_prompt_sbc.h"
#include "bt_if.h"
int bt_sco_player_forcemute(bool mic_mute, bool spk_mute);
int bt_sco_player_get_codetype(void);
extern struct BT_DEVICE_T app_bt_device;
extern enum AUD_SAMPRATE_T a2dp_sample_rate;
struct bt_media_manager {
uint16_t media_active[BT_DEVICE_NUM];
uint8_t media_current_call_state[BT_DEVICE_NUM];
uint8_t media_curr_sbc;
uint8_t media_curr_sco;
uint16_t curr_active_media; // low 8 bits are out direciton, while high 8 bits
// are in direction
};
static char _strm_type_str[168];
static char *_catstr(char *dst, const char *src) {
while (*dst)
dst++;
while ((*dst++ = *src++))
;
return --dst;
}
static const char *strmtype2str(uint16_t stream_type) {
const char *s = NULL;
char _cat = 0, first = 1, *d = NULL;
_strm_type_str[0] = '\0';
d = _strm_type_str;
d = _catstr(d, "[");
if (stream_type != 0) {
for (int i = 15; i >= 0; i--) {
_cat = 1;
// TRACE_AUD_MGR_I("i=%d,stream_type=0x%d,stream_type&(1<<i)=0x%x", i,
// stream_type, stream_type&(1<<i));
switch (stream_type & (1 << i)) {
case 0:
_cat = 0;
break;
case BT_STREAM_SBC:
s = "SBC";
break;
case BT_STREAM_MEDIA:
s = "MEDIA";
break;
case BT_STREAM_VOICE:
s = "VOICE";
break;
#ifdef RB_CODEC
case BT_STREAM_RBCODEC:
s = "RB_CODEC";
break;
#endif
// direction is in
#ifdef VOICE_DATAPATH
case BT_STREAM_CAPTURE:
s = "CAPTURE";
break;
#endif
#ifdef __AI_VOICE__
case BT_STREAM_AI_VOICE:
s = "AI_VOICE";
break;
#endif
#ifdef __THIRDPARTY
case BT_STREAM_THIRDPARTY_VOICE:
s = "THIRDPARTY";
break;
#endif
#ifdef AUDIO_LINEIN
case BT_STREAM_LINEIN:
s = "LINEIN";
break;
#endif
default:
s = "UNKNOWN";
break;
}
if (_cat) {
if (!first)
d = _catstr(d, "|");
// TRACE_AUD_MGR_I("d=%s,s=%s", d, s);
d = _catstr(d, s);
first = 0;
}
}
}
_catstr(d, "]");
return _strm_type_str;
}
static const char *handleId2str(uint8_t id) {
#define CASE_M(s) \
case APP_BT_STREAM_MANAGER_##s: \
return "[" #s "]";
switch (id) {
CASE_M(START)
CASE_M(STOP)
CASE_M(SWITCHTO_SCO)
CASE_M(STOP_MEDIA)
CASE_M(UPDATE_MEDIA)
CASE_M(SWAP_SCO)
CASE_M(CTRL_VOLUME)
CASE_M(TUNE_SAMPLERATE_RATIO)
}
return "[]";
}
extern enum AUD_SAMPRATE_T sco_sample_rate;
static struct bt_media_manager bt_meida;
uint16_t bt_media_get_media_active(enum BT_DEVICE_ID_T device_id) {
return bt_meida.media_active[device_id];
}
uint8_t bt_media_is_media_active_by_type(uint16_t media_type) {
uint8_t i;
for (i = 0; i < BT_DEVICE_NUM; i++) {
if (bt_meida.media_active[i] & media_type)
return 1;
}
return 0;
}
bool bt_media_is_media_idle(void) {
uint8_t i;
for (i = 0; i < BT_DEVICE_NUM; i++) {
if (bt_meida.media_active[i] != 0)
return false;
}
return true;
}
void bt_media_clean_up(void) {
bt_meida.curr_active_media = 0;
for (uint8_t index = 0; index < BT_DEVICE_NUM; index++) {
bt_meida.media_active[index] = 0;
}
}
bool bt_media_is_media_active_by_sbc(void) {
uint8_t i;
for (i = 0; i < BT_DEVICE_NUM; i++) {
if (bt_meida.media_active[i] & BT_STREAM_SBC)
return 1;
}
return 0;
}
bool bt_is_sco_media_open(void) {
return (bt_meida.curr_active_media == BT_STREAM_VOICE) ? (true) : (false);
}
static enum BT_DEVICE_ID_T
bt_media_get_active_device_by_type(uint16_t media_type) {
uint8_t i;
for (i = 0; i < BT_DEVICE_NUM; i++) {
if (bt_meida.media_active[i] & media_type)
return (enum BT_DEVICE_ID_T)i;
}
return BT_DEVICE_NUM;
}
uint8_t bt_media_is_media_active_by_device(uint16_t media_type,
enum BT_DEVICE_ID_T device_id) {
if (bt_meida.media_active[device_id] & media_type)
return 1;
return 0;
}
uint16_t bt_media_get_current_media(void) { return bt_meida.curr_active_media; }
bool bt_media_cur_is_bt_stream_media(void) {
return (BT_STREAM_MEDIA & bt_meida.curr_active_media) ? (true) : (false);
}
bool bt_media_is_sbc_media_active(void) {
return (bt_media_is_media_active_by_type(BT_STREAM_SBC) == 1) ? (true)
: (false);
}
void bt_media_current_sbc_set(uint8_t id) {
TRACE_AUD_MGR_I("current sbc %d->%d", bt_meida.media_curr_sbc, id);
bt_meida.media_curr_sbc = id;
}
static void bt_media_set_current_media(uint16_t media_type) {
// out direction
if (media_type < 0x100) {
bt_meida.curr_active_media &= (~0xFF);
bt_meida.curr_active_media |= media_type;
} else {
// bt_meida.curr_active_media &= (~0xFF00);
bt_meida.curr_active_media |= media_type;
}
TRACE_AUD_MGR_I("curr_active_media is set to 0x%x->:%s",
bt_meida.curr_active_media,
strmtype2str(bt_meida.curr_active_media));
}
static void bt_media_clear_current_media(uint16_t media_type) {
if (media_type < 0x100) {
bt_meida.curr_active_media &= (~0xFF);
} else {
bt_meida.curr_active_media &= (~media_type);
}
TRACE_AUD_MGR_I("clear media 0x%x curr media 0x%x", media_type,
bt_meida.curr_active_media);
}
#ifdef VOICE_DATAPATH
#if !ISOLATED_AUDIO_STREAM_ENABLED
static void bt_media_clear_all_media_type(void) {
uint8_t i;
for (i = 0; i < BT_DEVICE_NUM; i++) {
bt_meida.media_active[i] &= (~BT_STREAM_MEDIA);
}
}
#endif
#endif
static uint8_t bt_media_set_media_type(uint16_t media_type,
enum BT_DEVICE_ID_T device_id) {
TRACE_AUD_MGR_I("[MEDIA_TYPE][SET] 0x%x active_now 0x%x id %d", media_type,
bt_meida.media_active[0], device_id);
if (device_id < BT_DEVICE_NUM) {
bt_meida.media_active[device_id] |= media_type;
} else {
TRACE_AUD_MGR_W("[MEDIA_TYPE][SET] invalid devcie_id:%d", device_id);
}
return 0;
}
void bt_media_clear_media_type(uint16_t media_type,
enum BT_DEVICE_ID_T device_id) {
TRACE_AUD_MGR_I("[MEDIA_TYPE][CLR] 0x%x active_now 0x%x id %d", media_type,
bt_meida.media_active[0], device_id);
if (media_type == BT_STREAM_MEDIA) {
for (uint8_t i = 0; i < BT_DEVICE_NUM; i++) {
bt_meida.media_active[i] &= (~media_type);
}
} else {
bt_meida.media_active[device_id] &= (~media_type);
}
}
static enum BT_DEVICE_ID_T bt_media_get_active_sbc_device(void) {
enum BT_DEVICE_ID_T device = BT_DEVICE_NUM;
uint8_t i;
for (i = 0; i < BT_DEVICE_NUM; i++) {
if ((bt_meida.media_active[i] & BT_STREAM_SBC) &&
(i == bt_meida.media_curr_sbc))
device = (enum BT_DEVICE_ID_T)i;
}
return device;
}
#ifdef RB_CODEC
bool bt_media_rbcodec_start_process(uint16_t stream_type,
enum BT_DEVICE_ID_T device_id,
AUD_ID_ENUM media_id, uint32_t param,
uint32_t ptr) {
int ret_SendReq2AudioThread = -1;
bt_meida.media_active[device_id] |= stream_type;
ret_SendReq2AudioThread = app_audio_sendrequest(
APP_BT_STREAM_RBCODEC, (uint8_t)APP_BT_SETTING_OPEN, media_id);
bt_media_set_current_media(BT_STREAM_RBCODEC);
return true;
exit:
return false;
}
#endif
#ifdef VOICE_DATAPATH
static bool bt_media_voicepath_start_process(uint16_t stream_type,
enum BT_DEVICE_ID_T device_id,
AUD_ID_ENUM media_id,
uint32_t param, uint32_t ptr) {
bt_meida.media_active[device_id] |= stream_type;
app_audio_sendrequest(APP_BT_STREAM_VOICEPATH, (uint8_t)APP_BT_SETTING_OPEN,
media_id);
bt_media_set_current_media(BT_STREAM_CAPTURE);
return true;
}
#endif
#ifdef __AI_VOICE__
static bool bt_media_ai_voice_start_process(uint16_t stream_type,
enum BT_DEVICE_ID_T device_id,
AUD_ID_ENUM media_id,
uint32_t param, uint32_t ptr) {
bt_meida.media_active[device_id] |= stream_type;
app_audio_sendrequest(APP_BT_STREAM_AI_VOICE, (uint8_t)APP_BT_SETTING_OPEN,
media_id);
bt_media_set_current_media(BT_STREAM_AI_VOICE);
return true;
}
#endif
#ifdef __THIRDPARTY
static bool bt_media_thirdparty_voice_start_process(
uint16_t stream_type, enum BT_DEVICE_ID_T device_id, AUD_ID_ENUM media_id,
uint32_t param, uint32_t ptr) {
bt_meida.media_active[device_id] |= stream_type;
app_audio_sendrequest(APP_BT_STREAM_THIRDPARTY_VOICE,
(uint8_t)APP_BT_SETTING_OPEN, media_id);
bt_media_set_current_media(BT_STREAM_THIRDPARTY_VOICE);
return true;
}
#endif
void app_stop_a2dp_media_stream(uint8_t devId) {
app_audio_manager_sendrequest(APP_BT_STREAM_MANAGER_STOP, BT_STREAM_SBC,
devId, 0);
}
void app_stop_sco_media_stream(uint8_t devId) {
app_audio_manager_sendrequest(APP_BT_STREAM_MANAGER_STOP, BT_STREAM_VOICE,
devId, 0);
}
// only used in iamain thread ,can't used in other thread or interrupt
void bt_media_start(uint16_t stream_type, enum BT_DEVICE_ID_T device_id,
uint16_t media_id) {
#ifdef __BT_ONE_BRING_TWO__
enum BT_DEVICE_ID_T other_device_id =
(device_id == BT_DEVICE_ID_1) ? BT_DEVICE_ID_2 : BT_DEVICE_ID_1;
#endif
#ifdef MEDIA_PLAYER_SUPPORT
#ifdef MIX_AUDIO_PROMPT_WITH_A2DP_MEDIA_ENABLED
bool isMergingPrompt = true;
#endif
#endif
bt_media_set_media_type(stream_type, device_id);
TRACE_AUD_MGR_I(
"[HANDLE_START] type= 0x%x->:%s,device id = 0x%x,media_id = 0x%x",
stream_type, strmtype2str(stream_type), device_id, media_id);
#ifdef __BT_ONE_BRING_TWO__
TRACE_AUD_MGR_I("[HANDLE_START] media_active[0] = 0x%x->:%s",
bt_meida.media_active[0],
strmtype2str(bt_meida.media_active[0]));
TRACE_AUD_MGR_I("[HANDLE_START] media_active[1] = 0x%x->:%s",
bt_meida.media_active[1],
strmtype2str(bt_meida.media_active[1]));
TRACE_AUD_MGR_I("[HANDLE_START] curr_active_media = 0x%x->:%s",
bt_meida.curr_active_media,
strmtype2str(bt_meida.curr_active_media));
#else
TRACE_AUD_MGR_I("[HANDLE_START] media_active = 0x%x->:%s",
bt_meida.media_active[0],
strmtype2str(bt_meida.media_active[0]));
TRACE_AUD_MGR_I("[HANDLE_START] curr_active_media = 0x%x->:%s",
bt_meida.curr_active_media,
strmtype2str(bt_meida.curr_active_media));
#endif
switch (stream_type) {
#ifdef RB_CODEC
case BT_STREAM_RBCODEC:
if (!bt_media_rbcodec_start_process(stream_type, device_id,
(AUD_ID_ENUM)media_id, NULL, NULL))
goto exit;
break;
#endif
#ifdef VOICE_DATAPATH
case BT_STREAM_CAPTURE:
if (bt_media_get_current_media() & BT_STREAM_CAPTURE) {
TRACE_AUD_MGR_I("[HANDLE_START] capture stream exist ,do nothing");
return;
}
if (bt_media_is_media_active_by_type(BT_STREAM_VOICE)) {
goto exit;
}
#ifdef MEDIA_PLAYER_SUPPORT
#if !ISOLATED_AUDIO_STREAM_ENABLED
if (bt_media_is_media_active_by_type(BT_STREAM_MEDIA)) {
return;
}
#endif
#endif
if (!bt_media_voicepath_start_process(BT_STREAM_CAPTURE, device_id,
(AUD_ID_ENUM)media_id, (uint32_t)NULL,
(uint32_t)NULL))
goto exit;
break;
#endif
#ifdef __AI_VOICE__
case BT_STREAM_AI_VOICE:
if (bt_media_get_current_media() & BT_STREAM_AI_VOICE) {
TRACE_AUD_MGR_I("[HANDLE_START] ai voice stream exist ,do nothing");
return;
}
if (bt_media_is_media_active_by_type(BT_STREAM_VOICE)) {
TRACE_AUD_MGR_I("[HANDLE_START] SCO stream exist ,do nothing");
goto exit;
}
if (bt_media_is_media_active_by_type(BT_STREAM_SBC)) {
if (bt_media_get_current_media() & BT_STREAM_SBC) {
TRACE_AUD_MGR_I("[HANDLE_START] CLOSE SBC.");
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
bt_media_clear_current_media(BT_STREAM_SBC);
}
}
if (!bt_media_ai_voice_start_process(BT_STREAM_AI_VOICE, device_id,
(AUD_ID_ENUM)media_id, (uint32_t)NULL,
(uint32_t)NULL))
goto exit;
break;
#endif
#ifdef __THIRDPARTY
case BT_STREAM_THIRDPARTY_VOICE:
if (bt_media_get_current_media() & BT_STREAM_THIRDPARTY_VOICE) {
TRACE_AUD_MGR_I(
"[HANDLE_START]there is a thirdparty voice stream exist ,do nothing");
return;
}
if (bt_media_is_media_active_by_type(BT_STREAM_VOICE)) {
TRACE_AUD_MGR_I("[HANDLE_START]there is a SCO stream exist ,do nothing");
goto exit;
}
if (!bt_media_thirdparty_voice_start_process(
BT_STREAM_THIRDPARTY_VOICE, device_id, (AUD_ID_ENUM)media_id,
(uint32_t)NULL, (uint32_t)NULL))
goto exit;
break;
#endif
case BT_STREAM_SBC: {
uint8_t media_pre_sbc = bt_meida.media_curr_sbc;
////because voice is the highest priority and media report will stop soon
//// so just store the sbc type
if (bt_meida.media_curr_sbc == BT_DEVICE_NUM)
bt_meida.media_curr_sbc = device_id;
TRACE_AUD_MGR_I("[HANDLE_START] pre/cur_sbc = %d/%d", media_pre_sbc,
bt_meida.media_curr_sbc);
#ifdef MEDIA_PLAYER_SUPPORT
#ifdef MIX_AUDIO_PROMPT_WITH_A2DP_MEDIA_ENABLED
/// clear the pending stop flag if it is set
audio_prompt_clear_pending_stream(PENDING_TO_STOP_A2DP_STREAMING);
#endif
if (bt_media_is_media_active_by_type(BT_STREAM_MEDIA)) {
goto exit;
}
#endif
#ifdef RB_CODEC
if (bt_media_is_media_active_by_type(BT_STREAM_RBCODEC)) {
goto exit;
}
#endif
#ifdef VOICE_DATAPATH
#if !ISOLATED_AUDIO_STREAM_ENABLED
if (bt_media_is_media_active_by_type(BT_STREAM_CAPTURE)) {
goto exit;
}
#endif
#endif
#ifdef __AI_VOICE__
if (bt_media_is_media_active_by_type(BT_STREAM_AI_VOICE) ||
ai_if_is_ai_stream_mic_open()) {
TRACE_AUD_MGR_I("[HANDLE_START] ai voice stream exist");
goto exit;
}
#endif
#ifdef AUDIO_LINEIN
if (bt_media_is_media_active_by_type(BT_STREAM_LINEIN)) {
if (bt_media_get_current_media() & BT_STREAM_LINEIN) {
app_audio_manager_sendrequest(APP_BT_STREAM_MANAGER_STOP,
(uint8_t)BT_STREAM_LINEIN, 0, 0);
app_audio_manager_sendrequest(APP_BT_STREAM_MANAGER_START,
BT_STREAM_SBC, device_id, 0);
return;
}
}
#endif
if (bt_media_is_media_active_by_type(BT_STREAM_VOICE)) {
////sbc and voice is all on so set sys freq to 104m
app_sysfreq_req(APP_SYSFREQ_USER_APP_0, APP_SYSFREQ_104M);
return;
}
#ifdef __BT_ONE_BRING_TWO__
else if (btapp_hfp_is_call_active()) {
// do nothing
TRACE_AUD_MGR_I("[HANDLE_START] skip sbc start, because HF_CALL_ACTIVE");
} else if (bt_media_is_media_active_by_device(BT_STREAM_SBC,
other_device_id)) {
#if !defined(__MULTIPOINT_A2DP_PREEMPT__)
// if another device is the active stream do nothing
if (bt_meida.media_curr_sbc == other_device_id) {
/// 2 device is play sbc,so set sys freq to 104m
app_audio_manager_switch_a2dp(
(enum BT_DEVICE_ID_T)bt_meida.media_curr_sbc);
app_audio_sendrequest_param((uint8_t)APP_BT_STREAM_A2DP_SBC,
(uint8_t)APP_BT_SETTING_RESTART, 0,
APP_SYSFREQ_104M);
return;
}
#else
if (bt_meida.media_curr_sbc == other_device_id) {
app_audio_manager_switch_a2dp(device_id);
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)(APP_BT_SETTING_SETUP),
(uint32_t)(app_bt_device.sample_rate[device_id] &
A2D_STREAM_SAMP_FREQ_MSK));
app_audio_sendrequest_param(APP_BT_STREAM_A2DP_SBC,
(uint8_t)APP_BT_SETTING_RESTART, 0,
APP_SYSFREQ_104M);
return;
}
#endif
////if curr active media is not sbc,wrong~~
if (0 == (bt_media_get_current_media() & BT_STREAM_SBC)) {
ASSERT(0, "curr_active_media is wrong!");
}
/// stop the old audio sbc and start the new audio sbc
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
}
#endif
else {
// start audio sbc stream
if (media_pre_sbc != bt_meida.media_curr_sbc) {
app_audio_manager_switch_a2dp(device_id);
bt_media_set_current_media(BT_STREAM_SBC);
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)(APP_BT_SETTING_SETUP),
(uint32_t)(app_bt_device.sample_rate[device_id] &
A2D_STREAM_SAMP_FREQ_MSK));
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)APP_BT_SETTING_OPEN, 0);
}
}
} break;
#ifdef MEDIA_PLAYER_SUPPORT
case BT_STREAM_MEDIA:
#ifdef MIX_AUDIO_PROMPT_WITH_A2DP_MEDIA_ENABLED
isMergingPrompt = IS_PROMPT_NEED_MERGING(media_id);
#endif
if (
#ifdef MIX_AUDIO_PROMPT_WITH_A2DP_MEDIA_ENABLED
audio_prompt_is_playing_ongoing() ||
#endif
app_audio_list_playback_exist()) {
if (!bt_media_cur_is_bt_stream_media()) {
bt_media_clear_media_type(BT_STREAM_MEDIA, device_id);
}
media_id = PROMPT_ID_FROM_ID_VALUE(media_id);
APP_AUDIO_STATUS aud_status;
aud_status.id = APP_PLAY_BACK_AUDIO;
aud_status.aud_id = media_id;
app_audio_list_append(&aud_status);
break;
}
#ifdef AUDIO_LINEIN
if (bt_media_is_media_active_by_type(BT_STREAM_LINEIN)) {
if (bt_media_get_current_media() & BT_STREAM_LINEIN) {
APP_AUDIO_STATUS aud_status;
aud_status.id = media_id;
app_play_audio_lineinmode_start(&aud_status);
bt_media_clear_media_type(BT_STREAM_MEDIA, device_id);
}
} else
#endif
// first,if the voice is active so mix "dudu" to the stream
if (bt_media_is_media_active_by_type(BT_STREAM_VOICE)) {
if (bt_media_get_current_media() & BT_STREAM_VOICE) {
#ifdef MIX_AUDIO_PROMPT_WITH_A2DP_MEDIA_ENABLED
// if the playback is not triggered yet, we just use the stand-alone
// prompt playing
if (!bt_is_playback_triggered()) {
isMergingPrompt = false;
}
#endif
// if call is not active so do media report
if ((btapp_hfp_is_call_active() && !btapp_hfp_incoming_calls()) ||
(app_bt_stream_isrun(APP_BT_STREAM_HFP_PCM))) {
#ifdef MIX_AUDIO_PROMPT_WITH_A2DP_MEDIA_ENABLED
bt_media_clear_media_type(BT_STREAM_MEDIA, device_id);
if (isMergingPrompt) {
audio_prompt_start_playing(media_id, sco_sample_rate);
goto exit;
} else {
app_audio_sendrequest(APP_BT_STREAM_HFP_PCM,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
app_audio_sendrequest(APP_PLAY_BACK_AUDIO,
(uint8_t)APP_BT_SETTING_OPEN, media_id);
bt_media_set_current_media(BT_STREAM_MEDIA);
}
#else
// in three way call merge "dudu"
TRACE_AUD_MGR_I(
"[HANDLE_START] BT_STREAM_VOICE-->app_ring_merge_start\n");
app_ring_merge_start();
// meida is done here
bt_media_clear_media_type(BT_STREAM_MEDIA, device_id);
#endif
} else {
#ifdef MIX_AUDIO_PROMPT_WITH_A2DP_MEDIA_ENABLED
bt_media_clear_media_type(BT_STREAM_MEDIA, device_id);
if (isMergingPrompt) {
audio_prompt_start_playing(media_id, sco_sample_rate);
goto exit;
} else {
app_audio_sendrequest(APP_BT_STREAM_HFP_PCM,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
app_audio_sendrequest(APP_PLAY_BACK_AUDIO,
(uint8_t)APP_BT_SETTING_OPEN, media_id);
bt_media_set_current_media(BT_STREAM_MEDIA);
}
#else
TRACE_AUD_MGR_I("[HANDLE_START] stop sco and do media report\n");
bt_media_set_current_media(BT_STREAM_MEDIA);
app_audio_sendrequest(APP_BT_STREAM_HFP_PCM,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
app_audio_sendrequest(APP_PLAY_BACK_AUDIO,
(uint8_t)APP_BT_SETTING_OPEN, media_id);
#endif
}
} else if (bt_media_get_current_media() & BT_STREAM_MEDIA) {
bt_media_set_current_media(BT_STREAM_MEDIA);
app_audio_sendrequest(APP_PLAY_BACK_AUDIO, (uint8_t)APP_BT_SETTING_OPEN,
media_id);
} else {
/// if voice is active but current is not voice something is unkown
bt_media_clear_media_type(BT_STREAM_MEDIA, device_id);
#ifdef __BT_ONE_BRING_TWO__
TRACE_AUD_MGR_I(
"[HANDLE_START] voice_act media_act = %x,%x,curr_media = %x",
bt_meida.media_active[0], bt_meida.media_active[1],
bt_meida.curr_active_media);
#else
TRACE_AUD_MGR_I(
"[HANDLE_START] voice_act media_act = %x,curr_media = %x",
bt_meida.media_active[0], bt_meida.curr_active_media);
#endif
}
} else if (btapp_hfp_is_call_active()) {
bt_media_set_current_media(BT_STREAM_MEDIA);
app_audio_sendrequest(APP_PLAY_BACK_AUDIO, (uint8_t)APP_BT_SETTING_OPEN,
media_id);
}
#ifdef VOICE_DATAPATH
#if !ISOLATED_AUDIO_STREAM_ENABLED
else if (bt_media_is_media_active_by_type(BT_STREAM_CAPTURE)) {
if (bt_media_get_current_media() & BT_STREAM_MEDIA) {
app_audio_sendrequest(APP_PLAY_BACK_AUDIO, (uint8_t)APP_BT_SETTING_OPEN,
media_id);
} else {
goto exit;
}
}
#endif
#endif
////if sbc active so
else if (bt_media_is_media_active_by_type(BT_STREAM_SBC)) {
if (bt_media_get_current_media() & BT_STREAM_SBC) {
#ifdef MIX_AUDIO_PROMPT_WITH_A2DP_MEDIA_ENABLED
// if the playback is not triggered yet, we just use the stand-alone
// prompt playing
if (!bt_is_playback_triggered()) {
isMergingPrompt = false;
}
bt_media_clear_media_type(BT_STREAM_MEDIA, device_id);
if (isMergingPrompt) {
audio_prompt_start_playing(media_id, a2dp_sample_rate);
goto exit;
} else {
TRACE_AUD_MGR_I("[HANDLE_START] START prompt.");
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
bt_media_set_current_media(BT_STREAM_MEDIA);
app_audio_sendrequest(APP_PLAY_BACK_AUDIO,
(uint8_t)APP_BT_SETTING_OPEN, media_id);
}
#else
#ifdef __BT_WARNING_TONE_MERGE_INTO_STREAM_SBC__
if (PROMPT_ID_FROM_ID_VALUE(media_id) == AUD_ID_BT_WARNING) {
TRACE_AUD_MGR_I(
"[HANDLE_START] BT_STREAM_SBC-->app_ring_merge_start\n");
app_ring_merge_start();
// meida is done here
bt_media_clear_media_type(BT_STREAM_MEDIA, device_id);
} else
#endif
{
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
bt_media_set_current_media(BT_STREAM_MEDIA);
app_audio_sendrequest(APP_PLAY_BACK_AUDIO,
(uint8_t)APP_BT_SETTING_OPEN, media_id);
}
#endif // #ifdef MIX_AUDIO_PROMPT_WITH_A2DP_MEDIA_ENABLED
} else if (bt_media_get_current_media() & BT_STREAM_MEDIA) {
app_audio_sendrequest(APP_PLAY_BACK_AUDIO, (uint8_t)APP_BT_SETTING_OPEN,
media_id);
} else if ((bt_media_get_current_media() & 0xFF) == 0) {
app_audio_sendrequest(APP_PLAY_BACK_AUDIO, (uint8_t)APP_BT_SETTING_OPEN,
media_id);
} else {
ASSERT(0, "media in sbc current wrong");
}
}
/// just play the media
else {
bt_media_set_current_media(BT_STREAM_MEDIA);
app_audio_sendrequest(APP_PLAY_BACK_AUDIO, (uint8_t)APP_BT_SETTING_OPEN,
media_id);
}
break;
#endif
case BT_STREAM_VOICE:
#ifdef HFP_NO_PRERMPT
if (app_audio_manager_get_active_sco_num() != BT_DEVICE_NUM)
return;
#endif
app_audio_manager_set_active_sco_num(device_id);
#ifdef VOICE_DATAPATH
if (bt_media_is_media_active_by_type(BT_STREAM_CAPTURE)) {
if (bt_media_get_current_media() & BT_STREAM_CAPTURE) {
app_audio_sendrequest(APP_BT_STREAM_VOICEPATH,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
bt_media_clear_current_media(BT_STREAM_CAPTURE);
}
}
#endif
#ifdef __AI_VOICE__
if (bt_media_is_media_active_by_type(BT_STREAM_AI_VOICE)) {
if (bt_media_get_current_media() & BT_STREAM_AI_VOICE) {
app_audio_sendrequest(APP_BT_STREAM_AI_VOICE,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
bt_media_clear_current_media(BT_STREAM_AI_VOICE);
}
}
#endif
#ifdef __THIRDPARTY
if (bt_media_is_media_active_by_type(BT_STREAM_THIRDPARTY_VOICE)) {
if (bt_media_get_current_media() & BT_STREAM_THIRDPARTY_VOICE) {
app_audio_sendrequest(APP_BT_STREAM_THIRDPARTY_VOICE,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
bt_media_clear_current_media(BT_STREAM_THIRDPARTY_VOICE);
}
}
#endif
#ifdef MEDIA_PLAYER_SUPPORT
#ifdef MIX_AUDIO_PROMPT_WITH_A2DP_MEDIA_ENABLED
/// clear the pending stop flag if it is set
audio_prompt_clear_pending_stream(PENDING_TO_STOP_A2DP_STREAMING);
#endif
if (bt_media_is_media_active_by_type(BT_STREAM_MEDIA)) {
// if call is active ,so disable media report
if (bt_media_is_media_active_by_type(BT_STREAM_VOICE)) {
if (bt_media_get_current_media() & BT_STREAM_MEDIA) {
if (app_play_audio_get_aud_id() == AUD_ID_BT_CALL_INCOMING_NUMBER) {
// if meida is open ,close media clear all media type
TRACE_AUD_MGR_I("[HANDLE_START] call active so start sco and stop "
"media report\n");
#ifdef __AUDIO_QUEUE_SUPPORT__
app_audio_list_clear();
#endif
app_audio_sendrequest(APP_PLAY_BACK_AUDIO,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
bt_media_clear_media_type(BT_STREAM_MEDIA, device_id);
bt_media_set_current_media(BT_STREAM_VOICE);
app_audio_sendrequest(APP_BT_STREAM_HFP_PCM,
(uint8_t)APP_BT_SETTING_OPEN, 0);
}
}
} else {
////call is not active so media report continue
}
} else
#endif
if (bt_media_is_media_active_by_type(BT_STREAM_SBC)) {
/// if sbc is open stop sbc
if (bt_media_get_current_media() & BT_STREAM_SBC) {
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
}
////start voice stream
bt_media_set_current_media(BT_STREAM_VOICE);
app_audio_sendrequest_param(APP_BT_STREAM_HFP_PCM,
(uint8_t)APP_BT_SETTING_OPEN, 0,
APP_SYSFREQ_104M);
} else {
// voice is open already so do nothing
if (bt_media_get_current_media() & BT_STREAM_VOICE) {
#if defined(__BT_ONE_BRING_TWO__)
if (bt_get_sco_number() > 1
#ifdef CHIP_BEST1000
&& hal_get_chip_metal_id() >= HAL_CHIP_METAL_ID_2
#endif
) {
app_audio_manager_swap_sco(device_id);
#if defined(__HF_KEEP_ONE_ALIVE__)
if (btif_hf_check_AudioConnect_status(
app_bt_device.hf_channel[other_device_id])) {
TRACE_AUD_MGR_I("[MEDIA_START] Disconnect another AudioLink");
btif_hf_disc_audio_link(app_bt_device.hf_channel[other_device_id]);
}
#endif
}
#endif
} else {
bt_media_set_current_media(BT_STREAM_VOICE);
app_audio_sendrequest(APP_BT_STREAM_HFP_PCM,
(uint8_t)APP_BT_SETTING_OPEN, 0);
}
}
break;
#ifdef AUDIO_LINEIN
case BT_STREAM_LINEIN:
if (!bt_media_is_media_active_by_type(BT_STREAM_SBC | BT_STREAM_MEDIA |
BT_STREAM_VOICE)) {
app_audio_sendrequest(APP_PLAY_LINEIN_AUDIO, (uint8_t)APP_BT_SETTING_OPEN,
0);
bt_media_set_current_media(BT_STREAM_LINEIN);
}
break;
#endif
default:
ASSERT(0, "bt_media_open ERROR TYPE");
break;
}
#if defined(RB_CODEC) || defined(VOICE_DATAPATH) || \
defined(MEDIA_PLAYER_SUPPORT) || defined(__AI_VOICE__)
exit:
return;
#endif
}
#ifdef RB_CODEC
static bool bt_media_rbcodec_stop_process(uint16_t stream_type,
enum BT_DEVICE_ID_T device_id,
uint32_t ptr) {
int ret_SendReq2AudioThread = -1;
bt_media_clear_media_type(stream_type, device_id);
// if current stream is the stop one ,so stop it
if (bt_media_get_current_media() & BT_STREAM_RBCODEC) {
ret_SendReq2AudioThread = app_audio_sendrequest(
APP_BT_STREAM_RBCODEC, (uint8_t)APP_BT_SETTING_CLOSE, ptr);
bt_media_clear_current_media(BT_STREAM_RBCODEC);
TRACE_AUD_MGR_I("[RBCODEC][STOPED]");
}
if (bt_media_is_media_active_by_type(BT_STREAM_SBC)) {
enum BT_DEVICE_ID_T sbc_id =
bt_media_get_active_device_by_type(BT_STREAM_SBC);
TRACE_AUD_MGR_I("[RBCODEC][STOPED] sbc_id %d", sbc_id);
if (sbc_id < BT_DEVICE_NUM) {
bt_meida.media_curr_sbc = sbc_id;
}
} else {
bt_meida.media_curr_sbc = BT_DEVICE_NUM;
}
TRACE_AUD_MGR_I("[RBCODEC][STOPED] bt_meida.media_curr_sbc %d",
bt_meida.media_curr_sbc);
if (bt_media_is_media_active_by_type(BT_STREAM_VOICE)) {
} else if (bt_media_is_media_active_by_type(BT_STREAM_SBC)) {
enum BT_DEVICE_ID_T sbc_id =
bt_media_get_active_device_by_type(BT_STREAM_SBC);
if (sbc_id < BT_DEVICE_NUM) {
#ifdef __TWS__
bt_media_clear_media_type(BT_STREAM_SBC, sbc_id);
bt_media_clear_current_media(BT_STREAM_SBC);
notify_tws_player_status(APP_BT_SETTING_OPEN);
#else
bt_parse_store_sbc_sample_rate(app_bt_device.sample_rate[sbc_id]);
ret_SendReq2AudioThread = app_audio_sendrequest(
APP_BT_STREAM_A2DP_SBC, (uint8_t)APP_BT_SETTING_OPEN, 0);
bt_media_set_current_media(BT_STREAM_SBC);
#endif
}
} else if (bt_media_is_media_active_by_type(BT_STREAM_MEDIA)) {
// do nothing
}
}
#endif
#ifdef VOICE_DATAPATH
bool bt_media_voicepath_stop_process(uint16_t stream_type,
enum BT_DEVICE_ID_T device_id) {
int ret_SendReq2AudioThread __attribute__((unused));
ret_SendReq2AudioThread = -1;
bt_media_clear_media_type(stream_type, device_id);
// if current stream is the stop one ,so stop it
if (bt_media_get_current_media() & BT_STREAM_CAPTURE) {
ret_SendReq2AudioThread = app_audio_sendrequest(
APP_BT_STREAM_VOICEPATH, (uint8_t)APP_BT_SETTING_CLOSE, 0);
bt_media_clear_current_media(BT_STREAM_CAPTURE);
TRACE_AUD_MGR_I("[VOICEPATH][STOPED] Voice Path STOPED! ");
}
if (bt_media_is_media_active_by_type(BT_STREAM_SBC)) {
enum BT_DEVICE_ID_T sbc_id =
bt_media_get_active_device_by_type(BT_STREAM_SBC);
TRACE_AUD_MGR_I("[VOICEPATH][STOPED] sbc_id %d", sbc_id);
if (sbc_id < BT_DEVICE_NUM) {
bt_meida.media_curr_sbc = sbc_id;
}
} else {
bt_meida.media_curr_sbc = BT_DEVICE_NUM;
}
TRACE_AUD_MGR_I("[VOICEPATH][STOPED] bt_meida.media_curr_sbc %d",
bt_meida.media_curr_sbc);
if (bt_media_is_media_active_by_type(BT_STREAM_VOICE)) {
}
#if !ISOLATED_AUDIO_STREAM_ENABLED
else if (bt_media_is_media_active_by_type(BT_STREAM_MEDIA)) {
app_audio_sendrequest(APP_PLAY_BACK_AUDIO, (uint8_t)APP_BT_SETTING_OPEN, 0);
bt_media_set_current_media(BT_STREAM_MEDIA);
} else if (bt_media_is_media_active_by_type(BT_STREAM_SBC)) {
enum BT_DEVICE_ID_T sbc_id =
bt_media_get_active_device_by_type(BT_STREAM_SBC);
if (sbc_id < BT_DEVICE_NUM) {
#ifdef __TWS__
bt_media_clear_media_type(BT_STREAM_SBC, sbc_id);
bt_media_clear_current_media(BT_STREAM_SBC);
notify_tws_player_status(APP_BT_SETTING_OPEN);
#else
// bt_parse_store_sbc_sample_rate(app_bt_device.sample_rate[sbc_id]);
ret_SendReq2AudioThread = app_audio_sendrequest(
APP_BT_STREAM_A2DP_SBC, (uint8_t)APP_BT_SETTING_OPEN, 0);
bt_media_set_current_media(BT_STREAM_SBC);
#endif
}
}
#endif
return true;
}
#endif
#ifdef __AI_VOICE__
bool bt_media_ai_voice_stop_process(uint16_t stream_type,
enum BT_DEVICE_ID_T device_id) {
bt_media_clear_media_type(BT_STREAM_AI_VOICE, device_id);
// if current stream is the stop one ,stop it
if (bt_media_get_current_media() & BT_STREAM_AI_VOICE) {
app_audio_sendrequest(APP_BT_STREAM_AI_VOICE, (uint8_t)APP_BT_SETTING_CLOSE,
0);
bt_media_clear_current_media(BT_STREAM_AI_VOICE);
TRACE_AUD_MGR_I("[AI_VOICE][STOPED]");
#ifdef IBRT
if (!bt_media_is_media_active_by_type(BT_STREAM_VOICE)) {
app_ibrt_if_force_audio_retrigger();
}
#endif
}
#ifndef IBRT
enum BT_DEVICE_ID_T sbc_id = BT_DEVICE_NUM;
sbc_id = bt_media_get_active_device_by_type(BT_STREAM_SBC);
TRACE_AUD_MGR_I("[AI_VOICE][STOPED] sbc_id %d", sbc_id);
bt_meida.media_curr_sbc = sbc_id;
TRACE_AUD_MGR_I("[AI_VOICE][STOPED] bt_meida.media_curr_sbc %d",
bt_meida.media_curr_sbc);
if (bt_media_is_media_active_by_type(BT_STREAM_VOICE)) {
} else if (sbc_id < BT_DEVICE_NUM) {
if (!(bt_media_get_current_media() & BT_STREAM_SBC)) {
// bt_parse_store_sbc_sample_rate(app_bt_device.sample_rate[sbc_id]);
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)(APP_BT_SETTING_SETUP),
(uint32_t)(app_bt_device.sample_rate[sbc_id] &
A2D_STREAM_SAMP_FREQ_MSK));
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)APP_BT_SETTING_OPEN, 0);
bt_media_set_current_media(BT_STREAM_SBC);
}
}
#endif
return true;
}
#endif
#ifdef __THIRDPARTY
bool bt_media_thirdparty_voice_stop_process(uint16_t stream_type,
enum BT_DEVICE_ID_T device_id) {
bt_media_clear_media_type(BT_STREAM_THIRDPARTY_VOICE, device_id);
// if current stream is the stop one ,stop it
if (bt_media_get_current_media() & BT_STREAM_THIRDPARTY_VOICE) {
app_audio_sendrequest(APP_BT_STREAM_THIRDPARTY_VOICE,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
bt_media_clear_current_media(BT_STREAM_THIRDPARTY_VOICE);
TRACE_AUD_MGR_I("THIRDPARTY VOICE STOPED! ");
}
return true;
}
#endif
/*
bt_media_stop function is called to stop media by app or media play callback
sbc is just stop by a2dp stream suspend or close
voice is just stop by hfp audio disconnect
media is stop by media player finished call back
*/
void bt_media_stop(uint16_t stream_type, enum BT_DEVICE_ID_T device_id) {
TRACE_AUD_MGR_I("[HANDLE_STOP] type= 0x%x->:%s, device id = 0x%x",
stream_type, strmtype2str(stream_type), device_id);
#ifdef __BT_ONE_BRING_TWO__
TRACE_AUD_MGR_I("[HANDLE_STOP] media_active[0] = 0x%x->:%s",
bt_meida.media_active[0],
strmtype2str(bt_meida.media_active[0]));
TRACE_AUD_MGR_I("[HANDLE_STOP] media_active[1] = 0x%x->:%s",
bt_meida.media_active[1],
strmtype2str(bt_meida.media_active[1]));
TRACE_AUD_MGR_I("[HANDLE_STOP] curr_active_media = 0x%x->:%s",
bt_meida.curr_active_media,
strmtype2str(bt_meida.curr_active_media));
#else
TRACE_AUD_MGR_I("[HANDLE_STOP] media_active = 0x%x->:%s",
bt_meida.media_active[0],
strmtype2str(bt_meida.media_active[0]));
TRACE_AUD_MGR_I("[HANDLE_STOP] curr_active_media = 0x%x->:%s",
bt_meida.curr_active_media,
strmtype2str(bt_meida.curr_active_media));
#endif
if (!bt_media_is_media_active_by_device(stream_type, device_id) &&
!(bt_media_get_current_media() & stream_type)) {
return;
}
switch (stream_type) {
#ifdef VOICE_DATAPATH
case BT_STREAM_CAPTURE:
bt_media_voicepath_stop_process(stream_type, device_id);
break;
#endif
#ifdef __AI_VOICE__
case BT_STREAM_AI_VOICE:
bt_media_ai_voice_stop_process(stream_type, device_id);
break;
#endif
#ifdef __THIRDPARTY
case BT_STREAM_THIRDPARTY_VOICE:
bt_media_thirdparty_voice_stop_process(stream_type, device_id);
break;
#endif
case BT_STREAM_SBC: {
#ifdef MIX_AUDIO_PROMPT_WITH_A2DP_MEDIA_ENABLED
if (!audio_prompt_check_on_stopping_stream(PENDING_TO_STOP_A2DP_STREAMING,
device_id)) {
TRACE_AUD_MGR_I("[HANDLE_STOP] Pending stop BT_STREAM_SBC");
return;
}
#else
if (app_ring_merge_isrun()) {
TRACE_AUD_MGR_I("[HANDLE_STOP] pending BT_STREAM_SBC");
app_ring_merge_save_pending_start_stream_op(
PENDING_TO_STOP_A2DP_STREAMING, device_id);
return;
}
#endif
uint8_t media_pre_sbc = bt_meida.media_curr_sbc;
TRACE_AUD_MGR_I("[HANDLE_STOP] SBC STOPPING id:%d/%d",
bt_meida.media_curr_sbc, device_id);
////if current media is sbc ,stop the sbc streaming
bt_media_clear_media_type(stream_type, device_id);
// if current stream is the stop one ,so stop it
if ((bt_media_get_current_media() & BT_STREAM_SBC)
#if !defined(IBRT)
&& bt_meida.media_curr_sbc == device_id
#endif
) {
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
bt_media_clear_current_media(BT_STREAM_SBC);
TRACE_AUD_MGR_I("[HANDLE_STOP] SBC STOPED!");
}
if (bt_media_is_media_active_by_type(BT_STREAM_SBC)) {
enum BT_DEVICE_ID_T sbc_id =
bt_media_get_active_device_by_type(BT_STREAM_SBC);
if (sbc_id < BT_DEVICE_NUM) {
bt_meida.media_curr_sbc = sbc_id;
}
} else {
bt_meida.media_curr_sbc = BT_DEVICE_NUM;
}
if (bt_media_is_media_active_by_type(BT_STREAM_VOICE)) {
} else if (bt_media_is_media_active_by_type(BT_STREAM_MEDIA)) {
// do nothing
}
#ifdef VOICE_DATAPATH
#if !ISOLATED_AUDIO_STREAM_ENABLED
else if (bt_media_is_media_active_by_type(BT_STREAM_CAPTURE)) {
// do nothing
}
#endif
#endif
else if (bt_media_is_media_active_by_type(BT_STREAM_SBC)) {
enum BT_DEVICE_ID_T sbc_id =
bt_media_get_active_device_by_type(BT_STREAM_SBC);
if (sbc_id < BT_DEVICE_NUM &&
(media_pre_sbc != bt_meida.media_curr_sbc)) {
app_audio_manager_switch_a2dp(sbc_id);
bt_media_set_current_media(BT_STREAM_SBC);
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)(APP_BT_SETTING_SETUP),
(uint32_t)(app_bt_device.sample_rate[sbc_id] &
A2D_STREAM_SAMP_FREQ_MSK));
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)APP_BT_SETTING_OPEN, 0);
}
}
} break;
#ifdef MEDIA_PLAYER_SUPPORT
case BT_STREAM_MEDIA:
bt_media_clear_media_type(BT_STREAM_MEDIA, device_id);
if (bt_media_is_media_active_by_type(BT_STREAM_MEDIA)) {
// also have media report so do nothing
} else if (bt_media_is_media_active_by_type(BT_STREAM_VOICE)) {
if (bt_media_get_current_media() & BT_STREAM_VOICE) {
// do nothing
} else if (bt_media_get_current_media() & BT_STREAM_MEDIA) {
/// media report is end ,so goto voice
uint8_t curr_sco_id;
curr_sco_id = app_audio_manager_get_active_sco_num();
if (curr_sco_id != BT_DEVICE_NUM) {
bt_media_set_media_type(BT_STREAM_VOICE,
(enum BT_DEVICE_ID_T)curr_sco_id);
bt_media_set_current_media(BT_STREAM_VOICE);
#ifdef __BT_ONE_BRING_TWO__
app_audio_manager_swap_sco((enum BT_DEVICE_ID_T)curr_sco_id);
#endif
app_audio_sendrequest(APP_BT_STREAM_HFP_PCM,
(uint8_t)APP_BT_SETTING_OPEN, 0);
}
}
} else if (btapp_hfp_is_call_active()) {
// do nothing
}
#ifdef VOICE_DATAPATH
#if !ISOLATED_AUDIO_STREAM_ENABLED
else if (bt_media_is_media_active_by_type(BT_STREAM_CAPTURE)) {
app_audio_sendrequest(APP_BT_STREAM_VOICEPATH,
(uint8_t)APP_BT_SETTING_OPEN, 0);
bt_media_set_current_media(BT_STREAM_CAPTURE);
}
#endif
#endif
#ifdef __AI_VOICE__
else if (bt_media_is_media_active_by_type(BT_STREAM_AI_VOICE) ||
ai_if_is_ai_stream_mic_open()) {
bt_media_clear_current_media(BT_STREAM_MEDIA);
if (bt_media_is_media_active_by_type(BT_STREAM_AI_VOICE) &&
!(bt_media_get_current_media() & BT_STREAM_AI_VOICE)) {
app_audio_sendrequest(APP_BT_STREAM_AI_VOICE,
(uint8_t)APP_BT_SETTING_OPEN, 0);
bt_media_set_current_media(BT_STREAM_AI_VOICE);
}
}
#endif
else if (bt_media_is_media_active_by_type(BT_STREAM_SBC)) {
/// if another device is also in sbc mode
enum BT_DEVICE_ID_T sbc_id = bt_media_get_active_sbc_device();
bt_media_set_media_type(BT_STREAM_SBC, sbc_id);
app_audio_manager_switch_a2dp(sbc_id);
bt_media_set_current_media(BT_STREAM_SBC);
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)(APP_BT_SETTING_SETUP),
(uint32_t)(app_bt_device.sample_rate[sbc_id] &
A2D_STREAM_SAMP_FREQ_MSK));
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)APP_BT_SETTING_OPEN, 0);
} else {
// have no meida task,so goto idle
bt_media_set_current_media(0);
}
break;
#endif
case BT_STREAM_VOICE:
if (!bt_media_is_media_active_by_device(BT_STREAM_VOICE, device_id) ||
!(bt_media_get_current_media() & BT_STREAM_VOICE)) {
TRACE_AUD_MGR_I("[HANDLE_STOP] bt_media_stop already stop");
bt_media_clear_media_type(stream_type, device_id);
return;
}
#ifdef MIX_AUDIO_PROMPT_WITH_A2DP_MEDIA_ENABLED
if (!audio_prompt_check_on_stopping_stream(PENDING_TO_STOP_SCO_STREAMING,
device_id)) {
return;
}
#else
if (app_ring_merge_isrun()) {
TRACE_AUD_MGR_I("[HANDLE_STOP] bt_media_stop pending BT_STREAM_VOICE");
app_ring_merge_save_pending_start_stream_op(PENDING_TO_STOP_SCO_STREAMING,
device_id);
return;
}
#endif
app_audio_manager_set_active_sco_num(BT_DEVICE_NUM);
bt_media_clear_media_type(stream_type, device_id);
#ifdef MEDIA_PLAYER_SUPPORT
if (bt_media_is_media_active_by_type(BT_STREAM_MEDIA)) {
if (bt_media_get_current_media() & BT_STREAM_MEDIA) {
// do nothing
}
#ifdef VOICE_DATAPATH
#if !ISOLATED_AUDIO_STREAM_ENABLED
else if (bt_media_is_media_active_by_type(BT_STREAM_CAPTURE)) {
bt_media_clear_all_media_type();
app_audio_sendrequest(APP_BT_STREAM_VOICEPATH,
(uint8_t)APP_BT_SETTING_OPEN, 0);
bt_media_set_current_media(BT_STREAM_CAPTURE);
}
#endif
#endif
else if (bt_media_get_current_media() & BT_STREAM_VOICE) {
TRACE_AUD_MGR_W("[HANDLE_STOP] voice and media is all on,media should "
"be the current media");
if (!bt_media_is_media_active_by_type(BT_STREAM_VOICE)) {
app_audio_sendrequest(APP_BT_STREAM_HFP_PCM,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
}
} else if (bt_media_get_current_media() & BT_STREAM_SBC) {
TRACE_AUD_MGR_W("[HANDLE_STOP] voice and media is all on,media should "
"be the current media");
if (!bt_media_is_media_active_by_type(BT_STREAM_SBC)) {
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
}
}
} else
#endif
if (bt_media_is_media_active_by_type(BT_STREAM_VOICE)) {
#ifdef __BT_ONE_BRING_TWO__
if (bt_get_sco_number() > 1
#ifdef CHIP_BEST1000
&& hal_get_chip_metal_id() >= HAL_CHIP_METAL_ID_2
#endif
) {
TRACE_AUD_MGR_W(
"[HANDLE_STOP] bt_media_stop, but another soc need connect");
enum BT_DEVICE_ID_T voice_dev_id =
bt_media_get_active_device_by_type(BT_STREAM_VOICE);
#ifdef HFP_NO_PRERMPT
app_audio_manager_set_active_sco_num(voice_dev_id);
#else
app_audio_manager_swap_sco(voice_dev_id);
#ifdef __HF_KEEP_ONE_ALIVE__
enum BT_DEVICE_ID_T other_voice_dev_id =
(voice_dev_id == BT_DEVICE_ID_1) ? BT_DEVICE_ID_2 : BT_DEVICE_ID_1;
;
if (btif_hf_check_AudioConnect_status(
app_bt_device.hf_channel[other_voice_dev_id])) {
TRACE_AUD_MGR_I("[HANDLE_STOP] Disconnect another AudioLink");
app_bt_HF_DisconnectAudioLink(
app_bt_device.hf_channel[other_voice_dev_id]);
}
#endif
#endif
}
bt_media_set_current_media(BT_STREAM_VOICE);
#endif
} else if (btapp_hfp_is_call_active()) {
TRACE_AUD_MGR_I("[HANDLE_STOP] stop in HF_CALL_ACTIVE and no sco need");
bt_media_set_current_media(0);
app_audio_sendrequest(APP_BT_STREAM_HFP_PCM,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
bt_media_clear_media_type(BT_STREAM_VOICE, device_id);
{
enum BT_DEVICE_ID_T sbc_id = bt_media_get_active_sbc_device();
if (sbc_id < BT_DEVICE_NUM) {
app_audio_manager_switch_a2dp(sbc_id);
bt_media_set_current_media(BT_STREAM_SBC);
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)(APP_BT_SETTING_SETUP),
(uint32_t)(app_bt_device.sample_rate[sbc_id] &
A2D_STREAM_SAMP_FREQ_MSK));
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)APP_BT_SETTING_OPEN, 0);
}
}
}
#ifdef VOICE_DATAPATH
#if !ISOLATED_AUDIO_STREAM_ENABLED
else if (bt_media_is_media_active_by_type(BT_STREAM_CAPTURE)) {
app_audio_sendrequest(APP_BT_STREAM_HFP_PCM,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
app_audio_sendrequest(APP_BT_STREAM_VOICEPATH,
(uint8_t)APP_BT_SETTING_OPEN, 0);
bt_media_set_current_media(BT_STREAM_CAPTURE);
}
#endif
#endif
else if (bt_media_is_media_active_by_type(BT_STREAM_SBC)) {
/// if another device is also in sbc mode
enum BT_DEVICE_ID_T sbc_id = bt_media_get_active_sbc_device();
if (sbc_id < BT_DEVICE_NUM /*&& device_id == sbc_id*/) {
app_audio_sendrequest(APP_BT_STREAM_HFP_PCM,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
app_audio_manager_switch_a2dp(sbc_id);
bt_media_set_current_media(BT_STREAM_SBC);
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)(APP_BT_SETTING_SETUP),
(uint32_t)(app_bt_device.sample_rate[sbc_id] &
A2D_STREAM_SAMP_FREQ_MSK));
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)APP_BT_SETTING_OPEN, 0);
}
} else {
bt_media_set_current_media(0);
app_audio_sendrequest(APP_BT_STREAM_HFP_PCM,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
}
#if ISOLATED_AUDIO_STREAM_ENABLED
#ifdef VOICE_DATAPATH
if (bt_media_is_media_active_by_type(BT_STREAM_CAPTURE)) {
app_audio_sendrequest(APP_BT_STREAM_VOICEPATH,
(uint8_t)APP_BT_SETTING_OPEN, 0);
bt_media_set_current_media(BT_STREAM_CAPTURE);
}
#endif
#endif
#ifdef __THIRDPARTY
if (bt_media_is_media_active_by_type(BT_STREAM_THIRDPARTY_VOICE)) {
app_audio_sendrequest(APP_BT_STREAM_THIRDPARTY_VOICE,
(uint8_t)APP_BT_SETTING_OPEN, 0);
bt_media_set_current_media(BT_STREAM_THIRDPARTY_VOICE);
}
#endif
break;
#ifdef RB_CODEC
case BT_STREAM_RBCODEC:
bt_media_rbcodec_stop_process(stream_type, device_id, 0);
break;
#endif
#ifdef AUDIO_LINEIN
case BT_STREAM_LINEIN:
if (bt_media_is_media_active_by_type(BT_STREAM_LINEIN)) {
app_audio_sendrequest(APP_PLAY_LINEIN_AUDIO,
(uint8_t)APP_BT_SETTING_CLOSE, 0);
if (bt_media_get_current_media() & BT_STREAM_LINEIN)
bt_media_set_current_media(0);
bt_media_clear_media_type(stream_type, device_id);
}
break;
#endif
default:
ASSERT(0, "[HANDLE_STOP] ERROR TYPE: %x", stream_type);
break;
}
#ifdef __BT_ONE_BRING_TWO__
TRACE_AUD_MGR_I(
"[HANDLE_STOP] end media_active = %x,%x,curr_active_media = %x",
bt_meida.media_active[0], bt_meida.media_active[1],
bt_meida.curr_active_media);
#else
TRACE_AUD_MGR_I("[HANDLE_STOP] end media_active = %x%s",
bt_meida.media_active[0],
strmtype2str(bt_meida.media_active[0]));
TRACE_AUD_MGR_I("[HANDLE_STOP] end curr_active_media = %x%s",
bt_meida.curr_active_media,
strmtype2str(bt_meida.curr_active_media));
#endif
}
void app_media_stop_media(uint16_t stream_type, enum BT_DEVICE_ID_T device_id) {
#ifdef MEDIA_PLAYER_SUPPORT
#ifdef MIX_AUDIO_PROMPT_WITH_A2DP_MEDIA_ENABLED
audio_prompt_stop_playing();
#endif
if (bt_media_is_media_active_by_type(BT_STREAM_MEDIA) ||
app_audio_list_playback_exist()) {
#ifdef __AUDIO_QUEUE_SUPPORT__
////should have no sbc
app_audio_list_clear();
#endif
if (bt_media_get_current_media() & BT_STREAM_MEDIA) {
TRACE_AUD_MGR_I("[STOP_MEDIA]");
// bt_media_set_current_media(0);
app_audio_sendrequest(APP_PLAY_BACK_AUDIO, (uint8_t)APP_BT_SETTING_CLOSE,
0);
}
bt_media_clear_media_type(BT_STREAM_MEDIA, device_id);
if (bt_media_is_media_active_by_type(BT_STREAM_VOICE)) {
enum BT_DEVICE_ID_T currScoId = BT_DEVICE_NUM;
currScoId = (enum BT_DEVICE_ID_T)app_audio_manager_get_active_sco_num();
if (currScoId == BT_DEVICE_NUM) {
for (uint8_t i = 0; i < BT_DEVICE_NUM; i++) {
if (bt_media_is_media_active_by_device(BT_STREAM_VOICE,
(enum BT_DEVICE_ID_T)i)) {
currScoId = device_id;
break;
}
}
}
TRACE_AUD_MGR_I("[STOP_MEDIA] try to resume sco:%d", currScoId);
if (currScoId != BT_DEVICE_NUM) {
bt_media_set_media_type(BT_STREAM_VOICE, currScoId);
bt_media_set_current_media(BT_STREAM_VOICE);
#ifdef __BT_ONE_BRING_TWO__
app_audio_manager_swap_sco(currScoId);
#endif
app_audio_sendrequest(APP_BT_STREAM_HFP_PCM,
(uint8_t)APP_BT_SETTING_OPEN, 0);
}
}
#if !ISOLATED_AUDIO_STREAM_ENABLED
#ifdef VOICE_DATAPATH
else if (bt_media_is_media_active_by_type(BT_STREAM_CAPTURE)) {
app_audio_sendrequest(APP_BT_STREAM_VOICEPATH,
(uint8_t)APP_BT_SETTING_OPEN, 0);
bt_media_set_current_media(BT_STREAM_CAPTURE);
}
#endif
#endif
#ifdef __AI_VOICE__
else if (bt_media_is_media_active_by_type(BT_STREAM_AI_VOICE)) {
if ((bt_media_get_current_media() & BT_STREAM_AI_VOICE) == 0) {
app_audio_sendrequest(APP_BT_STREAM_AI_VOICE,
(uint8_t)APP_BT_SETTING_OPEN, 0);
bt_media_set_current_media(BT_STREAM_AI_VOICE);
}
}
#endif
else if (bt_media_is_media_active_by_type(BT_STREAM_SBC)) {
enum BT_DEVICE_ID_T sbc_id = bt_media_get_active_sbc_device();
bt_media_set_media_type(BT_STREAM_SBC, device_id);
app_audio_manager_switch_a2dp(sbc_id);
bt_media_set_current_media(BT_STREAM_SBC);
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)(APP_BT_SETTING_SETUP),
(uint32_t)(app_bt_device.sample_rate[sbc_id] &
A2D_STREAM_SAMP_FREQ_MSK));
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)APP_BT_SETTING_OPEN, 0);
}
}
#endif
}
void bt_media_switch_to_voice(uint16_t stream_type,
enum BT_DEVICE_ID_T device_id) {
TRACE_AUD_MGR_I("[SW2VOICE] stream_type= 0x%x,device_id=0x%x ", stream_type,
device_id);
#ifdef __BT_ONE_BRING_TWO__
TRACE_AUD_MGR_I(
"[SW2VOICE] media_active = 0x%x,0x%x,curr_active_media = 0x%x",
bt_meida.media_active[0], bt_meida.media_active[1],
bt_meida.curr_active_media);
#else
TRACE_AUD_MGR_I("[SW2VOICE] media_active = 0x%x,curr_active_media = 0x%x",
bt_meida.media_active[0], bt_meida.curr_active_media);
#endif
/// already in voice ,so return
if (bt_media_get_current_media() & BT_STREAM_VOICE) {
#ifndef HFP_NO_PRERMPT
#ifdef __BT_ONE_BRING_TWO__
if (!bt_media_is_media_active_by_device(BT_STREAM_VOICE, device_id)) {
app_audio_manager_swap_sco(device_id);
}
#ifdef __HF_KEEP_ONE_ALIVE__
enum BT_DEVICE_ID_T other_device_id =
(device_id == BT_DEVICE_ID_1) ? BT_DEVICE_ID_2 : BT_DEVICE_ID_1;
if (btif_hf_check_AudioConnect_status(
app_bt_device.hf_channel[other_device_id])) {
TRACE_AUD_MGR_I("[SW2VOICE] Disconnect another AudioLink");
btif_hf_disc_audio_link(app_bt_device.hf_channel[other_device_id]);
}
#endif
#endif
#endif
return;
}
app_media_stop_media(stream_type, device_id);
}
void app_media_update_media(uint16_t stream_type,
enum BT_DEVICE_ID_T device_id) {
TRACE_AUD_MGR_I("[UPDATE_MEDIA]");
#ifdef MEDIA_PLAYER_SUPPORT
if (bt_media_is_media_active_by_type(BT_STREAM_MEDIA)) {
// do nothing
TRACE_AUD_MGR_I("[UPDATE_MEDIA] skip BT_STREAM_MEDIA");
} else
#endif
if (bt_media_is_media_active_by_type(BT_STREAM_VOICE) ||
btapp_hfp_is_call_active()) {
// do nothing
TRACE_AUD_MGR_I("[UPDATE_MEDIA] skip BT_STREAM_VOICE");
TRACE_AUD_MGR_I("[UPDATE_MEDIA] DEBUG INFO actByVoc:%d %d %d",
bt_media_is_media_active_by_type(BT_STREAM_VOICE),
btapp_hfp_is_call_active(), btapp_hfp_incoming_calls());
} else if (bt_media_is_media_active_by_type(BT_STREAM_SBC)) {
#ifdef __AI_VOICE__
if (bt_media_is_media_active_by_type(BT_STREAM_AI_VOICE) ||
ai_if_is_ai_stream_mic_open()) {
TRACE_AUD_MGR_I("[UPDATE_MEDIA] there is a ai voice stream exist, skip");
return;
}
#endif
/// if another device is also in sbc mode
TRACE_AUD_MGR_I("[UPDATE_MEDIA] try to resume sbc");
enum BT_DEVICE_ID_T sbc_id = bt_media_get_active_sbc_device();
if (0 == (bt_media_get_current_media() & BT_STREAM_SBC)) {
app_audio_manager_switch_a2dp(sbc_id);
bt_media_set_current_media(BT_STREAM_SBC);
app_audio_sendrequest(
APP_BT_STREAM_A2DP_SBC, (uint8_t)(APP_BT_SETTING_SETUP),
(uint32_t)(app_bt_device
.sample_rate[sbc_id < BT_DEVICE_NUM ? sbc_id
: BT_DEVICE_ID_1] &
A2D_STREAM_SAMP_FREQ_MSK));
app_audio_sendrequest(APP_BT_STREAM_A2DP_SBC,
(uint8_t)APP_BT_SETTING_OPEN, 0);
}
} else {
TRACE_AUD_MGR_I("[UPDATE_MEDIA] skip idle");
}
}
int app_audio_manager_sco_status_checker(void) {
btif_cmgr_handler_t *cmgrHandler __attribute__((unused)) = NULL;
TRACE_AUD_MGR_I("[SCO_CHK] enter");
#if defined(CHIP_BEST1000) || defined(CHIP_BEST2000)
uint32_t scoTransmissionInterval_reg;
bt_bdaddr_t bdaddr;
if (bt_meida.media_curr_sco != BT_DEVICE_NUM) {
BTDIGITAL_REG_GET_FIELD(0xD0220120, 0xff, 24, scoTransmissionInterval_reg);
// cmgrHandler =
// &app_bt_device.hf_channel[bt_meida.media_curr_sco].cmgrHandler;
cmgrHandler = (btif_cmgr_handler_t *)btif_hf_get_chan_manager_handler(
app_bt_device.hf_channel[bt_meida.media_curr_sco]);
if (btif_cmgr_is_audio_up(cmgrHandler)) {
if (btif_cmgr_get_sco_connect_sco_link_type(cmgrHandler) ==
BTIF_BLT_ESCO) {
if (btif_cmgr_get_sco_connect_sco_rx_parms_sco_transmission_interval(
cmgrHandler) != scoTransmissionInterval_reg) {
BTDIGITAL_REG_SET_FIELD(
0xD0220120, 0xff, 24,
btif_cmgr_get_sco_connect_sco_rx_parms_sco_transmission_interval(
cmgrHandler));
}
}
}
TRACE_AUD_MGR_I(
"[SCO_CHK] curr:%d type:%d Intv:%d Intv_reg:%d",
bt_meida.media_curr_sco,
btif_cmgr_get_sco_connect_sco_link_type(cmgrHandler),
btif_cmgr_get_sco_connect_sco_rx_parms_sco_transmission_interval(
cmgrHandler),
scoTransmissionInterval_reg);
// DUMP8("%02x ",
// app_bt_device.hf_channel[bt_meida.media_curr_sco].cmgrHandler.remDev->bdAddr.addr,
// 6);
btif_hf_get_remote_bdaddr(app_bt_device.hf_channel[bt_meida.media_curr_sco],
&bdaddr);
DUMP8("%02x ", bdaddr.address, 6);
#if defined(HFP_1_6_ENABLE)
uint32_t code_type;
uint32_t code_type_reg;
code_type = app_audio_manager_get_scocodecid();
code_type_reg = BTDIGITAL_REG(0xD0222000);
if (code_type == BTIF_HF_SCO_CODEC_MSBC) {
BTDIGITAL_REG(0xD0222000) = (code_type_reg & (~(7 << 1))) | (3 << 1);
TRACE_AUD_MGR_I("[SCO_CHK] MSBC REG:0xD0222000=0x%08x B:%d",
BTDIGITAL_REG(0xD0222000),
(BTDIGITAL_REG(0xD0222000) >> 15) & 1);
} else {
BTDIGITAL_REG(0xD0222000) = (code_type_reg & (~(7 << 1))) | (2 << 1);
TRACE_AUD_MGR_I("[SCO_CHK] CVSD REG:0xD0222000=0x%08x B:%d",
BTDIGITAL_REG(0xD0222000),
(BTDIGITAL_REG(0xD0222000) >> 15) & 1);
}
#else
uint32_t code_type_reg;
code_type_reg = BTDIGITAL_REG(0xD0222000);
BTDIGITAL_REG(0xD0222000) = (code_type_reg & (~(7 << 1))) | (2 << 1);
TRACE_AUD_MGR_I("[SCO_CHK] CVSD REG:0xD0222000=0x%08x B:%d",
BTDIGITAL_REG(0xD0222000),
(BTDIGITAL_REG(0xD0222000) >> 15) & 1);
#endif
}
#else
#if defined(DEBUG)
#if defined(IBRT)
if (app_tws_ibrt_mobile_link_connected())
#endif
{
hf_chan_handle_t hf_chan =
app_bt_device.hf_channel[bt_meida.media_curr_sco];
if (hf_chan && (cmgrHandler = btif_hf_get_chan_manager_handler(hf_chan))) {
TRACE_AUD_MGR_I(
"[SCO_CHK] curSco:%d type:%d Interval:%d", bt_meida.media_curr_sco,
btif_cmgr_get_sco_connect_sco_link_type(cmgrHandler),
btif_cmgr_get_sco_connect_sco_rx_parms_sco_transmission_interval(
cmgrHandler));
}
}
#endif
#endif
TRACE_AUD_MGR_I("[SCO_CHK] exit");
return 0;
}
int app_audio_manager_swap_sco(enum BT_DEVICE_ID_T id) {
if (bt_get_sco_number() <= 1)
return 0;
#if defined(HFP_1_6_ENABLE)
uint8_t curr_sco_id;
curr_sco_id = app_audio_manager_get_active_sco_num();
#endif
bt_bdaddr_t bdAdd;
uint16_t scohandle;
// if (HF_GetRemoteBDAddr(&app_bt_device.hf_channel[id], &bdAdd)){
if (btif_hf_get_remote_bdaddr(app_bt_device.hf_channel[id], &bdAdd)) {
// TRACE_AUD_MGR_I("[SCO SWAP]switch_sco to id:%d sco:%x", id,
// app_bt_device.hf_channel[id].cmgrHandler.scoConnect);
// DUMP8("%02x ",
// app_bt_device.hf_channel[id].cmgrHandler.remDev->bdAddr.addr, 6);
// DUMP8("%02x ", bdAdd.address, 6);
/*
TRACE_AUD_MGR_I("[SCO_SWAP] state:%d type:%d hdl:%x ",
app_bt_device.hf_channel[id].cmgrHandler.scoConnect->scostate,
app_bt_device.hf_channel[id].cmgrHandler.scoConnect->scoLinkType,
app_bt_device.hf_channel[id].cmgrHandler.scoConnect->scoHciHandle);
TRACE_AUD_MGR_I("[SCO_SWAP] tx[bw:%d rbw:%d ml:%d vs:%d rt:%d pktyp:%d]",
app_bt_device.hf_channel[id].cmgrHandler.scoConnect->scoTxParms.transmitBandwidth,
app_bt_device.hf_channel[id].cmgrHandler.scoConnect->scoTxParms.receiveBandwidth,
app_bt_device.hf_channel[id].cmgrHandler.scoConnect->scoTxParms.maxLatency,
app_bt_device.hf_channel[id].cmgrHandler.scoConnect->scoTxParms.voiceSetting,
app_bt_device.hf_channel[id].cmgrHandler.scoConnect->scoTxParms.retransmissionEffort,
app_bt_device.hf_channel[id].cmgrHandler.scoConnect->scoTxParms.eScoPktType);
TRACE_AUD_MGR_I("[SCO_SWAP] rx[itv:%d ret:%d rxl:%d txl:%d]",
app_bt_device.hf_channel[id].cmgrHandler.scoConnect->scoRxParms.scoTransmissionInterval,
app_bt_device.hf_channel[id].cmgrHandler.scoConnect->scoRxParms.scoRetransmissionWindow,
app_bt_device.hf_channel[id].cmgrHandler.scoConnect->scoRxParms.scoRxPacketLen,
app_bt_device.hf_channel[id].cmgrHandler.scoConnect->scoRxParms.scoTxPacketLen);
*/
app_audio_manager_set_active_sco_num(id);
scohandle = btif_hf_get_sco_hcihandle(app_bt_device.hf_channel[id]);
if (scohandle != BTIF_HCI_INVALID_HANDLE) {
app_bt_Me_switch_sco(scohandle);
}
app_bt_stream_volume_ptr_update(bdAdd.address);
app_audio_manager_ctrl_volume(APP_AUDIO_MANAGER_VOLUME_CTRL_SET,
app_bt_stream_volume_get_ptr()->hfp_vol);
#if defined(HFP_1_6_ENABLE)
if (curr_sco_id != id) {
TRACE_AUD_MGR_I("[SCO_SWAP] try restart");
bt_sco_player_forcemute(true, true);
app_audio_sendrequest(APP_BT_STREAM_HFP_PCM,
(uint8_t)APP_BT_SETTING_RESTART, 0);
}
#endif
app_audio_manager_sco_status_checker();
}
return 0;
}
int app_audio_manager_ctrl_volume_handle(APP_MESSAGE_BODY *msg_body) {
enum APP_AUDIO_MANAGER_VOLUME_CTRL_T volume_ctrl;
uint16_t volume_level = 0;
volume_ctrl = (enum APP_AUDIO_MANAGER_VOLUME_CTRL_T)msg_body->message_ptr;
volume_level = (uint16_t)msg_body->message_Param0;
switch (volume_ctrl) {
case APP_AUDIO_MANAGER_VOLUME_CTRL_SET:
app_bt_stream_volumeset(volume_level);
break;
case APP_AUDIO_MANAGER_VOLUME_CTRL_UP:
app_bt_stream_volumeup();
btapp_hfp_report_speak_gain();
btapp_a2dp_report_speak_gain();
break;
case APP_AUDIO_MANAGER_VOLUME_CTRL_DOWN:
app_bt_stream_volumedown();
btapp_hfp_report_speak_gain();
btapp_a2dp_report_speak_gain();
break;
default:
break;
}
return 0;
}
int app_audio_manager_tune_samplerate_ratio_handle(APP_MESSAGE_BODY *msg_body) {
enum AUD_STREAM_T stream = AUD_STREAM_NUM;
float ratio = 1.0f;
stream = (enum AUD_STREAM_T)msg_body->message_ptr;
ratio = *(float *)&msg_body->message_Param0;
TRACE_AUD_MGR_I("[TUNE] %d", (int32_t)(ratio * 10000000));
af_codec_tune(stream, ratio);
return 0;
}
static bool app_audio_manager_init = false;
int app_audio_manager_sendrequest(uint8_t massage_id, uint16_t stream_type,
uint8_t device_id, uint16_t aud_id) {
uint32_t audevt;
uint32_t msg0;
APP_MESSAGE_BLOCK msg;
if (app_audio_manager_init == false)
return -1;
// only allow prompt playing if powering-off is on-going
if (app_is_power_off_in_progress()) {
if ((APP_BT_STREAM_MANAGER_START == massage_id) &&
(BT_STREAM_MEDIA != stream_type)) {
return -1;
}
}
msg.mod_id = APP_MODUAL_AUDIO_MANAGE;
APP_AUDIO_MANAGER_SET_MESSAGE(audevt, massage_id, stream_type);
APP_AUDIO_MANAGER_SET_MESSAGE0(msg0, device_id, aud_id);
msg.msg_body.message_id = audevt;
msg.msg_body.message_ptr = msg0;
msg.msg_body.message_Param0 = msg0;
msg.msg_body.message_Param1 = 0;
msg.msg_body.message_Param2 = 0;
app_mailbox_put(&msg);
return 0;
}
int app_audio_manager_sendrequest_need_callback(uint8_t massage_id,
uint16_t stream_type,
uint8_t device_id,
uint16_t aud_id, uint32_t cb,
uint32_t cb_param) {
uint32_t audevt;
uint32_t msg0;
APP_MESSAGE_BLOCK msg;
if (app_audio_manager_init == false)
return -1;
msg.mod_id = APP_MODUAL_AUDIO_MANAGE;
APP_AUDIO_MANAGER_SET_MESSAGE(audevt, massage_id, stream_type);
APP_AUDIO_MANAGER_SET_MESSAGE0(msg0, device_id, aud_id);
msg.msg_body.message_id = audevt;
msg.msg_body.message_ptr = msg0;
msg.msg_body.message_Param0 = msg0;
msg.msg_body.message_Param1 = cb;
msg.msg_body.message_Param2 = cb_param;
app_mailbox_put(&msg);
return 0;
}
int app_audio_manager_ctrl_volume(APP_AUDIO_MANAGER_VOLUME_CTRL_T volume_ctrl,
uint16_t volume_level) {
uint32_t audevt;
APP_MESSAGE_BLOCK msg;
osThreadId currThreadId;
if (app_audio_manager_init == false)
return -1;
msg.mod_id = APP_MODUAL_AUDIO_MANAGE;
APP_AUDIO_MANAGER_SET_MESSAGE(audevt, APP_BT_STREAM_MANAGER_CTRL_VOLUME, 0);
msg.msg_body.message_id = audevt;
msg.msg_body.message_ptr = (uint32_t)volume_ctrl;
msg.msg_body.message_Param0 = (uint32_t)volume_level;
msg.msg_body.message_Param1 = 0;
msg.msg_body.message_Param2 = 0;
currThreadId = osThreadGetId();
if (currThreadId == af_thread_tid_get() || currThreadId == app_os_tid_get()) {
app_audio_manager_ctrl_volume_handle(&msg.msg_body);
} else {
app_mailbox_put(&msg);
}
return 0;
}
int app_audio_manager_tune_samplerate_ratio(enum AUD_STREAM_T stream,
float ratio) {
uint32_t audevt;
APP_MESSAGE_BLOCK msg;
osThreadId currThreadId;
if (app_audio_manager_init == false)
return -1;
msg.mod_id = APP_MODUAL_AUDIO_MANAGE;
APP_AUDIO_MANAGER_SET_MESSAGE(audevt,
APP_BT_STREAM_MANAGER_TUNE_SAMPLERATE_RATIO, 0);
msg.msg_body.message_id = audevt;
msg.msg_body.message_ptr = (uint32_t)stream;
msg.msg_body.message_Param0 = *(uint32_t *)&ratio;
msg.msg_body.message_Param1 = 0;
msg.msg_body.message_Param2 = 0;
currThreadId = osThreadGetId();
if (currThreadId == af_thread_tid_get() || currThreadId == app_os_tid_get()) {
app_audio_manager_tune_samplerate_ratio_handle(&msg.msg_body);
} else {
app_mailbox_put(&msg);
}
return 0;
}
#if defined(VOICE_DATAPATH) && defined(MIX_MIC_DURING_MUSIC)
static bool app_audio_handle_pre_processing(APP_MESSAGE_BODY *msg_body) {
uint16_t stream_type;
APP_AUDIO_MANAGER_GET_STREAM_TYPE(msg_body->message_id, stream_type);
bool isToResetCaptureStream = false;
if ((BT_STREAM_SBC == stream_type) || (BT_STREAM_MEDIA == stream_type)) {
if (app_audio_manager_capture_is_active()) {
isToResetCaptureStream = true;
}
}
if (isToResetCaptureStream) {
app_audio_manager_sendrequest(APP_BT_STREAM_MANAGER_STOP, BT_STREAM_CAPTURE,
0, 0);
APP_MESSAGE_BLOCK msg;
msg.msg_body = *msg_body;
msg.mod_id = APP_MODUAL_AUDIO_MANAGE;
app_mailbox_put(&msg);
app_audio_manager_sendrequest(APP_BT_STREAM_MANAGER_START,
BT_STREAM_CAPTURE, 0, 0);
return false;
} else {
return true;
}
}
#endif
static int app_audio_manager_handle_process(APP_MESSAGE_BODY *msg_body) {
int nRet = 0;
APP_AUDIO_MANAGER_MSG_STRUCT aud_manager_msg;
APP_AUDIO_MANAGER_CALLBACK_T callback_fn = NULL;
uint32_t callback_param = 0;
if (app_audio_manager_init == false)
return -1;
#if defined(VOICE_DATAPATH) && defined(MIX_MIC_DURING_MUSIC)
bool isContinue = app_audio_handle_pre_processing(msg_body);
if (!isContinue) {
return -1;
}
#endif
APP_AUDIO_MANAGER_GET_ID(msg_body->message_id, aud_manager_msg.id);
APP_AUDIO_MANAGER_GET_STREAM_TYPE(msg_body->message_id,
aud_manager_msg.stream_type);
APP_AUDIO_MANAGER_GET_DEVICE_ID(msg_body->message_Param0,
aud_manager_msg.device_id);
APP_AUDIO_MANAGER_GET_AUD_ID(msg_body->message_Param0,
aud_manager_msg.aud_id);
APP_AUDIO_MANAGER_GET_CALLBACK((uintptr_t)msg_body->message_Param1,
callback_fn);
APP_AUDIO_MANAGER_GET_CALLBACK_PARAM(msg_body->message_Param2,
callback_param);
TRACE_AUD_MGR_I("[handle_process] id %d %s type 0x%x %s", aud_manager_msg.id,
handleId2str(aud_manager_msg.id), aud_manager_msg.stream_type,
strmtype2str(aud_manager_msg.stream_type));
switch (aud_manager_msg.id) {
case APP_BT_STREAM_MANAGER_START:
bt_media_start(aud_manager_msg.stream_type,
(enum BT_DEVICE_ID_T)aud_manager_msg.device_id,
aud_manager_msg.aud_id);
break;
case APP_BT_STREAM_MANAGER_STOP:
bt_media_stop(aud_manager_msg.stream_type,
(enum BT_DEVICE_ID_T)aud_manager_msg.device_id);
break;
case APP_BT_STREAM_MANAGER_SWITCHTO_SCO:
bt_media_switch_to_voice(aud_manager_msg.stream_type,
(enum BT_DEVICE_ID_T)aud_manager_msg.device_id);
break;
case APP_BT_STREAM_MANAGER_STOP_MEDIA:
app_media_stop_media(aud_manager_msg.stream_type,
(enum BT_DEVICE_ID_T)aud_manager_msg.device_id);
break;
case APP_BT_STREAM_MANAGER_UPDATE_MEDIA:
app_media_update_media(aud_manager_msg.stream_type,
(enum BT_DEVICE_ID_T)aud_manager_msg.device_id);
break;
case APP_BT_STREAM_MANAGER_SWAP_SCO:
app_audio_manager_swap_sco((enum BT_DEVICE_ID_T)aud_manager_msg.device_id);
break;
case APP_BT_STREAM_MANAGER_CTRL_VOLUME:
app_audio_manager_ctrl_volume_handle(msg_body);
break;
case APP_BT_STREAM_MANAGER_TUNE_SAMPLERATE_RATIO:
app_audio_manager_tune_samplerate_ratio_handle(msg_body);
break;
default:
break;
}
if (callback_fn) {
callback_fn(aud_manager_msg.id, callback_param);
}
return nRet;
}
void bt_media_volume_ptr_update_by_mediatype(uint16_t stream_type) {
bt_bdaddr_t *bdAdd = NULL;
bt_bdaddr_t temp;
btif_remote_device_t *remDev = NULL;
uint8_t id;
TRACE_AUD_MGR_I("[VOLUME_PTR] enter");
if (stream_type & bt_media_get_current_media()) {
switch (stream_type) {
case BT_STREAM_SBC:
id = bt_meida.media_curr_sbc;
ASSERT(id < BT_DEVICE_NUM, "INVALID_BT_DEVICE_NUM");
remDev =
btif_a2dp_get_remote_device(app_bt_device.a2dp_connected_stream[id]);
if (remDev) {
bdAdd = btif_me_get_remote_device_bdaddr(remDev);
app_bt_stream_volume_ptr_update(bdAdd->address);
}
break;
case BT_STREAM_VOICE:
id = app_audio_manager_get_active_sco_num();
ASSERT(id < BT_DEVICE_NUM, "INVALID_BT_DEVICE_NUM");
// if (HF_GetRemoteBDAddr(&app_bt_device.hf_channel[id], &bdAdd)){
bdAdd = &temp;
if (btif_hf_get_remote_bdaddr(app_bt_device.hf_channel[id], bdAdd)) {
app_bt_stream_volume_ptr_update(bdAdd->address);
}
break;
case BT_STREAM_MEDIA:
default:
break;
}
}
TRACE_AUD_MGR_I("[VOLUME_PTR] exit");
}
int app_audio_manager_set_active_sco_num(enum BT_DEVICE_ID_T id) {
bt_meida.media_curr_sco = id;
return 0;
}
int app_audio_manager_get_active_sco_num(void) {
return bt_meida.media_curr_sco;
}
hf_chan_handle_t *app_audio_manager_get_active_sco_chnl(void) {
int curr_sco;
curr_sco = app_audio_manager_get_active_sco_num();
if (curr_sco != BT_DEVICE_NUM) {
return &app_bt_device.hf_channel[curr_sco];
}
return NULL;
}
#if defined(HFP_1_6_ENABLE)
#ifdef __BT_ONE_BRING_TWO__
static uint16_t app_audio_manage_scocodecid[BT_DEVICE_NUM] = {
BTIF_HF_SCO_CODEC_CVSD, BTIF_HF_SCO_CODEC_CVSD};
#else
static uint16_t app_audio_manage_scocodecid[BT_DEVICE_NUM] = {
BTIF_HF_SCO_CODEC_CVSD};
#endif
int app_audio_manager_set_scocodecid(enum BT_DEVICE_ID_T dev_id,
uint16_t codec_id) {
app_audio_manage_scocodecid[dev_id] = codec_id;
return 0;
}
int app_audio_manager_get_scocodecid(void) {
int scocodecid = BTIF_HF_SCO_CODEC_NONE;
if (bt_meida.media_curr_sco != BT_DEVICE_NUM) {
scocodecid = app_audio_manage_scocodecid[bt_meida.media_curr_sco];
}
return scocodecid;
}
#endif
int app_audio_manager_switch_a2dp(enum BT_DEVICE_ID_T id) {
bt_bdaddr_t *bdAdd = NULL;
btif_remote_device_t *remDev = NULL;
#ifndef __MULTIPOINT_A2DP_PREEMPT__
if (bt_meida.media_curr_sbc == id) {
TRACE_AUD_MGR_I("[A2DP_SWITCH]the disconnected dev not working");
return 0;
}
#endif
remDev = btif_a2dp_get_remote_device(app_bt_device.a2dp_connected_stream[id]);
if (remDev) {
TRACE_AUD_MGR_I("[A2DP_SWITCH] switch_a2dp to id:%d", id);
bdAdd = btif_me_get_remote_device_bdaddr(remDev);
app_bt_stream_volume_ptr_update(bdAdd->address);
bt_meida.media_curr_sbc = id;
}
return 0;
}
bool app_audio_manager_a2dp_is_active(enum BT_DEVICE_ID_T id) {
uint16_t media_type;
bool nRet = false;
media_type = bt_media_get_current_media();
if (media_type & BT_STREAM_SBC) {
if (bt_meida.media_curr_sbc == id) {
nRet = true;
}
}
#ifndef BES_AUTOMATE_TEST
TRACE_AUD_MGR_I("[A2DP_ACTIVE] nRet:%d type:%d %d/%d", nRet, media_type, id,
bt_meida.media_curr_sbc);
#endif
return nRet;
}
bool app_audio_manager_hfp_is_active(enum BT_DEVICE_ID_T id) {
uint16_t media_type;
bool nRet = false;
media_type = bt_media_get_current_media();
if (media_type & BT_STREAM_VOICE) {
if (bt_meida.media_curr_sco == id) {
nRet = true;
}
}
#ifndef BES_AUTOMATE_TEST
TRACE_AUD_MGR_I("[SCO_ACTIVE] nRet:%d type:%d %d/%d", nRet, media_type, id,
bt_meida.media_curr_sco);
#endif
return nRet;
}
#ifdef VOICE_DATAPATH
bool app_audio_manager_capture_is_active(void) {
uint16_t media_type;
bool nRet = false;
media_type = bt_media_get_current_media();
if (media_type & BT_STREAM_CAPTURE) {
nRet = true;
}
return nRet;
}
#endif
bool app_audio_manager_media_is_active(void) {
uint16_t media_type;
bool nRet = false;
media_type = bt_media_get_current_media();
if (media_type & BT_STREAM_MEDIA) {
nRet = true;
}
return nRet;
}
void app_audio_manager_open(void) {
if (app_audio_manager_init) {
return;
}
bt_meida.media_curr_sbc = BT_DEVICE_NUM;
bt_meida.media_curr_sco = BT_DEVICE_NUM;
bt_meida.curr_active_media = 0;
app_set_threadhandle(APP_MODUAL_AUDIO_MANAGE,
app_audio_manager_handle_process);
app_audio_manager_init = true;
#ifdef MIX_AUDIO_PROMPT_WITH_A2DP_MEDIA_ENABLED
audio_prompt_init_handler();
#endif
}
void app_audio_manager_close(void) {
app_set_threadhandle(APP_MODUAL_AUDIO_MANAGE, NULL);
app_audio_manager_init = false;
}
#ifdef RB_CODEC
static bool app_rbcodec_play_status = false;
static bool app_rbplay_player_mode = false;
bool app_rbplay_is_localplayer_mode(void) { return app_rbplay_player_mode; }
bool app_rbplay_mode_switch(void) {
return (app_rbplay_player_mode = !app_rbplay_player_mode);
}
void app_rbplay_set_player_mode(bool isInPlayerMode) {
app_rbplay_player_mode = isInPlayerMode;
}
void app_rbcodec_ctr_play_onoff(bool on) {
TRACE_AUD_MGR_I("[RBCODEC] onoff %d ,turnon:%d ", app_rbcodec_play_status,
on);
if (app_rbcodec_play_status == on)
return;
app_rbcodec_play_status = on;
if (on)
app_audio_manager_sendrequest(APP_BT_STREAM_MANAGER_START,
BT_STREAM_RBCODEC, 0, 0);
else
app_audio_manager_sendrequest(APP_BT_STREAM_MANAGER_STOP, BT_STREAM_RBCODEC,
0, 0);
}
void app_rbcodec_ctl_set_play_status(bool st) {
app_rbcodec_play_status = st;
TRACE_AUD_MGR_I("[RBCODEC] curr_status%d", app_rbcodec_play_status);
}
bool app_rbcodec_get_play_status(void) {
TRACE_AUD_MGR_I("[RBCODEC] play_status:%d", app_rbcodec_play_status);
return app_rbcodec_play_status;
}
void app_rbcodec_toggle_play_stop(void) {
if (app_rbcodec_get_play_status()) {
app_rbcodec_ctr_play_onoff(false);
} else {
app_rbcodec_ctr_play_onoff(true);
}
}
bool app_rbcodec_check_hfp_active(void) {
return (bool)bt_media_is_media_active_by_type(BT_STREAM_VOICE);
}
#endif
void app_ibrt_sync_mix_prompt_req_handler(uint8_t *ptrParam,
uint16_t paramLen) {
#ifdef TWS_PROMPT_SYNC
app_tws_cmd_sync_mix_prompt_req_handler(ptrParam, paramLen);
#endif
}
void app_audio_decode_err_force_trigger(void) {
#ifndef IBRT
trigger_media_play((AUD_ID_ENUM)AUDIO_ID_BT_MUTE, 0, false);
#endif
}
Reference in a new issue View git blame Copy permalink