1826 lines
51 KiB
C
1826 lines
51 KiB
C
#include "intercom.h"
|
|
#include "osal/string.h"
|
|
#include "custom_mem/custom_mem.h"
|
|
#include "stream_frame.h"
|
|
#include "osal/task.h"
|
|
#include "osal/work.h"
|
|
#include "lwip/api.h"
|
|
#include "lwip/sockets.h"
|
|
#include "lib/net/eloop/eloop.h"
|
|
#include "netif/ethernetif.h"
|
|
#include "syscfg.h"
|
|
#include "dev/audio/components/vad/auvad.h"
|
|
#include "hal/gpio.h"
|
|
#include "adpcm_code.h"
|
|
#include "keyWork.h"
|
|
#include "keyScan.h"
|
|
#include "hal/timer_device.h"
|
|
|
|
#define PIN_SPK_MUTE PA_7
|
|
|
|
#define MUTE_SPEAKER 0
|
|
#define SERVER_RECORD 0
|
|
#define SERVER_RECORD_NODE_NUM 70
|
|
|
|
#define DUPLEX_TYPE HALF_DUPLEX
|
|
|
|
#define PLC_PROCESS 1
|
|
#define CHANGE_PLAY_SPEED 1
|
|
|
|
#define SAMPLERATE 8000
|
|
|
|
#define INTERCOM_SERVER 1
|
|
#define INTERCOM_CLIENT 0
|
|
#define INTERCOM_PORT 5008
|
|
|
|
#define REDUNDANCY_NUM 2
|
|
#define CODE_BPS 4
|
|
#define DECODED_DATA_LEN 160
|
|
#define ENCODED_BUF_NUM 15
|
|
#define SUBLIST_NUM 60
|
|
#define ENCODED_DATA_BYTE ((DECODED_DATA_LEN/8*CODE_BPS+4)*(1+REDUNDANCY_NUM)+4)
|
|
#define RESERVE 14
|
|
#define ENCODED_BUF_BYTE (ENCODED_DATA_BYTE+RESERVE)
|
|
#define ENCODED_RINGBUF_LEN (ENCODED_BUF_BYTE*ENCODED_BUF_NUM)
|
|
#define SOFTBUF_LEN (ENCODED_DATA_BYTE*SUBLIST_NUM)
|
|
|
|
#define CODE_MODE 20
|
|
#define NODE_DATA_LEN ENCODED_DATA_BYTE
|
|
|
|
#define NUM_OF_FRAME 1
|
|
|
|
#define LOSE_STATISTICAL 0
|
|
|
|
TYPE_INTERCOM_STRUCT *intercom = NULL;
|
|
audio_node audio_node_src[SOFTBUF_LEN/NODE_DATA_LEN] __attribute__ ((aligned(4),section(".psram.src")));
|
|
sublist sublist_src[SUBLIST_NUM] __attribute__ ((aligned(4),section(".psram.src")));
|
|
ringbuf_manage ringbuf_mana[ENCODED_BUF_NUM] __attribute__ ((aligned(4),section(".psram.src")));
|
|
struct list_head sublist_head;
|
|
struct list_head ringbuf_manage_src;
|
|
struct list_head ringbuf_manage_use;
|
|
struct list_head *manage_cur_push;
|
|
struct list_head *manage_cur_pop;
|
|
|
|
|
|
TYPE_RINGBUF *encoded_ringbuf = NULL;
|
|
char *sort_buf = NULL;
|
|
uint32 del_node_num = 0;
|
|
uint32 g_intercom_start = 0;
|
|
|
|
struct os_mutex send_mutex;
|
|
struct os_mutex list_mutex;
|
|
static struct os_semaphore encode_sem;
|
|
static struct os_semaphore decode_sem;
|
|
struct os_task intercom_server_handle_task;
|
|
struct os_task intercom_client_handle_task;
|
|
|
|
volatile uint16 play_sort = 0;
|
|
uint16 g_current_sort = 1;
|
|
uint32_t g_numofcached = 0;
|
|
uint8 g_send_sequence = 0;
|
|
uint32 g_send_sort = 0;
|
|
uint32 g_s_identify_num = 0;
|
|
int now_dac_filter_type = 0;
|
|
|
|
static struct data_structure *current_adc_data = NULL;
|
|
static struct data_structure *current_dac_data = NULL;
|
|
|
|
#if DEALY_ADJUSTMENT
|
|
extern uint8 txmode;
|
|
extern uint8_t send_mode;
|
|
#endif
|
|
|
|
uint32 playofwait = 30;
|
|
volatile uint8 send_start_flag = 0; //发送端缓存到一定数量再开启发送;
|
|
uint8 play_start_flag = 2; //接收到缓存到一定数量再开始解码和播放；
|
|
uint8 intercom_encode_flag = 0x03; //编码控制开关；bit0:手动控制，bit1：软件控制；
|
|
|
|
#if INTERCOM_SERVER
|
|
uint8 g_transfer_mode = RECV_MODE;
|
|
#elif INTERCOM_CLIENT
|
|
uint8 g_transfer_mode = SEND_MODE;
|
|
#endif
|
|
|
|
uint8 g_switch_recv_success = 1;
|
|
uint8 g_code_sema_init = 0;
|
|
|
|
AdpcmEncoder *Enc_Inst = NULL;
|
|
AdpcmDecoder *Dec_Inst = NULL;
|
|
|
|
extern struct sonic_process_priv *sonic_priv;
|
|
|
|
void intercom_server_handle(void *d);
|
|
void intercom_client_handle(void *d);
|
|
void intercom_recv(void *d);
|
|
void intercom_encoded_handle(void *d);
|
|
void intercom_decoded_handle(void *d);
|
|
void retransfer_check(void *d);
|
|
|
|
int intercom_server_init(void);
|
|
int intercom_client_init(void);
|
|
void intercom_send(uint8 num);
|
|
void lose_packet_check(void);
|
|
|
|
static struct os_timer ctl_timer;
|
|
void decode_sem_up(uint32 *args);
|
|
|
|
void intercom_init(void)
|
|
{
|
|
#if INTERCOM_SERVER
|
|
intercom_server_init();
|
|
#elif INTERCOM_CLIENT
|
|
intercom_client_init();
|
|
#endif
|
|
}
|
|
|
|
static void intercom_struct_init(void)
|
|
{
|
|
for(uint8 i=0; i<4; i++)
|
|
{
|
|
*((&intercom->udp_sfd)+i) = -1;
|
|
}
|
|
}
|
|
|
|
static void srcList_init(void)
|
|
{
|
|
for(uint32 i=0; i<(SOFTBUF_LEN/NODE_DATA_LEN); i++)
|
|
{
|
|
audio_node_src[i].buf_addr = (uint8*)(sort_buf+(NODE_DATA_LEN*i));
|
|
list_add_tail((struct list_head *)&audio_node_src[i].list,(struct list_head *)&intercom->srcList_head);
|
|
}
|
|
}
|
|
|
|
static void sublist_init(void)
|
|
{
|
|
for(uint32 i=0; i<SUBLIST_NUM; i++)
|
|
{
|
|
sublist_src[i].node_head.next = &(sublist_src[i].node_head);
|
|
sublist_src[i].node_head.prev = &(sublist_src[i].node_head);
|
|
list_add_tail((struct list_head *)&sublist_src[i].list,(struct list_head *)&sublist_head);
|
|
}
|
|
}
|
|
|
|
static void ringbuf_manage_init(void)
|
|
{
|
|
for(uint32 i=0; i<ENCODED_BUF_NUM; i++)
|
|
{
|
|
list_add_tail((struct list_head *)&ringbuf_mana[i].list,(struct list_head *)&ringbuf_manage_src);
|
|
}
|
|
manage_cur_pop = &(ringbuf_manage_use);
|
|
manage_cur_pop = &(ringbuf_manage_use);
|
|
}
|
|
|
|
int intercom_room_init(void)
|
|
{
|
|
encoded_ringbuf = (TYPE_RINGBUF*)intercom_malloc(sizeof(TYPE_RINGBUF));
|
|
if(ringbuf_Init(encoded_ringbuf,(ENCODED_RINGBUF_LEN)) == -1)
|
|
return -1;
|
|
encoded_ringbuf->data = (uint8*)intercom_zalloc( (encoded_ringbuf->size)*sizeof(uint8) );
|
|
if(!(encoded_ringbuf->data)) {
|
|
os_printf("malloc encode_ringbuf->data err\n");
|
|
return -1;
|
|
}
|
|
|
|
sort_buf = (char*)intercom_zalloc(SOFTBUF_LEN* sizeof(uint8));
|
|
if(!sort_buf) {
|
|
os_printf("malloc sort_buf err\n");
|
|
return -1;
|
|
}
|
|
|
|
INIT_LIST_HEAD((struct list_head *)&intercom->srcList_head);
|
|
INIT_LIST_HEAD((struct list_head *)&intercom->checkList_head);
|
|
INIT_LIST_HEAD((struct list_head *)&intercom->useList_head);
|
|
INIT_LIST_HEAD((struct list_head *)&sublist_head);
|
|
INIT_LIST_HEAD((struct list_head *)&ringbuf_manage_src);
|
|
INIT_LIST_HEAD((struct list_head *)&ringbuf_manage_use);
|
|
srcList_init();
|
|
sublist_init();
|
|
ringbuf_manage_init();
|
|
os_printf("intercom_room_init succes\n");
|
|
return 0;
|
|
}
|
|
|
|
static void close_socket(void)
|
|
{
|
|
for(uint8 i=0; i<4; i++) {
|
|
if(*((&intercom->udp_sfd)+i) != -1)
|
|
close(*((&intercom->udp_sfd)+i));
|
|
}
|
|
}
|
|
|
|
static void free_room(void)
|
|
{
|
|
if(encoded_ringbuf->data) {
|
|
intercom_free(encoded_ringbuf->data);
|
|
encoded_ringbuf->data = NULL;
|
|
}
|
|
ringbuf_del(encoded_ringbuf);
|
|
|
|
if(sort_buf) {
|
|
intercom_free(sort_buf);
|
|
sort_buf = NULL;
|
|
}
|
|
}
|
|
uint32_t intercom_push_key(struct key_callback_list_s *callback_list,uint32_t keyvalue,uint32_t extern_value)
|
|
{
|
|
if( (keyvalue>>8) != AD_PRESS)
|
|
return 0;
|
|
uint32 key_val = (keyvalue & 0xff);
|
|
if((key_val == KEY_EVENT_DOWN) || (key_val == KEY_EVENT_LDOWN) || (key_val == KEY_EVENT_REPEAT)) {
|
|
g_transfer_mode = SEND_MODE;
|
|
}
|
|
else if((key_val == KEY_EVENT_SUP) || (key_val == KEY_EVENT_LUP)) {
|
|
g_transfer_mode = RECV_MODE;
|
|
}
|
|
return 0;
|
|
}
|
|
int intercom_server_init(void)
|
|
{
|
|
int time_out = CODE_MODE*2;
|
|
intercom = (TYPE_INTERCOM_STRUCT*)custom_malloc(sizeof(TYPE_INTERCOM_STRUCT));
|
|
if(!intercom)
|
|
goto intercom_server_init_err;
|
|
intercom_struct_init();
|
|
|
|
intercom->udp_sfd = socket(AF_INET,SOCK_DGRAM,0);
|
|
intercom->ack_sfd = socket(AF_INET,SOCK_DGRAM,0);
|
|
|
|
#if DUPLEX_TYPE == HALF_DUPLEX
|
|
add_keycallback(intercom_push_key,NULL);
|
|
#endif
|
|
|
|
if((intercom->udp_sfd==-1) || (intercom->ack_sfd==-1)) {
|
|
os_printf("\nerr:%s %d",__FUNCTION__,__LINE__);
|
|
goto intercom_server_init_err;
|
|
}
|
|
|
|
if(setsockopt(intercom->udp_sfd,SOL_SOCKET,SO_RCVTIMEO,(char *)&time_out,sizeof(int)) == -1) {
|
|
os_printf("\nerr:%s %d",__FUNCTION__,__LINE__);
|
|
goto intercom_server_init_err;
|
|
}
|
|
|
|
OS_TASK_INIT("intercom_server_handle", &intercom_server_handle_task, intercom_server_handle, NULL, OS_TASK_PRIORITY_NORMAL, 1024);
|
|
return 0;
|
|
|
|
intercom_server_init_err:
|
|
close_socket();
|
|
if(intercom)
|
|
custom_free(intercom);
|
|
intercom = NULL;
|
|
return -1;
|
|
}
|
|
|
|
int intercom_client_init(void)
|
|
{
|
|
intercom = (TYPE_INTERCOM_STRUCT*)custom_malloc(sizeof(TYPE_INTERCOM_STRUCT));
|
|
if(!intercom)
|
|
goto intercom_client_init_err;
|
|
intercom_struct_init();
|
|
|
|
intercom->udp_cfd = socket(AF_INET,SOCK_DGRAM,0);
|
|
intercom->ack_cfd = socket(AF_INET,SOCK_DGRAM,0);
|
|
|
|
if((intercom->udp_cfd==-1) || (intercom->ack_cfd==-1)) {
|
|
os_printf("\nerr:%s %d",__FUNCTION__,__LINE__);
|
|
goto intercom_client_init_err;
|
|
}
|
|
|
|
// #if DUPLEX_TYPE == FULL_DUPLEX
|
|
int time_out = CODE_MODE*2;
|
|
if(setsockopt(intercom->udp_cfd,SOL_SOCKET,SO_RCVTIMEO,(char *)&time_out,sizeof(int)) == -1) {
|
|
os_printf("\nerr:%s %d",__FUNCTION__,__LINE__);
|
|
goto intercom_client_init_err;
|
|
}
|
|
// #endif
|
|
|
|
OS_TASK_INIT("intercom_client_handle", &intercom_client_handle_task, intercom_client_handle, NULL, OS_TASK_PRIORITY_NORMAL, 1024);
|
|
return 0;
|
|
|
|
intercom_client_init_err:
|
|
close_socket();
|
|
if(intercom)
|
|
custom_free(intercom);
|
|
intercom = NULL;
|
|
return -1;
|
|
}
|
|
|
|
static void close_intercom_stream(void)
|
|
{
|
|
for(uint8 i=0; i<2; i++)
|
|
{
|
|
if(*((&intercom->recv_s)+i))
|
|
close_stream((stream*)*((&intercom->recv_s)+i));
|
|
}
|
|
}
|
|
|
|
static int opcode_func_r(stream *s,void *priv,int opcode)
|
|
{
|
|
int res = 0;
|
|
switch(opcode)
|
|
{
|
|
case STREAM_OPEN_ENTER:
|
|
break;
|
|
case STREAM_OPEN_EXIT:
|
|
{
|
|
enable_stream(s,1);
|
|
}
|
|
break;
|
|
case STREAM_OPEN_FAIL:
|
|
break;
|
|
default:
|
|
//默认都返回成功
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
static uint32_t get_sound_data_len(void *data)
|
|
{
|
|
struct data_structure *d = (struct data_structure *)data;
|
|
return (uint32_t)d->priv;
|
|
}
|
|
static uint32_t set_sound_data_len(void *data,uint32_t len)
|
|
{
|
|
struct data_structure *d = (struct data_structure *)data;
|
|
d->priv = (void*)len;
|
|
return len;
|
|
}
|
|
static stream_ops_func stream_sound_ops =
|
|
{
|
|
.get_data_len = get_sound_data_len,
|
|
.set_data_len = set_sound_data_len,
|
|
};
|
|
static int opcode_func_s(stream *s,void *priv,int opcode)
|
|
{
|
|
static uint8 *audio_buf = NULL;
|
|
int res = 0;
|
|
switch(opcode)
|
|
{
|
|
case STREAM_OPEN_ENTER:
|
|
break;
|
|
case STREAM_OPEN_EXIT:
|
|
{
|
|
audio_buf = os_malloc(8 * ((DECODED_DATA_LEN+10)*2));
|
|
if(audio_buf)
|
|
{
|
|
stream_data_dis_mem_custom(s);
|
|
}
|
|
streamSrc_bind_streamDest(s,R_SONIC_PROCESS);
|
|
#if SERVER_RECORD && INTERCOM_SERVER
|
|
streamSrc_bind_streamDest(s,R_INTERMEDIATE_DATA);
|
|
#endif
|
|
}
|
|
break;
|
|
case STREAM_OPEN_FAIL:
|
|
break;
|
|
|
|
case STREAM_FILTER_DATA:
|
|
break;
|
|
|
|
case STREAM_DATA_DIS:
|
|
{
|
|
struct data_structure *data = (struct data_structure *)priv;
|
|
int data_num = (int)data->priv;
|
|
data->ops = &stream_sound_ops;
|
|
data->data = audio_buf + data_num*((DECODED_DATA_LEN+10)*2);
|
|
}
|
|
break;
|
|
|
|
case STREAM_DATA_FREE:
|
|
break;
|
|
case STREAM_DATA_DESTORY:
|
|
{
|
|
if(audio_buf)
|
|
os_free(audio_buf);
|
|
}
|
|
break;
|
|
//数据发送完成,可以选择唤醒对应的任务
|
|
case STREAM_RECV_DATA_FINISH:
|
|
break;
|
|
|
|
default:
|
|
//默认都返回成功
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
#if SERVER_RECORD && INTERCOM_SERVER
|
|
static int opcode_func_record_s(stream *s,void *priv,int opcode)
|
|
{
|
|
static uint8 *audio_buf = NULL;
|
|
int res = 0;
|
|
switch(opcode)
|
|
{
|
|
case STREAM_OPEN_ENTER:
|
|
break;
|
|
case STREAM_OPEN_EXIT:
|
|
{
|
|
audio_buf = os_malloc_psram( SERVER_RECORD_NODE_NUM* ((DECODED_DATA_LEN+10)*2));
|
|
if(audio_buf)
|
|
{
|
|
stream_data_dis_mem_custom(s);
|
|
}
|
|
// streamSrc_bind_streamDest(s,R_SPEAKER);
|
|
streamSrc_bind_streamDest(s,R_AT_AVI_AUDIO);
|
|
streamSrc_bind_streamDest(s,R_AT_SAVE_AUDIO);
|
|
}
|
|
break;
|
|
case STREAM_OPEN_FAIL:
|
|
break;
|
|
|
|
case STREAM_FILTER_DATA:
|
|
break;
|
|
|
|
case STREAM_DATA_DIS:
|
|
{
|
|
struct data_structure *data = (struct data_structure *)priv;
|
|
int data_num = (int)data->priv;
|
|
data->ops = &stream_sound_ops;
|
|
data->data = audio_buf + data_num*((DECODED_DATA_LEN+10)*2);
|
|
}
|
|
break;
|
|
|
|
case STREAM_DATA_FREE:
|
|
{
|
|
}
|
|
break;
|
|
//数据发送完成,可以选择唤醒对应的任务
|
|
case STREAM_RECV_DATA_FINISH:
|
|
break;
|
|
|
|
default:
|
|
//默认都返回成功
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
void intercom_record_thread(void *d)
|
|
{
|
|
int flen = 0;
|
|
int16 *send_record_stream_buf = NULL;
|
|
struct data_structure *get_f_inter_r = NULL;
|
|
struct data_structure *get_f_inter_s = NULL;
|
|
stream* s_inter_s = NULL;
|
|
stream* r_inter_s = NULL;
|
|
uint8_t *buf = NULL;
|
|
int ret ;
|
|
uint32_t count = 0;
|
|
uint32_t delay_count = 0;
|
|
|
|
static uint32_t last_timestemp = 0;
|
|
static uint32_t cur_timestemp = 0;
|
|
|
|
s_inter_s = open_stream_available(S_INTERMEDIATE_DATA,SERVER_RECORD_NODE_NUM,0,opcode_func_record_s,NULL);
|
|
r_inter_s = open_stream_available(R_INTERMEDIATE_DATA,0,SERVER_RECORD_NODE_NUM,opcode_func_r,NULL);
|
|
if(!s_inter_s || !r_inter_s)
|
|
{
|
|
os_printf("open stream err\n");
|
|
goto intercom_record_end;
|
|
}
|
|
|
|
while(1)
|
|
{
|
|
get_f_inter_r = recv_real_data(r_inter_s);
|
|
|
|
if(get_f_inter_r)
|
|
{
|
|
get_f_inter_s = get_src_data_f(s_inter_s);
|
|
if(get_f_inter_s)
|
|
{
|
|
count++;
|
|
delay_count = 0;
|
|
send_record_stream_buf = get_stream_real_data(get_f_inter_s);
|
|
|
|
buf = (uint8_t*)get_stream_real_data(get_f_inter_r);
|
|
|
|
|
|
flen = get_stream_real_data_len(get_f_inter_r);
|
|
|
|
os_memcpy(send_record_stream_buf,buf,flen);
|
|
|
|
set_stream_real_data_len(get_f_inter_s,flen);
|
|
set_stream_data_time(get_f_inter_s,get_f_inter_r->timestamp);
|
|
|
|
cur_timestemp = get_f_inter_r->timestamp;
|
|
|
|
if((cur_timestemp > last_timestemp) && (last_timestemp != 0))
|
|
{
|
|
// os_printf("audio sleep:%d ms CUR:%d LAST:%d\n",(cur_timestemp-last_timestemp),cur_timestemp,last_timestemp);
|
|
}
|
|
|
|
ret = send_data_to_stream(get_f_inter_s);
|
|
last_timestemp = cur_timestemp;
|
|
free_data(get_f_inter_r);
|
|
get_f_inter_r = NULL;
|
|
|
|
}else
|
|
{
|
|
free_data(get_f_inter_r);
|
|
os_sleep_ms(1);
|
|
os_printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); //节点数量不足，不能保证肯定能获取到节点
|
|
}
|
|
}else{
|
|
delay_count++;
|
|
os_sleep_ms(1);
|
|
// printf("M");
|
|
if(delay_count == 90){
|
|
//printf("!");
|
|
//os_printf("================audio reset diff time==============\n");
|
|
delay_count = 0;
|
|
count = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
intercom_record_end:
|
|
|
|
if(get_f_inter_s)
|
|
{
|
|
force_del_data(get_f_inter_s);
|
|
}
|
|
|
|
if(get_f_inter_r)
|
|
{
|
|
free_data(get_f_inter_r);
|
|
}
|
|
|
|
if(r_inter_s)
|
|
{
|
|
close_stream(r_inter_s);
|
|
}
|
|
|
|
if(s_inter_s)
|
|
{
|
|
close_stream(s_inter_s);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void intercom_server_handle(void *d)
|
|
{
|
|
socklen_t addrlen = sizeof(struct sockaddr_in);
|
|
uint32_t ipaddr;
|
|
int err = -1;
|
|
|
|
if(sys_cfgs.wifi_mode == WIFI_MODE_STA) {
|
|
do{
|
|
ipaddr = lwip_netif_get_ip2("w0").addr;
|
|
os_sleep_ms(100);
|
|
}while((ipaddr&0xff000000) == 0x1000000);
|
|
}
|
|
|
|
for(char i=0; i<2; i++)
|
|
{
|
|
(*((&intercom->udp_s_addr)+i)).sin_family = AF_INET;
|
|
(*((&intercom->udp_s_addr)+i)).sin_port = htons(INTERCOM_PORT + i);
|
|
(*((&intercom->udp_s_addr)+i)).sin_addr.s_addr = 0;
|
|
|
|
err = bind(*((&intercom->udp_sfd)+i), (struct sockaddr *)((&intercom->udp_s_addr)+i), addrlen);
|
|
if(err == -1) {
|
|
os_printf("\nerr:%s %d %d",__FUNCTION__,__LINE__,i);
|
|
goto intercom_server_handle;
|
|
}
|
|
}
|
|
|
|
for(char i=0; i<2; i++)
|
|
{
|
|
(*((&intercom->udp_c_addr)+i)).sin_family = AF_INET;
|
|
(*((&intercom->udp_c_addr)+i)).sin_port = htons(INTERCOM_PORT + i);
|
|
(*((&intercom->udp_c_addr)+i)).sin_addr.s_addr = inet_addr("192.168.1.100");
|
|
}
|
|
|
|
err = intercom_room_init();
|
|
if(err == -1)
|
|
{
|
|
os_printf("\nerr:%s %d",__FUNCTION__,__LINE__);
|
|
goto intercom_server_handle;
|
|
}
|
|
|
|
intercom->recv_s = open_stream_available(R_INTERCOM_AUDIO, 0, 8, opcode_func_r, NULL);
|
|
intercom->send_s = open_stream_available(S_INTERCOM_AUDIO, 8, 0, opcode_func_s, NULL);
|
|
|
|
if( (!intercom->recv_s) || (!intercom->send_s) )
|
|
{
|
|
os_printf("\nopen stream R_INTERCOM_AUDIO err");
|
|
goto intercom_server_handle;
|
|
}
|
|
|
|
Enc_Inst = adpcm_encoder_create(SAMPLERATE,0,0,DECODED_DATA_LEN,REDUNDANCY_NUM);
|
|
Dec_Inst = adpcm_decoder_create(DECODED_DATA_LEN,REDUNDANCY_NUM);
|
|
|
|
os_mutex_init(&send_mutex);
|
|
os_mutex_init(&list_mutex);
|
|
os_sema_init(&encode_sem, 0);
|
|
os_sema_init(&decode_sem, 0);
|
|
g_code_sema_init = 1;
|
|
|
|
#if MUTE_SPEAKER == 1
|
|
gpio_set_mode(PIN_SPK_MUTE, GPIO_PULL_NONE, GPIO_PULL_LEVEL_NONE);
|
|
gpio_set_dir(PIN_SPK_MUTE, GPIO_DIR_OUTPUT);
|
|
#endif
|
|
|
|
OS_TASK_INIT("intercom_encoded_handle", &intercom->encoded_task, intercom_encoded_handle, &encode_sem, OS_TASK_PRIORITY_NORMAL-3, 4096);
|
|
OS_TASK_INIT("intercom_decoded_handle", &intercom->decoded_task, intercom_decoded_handle, &decode_sem, OS_TASK_PRIORITY_NORMAL-3, 2048);
|
|
OS_TASK_INIT("intercom_recv", &intercom->recv_task, intercom_recv, NULL, OS_TASK_PRIORITY_NORMAL+1, 1024);
|
|
OS_TASK_INIT("retransfer_check", &intercom->retransfer_task, retransfer_check, NULL, OS_TASK_PRIORITY_NORMAL-1, 1024);
|
|
#if SERVER_RECORD && INTERCOM_SERVER
|
|
OS_TASK_INIT("intercom_record_thread", &intercom->record_task, intercom_record_thread, NULL, OS_TASK_PRIORITY_NORMAL, 1024);
|
|
#endif
|
|
|
|
os_timer_init(&ctl_timer, (os_timer_func_t)decode_sem_up, OS_TIMER_MODE_PERIODIC, &ctl_timer);
|
|
os_timer_start(&ctl_timer, CODE_MODE);
|
|
return;
|
|
|
|
intercom_server_handle:
|
|
close_socket();
|
|
close_intercom_stream();
|
|
free_room();
|
|
if(intercom) {
|
|
custom_free(intercom);
|
|
intercom = NULL;
|
|
}
|
|
return;
|
|
}
|
|
|
|
void intercom_client_handle(void *d)
|
|
{
|
|
socklen_t addrlen = sizeof(struct sockaddr_in);
|
|
int err = -1;
|
|
uint32_t ipaddr;
|
|
|
|
if(sys_cfgs.wifi_mode == WIFI_MODE_STA) {
|
|
do{
|
|
ipaddr = lwip_netif_get_ip2("w0").addr;
|
|
os_sleep_ms(100);
|
|
}while((ipaddr&0xff000000) == 0x1000000);
|
|
}
|
|
|
|
for(char i=0; i<2; i++)
|
|
{
|
|
(*((&intercom->udp_c_addr)+i)).sin_family = AF_INET;
|
|
(*((&intercom->udp_c_addr)+i)).sin_port = htons(INTERCOM_PORT + i);
|
|
(*((&intercom->udp_c_addr)+i)).sin_addr.s_addr = 0;
|
|
|
|
err = bind(*((&intercom->udp_cfd)+i), (struct sockaddr *)(&(intercom->udp_c_addr)+i), addrlen);
|
|
if(err == -1) {
|
|
os_printf("\nerr:%s %d",__FUNCTION__,__LINE__);
|
|
goto intercom_client_handle;
|
|
}
|
|
}
|
|
|
|
for(char i=0; i<2; i++)
|
|
{
|
|
(*((&intercom->udp_s_addr)+i)).sin_family = AF_INET;
|
|
(*((&intercom->udp_s_addr)+i)).sin_port = htons(INTERCOM_PORT + i);
|
|
(*((&intercom->udp_s_addr)+i)).sin_addr.s_addr = inet_addr("192.168.1.1");
|
|
}
|
|
|
|
err = intercom_room_init();
|
|
if(err == -1)
|
|
{
|
|
os_printf("\nerr:%s %d",__FUNCTION__,__LINE__);
|
|
goto intercom_client_handle;
|
|
}
|
|
|
|
intercom->recv_s = open_stream_available(R_INTERCOM_AUDIO, 0, 8, opcode_func_r, NULL);
|
|
intercom->send_s = open_stream_available(S_INTERCOM_AUDIO, 8, 0, opcode_func_s, NULL);
|
|
if( (!intercom->recv_s) || (!intercom->send_s) )
|
|
{
|
|
os_printf("\nopen stream R_INTERCOM_AUDIO err");
|
|
goto intercom_client_handle;
|
|
}
|
|
|
|
Enc_Inst = adpcm_encoder_create(SAMPLERATE,0,0,DECODED_DATA_LEN,REDUNDANCY_NUM);
|
|
Dec_Inst = adpcm_decoder_create(DECODED_DATA_LEN,REDUNDANCY_NUM);
|
|
|
|
os_mutex_init(&send_mutex);
|
|
os_mutex_init(&list_mutex);
|
|
os_sema_init(&encode_sem, 0);
|
|
os_sema_init(&decode_sem, 0);
|
|
g_code_sema_init = 1;
|
|
|
|
#if MUTE_SPEAKER == 1
|
|
gpio_set_mode(PIN_SPK_MUTE, GPIO_PULL_NONE, GPIO_PULL_LEVEL_NONE);
|
|
gpio_set_dir(PIN_SPK_MUTE, GPIO_DIR_OUTPUT);
|
|
#endif
|
|
|
|
OS_TASK_INIT("intercom_encoded_handle", &intercom->encoded_task, intercom_encoded_handle, &encode_sem, OS_TASK_PRIORITY_NORMAL-3, 4096);
|
|
OS_TASK_INIT("intercom_decoded_handle", &intercom->decoded_task, intercom_decoded_handle, &decode_sem, OS_TASK_PRIORITY_NORMAL-3, 2048);
|
|
OS_TASK_INIT("intercom_recv", &intercom->recv_task, intercom_recv, NULL, OS_TASK_PRIORITY_NORMAL+1, 1024);
|
|
OS_TASK_INIT("retransfer_check", &intercom->retransfer_task, retransfer_check, NULL, OS_TASK_PRIORITY_NORMAL-1, 1024);
|
|
|
|
os_timer_init(&ctl_timer, (os_timer_func_t)decode_sem_up, OS_TIMER_MODE_PERIODIC, &ctl_timer);
|
|
os_timer_start(&ctl_timer, CODE_MODE);
|
|
return;
|
|
|
|
intercom_client_handle:
|
|
close_socket();
|
|
close_intercom_stream();
|
|
free_room();
|
|
if(intercom) {
|
|
custom_free(intercom);
|
|
intercom = NULL;
|
|
}
|
|
return;
|
|
}
|
|
|
|
int get_audio_sublist_count(volatile struct list_head *head)
|
|
{
|
|
int count = 0;
|
|
struct list_head *list_n = (struct list_head *)head;
|
|
int ret = os_mutex_lock(&list_mutex,-1);
|
|
if(ret < 0) {
|
|
return 0;
|
|
}
|
|
while(list_n->next != head) {
|
|
list_n = list_n->next;
|
|
count++;
|
|
if(count>SUBLIST_NUM)
|
|
{
|
|
count = 0;
|
|
break;
|
|
}
|
|
}
|
|
os_mutex_unlock(&list_mutex);
|
|
return count;
|
|
}
|
|
int get_audio_node_count(struct list_head *head)
|
|
{
|
|
int count = 0;
|
|
struct list_head *list_n = (struct list_head *)head;
|
|
while(list_n->next != head) {
|
|
list_n = list_n->next;
|
|
count++;
|
|
if(count>(SOFTBUF_LEN/NODE_DATA_LEN))
|
|
{
|
|
count = 0;
|
|
break;
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
int get_ringbuf_manage_count()
|
|
{
|
|
int count = 0;
|
|
struct list_head *list_n = (struct list_head *)manage_cur_pop;
|
|
struct list_head *head = (struct list_head *)manage_cur_push;
|
|
while(list_n != head) {
|
|
list_n = list_n->next;
|
|
count++;
|
|
if(count>(ENCODED_BUF_NUM))
|
|
{
|
|
count = 0;
|
|
break;
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
static struct list_head *get_audio_sublist(struct list_head *head)
|
|
{
|
|
int ret = os_mutex_lock(&list_mutex,-1);
|
|
if(ret < 0)
|
|
return 0;
|
|
if(list_empty_careful((const struct list_head *)&sublist_head)){
|
|
os_mutex_unlock(&list_mutex);
|
|
os_printf("sublist_head empty\n");
|
|
return 0;
|
|
}
|
|
list_move_tail((struct list_head *)sublist_head.next,(struct list_head *)head);
|
|
os_mutex_unlock(&list_mutex);
|
|
return head->prev;
|
|
}
|
|
static struct list_head *get_audio_node(volatile struct list_head *head, uint32 node_num)
|
|
{
|
|
int ret = os_mutex_lock(&list_mutex,-1);
|
|
if(ret < 0)
|
|
return 0;
|
|
if(get_audio_node_count((struct list_head *)&intercom->srcList_head) < node_num){
|
|
os_mutex_unlock(&list_mutex);
|
|
os_printf("srcList empty\n");
|
|
return 0;
|
|
}
|
|
|
|
for(uint32 i=0; i<node_num; i++)
|
|
list_move_tail((struct list_head *)intercom->srcList_head.next,(struct list_head *)head);
|
|
os_mutex_unlock(&list_mutex);
|
|
return head->next;
|
|
}
|
|
static void del_ringbuf_manage()
|
|
{
|
|
list_move_tail((struct list_head *)ringbuf_manage_use.next,(struct list_head*)&ringbuf_manage_src);
|
|
os_mutex_unlock(&list_mutex);
|
|
}
|
|
static struct list_head *get_ringbuf_manage(uint8 grab)
|
|
{
|
|
if(list_empty_careful((const struct list_head *)&ringbuf_manage_src)) {
|
|
if(grab)
|
|
list_move_tail((struct list_head *)ringbuf_manage_use.next,(struct list_head *)&ringbuf_manage_use);
|
|
else {
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
list_move_tail((struct list_head *)ringbuf_manage_src.next,(struct list_head *)&ringbuf_manage_use);
|
|
return ringbuf_manage_use.prev;
|
|
}
|
|
static void clear_ringbuf_manage_use(void)
|
|
{
|
|
ringbuf_manage_use.next->prev = ringbuf_manage_src.prev;
|
|
ringbuf_manage_use.prev->next = (struct list_head*)(&(ringbuf_manage_src));
|
|
ringbuf_manage_src.prev->next = ringbuf_manage_use.next;
|
|
ringbuf_manage_src.prev = ringbuf_manage_use.prev;
|
|
ringbuf_manage_use.next = (struct list_head*)(&(ringbuf_manage_use));
|
|
ringbuf_manage_use.prev = (struct list_head*)(&(ringbuf_manage_use));
|
|
}
|
|
static void *get_audio_addr(struct list_head *list)
|
|
{
|
|
audio_node *audio_n;
|
|
audio_n = list_entry((struct list_head *)list,audio_node,list);
|
|
return audio_n->buf_addr;
|
|
}
|
|
static void *get_ringbuf_manage_addr(struct list_head *list)
|
|
{
|
|
ringbuf_manage *ringbuf_mana;
|
|
ringbuf_mana = list_entry((struct list_head *)list,ringbuf_manage,list);
|
|
return ringbuf_mana->buf_addr;
|
|
}
|
|
|
|
static void del_audio_node(volatile struct list_head *del)
|
|
{
|
|
del->next->prev = intercom->srcList_head.prev;
|
|
del->prev->next = (struct list_head*)(&(intercom->srcList_head));
|
|
intercom->srcList_head.prev->next = del->next;
|
|
intercom->srcList_head.prev = del->prev;
|
|
del->next = (struct list_head *)del;
|
|
del->prev = (struct list_head *)del;
|
|
}
|
|
static void del_audio_sublist(volatile struct list_head *del)
|
|
{
|
|
int ret = os_mutex_lock(&list_mutex,-1);
|
|
if(ret < 0)
|
|
return;
|
|
sublist *sublist_n = list_entry((struct list_head *)del,sublist,list);
|
|
if(sublist_n->node_cnt)
|
|
del_audio_node(&(sublist_n->node_head));
|
|
list_move_tail((struct list_head *)del,(struct list_head*)&sublist_head);
|
|
os_mutex_unlock(&list_mutex);
|
|
}
|
|
|
|
static void insert_into_useList(volatile struct list_head *del, volatile struct list_head *head)
|
|
{
|
|
sublist *sublist_n;
|
|
sublist *sublist_n_pos;
|
|
sublist *npos;
|
|
sublist_n = list_entry((struct list_head *)del,sublist,list);
|
|
int prev_sort = 0;
|
|
uint16 new_sort = 0;
|
|
uint16 next_sort = 0;
|
|
|
|
new_sort = sublist_n->sort;
|
|
prev_sort = (play_start_flag&BIT(0))?play_sort:-1;
|
|
if((prev_sort>=new_sort) && ((prev_sort-new_sort)<=20))
|
|
{
|
|
// os_printf("del1:%d %d\n",new_sort,prev_sort);
|
|
del_audio_sublist(del);
|
|
return;
|
|
}
|
|
|
|
int ret = os_mutex_lock(&list_mutex,-1);
|
|
if(ret < 0)
|
|
return;
|
|
if(list_empty_careful((struct list_head *)head)) {
|
|
// os_printf("is1:%d %d\n",new_sort,prev_sort);
|
|
list_move((struct list_head *)del,(struct list_head *)head);
|
|
os_mutex_unlock(&list_mutex);
|
|
return;
|
|
}
|
|
os_mutex_unlock(&list_mutex);
|
|
list_for_each_entry_safe(sublist_n_pos, npos, (struct list_head *)head, list)
|
|
{
|
|
next_sort = sublist_n_pos->sort;
|
|
if(new_sort == next_sort)
|
|
{
|
|
// os_printf("del2:%d %d %d\n",new_sort,prev_sort,next_sort);
|
|
del_audio_sublist(del);
|
|
return;
|
|
}
|
|
else if( (prev_sort < new_sort ) && (new_sort < next_sort) && ((next_sort-new_sort) < 60000) )
|
|
{
|
|
ret = os_mutex_lock(&list_mutex,-1);
|
|
if(ret < 0)
|
|
return;
|
|
// os_printf("is2:%d %d %d\n",new_sort,prev_sort,next_sort);
|
|
list_move((struct list_head *)del,(struct list_head *)(sublist_n_pos->list.prev));
|
|
os_mutex_unlock(&list_mutex);
|
|
return;
|
|
}
|
|
else if( (prev_sort>60000) && ((prev_sort - new_sort)>60000) && (new_sort < next_sort) && (prev_sort - next_sort>60000) )
|
|
{
|
|
ret = os_mutex_lock(&list_mutex,-1);
|
|
if(ret < 0)
|
|
return;
|
|
// os_printf("is3:%d %d %d\n",new_sort,prev_sort,next_sort);
|
|
list_move((struct list_head *)del,(struct list_head *)(sublist_n_pos->list.prev));
|
|
os_mutex_unlock(&list_mutex);
|
|
return;
|
|
}
|
|
prev_sort = next_sort;
|
|
}
|
|
ret = os_mutex_lock(&list_mutex,-1);
|
|
if(ret < 0)
|
|
return;
|
|
// os_printf("is4:%d %d %d\n",new_sort,prev_sort,next_sort);
|
|
list_move_tail((struct list_head *)del,(struct list_head *)head);
|
|
os_mutex_unlock(&list_mutex);
|
|
return;
|
|
}
|
|
|
|
int recv_repeat_check(uint16 seq, uint16 sort)
|
|
{
|
|
static uint16 seq_sort[ENCODED_BUF_NUM*2+1] = {0};
|
|
|
|
if(sort == seq_sort[seq]) {
|
|
return 1;
|
|
}
|
|
else {
|
|
seq_sort[seq] = sort;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
uint16_t calulate_sum(uint8_t * buf, uint16_t len)
|
|
{
|
|
uint16_t sum = 0;
|
|
for(uint16_t i=0; i<len; i++) {
|
|
sum += *(buf+i);
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
void lose_packet_check(void)
|
|
{
|
|
static char sequence = 0;
|
|
char temp = 0;
|
|
static uint32 lose_packet = 0;
|
|
static char retrans_num[ENCODED_BUF_NUM*2+1] = {0};
|
|
socklen_t addrlen = sizeof(struct sockaddr_in);
|
|
uint32 last_loop_lose = 0;
|
|
uint32 new_loop_lose = 0;
|
|
uint8 seq = 0;
|
|
uint16 sort = 0;
|
|
struct list_head *sublist_l = NULL;
|
|
sublist *sublist_n = NULL;
|
|
uint32 i = 0;
|
|
uint16 status = 0;
|
|
uint8 recv_timeout = 0;
|
|
int prev_sort = 0;
|
|
|
|
for(i=1; i<(ENCODED_BUF_NUM*2+1); i++)
|
|
{
|
|
if(lose_packet & BIT(i)) {
|
|
retrans_num[i] +=1;
|
|
if(retrans_num[i] >= 2) {
|
|
retrans_num[i] = 0;
|
|
lose_packet &= ~BIT(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
sublist_l = intercom->checkList_head.next;
|
|
sublist_n = list_entry((struct list_head *)sublist_l,sublist,list);
|
|
status = sublist_n->status;
|
|
#if INTERCOM_CLIENT
|
|
if(status == 2)
|
|
{
|
|
g_transfer_mode = SEND_MODE;
|
|
del_audio_sublist(sublist_l);
|
|
}
|
|
else
|
|
{
|
|
g_transfer_mode = RECV_MODE;
|
|
#endif
|
|
temp = (sequence % (ENCODED_BUF_NUM*2))+1;
|
|
seq = sublist_n->seq;
|
|
if(os_abs(seq-temp) >= 8)
|
|
temp = seq;
|
|
sort = sublist_n->sort;
|
|
prev_sort = (play_start_flag&BIT(0))?play_sort:-1;
|
|
/*收到重复包，丢弃*/
|
|
if(recv_repeat_check(seq, sort)) {
|
|
del_audio_sublist(sublist_l);
|
|
}
|
|
else if((sort <= prev_sort) && (prev_sort-sort <10))
|
|
{
|
|
del_audio_sublist(sublist_l);
|
|
lose_packet &= ~BIT(seq);
|
|
retrans_num[seq] = 0;
|
|
}
|
|
else
|
|
{
|
|
/*收到丢包，清掉该丢包位*/
|
|
if( lose_packet & BIT(seq) )
|
|
{
|
|
lose_packet &= ~BIT(seq);
|
|
retrans_num[seq] = 0;
|
|
// printf("re:%d\n",sort);
|
|
}
|
|
else if( temp != seq)
|
|
{
|
|
if(BIT(seq) > BIT(temp))
|
|
lose_packet |= (BIT(seq) - BIT(temp));
|
|
else {
|
|
last_loop_lose = BIT(ENCODED_BUF_NUM*2+1) - BIT(temp);
|
|
new_loop_lose = BIT(seq) - BIT(1);
|
|
lose_packet |= (last_loop_lose|new_loop_lose);
|
|
}
|
|
sequence = seq;
|
|
}
|
|
else
|
|
sequence = temp;
|
|
recv_timeout = 0;
|
|
insert_into_useList(sublist_l,&intercom->useList_head);
|
|
// os_printf("r:%d\n",sort);
|
|
}
|
|
#if INTERCOM_CLIENT
|
|
}
|
|
#endif
|
|
if(lose_packet)
|
|
{
|
|
if(now_dac_filter_type == SOUND_INTERCOM) {
|
|
#if INTERCOM_SERVER
|
|
sendto(intercom->ack_sfd, &lose_packet,4, 0, (struct sockaddr*)&(intercom->ack_c_addr), addrlen);
|
|
#elif INTERCOM_CLIENT
|
|
sendto(intercom->ack_cfd, &lose_packet, 4, 0, (struct sockaddr*)&(intercom->ack_s_addr), addrlen);
|
|
#endif
|
|
// printf("lp:%d***********\n",lose_packet);
|
|
}
|
|
}
|
|
}
|
|
|
|
void losePacket_retransfer(uint8 *addr, uint32 len)
|
|
{
|
|
if(encoded_ringbuf == NULL) {
|
|
return;
|
|
}
|
|
uint8 send_buf[ENCODED_BUF_BYTE*NUM_OF_FRAME] = {0};
|
|
if((addr+len) > ((uint8*)(encoded_ringbuf->data+encoded_ringbuf->size))) {
|
|
uint32 residue_len = (uint8*)(encoded_ringbuf->data+encoded_ringbuf->size)-addr;
|
|
os_memcpy(send_buf, addr, residue_len);
|
|
os_memcpy(send_buf+residue_len, encoded_ringbuf->data, len-residue_len);
|
|
}
|
|
else
|
|
os_memcpy(send_buf, addr, len);
|
|
#if INTERCOM_SERVER
|
|
sendto(intercom->udp_sfd, send_buf, len, 0,
|
|
(struct sockaddr*)&(intercom->udp_c_addr), sizeof(intercom->udp_c_addr));
|
|
#elif INTERCOM_CLIENT
|
|
sendto(intercom->udp_cfd, send_buf, len, 0,
|
|
(struct sockaddr*)&(intercom->udp_s_addr), sizeof(intercom->udp_s_addr));
|
|
#endif
|
|
}
|
|
|
|
void retransfer_check(void *d)
|
|
{
|
|
int len = 0;
|
|
char sequence = 0;
|
|
socklen_t addrlen = sizeof(struct sockaddr_in);
|
|
uint32 lose_packet = 0;
|
|
volatile struct list_head *manage_p = NULL;
|
|
uint8 *addr = NULL;
|
|
uint32 send_totallen = 0;
|
|
uint8_t cnt = 0;
|
|
|
|
while(1)
|
|
{
|
|
#if INTERCOM_SERVER
|
|
len = recvfrom(intercom->ack_sfd, &lose_packet, 4, 0, (struct sockaddr*)&(intercom->ack_c_addr), &addrlen);
|
|
if(g_transfer_mode == RECV_MODE)
|
|
continue;
|
|
#elif INTERCOM_CLIENT
|
|
len = recvfrom(intercom->ack_cfd, &lose_packet, 4, 0, (struct sockaddr*)&(intercom->ack_s_addr), &addrlen);
|
|
#endif
|
|
if((play_start_flag&BIT(1)) == 0)
|
|
continue;
|
|
if(len > 0)
|
|
{
|
|
if(os_mutex_lock(&send_mutex,-1) == 0)
|
|
{
|
|
manage_p = ringbuf_manage_use.next;
|
|
while(manage_p != &(ringbuf_manage_use)) {
|
|
cnt++;
|
|
send_totallen = 0;
|
|
addr = (uint8*)get_ringbuf_manage_addr((struct list_head *)manage_p);
|
|
sequence = *addr;
|
|
if(BIT(sequence) & lose_packet)
|
|
{
|
|
// printf("rs:%d\n",sequence);
|
|
for(uint32 i=0; i<NUM_OF_FRAME; i++) {
|
|
send_totallen += ENCODED_BUF_BYTE;
|
|
manage_p = manage_p->next;
|
|
if(manage_p == (&ringbuf_manage_use))
|
|
break;
|
|
}
|
|
losePacket_retransfer(addr, send_totallen);
|
|
os_sleep_ms(1);
|
|
}
|
|
else
|
|
manage_p = manage_p->next;
|
|
if(cnt >= ENCODED_BUF_NUM)
|
|
break;
|
|
}
|
|
os_mutex_unlock(&send_mutex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void intercom_send(uint8 num)
|
|
{
|
|
int slen = 0;
|
|
socklen_t addrlen = sizeof(struct sockaddr_in);
|
|
uint8 send_buf[ENCODED_BUF_BYTE*NUM_OF_FRAME] = {0};
|
|
uint32 send_totallen = 0;
|
|
uint8 *addr = NULL;
|
|
struct list_head *manage_p = NULL;
|
|
|
|
uint32 numof_available = get_ringbuf_manage_count();
|
|
|
|
if((numof_available >= num) && (send_start_flag==0)) {
|
|
send_start_flag = 1;
|
|
}
|
|
|
|
if((send_start_flag) && (numof_available >= num))
|
|
{
|
|
manage_cur_pop = manage_cur_pop->next;
|
|
manage_p = manage_cur_pop;
|
|
addr = (uint8*)get_ringbuf_manage_addr(manage_cur_pop);
|
|
for(uint32 i=0; i<num; i++) {
|
|
send_totallen += ENCODED_BUF_BYTE;
|
|
manage_p = manage_p->next;
|
|
}
|
|
if((addr+send_totallen) > ((uint8*)(encoded_ringbuf->data+encoded_ringbuf->size))) {
|
|
uint32 residue_len = (uint8*)(encoded_ringbuf->data+encoded_ringbuf->size)-addr;
|
|
os_memcpy(send_buf, addr, residue_len);
|
|
os_memcpy(send_buf+residue_len, encoded_ringbuf->data, send_totallen-residue_len);
|
|
}
|
|
else
|
|
os_memcpy(send_buf, addr, send_totallen);
|
|
|
|
if(send_start_flag == 1) {
|
|
#if INTERCOM_SERVER
|
|
slen = sendto(intercom->udp_sfd, send_buf, send_totallen, 0, (struct sockaddr*)&(intercom->udp_c_addr), addrlen);
|
|
#elif INTERCOM_CLIENT
|
|
slen = sendto(intercom->udp_cfd, send_buf, send_totallen, 0, (struct sockaddr*)&(intercom->udp_s_addr), addrlen);
|
|
#endif
|
|
// os_printf("s:%d %d\n",*((uint16_t*)(send_buf+2)),send_totallen);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void intercom_recv(void *d)
|
|
{
|
|
int rlen = 0;
|
|
socklen_t addrlen = sizeof(struct sockaddr_in);
|
|
uint8 recv_buf[ENCODED_BUF_BYTE*NUM_OF_FRAME] = {0};
|
|
uint8 *node_addr = NULL;
|
|
uint32 code_len = 0;
|
|
uint32 offset = 0;
|
|
uint32 node_num = 0;
|
|
#if DUPLEX_TYPE == FULL_DUPLEX
|
|
static int recv_timeout_cnt = 0;
|
|
#endif
|
|
#if INTERCOM_SERVER
|
|
uint8 encoded_buf[RESERVE] = {0};
|
|
int ret = -1;
|
|
static uint32 send_req_cnt = 0;
|
|
#endif
|
|
static int r_identify_num = 0;
|
|
while(1)
|
|
{
|
|
#if INTERCOM_SERVER
|
|
rlen = recvfrom(intercom->udp_sfd, recv_buf, ENCODED_BUF_BYTE*NUM_OF_FRAME, 0, (struct sockaddr*)&(intercom->udp_c_addr), &addrlen);
|
|
if(memcmp(&intercom->udp_c_addr.sin_addr,&intercom->ack_c_addr.sin_addr,sizeof(struct in_addr)) != 0)
|
|
memcpy(&intercom->ack_c_addr.sin_addr,&intercom->udp_c_addr.sin_addr,sizeof(struct in_addr));
|
|
if(rlen <= 0) {
|
|
#if DUPLEX_TYPE == HALF_DUPLEX
|
|
ret = os_mutex_lock(&send_mutex,-1);
|
|
if(ret < 0)
|
|
continue;
|
|
if((get_ringbuf_manage_count()<=0) && (g_transfer_mode == RECV_MODE) && (g_switch_recv_success==0) && (send_req_cnt < 10))
|
|
{
|
|
os_printf("intercom server send request\n");
|
|
encoded_buf[1] = 2;
|
|
*((uint32*)(encoded_buf+8)) = g_s_identify_num;
|
|
sendto(intercom->udp_sfd, encoded_buf, RESERVE, 0, (struct sockaddr*)&(intercom->udp_c_addr), addrlen);
|
|
send_req_cnt++;
|
|
if(send_req_cnt >= 10)
|
|
send_req_cnt = 10;
|
|
}
|
|
os_mutex_unlock(&send_mutex);
|
|
#elif DUPLEX_TYPE == FULL_DUPLEX
|
|
recv_timeout_cnt++;
|
|
if(recv_timeout_cnt>=20){
|
|
recv_timeout_cnt = 20;
|
|
if(send_start_flag==1)
|
|
send_start_flag = 2; //认为对方进入低功耗或者掉线，停止发送，但是发送缓存区还需要更新；
|
|
intercom_encode_flag &= ~BIT(1); //停止编码
|
|
}
|
|
#endif
|
|
continue;
|
|
}
|
|
else {
|
|
#if DUPLEX_TYPE == HALF_DUPLEX
|
|
g_switch_recv_success = 1;
|
|
send_req_cnt = 0;
|
|
#elif DUPLEX_TYPE == FULL_DUPLEX
|
|
recv_timeout_cnt = 0;
|
|
if(send_start_flag==2)
|
|
send_start_flag = 1;
|
|
intercom_encode_flag |= BIT(1);
|
|
#endif
|
|
}
|
|
#elif INTERCOM_CLIENT
|
|
rlen = recvfrom(intercom->udp_cfd, recv_buf, ENCODED_BUF_BYTE*NUM_OF_FRAME, 0, (struct sockaddr*)&(intercom->udp_s_addr), &addrlen);
|
|
if((play_start_flag&BIT(1)) == 0) {
|
|
continue;
|
|
}
|
|
if(rlen <= 0) {
|
|
recv_timeout_cnt++;
|
|
if(recv_timeout_cnt>=20){
|
|
recv_timeout_cnt = 20;
|
|
#if(DUPLEX_TYPE == FULL_DUPLEX)
|
|
intercom_encode_flag &= ~BIT(1); //停止编码
|
|
#else
|
|
if(g_transfer_mode == RECV_MODE)
|
|
g_transfer_mode = SEND_MODE;
|
|
#endif
|
|
}
|
|
}
|
|
else {
|
|
recv_timeout_cnt = 0;
|
|
#if(DUPLEX_TYPE == FULL_DUPLEX)
|
|
intercom_encode_flag |= BIT(1);
|
|
#endif
|
|
}
|
|
#endif
|
|
if(rlen >= RESERVE)
|
|
{
|
|
offset = 0;
|
|
while(rlen > offset)
|
|
{
|
|
uint16_t check_sum = *((uint16_t*)(recv_buf+offset+RESERVE-2));
|
|
if(check_sum != calulate_sum(recv_buf+offset, RESERVE-2)) {
|
|
os_printf("intercom abnormal packet\n");
|
|
break;
|
|
}
|
|
struct list_head *sublist_l = get_audio_sublist((struct list_head*)(&intercom->checkList_head));
|
|
if(!sublist_l)
|
|
break;
|
|
sublist *sublist_n = list_entry((struct list_head *)sublist_l,sublist,list);
|
|
os_memcpy(&(sublist_n->seq), recv_buf+offset, RESERVE-2);
|
|
if(r_identify_num != sublist_n->identify_num) {
|
|
for(uint8 i=0; i<g_numofcached; i++)
|
|
{
|
|
struct list_head *sublist_l = intercom->useList_head.next;
|
|
del_audio_sublist(sublist_l);
|
|
}
|
|
g_numofcached = 0;
|
|
play_start_flag &= ~BIT(0);
|
|
r_identify_num = sublist_n->identify_num;
|
|
os_printf("\n******change intercom identify_num****\n");
|
|
}
|
|
offset += RESERVE;
|
|
code_len = ENCODED_DATA_BYTE;
|
|
node_num = (code_len%NODE_DATA_LEN)?(code_len/NODE_DATA_LEN+1):(code_len/NODE_DATA_LEN);
|
|
sublist_n->node_cnt = node_num;
|
|
struct list_head *audio_n = get_audio_node(&(sublist_n->node_head), node_num);
|
|
if(audio_n)
|
|
{
|
|
while(code_len > NODE_DATA_LEN) {
|
|
node_addr = (uint8*)get_audio_addr(audio_n);
|
|
os_memcpy(node_addr, recv_buf+offset, NODE_DATA_LEN);
|
|
audio_n = audio_n->next;
|
|
offset += NODE_DATA_LEN;
|
|
code_len -= NODE_DATA_LEN;
|
|
}
|
|
if(code_len > 0) {
|
|
node_addr = (uint8*)get_audio_addr(audio_n);
|
|
os_memcpy(node_addr, recv_buf+offset, code_len);
|
|
offset += code_len;
|
|
code_len = 0;
|
|
}
|
|
lose_packet_check();
|
|
}
|
|
else {
|
|
sublist_n->node_cnt = 0;
|
|
del_audio_sublist(sublist_l);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void mute_speaker(uint8 enable)
|
|
{
|
|
gpio_set_val(PIN_SPK_MUTE, enable);
|
|
}
|
|
|
|
void decode_sem_up(uint32 *args)
|
|
{
|
|
if(g_code_sema_init) {
|
|
os_sema_up(&decode_sem);
|
|
}
|
|
return;
|
|
}
|
|
|
|
void encode_sema_up()
|
|
{
|
|
if(g_code_sema_init) {
|
|
os_sema_up(&encode_sem);
|
|
}
|
|
}
|
|
|
|
void intercom_encoded_start(void)
|
|
{
|
|
intercom_encode_flag |= BIT(0);
|
|
}
|
|
void intercom_emcoded_stop(void)
|
|
{
|
|
intercom_encode_flag &= ~BIT(0);
|
|
}
|
|
|
|
void intercom_encoded_handle(void *d)
|
|
{
|
|
int16 *recv_stream_buf = NULL;
|
|
struct data_structure *get_f = NULL;
|
|
int code_len = 0;
|
|
uint8_t encoded_buf[ENCODED_BUF_BYTE] = {0};
|
|
static uint16 sort = 0;
|
|
uint32 timestamp = 0;
|
|
static uint8 mute_sta = 0;
|
|
static uint8 num_of_avaiable = 0;
|
|
uint8 send_num = 0;
|
|
ringbuf_manage *ringbuf_mana_n = NULL;
|
|
struct list_head *ringbuf_mana_l = NULL;
|
|
struct list_head *manage_l_del = NULL;
|
|
ringbuf_manage *manage_n_del = NULL;
|
|
struct os_semaphore *sem = (struct os_semaphore *)d;
|
|
int ret = -1;
|
|
|
|
g_s_identify_num = 0;
|
|
os_random_bytes((uint8*)(&g_s_identify_num), 4);
|
|
os_printf("\n**********intercom ID:%d***********\n",g_s_identify_num);
|
|
|
|
while(1)
|
|
{
|
|
os_sema_down(sem,-1);
|
|
get_f = recv_real_data(intercom->recv_s);
|
|
current_adc_data = get_f;
|
|
ret = os_mutex_lock(&send_mutex,-1);
|
|
if(ret == 0){
|
|
#if DUPLEX_TYPE == HALF_DUPLEX
|
|
if(g_transfer_mode == SEND_MODE)
|
|
{
|
|
#endif
|
|
if(get_f)
|
|
{
|
|
#if DUPLEX_TYPE == HALF_DUPLEX
|
|
if((g_numofcached > 0) || (intercom_encode_flag!=0x03))
|
|
{
|
|
#elif DUPLEX_TYPE == FULL_DUPLEX
|
|
if(intercom_encode_flag!=0x03)
|
|
{
|
|
#endif
|
|
free_data(get_f);
|
|
current_adc_data = NULL;
|
|
g_send_sequence = (g_send_sequence % (ENCODED_BUF_NUM*2))+1;
|
|
encoded_buf[0] = (uint8)g_send_sequence;
|
|
encoded_buf[1] = 0;
|
|
if(sort < 65535) sort++;
|
|
else sort = 0;
|
|
*((uint16*)(encoded_buf+2)) = sort;
|
|
timestamp = os_jiffies();
|
|
*((uint32*)(encoded_buf+4)) = timestamp;
|
|
*((uint32*)(encoded_buf+8)) = g_s_identify_num;
|
|
*((uint16_t*)(encoded_buf+12)) = calulate_sum(encoded_buf,RESERVE-2);
|
|
ringbuf_mana_l = get_ringbuf_manage(0);
|
|
if(!ringbuf_mana_l) {
|
|
ringbuf_mana_l = ringbuf_manage_use.next;
|
|
ringbuf_mana_n = list_entry(ringbuf_mana_l, ringbuf_manage, list);
|
|
encoded_ringbuf->front = (encoded_ringbuf->front+ENCODED_BUF_BYTE)%(encoded_ringbuf->size);
|
|
if(manage_cur_pop == ringbuf_manage_use.next)
|
|
manage_cur_pop = manage_cur_pop->next;
|
|
ringbuf_mana_l = get_ringbuf_manage(1);
|
|
}
|
|
manage_cur_push = ringbuf_mana_l;
|
|
ringbuf_mana_n = list_entry(ringbuf_mana_l, ringbuf_manage, list);
|
|
ringbuf_mana_n->buf_addr = (uint8*)encoded_ringbuf->data + encoded_ringbuf->rear;
|
|
while(ringbuf_push_available(encoded_ringbuf) < ENCODED_BUF_BYTE) {
|
|
manage_l_del = ringbuf_manage_use.next;
|
|
manage_n_del = list_entry(manage_l_del, ringbuf_manage, list);
|
|
encoded_ringbuf->front = (encoded_ringbuf->front+ENCODED_BUF_BYTE)%(encoded_ringbuf->size);
|
|
if(manage_cur_pop == ringbuf_manage_use.next)
|
|
manage_cur_pop = manage_cur_pop->next;
|
|
del_ringbuf_manage();
|
|
}
|
|
push_ringbuf(encoded_ringbuf, encoded_buf, ENCODED_BUF_BYTE);
|
|
send_num = 1;
|
|
intercom_send(send_num);
|
|
os_mutex_unlock(&send_mutex);
|
|
continue;
|
|
}
|
|
g_switch_recv_success = 0;
|
|
|
|
mute_sta = 0;
|
|
recv_stream_buf = get_stream_real_data(get_f);
|
|
timestamp = os_jiffies();
|
|
adpcm_encode(Enc_Inst,encoded_buf+RESERVE,&code_len,recv_stream_buf,DECODED_DATA_LEN,CODE_BPS);
|
|
free_data(get_f);
|
|
current_adc_data = NULL;
|
|
g_send_sequence = (g_send_sequence % (ENCODED_BUF_NUM*2))+1;
|
|
encoded_buf[0] = (uint8)g_send_sequence;
|
|
encoded_buf[1] = 1;
|
|
if(sort < 65535) sort++;
|
|
else sort = 0;
|
|
*((uint16*)(encoded_buf+2)) = sort;
|
|
*((uint32*)(encoded_buf+4)) = timestamp;
|
|
*((uint32*)(encoded_buf+8)) = g_s_identify_num;
|
|
*((uint16_t*)(encoded_buf+12)) = calulate_sum(encoded_buf,RESERVE-2);
|
|
ringbuf_mana_l = get_ringbuf_manage(0);
|
|
if(!ringbuf_mana_l) {
|
|
ringbuf_mana_l = ringbuf_manage_use.next;
|
|
ringbuf_mana_n = list_entry(ringbuf_mana_l, ringbuf_manage, list);
|
|
encoded_ringbuf->front = (encoded_ringbuf->front+ENCODED_BUF_BYTE)%(encoded_ringbuf->size);
|
|
if(manage_cur_pop == ringbuf_manage_use.next)
|
|
manage_cur_pop = manage_cur_pop->next;
|
|
ringbuf_mana_l = get_ringbuf_manage(1);
|
|
}
|
|
manage_cur_push = ringbuf_mana_l;
|
|
ringbuf_mana_n = list_entry(ringbuf_mana_l, ringbuf_manage, list);
|
|
ringbuf_mana_n->buf_addr = (uint8*)encoded_ringbuf->data + encoded_ringbuf->rear;
|
|
while(ringbuf_push_available(encoded_ringbuf) < ENCODED_BUF_BYTE) {
|
|
manage_l_del = ringbuf_manage_use.next;
|
|
manage_n_del = list_entry(manage_l_del, ringbuf_manage, list);
|
|
encoded_ringbuf->front = (encoded_ringbuf->front+ENCODED_BUF_BYTE)%(encoded_ringbuf->size);
|
|
if(manage_cur_pop == ringbuf_manage_use.next)
|
|
manage_cur_pop = manage_cur_pop->next;
|
|
del_ringbuf_manage();
|
|
}
|
|
push_ringbuf(encoded_ringbuf, encoded_buf, ENCODED_BUF_BYTE);
|
|
send_num = NUM_OF_FRAME;
|
|
intercom_send(send_num);
|
|
}
|
|
else {
|
|
if(send_start_flag)
|
|
{
|
|
if(mute_sta == 0) {
|
|
num_of_avaiable = get_ringbuf_manage_count();
|
|
mute_sta = 1;
|
|
}
|
|
|
|
if(num_of_avaiable > 0) {
|
|
intercom_send(num_of_avaiable);
|
|
num_of_avaiable--;
|
|
}
|
|
else {
|
|
g_send_sequence = (g_send_sequence % (ENCODED_BUF_NUM*2))+1;
|
|
encoded_buf[0] = (uint8)g_send_sequence;
|
|
encoded_buf[1] = 0;
|
|
if(sort < 65535) sort++;
|
|
else sort = 0;
|
|
*((uint16*)(encoded_buf+2)) = sort;
|
|
timestamp = os_jiffies();
|
|
*((uint32*)(encoded_buf+4)) = timestamp;
|
|
*((uint32*)(encoded_buf+8)) = g_s_identify_num;
|
|
*((uint16_t*)(encoded_buf+12)) = calulate_sum(encoded_buf,RESERVE-2);
|
|
ringbuf_mana_l = get_ringbuf_manage(0);
|
|
if(!ringbuf_mana_l) {
|
|
ringbuf_mana_l = ringbuf_manage_use.next;
|
|
ringbuf_mana_n = list_entry(ringbuf_mana_l, ringbuf_manage, list);
|
|
encoded_ringbuf->front = (encoded_ringbuf->front+ENCODED_BUF_BYTE)%(encoded_ringbuf->size);
|
|
if(manage_cur_pop == ringbuf_manage_use.next)
|
|
manage_cur_pop = manage_cur_pop->next;
|
|
ringbuf_mana_l = get_ringbuf_manage(1);
|
|
}
|
|
manage_cur_push = ringbuf_mana_l;
|
|
ringbuf_mana_n = list_entry(ringbuf_mana_l, ringbuf_manage, list);
|
|
ringbuf_mana_n->buf_addr = (uint8*)encoded_ringbuf->data + encoded_ringbuf->rear;
|
|
while(ringbuf_push_available(encoded_ringbuf) < ENCODED_BUF_BYTE) {
|
|
manage_l_del = ringbuf_manage_use.next;
|
|
manage_n_del = list_entry(manage_l_del, ringbuf_manage, list);
|
|
encoded_ringbuf->front = (encoded_ringbuf->front+ENCODED_BUF_BYTE)%(encoded_ringbuf->size);
|
|
if(manage_cur_pop == ringbuf_manage_use.next)
|
|
manage_cur_pop = manage_cur_pop->next;
|
|
del_ringbuf_manage();
|
|
}
|
|
push_ringbuf(encoded_ringbuf, encoded_buf, ENCODED_BUF_BYTE);
|
|
send_num = 1;
|
|
intercom_send(send_num);
|
|
}
|
|
}
|
|
}
|
|
#if DUPLEX_TYPE == HALF_DUPLEX
|
|
}
|
|
else if(g_transfer_mode == RECV_MODE){
|
|
num_of_avaiable = get_ringbuf_manage_count();
|
|
if(num_of_avaiable > 0) {
|
|
intercom_send(num_of_avaiable);
|
|
num_of_avaiable--;
|
|
}
|
|
if(get_f) {
|
|
free_data(get_f);
|
|
current_adc_data = NULL;
|
|
}
|
|
}
|
|
#endif
|
|
os_mutex_unlock(&send_mutex);
|
|
}
|
|
}
|
|
}
|
|
|
|
void set_sonic_speed(struct sonic_process_priv *sonic_priv, float speed);
|
|
static int send_to_stream(uint32_t cached)
|
|
{
|
|
int16 *send_stream_buf = NULL;
|
|
struct data_structure *get_f = NULL;
|
|
struct list_head *sublist_l = NULL;
|
|
sublist *sublist_n = NULL;
|
|
int code_len = 0;
|
|
uint32 offset = 0;
|
|
uint16 new_sort = 0;
|
|
uint32_t timestamp = 0;
|
|
int16 decode_data[DECODED_DATA_LEN] = {0};
|
|
uint8 encode_data[ENCODED_DATA_BYTE] = {0};
|
|
uint8 packet_sta = 0;
|
|
static uint32_t last_timestamp = 0;
|
|
static uint32_t plc_cnt = 0;
|
|
int send_res = 0;
|
|
static uint32_t lose_sum = 0;
|
|
static uint8_t play_speed_sta = 2;
|
|
static float play_speed = 1.0f;
|
|
#if LOSE_STATISTICAL
|
|
static uint32_t last_statistical_time = 0;
|
|
#endif
|
|
|
|
send_to_stream_again:
|
|
get_f = get_src_data_f(intercom->send_s);
|
|
current_dac_data = get_f;
|
|
if(get_f) {
|
|
send_stream_buf = get_stream_real_data(get_f);
|
|
play_sort = g_current_sort;
|
|
if(list_empty((struct list_head*)&intercom->useList_head) == 0) {
|
|
sublist_l = intercom->useList_head.next;
|
|
sublist_n = list_entry((struct list_head*)sublist_l, sublist, list);
|
|
new_sort = sublist_n->sort;
|
|
if( (new_sort - g_current_sort) > 20 )
|
|
g_current_sort = new_sort;
|
|
// else if( ((g_current_sort - new_sort)>0) && ((g_current_sort - new_sort)<60000) )
|
|
// g_current_sort = new_sort;
|
|
if(SUBLIST_NUM-cached<15)
|
|
g_current_sort = new_sort;
|
|
packet_sta = sublist_n->status;
|
|
if(packet_sta == 0) {
|
|
#if MUTE_SPEAKER == 1
|
|
mute_speaker(1);
|
|
#endif
|
|
force_del_data(get_f);
|
|
del_audio_sublist(sublist_l);
|
|
g_intercom_start = 0;
|
|
g_current_sort += 1;
|
|
return 0;
|
|
}
|
|
#if MUTE_SPEAKER == 1
|
|
mute_speaker(0);
|
|
#endif
|
|
if(g_current_sort == new_sort) {
|
|
timestamp = sublist_n->timestamp;
|
|
last_timestamp = timestamp;
|
|
code_len = ENCODED_DATA_BYTE;
|
|
struct list_head *audio_n = sublist_n->node_head.next;
|
|
uint8 *addr = NULL;
|
|
offset = 0;
|
|
while(code_len > NODE_DATA_LEN) {
|
|
addr = (uint8*)get_audio_addr(audio_n);
|
|
os_memcpy(encode_data+offset, addr, NODE_DATA_LEN);
|
|
audio_n = audio_n->next;
|
|
offset += NODE_DATA_LEN;
|
|
code_len -= NODE_DATA_LEN;
|
|
}
|
|
if(code_len > 0) {
|
|
addr = (uint8*)get_audio_addr(audio_n);
|
|
os_memcpy(encode_data+offset, addr, code_len);
|
|
offset += code_len;
|
|
code_len = 0;
|
|
}
|
|
code_len = adpcm_decode(Dec_Inst,decode_data,encode_data,ENCODED_DATA_BYTE,CODE_BPS);
|
|
del_audio_sublist(sublist_l);
|
|
plc_cnt = 0;
|
|
}
|
|
else {
|
|
#if PLC_PROCESS == 1
|
|
code_len = adpcm_decode_plc(Dec_Inst,decode_data);
|
|
timestamp = last_timestamp+CODE_MODE;
|
|
last_timestamp = timestamp;
|
|
#else
|
|
os_memset(decode_data, 0, DECODED_DATA_LEN*2);
|
|
#endif
|
|
plc_cnt++;
|
|
lose_sum++;
|
|
if(plc_cnt > 20)
|
|
play_start_flag &= ~BIT(0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
#if PLC_PROCESS == 1
|
|
code_len = adpcm_decode_plc(Dec_Inst,decode_data);
|
|
timestamp = last_timestamp+CODE_MODE;
|
|
last_timestamp = timestamp;
|
|
#else
|
|
os_memset(decode_data, 0, DECODED_DATA_LEN*2);
|
|
#endif
|
|
plc_cnt++;
|
|
lose_sum++;
|
|
if(plc_cnt > 20)
|
|
play_start_flag &= ~BIT(0);
|
|
}
|
|
g_current_sort += 1;
|
|
#if CHANGE_PLAY_SPEED == 1
|
|
if(cached<=(playofwait-5)) {
|
|
if(play_speed_sta != 0) {
|
|
play_speed = 0.9f;
|
|
set_sonic_speed(sonic_priv, play_speed);
|
|
play_speed_sta = 0;
|
|
}
|
|
}
|
|
else if(cached>=(playofwait+5)) {
|
|
if(play_speed_sta != 1) {
|
|
play_speed = 1.1f;
|
|
set_sonic_speed(sonic_priv, play_speed);
|
|
play_speed_sta = 1;
|
|
}
|
|
}
|
|
else if(cached==playofwait) {
|
|
if(play_speed_sta != 2) {
|
|
play_speed = 1.0f;
|
|
set_sonic_speed(sonic_priv, play_speed);
|
|
play_speed_sta = 2;
|
|
}
|
|
}
|
|
#endif
|
|
os_memcpy(send_stream_buf, decode_data, DECODED_DATA_LEN*2);
|
|
set_sound_data_len(get_f, DECODED_DATA_LEN*2);
|
|
get_f->type = SET_DATA_TYPE(SOUND, SOUND_INTERCOM);
|
|
set_stream_data_time(get_f,timestamp);
|
|
send_res = send_data_to_stream(get_f);
|
|
current_dac_data = NULL;
|
|
g_intercom_start = 1;
|
|
if((now_dac_filter_type == SOUND_INTERCOM) && (send_res>0) &&(cached>=1)){
|
|
cached -= 1;
|
|
os_sleep_ms(2);
|
|
goto send_to_stream_again;
|
|
}
|
|
}
|
|
#if LOSE_STATISTICAL
|
|
if(os_jiffies()-last_statistical_time > 1000) {
|
|
os_printf("intercom loss statistical:%d\n",lose_sum);
|
|
lose_sum = 0;
|
|
last_statistical_time = os_jiffies();
|
|
}
|
|
#endif
|
|
// os_printf("g_numofcached:%d\n",cached);
|
|
return 0;
|
|
}
|
|
|
|
extern void audio_dac_set_filter_type(int filter_type);
|
|
extern int get_audio_dac_set_filter_type(void);
|
|
|
|
void intercom_decoded_handle(void *d)
|
|
{
|
|
static int former_dac_filter_type = 0;
|
|
uint8 numofwait = 0; //等待缓存数量满足条件而暂缓播放的次数
|
|
struct os_semaphore *sem = (struct os_semaphore *)d;
|
|
|
|
former_dac_filter_type = get_audio_dac_set_filter_type();
|
|
if(former_dac_filter_type != SOUND_FILE)
|
|
audio_dac_set_filter_type(SOUND_INTERCOM);
|
|
|
|
struct list_head *sublist_l = NULL;
|
|
sublist *sublist_n = NULL;
|
|
|
|
while(1)
|
|
{
|
|
os_sema_down(sem, -1);
|
|
#if DEALY_ADJUSTMENT
|
|
#if INTERCOM_SERVER
|
|
if(txmode == 3)
|
|
#elif INTERCOM_CLIENT
|
|
if(send_mode == 3)
|
|
#endif
|
|
playofwait = 5;
|
|
else
|
|
playofwait = SORTBUF_NUM/2;
|
|
#endif
|
|
g_numofcached = get_audio_sublist_count((struct list_head *)&intercom->useList_head);
|
|
now_dac_filter_type = get_audio_dac_set_filter_type();
|
|
if((now_dac_filter_type != SOUND_INTERCOM) && (!find_stream_enable(R_AT_AVI_AUDIO))) {
|
|
for(uint8_t i=0; i<g_numofcached; i++) {
|
|
struct list_head *sublist_l = intercom->useList_head.next;
|
|
del_audio_sublist(sublist_l);
|
|
g_current_sort += 1;
|
|
play_sort = g_current_sort;
|
|
}
|
|
play_start_flag &= ~BIT(0);
|
|
numofwait = 0;
|
|
os_sleep_ms(1);
|
|
continue;
|
|
}
|
|
if((g_numofcached >= playofwait) && (!find_stream_enable(R_AT_AVI_AUDIO)) && (play_start_flag&BIT(0)))
|
|
{
|
|
for(uint8 i=0; i<del_node_num; i++)
|
|
{
|
|
struct list_head *sublist_l = intercom->useList_head.next;
|
|
del_audio_sublist(sublist_l);
|
|
g_current_sort += 1;
|
|
play_sort = g_current_sort;
|
|
}
|
|
}
|
|
del_node_num = 0;
|
|
g_numofcached = get_audio_sublist_count((struct list_head *)&intercom->useList_head);
|
|
/*缓存的帧数大于一定数量则开始播放*/
|
|
#if DUPLEX_TYPE == HALF_DUPLEX
|
|
if( ((play_start_flag&BIT(0)) == 0) && ((g_numofcached > playofwait) || (numofwait > playofwait) || ((g_transfer_mode == SEND_MODE)&&(g_numofcached>0))) )
|
|
#else
|
|
if( ((play_start_flag&BIT(0)) == 0) && ((g_numofcached > playofwait) || (numofwait > playofwait)))
|
|
#endif
|
|
{
|
|
play_start_flag |= BIT(0);
|
|
numofwait = 0;
|
|
sublist_l = intercom->useList_head.next;
|
|
sublist_n = list_entry((struct list_head*)sublist_l, sublist, list);
|
|
g_current_sort = sublist_n->sort;
|
|
os_printf("intercom play start\n");
|
|
}
|
|
if( ((play_start_flag&BIT(0)) == 0) && (g_numofcached > 0) ) {
|
|
numofwait++;
|
|
}
|
|
if(play_start_flag&BIT(0))
|
|
{
|
|
send_to_stream(g_numofcached);
|
|
}
|
|
#if DUPLEX_TYPE == HALF_DUPLEX
|
|
if((g_numofcached <=0) && (g_transfer_mode == SEND_MODE) && (play_start_flag&BIT(0))) {
|
|
#if MUTE_SPEAKER == 1
|
|
mute_speaker(1);
|
|
#endif
|
|
play_start_flag &= ~BIT(0);
|
|
g_intercom_start = 0;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void intercom_encode_switch(uint8 enable)
|
|
{
|
|
if(enable)
|
|
intercom_encode_flag |= BIT(0);
|
|
else
|
|
intercom_encode_flag &= ~BIT(0);
|
|
}
|
|
void intercom_suspend(void)
|
|
{
|
|
os_timer_stop(&ctl_timer);
|
|
g_code_sema_init = 0;
|
|
play_start_flag &= ~BIT(1);
|
|
os_sleep_ms(60);
|
|
clear_ringbuf_manage_use();
|
|
if(current_adc_data) {
|
|
free_data(current_adc_data);
|
|
current_adc_data = NULL;
|
|
}
|
|
if(current_dac_data) {
|
|
force_del_data(current_dac_data);
|
|
current_dac_data = NULL;
|
|
}
|
|
}
|
|
|
|
void intercom_resume(void)
|
|
{
|
|
os_timer_start(&ctl_timer,CODE_MODE);
|
|
g_numofcached = get_audio_sublist_count((struct list_head *)&intercom->useList_head);
|
|
for(uint8 i=0; i<g_numofcached; i++)
|
|
{
|
|
struct list_head *sublist_l = intercom->useList_head.next;
|
|
del_audio_sublist(sublist_l);
|
|
|
|
}
|
|
g_numofcached = 0;
|
|
g_code_sema_init = 1;
|
|
play_start_flag &= ~BIT(0);
|
|
play_start_flag |= BIT(1);
|
|
send_start_flag = 0;
|
|
g_intercom_start = 0;
|
|
}
|