lmx/99_7018_lmx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first

Browse Source
This commit is contained in:
lmx
2025-10-29 13:10:02 +08:00
commit 49a07fa419
2284 changed files with 642060 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
apps/earphone/wireless_mic/odev/adapter_odev.c Normal file
View File

@ -0,0 +1,100 @@
#include "adapter_odev.h"
#if TCFG_WIRELESS_MIC_ENABLE
struct odev *adapter_odev_open(u16 id, void *parm)
{
g_printf("adapter_odev_open\n");
struct odev *dev = NULL;
list_for_each_adapter_odev(dev) {
if (dev->id == id) {
if (dev->open) {
dev->open(parm);
}
return dev;
}
}
return NULL;
}
void adapter_odev_start(struct odev *dev, struct adapter_media *media)
{
g_printf("adapter_odev_start\n");
if (dev && dev->start) {
dev->start(NULL, media);
}
return;
}
void adapter_odev_stop(struct odev *dev)
{
g_printf("adapter_odev_stop\n");
if (dev && dev->stop) {
dev->stop(NULL);
}
return;
}
void adapter_odev_close(struct odev *dev)
{
g_printf("adapter_odev_close\n");
if (dev && dev->close) {
dev->close(NULL);
}
return;
}
int adapter_odev_get_status(struct odev *dev)
{
g_printf("adapter_odev_get_status\n");
if (dev && dev->get_status) {
return (dev->get_status(NULL));
}
return 0;
}
int adapter_odev_media_pp(struct odev *dev, u8 pp)
{
g_printf("adapter_odev_media_pp\n");
if (dev && dev->media_pp) {
return (dev->media_pp(pp));
}
return 0;
}
int adapter_odev_media_prepare(struct odev *dev, u8 mode, int (*fun)(void *, u8, u8, void *), void *priv)
{
g_printf("adapter_odev_media_prepare\n");
if (dev && dev->media_prepare) {
return dev->media_prepare(mode, fun, priv);
}
return -1;
}
int adapter_odev_event_deal(struct odev *dev, struct sys_event *event)
{
if (dev && dev->event_fun) {
return dev->event_fun(event);
}
return 0;
}
void adapter_odev_config(struct odev *dev, int cmd, void *priv)
{
g_printf("adapter_odev_config\n");
if (dev && dev->config) {
dev->config(cmd, priv);
}
return;
}
int adapter_odev_output(struct odev *dev, void *priv, u8 *buf, u16 len)
{
int ret = 0;
if (dev && dev->output) {
ret = dev->output(priv, buf, len);
}
return ret;
}
#endif

56
apps/earphone/wireless_mic/odev/adapter_odev.h Normal file
View File

@ -0,0 +1,56 @@
#ifndef __ADAPTER_ODEV_H__
#define __ADAPTER_ODEV_H__
#include "generic/typedef.h"
#include "adapter_odev_bt.h"
#include "adapter_media.h"
#include "wireless_mic_test.h"
#include "event.h"
enum adapter_odev_type {
ADAPTER_ODEV_BT = 0x0,
ADAPTER_ODEV_DAC,
ADAPTER_ODEV_USB,
};
enum {
ADAPTER_ODEV_PAUSE = 0x0,
ADAPTER_ODEV_PLAY,
};
struct odev {
u16 id;
int (*open)(void *);
int (*start)(void *, struct adapter_media *);
int (*stop)(void *);
int (*close)(void *);
int (*get_status)(void *);
int (*media_pp)(u8);
int (*media_prepare)(u8, int (*fun)(void *, u8, u8, void *), void *);
int (*event_fun)(struct sys_event *);
int (*config)(int cmd, void *parm);
int (*output)(void *, u8 *, u16);
};
struct odev *adapter_odev_open(u16 id, void *parm);
void adapter_odev_start(struct odev *dev, struct adapter_media *media);
void adapter_odev_stop(struct odev *dev);
void adapter_odev_close(struct odev *dev);
int adapter_odev_get_status(struct odev *dev);
int adapter_odev_media_pp(struct odev *dev, u8 pp);
int adapter_odev_media_prepare(struct odev *dev, u8 mode, int (*fun)(void *, u8, u8, void *), void *priv);
int adapter_odev_event_deal(struct odev *dev, struct sys_event *event);
void adapter_odev_config(struct odev *dev, int cmd, void *priv);
int adapter_odev_output(struct odev *dev, void *priv, u8 *buf, u16 len);
#define REGISTER_ADAPTER_ODEV(ops) \
const struct odev ops sec(.adapter_odev)
extern const struct odev adapter_odev_begin[];
extern const struct odev adapter_odev_end[];
#define list_for_each_adapter_odev(p) \
for (p = adapter_odev_begin; p < adapter_odev_end; p++)
#endif//__ADAPTER_ODEV_H__

213
apps/earphone/wireless_mic/odev/odev_bt/adapter_odev_bt.c Normal file
View File

