long r_map_gckey_add_d(rmap_t *map, rgc_t* gc, double name, rconstpointer pval)
{
char key[128];
r_memset(key, 0, sizeof(key));
r_snprintf(key, sizeof(key) - 1, "%.15f", name);
return r_map_gckey_add_s(map, gc, key, pval);
}
rbuffer_t *r_buffer_create(unsigned long size)
{
rbuffer_t *buffer;
buffer = (rbuffer_t *)r_malloc(sizeof(rbuffer_t));
if (!buffer)
return (void*)0;
r_memset(buffer, 0, sizeof(*buffer));
if (!(buffer->s = (char *)r_malloc((size + 1) * sizeof(char)))) {
r_free(buffer);
return (void*)0;
}
r_memset(buffer->s, 0, size + 1);
buffer->size = size;
return buffer;
}
unsigned long r_carray_replace(rcarray_t *carray, unsigned long index, rconstpointer data)
{
if (data)
r_memcpy(r_carray_slot_expand(carray, index), data, carray->elt_size);
else
r_memset(r_carray_slot_expand(carray, index), 0, carray->elt_size);
return index;
}
long rex_compiler_setblanks(rexcompiler_t *co, const char *str, unsigned int size)
{
if (size + 1 > sizeof(co->blankchars))
return -1;
r_memset(co->blankchars, 0, sizeof(co->blankchars));
r_strncpy(co->blankchars, str, sizeof(co->blankchars) - 1);
return 0;
}
rvmreg_t rvm_reg_create_string(const rstr_t *s)
{
rvmreg_t r;
r_memset(&r, 0, sizeof(r));
RVM_REG_SETP(&r, r_string_create_from_rstr(s));
RVM_REG_SETTYPE(&r, RVM_DTYPE_STRING);
RVM_REG_SETFLAG(&r, RVM_INFOBIT_ROBJECT);
return r;
}
rexcompiler_t *rex_compiler_create()
{
rexcompiler_t *co;
co = (rexcompiler_t *)r_malloc(sizeof(*co));
r_memset(co, 0, sizeof(*co));
r_strncpy(co->blankchars, " \t", sizeof(co->blankchars) - 1);
co->stack = r_array_create(sizeof(rexfragment_t*));
co->temptrans = r_array_create(sizeof(rex_transition_t));
return co;
}
rpa_compiler_t *rpa_compiler_create()
{
rpa_compiler_t *co;
co = (rpa_compiler_t *)r_malloc(sizeof(*co));
r_memset(co, 0, sizeof(*co));
co->cg = rvm_codegen_create();
co->scope = rvm_scope_create();
co->expressions = r_array_create(sizeof(rpa_ruledef_t));
co->ruleprefs = r_harray_create(sizeof(rpa_rulepref_t));
return co;
}
static long rpa_codegen_invalid_add_numlabel_s(rvm_codegen_t *cg, const char *alphaname, long numname)
{
#if 0
/*
* The alphaname and numname, might be used for
* debugging at some point, but not used for now
*/
char label[128];
r_memset(label, 0, sizeof(label));
r_snprintf(label, sizeof(label) - 1, "L%07ld__%s:", numname, alphaname);
return rvm_codegen_invalid_addlabel_s(cg, label);
#else
return rvm_codegen_invalid_addlabel_s(cg, NULL);
#endif
}
long rpa_compiler_addblob(rpa_compiler_t *co, long ruleid, long ruleuid, unsigned long flags, const char *name, unsigned long namesize)
{
char blob[RPA_RULEBLOB_SIZE];
char *ptr;
rpa_ruledata_t *pblob = (rpa_ruledata_t *)blob;
if (namesize >= RPA_RULENAME_MAXSIZE)
return -1;
r_memset(pblob, 0, RPA_RULEBLOB_SIZE);
ptr = blob + sizeof(rpa_ruledata_t);
pblob->name = (unsigned long)(ptr - blob);
pblob->ruleid = ruleid;
pblob->ruleuid = ruleuid;
pblob->flags = flags;
pblob->namesize = namesize;
r_strncpy(ptr, name, namesize);
ptr += namesize;
pblob->size = (long)(ptr - blob + 1);
return rvm_codegen_adddata_s(co->cg, NULL, pblob, pblob->size);
}
/*
* The state must have all transitions in place, otherwise they
* will not be added to the dangling array.
*/
rexfragment_t *rex_fragment_create(rexstate_t *state)
{
long i;
rex_transition_t *t;
rexfragment_t *frag;
frag = (rexfragment_t*)r_malloc(sizeof(*frag));
r_memset(frag, 0, sizeof(*frag));
frag->dangling = r_array_create(sizeof(rex_transition_t*));
frag->sstate = state;
for (i = 0; i < r_array_length(state->trans); i++) {
t = (rex_transition_t *)r_array_slot(state->trans, i);
if (t->dstuid < 0)
r_array_add(frag->dangling, &t);
}
for (i = 0; i < r_array_length(state->etrans); i++) {
t = (rex_transition_t *)r_array_slot(state->etrans, i);
if (t->dstuid < 0)
r_array_add(frag->dangling, &t);
}
return frag;
}
void rvm_reg_setdouble(rvmreg_t *r, double d)
{
r_memset(r, 0, sizeof(*r));
RVM_REG_SETD(r, d);
RVM_REG_SETTYPE(r, RVM_DTYPE_DOUBLE);
}
void rvm_reg_setsigned(rvmreg_t *r, rword l)
{
r_memset(r, 0, sizeof(*r));
RVM_REG_SETL(r, l);
RVM_REG_SETTYPE(r, RVM_DTYPE_SIGNED);
}
void rvm_reg_setboolean(rvmreg_t *r, rboolean b)
{
r_memset(r, 0, sizeof(*r));
RVM_REG_SETU(r, b ? 1 : 0);
RVM_REG_SETTYPE(r, RVM_DTYPE_BOOLEAN);
}
void rvm_reg_setundef(rvmreg_t *r)
{
r_memset(r, 0, sizeof(*r));
RVM_REG_SETTYPE(r, RVM_DTYPE_UNDEF);
}
void rvm_reg_setunsigned(rvmreg_t *r, ruword u)
{
r_memset(r, 0, sizeof(*r));
RVM_REG_SETU(r, u);
RVM_REG_SETTYPE(r, RVM_DTYPE_UNSIGNED);
}
void rvm_reg_setstrptr(rvmreg_t *r, char *s, unsigned int size)
{
r_memset(r, 0, sizeof(*r));
RVM_REG_SETSTR(r, s, size);
RVM_REG_SETTYPE(r, RVM_DTYPE_STRPTR);
}
void rvm_reg_setswi(rvmreg_t *r, ruword swiid)
{
r_memset(r, 0, sizeof(*r));
RVM_REG_SETU(r, swiid);
RVM_REG_SETTYPE(r, RVM_DTYPE_SWIID);
}
void rvm_reg_setpair(rvmreg_t *r, ruint32 p1, ruint32 p2)
{
r_memset(r, 0, sizeof(*r));
RVM_REG_SETPAIR(r, p1, p2);
RVM_REG_SETTYPE(r, RVM_DTYPE_PAIR);
}
int32_t __main(int32_t argc, int8_t **argv)
{
int32_t rc, i = 0;
recv_param r_param[MAX_STREAM];
recv_room_handle * recv_handle= NULL;
rc = dzlog_init(NSLOG_CONF, "Rec_server");
if (rc) {
printf("dzlog_init failed : <%s>\n", NSLOG_CONF);
return -1;
}
r_memset(r_param, 0, sizeof(recv_param) * MAX_STREAM);
r_memcpy(r_param[0].ipaddr, CONTROL_ADDR, sizeof(CONTROL_ADDR));
r_param[0].port = ENCODE_PORT;
r_param[0]. stream_id = 1;
r_param[0].status = RUNNING;
#if 1
r_memcpy(r_param[2].ipaddr, "192.168.4.239", sizeof(CONTROL_ADDR));
r_param[2].port = ENCODE_PORT;
r_param[2]. stream_id = 3;
r_param[2].status = RUNNING;
r_memcpy(r_param[1].ipaddr, "192.168.4.112", sizeof(CONTROL_ADDR));
r_param[1].port = ENCODE_PORT;
r_param[1]. stream_id = 2;
r_param[1].status = RUNNING;
r_memcpy(r_param[3].ipaddr, "192.168.4.239", sizeof(CONTROL_ADDR));
r_param[3].port = ENCODE_PORT;
r_param[3]. stream_id = 4;
r_param[3].status = RUNNING;
r_memcpy(r_param[4].ipaddr, "192.168.4.242", sizeof(CONTROL_ADDR));
r_param[4].port = ENCODE_PORT;
r_param[4]. stream_id = 5;
r_param[4].status = RUNNING;
#endif
recv_handle = register_room_receive_module(1);
recv_handle->set_room_info(r_param, recv_handle, 5);
int count = 0;
while (1)
{
if (60 == (count++))
{
unregister_room_receive_module(recv_handle);
}
if (120 == count)
{
recv_handle = register_room_receive_module(5);
recv_handle->set_room_info(r_param, recv_handle, 5);
count = 0;
}
sleep(1);
}
return 0;
}
static int32_t send_msg_to_live_audio(hdb_freame_head_t *fh, stream_handle *M_handle)
{
int32_t index = 0;
int32_t audio_vaild_num = 0;
stream_handle *temp_handle = NULL;
int return_code = OPERATION_SUCC;
int8_t *live_frame_data = NULL;
parse_data_t *live_frame_head = NULL;
m_msgque m_live_msgque ;
if(M_handle->audio_info == NULL)
{
nslog(NS_ERROR,"IMPORT ERROR, < LIVE AUDIO_INTO IS NULL >STREAM ID : %d\n",M_handle->stream_id);
return RECEIVE_MALLOC_ERR;
}
if(M_handle->audio_info->audio_tran_live_into.stream_num == 0)
{
nslog(NS_ERROR,"IMPORT ERROR, <LIVE AUDIO NUM IS 0>STREAM ID : %d\n",M_handle->stream_id);
return OPERATION_SUCC;
}
audio_vaild_num = M_handle->audio_info->audio_tran_live_into.stream_num;
// nslog(NS_ERROR,"AUDIO NUM : %d\n",audio_vaild_num);
for(index =0 ;index < audio_vaild_num;index ++ )
{
// add zl
temp_handle = (stream_handle *)(M_handle->audio_info->audio_tran_live_into.stream_handle_addr[index]);
if(START_LIVE != get_live_status(temp_handle))
{
continue;
}
// nslog(NS_ERROR,"STREAM_ID : %d\n",temp_handle->stream_id);
live_frame_data = (int8_t *)r_malloc(fh->m_frame_length);
if(NULL == live_frame_data) {
if(live_frame_data) {
r_free(live_frame_data);
live_frame_data = NULL;
}
nslog(NS_ERROR, "malloc is error !!!");
return_code = RECEIVE_MALLOC_ERR;
return return_code;
}
live_frame_head = (parse_data_t *)r_malloc(sizeof(parse_data_t));
if(NULL == live_frame_head) {
if(live_frame_head) {
r_free(live_frame_head);
live_frame_head = NULL;
}
return_code = RECEIVE_MALLOC_ERR;
return return_code;
}
r_memset(live_frame_head, 0, sizeof(parse_data_t));
r_memset(live_frame_data, 0, fh->m_frame_length);
r_memcpy(live_frame_data, M_handle->audio_data, fh->m_frame_length);
live_frame_head->data_type = R_AUDIO;
live_frame_head->code_rate = fh->m_colors;
live_frame_head->sample_rate = fh->m_frame_rate;
live_frame_head->time_tick = M_handle->recv_time_t.time_audio_tick;
live_frame_head->data_len = fh->m_frame_length;
live_frame_head->data = live_frame_data;
live_frame_data = NULL;
live_frame_head->flags = fh->m_dw_flags;
// add zl
// live_frame_head->sindex = M_handle->stream_id - 1;
live_frame_head->sindex = temp_handle->stream_id;
live_frame_head->index = 0;
live_frame_head->audio_sindex = M_handle->stream_id - 1;
live_frame_head->height = fh->m_hight;
live_frame_head->width = fh->m_width;
live_frame_head->end_flag = M_handle->live_status;
live_frame_head->blue_flag = !(fh->m_others);
// add zl
// m_live_msgque.msgtype = M_handle->stream_id;
m_live_msgque.msgtype = temp_handle->stream_id;
m_live_msgque.msgbuf = (int8_t *)live_frame_head;
M_handle->recv_pri.to_live = 1;
return_code = r_msg_send(temp_handle->msg_recv_to_live, &m_live_msgque, MsgqueLen - sizeof(long), IPC_NOWAIT);
if(0 > return_code) {
if(live_frame_head->data) {
r_free(live_frame_head->data);
live_frame_head->data = NULL;
}
if(live_frame_head) {
r_free(live_frame_head);
live_frame_head = NULL;
}
if(FALSE == IS_FLAG_BIT_TRUE(M_handle->log_flag, LIVE_BIT)) {
nslog(NS_WARN, "msgsnd to live failed, msgid = %d, errno = %d, stream_id=%d", M_handle->msg_recv_to_live, errno, M_handle->stream_id);
SET_FLAG_BIT_TRUE(M_handle->log_flag, LIVE_BIT);//置第1位为1.
}
M_handle->recv_pri.to_live = 0;
return -1;
}
}
SET_FLAG_BIT_FALSE(M_handle->log_flag, LIVE_BIT);//置第1位为0.
return 0;
}
void rvm_reg_setpointer(rvmreg_t *r, rpointer p)
{
r_memset(r, 0, sizeof(*r));
RVM_REG_SETP(r, p);
RVM_REG_SETTYPE(r, RVM_DTYPE_POINTER);
}
void rex_dfa_dumpstate(rexdfa_t *dfa, rexuint_t nstate)
{
long index;
char buf[240];
int bufsize = sizeof(buf) - 1;
int n = 0;
rexdfs_t *s = rex_dfa_state(dfa, nstate);
rexdfss_t *ss = NULL;
rexdft_t *t = NULL;
if (!s)
return;
fprintf(stdout, "State %ld", (unsigned long)nstate);
fprintf(stdout, " (");
for (index = 0; index < s->nsubstates; index++) {
ss = REX_DFA_SUBSTATE(dfa, nstate, index);
if (ss) {
fprintf(stdout, "%ld", (unsigned long)ss->uid);
if (ss->type == REX_STATETYPE_ACCEPT)
fprintf(stdout, "*");
if (index + 1 < s->nsubstates)
fprintf(stdout, ",");
}
}
fprintf(stdout, ")");
fprintf(stdout, ": ");
if (s->type == REX_STATETYPE_ACCEPT) {
fprintf(stdout, " REX_STATETYPE_ACCEPT ");
fprintf(stdout, " (");
for (index = 0; index < s->naccsubstates; index++) {
ss = REX_DFA_ACCSUBSTATE(dfa, nstate, index);
if (ss) {
fprintf(stdout, "%ld*", (unsigned long)ss->uid);
if (index + 1 < s->naccsubstates)
fprintf(stdout, ",");
}
}
fprintf(stdout, ")");
} else if (s->type == REX_STATETYPE_DEAD) {
fprintf(stdout, " REX_STATETYPE_DEAD ");
} else if (s->type == REX_STATETYPE_START) {
fprintf(stdout, " REX_STATETYPE_START ");
}
fprintf(stdout, "\n");
for (index = 0; index < s->ntrans; index++) {
t = &dfa->trans[s->trans + index];
n = 0;
if (t->lowin != t->highin) {
if (isprint(t->lowin) && !isspace(t->lowin) && isprint(t->highin) && !isspace(t->highin) && !r_strchr("[]-^", t->lowin) && !r_strchr("[]-^", t->highin))
n += r_snprintf(buf + n, n < bufsize ? bufsize - n : 0, " [%c - %c] ", t->lowin, t->highin);
else
n += r_snprintf(buf + n, n < bufsize ? bufsize - n : 0, " [0x%X - 0x%X] ", t->lowin, t->highin);
} else {
if (isprint(t->lowin) && !isspace(t->lowin))
n += r_snprintf(buf + n, n < bufsize ? bufsize - n : 0, " '%c' ", t->lowin);
else
n += r_snprintf(buf + n, n < bufsize ? bufsize - n : 0, " 0x%X ", t->lowin);
}
r_memset(buf + n, ' ', bufsize - n);
n = 40;
n += r_snprintf(buf + n, n < bufsize ? bufsize - n : 0, "-> %ld", t->state);
fprintf(stdout, "%s\n", buf);
}
if (!s->ntrans)
fprintf(stdout, " (none)\n");
fprintf(stdout, "\n");
}
void rvm_reg_setprophandler(rvmreg_t *r, rpointer p)
{
r_memset(r, 0, sizeof(*r));
RVM_REG_SETP(r, p);
RVM_REG_SETTYPE(r, RVM_DTYPE_PROPHANDLER);
}
static int32_t send_msg_to_live_media(hdb_freame_head_t *fh, stream_handle *M_handle)
{
int return_code = OPERATION_SUCC;
int8_t *live_frame_data = NULL;
parse_data_t *live_frame_head = NULL;
m_msgque m_live_msgque ;
live_frame_data = (int8_t *)r_malloc(fh->m_frame_length);
if(NULL == live_frame_data) {
if(live_frame_data) {
r_free(live_frame_data);
live_frame_data = NULL;
}
nslog(NS_ERROR, "malloc is error !!!");
return_code = RECEIVE_MALLOC_ERR;
return return_code;
}
live_frame_head = (parse_data_t *)r_malloc(sizeof(parse_data_t));
if(NULL == live_frame_head) {
if(live_frame_head) {
r_free(live_frame_head);
live_frame_head = NULL;
}
return_code = RECEIVE_MALLOC_ERR;
return return_code;
}
r_memset(live_frame_head, 0, sizeof(parse_data_t));
r_memset(live_frame_data, 0, fh->m_frame_length);
if(H264_CODEC_TYPE == fh->m_data_codec)
{
r_memcpy(live_frame_data, M_handle->frame_data, fh->m_frame_length);
live_frame_head->data_type = R_VIDEO;
live_frame_head->sample_rate = fh->m_frame_rate;
live_frame_head->time_tick = M_handle->recv_time_t.time_video_tick;
}
else if(JPEG_CODEC_TYPE == fh->m_data_codec)
{
r_memcpy(live_frame_data, M_handle->frame_data, fh->m_frame_length);
live_frame_head->data_type = R_JPEG;
live_frame_head->time_tick = M_handle->recv_time_t.time_video_tick;
}
live_frame_head->data_len = fh->m_frame_length;
live_frame_head->data = live_frame_data;
live_frame_data = NULL;
live_frame_head->flags = fh->m_dw_flags;
live_frame_head->sindex = M_handle->stream_id - 1;
live_frame_head->index = 0;
live_frame_head->audio_sindex = M_handle->stream_id - 1;
live_frame_head->height = fh->m_hight;
live_frame_head->width = fh->m_width;
live_frame_head->end_flag = M_handle->live_status;
live_frame_head->blue_flag = !(fh->m_others);
m_live_msgque.msgtype = M_handle->stream_id;
m_live_msgque.msgbuf = (int8_t *)live_frame_head;
M_handle->recv_pri.to_live = 1;
if(live_frame_head->data_type == R_JPEG)
{
nslog(NS_ERROR,"FUCK_GOD_1114 SEND TO A JPEG !\n");
}
return_code = r_msg_send(M_handle->msg_recv_to_live, &m_live_msgque, MsgqueLen - sizeof(long), IPC_NOWAIT);
if(0 > return_code) {
if(live_frame_head->data) {
r_free(live_frame_head->data);
live_frame_head->data = NULL;
}
if(live_frame_head) {
r_free(live_frame_head);
live_frame_head = NULL;
}
if(FALSE == IS_FLAG_BIT_TRUE(M_handle->log_flag, LIVE_BIT)) {
nslog(NS_WARN, "msgsnd to live failed, msgid = %d, errno = %d, stream_id=%d", M_handle->msg_recv_to_live, errno, M_handle->stream_id);
SET_FLAG_BIT_TRUE(M_handle->log_flag, LIVE_BIT);//置第1位为1.
}
M_handle->recv_pri.to_live = 0;
return -1;
}
SET_FLAG_BIT_FALSE(M_handle->log_flag, LIVE_BIT);//置第1位为0.
return OPERATION_SUCC;
}
