void ListingUpdater::updateAll()
{
const auto& channelDataList = m_spConfig->getChannelData();
const ListingParse_Jsontv parseJsontv;
for (const auto& channelData : channelDataList)
{
ListingFetch_XmltvSe fetcher(channelData, parseJsontv, m_spListingDb);
INFO_PRINT("Updating programme listings for channel: " << channelData.name << std::endl);
auto res = fetcher.fetch();
for (const auto& programme : res.programmes)
{
m_spListingDb->insertProgramme(programme);
}
for (const auto& downloaded : res.downloadedFiles)
{
m_spListingDb->insertDownloaded(downloaded);
}
INFO_PRINT("Channel: " << channelData.name <<
" -- Downloaded " << res.downloadedFiles.size() << " files with "
<< res.programmes.size() << " programmes" << std::endl);
}
m_spListingDb->deletePastProgrammes();
}
bool TalkbackCore::talkbackCoreThreadStep_sendbuf_rtp()
{
int nSize=0;
int nBuffsize=getSpecAudioCodeModeFrameBuffSize(m_pRtspInfo->tAudioCodeMode);
char pBuffer[nBuffsize];
memset(pBuffer,0,nBuffsize);
bool bRet=true;
long long nTimeStamp=0;
while(bRet){
if(m_pAudioDataContext->pAudioDataContext!=NULL){
bRet=getData(m_pAudioDataContext,pBuffer,nBuffsize,nSize,nTimeStamp);
if(bRet){
int nDiv=nTimeStamp-g_nTime;
g_nTime=nTimeStamp;
//INFO_PRINT(nDiv);
//等待修正
if(nTimeStamp==0){
printf("nSize:%d;nDiv:%d;nTimeStamp:%lld\n",nSize,nDiv,nTimeStamp);
}
if(nDiv<0){
printf("error data:nDiv:%d;nTimeStamp:%lld\n",nDiv,nTimeStamp);
return true;
}
//send
if(m_pRtspInfo->startPlayTime>nTimeStamp){
//do nothing
continue;
}
unsigned int nInterval=nTimeStamp-m_pRtspInfo->startPlayTime;//时间间隔
//频率 m_pRtspInfo->rtpMap.freq
int freq=m_pRtspInfo->rtpMap.freq;//采样频率
m_pRtspInfo->rtptime;//rtp 开始时间
uint32_t ts=m_pRtspInfo->rtptime+freq*nInterval/1000;
if(m_bStartTalkback==false){
memset(pBuffer,0,nBuffsize);
}
if(NULL!=m_pRtspInfo->pRtp_audio){
if(m_pRtspInfo->pRtp_audio->sendbuf(pBuffer,nSize,ts)){
//keep going
}else{
INFO_PRINT("talkbackCoreThreadStep_sendbuf_rtp fail as sendbuf fail");
VLOG(VLOG_ERROR,"send buffer fail,bufferSize:%d",nSize);
return false;
}
}else{
INFO_PRINT("talkbackCoreThreadStep_sendbuf_rtp fail as m_pRtspInfo->pRtp_audio is null");
return false;
}
#ifdef TEST_G711
fwrite(pBuffer,1,nSize,m_pRtspInfo->file);
#endif
}
}else{
bRet=false;
}
}
return true;
}
static int mn885521_parse_dt(struct device *dev, struct mn885521_platform_data *pdata)
{
int rc = 0;
INFO_PRINT("%s \n", __func__);
pdata->fm_fullseg_pw_vreg = devm_regulator_get(dev, "fm_fullseg_pw");
if (IS_ERR(pdata->fm_fullseg_pw_vreg)) {
pdata->fm_fullseg_pw_vreg = NULL;
pr_err("%s: could not get fm_fullseg_pw reg!\n", __func__);
return -EINVAL;
}else
INFO_PRINT("%s: get fm_fullseg_pw reg\n", __func__);
rc = regulator_set_voltage(pdata->fm_fullseg_pw_vreg, 2850000, 2850000);
if (rc < 0) {
pr_err("%s: set voltage failed\n", __func__);
return -EINVAL;
}else
INFO_PRINT("%s: set fm_fullseg_pw voltage\n", __func__);
#if 0
prop = of_find_property(dt, "mn885521,npd_reg_npd_xtal", NULL);
if (prop) {
pdata->npd_reg_npd_xtal = of_get_named_gpio(dt, "mn885521,npd_reg_npd_xtal", 0);
printk("%s: pdata->npd_reg_npd_xtal = %x\n", __func__, pdata->npd_reg_npd_xtal);
}else
printk("%s: fail to get npd_reg_npd_xtal\n", __func__);
prop = of_find_property(dt, "mn885521,nrst", NULL);
if (prop) {
pdata->nrst = of_get_named_gpio(dt, "mn885521,nrst", 0);
printk("%s: pdata->nrst = %x\n", __func__, pdata->nrst);
}
prop = of_find_property(dt, "mn885521,spisel", NULL);
if (prop) {
pdata->spisel = of_get_named_gpio(dt, "mn885521,spisel", 0);
printk("%s: pdata->spisel = %x\n", __func__, pdata->spisel);
}
prop = of_find_property(dt, "mn885521,sadr1", NULL);
if (prop) {
pdata->sadr1 = of_get_named_gpio(dt, "mn885521,sadr1", 0);
printk("%s: pdata->sadr1 = %x\n", __func__, pdata->sadr1);
}
prop = of_find_property(dt, "mn885521,sadr2", NULL);
if (prop) {
pdata->sadr2 = of_get_named_gpio(dt, "mn885521,sadr2", 0);
printk("%s: pdata->sadr2 = %x\n", __func__, pdata->sadr2);
}
#endif
return 0;
}
/*
*函数名称：plugin_init
*函数功能：初始化webqq插件
*调用函数：插件管理模块的插件注册函数、获取特征码函数
*输入参数：无
*输出参数：0 成功 -1错误
*/
static int __attribute ((constructor)) plugin_init()
{
INFO_PRINT("Plugin_webqq 模块初始化\n");
struct plugin_info ppi;
int i = 0;
struct yt_config *config_tmp = NULL;
//获取插件文件存放路径
config_tmp = base_get_configuration();
if(!config_tmp){
log_write(LOG_ERROR, "webqq base_get_configuration() error\n");
return YT_FAILED;
}
webqq_plugin_path = config_tmp->plugin_storage_path;
//注册插件
memset(&ppi, 0, sizeof(struct plugin_info));
ppi.plugin_id = IM_GROUP_ID;
ppi.func_plugin_deal = plugin_deal;
for(i = 0; i < 1; i++){
ppi.port = URL_PORT[i];
if(plugin_manager_register(&ppi)){
log_write(LOG_ERROR, "webqq plugin_manager_register() error\n");
return YT_FAILED;
}
}
return YT_SUCCESSFUL;
}
EStatus StationReset(Station* pThis)
{
VALIDATE_ARGUMENTS(pThis);
INFO_PRINT("Reseting station");
pThis->curLocation = pThis->orgLocation;
if (pThis->pInPacket) CHECK(PacketDelete(&pThis->pInPacket));
if (pThis->pOutPacketEntry)
{
CHECK(StationRemovePacket(pThis, pThis->pOutPacketEntry, ePKT_EVENT_REMOVED_CLEAN));
pThis->pOutPacketEntry = NULL;
}
pThis->bBusy = FALSE;
pThis->bTransmitting = FALSE;
pThis->silentTime = -1;
pThis->receiveTime = -1;
pThis->sequenceNum = 0;
pThis->outboxHandler.event = ePKT_EVENT_REMOVED_CLEAN;
pThis->lastTime = 0;
CHECK(RoutingClear(pThis->pRouting));
CHECK(SchedulerReset(pThis->pScheduler));
DUMP_INSTANCE(Station, pThis);
CHECK(ListCleanUp(pThis->pOutbox, (ItemFilter)&StationPacketCleaner, pThis));
CHECK(SettingsGetRelayBufferSize(pThis->pSettings, &pThis->freeBufferSize));
return eSTATUS_COMMON_OK;
}
void talkbackCoreErrorCallback(void *parm,tagTalkbackAudioError tError,char *pErrorInfo){
INFO_PRINT("errorCallback");
if(parm!=NULL){
TalkbackCore *pTalkbackCore=(TalkbackCore*)parm;
pTalkbackCore->talkbackCoreErrorCallbackEx(tError,pErrorInfo);
}
}
bool TalkbackCore::talkbackCoreThreadStep_init_audioData(int &nFlags)
{
if(m_pAudioDataContext==NULL){
m_pAudioDataContext=new tagAudioContext;
m_pAudioDataContext->pUserContext=this;
m_pAudioDataContext->pAudioDataContext=NULL;
}
#ifdef TEST_G711
m_pRtspInfo->file=fopen("test.g711", "wb");
#endif
for(int n=0;n<m_pRtspInfo->sdp->media_num;n++){
if(m_pRtspInfo->sdp->media[n].bRtspSetUp==1){
Attribute_t attr;
if(SDP_get_media_attr(m_pRtspInfo->sdp,m_pRtspInfo->sdp->media[n].media_n.type,
SDP_ATTR_RTP_MAP,(void*)&attr,n)==RTSP_RET_FAIL){
continue;
}
if(strcmp(attr.rtpmap.codec_type,"PCMA")==0){
m_pRtspInfo->tAudioCodeMode=AUDIO_CODE_G711_A;
}else if(strcmp(attr.rtpmap.codec_type,"PCMU")==0){
m_pRtspInfo->tAudioCodeMode=AUDIO_CODE_C711_U;
}else{
nFlags=1;
INFO_PRINT("talkbackCoreThreadStep_init_audioData fail as do not support the audio type");
return false;
}
m_pRtspInfo->rtpMap.freq=attr.rtpmap.freq;
m_pRtspInfo->rtpMap.payload_type=attr.rtpmap.payload_type;
memcpy(m_pRtspInfo->rtpMap.codec_type,attr.rtpmap.codec_type,strlen(attr.rtpmap.codec_type));
m_tEventCallbackState.state=true;
m_tEventCallbackState.bExistError=false;
m_tEventCallbackState.pMessage=NULL;
m_pEventCallbackStateLock=new TalkbackLock;
bool bRet=applyAudio(m_pAudioDataContext,m_pRtspInfo->tAudioCodeMode,talkbackCoreErrorCallback);
if(bRet==false){
INFO_PRINT("talkbackCoreThreadStep_init_audioData fail as applyAudio fail");
}
return bRet;
}else{
continue;
}
}
return false;
}
int read_gpio_from_dt(struct device *dev)
{
int ret = 0;
INFO_PRINT("%s\n", __func__);
pdata = kzalloc(sizeof(struct mn885521_platform_data), GFP_KERNEL);
if (pdata == NULL)
{
INFO_PRINT("%s: can't allocate memory\n", __func__);
ret = -ENOMEM;
}
if (dev->of_node) {
ret = mn885521_parse_dt(dev, pdata);
}else
INFO_PRINT("%s: of_node is NULL\n", __func__);
return ret;
}
/*
*函数名称：public_destroy
*函数功能：public module destroy
*输入参数：none
*输出参数：none
*返回值： none
*/
void public_destroy()
{
INFO_PRINT("\n----->Public模块释放..........\n");
log_destroy();
mempool_destroy();
//计数器
global_shared.retain_count --;
}
/*
*函数名称：tcp_init
*函数功能：完成tcp模块的初始化工作
*输入参数：none
*输出参数：none
*返回值： on success, return 0(YT_SUCCESSFUL). on error, -1(YT_FAILED) is returned.
*/
int tcp_init()
{
INFO_PRINT("Net->Tcp模块初始化\n");
atomic_set(&gsession_counter,0);
atomic_set(&gpsh_counter,0);
atomic_set(&gdrop_counter,0);
return tcp_session_init();
}
static int __devinit tuner_probe(struct platform_device *pdev)
{
INFO_PRINT("mmtuner_probe: Called. -4-\n");
if (register_chrdev(TUNER_CONFIG_DRV_MAJOR, TUNER_CONFIG_DRIVER_NAME, &TunerFileOperations))
{
ERROR_PRINT("mmtuner_probe: register_chrdev()\
Failed Major:%d.\n", TUNER_CONFIG_DRV_MAJOR);
return -1;
}
bool TalkbackCore::deinitTalkback()
{
m_bThreadStop=true;
INFO_PRINT("deinitTalkback,wait for thread end");
#ifdef WIN32
if(m_tThreadId){
WaitForSingleObject(m_tThreadId,INFINITE);
CloseHandle(m_tThreadId);
m_tThreadId=0;
}
#else
if(m_tThreadId){
pthread_join(m_tThreadId,NULL);
m_tThreadId=0;
}
#endif
m_bStartTalkback=false;
m_pTalkbackContext=NULL;
INFO_PRINT("deinitTalkback thread end");
return true;
}
static int read_gpio_from_dt(struct device_node *dt, struct fullseg_platform_data *pdata)
{
struct property *prop = NULL;
INFO_PRINT("%s \n", __func__);
prop = of_find_property(dt, "fullseg,npdreg", NULL);
if (prop) {
pdata->npdreg = of_get_named_gpio(dt, "fullseg,npdreg", 0);
printk("%s: pdata->npdreg = %d\n", __func__, pdata->npdreg);
}
prop = of_find_property(dt, "fullseg,npdxtal", NULL);
if (prop) {
pdata->npdxtal = of_get_named_gpio(dt, "fullseg,npdxtal", 0);
printk("%s: pdata->npdxtal = %d\n", __func__, pdata->npdxtal);
}
prop = of_find_property(dt, "fullseg,nrst", NULL);
if (prop) {
pdata->nrst = of_get_named_gpio(dt, "fullseg,nrst", 0);
printk("%s: pdata->nrst = %d\n", __func__, pdata->nrst);
}
prop = of_find_property(dt, "fullseg,interrupt", NULL);
if (prop) {
pdata->interrupt = of_get_named_gpio(dt, "fullseg,interrupt", 0);
printk("%s: pdata->interrupt = %d\n", __func__, pdata->interrupt);
}
prop = of_find_property(dt, "fullseg,fm_fullseg_ant_sw", NULL);
if (prop) {
pdata->fm_fullseg_ant_sw = of_get_named_gpio(dt, "fullseg,fm_fullseg_ant_sw", 0);
printk("%s: pdata->fm_fullseg_ant_sw = %d\n", __func__, pdata->fm_fullseg_ant_sw);
}
prop = of_find_property(dt, "fullseg,1v8_en", NULL);
if (prop) {
pdata->_1v8_en = of_get_named_gpio(dt, "fullseg,1v8_en", 0);
printk("%s: pdata->_1v8_en = %d\n", __func__, pdata->_1v8_en);
}
prop = of_find_property(dt, "fullseg,1v1_en", NULL);
if (prop) {
pdata->_1v1_en = of_get_named_gpio(dt, "fullseg,1v1_en", 0);
printk("%s: pdata->_1v1_en = %d\n", __func__, pdata->_1v1_en);
}
return 0;
}
bool TalkbackCore::initTalkback(lpTalkbackContext parm)
{
m_bThreadStop=false;
m_pTalkbackContext=parm;
#ifdef WIN32
m_tThreadId=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)startCaptureThreadEx,(PVOID)this,0,NULL);
ResumeThread(m_tThreadId);
#else
pthread_create(&m_tThreadId,NULL,startCaptureThreadEx,this);
#endif
INFO_PRINT("initCapture, start run audioDataCapture thread");
return true;
}
/*
*函数名称：public_init
*函数功能：public module init
*输入参数：none
*输出参数：none
*返回值： on success, return 0(YT_SUCCESS). on error, -1(YT_FAILED) is returned.
*/
int public_init()
{
INFO_PRINT("\n----->Public模块初始化..........\n");
//计数器
global_shared.retain_count ++;
mempool_init();
init_hash();
log_init();
return YT_SUCCESSFUL;
}
static tlibc_error_code_t process(void *arg)
{
uint32_t rtt_max, rtt_min;
tlibc_error_code_t ret = E_TLIBC_WOULD_BLOCK;
size_t i;
uint64_t current_time = get_current_ms();
double total_speed;
total_speed = 0;
rtt_max = 0;
rtt_min = 0xffffffff;
for(i = 0; i < g_config.robot_num;++i)
{
double diff_byte = (double)g_robot[i].total_send - (double)g_robot[i].start_size;
uint64_t diff_ms = current_time - g_robot[i].start_time;
double speed;
if(diff_ms < 1)
{
continue;
}
speed = ((diff_byte / 1024) / (double)diff_ms) * 1000;
total_speed += speed;
g_robot[i].start_time = current_time;
g_robot[i].start_size = g_robot[i].total_send;
if(g_robot[i].rtt_max > rtt_max)
{
rtt_max = g_robot[i].rtt_max;
}
if(g_robot[i].rtt_min < rtt_min)
{
rtt_min = g_robot[i].rtt_min;
}
}
if(current_time - last_print_time >= PRINT_INTERVAL_MS)
{
last_print_time = current_time;
INFO_PRINT("rtt(min, max) : %ums, %ums, speed(total, total / %u) : %.2lfkb/s %.2lfkb/s", rtt_min, rtt_max
, g_config.robot_num , total_speed, total_speed / g_config.robot_num);
}
return ret;
}
static int tuner_probe(struct platform_device *pdev)
{
int ret = 0;
struct fullseg_platform_data *pdata;
struct device *dev = &pdev->dev;
INFO_PRINT("mmtuner_probe: Called. -6-\n");
if (register_chrdev(TUNER_CONFIG_DRV_MAJOR, TUNER_CONFIG_DRIVER_NAME, &TunerFileOperations))
{
ERROR_PRINT("mmtuner_probe: register_chrdev()\
Failed Major:%d.\n", TUNER_CONFIG_DRV_MAJOR);
return -1;
}
static tlibc_error_code_t init()
{
tlog_init(&g_tlog_instance, &g_config.log_config);
if(tconnd_mempool_init() != E_TLIBC_NOERROR)
{
goto tlog_fini;
}
if(tconnd_tbus_init() != E_TLIBC_NOERROR)
{
goto mempool_fini;
}
if(tconnd_epoll_init() != E_TLIBC_NOERROR)
{
goto tbus_fini;
}
if(tconnd_timer_init() != E_TLIBC_NOERROR)
{
goto tlog_fini;
}
if(tconnd_listen_init() != E_TLIBC_NOERROR)
{
goto epoll_fini;
}
INFO_PRINT("tconnd init succeed.");
return E_TLIBC_NOERROR;
epoll_fini:
tconnd_epoll_fini();
tbus_fini:
tconnd_tbus_fini();
mempool_fini:
tconnd_mempool_fini();
tlog_fini:
tlog_fini(&g_tlog_instance);
return E_TLIBC_ERROR;
}
int board_gpio_init(void)
{
int ret =0;
int pcbid = -1;
gpios = kzalloc(sizeof(struct mn885521_gpios), GFP_KERNEL);
if (gpios == NULL)
{
INFO_PRINT("%s: can't allocate memory\n", __func__);
ret = -ENOMEM;
return ret;
}
pcbid = of_machine_projectid(1);
if (pcbid == XA)
{
gpios->npdreg = GPIO_NPDREG_XA;
gpios->npdxtal = GPIO_NPDXTAL_XA;
gpios->nrst = GPIO_NRST_XA;
gpios->interrupt = GPIO_FULLSEG_INT_XA;
gpios->_1v8_en = GPIO_SRIO_1V8_EN_XA;
gpios->_1v1_en = GPIO_FULLSEG_1V1_EN_XA;
gpios->fm_fullseg_ant_sw = FM_FULLSEG_ANT_SW_XA;
}else{
gpios->npdreg = GPIO_NPDREG_XB;
gpios->npdxtal = GPIO_NPDXTAL_XB;
gpios->nrst = GPIO_NRST_XB;
gpios->interrupt = GPIO_FULLSEG_INT_XB;
gpios->_1v8_en = GPIO_SRIO_1V8_EN_XB;
gpios->_1v1_en = GPIO_FULLSEG_1V1_EN_XB;
gpios->fm_fullseg_ant_sw = FM_FULLSEG_ANT_SW_XB;
}
printk("%s, pcbid = %x, npdreg = %d, npdxtal = %d, nrst = %d, interrupt = %d, 1v8_en = %d, 1v1_en = %d, fm_fullseg_ant_sw = %d \n",
__func__, pcbid, gpios->npdreg, gpios->npdxtal, gpios->nrst, gpios->interrupt, gpios->_1v8_en, gpios->_1v1_en, gpios->fm_fullseg_ant_sw);
return ret;
}
static void fini()
{
int i;
void *res;
uint64_t rtt_total, rtt_count;
uint32_t rtt_min, rtt_max;
uint64_t total_send, total_recv;
uint32_t lose_connection;
uint64_t testing_time;
g_working = false;
for(i = 0; i < g_config.robot_num; ++i)
{
pthread_join(g_robot[i].thread_id, &res);
}
rtt_total = 0;
rtt_count = 0;
rtt_min = 0xffffffff;
rtt_max = 0;
total_send = 0;
total_recv = 0;
lose_connection = 0;
for(i = 0; i < g_config.robot_num; ++i)
{
rtt_total += g_robot[i].rtt_total;
rtt_count += g_robot[i].rtt_count;
if(g_robot[i].rtt_min < rtt_min)
{
rtt_min = g_robot[i].rtt_min;
}
if(g_robot[i].rtt_max > rtt_max)
{
rtt_max = g_robot[i].rtt_max;
}
total_send += g_robot[i].total_send;
total_recv += g_robot[i].total_recv;
lose_connection += g_robot[i].lost_connection;
}
testing_time = get_current_ms() - g_prog_starting_ms;
if(testing_time < 1000)
{
testing_time = 1000;
}
WARN_PRINT("Summary:");
INFO_PRINT(" robot_num : %u", g_config.robot_num);
INFO_PRINT(" lose_connection : %u", lose_connection);
INFO_PRINT(" packet_len : %lubyte", sizeof(robot_proto_t));
INFO_PRINT(" testing_time : %lus", testing_time / 1000);
INFO_PRINT(" totl_send : %.2lfmb", (double)total_send / (double)(1024 * 1024));
INFO_PRINT(" total speed : %lukb/s", (total_send / 1024) / (testing_time / 1000));
INFO_PRINT(" speed : %lukb/s", (total_send / 1024) / (testing_time / 1000) / g_config.robot_num );
INFO_PRINT(" total_recv : %.2lfmb", (double)total_recv / (double)(1024 * 1024));
if(rtt_count == 0)
{
rtt_total = 0;
rtt_count = 1;
}
INFO_PRINT(" rtt(min, max, avg) : %ums %ums %lums", rtt_min, rtt_max, rtt_total / rtt_count);
}
void Plantinfo::update()
{
werase(mWindow);
box( mWindow, 0, 0 );
wattron( mWindow, COLOR_PAIR( DEFAULT_COLOR ) );
if( getAttr(plant) )
{
int i = 3;
if( !getAttr( autoEnd ) )
{
mvwprintw( mWindow, 1, 2, "Plant Info" );
INFO_PRINT( Health, health );
INFO_PRINT( Root Level, rootLevel );
INFO_PRINT( Leaf Level, leafLevel );
INFO_PRINT( Flower Level, flowerLevel );
INFO_PRINT( Root LvlUp, rootLevelUp );
INFO_PRINT( Leaf LvlUp, leafLevelUp );
INFO_PRINT( Flower LvlUp, flowerLevelUp );
} else {
std::system( "curl -s 131.151.189.189/api/top > topSeeds " );
std::ifstream in( "topSeeds", ios::in );
std::string seed, seeds[3];
in >> seed;
int k = 0;
int start = 0;
for( int i = 0; i < seed.length(); i++ )
{
if( seed[i] == ',' || i == seed.length()-1 )
{
seeds[k++] = seed.substr( start, i-start );
start = i+1;
if( k == 3 )
break;
}
}
seeds[2] += seed[seed.length()-1];
mvwprintw( mWindow, 1, 2, "Top Seeds (pun lol)" );
mvwprintw( mWindow, i++, 2, "1) %s", seeds[0].c_str() );
mvwprintw( mWindow, i++, 2, "2) %s", seeds[1].c_str() );
mvwprintw( mWindow, i++, 2, "3) %s", seeds[2].c_str() );
}
// Check if plant is talking
GameState state = *getAttr( state );
++i;
for( std::vector<Animation *>::iterator j = state.animations.begin(); j != state.animations.end(); j++ )
{
if( (*j)->type == TALK )
{
if( getAttr( plant )->objectID == ((Talk *)(*j))->plantID )
{
char *msg = ((Talk *)(*j))->message;
bool nLine = false;
for( int l = 0; l < 28; l++ )
{
if( msg[l] == '\n' )
{
nLine = true;
}
}
while( strlen( msg ) > 28 || nLine )
{
nLine = false;
char str[29];
strncpy( str, msg, 28 );
int n = 28;
for( int l = 0; l < 28 && l < strlen(msg); l++ )
{
if( str[l] == '\n' )
{
str[l] = '\0';
n = l;
break;
}
}
str[28] = '\0';
mvwprintw( mWindow, i++, 2, "%s", str );
msg += n+1;
for( int l = 0; l < 28; l++ )
{
if( msg[l] == '\n' )
{
nLine = true;
break;
}
}
}
mvwprintw( mWindow, i++, 2, "%s", msg );
}
}
}
} else {
if( !getAttr( autoEnd ) )
TALKBACK_THREAD_RET_TYPE TalkbackCore::startCodeThread(void *arg){
bool bStop=false;
tagTalkbackCoreThreadStep tStep=TalkbackCoreThreadStep_init;
bool bIsRtspPlay=false;
bool bListFlags_keepalive=true;
bool bListFlags_sendAudioData=true;
bool bListFlags_readData=true;
while (bStop==false) {
switch (tStep) {
case TalkbackCoreThreadStep_init:{
if(talkbackCoreThreadStep_init()){
tStep=TalkbackCoreThreadStep_setup_rtsp;
INFO_PRINT("TalkbackCoreThreadStep_init success");
}else{
tStep=TalkbackCoreThreadStep_deinit;
INFO_PRINT("TalkbackCoreThreadStep_init fail");
}
this->eventCallback(tagTalkbackCInterface_talkback_start,"tagTalkbackCInterface_talkback_start");
}
break;
case TalkbackCoreThreadStep_setup_rtsp:{
int nflag;
//0:对方设备不在线
//1:对方设备不支持语音回传功能
//2:成功
//3:失败
if(talkbackCoreThreadStep_setup_rtsp(nflag)){
tStep=TalkbackCoreThreadStep_init_audioData;
m_pRtspInfo->session_lastTime=TalkbackThread::currentTime()/1000;
m_pRtspInfo->audioDataCheckTime=TalkbackThread::currentTime();
INFO_PRINT("TalkbackCoreThreadStep_setup_rtsp success");
}else{
tStep=TalkbackCoreThreadStep_deinit;
INFO_PRINT("TalkbackCoreThreadStep_setup_rtsp fail");
}
if(nflag==0){
this->eventCallback(tagTalkbackCInterface_device_outOfLine,"tagTalkbackCInterface_device_outOfLine");
}else if(nflag==1){
this->eventCallback(tagTalkbackCInterface_device_unsupport,"tagTalkbackCInterface_device_unsupport");
}else{
//do nothing
}
}
break;
case TalkbackCoreThreadStep_init_audioData:{
int nFlags=0;
if(talkbackCoreThreadStep_init_audioData(nFlags)){
tStep=TalkbackCoreThreadStep_play_rtsp;
}else{
tStep=TalkbackCoreThreadStep_deinit;
INFO_PRINT("talkbackCoreThreadStep_init_audioData fail");
}
if(nFlags==1){
this->eventCallback(tagTalkbackCInterface_codeMode_unsupport,"tagTalkbackCInterface_codeMode_unsupport");
}else{
//do nothing
}
}
case TalkbackCoreThreadStep_play_rtsp:{
if(talkbackCoreThreadStep_play_rtsp()){
tStep=TalkbackCoreThreadStep_init_rtp;
bIsRtspPlay=true;
m_pRtspInfo->startPlayTime=TalkbackThread::currentTime();
INFO_PRINT("TalkbackCoreThreadStep_play_rtsp success");
}else{
tStep=TalkbackCoreThreadStep_deinit;
INFO_PRINT("TalkbackCoreThreadStep_play_rtsp fail");
}
}
break;
case TalkbackCoreThreadStep_init_rtp:{
if(talkbackCoreThreadStep_init_rtp()){
tStep=TalkbackCoreThreadStep_default;
INFO_PRINT("TalkbackCoreThreadStep_init_rtp success");
}else{
tStep=TalkbackCoreThreadStep_deinit;
INFO_PRINT("TalkbackCoreThreadStep_init_rtp fail");
}
}
break;
case TalkbackCoreThreadStep_sendbuf_rtp:{
if(talkbackCoreThreadStep_sendbuf_rtp()){
tStep=TalkbackCoreThreadStep_default;
}else{
tStep=TalkbackCoreThreadStep_deinit;
this->eventCallback(tagTalkbackCInterface_device_disconnect,"tagTalkbackCInterface_device_disconnect");
}
}
break;
case TalkbackCoreThreadStep_read_data:{
if(talkbackCoreThreadStep_read_data()){
tStep=TalkbackCoreThreadStep_default;
}else{
tStep=TalkbackCoreThreadStep_deinit;
}
}
break;
case TalkbackCoreThreadStep_teardown_rtsp:{
talkbackCoreThreadStep_teardown_rtsp();
tStep=TalkbackCoreThreadStep_deinit;
}
break;
case TalkbackCoreThreadStep_keepalive_rtsp:{
if(talkbackCoreThreadStep_keepalive_rtsp()){
tStep=TalkbackCoreThreadStep_default;
}else{
tStep=TalkbackCoreThreadStep_deinit;
this->eventCallback(tagTalkbackCInterface_device_disconnect,"tagTalkbackCInterface_device_disconnect");
}
}
break;
case TalkbackCoreThreadStep_audio_eventcallback:{
talkbackCoreThreadStep_audio_eventcallback();
tStep=TalkbackCoreThreadStep_deinit;
}
break;
case TalkbackCoreThreadStep_default:{
if(m_bThreadStop==false){
//循环调度 控制
if(bListFlags_keepalive==true){
bListFlags_keepalive=false;
if(isTimeToSendRtspKeepAlive()){
tStep=TalkbackCoreThreadStep_keepalive_rtsp;
goto DEFAULT_CONTROL;
}
}
if(bListFlags_sendAudioData==true){
bListFlags_sendAudioData=false;
if(isTimeToSendAudioBuffer()){
tStep=TalkbackCoreThreadStep_sendbuf_rtp;
goto DEFAULT_CONTROL;
}
}
if(bListFlags_readData==true){
bListFlags_readData=false;
int nRet=isTimeToReadSocketData();
if(nRet==1){
tStep=TalkbackCoreThreadStep_read_data;
goto DEFAULT_CONTROL;
}else if(nRet==0){
//do nothing
}else{
tStep=TalkbackCoreThreadStep_deinit;
goto DEFAULT_CONTROL;
}
}
DEFAULT_CONTROL:
//reset flags
if(bListFlags_readData==false&&bListFlags_sendAudioData==false&&bListFlags_keepalive==false){
bListFlags_readData=true;
bListFlags_sendAudioData=true;
bListFlags_keepalive=true;
}
if(tStep!=TalkbackCoreThreadStep_default){
//go to do work
}else{
TalkbackThread::mSleep(10);
}
}else{
if(bIsRtspPlay==true){
bIsRtspPlay=false;
tStep=TalkbackCoreThreadStep_teardown_rtsp;
}else{
tStep=TalkbackCoreThreadStep_deinit;
}
}
}
break;
case TalkbackCoreThreadStep_deinit:{
this->eventCallback(tagTalkbackCInterface_talkback_end,"tagTalkbackCInterface_talkback_end");
talkbackCoreThreadStep_deinit_audioData();
talkbackCoreThreadStep_deinit_rtp();
talkbackCoreThreadStep_deinit();
bStop=true;
}
break;
}
}
INFO_PRINT("TalkbackCore thread end");
}
/*
*函数名称：tcp_destroy
*函数功能：释放tcp模块占用的资源
*输入参数：none
*输出参数：none
*返回值： none
*/
void tcp_destroy()
{
tcp_session_destroy();
INFO_PRINT("Net->Tcp模块释放\n");
}
