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;
}