@ -0,0 +1,213 @@
#include "adapter_odev.h"
#include "adapter_odev_bt.h"
#include "adapter_odev_edr.h"
#include "adapter_odev_ble.h"
#include "btstack/avctp_user.h"
#include "classic/hci_lmp.h"
#include "list.h"
#include "os/os_api.h"
#include "circular_buf.h"
#include "app_config.h"
#include "adapter_process.h"
#include "btstack/bluetooth.h"
#include "btstack/btstack_error.h"
#include "bt_edr_fun.h"
#if TCFG_WIRELESS_MIC_ENABLE
#define LOG_TAG_CONST WIRELESSMIC
#define LOG_TAG "[ODEV_BT]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
#define LOG_DUMP_ENABLE
#define LOG_CLI_ENABLE
#include "debug.h"
struct _odev_bt odev_bt;
#define __this (&odev_bt)
static int adapter_odev_bt_open(void *parm)
{
r_printf("adapter_odev_bt_open\n");
memset(__this, 0, sizeof(struct _odev_bt));
set_bt_dev_role(BT_AS_ODEV);
__this->parm = (struct _odev_bt_parm *)parm;
#if 0 //parm test
g_printf("bt filt:%d spp filt:%d addr filt:%d\n", __this->parm->edr_parm.bt_name_filt_num, __this->parm->edr_parm.spp_name_filt_num, __this->parm->edr_parm.bd_addr_filt_num);
for (u8 i = 0; i < __this->parm->edr_parm.bt_name_filt_num; i++) {
printf("%d:%s\n", i, __this->parm->edr_parm.bt_name_filt[i]);
}
for (u8 i = 0; i < __this->parm->edr_parm.spp_name_filt_num; i++) {
printf("%d:%s\n", i, __this->parm->edr_parm.spp_name_filt[i]);
}
for (u8 i = 0; i < __this->parm->edr_parm.bd_addr_filt_num; i++) {
put_buf(__this->parm->edr_parm.bd_addr_filt[i], 6);
}
#endif
if (__this->parm->mode & BIT(ODEV_BLE)) {
adapter_odev_ble_open(&__this->parm->ble_parm);
}
bt_init();
if (__this->parm->mode & BIT(ODEV_EDR)) {
#if 0 //for test,config edr_bt_name by config_tool
extern const char *bt_get_local_name();
memset(__this->parm->edr_parm.bt_name_filt[0], 0x00, LOCAL_NAME_LEN);
memcpy(__this->parm->edr_parm.bt_name_filt[0], (u8 *)(bt_get_local_name()), LOCAL_NAME_LEN);
#endif
adapter_odev_edr_open(&__this->parm->edr_parm);
}
__this->edr = &odev_edr;
__this->ble = &odev_ble;
return 0;
}
static int adapter_odev_bt_start(void *priv, struct adapter_media *media)
{
r_printf("adapter_odev_bt_start\n");
if (__this->parm->mode & BIT(ODEV_EDR)) {
adapter_odev_edr_start(NULL);
}
if (__this->parm->mode & BIT(ODEV_BLE)) {
adapter_odev_ble_start(NULL);
}
return 0;
}
static int adapter_odev_bt_stop(void *priv)
{
r_printf("adapter_odev_bt_stop\n");
if (__this->parm->mode & BIT(ODEV_EDR)) {
adapter_odev_edr_stop(NULL);
}
if (__this->parm->mode & BIT(ODEV_BLE)) {
adapter_odev_ble_stop(NULL);
}
return 0;
}
static int adapter_odev_bt_close(void)
{
r_printf("adapter_odev_bt_close\n");
if (__this->parm->mode & BIT(ODEV_EDR)) {
adapter_odev_edr_close(NULL);
}
if (__this->parm->mode & BIT(ODEV_BLE)) {
adapter_odev_ble_close(NULL);
}
return 0;
}
static int adapter_odev_bt_get_status(void *priv)
{
if (__this->parm->mode & BIT(ODEV_EDR)) {
return adapter_odev_edr_get_status(NULL);
}
return 0;
}
static int adapter_odev_bt_pp_ctl(u8 pp)
{
if (__this->parm->mode & BIT(ODEV_EDR)) {
return adapter_odev_edr_pp(pp);
}
return 0;
}
static int adapter_odev_bt_media_prepare(u8 mode, int (*fun)(void *, u8, u8, void *), void *priv)
{
if (__this->parm->mode & BIT(ODEV_EDR)) {
return adapter_odev_edr_media_prepare(mode, fun, priv);
}
return -1;
}
static int adapter_odev_bt_office(struct sys_event *event)
{
int ret = 0;
if ((u32)event->arg == SYS_BT_EVENT_TYPE_CON_STATUS) {
bt_connction_status_event_handler(&event->u.bt, __this);
} else if ((u32)event->arg == SYS_BT_EVENT_TYPE_HCI_STATUS) {
//bt_hci_event_handler(&event->u.bt, __this);
}
return ret;
}
static int adapter_odev_bt_event_deal(struct sys_event *event)
{
//r_printf("adapter_odev_bt_event_deal\n");
int ret = 0;
switch (event->type) {
case SYS_KEY_EVENT:
break;
case SYS_DEVICE_EVENT:
break;
case SYS_BT_EVENT:
adapter_odev_bt_office(event);
ret = 1;
break;
default:
break;
}
return ret;
}
static int adapter_odev_bt_config(int cmd, void *parm)
{
r_printf("adapter_odev_bt_config\n");
if (__this->parm->mode & BIT(ODEV_EDR)) {
adapter_odev_edr_config(cmd, parm);
}
if (__this->parm->mode & BIT(ODEV_BLE)) {
adapter_odev_ble_config(cmd, parm);
}
return 0;
}
static int adapter_odev_bt_send(void *priv, u8 *buf, u16 len)
{
int ret = -1;
if (__this->parm->mode & BIT(ODEV_BLE)) {
ret = adapter_odev_ble_send(priv, buf, len);
}
return ret;
}
REGISTER_ADAPTER_ODEV(adapter_odev_bt) = {
.id = ADAPTER_ODEV_BT,
.open = adapter_odev_bt_open,
.start = adapter_odev_bt_start,
.stop = adapter_odev_bt_stop,
.close = adapter_odev_bt_close,
.media_pp = adapter_odev_bt_pp_ctl,
.get_status = adapter_odev_bt_get_status,
.media_prepare = adapter_odev_bt_media_prepare,
.event_fun = adapter_odev_bt_event_deal,
.config = adapter_odev_bt_config,
.output = adapter_odev_bt_send,
};
#endif

64
apps/earphone/wireless_mic/odev/odev_bt/include/adapter_odev_ble.h Normal file
View File

@ -0,0 +1,64 @@
#ifndef __ADAPTER_ODEV_BLE_H__
#define __ADAPTER_ODEV_BLE_H__
#include "generic/typedef.h"
#include "le_client_demo.h"
#include "app_config.h"
#define DEVICE_RSSI_LEVEL (-50)
#define POWER_ON_PAIR_TIME (3500)//unit ms,切换搜索回连周期
struct _odev_ble_parm {
client_conn_cfg_t *cfg_t;
};
enum {
ODEV_BLE_CLOSE,
ODEV_BLE_OPEN,
ODEV_BLE_START,
ODEV_BLE_STOP,
};
enum {
MATCH_KEYBOARD,
MATCH_MOUSE,
MATCH_NULL,
};
struct _odev_ble {
u16 ble_connected;
u16 ble_timer_id;
u8 status;
u8 match_type;
struct ble_client_operation_t *ble_client_api;
struct _odev_ble_parm *parm;
};
int adapter_odev_ble_open(void *priv);
int adapter_odev_ble_start(void *priv);
int adapter_odev_ble_stop(void *priv);
int adapter_odev_ble_close(void *priv);
int adapter_odev_ble_config(int cmd, void *parm);
int adapter_odev_ble_send(void *priv, u8 *buf, u16 len);
void adapter_odev_ble_search_device(void);
//dongle
void dongle_ble_report_data_deal(att_data_report_t *report_data, target_uuid_t *search_uuid);
void dongle_adapter_event_callback(le_client_event_e event, u8 *packet, int size);
int dongle_ble_send(void *priv, u8 *buf, u16 len);
//wireless_mic
void wireless_mic_ble_report_data_deal(att_data_report_t *report_data, target_uuid_t *search_uuid);
void wireless_adapter_event_callback(le_client_event_e event, u8 *packet, int size);
int wireless_mic_ble_send(void *priv, u8 *buf, u16 len);
#define BLE_REPORT_DATA_DEAL(a,b) wireless_mic_ble_report_data_deal(a,b)
#define ADAPTER_EVENT_CALLBACK(a,b,c) wireless_adapter_event_callback(a,b,c)
#define ADAPTER_ODEV_BLE_SEND(a,b,c) wireless_mic_ble_send(a,b,c)
extern struct _odev_ble odev_ble;
extern client_conn_cfg_t odev_ble_conn_config;
#endif//__ADAPTER_ODEV_BLE_H__

