466 lines
13 KiB
C
466 lines
13 KiB
C
//*****************************************************************************
|
|
//
|
|
// voles_main.c
|
|
//! @file
|
|
//!
|
|
//! @brief This file provides the main application for the VOLE service.
|
|
//!
|
|
//
|
|
//*****************************************************************************
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Copyright (c) 2020, Ambiq Micro
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are met:
|
|
//
|
|
// 1. Redistributions of source code must retain the above copyright notice,
|
|
// this list of conditions and the following disclaimer.
|
|
//
|
|
// 2. Redistributions in binary form must reproduce the above copyright
|
|
// notice, this list of conditions and the following disclaimer in the
|
|
// documentation and/or other materials provided with the distribution.
|
|
//
|
|
// 3. Neither the name of the copyright holder nor the names of its
|
|
// contributors may be used to endorse or promote products derived from this
|
|
// software without specific prior written permission.
|
|
//
|
|
// Third party software included in this distribution is subject to the
|
|
// additional license terms as defined in the /docs/licenses directory.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
|
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
// POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
// This is part of revision 2.4.2 of the AmbiqSuite Development Package.
|
|
//
|
|
//*****************************************************************************
|
|
#include <string.h>
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include <stdlib.h>
|
|
#include "wsf_types.h"
|
|
#include "wsf_assert.h"
|
|
#include "wsf_trace.h"
|
|
#include "wsf_buf.h" //for WsfBufAlloc and WsfBufFree
|
|
#include "bstream.h"
|
|
#include "att_api.h"
|
|
#include "svc_ch.h"
|
|
#include "svc_amvole.h"
|
|
#include "app_api.h"
|
|
#include "app_hw.h"
|
|
#include "voles_api.h"
|
|
#include "am_util_debug.h"
|
|
#include "crc32.h"
|
|
|
|
#include "am_mcu_apollo.h"
|
|
#include "am_bsp.h"
|
|
#include "am_util.h"
|
|
#include "sbc.h"
|
|
#include "vole_common.h"
|
|
#include "att_defs.h"
|
|
#include "vole_board_config.h"
|
|
#include "voice_data.h"
|
|
|
|
#include "ae_api.h"
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Global variables
|
|
//
|
|
//*****************************************************************************
|
|
eVoleCodecType g_vole_codec_type;
|
|
uint8_t g_ble_data_buffer[ATT_MAX_MTU];
|
|
|
|
extern bool_t g_start_voice_send;
|
|
//*****************************************************************************
|
|
//
|
|
// Macro definitions
|
|
//
|
|
//*****************************************************************************
|
|
|
|
static sbc_t g_SBCInstance;
|
|
int g_opusErr;
|
|
uint32_t g_audioSampleRate = 16000;
|
|
int32_t g_audioChannel = 1;
|
|
|
|
/* Control block */
|
|
static struct
|
|
{
|
|
volesConn_t conn[DM_CONN_MAX]; // connection control block
|
|
bool_t txReady; // TRUE if ready to send notifications
|
|
wsfHandlerId_t appHandlerId;
|
|
VolesCfg_t cfg; // configurable parameters
|
|
voleCb_t core;
|
|
}
|
|
volesCb;
|
|
|
|
extern bool am_app_KWD_AMA_tx_ver_exchange_send(void);
|
|
extern uint16_t am_app_KWD_AMA_stream_send(uint8_t* buf, uint32_t len);
|
|
extern void am_app_led_off(void);
|
|
|
|
static void voles_conn_parameter_req(void)
|
|
{
|
|
hciConnSpec_t connSpec;
|
|
connSpec.connIntervalMin = 6; //(15/1.25);//(30/1.25);
|
|
connSpec.connIntervalMax = 12; //(15/1.25);//(30/1.25);
|
|
connSpec.connLatency = 0; //0;
|
|
connSpec.supTimeout = 400;
|
|
connSpec.minCeLen = 0;
|
|
connSpec.maxCeLen = 0xffff; //fixme
|
|
DmConnUpdate(1, &connSpec);
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Connection Open event
|
|
//
|
|
//*****************************************************************************
|
|
static void
|
|
voles_conn_open(dmEvt_t *pMsg)
|
|
{
|
|
hciLeConnCmplEvt_t *evt = (hciLeConnCmplEvt_t*) pMsg;
|
|
|
|
APP_TRACE_INFO0("connection opened\n");
|
|
APP_TRACE_INFO1("handle = 0x%x\n", evt->handle);
|
|
APP_TRACE_INFO1("role = 0x%x\n", evt->role);
|
|
APP_TRACE_INFO3("addrMSB = %02x%02x%02x%02x%02x%02x\n", evt->peerAddr[0], evt->peerAddr[1], evt->peerAddr[2]);
|
|
APP_TRACE_INFO3("addrLSB = %02x%02x%02x%02x%02x%02x\n", evt->peerAddr[3], evt->peerAddr[4], evt->peerAddr[5]);
|
|
APP_TRACE_INFO1("connInterval = %d x 1.25 ms\n", evt->connInterval);
|
|
APP_TRACE_INFO1("connLatency = %d\n", evt->connLatency);
|
|
APP_TRACE_INFO1("supTimeout = %d ms\n", evt->supTimeout * 10);
|
|
|
|
if ( evt->connInterval > 12 )
|
|
{
|
|
voles_conn_parameter_req();
|
|
}
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//
|
|
// Connection Update event
|
|
//
|
|
//*****************************************************************************
|
|
static void
|
|
voles_conn_update(dmEvt_t *pMsg)
|
|
{
|
|
hciLeConnUpdateCmplEvt_t *evt = (hciLeConnUpdateCmplEvt_t*) pMsg;
|
|
|
|
APP_TRACE_INFO1("connection update status = 0x%x", evt->status);
|
|
APP_TRACE_INFO1("handle = 0x%x", evt->handle);
|
|
APP_TRACE_INFO1("connInterval = 0x%x", evt->connInterval);
|
|
APP_TRACE_INFO1("connLatency = 0x%x", evt->connLatency);
|
|
APP_TRACE_INFO1("supTimeout = 0x%x", evt->supTimeout);
|
|
|
|
|
|
if ( evt->connInterval > (15 / 1.25) )
|
|
{
|
|
// retry
|
|
voles_conn_parameter_req();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
int32_t voles_msbc_encode_voice_data(uint8_t *input, uint8_t *output, uint16_t len)
|
|
{
|
|
int32_t i32CompressedLen = 0;
|
|
|
|
if ((input == NULL) || (output == NULL))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
sbc_encoder_encode(&g_SBCInstance, input, len,
|
|
output, CODEC_MSBC_OUTPUT_SIZE, (int *)&i32CompressedLen);
|
|
|
|
APP_TRACE_INFO2("voles encode, input len:%d, compressedLen:%d", len, i32CompressedLen);
|
|
|
|
return i32CompressedLen;
|
|
}
|
|
|
|
int voles_set_codec_type(eVoleCodecType codec_type)
|
|
{
|
|
APP_TRACE_INFO1("set codec type:%s", ((codec_type == 0) ? "MSBC code" : "OPUS codec"));
|
|
|
|
if (codec_type != VOLE_CODEC_TYPE_INVALID)
|
|
{
|
|
g_vole_codec_type = codec_type;
|
|
return codec_type;
|
|
}
|
|
else
|
|
{
|
|
return VOLE_CODEC_TYPE_INVALID;
|
|
}
|
|
}
|
|
|
|
eVoleCodecType voles_get_codec_type(void)
|
|
{
|
|
return g_vole_codec_type;
|
|
}
|
|
|
|
// get the size for each sending packet
|
|
int voles_ble_buffer_size(void)
|
|
{
|
|
eVoleCodecType codec_type = voles_get_codec_type();
|
|
int buffer_size = 0;
|
|
|
|
switch(codec_type)
|
|
{
|
|
case MSBC_CODEC_IN_USE:
|
|
buffer_size = BLE_MSBC_DATA_BUFFER_SIZE;
|
|
break;
|
|
|
|
case OPUS_CODEC_IN_USE:
|
|
buffer_size = BLE_OPUS_DATA_BUFFER_SIZE;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return buffer_size;
|
|
}
|
|
|
|
void voles_transmit_voice_data(void)
|
|
{
|
|
volePacket_t *txPkt = &volesCb.core.txPkt;
|
|
uint32_t offset = txPkt->offset;
|
|
int remain_data_len = 0;
|
|
int enc_data_len = 0;
|
|
uint8_t output_data[100] = {0};
|
|
int output_len = 0;
|
|
static int index = 0;
|
|
eVoleCodecType codec_type = voles_get_codec_type();
|
|
|
|
txPkt->len = sizeof(voice_data);
|
|
remain_data_len = txPkt->len - offset;
|
|
|
|
if (codec_type == MSBC_CODEC_IN_USE)
|
|
{
|
|
enc_data_len = (remain_data_len>CODEC_MSBC_INPUT_SIZE)?CODEC_MSBC_INPUT_SIZE:remain_data_len;
|
|
}
|
|
else if (codec_type == OPUS_CODEC_IN_USE)
|
|
{
|
|
enc_data_len = (remain_data_len>CODEC_OPUS_INPUT_SIZE)?CODEC_OPUS_INPUT_SIZE:remain_data_len;
|
|
}
|
|
|
|
APP_TRACE_INFO3("send %s encode data, total len:%d, offset:%d", (codec_type == MSBC_CODEC_IN_USE) ? "mSBC" : "Opus",
|
|
txPkt->len, offset);
|
|
|
|
if (offset >= txPkt->len)
|
|
{
|
|
am_app_led_off();
|
|
g_start_voice_send = FALSE;
|
|
memset(output_data, 0x0, sizeof(output_data));
|
|
txPkt->offset = 0;
|
|
}
|
|
else
|
|
{
|
|
if (codec_type == MSBC_CODEC_IN_USE)
|
|
{
|
|
output_len = voles_msbc_encode_voice_data(&voice_data[offset + AUD_HEADER_LEN], output_data, enc_data_len);
|
|
txPkt->offset += enc_data_len;
|
|
}
|
|
else if (codec_type == OPUS_CODEC_IN_USE)
|
|
{
|
|
output_len = audio_enc_encode_frame((short *)&voice_data[offset + AUD_HEADER_LEN], enc_data_len, output_data);
|
|
APP_TRACE_INFO1("opus encode, output_len:%d", output_len);
|
|
if (output_len == (CODEC_OPUS_OUTPUT_SIZE))
|
|
{
|
|
txPkt->offset += (2*CODEC_OPUS_INPUT_SIZE);
|
|
//APP_TRACE_INFO1("opus_encode: ret:%d", output_len);
|
|
}
|
|
else
|
|
{
|
|
txPkt->offset += enc_data_len;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( output_len > 0 )
|
|
{
|
|
memcpy(&g_ble_data_buffer[index], output_data, output_len);
|
|
index += output_len;
|
|
}
|
|
|
|
if ( index >= voles_ble_buffer_size() || output_len <= 0 )
|
|
{
|
|
if (index >0)
|
|
{
|
|
am_app_KWD_AMA_stream_send(g_ble_data_buffer, index);
|
|
index = 0;
|
|
memset(g_ble_data_buffer, 0x0, sizeof(g_ble_data_buffer));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
uint8_t output_size = ((voles_get_codec_type() == MSBC_CODEC_IN_USE) ? CODEC_MSBC_OUTPUT_SIZE : (CODEC_OPUS_OUTPUT_SIZE));
|
|
|
|
if (output_len == output_size)
|
|
{
|
|
voles_transmit_voice_data();
|
|
}
|
|
else if (output_len>0 && output_len<output_size)
|
|
{
|
|
am_app_KWD_AMA_stream_send(output_data, output_len);
|
|
index = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//extern opus_encoder_t* octopus_encoder_create(int option);
|
|
/*************************************************************************************************/
|
|
/*!
|
|
* \fn volesHandleValueCnf
|
|
*
|
|
* \brief Handle a received ATT handle value confirm.
|
|
*
|
|
* \param pMsg Event message.
|
|
*
|
|
* \return None.
|
|
*/
|
|
/*************************************************************************************************/
|
|
static void
|
|
volesHandleValueCnf(attEvt_t *pMsg)
|
|
{
|
|
if (pMsg->hdr.status == ATT_SUCCESS)
|
|
{
|
|
if (g_start_voice_send)
|
|
{
|
|
voles_transmit_voice_data();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
APP_TRACE_WARN2("cnf status = %d, hdl = 0x%x\n", pMsg->hdr.status, pMsg->handle);
|
|
}
|
|
}
|
|
|
|
void voles_opus_encoder_init(void)
|
|
{
|
|
//
|
|
// Opus codec init
|
|
//
|
|
audio_enc_init(0);
|
|
|
|
APP_TRACE_INFO0("Opus encoder initialization is finished!\r\n\n");
|
|
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//6
|
|
//! @brief initialize vole service
|
|
//!
|
|
//! @param handlerId - connection handle
|
|
//! @param pCfg - configuration parameters
|
|
//!
|
|
//! @return None
|
|
//
|
|
//*****************************************************************************
|
|
void voles_init(wsfHandlerId_t handlerId, eVoleCodecType codec_type)
|
|
{
|
|
memset(&volesCb, 0, sizeof(volesCb));
|
|
volesCb.appHandlerId = handlerId;
|
|
|
|
volesCb.core.txPkt.data = voice_data;
|
|
|
|
if (codec_type == MSBC_CODEC_IN_USE)
|
|
{
|
|
sbc_encode_init(&g_SBCInstance, 1); //0: SBC
|
|
}
|
|
else if (codec_type == OPUS_CODEC_IN_USE)
|
|
{
|
|
voles_opus_encoder_init();
|
|
}
|
|
}
|
|
|
|
static void
|
|
voles_conn_close(dmEvt_t *pMsg)
|
|
{
|
|
hciDisconnectCmplEvt_t *evt = (hciDisconnectCmplEvt_t*) pMsg;
|
|
dmConnId_t connId = evt->hdr.param;
|
|
/* clear connection */
|
|
volesCb.conn[connId - 1].connId = DM_CONN_ID_NONE;
|
|
volesCb.conn[connId - 1].voleToSend = FALSE;
|
|
|
|
WsfTimerStop(&volesCb.core.timeoutTimer);
|
|
volesCb.core.txState = VOLE_STATE_INIT;
|
|
volesCb.core.rxState = VOLE_STATE_RX_IDLE;
|
|
volesCb.core.lastRxPktSn = 0;
|
|
volesCb.core.txPktSn = 0;
|
|
VoleResetPkt(&volesCb.core.rxPkt);
|
|
VoleResetPkt(&volesCb.core.txPkt);
|
|
VoleResetPkt(&volesCb.core.ackPkt);
|
|
}
|
|
|
|
uint8_t
|
|
voles_write_cback(dmConnId_t connId, uint16_t handle, uint8_t operation,
|
|
uint16_t offset, uint16_t len, uint8_t *pValue, attsAttr_t *pAttr)
|
|
{
|
|
APP_TRACE_INFO3("write cb, len:%d, value %x %x", len, pValue[0], pValue[1]);
|
|
|
|
return ATT_SUCCESS;
|
|
}
|
|
|
|
void
|
|
voles_start(dmConnId_t connId, uint8_t timerEvt, uint8_t voleCccIdx)
|
|
{
|
|
//
|
|
// set conn id
|
|
//
|
|
volesCb.conn[connId - 1].connId = connId;
|
|
volesCb.conn[connId - 1].voleToSend = TRUE;
|
|
|
|
volesCb.core.timeoutTimer.msg.event = timerEvt;
|
|
volesCb.core.txState = VOLE_STATE_TX_IDLE;
|
|
volesCb.txReady = true;
|
|
|
|
volesCb.core.attMtuSize = AttGetMtu(connId);
|
|
APP_TRACE_INFO1("MTU size = %d bytes", volesCb.core.attMtuSize);
|
|
}
|
|
|
|
void
|
|
voles_stop(dmConnId_t connId)
|
|
{
|
|
//
|
|
// clear connection
|
|
//
|
|
volesCb.conn[connId - 1].connId = DM_CONN_ID_NONE;
|
|
volesCb.conn[connId - 1].voleToSend = FALSE;
|
|
|
|
volesCb.core.txState = VOLE_STATE_INIT;
|
|
volesCb.txReady = false;
|
|
}
|
|
|
|
|
|
void voles_proc_msg(wsfMsgHdr_t *pMsg)
|
|
{
|
|
if (pMsg->event == DM_CONN_OPEN_IND)
|
|
{
|
|
voles_conn_open((dmEvt_t *) pMsg);
|
|
}
|
|
else if (pMsg->event == DM_CONN_CLOSE_IND)
|
|
{
|
|
voles_conn_close((dmEvt_t *) pMsg);
|
|
}
|
|
else if (pMsg->event == DM_CONN_UPDATE_IND)
|
|
{
|
|
voles_conn_update((dmEvt_t *) pMsg);
|
|
}
|
|
else if (pMsg->event == ATTS_HANDLE_VALUE_CNF)
|
|
{
|
|
volesHandleValueCnf((attEvt_t *) pMsg);
|
|
}
|
|
}
|