enum sllp_err packet_process (sllp_instance_t *sllp, struct sllp_raw_packet *recv_pkt, struct sllp_raw_packet *send_pkt) { if(!sllp || !recv_pkt || !send_pkt) return SLLP_ERR_PARAM_INVALID; // Interpret packet payload as a message struct raw_message *recv_raw_msg = (struct raw_message *) recv_pkt->data; struct raw_message *send_raw_msg = (struct raw_message *) send_pkt->data; // Create proper messages from the raw messages struct message recv_msg, send_msg; recv_msg.command_code = (enum command_code) recv_raw_msg->command_code; recv_msg.payload_size = decode_size(recv_raw_msg->encoded_size); recv_msg.payload = recv_raw_msg->payload; send_msg.payload = send_raw_msg->payload; // Check inconsistency between the size of the received data and the size // specified in the message header if(!is_size_ok(recv_pkt->len, recv_msg.payload_size)) message_set_answer(&send_msg, CMD_ERR_MALFORMED_MESSAGE); else message_process(sllp, &recv_msg, &send_msg); send_raw_msg->command_code = send_msg.command_code; send_raw_msg->encoded_size = encode_size(send_msg.payload_size); send_pkt->len = send_msg.payload_size + 2; return SLLP_SUCCESS; }
int setup_ts(struct termios* pts, int baud, int size, int parity, int stop, int timeout) { //encode baud speed_t cbaud = encode_baud(baud); //check baud if (cbaud == 0) return errno = EINVAL?-1:0; //encode size tcflag_t csize = encode_size(size); //check size if (csize == 0) return errno = EINVAL?-1:0; //check parity if ((parity < 0) || (parity > 2)) return errno = EINVAL?-1:0; //check stop if ((stop < 1) || (stop > 2)) return errno = EINVAL?-1:0; //check timeout if (timeout < 0) return errno = EINVAL?-1:0; //cleanup bzero(pts, sizeof(struct termios)); //default settings cfmakeraw(pts); //reset input modes pts->c_iflag = 0; //reset output modes pts->c_oflag = 0; //set input baudrate cfsetispeed(pts, cbaud); //set output baudrate cfsetospeed(pts, cbaud); //local mode pts->c_cflag |= CLOCAL; //enable the receiver pts->c_cflag |= CREAD; //disable hardware flow control pts->c_cflag &= ~CRTSCTS; //no parity pts->c_cflag &= ~PARENB; //stopbit if (stop == 1) pts->c_cflag &= ~CSTOPB; if (stop == 2) pts->c_cflag |= CSTOPB; //mask datasize pts->c_cflag &= ~CSIZE; //datasize 5,6,7,8 bit pts->c_cflag |= csize; //data processed as raw input (noncanonical) pts->c_lflag &= ~ICANON; //no echo pts->c_lflag &= ~ECHO; //no signal pts->c_lflag &= ~ISIG; //minimum number of characters pts->c_cc[VMIN] = timeout?0:1; //timeout in 1/10s pts->c_cc[VTIME] = timeout?(timeout / 100):0; return 0; }
void encode_event(DBusMessageIter *iter, int *err, const alarm_event_t *eve, const char **def_args) { encode_cookie (iter, err, &eve->ALARMD_PRIVATE(cookie)); encode_time (iter, err, &eve->ALARMD_PRIVATE(trigger)); encode_string (iter, err, &eve->title); encode_string (iter, err, &eve->message); encode_string (iter, err, &eve->sound); encode_string (iter, err, &eve->icon); encode_unsigned (iter, err, &eve->flags); encode_string (iter, err, &eve->alarm_appid); encode_time (iter, err, &eve->alarm_time); encode_tm (iter, err, &eve->alarm_tm); encode_string (iter, err, &eve->alarm_tz); encode_time (iter, err, &eve->recur_secs); encode_int (iter, err, &eve->recur_count); encode_time (iter, err, &eve->snooze_secs); encode_time (iter, err, &eve->snooze_total); encode_size (iter, err, &eve->action_cnt); encode_int (iter, err, &eve->response); for( size_t i = 0; i < eve->action_cnt; ++i ) { encode_action(iter, err, &eve->action_tab[i], def_args); } encode_size (iter, err, &eve->recurrence_cnt); for( size_t i = 0; i < eve->recurrence_cnt; ++i ) { encode_recur(iter, err, &eve->recurrence_tab[i]); } encode_size (iter, err, &eve->attr_cnt); for( size_t i = 0; i < eve->attr_cnt; ++i ) { encode_attr(iter, err, eve->attr_tab[i]); } }
int rp_get_packet(Repacketizer *st, int interval, unsigned char *data) { /* Returns number of bytes written. interval is specified in samples at 48k. *data must have at least 61250 bytes allocated. */ int duration = st->samples_sent; int count = 0, i; short size[48]; unsigned char *start = data; FrameCell *fc = st->buffer.first; if (interval > 48*120) interval = 48*120; if (st->samples_sent >= interval) { /* Reset delay accumulator; there must have been an interval change */ st->samples_sent = 0; } if (st->samples_sent + st->buffer.total_duration < interval) return 0; while (duration < interval && duration + fc->duration <= 48*120) { duration += fc->duration; size[count] = fc->size; fc = fc->next; count += 1; } fc = st->buffer.first; *data++ = fc->toc | 0x3; /* Force code 3 */ *data++ = 49; /* Multi-mode */ *data++ = count | 0x80; /* Number of frames, VBR, no padding */ for(i=0;i<count-1;i++) data += encode_size(size[i], data); for(i=0;i<count;i++) { if (i > 0) *data++ = fc->toc & (~0x3); /* Force code 0 */ memcpy(data, fc->data, fc->size); data += fc->size; st->buffer.total_duration -= fc->duration; st->buffer.first = fc->next; rp_clear_framecell(fc); free(fc); st->buffer.numframes--; fc = st->buffer.first; } if (!st->buffer.first) st->buffer.last = NULL; return data-start; }
opus_int32 opus_repacketizer_out_range_impl(OpusRepacketizer *rp, int begin, int end, unsigned char *data, opus_int32 maxlen, int self_delimited, int pad) { int i, count; opus_int32 tot_size; opus_int16 *len; const unsigned char **frames; unsigned char * ptr; if (begin<0 || begin>=end || end>rp->nb_frames) { /*fprintf(stderr, "%d %d %d\n", begin, end, rp->nb_frames);*/ return OPUS_BAD_ARG; } count = end-begin; len = rp->len+begin; frames = rp->frames+begin; if (self_delimited) tot_size = 1 + (len[count-1]>=252); else tot_size = 0; ptr = data; if (count==1) { /* Code 0 */ tot_size += len[0]+1; if (tot_size > maxlen) return OPUS_BUFFER_TOO_SMALL; *ptr++ = rp->toc&0xFC; } else if (count==2) { if (len[1] == len[0]) { /* Code 1 */ tot_size += 2*len[0]+1; if (tot_size > maxlen) return OPUS_BUFFER_TOO_SMALL; *ptr++ = (rp->toc&0xFC) | 0x1; } else { /* Code 2 */ tot_size += len[0]+len[1]+2+(len[0]>=252); if (tot_size > maxlen) return OPUS_BUFFER_TOO_SMALL; *ptr++ = (rp->toc&0xFC) | 0x2; ptr += encode_size(len[0], ptr); } } if (count > 2 || (pad && tot_size < maxlen)) { /* Code 3 */ int vbr; int pad_amount=0; /* Restart the process for the padding case */ ptr = data; if (self_delimited) tot_size = 1 + (len[count-1]>=252); else tot_size = 0; vbr = 0; for (i=1;i<count;i++) { if (len[i] != len[0]) { vbr=1; break; } } if (vbr) { tot_size += 2; for (i=0;i<count-1;i++) tot_size += 1 + (len[i]>=252) + len[i]; tot_size += len[count-1]; if (tot_size > maxlen) return OPUS_BUFFER_TOO_SMALL; *ptr++ = (rp->toc&0xFC) | 0x3; *ptr++ = count | 0x80; } else { tot_size += count*len[0]+2; if (tot_size > maxlen) return OPUS_BUFFER_TOO_SMALL; *ptr++ = (rp->toc&0xFC) | 0x3; *ptr++ = count; } pad_amount = pad ? (maxlen-tot_size) : 0; if (pad_amount != 0) { int nb_255s; data[1] |= 0x40; nb_255s = (pad_amount-1)/255; for (i=0;i<nb_255s;i++) *ptr++ = 255; *ptr++ = pad_amount-255*nb_255s-1; tot_size += pad_amount; } if (vbr) { for (i=0;i<count-1;i++) ptr += encode_size(len[i], ptr); } } if (self_delimited) { int sdlen = encode_size(len[count-1], ptr); ptr += sdlen; } /* Copy the actual data */ for (i=0;i<count;i++) { /* Using OPUS_MOVE() instead of OPUS_COPY() in case we're doing in-place padding from opus_packet_pad or opus_packet_unpad(). */ celt_assert(frames[i] + len[i] <= data || ptr <= frames[i]); OPUS_MOVE(ptr, frames[i], len[i]); ptr += len[i]; } if (pad) { /* Fill padding with zeros. */ while (ptr<data+maxlen) *ptr++=0; } return tot_size; }