26
apps/earphone/wireless_mic/odev/odev_bt/include/adapter_odev_bt.h Normal file
View File

@ -0,0 +1,26 @@
#ifndef __ADAPTER_ODEV_BT_H__
#define __ADAPTER_ODEV_BT_H__
#include "generic/typedef.h"
#include "adapter_odev_edr.h"
#include "adapter_odev_ble.h"
enum {
ODEV_EDR = 0x0,
ODEV_BLE,
};
struct _odev_bt_parm {
u8 mode;
struct _odev_edr_parm edr_parm;
struct _odev_ble_parm ble_parm;
};
struct _odev_bt {
struct _odev_bt_parm *parm;
struct _odev_edr *edr;
struct _odev_ble *ble;
};
#endif//__ADAPTER_ODEV_BT_H__

80
apps/earphone/wireless_mic/odev/odev_bt/include/adapter_odev_edr.h Normal file
View File

@ -0,0 +1,80 @@
#ifndef __ADAPTER_ODEV_EDR_H__
#define __ADAPTER_ODEV_EDR_H__
#include "generic/typedef.h"
#include "user_cfg.h"
#include "event.h"
#include "sbc_enc.h"
#define SEARCH_BD_ADDR_LIMITED 0
#define SEARCH_BD_NAME_LIMITED 1
#define SEARCH_CUSTOM_LIMITED 2
#define SEARCH_NULL_LIMITED 3
#define SEARCH_LIMITED_MODE SEARCH_BD_NAME_LIMITED
enum {
ODEV_EDR_CLOSE,
ODEV_EDR_OPEN,
ODEV_EDR_START,
ODEV_EDR_STOP,
};
struct _odev_edr {
struct list_head inquiry_noname_head;
u8 edr_search_busy;
u8 edr_read_name_start;
u8 edr_search_spp;
u8 status;
int (*fun)(void *, u8, u8, void *);
void *priv;
u8 mode;
u16 call_timeout;
volatile u16 start_a2dp_flag;
struct _odev_edr_parm *parm;
};
struct _odev_edr_parm {
u8 poweron_start_search : 1;
u8 disable_filt : 1;
u8 discon_always_search : 1;
u8 inquiry_len;
u8 search_type;
u8 bt_name_filt_num;
u8(*bt_name_filt)[LOCAL_NAME_LEN];
u8 spp_name_filt_num;
u8(*spp_name_filt)[LOCAL_NAME_LEN];
u8 bd_addr_filt_num;
u8(*bd_addr_filt)[6];
};
typedef enum {
AVCTP_OPID_VOLUME_UP = 0x41,
AVCTP_OPID_VOLUME_DOWN = 0x42,
AVCTP_OPID_MUTE = 0x43,
AVCTP_OPID_PLAY = 0x44,
AVCTP_OPID_STOP = 0x45,
AVCTP_OPID_PAUSE = 0x46,
AVCTP_OPID_NEXT = 0x4B,
AVCTP_OPID_PREV = 0x4C,
} AVCTP_CMD_TYPE;
int adapter_odev_edr_open(void *priv);
int adapter_odev_edr_start(void *priv);
int adapter_odev_edr_stop(void *priv);
int adapter_odev_edr_close(void *priv);
int adapter_odev_edr_get_status(void *priv);
int adapter_odev_edr_config(int cmd, void *parm);
int adapter_odev_edr_pp(u8 pp);
int adapter_odev_edr_media_prepare(u8 mode, int (*fun)(void *, u8, u8, void *), void *priv);
void adapter_odev_edr_search_device(void);
void adapter_odev_edr_search_stop();
extern struct _odev_edr odev_edr;
#endif//__ADAPTER_ODEV_BT_H__

197
apps/earphone/wireless_mic/odev/odev_bt/odev_ble/adapter_odev_ble.c Normal file
View File

