int
layered_decoder_decode(u_char *state,
struct s_pb *in,
struct s_pb *out,
timestamp_t now)
{
struct s_pb_iterator *pi;
u_char *c_get;
channel_data *c;
uint32_t clen;
timestamp_t playout;
UNUSED(state);
pb_iterator_create(in, &pi);
assert(pi != NULL);
while(pb_iterator_get_at(pi, &c_get, &clen, &playout)) {
c = (channel_data*)c_get;
assert(c != NULL);
assert(clen == sizeof(channel_data));
if (ts_gt(playout, now)) {
/* Playout point of unit is after now. Stop! */
break;
}
pb_iterator_detach_at(pi, &c_get, &clen, &playout);
layered_decoder_reorganise(c, out, playout);
}
pb_iterator_destroy(in, &pi);
return TRUE;
}
int
redundancy_decoder_decode(u_char *state,
struct s_pb *in,
struct s_pb *out,
timestamp_t now)
{
struct s_pb_iterator *pi;
u_char *c_get;
channel_data *c;
uint32_t clen;
timestamp_t cplayout;
pb_iterator_create(in, &pi);
assert(pi != NULL);
assert(state == NULL); /* No decoder state necesssary */
UNUSED(state);
while(pb_iterator_get_at(pi, &c_get, &clen, &cplayout)) {
c = (channel_data*)c_get;
assert(c != NULL);
assert(clen == sizeof(channel_data));
if (ts_gt(cplayout, now)) {
break;
}
pb_iterator_detach_at(pi, &c_get, &clen, &cplayout);
c = (channel_data*)c_get;
assert(c->nelem == 1);
redundancy_decoder_output(c->elem[0], out, cplayout);
channel_data_destroy(&c, sizeof(channel_data));
}
pb_iterator_destroy(in, &pi);
return TRUE;
}
int
pktbuf_dequeue(struct s_pktbuf *pb, rtp_packet **pp)
{
timestamp_t playout;
uint32_t psize;
if (pb_iterator_rwd(pb->rtp_iterator) == FALSE) {
return FALSE;
}
pb_iterator_detach_at(pb->rtp_iterator, (u_char**)pp, &psize, &playout);
return TRUE;
}
int
vanilla_decoder_decode(u_char *state,
struct s_pb *in,
struct s_pb *out,
timestamp_t now)
{
struct s_pb_iterator *pi;
channel_unit *cu;
u_char *c_get;
channel_data *c;
uint32_t clen;
timestamp_t playout;
assert(state == NULL); /* No decoder state needed */
UNUSED(state);
pb_iterator_create(in, &pi);
assert(pi != NULL);
while(pb_iterator_get_at(pi, &c_get, &clen, &playout)) {
c = (channel_data*)c_get;
assert(c != NULL);
assert(clen == sizeof(channel_data));
if (ts_gt(playout, now)) {
/* Playout point of unit is after now. Stop! */
break;
}
pb_iterator_detach_at(pi, &c_get, &clen, &playout);
c = (channel_data*)c_get;
assert(c != NULL);
assert(c->nelem == 1);
cu = c->elem[0];
vanilla_decoder_output(cu, out, playout);
channel_data_destroy(&c, sizeof(channel_data));
}
pb_iterator_destroy(in, &pi);
return TRUE;
}
int
layered_encoder_encode (u_char *state,
struct s_pb *in,
struct s_pb *out,
uint32_t upp)
{
uint32_t m_len;
timestamp_t playout;
struct s_pb_iterator *pi;
u_char *m_get;
media_data *m;
lay_state *le = (lay_state*)state;
assert(upp != 0 && upp <= MAX_UNITS_PER_PACKET);
pb_iterator_create(in, &pi);
pb_iterator_advance(pi); /* Move to first element */
while(pb_iterator_detach_at(pi, &m_get, &m_len, &playout)) {
/* Remove element from playout buffer - it belongs to
* the layered encoder now.
*/
m = (media_data*)m_get;
assert(m != NULL);
if (le->nelem == 0) {
/* If it's the first unit make a note of it's
* playout */
le->playout = playout;
if (m->nrep == 0) {
/* We have no data ready to go and no data
* came off on incoming queue.
*/
media_data_destroy(&m, sizeof(media_data));
continue;
}
} else {
/* Check for early send required:
* (a) if this unit has no media respresentations
* e.g. end of talkspurt.
* (b) codec type of incoming unit is different
* from what is on queue.
*/
if (m->nrep == 0) {
layered_encoder_output(le, out);
media_data_destroy(&m, sizeof(media_data));
continue;
} else if (m->rep[0]->id != le->codec_id) {
layered_encoder_output(le, out);
}
}
assert(m_len == sizeof(media_data));
le->codec_id = m->rep[0]->id;
le->elem[le->nelem] = m;
le->nelem++;
if (le->nelem >= (uint32_t)upp) {
layered_encoder_output(le, out);
}
}
pb_iterator_destroy(in, &pi);
xmemchk();
return TRUE;
}
int
redundancy_encoder_encode (u_char *state,
struct s_pb *in,
struct s_pb *out,
uint32_t upp)
{
uint32_t m_len;
timestamp_t playout;
struct s_pb_iterator *pi;
u_char *m_get;
media_data *m;
red_enc_state *re = (red_enc_state*)state;
assert(upp != 0 && upp <= MAX_UNITS_PER_PACKET);
pb_iterator_create(in, &pi);
assert(pi != NULL);
pb_iterator_advance(pi);
while(pb_iterator_detach_at(pi, &m_get, &m_len, &playout)) {
m = (media_data*)m_get;
/* Remove element from playout buffer - it belongs to
* the redundancy encoder now. */
#ifdef DEBUG_REDUNDANCY
debug_msg("claimed %d, prev %d\n", playout.ticks, re->last_in.ticks);
#endif /* DEBUG_REDUNDANCY */
assert(m != NULL);
if (re->units_ready == 0) {
re->last_in = playout;
re->last_in.ticks--;
}
assert(ts_gt(playout, re->last_in));
re->last_in = playout;
if (m->nrep > 0) {
pb_add(re->media_buffer,
(u_char*)m,
m_len,
playout);
re->units_ready++;
} else {
/* Incoming unit has no data so transmission is
* not happening.
*/
#ifdef DEBUG_REDUNDANCY
debug_msg("No incoming data\n");
#endif /* DEBUG_REDUNDANCY */
media_data_destroy(&m, sizeof(media_data));
pb_flush(re->media_buffer);
re->units_ready = 0;
continue;
}
if (re->units_ready && (re->units_ready % upp) == 0) {
channel_data *cd;
int s;
cd = redundancy_encoder_output(re, upp);
assert(cd != NULL);
s = pb_add(out, (u_char*)cd, sizeof(channel_data), playout);
#ifdef DEBUG_REDUNDANCY
debug_msg("Ready %d, Added %d\n", re->units_ready, playout.ticks);
#endif /* DEBUG_REDUNDANCY */
assert(s);
}
}
pb_iterator_destroy(in, &pi);
return TRUE;
}
