void switch_by_message(uint8_t msg_id)
{
msg_send(msg_id);
msg_process();
state = hall_fsm(state, &hall);
msg_process();
}
/*****************************************************************************
Prototype : vid_enc_thr
Description : image encode thread
Input : void *arg
Output : None
Return Value : void
Calls :
Called By :
History :
1.Date : 2012/3/8
Author : Sun
Modification : Created function
*****************************************************************************/
void *vid_enc_thr(void *arg)
{
VidEncThrEnv env;
CommonMsg msgBuf;
Int32 ret;
Int32 fdMsg, fdMax;
fd_set rdSet;
ret = vid_enc_thr_init((VidEncThrArg *)arg, (VidEncThrEnv *)&env);
assert(ret == E_NO);
if(ret)
goto exit;
fdMsg = msg_get_fd(env.hMsg);
fdMax = fdMsg + 1;
/* start main loop */
while(!env.exit) {
/* wait data ready */
FD_ZERO(&rdSet);
FD_SET(fdMsg, &rdSet);
ret = select(fdMax, &rdSet, NULL, NULL, NULL);
if(ret < 0 && errno != EINTR) {
ERRSTR("select err");
break;
}
/* no data ready */
if(!ret)
continue;
if(FD_ISSET(fdMsg, &rdSet)) {
/* process msg */
msg_process(&env, &msgBuf);
}
}
exit:
if(env.hH264Enc)
h264_enc_delete(env.hH264Enc);
if(env.hOsd)
osd_delete(env.hOsd);
if(env.hBufEnc)
buffer_free(env.hBufEnc);
if(env.hMsg)
msg_delete(env.hMsg);
INFO("vid encode thread exit...");
pthread_exit(0);
}
void msg_read_common(char type, uint8_t *buf, int len)
{
static char read_state = READSTATE_IDLE;
static uint8_t msg_in[MSG_IN_SIZE];
static uint16_t msg_id = 0xFFFF;
static uint32_t msg_size = 0;
static uint32_t msg_pos = 0;
static const pb_field_t *fields = 0;
if (len != 64) return;
if (read_state == READSTATE_IDLE) {
if (buf[0] != '?' || buf[1] != '#' || buf[2] != '#') { // invalid start - discard
return;
}
msg_id = (buf[3] << 8) + buf[4];
msg_size = (buf[5] << 24)+ (buf[6] << 16) + (buf[7] << 8) + buf[8];
fields = MessageFields(type, 'i', msg_id);
if (!fields) { // unknown message
fsm_sendFailure(FailureType_Failure_UnexpectedMessage, "Unknown message");
return;
}
if (msg_size > MSG_IN_SIZE) { // message is too big :(
fsm_sendFailure(FailureType_Failure_SyntaxError, "Message too big");
return;
}
read_state = READSTATE_READING;
memcpy(msg_in, buf + 9, len - 9);
msg_pos = len - 9;
} else
if (read_state == READSTATE_READING) {
if (buf[0] != '?') { // invalid contents
read_state = READSTATE_IDLE;
return;
}
memcpy(msg_in + msg_pos, buf + 1, len - 1);
msg_pos += len - 1;
}
if (msg_pos >= msg_size) {
msg_process(type, msg_id, fields, msg_in, msg_size);
msg_pos = 0;
read_state = READSTATE_IDLE;
}
}
void *mrp_monitor_thread(void *arg)
{
char *msgbuf;
struct sockaddr_in client_addr;
struct msghdr msg;
struct iovec iov;
int bytes = 0;
struct pollfd fds;
int rc;
struct mrp_listener_ctx *ctx = (struct mrp_listener_ctx*) arg;
msgbuf = (char *)malloc(MAX_MRPD_CMDSZ);
if (NULL == msgbuf)
return NULL;
while (!ctx->halt_tx) {
fds.fd = ctx->control_socket;
fds.events = POLLIN;
fds.revents = 0;
rc = poll(&fds, 1, 100);
if (rc < 0) {
free(msgbuf);
pthread_exit(NULL);
}
if (rc == 0)
continue;
if ((fds.revents & POLLIN) == 0) {
free(msgbuf);
pthread_exit(NULL);
}
memset(&msg, 0, sizeof(msg));
memset(&client_addr, 0, sizeof(client_addr));
memset(msgbuf, 0, MAX_MRPD_CMDSZ);
iov.iov_len = MAX_MRPD_CMDSZ;
iov.iov_base = msgbuf;
msg.msg_name = &client_addr;
msg.msg_namelen = sizeof(client_addr);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
bytes = recvmsg(ctx->control_socket, &msg, 0);
if (bytes < 0)
continue;
msg_process(msgbuf, bytes, ctx);
}
free(msgbuf);
pthread_exit(NULL);
}
int recv_msg()
{
char *databuf;
int bytes = 0;
databuf = (char *)malloc(2000);
if (NULL == databuf)
return -1;
memset(databuf, 0, 2000);
bytes = recv(control_socket, databuf, 2000, 0);
if (bytes <= -1)
{
free(databuf);
return (-1);
}
return msg_process(databuf, bytes);
}
/*****************************************************************************
Prototype : encoder_thread
Description : encode thread
Input : void *arg
Output : None
Return Value : void
Calls :
Called By :
History :
1.Date : 2012/3/8
Author : Sun
Modification : Created function
*****************************************************************************/
void *encoder_thread(void *arg)
{
EncoderHandle hEnc = (EncoderHandle)arg;
CommonMsg msgBuf;
Int32 ret;
Int32 fdMsg, fdMax;
fd_set rdSet;
assert(arg);
fdMsg = msg_get_fd(hEnc->hMsg);
fdMax = fdMsg + 1;
DBG("%s thread start", hEnc->name);
/* start main loop */
while(!hEnc->exit) {
/* wait data ready */
FD_ZERO(&rdSet);
FD_SET(fdMsg, &rdSet);
ret = select(fdMax, &rdSet, NULL, NULL, NULL);
if(ret < 0 && errno != EINTR) {
ERRSTR("select err");
break;
}
/* no data ready */
if(!ret)
continue;
if(FD_ISSET(fdMsg, &rdSet)) {
/* process msg */
msg_process(hEnc, &msgBuf);
}
}
INFO("<%s> encode thread exit...", hEnc->name);
pthread_exit(0);
}
int main(int argc, char **argv) {
struct pollfd polls[MAX_POLL_ITEMS];
int opt, background, fdin, nfds, watch_alsa;
int con_in, msg_in;
background = 0;
watch_alsa = 0;
client_name = DEFAULT_CLIENT_NAME;
server_name = DEFAULT_SERVER_NAME;
msg_port = DEFAULT_MSG_PORT;
sampling_rate = DEFAULT_SAMPLING_RATE;
period_frames = DEFAULT_PERIOD_SIZE;
while ((opt = getopt(argc, argv, "adn:p:P:r:s:")) != -1) {
switch (opt) {
case 'a': watch_alsa = 1; break;
case 'd': background = 1; break;
case 'j': use_jack = 1; break;
case 'n': client_name = optarg; break;
case 'P': msg_port = atoi(optarg); break;
case 'p': period_frames = atoi(optarg); break;
case 'r': sampling_rate = atoi(optarg); break;
case 's': server_name = optarg; break;
default:
fprintf(stderr, "invalid option: %c", opt);
exit(1);
}
}
if (background) {
set_handler(SIGCHLD, sigsnag);
if (fork() > 0) _exit(0);
}
set_handler(SIGINT, sigsnag);
set_handler(SIGTERM, sigsnag);
set_handler(SIGABRT, sigsnag);
set_handler(SIGHUP, sigsnag);
set_handler(SIGQUIT, sigsnag);
scm_init_guile();
init_env();
if (use_jack) start_jack(NULL);
else {
size_t memsize = QMX_CHANNELS * period_frames * sizeof(sample_t);
fixed_cauldron = (sample_t *)malloc(memsize);
int ret = mlock(fixed_cauldron, memsize);
if (ret == 0) log_msg("MIXMEM locked: %lu\n", memsize);
else log_msg("MIXMEM not locked: %s\n", strerror(errno));
}
start_outbuffer();
scm_c_define("jack-sampling-rate", scm_from_int(sampling_rate));
while (optind < argc) {
log_msg("load %s\n", argv[optind]);
scm_c_primitive_load(argv[optind]);
optind++;
}
fdin = fileno(stdin);
nfds = 0;
con_in = -1;
if (!background) {
con_in = nfds;
polls[nfds].fd = fdin;
polls[nfds].events = POLLIN;
nfds++;
}
msg_in = -1;
if (msg_socket() >= 0) {
msg_in = nfds;
polls[nfds].fd = msg_socket();
polls[nfds].events = POLLIN;
nfds++;
}
if (isatty(fdin)) rl_callback_handler_install(prompt, line_handler);
running = 1;
if (!use_jack) spawn_detached_thread(mix_thread_abs, NULL);
while (running) {
if (watch_alsa) check_card_event();
if (poll(polls, nfds, POLL_TIMEOUT) < 1) continue;
if ((con_in >= 0) && (polls[con_in].revents & POLLIN))
process_line(fdin);
if ((msg_in >= 0) && (polls[msg_in].revents & POLLIN))
msg_process();
}
if (isatty(fdin)) rl_callback_handler_remove();
shutdown_env();
log_msg("bye!\n");
cleanup();
return 0;
}