@ -0,0 +1,197 @@
#include "adapter_odev.h"
#include "adapter_odev_ble.h"
#include "app_config.h"
#include "btstack/le/att.h"
#include "btstack/le/le_user.h"
#include "ble_user.h"
#include "btcontroller_modules.h"
#if TCFG_WIRELESS_MIC_ENABLE
#define LOG_TAG_CONST WIRELESSMIC
#define LOG_TAG "[ODEV_BLE]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
#define LOG_DUMP_ENABLE
#define LOG_CLI_ENABLE
#include "debug.h"
struct _odev_ble odev_ble;
#define __this (&odev_ble)
extern void ble_module_enable(u8 en);
extern void bt_ble_init(void);
static void ble_report_data_deal(att_data_report_t *report_data, target_uuid_t *search_uuid)
{
/* dongle_ble_report_data_deal(report_data,search_uuid); */
/* wireless_mic_ble_report_data_deal(report_data,search_uuid); */
BLE_REPORT_DATA_DEAL(report_data, search_uuid);
}
static void adapter_event_callback(le_client_event_e event, u8 *packet, int size)
{
/* dongle_adapter_event_callback(event,packet,size); */
/* wireless_adapter_event_callback(event,packet,size); */
ADAPTER_EVENT_CALLBACK(event, packet, size);
}
//client default 信息
client_conn_cfg_t odev_ble_conn_config = {
.match_dev_cfg[0] = NULL, //匹配指定的名字
.match_dev_cfg[1] = NULL,
.match_dev_cfg[2] = NULL,
.search_uuid_cnt = 0,
.security_en = 0, //加密配对
.report_data_callback = ble_report_data_deal,
.event_callback = adapter_event_callback,
};
int adapter_odev_ble_open(void *priv)
{
r_printf("adapter_odev_ble_open\n");
if (__this->status == ODEV_BLE_OPEN) {
r_printf("adapter_odev_ble_already_open\n");
return 0;
}
memset(__this, 0, sizeof(struct _odev_ble));
__this->status = ODEV_BLE_OPEN;
__this->match_type = MATCH_NULL;
if (priv) {
__this->parm = (struct _odev_ble_parm *)priv;
if (__this->parm->cfg_t->match_dev_cfg[0]) {
odev_ble_conn_config.match_dev_cfg[0] = __this->parm->cfg_t->match_dev_cfg[0];
}
if (__this->parm->cfg_t->match_dev_cfg[1]) {
odev_ble_conn_config.match_dev_cfg[1] = __this->parm->cfg_t->match_dev_cfg[1];
}
if (__this->parm->cfg_t->match_dev_cfg[2]) {
odev_ble_conn_config.match_dev_cfg[2] = __this->parm->cfg_t->match_dev_cfg[2];
}
if (__this->parm->cfg_t->search_uuid_table) {
odev_ble_conn_config.search_uuid_table = __this->parm->cfg_t->search_uuid_table;
}
odev_ble_conn_config.search_uuid_cnt = __this->parm->cfg_t->search_uuid_cnt;
odev_ble_conn_config.security_en = __this->parm->cfg_t->security_en;
if (odev_ble_conn_config.match_dev_cfg[0]) {
y_printf("match_dev_cfg[0] : %s\n", odev_ble_conn_config.match_dev_cfg[0]->compare_data);
}
if (odev_ble_conn_config.match_dev_cfg[1]) {
y_printf("match_dev_cfg[1] : %s\n", odev_ble_conn_config.match_dev_cfg[1]->compare_data);
}
if (odev_ble_conn_config.match_dev_cfg[2]) {
y_printf("match_dev_cfg[2] : %s\n", odev_ble_conn_config.match_dev_cfg[2]->compare_data);
}
}
#if BLE_CLIENT_EN || TRANS_MULTI_BLE_EN || BLE_WIRELESS_MIC_CLIENT_EN
__this->ble_client_api = ble_get_client_operation_table();
ASSERT(__this->ble_client_api, "%s : %s : %d\n", __FUNCTION__, "ble_client_api == NULL", __LINE__);
__this->ble_client_api->init_config(0, &odev_ble_conn_config);
extern void ble_vendor_set_hold_prio(u8 role, u8 enable);
ble_vendor_set_hold_prio(0, 1);
#ifndef CONFIG_NEW_BREDR_ENABLE
//优化多连接,卡音
bredr_link_vendor_support_packet_enable(PKT_TYPE_2DH5_EU, 0);
#endif //CONFIG_NEW_BREDR_ENABLE
#endif //#if BLE_CLIENT_EN || TRANS_MULTI_BLE_EN || BLE_WIRELESS_MIC_CLIENT_EN
return 0;
}
void adapter_odev_ble_search_device(void)
{
#if BLE_CLIENT_EN || TRANS_MULTI_BLE_EN || BLE_WIRELESS_MIC_CLIENT_EN
ble_module_enable(1);
#endif
}
int adapter_odev_ble_start(void *priv)
{
r_printf("adapter_odev_ble_start\n");
if (__this->status == ODEV_BLE_START) {
r_printf("adapter_odev_ble_already_start\n");
return 0;
}
__this->status = ODEV_BLE_START;
#if BLE_CLIENT_EN || TRANS_MULTI_BLE_EN || BLE_WIRELESS_MIC_CLIENT_EN
bt_ble_init();
#endif
return 0;
}
int adapter_odev_ble_stop(void *priv)
{
r_printf("adapter_odev_ble_stop\n");
if (__this->status == ODEV_BLE_STOP) {
r_printf("adapter_odev_ble_already_stop\n");
return 0;
}
__this->status = ODEV_BLE_STOP;
#if BLE_CLIENT_EN || TRANS_MULTI_BLE_EN || BLE_WIRELESS_MIC_CLIENT_EN
ble_module_enable(0);
#endif
return 0;
}
int adapter_odev_ble_close(void *priv)
{
r_printf("adapter_odev_ble_close\n");
if (__this->status == ODEV_BLE_CLOSE) {
r_printf("adapter_odev_ble_already_close\n");
return 0;
}
__this->status = ODEV_BLE_CLOSE;
#if BLE_CLIENT_EN || TRANS_MULTI_BLE_EN || BLE_WIRELESS_MIC_CLIENT_EN
ble_module_enable(0);
#endif
__this->ble_client_api = NULL;
return 0;
}
int adapter_odev_ble_send(void *priv, u8 *buf, u16 len)
{
int ret = 0;
if (!__this->ble_connected) {
r_printf("adapter_odev_ble not connect\n");
return -1;
}
ret = ADAPTER_ODEV_BLE_SEND(priv, buf, len);
return ret;
}
int adapter_odev_ble_config(int cmd, void *parm)
{
switch (cmd) {
case 0:
break;
default:
break;
}
return 0;
}
#endif

153
apps/earphone/wireless_mic/odev/odev_bt/odev_ble/odev_ble_wireless.c Normal file
View File

