int avr_input(void)
{
char avr_button;
if (!avr_tstc())
return 0;
avr_button = avr_getc();
switch (avr_button) {
case PWRP:
if (push_timeout(PWRR)) {
/* Timeout before power button release */
boot_stop = ~boot_stop;
if (boot_stop)
miconCntl_SendCmd(PWRBLINKSTOP);
else
miconCntl_SendCmd(PWRBLINKSTRT);
/* Wait for power button release */
while (avr_getc() != PWRR)
;
} else
/* Power button released */
next_boot_choice();
break;
case RESP:
/* Wait for Reset button release */
while (avr_getc() != RESR)
;
next_cons_choice(cons_choice);
break;
case AVRINIT:
return 0;
default:
perror("Unexpected code: 0x%02X\n", avr_button);
return 0;
}
if (boot_stop)
return (-3);
else
return (-2);
}
int start_server(const char *url, const char *rtspport)
{
int mediafd = -1, listenfd, tempfd, maxfd;
int videofd;
struct addrinfo *info;
struct sockaddr_storage remoteaddr;
socklen_t addrlen = sizeof remoteaddr;
fd_set readfds, masterfds;
struct timeval *timeout, *timeind = NULL, timenow;
int nready, i;
int videosize, videoleft;
int recvd, sent;
char urlhost[URLSIZE], urlpath[URLSIZE], tempstr[URLSIZE];
unsigned char msgbuf[BUFSIZE], sendbuf[BUFSIZE];
char *temp;
unsigned char *sps = NULL, *pps = NULL;
size_t spslen, ppslen;
RTSPMsg rtspmsg;
Client streamclient;
pthread_t threadid;
ThreadInfo *tinfo = NULL;
uint16_t rtpseqno_video = (rand() % 1000000);
uint16_t rtpseqno_audio = (rand() % 1000000);
TimeoutEvent *event;
/* The current state of the protocol */
int mediastate = IDLE;
int quit = 0;
int media_downloaded = 0;
timeout = (struct timeval *)malloc(sizeof(struct timeval));
init_client(&streamclient);
/* Open the a file where the video is to be stored */
if ((videofd = open("videotemp.mp4", O_RDWR | O_CREAT | O_TRUNC, S_IRWXU)) < 0) {
fatal_error("Error opening the temporary videofile");
}
/* Create the RTSP listening socket */
resolve_host(NULL, rtspport, SOCK_STREAM, AI_PASSIVE, &info);
listenfd = server_socket(info);
maxfd = listenfd;
FD_ZERO(&readfds);
FD_ZERO(&masterfds);
FD_SET(listenfd, &masterfds);
while (!quit) {
readfds = masterfds;
if ((nready = Select(maxfd + 1, &readfds, timeind)) == -1) {
printf("Select interrupted by a signal\n");
}
/* Timeout handling, used for packet pacing and other timeouts */
else if (nready == 0) {
timeind = NULL;
lock_mutex(&queuelock);
if ((event = pull_event(&queue)) != NULL) {
switch (event->type) {
case ENDOFSTREAM:
printf("MEDIA FINISHED\n");
break;
case FRAME:
/* Video frame */
if (event->frame->frametype == VIDEO_FRAME) {
rtpseqno_video += send_video_frame(sendbuf, event->frame, streamclient.videofds[0], rtpseqno_video);
}
/* Audio frame */
else {
rtpseqno_audio += send_audio_frame(sendbuf, event->frame, streamclient.audiofds[0], rtpseqno_audio);
}
free(event->frame->data);
free(event->frame);
break;
case CHECKMEDIASTATE:
oma_debug_print("Checking media ready for streaming...\n");
if (mediastate != STREAM) {
printf("Sending dummy RTP\n");
send_dummy_rtp(sendbuf, streamclient.videofds[0], &rtpseqno_video);
push_timeout(&queue, 1000, CHECKMEDIASTATE);
}
break;
default:
oma_debug_print("ERRORENOUS EVENT TYPE!\n");
break;
}
/* If there are elements left in the queue, calculate next timeout */
if (queue.size > 0) {
*timeout = calculate_delta(&event->time, &queue.first->time);
timeind = timeout;
oma_debug_print("Timeout: %ld secs, %ld usecs\n", timeout->tv_sec, timeout->tv_usec);
}
else {
oma_debug_print("The first entry of the queue is NULL!\n");
}
if (queue.size < QUEUESIZE / 2) {
oma_debug_print("Signaling thread to start filling the queue");
pthread_cond_signal(&queuecond);
}
free(event);
}
unlock_mutex(&queuelock);
continue;
} /* End of timeout handling */
/* Start to loop through the file descriptors */
for (i = 0; i <= maxfd; i++) {
if (FD_ISSET(i, &readfds)) {
nready--;
/* New connection from a client */
if (i == listenfd) {
oma_debug_print("Recieved a new RTSP connection\n");
fflush(stdout);
if ((tempfd = accept(i, (struct sockaddr *)&remoteaddr, &addrlen)) == -1) {
if (errno != EWOULDBLOCK && errno != ECONNABORTED &&
errno != EPROTO && errno != EINTR) {
fatal_error("accept");
}
}
/* If we are already serving a client, close the new connection. Otherwise, continue. */
if (streamclient.state != NOCLIENT) {
printf("Another RTSP client tried to connect. Sorry, we can only serve one client at a time\n");
close (tempfd);
}
else {
streamclient.rtspfd = tempfd;
streamclient.state = CLICONNECTED;
maxfd = max(2, streamclient.rtspfd, maxfd);
FD_SET(streamclient.rtspfd, &masterfds);
}
}
/* Data from the media source */
else if (i == mediafd) {
switch (mediastate) {
case GETSENT:
/* Read ONLY the HTTP message from the socket and store the video size */
recvd = recv_all(i, msgbuf, BUFSIZE, MSG_PEEK);
temp = strstr((char *)msgbuf, "\r\n\r\n");
recvd = recv_all(i, msgbuf, (int)(temp + 4 - (char *)msgbuf), 0);
printf("Received HTTP response\n%s\n", msgbuf);
temp = strstr((char *)msgbuf, "Content-Length:");
sscanf(temp, "Content-Length: %d", &videosize);
videoleft = videosize;
mediastate = RECVTCP;
break;
case RECVTCP:
if ((recvd = recv_all(i, msgbuf, BUFSIZE, 0)) == 0) {
FD_CLR(i, &masterfds);
close(i);
oma_debug_print("Socket closed\n");
}
oma_debug_print("Received data from video source!\n");
writestr(videofd, msgbuf, recvd);
videoleft -= recvd;
if (videoleft <= 0) {
printf("Video download complete.\n");
FD_CLR(mediafd, &masterfds);
close(videofd);
close(mediafd);
media_downloaded = 1;
printf("Media socket closed\n");
/* Create the context and the queue filler thread parameter struct */
tinfo = (ThreadInfo *)malloc(sizeof(ThreadInfo));
initialize_context(&tinfo->ctx, "videotemp.mp4", &tinfo->videoIdx, &tinfo->audioIdx,
&tinfo->videoRate, &tinfo->audioRate, &sps, &spslen, &pps, &ppslen);
/* Launch the queue filler thread */
CHECK((pthread_create(&threadid, NULL, fill_queue, tinfo)) == 0);
pthread_detach(threadid);
/* Send the sprop-parameters before any other frames */
send_video_frame(sendbuf, create_sprop_frame(sps, spslen, 0),
streamclient.videofds[0], rtpseqno_video++);
send_video_frame(sendbuf, create_sprop_frame(pps, ppslen, 0),
streamclient.videofds[0], rtpseqno_video++);
g_free(sps);
g_free(pps);
lock_mutex(&queuelock);
push_timeout(&queue, 1000, CHECKMEDIASTATE);
unlock_mutex(&queuelock);
mediastate = STREAM;
}
break;
case STREAM:
/*
close(videofd);
close(mediafd);
close(listenfd);
quit = 1;
*/
break;
default:
break;
}
}
/* Data from a client ( i == streamclient.rtspfd) */
else {
oma_debug_print("Received data from rtspfd\n");
fflush(stdout);
if ((recvd = recv_all(i, msgbuf, BUFSIZE, 0)) == 0) {
FD_CLR(i, &masterfds);
close(i);
oma_debug_print("RTSP client closed the connection\n");
streamclient.state = NOCLIENT;
}
else {
oma_debug_print("%s", msgbuf);
parse_rtsp(&rtspmsg, msgbuf);
}
if (rtspmsg.type == TEARDOWN) {
/* Kill thread and empty queue */
lock_mutex(&queuelock);
pthread_cancel(threadid);
empty_queue(&queue);
sleep(1);
/* Reply with 200 OK */
sent = rtsp_teardown(&rtspmsg, sendbuf);
send_all(i, sendbuf, sent);
FD_CLR(i, &masterfds);
close(i);
close(streamclient.videofds[0]);
close(streamclient.videofds[1]);
close(streamclient.audiofds[0]);
close(streamclient.audiofds[1]);
printf("Closing AVFormatContext\n");
close_context(tinfo->ctx);
free(tinfo);
rtpseqno_video = (rand() % 1000000) + 7;
rtpseqno_audio = rtpseqno_video + 9;
init_client(&streamclient);
printf("Closing RTSP client sockets (RTP&RTCP)\n");
streamclient.state = NOCLIENT;
unlock_mutex(&queuelock);
pthread_cond_signal(&queuecond);
}
switch (streamclient.state) {
case CLICONNECTED:
if (rtspmsg.type == OPTIONS) {
sent = rtsp_options(&rtspmsg, &streamclient, sendbuf);
send_all(i, sendbuf, sent);
}
else if (rtspmsg.type == DESCRIBE) {
if (media_downloaded == 0) {
/* Start fetching the file from the server */
parse_url(url, urlhost, urlpath);
resolve_host(urlhost, "80", SOCK_STREAM, 0, &info);
mediafd = client_socket(info, 0);
FD_SET(mediafd, &masterfds);
maxfd = max(2, maxfd, mediafd);
/* Send the GET message */
http_get(url, msgbuf);
send_all(mediafd, msgbuf, strlen((char *)msgbuf));
mediastate = GETSENT;
}
else {
mediastate = STREAM;
}
/* Send the SDP without sprop-parameter-sets, those are sent
* later in-band */
streamclient.state = SDPSENT;
sent = rtsp_describe(&streamclient, sendbuf);
send_all(i, sendbuf, sent);
}
break;
case SDPSENT:
if (rtspmsg.type == SETUP) {
streamclient.setupsreceived++;
/* Open up the needed ports and bind them locally. The RTCP ports opened here
* are not really used by this application. */
write_remote_ip(tempstr, streamclient.rtspfd);
oma_debug_print("Remote IP: %s\n", tempstr);
if (streamclient.setupsreceived < 2) {
resolve_host(tempstr, rtspmsg.clirtpport, SOCK_DGRAM, 0, &info);
streamclient.audiofds[0] = client_socket(info, streamclient.server_rtp_audio_port);
resolve_host(tempstr, rtspmsg.clirtcpport, SOCK_DGRAM, 0, &info);
streamclient.audiofds[1] = client_socket(info, streamclient.server_rtcp_audio_port);
sent = rtsp_setup(&rtspmsg, &streamclient, sendbuf,
streamclient.server_rtp_audio_port, streamclient.server_rtcp_audio_port);
}
else {
resolve_host(tempstr, rtspmsg.clirtpport, SOCK_DGRAM, 0, &info);
streamclient.videofds[0] = client_socket(info, streamclient.server_rtp_video_port);
resolve_host(tempstr, rtspmsg.clirtcpport, SOCK_DGRAM, 0, &info);
streamclient.audiofds[1] = client_socket(info, streamclient.server_rtcp_video_port);
sent = rtsp_setup(&rtspmsg, &streamclient, sendbuf,
streamclient.server_rtp_video_port, streamclient.server_rtcp_video_port);
streamclient.state = SETUPCOMPLETE;
}
oma_debug_print("Sending setup response...\n");
send_all(i, sendbuf, sent);
}
break;
case SETUPCOMPLETE:
if (rtspmsg.type == PLAY) {
/* Respond to the PLAY request, and start sending dummy RTP packets
* to disable the client timeout */
sent = rtsp_play(&rtspmsg, sendbuf);
send_all(i, sendbuf, sent);
if (media_downloaded == 0) {
lock_mutex(&queuelock);
push_timeout(&queue, 100, CHECKMEDIASTATE);
unlock_mutex(&queuelock);
}
/* Media has already been once downloaded, initialize context and thread */
else {
tinfo = (ThreadInfo *)malloc(sizeof(ThreadInfo));
initialize_context(&tinfo->ctx, "videotemp.mp4", &tinfo->videoIdx, &tinfo->audioIdx,
&tinfo->videoRate, &tinfo->audioRate, &sps, &spslen, &pps, &ppslen);
/* Launch the queue filler thread */
CHECK((pthread_create(&threadid, NULL, fill_queue, tinfo)) == 0);
pthread_detach(threadid);
/* Send the sprop-parameters before any other frames */
send_video_frame(sendbuf, create_sprop_frame(sps, spslen, 0),
streamclient.videofds[0], rtpseqno_video++);
send_video_frame(sendbuf, create_sprop_frame(pps, ppslen, 0),
streamclient.videofds[0], rtpseqno_video++);
g_free(sps);
g_free(pps);
/* Dummy timeouts to start queue/timeout mechanism */
push_timeout(&queue, 100, CHECKMEDIASTATE);
push_timeout(&queue, 2000, CHECKMEDIASTATE);
}
}
break;
default:
break;
}
}
}
if (nready <= 0) break;
}
/* Set the timeout value again, since select will mess it up */
lock_mutex(&queuelock);
if (queue.size > 0) {
CHECK((gettimeofday(&timenow, NULL)) == 0);
*timeout = calculate_delta(&timenow, &queue.first->time);
/* oma_debug_print("Delta sec: %ld, Delta usec: %ld\n", timeout->tv_sec, timeout->tv_usec); */
if (timeout->tv_sec < 0) {
timeout->tv_sec = 0;
timeout->tv_usec = 0;
}
timeind = timeout;
}
else timeind = NULL;
unlock_mutex(&queuelock);
}
return 1;
}
