/* * 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); } }