@ -0,0 +1,153 @@
#include "adapter_odev.h"
#include "adapter_odev_ble.h"
#include "app_config.h"
#include "btstack/le/att.h"
#include "btstack/le/le_user.h"
#include "ble_user.h"
#include "btcontroller_modules.h"
#include "adapter_process.h"
#if TCFG_WIRELESS_MIC_ENABLE
#define LOG_TAG_CONST WIRELESSMIC
#define LOG_TAG "[ODEV_BLE]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
#define LOG_DUMP_ENABLE
#define LOG_CLI_ENABLE
#include "debug.h"
#if (APP_MAIN == APP_WIRELESS_MIC)
#define __this (&odev_ble)
#define CLIENT_SENT_TEST 0
static u16 ble_client_timer = 0;
static void client_test_write(void)
{
static u8 count = 0;
u32 maxVaildAttValue = 141;
u8 test_buf[145];
printf(" %x ", count);
memset(test_buf, count, sizeof(test_buf));
int ret = __this->ble_client_api->opt_comm_send(0x0006, &test_buf, maxVaildAttValue + 4, ATT_OP_WRITE_WITHOUT_RESPOND);
if (APP_BLE_BUFF_FULL != ret) {
count++;
}
}
void wireless_mic_ble_report_data_deal(att_data_report_t *report_data, target_uuid_t *search_uuid)
{
switch (report_data->packet_type) {
case GATT_EVENT_NOTIFICATION:
//notify
y_printf("value_handle:%x conn_handle:%x uuid:%x\n", report_data->value_handle, report_data->conn_handle, search_uuid->services_uuid16);
break;
case GATT_EVENT_INDICATION: //indicate
log_info("indication handle:%04x,len= %d\n", report_data->value_handle, report_data->blob_length);
put_buf(report_data->blob, report_data->blob_length);
break;
case GATT_EVENT_CHARACTERISTIC_VALUE_QUERY_RESULT: //read
log_info("read handle:%04x,len= %d\n", report_data->value_handle, report_data->blob_length);
put_buf(report_data->blob, report_data->blob_length);
break;
case GATT_EVENT_LONG_CHARACTERISTIC_VALUE_QUERY_RESULT: //read long
log_info("read_long handle:%04x,len= %d\n", report_data->value_handle, report_data->blob_length);
put_buf(report_data->blob, report_data->blob_length);
break;
default:
break;
}
}
void wireless_adapter_event_callback(le_client_event_e event, u8 *packet, int size)
{
printf(" wireless_adapter_event_callback==================\n");
switch (event) {
case CLI_EVENT_MATCH_DEV:
client_match_cfg_t *match_dev = packet;
log_info("match_name:%s\n", match_dev->compare_data);
break;
case CLI_EVENT_MATCH_UUID:
r_printf("CLI_EVENT_MATCH_UUID\n");
opt_handle_t *opt_hdl = packet;
log_info("match_uuid handle : %x\n", opt_hdl->value_handle);
break;
case CLI_EVENT_SEARCH_PROFILE_COMPLETE:
log_info("search profile commplete");
__this->ble_connected = 2;
break;
case CLI_EVENT_CONNECTED:
log_info("bt connected");
__this->ble_connected = 1;
break;
case CLI_EVENT_CONNECTION_UPDATE:
printf("==============================CLI_EVENT_CONNECTION_UPDATE\n");
#if CLIENT_SENT_TEST
ble_client_timer = sys_timer_add(NULL, client_test_write, 100);
#endif
adapter_process_event_notify(ADAPTER_EVENT_ODEV_MEDIA_OPEN, 0);
break;
case CLI_EVENT_DISCONNECT:
__this->ble_connected = 0;
#if CLIENT_SENT_TEST
if (ble_client_timer) {
sys_timer_del(ble_client_timer);
}
ble_client_timer = 0;
#endif
adapter_process_event_notify(ADAPTER_EVENT_ODEV_MEDIA_CLOSE, 0);
log_info("bt disconnec");
break;
default:
break;
}
}
int wireless_mic_ble_send(void *priv, u8 *buf, u16 len)
{
// if (len > 145) {
// printf("ble send max len is 145 !!!!!, len = %d\n", len);
// return -1;
// }
int ret = __this->ble_client_api->opt_comm_send(0x0006, buf, len, ATT_OP_WRITE_WITHOUT_RESPOND);
return ret;
}
#else
void wireless_mic_ble_report_data_deal(att_data_report_t *report_data, target_uuid_t *search_uuid)
{
}
void wireless_adapter_event_callback(le_client_event_e event, u8 *packet, int size)
{
}
int wireless_mic_ble_send(void *priv, u8 *buf, u16 len)
{
return 0;
}
#endif
#endif

702
apps/earphone/wireless_mic/odev/odev_bt/odev_edr/adapter_odev_edr.c Normal file
View File

