GBbool gbLoadRLE (char* path, const char* filename, GBuint16* height, GBuint16** data)
{
FILE* f;
GBuint16* out;
GBuint16 totalCount;
GB_ASSERT(path && filename && height && data);
f = gbOpenFileFromPath(path, filename, "rb");
if (!f)
return GB_FALSE;
fread(&totalCount, sizeof(GBuint16), 1, f);
fread(height, sizeof(GBuint16), 1, f);
out = (GBuint16*)malloc(sizeof(GBuint16) * ((*height) + totalCount * 2));
if (!out)
{
fclose(f);
return GB_FALSE;
}
fread(out, sizeof(GBuint16), (*height) + totalCount * 2, f);
fclose(f);
*data = out;
return GB_TRUE;
}
void* GBMemory_alloc (GBMemory* mem, GBuint32 bytes)
{
GBAllocBlock* block;
void* ptr;
GB_ASSERT(mem);
if (mem->used + bytes > mem->limit)
return NULL;
ptr = malloc(bytes);
if (!ptr)
return NULL;
block = GBAllocBlock_create(ptr, bytes);
if (!block)
{
free(ptr);
return NULL;
}
mem->used += bytes;
block->next = mem->firstBlock;
mem->firstBlock = block;
return ptr;
}
void GBMemory_free (GBMemory* mem, void* ptr)
{
GBAllocBlock* last = NULL;
GBAllocBlock* block;
GB_ASSERT(mem);
if (!ptr)
return;
block = mem->firstBlock;
while (block)
{
if (block->ptr == ptr)
{
if (last)
last->next = block->next;
else
mem->firstBlock = block->next;
mem->used -= block->bytes;
GBAllocBlock_destroy(block);
return;
}
last = block;
block = block->next;
}
}
int gb28181_init_env(pSipEnv *env)
{
TRACE("Init GB28181 env\n");
//constly
SYSCONF_t *sysconf = SYSCONF_dup();
pSipEnv p = (pSipEnv)calloc(1,sizeof(sSipEnv));
*env = p;
char devip[20];
SOCK_gethostname(devip);
GB_ASSERT(*env,"Calloc env Node failed\n");
printf("calloc env hdr node %p\n",*env);
SIP_ENV_insert(p,"Model",sysconf->ipcam.info.device_model);
SIP_ENV_insert(p,"UserAgent",sysconf->ipcam.info.device_name);
SIP_ENV_insert(p,"Firmware",sysconf->ipcam.info.software_version);
SIP_ENV_insert(p,"MaxAlarm","1");
SIP_ENV_insert(p,"MaxCamera","1");
SIP_ENV_insert(p,"Manufacturer","JUAN");
// variable
Gb28181Conf_t gb_conf;
memset(&gb_conf, 0, sizeof(Gb28181Conf_t));
gb28181_read_env(&gb_conf,sizeof(Gb28181Conf_t));
if(strlen(gb_conf.SipServerId) > 0)
//if(0)
{
TRACE("use the env in the flash,SipServerId:%s:%d\n",gb_conf.SipServerId,
strlen(gb_conf.SipServerId));
SIP_ENV_insert(p,"Realm",gb_conf.LoginDomain);
SIP_ENV_insert(p,"SipServerId",gb_conf.SipServerId);
SIP_ENV_insert(p,"SipServerIp",gb_conf.SipServerIp);
SIP_ENV_insert(p,"SipServerPort",ITOA(gb_conf.SipServerPort));
SIP_ENV_insert(p,"UserId",gb_conf.UserId);
SIP_ENV_insert(p,"UserPwd",gb_conf.UserPwd);
SIP_ENV_insert(p,"DevPort",ITOA(GB28181_DEFAULT_DEV_PORT));
SIP_ENV_insert(p,"DevIp",devip);
SIP_ENV_insert(p,"AliveTime",ITOA(gb_conf.AliveTime));
SIP_ENV_insert(p,"HeartBeatTime",ITOA(gb_conf.HeartBeatTime));
SIP_ENV_insert(p,"Alarm1",gb_conf.AlarmId[0]);
SIP_ENV_insert(p,"Video1",gb_conf.VideoId[0]);
}
else{ // use the default gb28181 env
TRACE("NULL gb28181 env ,use default env\n");
gb28181_write_env(&def_gb_conf,sizeof(Gb28181Conf_t));
SIP_ENV_insert(p,"Realm",def_gb_conf.LoginDomain);
SIP_ENV_insert(p,"SipServerId",def_gb_conf.SipServerId);
SIP_ENV_insert(p,"SipServerIp",def_gb_conf.SipServerIp);
SIP_ENV_insert(p,"SipServerPort",ITOA(def_gb_conf.SipServerPort));
SIP_ENV_insert(p,"UserId",def_gb_conf.UserId);
SIP_ENV_insert(p,"UserPwd",def_gb_conf.UserPwd);
SIP_ENV_insert(p,"DevIp",devip);
SIP_ENV_insert(p,"DevPort",ITOA(GB28181_DEFAULT_DEV_PORT));
SIP_ENV_insert(p,"AliveTime",ITOA(def_gb_conf.AliveTime));
SIP_ENV_insert(p,"HeartBeatTime",ITOA(def_gb_conf.HeartBeatTime));
SIP_ENV_insert(p,"Alarm1",def_gb_conf.AlarmId[0]);
SIP_ENV_insert(p,"Video1",def_gb_conf.VideoId[0]);
}
return 0;
}
static int gb28181_read_env(unsigned char *addr,int len)
{
SYSCONF_t* sys_conf = SYSCONF_dup();
GB_ASSERT(len < sizeof(sys_conf->ipcam.gb28181_param), "No space in sysconf for Gb28181");
memcpy(addr, sys_conf->ipcam.gb28181_param.buf, len);
TRACE("Read Gb28181 param from flash size = %d\n", len);
return 0;
}
static int gb28181_write_env(unsigned char *addr,int len)
{
SYSCONF_t* sys_conf = SYSCONF_dup();
GB_ASSERT(len < sizeof(sys_conf->ipcam.gb28181_param), "No space in sysconf for GB28181");
memcpy(sys_conf->ipcam.gb28181_param.buf, addr, len);
SYSCONF_save(sys_conf); // save to flash
TRACE("Write Gb28181 param to flash size = %d\n", len);
return 0;
}
void *gb28181_alarm_loop(void* session)
{
GB_ASSERT(session,"NULL sip session handle\n");
pSipSession s = (pSipSession)session;
TRACE("now :%s\n",s->get_systime());
s->pack_msg(s,MSG_ALARM,NULL);
TRACE("send:\n%s\n",s->sendbuf);
sendto(s->sock,s->sendbuf,strlen(s->sendbuf),\
0,(struct sockaddr*)&s->server,sizeof(s->server));
}
void GBMemory_destroy (GBMemory* mem)
{
GB_ASSERT(mem);
#ifdef GB_DEVEL
if (mem->firstBlock)
printf("Error: Detected memory leaks\n");
#endif
free(mem);
}
GBAllocBlock* GBAllocBlock_create (void* ptr, GBuint32 bytes)
{
GBAllocBlock* block;
GB_ASSERT(ptr);
block = (GBAllocBlock*)malloc(sizeof(GBAllocBlock));
if (!block)
return NULL;
block->ptr = ptr;
block->bytes = bytes;
block->next = NULL;
return block;
}
void* gb28181_heartbeat_loop(void *session)
{
pSipSession s = (pSipSession)session;
GB_ASSERT(s,"heartbeat ,null argument\n");
time_t cur_time = time(NULL);
for(;;)
{
usleep(1);
if(time(NULL)- cur_time > s->heartbeat_time){//send a heartbeat
cur_time = time(NULL);
s->pack_msg(s,MSG_HEARTBEAT,NULL);
sendto(s->sock,s->sendbuf,strlen(s->sendbuf),\
0,(struct sockaddr*)&s->server,sizeof(s->server));
}
if(0 == s->online)break;
}
return NULL;
}
GBuint16 gbReadFromRLE (GBuint32 x, GBuint32 y, GBuint16* rle)
{
GB_ASSERT(rle);
while (y--)
rle += 1 + 2 * rle[0];
rle++;
while (x)
{
if (rle[0] > x)
{
x = 0;
}
else
{
x -= rle[0];
rle += 2;
}
}
return rle[1];
}
void* gb28181_msg_loop(void *session)
{
pSipSession s = (pSipSession)session;
GB_ASSERT(s,"sip_msg_loop null argument\n");
int re_cnt = 0;
char msg_buf[2048];
char *ptzcmd = NULL;
s->run_msg_loop = 1;//that's to say msg_loop is run now;
char *cmdtype = s->get_tagvalue(s->xml_str,"CmdType");
if( 0 == strcmp("DeviceInfo",cmdtype))
{
TRACE("Get a dev info request\n");
s->pack_msg(s,MSG_DEV_INFO,NULL);
}
else if(0 == strcmp("DeviceStatus",cmdtype))
{
TRACE("Get a devicestatus request\n");
s->pack_msg(s,MSG_DEV_STATUS,NULL);
}
else if(0 == strcmp("Alarm",cmdtype))
{
s->pack_msg(s,MSG_200,NULL);
sendto(s->sock,s->sendbuf,strlen(s->sendbuf),\
0,(struct sockaddr*)&s->server,sizeof(s->server));
goto exit_msg_loop;
}
else if (0 == strcmp("DeviceControl",cmdtype))
{
if(0 == s->get_subcmd(s,s->xml_str,"RecordCmd","Record"))
{
s->pack_msg(s,MSG_DEV_CTRL,NULL);
s->dev_ctrl(SIP_DEV_CTRL_RECORD_START,NULL);
}
else if(0 == s->get_subcmd(s,s->xml_str,"RecordCmd","StopRecord"))
{
s->pack_msg(s,MSG_DEV_CTRL,NULL);
s->dev_ctrl(SIP_DEV_CTRL_RECORD_STOP,NULL);
}
else if(0 == s->get_subcmd(s,s->xml_str,"GuardCmd","SetGuard"))
{
s->pack_msg(s,MSG_DEV_CTRL,NULL);
s->dev_ctrl(SIP_DEV_CTRL_GUARD_SET,NULL);
}
else if(0 == s->get_subcmd(s,s->xml_str,"GuardCmd","ResetGuard"))
{
s->pack_msg(s,MSG_DEV_CTRL,NULL);
s->dev_ctrl(SIP_DEV_CTRL_GUARD_RESET,NULL);
}
else if(0 == s->get_subcmd(s,s->xml_str,"AlarmCmd","ResetAlarm"))
{
s->pack_msg(s,MSG_DEV_CTRL,NULL);
char *method = s->get_tagvalue(s->xml_str,"AlarmMethod");
s->dev_ctrl(SIP_DEV_CTRL_ALARM_RESET,method);
}
else if(NULL != (ptzcmd = s->get_tagvalue(s->xml_str,"PTZCmd")))
{
s->ptz_cmd_parse(s,ptzcmd);
s->pack_msg(s,MSG_200,NULL);
sendto(s->sock,s->sendbuf,strlen(s->sendbuf),\
0,(struct sockaddr*)&s->server,sizeof(s->server));
goto exit_msg_loop;
}
else if(0 == s->get_subcmd(s,s->xml_str,"TeleBoot","Boot"))
{
//login out the sipserver first
s->pack_msg(s,MSG_200,NULL);
sprintf(msg_buf,"%s",s->sendbuf);
s->dev_ctrl(SIP_DEV_CTRL_TELEBOOT,NULL);
GB_NOTIFY("Loginout ing...\n ");
s->auth(s,0); //FIXME this func need 2 do in dev_ctrl later
sendto(s->sock,msg_buf,strlen(msg_buf),\
0,(struct sockaddr*)&s->server,sizeof(s->server));
sleep(1);
GB_NOTIFY("Login ing...\n ");
s->auth(s,1);
goto exit_msg_loop;
}
}
else if( 0 == strcmp("Catalog",cmdtype))
{
TRACE("Recv a Catalog msg\n");
s->pack_msg(s,MSG_CATALOG,NULL);
}
sprintf(msg_buf,"%s",s->sendbuf);
TRACE("\033[31mSIP PACK MSG:%s\n\033[0m",s->sendbuf);
time_t cur_time = time(NULL) - 4;
for(;;)
{
if(time(NULL)- cur_time > 3){//response a msg
sendto(s->sock,msg_buf,strlen(msg_buf),\
0,(struct sockaddr*)&s->server,sizeof(s->server));
cur_time = time(NULL);
if(++re_cnt >= 3)break;
}
usleep(1);
if(0 == s->run_msg_loop)break;
}
exit_msg_loop:
GB_ERROR("Exit the msg loop\n");
if(NULL != s->xml_str)
{
free(s->xml_str);
s->xml_str = NULL;
}
return NULL;
}
void GBAllocBlock_destroy (GBAllocBlock* block)
{
GB_ASSERT(block);
free(block->ptr);
free(block);
}
