static int decode_sdpparam_h263(struct videnc_state *st, const struct pl *name,
const struct pl *val)
{
enum h263_fmt fmt = h263_fmt(name);
const int mpi = pl_u32(val);
if (fmt == H263_FMT_OTHER) {
DEBUG_NOTICE("h263: unknown param '%r'\n", name);
return 0;
}
if (mpi < 1 || mpi > 32) {
DEBUG_NOTICE("h263: %r: MPI out of range %d\n", name, mpi);
return 0;
}
if (st->u.h263.picszn >= ARRAY_SIZE(st->u.h263.picszv)) {
DEBUG_NOTICE("h263: picszv overflow: %r\n", name);
return 0;
}
st->u.h263.picszv[st->u.h263.picszn].fmt = fmt;
st->u.h263.picszv[st->u.h263.picszn].mpi = mpi;
++st->u.h263.picszn;
return 0;
}
static int uuid_init(const char *file)
{
char uuid[37];
uuid_t uu;
FILE *f = NULL;
int err = 0;
f = fopen(file, "r");
if (f) {
err = 0;
goto out;
}
f = fopen(file, "w");
if (!f) {
err = errno;
DEBUG_WARNING("init: fopen() %s (%m)\n", file, err);
goto out;
}
uuid_generate(uu);
uuid_unparse(uu, uuid);
re_fprintf(f, "%s", uuid);
DEBUG_NOTICE("init: generated new UUID (%s)\n", uuid);
out:
if (f)
fclose(f);
return err;
}
/**
* Decode an RTCP Transport Layer Feedback Message
*
* @param mb Buffer to decode
* @param msg RTCP Message to decode into
*
* @return 0 for success, otherwise errorcode
*/
int rtcp_rtpfb_decode(struct mbuf *mb, struct rtcp_msg *msg)
{
size_t i, sz;
if (!msg)
return EINVAL;
switch (msg->hdr.count) {
case RTCP_RTPFB_GNACK:
sz = msg->r.fb.n * sizeof(*msg->r.fb.fci.gnackv);
msg->r.fb.fci.gnackv = mem_alloc(sz, NULL);
if (!msg->r.fb.fci.gnackv)
return ENOMEM;
if (mbuf_get_left(mb) < msg->r.fb.n * GNACK_SIZE)
return EBADMSG;
for (i=0; i<msg->r.fb.n; i++) {
msg->r.fb.fci.gnackv[i].pid = ntohs(mbuf_read_u16(mb));
msg->r.fb.fci.gnackv[i].blp = ntohs(mbuf_read_u16(mb));
}
break;
default:
DEBUG_NOTICE("unknown RTPFB fmt %d\n", msg->hdr.count);
break;
}
return 0;
}
/**
* Add and initialise an external module with exports
*
* @param mp Pointer to allocated module object
* @param me Module exports
*
* @return 0 if success, otherwise errorcode
*/
int mod_add(struct mod **mp, const struct mod_export *me)
{
struct mod *m;
int err = 0;
if (!mp || !me)
return EINVAL;
/* check if already loaded */
m = mod_find(me->name);
if (m) {
DEBUG_NOTICE("module already loaded: %s\n", me->name);
return EALREADY;
}
m = mem_zalloc(sizeof(*m), mod_destructor);
if (!m)
return ENOMEM;
list_append(&modl, &m->le, m);
m->me = me;
if (err)
mem_deref(m);
else
*mp = m;
return err;
}
void audio_sdp_attr_decode(struct audio *a)
{
const char *attr;
if (!a) return;
/* This is probably only meaningful for audio data, but
may be used with other media types if it makes sense. */
attr = sdp_media_rattr(stream_sdpmedia(a->strm), "ptime");
if (attr) {
struct autx *tx = &a->tx;
uint32_t ptime_tx = atoi(attr);
if (ptime_tx && ptime_tx != a->tx.ptime) {
DEBUG_NOTICE("peer changed ptime_tx %u -> %u\n", a->tx.ptime, ptime_tx);
tx->ptime = ptime_tx;
if (tx->ac) {
tx->psize = 2 * get_framesize(tx->ac, ptime_tx);
}
}
}
}
void gst_video_free(gst_video_t *ctx)
{
struct gst_video_state *st = (struct gst_video_state *)ctx;
if (st) {
/* Remove asynchronous callbacks to prevent using gst_video_t context ("st") after releasing. */
g_signal_handler_disconnect(st->source, st->need_data_handler);
g_signal_handler_disconnect(st->source, st->enough_data_handler);
g_signal_handler_disconnect(st->sink, st->new_buffer_handler);
/* Stop thread. */
if (st->run) {
st->run = FALSE;
pthread_join(st->tid, NULL);
}
gst_object_unref(GST_OBJECT(st->source));
gst_object_unref(GST_OBJECT(st->sink));
gst_object_unref(GST_OBJECT(st->bus));
gst_element_set_state(st->pipeline, GST_STATE_NULL);
gst_object_unref(GST_OBJECT(st->pipeline));
mem_deref(st);
DEBUG_NOTICE("deinitialized\n");
}
}
static void tcp_close_handler(int err, void *arg)
{
struct tcpconn *tc = arg;
DEBUG_NOTICE("connection (%J) closed: %m\n", &tc->srv, err);
tcpconn_close(tc, err);
}
void rtcp_sess_rx_rtp(struct rtcp_sess *sess, uint16_t seq, uint32_t ts,
uint32_t ssrc, size_t payload_size,
const struct sa *peer)
{
struct rtp_member *mbr;
if (!sess)
return;
mbr = get_member(sess, ssrc);
if (!mbr) {
DEBUG_NOTICE("could not add member: 0x%08x\n", ssrc);
return;
}
if (!mbr->s) {
mbr->s = mem_zalloc(sizeof(*mbr->s), NULL);
if (!mbr->s) {
DEBUG_NOTICE("could not add sender: 0x%08x\n", ssrc);
return;
}
/* first packet - init sequence number */
source_init_seq(mbr->s, seq);
mbr->s->max_seq = seq - 1;
/* probation not used */
sa_cpy(&mbr->s->rtp_peer, peer);
++sess->senderc;
}
if (!source_update_seq(mbr->s, seq)) {
DEBUG_WARNING("rtp_update_seq() returned 0\n");
}
if (sess->srate_rx) {
uint32_t ts_arrive;
/* Convert from wall-clock time to timestamp units */
ts_arrive = (uint32_t)(tmr_jiffies()) * sess->srate_rx / 1000;
source_calc_jitter(mbr->s, ts, ts_arrive);
}
mbr->s->rtp_rx_bytes += payload_size;
}
/** Eliminating Redundant Candidates */
void icem_cand_redund_elim(struct icem *icem)
{
uint32_t n = ice_list_unique(&icem->lcandl, unique_handler);
if (n > 0) {
DEBUG_NOTICE("%s: redundant candidates eliminated: %u\n",
icem->name, n);
}
}
static void *internal_thread(void *arg)
{
struct gst_video_state *st = arg;
/* Now set to playing and iterate. */
DEBUG_NOTICE("Setting pipeline to PLAYING\n");
gst_element_set_state(st->pipeline, GST_STATE_PLAYING);
while (st->run) {
internal_bus_watch_handler(st);
}
DEBUG_NOTICE("Pipeline thread was stopped.\n");
return NULL;
}
static int send_tcp(struct dns_query *q)
{
const struct sa *srv;
struct tcpconn *tc;
int err = 0;
if (!q)
return EINVAL;
while (q->ntx < *q->srvc) {
srv = &q->srvv[q->ntx++];
DEBUG_NOTICE("trying tcp server#%u: %J\n", q->ntx-1, srv);
tc = list_ledata(hash_lookup(q->dnsc->ht_tcpconn,
sa_hash(srv, SA_ALL),
tcpconn_cmp_handler,
(void *)srv));
if (!tc) {
err = tcpconn_alloc(&tc, q->dnsc, srv);
if (err)
continue;
}
if (tc->connected) {
q->mb.pos = 0;
err = tcp_send(tc->conn, &q->mb);
if (err) {
tcpconn_close(tc, err);
continue;
}
tmr_start(&tc->tmr, tc->dnsc->conf.idle_timeout,
tcpconn_timeout_handler, tc);
DEBUG_NOTICE("tcp send %J\n", srv);
}
list_append(&tc->ql, &q->le_tc, q);
q->tc = mem_ref(tc);
break;
}
return err;
}
/**
* Get the local IP address of the device
*
* @note Requires at least one IP packet sent in advance!
*/
int net_if_getaddr4(const char *ifname, int af, struct sa *ip)
{
(void)ifname;
if (AF_INET != af)
return EAFNOSUPPORT;
/* Already cached? */
if (sa_isset(&local_ip, SA_ADDR)) {
sa_cpy(ip, &local_ip);
return 0;
}
RSocketServ ss;
RSocket s;
TInt ret;
ret = ss.Connect();
if (KErrNone != ret) {
DEBUG_WARNING("connecting to socket server fail (ret=%d)\n",
ret);
return ECONNREFUSED;
}
ret = s.Open(ss, KAfInet, KSockDatagram, KProtocolInetUdp);
if (KErrNone != ret) {
DEBUG_WARNING("open socket failed (ret=%d)\n", ret);
return ECONNREFUSED;
}
TInetAddr bind;
bind.SetPort(0);
bind.SetAddress(KInetAddrAny);
ret = s.Bind(bind);
if (KErrNone != ret) {
DEBUG_WARNING("bind socket failed (ret=%d)\n", ret);
return ECONNREFUSED;
}
TInetAddr local;
s.LocalName(local);
s.Close();
ss.Close();
sa_set_in(&local_ip, local.Address(), local.Port());
DEBUG_NOTICE("local IP addr: %j\n", &local_ip);
if (!sa_isset(&local_ip, SA_ADDR))
return EINVAL;
sa_cpy(ip, &local_ip);
return 0;
}
static void tcpconn_timeout_handler(void *arg)
{
struct tcpconn *tc = arg;
DEBUG_NOTICE("tcp (%J) %s timeout \n", &tc->srv,
tc->connected ? "idle" : "connect");
tcpconn_close(tc, ETIMEDOUT);
}
static void tcp_close_handler(int err, void *arg)
{
struct nat_mapping *nm = arg;
DEBUG_NOTICE("TCP Connection Closed (%m)\n", err);
if (err) {
nm->mh(err, NAT_TYPE_UNKNOWN, nm->arg);
}
}
/**
* Print the name information
*
* @param fd Device file descriptor
*/
void print_name(int fd)
{
char name[256]= "Unknown";
if (ioctl(fd, EVIOCGNAME(sizeof(name)), name) < 0) {
perror("evdev ioctl");
}
DEBUG_NOTICE("evdev device name: %s\n", name);
}
/* The incoming data should not get here */
static void dummy_udp_recv(const struct sa *src, struct mbuf *mb, void *arg)
{
struct ice_lcand *lcand = arg;
DEBUG_NOTICE("@@@@ NO-ONE cared about this UDP packet? @@@@@"
" (%zu bytes from %J to %s.%J)\n",
mbuf_get_left(mb), src,
ice_cand_type2name(lcand->attr.type),
&lcand->attr.addr);
}
static void audio_ptime_tx_set(struct audio *a, uint32_t ptime_tx)
{
if (ptime_tx != a->tx.ptime) {
DEBUG_NOTICE("peer changed ptime_tx %u -> %u\n",
a->tx.ptime, ptime_tx);
a->tx.ptime = ptime_tx;
/* todo: refresh a->psize */
}
}
static void internal_bus_watch_handler(struct gst_video_state *st)
{
GstTagList *tag_list;
gchar *title;
GError *err;
gchar *d;
GstMessage *msg = gst_bus_pop(st->bus);
if (!msg) {
// take a nap (300ms)
usleep(300 * 1000);
return;
}
switch (GST_MESSAGE_TYPE(msg)) {
case GST_MESSAGE_EOS:
/* XXX decrementing repeat count? */
/* Re-start stream */
gst_element_set_state(st->pipeline, GST_STATE_NULL);
gst_element_set_state(st->pipeline, GST_STATE_PLAYING);
break;
case GST_MESSAGE_ERROR:
gst_message_parse_error(msg, &err, &d);
DEBUG_WARNING("Error: %d(%m) message=%s\n", err->code,
err->code, err->message);
DEBUG_WARNING("Debug: %s\n", d);
g_free(d);
g_error_free(err);
st->run = FALSE;
break;
case GST_MESSAGE_TAG:
gst_message_parse_tag(msg, &tag_list);
if (gst_tag_list_get_string(tag_list, GST_TAG_TITLE, &title)) {
DEBUG_NOTICE("Title: %s\n", title);
g_free(title);
}
break;
default:
break;
}
gst_message_unref(msg);
}
static int update(struct aufilt_st **stp, struct aufilt *af,
const struct aufilt_prm *encprm,
const struct aufilt_prm *decprm)
{
char filename_enc[128], filename_dec[128];
SF_INFO sfinfo_enc, sfinfo_dec;
struct sndfile_st *st;
(void)af;
st = mem_zalloc(sizeof(*st), sndfile_destructor);
if (!st)
return EINVAL;
(void)re_snprintf(filename_enc, sizeof(filename_enc),
"dump-%u-enc.wav", count);
(void)re_snprintf(filename_dec, sizeof(filename_dec),
"dump-%u-dec.wav", count);
sfinfo_enc.samplerate = encprm->srate;
sfinfo_enc.channels = encprm->ch;
sfinfo_enc.format = SF_FORMAT_WAV | SF_FORMAT_PCM_16;
sfinfo_dec.samplerate = decprm->srate;
sfinfo_dec.channels = decprm->ch;
sfinfo_dec.format = SF_FORMAT_WAV | SF_FORMAT_PCM_16;
st->enc = sf_open(filename_enc, SFM_WRITE, &sfinfo_enc);
if (!st->enc) {
DEBUG_WARNING("could not open: %s\n", filename_enc);
puts(sf_strerror(NULL));
goto error;
}
st->dec = sf_open(filename_dec, SFM_WRITE, &sfinfo_dec);
if (!st->dec) {
DEBUG_WARNING("could not open: %s\n", filename_dec);
puts(sf_strerror(NULL));
goto error;
}
DEBUG_NOTICE("dumping audio to %s and %s\n",
filename_enc, filename_dec);
++count;
*stp = (struct aufilt_st *)st;
return 0;
error:
mem_deref(st);
return ENOMEM;
}
int net_conn_start(net_conn_h *ch, uint32_t id, bool prompt)
{
DEBUG_NOTICE("rconn_start: iap_id=%u prompt=%d\n", id, prompt);
if (rconn)
return 0;
TRAPD(ret, rconn = CRconn::NewL(ch));
if (KErrNone != ret)
return kerr2errno(ret);
return kerr2errno(rconn->Start(id, prompt));
}
/**
* Decode an RTCP Payload-Specific Feedback Message
*
* @param mb Buffer to decode
* @param msg RTCP Message to decode into
*
* @return 0 for success, otherwise errorcode
*/
int rtcp_psfb_decode(struct mbuf *mb, struct rtcp_msg *msg)
{
size_t i, sz;
if (!msg)
return EINVAL;
switch (msg->hdr.count) {
case RTCP_PSFB_PLI:
/* no params */
break;
case RTCP_PSFB_SLI:
sz = msg->r.fb.n * sizeof(*msg->r.fb.fci.sliv);
msg->r.fb.fci.sliv = mem_alloc(sz, NULL);
if (!msg->r.fb.fci.sliv)
return ENOMEM;
if (mbuf_get_left(mb) < msg->r.fb.n * SLI_SIZE)
return EBADMSG;
for (i=0; i<msg->r.fb.n; i++) {
const uint32_t v = ntohl(mbuf_read_u32(mb));
msg->r.fb.fci.sliv[i].first = v>>19 & 0x1fff;
msg->r.fb.fci.sliv[i].number = v>> 6 & 0x1fff;
msg->r.fb.fci.sliv[i].picid = v>> 0 & 0x003f;
}
break;
case RTCP_PSFB_AFB:
sz = msg->r.fb.n * 4;
if (mbuf_get_left(mb) < sz)
return EBADMSG;
msg->r.fb.fci.afb = mbuf_alloc_ref(mb);
if (!msg->r.fb.fci.afb)
return ENOMEM;
msg->r.fb.fci.afb->end = msg->r.fb.fci.afb->pos + sz;
mbuf_advance(mb, sz);
break;
default:
DEBUG_NOTICE("unknown PSFB fmt %d\n", msg->hdr.count);
break;
}
return 0;
}
static void purge_relayed(struct icem *icem, struct icem_comp *comp)
{
DEBUG_NOTICE("{%s.%u} purge local RELAY candidates\n",
icem->name, comp->id);
/*
* Purge all Candidate-Pairs where the Local candidate
* is of type "Relay"
*/
icem_candpairs_flush(&icem->checkl, CAND_TYPE_RELAY, comp->id);
icem_candpairs_flush(&icem->validl, CAND_TYPE_RELAY, comp->id);
comp->turnc = mem_deref(comp->turnc);
}
static void *thread(void *arg)
{
struct ausrc_st *st = arg;
/* Now set to playing and iterate. */
DEBUG_NOTICE("Setting pipeline to PLAYING\n");
gst_element_set_state(st->pipeline, GST_STATE_PLAYING);
while (st->run) {
g_main_loop_run(st->loop);
}
return NULL;
}
static void mod_destructor(void *data)
{
struct mod *m = data;
const struct mod_export *me = m->me;
int err;
if (me && me->close && ((err = me->close()) != 0)) {
DEBUG_NOTICE("close: error (%m)\n", err);
}
list_unlink(&m->le);
_mod_close(m->h);
}
static int mod_gst_init(void)
{
gchar *s;
gst_init(0, NULL);
s = gst_version_string();
DEBUG_NOTICE("init: %s\n", s);
g_free(s);
return ausrc_register(&ausrc, "gst", gst_alloc);
}
void *trice_lcand_sock(struct trice *icem, const struct ice_lcand *lcand)
{
struct ice_lcand *base = NULL;
if (!icem || !lcand)
return NULL;
if (sa_isset(&lcand->base_addr, SA_ALL)) {
enum ice_cand_type base_type;
base_type = ice_cand_type_base(lcand->attr.type);
base = trice_lcand_find(icem,
base_type,
lcand->attr.compid,
lcand->attr.proto,
&lcand->base_addr);
}
/* note: original lcand has presedence, fallback to base-candidate */
switch (lcand->attr.type) {
case ICE_CAND_TYPE_HOST:
return lcand->us;
case ICE_CAND_TYPE_SRFLX:
case ICE_CAND_TYPE_PRFLX:
if (lcand->us)
return lcand->us;
else if (base && base->us)
return base->us;
else {
DEBUG_NOTICE("lcand_sock: no SOCK or BASE for "
" type '%s'\n",
ice_cand_type2name(lcand->attr.type));
return NULL;
}
break;
case ICE_CAND_TYPE_RELAY:
return lcand->us;
default:
return NULL;
}
return NULL;
}
/*The password code is not thread safe*/
static int password_cb(char *buf, int size, int rwflag, void *userdata)
{
struct tls *tls = userdata;
(void)rwflag;
DEBUG_NOTICE("password callback\n");
if (size < (int)strlen(tls->pass)+1)
return 0;
strncpy(buf, tls->pass, size);
return (int)strlen(tls->pass);
}
int ICACHE_FLASH_ATTR
user_dns_request(struct user_dns_param *param)
{
int err = EFAULT;
if(!param)
{
DEBUG_WARNING("EINVAL\n");
return EINVAL;
}
DEBUG_INFO("%s\n", ipaddr_ntoa(¶m->ip));
err = dns_gethostbyname(param->hostname, ¶m->ip, on_found, param);
DEBUG_INFO("dns_gethostbyname=%d | %s\n", err, lwip_strerr(err));
switch(err)
{
case ERR_INPROGRESS:
DEBUG_NOTICE("wait for callback\n");
os_timer_setfn(¶m->tmr, (os_timer_func_t *)on_timer, param);
os_timer_arm(¶m->tmr, 1000, 0);
err = 0;
break;
case ERR_OK:
DEBUG_NOTICE("is ipaddr\n");
os_timer_setfn(¶m->tmr, (os_timer_func_t *)on_timer, param);
os_timer_arm(¶m->tmr, 1, 0);
err = 0;
break;
default:
DEBUG_WARNING("bad hostname\n");
break;
}
return err;
}
/**
* Pruning the Pairs
*/
static void candpair_prune(struct icem *icem)
{
/* The agent MUST prune the list.
This is done by removing a pair if its local and remote
candidates are identical to the local and remote candidates
of a pair higher up on the priority list.
NOTE: This logic assumes the list is sorted by priority
*/
uint32_t n = ice_list_unique(&icem->checkl, unique_handler);
if (n > 0) {
DEBUG_NOTICE("%s: pruned candidate pairs: %u\n",
icem->name, n);
}
}
static void decode_param(const struct pl *name, const struct pl *val,
void *arg)
{
struct aucodec_st *st = arg;
int err;
if (0 == pl_strcasecmp(name, "bitrate")) {
st->bitrate = pl_u32(val) * 1000;
}
else if (0 == pl_strcasecmp(name, "frame-size")) {
st->frame_size = pl_u32(val);
if (st->frame_size & 0x1) {
DEBUG_WARNING("frame-size is NOT even: %u\n",
st->frame_size);
}
}
else if (0 == pl_strcasecmp(name, "low-overhead")) {
struct pl fs, bpfv;
uint32_t i;
st->low_overhead = true;
err = re_regex(val->p, val->l, "[0-9]+/[0-9,]+", &fs, &bpfv);
if (err)
return;
st->frame_size = pl_u32(&fs);
for (i=0; i<ARRAY_SIZE(st->bpfv) && bpfv.l > 0; i++) {
struct pl bpf, co;
co.l = 0;
if (re_regex(bpfv.p, bpfv.l, "[0-9]+[,]*", &bpf, &co))
break;
pl_advance(&bpfv, bpf.l + co.l);
st->bpfv[i] = pl_u32(&bpf);
}
st->bpfn = i;
}
else {
DEBUG_NOTICE("unknown param: %r = %r\n", name, val);
}
}
