/*
* Can you still remember input that looks like an execute @arg?
* @arg must end with a newline.
*/
int
seen_exec_input(char *arg)
{
size_t len = strlen(arg);
int n, i, j, ch;
unsigned char buf[RING_SIZE + 1];
assert(len && arg[len - 1] == '\n');
n = 1;
for (;;) {
/* find next line ending with arg */
n = ring_search(&recent_input, arg, n + 1);
if (n <= 0)
return 0;
/* extract command (same or previous line) */
i = n - 1;
if (ring_peek(&recent_input, i) == '\n')
i--;
j = sizeof(buf);
buf[--j] = 0;
for (; i >= 0 && (ch = ring_peek(&recent_input, i)) != '\n'; i--)
buf[--j] = ch;
/* compare command */
for (; isspace(buf[j]); j++) ;
for (i = j; buf[i] && !isspace(buf[i]); i++) ;
if (i - j >= 2 && !strncmp("execute", (char *)buf + j, i - j))
return 1;
}
}
uint8_t usart0_buffer_peek(ring_t *ring, uint8_t *buf, uint8_t count)
{
register uint8_t result;
register uint8_t sreg;
sreg = SREG;
cli();
result = ring_peek(ring, buf, count);
SREG = sreg;
return(result);
}
/*
* Forget remembered input up to SEEN.
* SEEN should be obtained from save_input() or seen_input().
*/
void
forget_input(size_t seen)
{
size_t forgotten = saved_bytes - ring_len(&recent_input);
assert(seen);
if (seen > forgotten) {
assert(ring_peek(&recent_input, seen - forgotten - 1) == '\n');
ring_discard(&recent_input, seen - forgotten);
}
}
static int peek_next_video_unit(multiplex_t *mx, index_unit *viu)
{
if (!ring_avail(mx->index_vrbuffer) && mx->finish) return 0;
while (ring_avail(mx->index_vrbuffer) < sizeof(index_unit))
if (mx->fill_buffers(mx->priv, mx->finish)< 0) {
fprintf(stderr,"error in peek next video unit\n");
return 0;
}
ring_peek(mx->index_vrbuffer, (uint8_t *)viu, sizeof(index_unit),0);
#ifdef OUT_DEBUG
fprintf(stderr,"video index start: %d stop: %d (%d) rpos: %d\n",
viu->start, (viu->start+viu->length),
viu->length, ring_rpos(mx->vrbuffer));
#endif
return 1;
}
static int peek_next_ext_unit(multiplex_t *mx, index_unit *extiu, int i)
{
if (!ring_avail(&mx->index_extrbuffer[i]) && mx->finish) return 0;
while (ring_avail(&mx->index_extrbuffer[i]) < sizeof(index_unit))
if (mx->fill_buffers(mx->priv, mx->finish)< 0) {
fprintf(stderr,"error in peek next video unit\n");
return 0;
}
ring_peek(&mx->index_extrbuffer[i], (uint8_t *)extiu,
sizeof(index_unit),0);
#ifdef OUT_DEBUG
fprintf(stderr,"ext index start: %d stop: %d (%d) rpos: %d\n",
extiu->start, (extiu->start+extiu->length),
extiu->length, ring_rpos(mx->extrbuffer));
#endif
return 1;
}
/*
* Receive command input from @fd into @inbuf.
* Return 1 on receipt of input, zero on EOF, -1 on error.
*/
static int
recv_input(int fd, struct ring *inbuf)
{
static struct lbuf cmdbuf;
int n, i, ch;
char *line;
int res = 1;
n = ring_from_file(inbuf, fd);
if (n < 0)
return -1;
if (n == 0) {
/* EOF on input */
if (lbuf_len(&cmdbuf)) {
/* incomplete line */
ring_putc(inbuf, '\n');
n++;
}
/*
* Can't put EOF cookie into INBUF here, it may not fit.
* Leave it to caller.
*/
res = 0;
}
/* copy input to AUXFP etc. */
for (i = -n; i < 0; i++) {
ch = ring_peek(inbuf, i);
assert(ch != EOF);
if (ch != '\r' && lbuf_putc(&cmdbuf, ch) > 0) {
line = lbuf_line(&cmdbuf);
save_input(line);
lbuf_init(&cmdbuf);
}
if (auxfp)
putc(ch, auxfp);
}
return res;
}
/*
* Play on @sock.
* The session must be in the playing phase.
* Return 0 when the session ended, -1 on error.
*/
int
play(int sock)
{
/*
* Player input flows from INPUT_FD through recv_input() into ring
* buffer INBUF, which drains into SOCK. This must not block.
* Server output flows from SOCK into recv_output(). Reading SOCK
* must not block.
*/
struct sigaction sa;
struct ring inbuf; /* input buffer, draining to SOCK */
int eof_fd0; /* read fd 0 hit EOF? */
int partial_line_sent; /* partial input line sent? */
fd_set rdfd, wrfd;
int n;
sa.sa_flags = 0;
sigemptyset(&sa.sa_mask);
sa.sa_handler = intr;
sigaction(SIGINT, &sa, NULL);
sa.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &sa, NULL);
ring_init(&inbuf);
eof_fd0 = partial_line_sent = send_eof = send_intr = 0;
input_fd = 0;
sysdep_stdin_init();
for (;;) {
FD_ZERO(&rdfd);
FD_ZERO(&wrfd);
/*
* Want to read player input only when we don't need to send
* cookies, and INPUT_FD is still open, and INBUF can accept
* some.
*/
if (!send_intr && !send_eof && input_fd >= 0 && ring_space(&inbuf))
FD_SET(input_fd, &rdfd);
/* Want to send player input only when we have something */
if (send_intr || send_eof || ring_len(&inbuf))
FD_SET(sock, &wrfd);
/* Always want to read server output */
FD_SET(sock, &rdfd);
n = select(MAX(input_fd, sock) + 1, &rdfd, &wrfd, NULL, NULL);
if (n < 0) {
if (errno != EINTR) {
perror("select");
return -1;
}
}
if ((send_eof || send_intr) && partial_line_sent
&& ring_putc(&inbuf, '\n') != EOF)
partial_line_sent = 0;
if (send_eof && !partial_line_sent
&& ring_putm(&inbuf, EOF_COOKIE, sizeof(EOF_COOKIE) - 1) >= 0)
send_eof--;
if (send_intr && !partial_line_sent
&& ring_putm(&inbuf, INTR_COOKIE, sizeof(INTR_COOKIE) - 1) >= 0) {
send_intr = 0;
if (input_fd) {
/* execute aborted, switch back to fd 0 */
close(input_fd);
input_fd = eof_fd0 ? -1 : 0;
}
}
if (n < 0)
continue;
/* read player input */
if (input_fd >= 0 && FD_ISSET(input_fd, &rdfd)) {
n = recv_input(input_fd, &inbuf);
if (n < 0) {
perror("read stdin"); /* FIXME stdin misleading, could be execing */
n = 0;
}
if (n == 0) {
/* EOF on input */
send_eof++;
if (input_fd) {
/* execute done, switch back to fd 0 */
close(input_fd);
input_fd = eof_fd0 ? -1 : 0;
} else {
/* stop reading input, drain socket ring buffers */
eof_fd0 = 1;
input_fd = -1;
sa.sa_handler = SIG_DFL;
sigaction(SIGINT, &sa, NULL);
}
} else
partial_line_sent = ring_peek(&inbuf, -1) != '\n';
}
/* send it to the server */
if (FD_ISSET(sock, &wrfd)) {
n = ring_to_file(&inbuf, sock);
if (n < 0) {
perror("write socket");
return -1;
}
}
/* read server output and print it */
if (FD_ISSET(sock, &rdfd)) {
n = recv_output(sock);
if (n < 0) {
perror("read socket");
return -1;
}
if (n == 0)
return 0;
}
}
}
uint16_t usart_peek(usart * usx) {
// if ( buffer_count(&(usx->rxring)) == 0 )
// return 0xffff;
return ring_peek(&usx->rxring); // rxring[usx->usid].buf[rxring[usx->usid].tail];
}
/* ------------------------------------------------------------------
* Peek at the rx buffer
* ------------------------------------------------------------------ */
uint8_t uart_rx_peek(uint8_t *buffer, uint8_t len) {
return ring_peek(&rx,buffer,len);
}
static void writeout_video(multiplex_t *mx)
{
uint8_t outbuf[3000];
int written=0;
uint8_t ptsdts=0;
unsigned int length;
int nlength=0;
int frame_len=0;
index_unit *viu = &mx->viu;
#ifdef OUT_DEBUG
fprintf(stderr,"writing VIDEO pack\n");
#endif
if(viu->frame_start) {
ptsdts = get_ptsdts(mx, viu);
frame_len = viu->length;
}
if (viu->frame_start && viu->seq_header && viu->gop &&
viu->frame == I_FRAME){
if (!mx->startup && mx->is_ts){
write_ts_patpmt(mx->ext, mx->extcnt, 1, outbuf);
write(mx->fd_out, outbuf, mx->pack_size*2);
ptsinc(&mx->SCR, mx->SCRinc*2);
} else if (!mx->startup && mx->navpack){
write_nav_pack(mx->pack_size, mx->extcnt,
mx->SCR, mx->muxr, outbuf);
write(mx->fd_out, outbuf, mx->pack_size);
ptsinc(&mx->SCR, mx->SCRinc);
} else mx->startup = 0;
#ifdef OUT_DEBUG
fprintf (stderr, " with sequence and gop header\n");
#endif
}
if (mx->finish != 2 && dummy_space(&mx->vdbuf) < mx->data_size){
return;
}
length = viu->length;
while (!mx->is_ts && length < mx->data_size){
index_unit nviu;
int old_start = viu->frame_start;
int old_frame = viu->frame;
uint64_t old_pts = viu->pts;
uint64_t old_dts = viu->dts;
dummy_add(&mx->vdbuf, uptsdiff(viu->dts+mx->video_delay,0)
, viu->length);
if ( peek_next_video_unit(mx, &nviu)){
if (!(nviu.seq_header && nviu.gop &&
nviu.frame == I_FRAME)){
get_next_video_unit(mx, viu);
frame_len = viu->length;
length += viu->length;
if(old_start) {
viu->pts = old_pts;
viu->dts = old_dts;
viu->frame = old_frame;
} else {
ptsdts = get_ptsdts(mx, viu);
}
} else break;
} else break;
}
if (viu->frame_start){
viu->frame_start=0;
if (viu->gop){
uint8_t gop[8];
frame_len=length-frame_len;
ring_peek(mx->vrbuffer, gop, 8, frame_len);
pts2time( viu->pts + mx->video_delay, gop, 8);
ring_poke(mx->vrbuffer, gop, 8, frame_len);
viu->gop=0;
}
if (mx->VBR) {
mx->extra_clock = ptsdiff(viu->dts + mx->video_delay,
mx->SCR + 500*CLOCK_MS);
#ifdef OUT_DEBUG1
fprintf(stderr,"EXTRACLOCK2: %lli %lli %lli\n", viu->dts, mx->video_delay, mx->SCR);
fprintf(stderr,"EXTRACLOCK2: %lli ", mx->extra_clock);
printpts(mx->extra_clock);
fprintf(stderr,"\n");
#endif
if (mx->extra_clock < 0)
mx->extra_clock = 0.0;
}
}
nlength = length;
if (mx->is_ts)
written = write_video_ts( viu->pts+mx->video_delay,
viu->dts+mx->video_delay,
mx->SCR, outbuf, &nlength,
ptsdts, mx->vrbuffer);
else
written = write_video_pes( mx->pack_size, mx->extcnt,
viu->pts+mx->video_delay,
viu->dts+mx->video_delay,
mx->SCR, mx->muxr, outbuf, &nlength,
ptsdts, mx->vrbuffer);
length -= nlength;
dummy_add(&mx->vdbuf, uptsdiff( viu->dts+mx->video_delay,0)
, viu->length-length);
viu->length = length;
//estimate next pts based on bitrate of this stream and data written
viu->dts = uptsdiff(viu->dts + ((nlength*viu->ptsrate)>>8), 0);
write(mx->fd_out, outbuf, written);
#ifdef OUT_DEBUG
fprintf(stderr,"VPTS");
printpts(viu->pts);
fprintf(stderr," DTS");
printpts(viu->dts);
printpts(mx->video_delay);
fprintf(stderr,"\n");
#endif
if (viu->length == 0){
get_next_video_unit(mx, viu);
}
}