@ -0,0 +1,702 @@
#include "adapter_odev.h"
#include "adapter_odev_bt.h"
#include "adapter_odev_edr.h"
//#include "wireless_mic/bt.h"
#include "btstack/avctp_user.h"
#include "classic/hci_lmp.h"
#include "list.h"
#include "os/os_api.h"
#include "circular_buf.h"
#include "app_config.h"
#include "event.h"
#include "bt_edr_fun.h"
#include "usb/device/hid.h"
#if TCFG_WIRELESS_MIC_ENABLE
#define LOG_TAG_CONST WIRELESSMIC
#define LOG_TAG "[ODEV_EDR]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
#define LOG_DUMP_ENABLE
#define LOG_CLI_ENABLE
#include "debug.h"
struct _odev_edr odev_edr;
#define __this (&odev_edr)
struct inquiry_noname_remote {
struct list_head entry;
u8 match;
s8 rssi;
u8 addr[6];
u32 class;
};
/*----------------------------------------------------------------------------*/
/**@brief 蓝牙发射发起搜索设备
@param 无
@return 无
@note
*/
/*----------------------------------------------------------------------------*/
void adapter_odev_edr_search_device(void)
{
if (!get_bt_init_status()) {
return;
}
printf("__this->edr_search_busy = %d", __this->edr_search_busy);
if (__this->edr_search_busy) {
return;
}
////断开链接
if (get_curr_channel_state() != 0) {
user_send_cmd_prepare(USER_CTRL_POWER_OFF, 0, NULL);
} else {
if (hci_standard_connect_check()) {
user_send_cmd_prepare(USER_CTRL_PAGE_CANCEL, 0, NULL);
user_send_cmd_prepare(USER_CTRL_CONNECTION_CANCEL, 0, NULL);
}
}
/* if there are some connected channel ,then disconnect*/
////关闭可发现可链接
user_send_cmd_prepare(USER_CTRL_WRITE_SCAN_DISABLE, 0, NULL);
user_send_cmd_prepare(USER_CTRL_WRITE_CONN_DISABLE, 0, NULL);
__this->edr_read_name_start = 0;
__this->edr_search_busy = 1;
u8 inquiry_length = __this->parm->inquiry_len; // inquiry_length * 1.28s
user_send_cmd_prepare(USER_CTRL_SEARCH_DEVICE, 1, &inquiry_length);
printf("[adapter] %s, %d\n", __FUNCTION__, __LINE__);
}
/*----------------------------------------------------------------------------*/
/**@brief 蓝牙发射发起搜索spp设备
@param 无
@return 无
@note
*/
/*----------------------------------------------------------------------------*/
void adapter_odev_edr_search_spp_device()
{
__this->edr_search_spp = 1;
set_start_search_spp_device(1);
adapter_odev_edr_search_device();
}
/*----------------------------------------------------------------------------*/
/**@brief 蓝牙发射停止搜索
@param 无
@return 无
@note
*/
/*----------------------------------------------------------------------------*/
void adapter_odev_edr_search_stop()
{
log_info("adapter_odev_edr_search_stop\n");
struct inquiry_noname_remote *remote, *n;
__this->edr_search_spp = 0;
__this->edr_search_busy = 0;
set_start_search_spp_device(0);
list_for_each_entry_safe(remote, n, &__this->inquiry_noname_head, entry) {
list_del(&remote->entry);
free(remote);
}
__this->edr_read_name_start = 0;
}
//搜索完成回调
void bt_hci_event_inquiry(struct bt_event *bt)
{
r_printf("bt_hci_event_inquiry result : %d\n", bt->value);
if (!__this->parm->discon_always_search) {
return;
}
adapter_odev_edr_search_stop();
if (!bt->value) {
adapter_odev_edr_search_device();
}
}
/*----------------------------------------------------------------------------*/
/**@brief 蓝牙发射搜索通过名字过滤
@param 无
@return 无
@note
*/
/*----------------------------------------------------------------------------*/
#if (SEARCH_LIMITED_MODE == SEARCH_BD_NAME_LIMITED)
static u8 adapter_odev_edr_search_bd_name_filt(char *data, u8 len, u32 dev_class, char rssi)
{
char bd_name[64] = {0};
u8 i;
if ((len > (sizeof(bd_name))) || (len == 0)) {
r_printf("bd_name_len error:%d\n", len);
return FALSE;
}
memset(bd_name, 0, sizeof(bd_name));
memcpy(bd_name, data, len);
g_printf("edr name:%s,len:%d,class %x ,rssi %d\n", bd_name, len, dev_class, rssi);
if (__this->edr_search_spp) {
for (i = 0; i < __this->parm->spp_name_filt_num; i++) {
if (memcmp(data, __this->parm->spp_name_filt[i], len) == 0) {
y_printf("*****find spp dev ok******\n");
return TRUE;
}
}
} else {
for (i = 0; i < __this->parm->bt_name_filt_num; i++) {
/* r_printf("%d : %s\n",i,__this->parm->bt_name_filt[i]); */
if (memcmp(data, __this->parm->bt_name_filt[i], len) == 0) {
y_printf("*****find dev ok******\n");
return TRUE;
}
}
}
return FALSE;
}
#endif //(SEARCH_LIMITED_MODE == SEARCH_BD_NAME_LIMITED)
/*----------------------------------------------------------------------------*/
/**@brief 蓝牙发射搜索通过地址过滤
@param 无
@return 无
@note
*/
/*----------------------------------------------------------------------------*/
#if (SEARCH_LIMITED_MODE == SEARCH_BD_ADDR_LIMITED)
static u8 adapter_odev_edr_search_bd_addr_filt(u8 *addr)
{
u8 i;
log_info("search_bd_addr_filt:");
log_info_hexdump(addr, 6);
for (i = 0; i < __this->parm->bd_addr_filt_num; i++) {
if (memcmp(addr, __this->parm->bd_addr_filt[i], 6) == 0) {
y_printf("bd_addr match:%d\n", i);
return TRUE;
}
}
y_printf("bd_addr not match\n");
return FALSE;
}
#endif //(SEARCH_LIMITED_MODE == SEARCH_BD_ADDR_LIMITED)
/*----------------------------------------------------------------------------*/
/**@brief 蓝牙发射搜索结果回调处理
@param name : 设备名字
name_len: 设备名字长度
addr: 设备地址
dev_class: 设备类型
rssi: 设备信号强度
@return 无
@note
蓝牙设备搜索结果，可以做名字/地址过滤，也可以保存搜到的所有设备
在选择一个进行连接，获取其他你想要的操作。
返回TRUE，表示搜到指定的想要的设备，搜索结束，直接连接当前设备
返回FALSE，则继续搜索，直到搜索完成或者超时
*/
/*----------------------------------------------------------------------------*/
static u8 adapter_odev_edr_search_result(char *name, u8 name_len, u8 *addr, u32 dev_class, char rssi)
{
if (__this->parm->disable_filt) {
return TRUE;
}
if (name == NULL) {
struct inquiry_noname_remote *remote = malloc(sizeof(struct inquiry_noname_remote));
remote->match = 0;
remote->class = dev_class;
remote->rssi = rssi;
memcpy(remote->addr, addr, 6);
local_irq_disable();
list_add_tail(&remote->entry, &__this->inquiry_noname_head);
local_irq_enable();
if (__this->edr_read_name_start == 0) {
__this->edr_read_name_start = 1;
user_send_cmd_prepare(USER_CTRL_READ_REMOTE_NAME, 6, addr);
}
}
#if (SEARCH_LIMITED_MODE == SEARCH_BD_NAME_LIMITED)
return adapter_odev_edr_search_bd_name_filt(name, name_len, dev_class, rssi);
#endif
#if (SEARCH_LIMITED_MODE == SEARCH_BD_ADDR_LIMITED)
return adapter_odev_edr_search_bd_addr_filt(addr);
#endif
#if (SEARCH_LIMITED_MODE == SEARCH_CUSTOM_LIMITED)
/*以下为搜索结果自定义处理*/
log_info("name:%s,len:%d,class %x ,rssi %d\n", bt_name, name_len, dev_class, rssi);
return FALSE;
#endif
#if (SEARCH_LIMITED_MODE == SEARCH_NULL_LIMITED)
/*没有指定限制，则搜到什么就连接什么*/
return TRUE;
#endif
}
/*----------------------------------------------------------------------------*/
/**@brief 蓝牙发射搜索设备没有名字的设备，放进需要获取名字链表
@param status : 获取成功 0：获取失败
addr:设备地址
name：设备名字
@return 无
@note
*/
/*----------------------------------------------------------------------------*/
static void adapter_odev_edr_search_noname(u8 status, u8 *addr, u8 *name)
{
u8 res = 0;
struct inquiry_noname_remote *remote, *n;
if (__this->status != ODEV_EDR_START) {
return ;
}
local_irq_disable();
if (status) {
list_for_each_entry_safe(remote, n, &__this->inquiry_noname_head, entry) {
if (!memcmp(addr, remote->addr, 6)) {
list_del(&remote->entry);
free(remote);
}
}
goto __find_next;
}
list_for_each_entry_safe(remote, n, &__this->inquiry_noname_head, entry) {
if (!memcmp(addr, remote->addr, 6)) {
res = adapter_odev_edr_search_result(name, strlen(name), addr, remote->class, remote->rssi);
if (res) {
__this->edr_read_name_start = 0;
remote->match = 1;
user_send_cmd_prepare(USER_CTRL_INQUIRY_CANCEL, 0, NULL);
local_irq_enable();
return;
}
list_del(&remote->entry);
free(remote);
}
}
__find_next:
__this->edr_read_name_start = 0;
remote = NULL;
if (!list_empty(&__this->inquiry_noname_head)) {
remote = list_first_entry(&__this->inquiry_noname_head, struct inquiry_noname_remote, entry);
}
local_irq_enable();
if (remote) {
__this->edr_read_name_start = 1;
user_send_cmd_prepare(USER_CTRL_READ_REMOTE_NAME, 6, remote->addr);
}
}
void remote_name_speciali_deal(u8 status, u8 *addr, u8 *name)
{
adapter_odev_edr_search_noname(status, addr, name);
}
/*----------------------------------------------------------------------------*/
/**@brief 蓝牙发射接收到设备按键消息
@param cmd:按键命令
@return 无
@note
发射器收到接收器发过来的控制命令处理
根据实际需求可以在收到控制命令之后做相应的处理
蓝牙库里面定义的是weak函数，直接再定义一个同名可获取信息
*/
/*----------------------------------------------------------------------------*/
void emitter_rx_avctp_opid_deal(u8 cmd, u8 id) //属于库的弱函数重写
{
log_debug("avctp_rx_cmd:%x\n", cmd);
#if (USB_DEVICE_CLASS_CONFIG & HID_CLASS)
switch (cmd) {
case AVCTP_OPID_NEXT:
log_info("AVCTP_OPID_NEXT\n");
adapter_avctp_key_handler(USB_AUDIO_NEXTFILE);
break;
case AVCTP_OPID_PREV:
log_info("AVCTP_OPID_PREV\n");
adapter_avctp_key_handler(USB_AUDIO_PREFILE);
break;
case AVCTP_OPID_PAUSE:
case AVCTP_OPID_PLAY:
log_info("AVCTP_OPID_PP\n");
adapter_avctp_key_handler(USB_AUDIO_PP);
break;
case AVCTP_OPID_VOLUME_UP:
log_info("AVCTP_OPID_VOLUME_UP\n");
adapter_avctp_key_handler(USB_AUDIO_VOLUP);
break;
case AVCTP_OPID_VOLUME_DOWN:
log_info("AVCTP_OPID_VOLUME_DOWN\n");
adapter_avctp_key_handler(USB_AUDIO_VOLDOWN);
break;
default:
break;
}
#endif//(USB_DEVICE_CLASS_CONFIG & HID_CLASS)
return ;
}
/*----------------------------------------------------------------------------*/
/**@brief 蓝牙发射接收设备同步音量
@param vol:接收到设备同步音量
@return 无
@note
*/
/*----------------------------------------------------------------------------*/
void emitter_rx_vol_change(u8 vol) //属于库的弱函数重写
{
log_info("vol_change:%d \n", vol);
}
//pin code 轮询功能
const char pin_code_list[10][4] = {
{'0', '0', '0', '0'},
{'1', '2', '3', '4'},
{'8', '8', '8', '8'},
{'1', '3', '1', '4'},
{'4', '3', '2', '1'},
{'1', '1', '1', '1'},
{'2', '2', '2', '2'},
{'3', '3', '3', '3'},
{'5', '6', '7', '8'},
{'5', '5', '5', '5'}
};
/*----------------------------------------------------------------------------*/
/**@brief 蓝牙发射链接pincode 轮询
@param 无
@return 无
@note
*/
/*----------------------------------------------------------------------------*/
const char *bt_get_emitter_pin_code(u8 flag) //属于库的弱函数重写
{
static u8 index_flag = 0;
int pincode_num = sizeof(pin_code_list) / sizeof(pin_code_list[0]);
if (flag == 1) {
//reset index
index_flag = 0;
} else if (flag == 2) {
//查询是否要开始继续回连尝试pin code。
if (index_flag >= pincode_num) {
//之前已经遍历完了
return NULL;
} else {
index_flag++; //准备使用下一个
}
} else {
log_debug("get pin code index %d\n", index_flag);
}
return &pin_code_list[index_flag][0];
}
/*----------------------------------------------------------------------------*/
/**@brief get source status
@param 无
@return 无
@note
*/
/*----------------------------------------------------------------------------*/
u8 bt_emitter_stu_get(void) //属于库的弱函数重写
{
//extern int adapter_audio_sbc_enc_is_work(void);
//return adapter_audio_sbc_enc_is_work();
return 1;
}
/*----------------------------------------------------------------------------*/
/**@brief set source status
@param 无
@return 无
@note
*/
/*----------------------------------------------------------------------------*/
static u8 adapter_odev_edr_stu_set(u8 on)
{
if (!(get_emitter_curr_channel_state() & A2DP_SRC_CH)) {
__emitter_send_media_toggle(NULL, 0);
return 0;
}
log_debug("total con dev:%d ", get_total_connect_dev());
if (on && (get_total_connect_dev() == 0)) {
on = 0;
}
r_printf("adapter_odev_edr_stu_set:%d\n", on);
__emitter_send_media_toggle(NULL, on);
return on;
}
static void esco_call_timeout(void *priv)
{
g_printf("esco_call_timeout\n");
__this->call_timeout = 0;
user_emitter_cmd_prepare(USER_CTRL_HFP_CALL_ANSWER, 0, NULL);
}
#define ESCO_CALL_TIMEOUT_MSEC (50)
static int esco_pp(u8 pp)
{
if (pp) {
user_emitter_cmd_prepare(USER_CTRL_HFP_CALL_LAST_NO, 0, NULL);
if (__this->call_timeout == 0) {
__this->call_timeout = sys_timeout_add(NULL, esco_call_timeout, ESCO_CALL_TIMEOUT_MSEC);
} else {
sys_timer_modify(__this->call_timeout, ESCO_CALL_TIMEOUT_MSEC);
}
} else {
user_emitter_cmd_prepare(USER_CTRL_HFP_CALL_HANGUP, 0, NULL);
}
return pp;
}
int a2dp_pp(u8 pp)
{
if (get_total_connect_dev() == 0) {
return 0;
}
if (!(get_emitter_curr_channel_state() & A2DP_SRC_CH)) {
return 0;
}
return adapter_odev_edr_stu_set(pp);
}
int adapter_odev_edr_pp(u8 pp)
{
int ret = 0;
if (__this->mode) { //esco
g_printf("esco mode\n");
ret = esco_pp(pp);
} else { //a2dp
g_printf("a2dp mode\n");
ret = a2dp_pp(pp);
}
return ret;
}
int adapter_odev_edr_open(void *priv)
{
r_printf("adapter_odev_edr_open\n");
if (__this->status == ODEV_EDR_OPEN) {
r_printf("adapter_odev_edr_already_open\n");
return 0;
}
__this->status = ODEV_EDR_OPEN;
memset(__this, 0, sizeof(struct _odev_edr));
__this->parm = (struct _odev_edr_parm *)priv;
return 0;
}
int adapter_odev_edr_start(void *priv)
{
r_printf("adapter_odev_edr_start\n");
if (__this->status == ODEV_EDR_START) {
r_printf("adapter_odev_edr_already_start\n");
return 0;
}
__this->status = ODEV_EDR_START;
INIT_LIST_HEAD(&__this->inquiry_noname_head);
lmp_set_sniff_establish_by_remote(1);
inquiry_result_handle_register(adapter_odev_edr_search_result);
bredr_bulk_change(0);
////切换样机状态
__set_emitter_enable_flag(1);
a2dp_source_init(NULL, 0, 1);
#if (USER_SUPPORT_PROFILE_HFP_AG==1)
hfp_ag_buf_init(NULL, 0, 1);
#endif
#if USER_SUPPORT_DUAL_A2DP_SOURCE
dongle_1t2_init(__this);
#endif
if (connect_last_device_from_vm()) {
r_printf("start connect device vm addr\n");
} else {
if (__this->parm->poweron_start_search) {
r_printf("start search device ...\n");
adapter_odev_edr_search_device();
}
}
return 0;
}
int adapter_odev_edr_stop(void *priv)
{
if (__this->status == ODEV_EDR_STOP) {
r_printf("adapter_odev_edr_already_stop\n");
return 0;
}
__this->status = ODEV_EDR_STOP;
if (__this->edr_search_busy) {
adapter_odev_edr_search_stop();
} else {
adapter_odev_edr_pp(0);
}
return 0;
}
int adapter_odev_edr_close(void *priv)
{
if (__this->status == ODEV_EDR_CLOSE) {
r_printf("adapter_odev_edr_already_close\n");
return 0;
}
__this->status = ODEV_EDR_CLOSE;
adapter_odev_edr_search_stop();
return 0;
}
int adapter_odev_edr_get_status(void *priv)
{
g_printf("adapter_odev_edr_get_status : %x\n", get_emitter_curr_channel_state());
if ((get_emitter_curr_channel_state() & A2DP_SRC_CH) && (get_emitter_curr_channel_state() & HFP_AG_CH)) {
return 1;
} else {
return 0;
}
}
int adapter_odev_edr_media_prepare(u8 mode, int (*fun)(void *, u8, u8, void *), void *priv)
{
__this->mode = mode;
__this->fun = fun;
__this->priv = priv;
u8 call_status = get_call_status();
r_printf("mode : %d pp status:%d call status:%d\n", mode, bt_emitter_stu_get(), call_status);
if (mode) { //esco
//stop a2dp
y_printf("stop a2dp\n");
a2dp_pp(0);
if (call_status == BT_CALL_HANGUP) {
//start esco
y_printf("start esco\n");
esco_pp(1);
} else if (call_status == BT_CALL_ACTIVE) {
extern struct app_bt_opr app_bt_hdl;
if (__this->fun) {
__this->fun(__this->priv, __this->mode, 1, &app_bt_hdl.sco_info);
}
}
} else { //a2dp
if (call_status != BT_CALL_HANGUP) {
//stop esco
y_printf("stop esco\n");
esco_pp(0);
__this->start_a2dp_flag = 1;
} else {
y_printf("start a2dp\n");
a2dp_pp(1);
}
}
return 0;
}
/*----------------------------------------------------------------------------*/
/**@brief 蓝牙SBC编码初始化函数,属于库的弱函数重写
@param
@return
@note
*/
/*----------------------------------------------------------------------------*/
int a2dp_sbc_encoder_init(void *sbc_struct)
{
if (!__this->fun) {
return 0;
}
if (sbc_struct) { //start a2dp
__this->fun(__this->priv, __this->mode, 1, sbc_struct);
} else { //stop a2dp
/* __this->fun(__this->priv, __this->mode, 0, sbc_struct); */
}
return 0;
}
int adapter_odev_edr_config(int cmd, void *parm)
{
switch (cmd) {
case 0:
break;
default:
break;
}
return 0;
}
#endif

67
apps/earphone/wireless_mic/odev/odev_dac/adapter_odev_dac.c Normal file
View File

@ -0,0 +1,67 @@
#include "adapter_odev.h"
#include "adapter_process.h"
#include "adapter_odev_dac.h"
#include "audio_config.h"
//#include "adapter_audio_stream.h"
#include "asm/dac.h"
#if TCFG_WIRELESS_MIC_ENABLE
#if (TCFG_AUDIO_DAC_ENABLE)
//struct audio_dac_channel default_dac = {0};
extern struct audio_dac_hdl dac_hdl;
static int adapter_odev_dac_open(void *parm)
{
adapter_process_event_notify(ADAPTER_EVENT_ODEV_INIT_OK, 0);
return 0;
}
static int adapter_odev_dac_start(void *priv, struct adapter_media *media)
{
//通知主流程请求启动音频媒体
adapter_process_event_notify(ADAPTER_EVENT_ODEV_MEDIA_OPEN, 0);
return 0;
}
static int adapter_odev_dac_stop(void *priv)
{
return 0;
}
static int adapter_odev_dac_close(void)
{
//通知主流程请求停止音频媒体
adapter_process_event_notify(ADAPTER_EVENT_ODEV_MEDIA_CLOSE, 0);
return 0;
}
static int adapter_odev_dac_pp_ctl(u8 pp)
{
return 0;
}
static int adapter_odev_dac_get_status(void *priv)
{
return 0;
}
static int adapter_odev_dac_config(int cmd, void *parm)
{
return 0;
}
REGISTER_ADAPTER_ODEV(adapter_odev_dac) = {
.id = ADAPTER_ODEV_DAC,
.open = adapter_odev_dac_open,
.start = adapter_odev_dac_start,
.stop = adapter_odev_dac_stop,
.close = adapter_odev_dac_close,
.media_pp = NULL,
.get_status = NULL,
.media_prepare = NULL,
.event_fun = NULL,
.config = NULL,
};
#endif
#endif//TCFG_AUDIO_DAC_ENABLE

11
apps/earphone/wireless_mic/odev/odev_dac/adapter_odev_dac.h Normal file
View File

@ -0,0 +1,11 @@
#ifndef __ADAPTER_ODEV_DAC_H__
#define __ADAPTER_ODEV_DAC_H__
#include "generic/typedef.h"
struct _odev_dac {
};
#endif//__ADAPTER_ODEV_DAC_H__