static int pthread_timer_set_rate(void *data, unsigned int rate)
{
struct pthread_timer *timer = data;
if (rate > MAX_RATE) {
ast_log(LOG_ERROR, "res_timing_pthread only supports timers at a "
"max rate of %d / sec\n", MAX_RATE);
errno = EINVAL;
return -1;
}
ao2_lock(timer);
if ((timer->rate = rate)) {
timer->interval = roundf(1000.0 / ((float) rate));
timer->start = ast_tvnow();
timer->state = TIMER_STATE_TICKING;
} else {
timer->interval = 0;
timer->start = ast_tv(0, 0);
timer->state = TIMER_STATE_IDLE;
}
timer->tick_count = 0;
ao2_unlock(timer);
return 0;
}
/*!
* \brief Retrieve a ast_sip_contact_status object from sorcery creating
* one if not found.
*/
struct ast_sip_contact_status *ast_res_pjsip_find_or_create_contact_status(const struct ast_sip_contact *contact)
{
struct ast_sip_contact_status *status;
SCOPED_MUTEX(lock, &creation_lock);
status = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), CONTACT_STATUS,
ast_sorcery_object_get_id(contact));
if (status) {
return status;
}
status = ast_sorcery_alloc(ast_sip_get_sorcery(), CONTACT_STATUS,
ast_sorcery_object_get_id(contact));
if (!status) {
ast_log(LOG_ERROR, "Unable to create ast_sip_contact_status for contact %s/%s\n",
contact->aor, contact->uri);
return NULL;
}
ast_string_field_set(status, uri, contact->uri);
status->rtt_start = ast_tv(0, 0);
status->rtt = 0;
if (ast_sorcery_create(ast_sip_get_sorcery(), status)) {
ast_log(LOG_ERROR, "Unable to persist ast_sip_contact_status for contact %s\n",
contact->uri);
ao2_ref(status, -1);
return NULL;
}
ast_statsd_log_string_va("PJSIP.contacts.states.%s", AST_STATSD_GAUGE,
"+1", 1.0, ast_sip_get_contact_status_label(status->status));
return status;
}
int ast_sched_add_variable(struct sched_context *con, int when, ast_sched_cb callback, void *data, int variable)
{
/*
* Schedule callback(data) to happen when ms into the future
*/
struct sched *tmp;
int res = -1;
DEBUG(ast_log(LOG_DEBUG, "ast_sched_add()\n"));
if (!when) {
ast_log(LOG_NOTICE, "Scheduled event in 0 ms?\n");
return -1;
}
ast_mutex_lock(&con->lock);
if ((tmp = sched_alloc(con))) {
tmp->id = con->eventcnt++;
tmp->callback = callback;
tmp->data = data;
tmp->resched = when;
tmp->variable = variable;
tmp->when = ast_tv(0, 0);
if (sched_settime(&tmp->when, when)) {
sched_release(con, tmp);
} else {
schedule(con, tmp);
res = tmp->id;
}
}
#ifdef DUMP_SCHEDULER
/* Dump contents of the context while we have the lock so nothing gets screwed up by accident. */
ast_sched_dump(con);
#endif
ast_mutex_unlock(&con->lock);
return res;
}
/*!
* \brief Retrieve a ast_sip_contact_status object from sorcery creating
* one if not found.
*/
struct ast_sip_contact_status *ast_res_pjsip_find_or_create_contact_status(const struct ast_sip_contact *contact)
{
struct ast_sip_contact_status *status;
status = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), CONTACT_STATUS,
ast_sorcery_object_get_id(contact));
if (status) {
return status;
}
status = ast_sorcery_alloc(ast_sip_get_sorcery(), CONTACT_STATUS,
ast_sorcery_object_get_id(contact));
if (!status) {
ast_log(LOG_ERROR, "Unable to create ast_sip_contact_status for contact %s\n",
contact->uri);
return NULL;
}
status->status = UNKNOWN;
status->rtt_start = ast_tv(0, 0);
status->rtt = 0;
if (ast_sorcery_create(ast_sip_get_sorcery(), status)) {
ast_log(LOG_ERROR, "Unable to persist ast_sip_contact_status for contact %s\n",
contact->uri);
ao2_ref(status, -1);
return NULL;
}
return status;
}
int ast_sched_runq(struct sched_context *con)
{
/*
* Launch all events which need to be run at this time.
*/
struct sched *current;
struct timeval tv;
int x=0;
int res;
DEBUG(ast_log(LOG_DEBUG, "ast_sched_runq()\n"));
ast_mutex_lock(&con->lock);
tv = ast_tvadd(ast_tvnow(), ast_tv(0, 1000));
for(;;) {
if (!con->schedq)
break;
/* schedule all events which are going to expire within 1ms.
* We only care about millisecond accuracy anyway, so this will
* help us get more than one event at one time if they are very
* close together.
*/
if (SOONER(con->schedq->when, tv)) {
current = con->schedq;
con->schedq = con->schedq->next;
con->schedcnt--;
/*
* At this point, the schedule queue is still intact. We
* have removed the first event and the rest is still there,
* so it's permissible for the callback to add new events, but
* trying to delete itself won't work because it isn't in
* the schedule queue. If that's what it wants to do, it
* should return 0.
*/
ast_mutex_unlock(&con->lock);
res = current->callback(current->data);
ast_mutex_lock(&con->lock);
if (res) {
/*
* If they return non-zero, we should schedule them to be
* run again.
*/
if (sched_settime(¤t->when, current->variable? res : current->resched)) {
sched_release(con, current);
} else
schedule(con, current);
} else {
/* No longer needed, so release it */
sched_release(con, current);
}
x++;
} else
break;
}
ast_mutex_unlock(&con->lock);
return x;
}
static void *do_timing(void *arg)
{
struct timeval next_wakeup = ast_tvnow();
while (!timing_thread.stop) {
struct timespec ts = { 0, };
ao2_callback(pthread_timers, OBJ_NODATA, run_timer, NULL);
next_wakeup = ast_tvadd(next_wakeup, ast_tv(0, 5000));
ts.tv_sec = next_wakeup.tv_sec;
ts.tv_nsec = next_wakeup.tv_usec * 1000;
ast_mutex_lock(&timing_thread.lock);
if (!timing_thread.stop) {
if (ao2_container_count(pthread_timers)) {
ast_cond_timedwait(&timing_thread.cond, &timing_thread.lock, &ts);
} else {
ast_cond_wait(&timing_thread.cond, &timing_thread.lock);
}
}
ast_mutex_unlock(&timing_thread.lock);
}
return NULL;
}
static int rtt_start_handler(const struct aco_option *opt,
struct ast_variable *var, void *obj)
{
struct ast_sip_contact_status *status = obj;
long int sec, usec;
if (sscanf(var->value, "%ld.%06ld", &sec, &usec) != 2) {
return -1;
}
status->rtt_start = ast_tv(sec, usec);
return 0;
}
/*! Build a set of translators based upon the given source and destination formats */
struct ast_trans_pvt *ast_translator_build_path(int dest, int source)
{
struct ast_trans_pvt *tmpr = NULL, *tmp = NULL;
source = powerof(source);
dest = powerof(dest);
while(source != dest) {
if (!tr_matrix[source][dest].step) {
/* We shouldn't have allocated any memory */
ast_log(LOG_WARNING, "No translator path from %s to %s\n",
ast_getformatname(source), ast_getformatname(dest));
return NULL;
}
if (tmp) {
tmp->next = malloc(sizeof(*tmp));
tmp = tmp->next;
} else
tmp = malloc(sizeof(*tmp));
if (!tmp) {
ast_log(LOG_WARNING, "Out of memory\n");
if (tmpr)
ast_translator_free_path(tmpr);
return NULL;
}
/* Set the root, if it doesn't exist yet... */
if (!tmpr)
tmpr = tmp;
tmp->next = NULL;
tmp->nextin = tmp->nextout = ast_tv(0, 0);
tmp->step = tr_matrix[source][dest].step;
tmp->state = tmp->step->newpvt();
if (!tmp->state) {
ast_log(LOG_WARNING, "Failed to build translator step from %d to %d\n", source, dest);
ast_translator_free_path(tmpr);
return NULL;
}
/* Keep going if this isn't the final destination */
source = tmp->step->dstfmt;
}
return tmpr;
}
/*!
* \internal
* \brief Update an ast_sip_contact_status's elements.
*/
static void update_contact_status(const struct ast_sip_contact *contact,
enum ast_sip_contact_status_type value)
{
struct ast_sip_contact_status *status;
struct ast_sip_contact_status *update;
status = ast_res_pjsip_find_or_create_contact_status(contact);
if (!status) {
ast_log(LOG_ERROR, "Unable to find ast_sip_contact_status for contact %s\n",
contact->uri);
return;
}
update = ast_sorcery_alloc(ast_sip_get_sorcery(), CONTACT_STATUS,
ast_sorcery_object_get_id(status));
if (!update) {
ast_log(LOG_ERROR, "Unable to allocate ast_sip_contact_status for contact %s\n",
contact->uri);
return;
}
update->last_status = status->status;
update->status = value;
/* if the contact is available calculate the rtt as
the diff between the last start time and "now" */
update->rtt = update->status == AVAILABLE && status->rtt_start.tv_sec > 0 ?
ast_tvdiff_us(ast_tvnow(), status->rtt_start) : 0;
update->rtt_start = ast_tv(0, 0);
ast_test_suite_event_notify("AOR_CONTACT_QUALIFY_RESULT",
"Contact: %s\r\n"
"Status: %s\r\n"
"RTT: %" PRId64,
ast_sorcery_object_get_id(update),
ast_sip_get_contact_status_label(update->status),
update->rtt);
if (ast_sorcery_update(ast_sip_get_sorcery(), update)) {
ast_log(LOG_ERROR, "Unable to update ast_sip_contact_status for contact %s\n",
contact->uri);
}
ao2_ref(status, -1);
ao2_ref(update, -1);
}
/*!
* \brief Retrieve a ast_sip_contact_status object from sorcery creating
* one if not found.
*/
struct ast_sip_contact_status *ast_res_pjsip_find_or_create_contact_status(const struct ast_sip_contact *contact)
{
struct ast_sip_contact_status *status;
SCOPED_MUTEX(lock, &creation_lock);
status = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), CONTACT_STATUS,
ast_sorcery_object_get_id(contact));
if (status) {
return status;
}
status = ast_sorcery_alloc(ast_sip_get_sorcery(), CONTACT_STATUS,
ast_sorcery_object_get_id(contact));
if (!status) {
ast_log(LOG_ERROR, "Unable to create ast_sip_contact_status for contact %s/%s\n",
contact->aor, contact->uri);
return NULL;
}
ast_string_field_set(status, uri, contact->uri);
status->rtt_start = ast_tv(0, 0);
status->rtt = 0;
if (ast_sorcery_create(ast_sip_get_sorcery(), status)) {
ast_log(LOG_ERROR, "Unable to persist ast_sip_contact_status for contact %s\n",
contact->uri);
ao2_ref(status, -1);
return NULL;
}
/* The permanent contact added after asterisk start should be qualified. */
if (ast_test_flag(&ast_options, AST_OPT_FLAG_FULLY_BOOTED) && ast_tvzero(contact->expiration_time)) {
/*
* The FULLY_BOOTED to filter out contacts that already existed when asterisk started.
* The zero expiration_time to select only permanent contacts.
*/
ao2_ref((struct ast_sip_contact *) contact, +1);
if (ast_sip_push_task(NULL, qualify_and_schedule_aor_contact, (struct ast_sip_contact *) contact)) {
ao2_ref((struct ast_sip_contact *) contact, -1);
}
}
ast_statsd_log_string_va("PJSIP.contacts.states.%s", AST_STATSD_GAUGE,
"+1", 1.0, ast_sip_get_contact_status_label(status->status));
return status;
}
int ast_poll2(struct pollfd *pArray, unsigned long n_fds, struct timeval *tv)
{
#if !defined(AST_POLL_COMPAT)
struct timeval start = ast_tvnow();
#if defined(HAVE_PPOLL)
struct timespec ts = { tv ? tv->tv_sec : 0, tv ? tv->tv_usec * 1000 : 0 };
int res = ppoll(pArray, n_fds, tv ? &ts : NULL, NULL);
#else
int res = poll(pArray, n_fds, tv ? tv->tv_sec * 1000 + tv->tv_usec / 1000 : -1);
#endif
struct timeval after = ast_tvnow();
if (res > 0 && tv && ast_tvdiff_ms(ast_tvadd(*tv, start), after) > 0) {
*tv = ast_tvsub(*tv, ast_tvsub(after, start));
} else if (res > 0 && tv) {
*tv = ast_tv(0, 0);
}
return res;
#else
ast_fdset read_descs, write_descs, except_descs;
int ready_descriptors, max_fd = 0;
FD_ZERO(&read_descs);
FD_ZERO(&write_descs);
FD_ZERO(&except_descs);
if (pArray) {
max_fd = map_poll_spec(pArray, n_fds, &read_descs, &write_descs, &except_descs);
}
ready_descriptors = ast_select(max_fd + 1, &read_descs, &write_descs, &except_descs, tv);
if (ready_descriptors >= 0) {
map_select_results(pArray, n_fds, &read_descs, &write_descs, &except_descs);
}
return ready_descriptors;
#endif
}
void ast_fr_init_ex(struct ast_frame *fr,
int frame_type,
int sub_type,
const char *src)
{
fr->frametype = frame_type;
fr->subclass = sub_type;
fr->datalen = 0;
fr->samples = 0;
fr->mallocd = 0;
fr->offset = 0;
fr->src = (src) ? src : "";
fr->data = NULL;
fr->delivery = ast_tv(0,0);
//fr->seq_no = 0;
fr->prev = NULL;
fr->next = NULL;
//fr->has_timing_info = 0;
//fr->ts = 0;
//fr->len = 0;
//fr->seq_no = 0;
//fr->tx_copies = 1;
}
/*!
* \internal
* \brief Update an ast_sip_contact_status's elements.
*/
static void update_contact_status(const struct ast_sip_contact *contact,
enum ast_sip_contact_status_type value)
{
struct ast_sip_contact_status *status;
struct ast_sip_contact_status *update;
status = find_or_create_contact_status(contact);
if (!status) {
return;
}
update = ast_sorcery_alloc(ast_sip_get_sorcery(), CONTACT_STATUS,
ast_sorcery_object_get_id(status));
if (!update) {
ast_log(LOG_ERROR, "Unable to create update ast_sip_contact_status for contact %s\n",
contact->uri);
ao2_ref(status, -1);
return;
}
update->status = value;
/* if the contact is available calculate the rtt as
the diff between the last start time and "now" */
update->rtt = update->status == AVAILABLE ?
ast_tvdiff_us(ast_tvnow(), status->rtt_start) : 0;
update->rtt_start = ast_tv(0, 0);
if (ast_sorcery_update(ast_sip_get_sorcery(), update)) {
ast_log(LOG_ERROR, "Unable to update ast_sip_contact_status for contact %s\n",
contact->uri);
}
ao2_ref(update, -1);
ao2_ref(status, -1);
}
/*!
* \internal
* \brief Update an ast_sip_contact_status's elements.
*/
static void update_contact_status(const struct ast_sip_contact *contact,
enum ast_sip_contact_status_type value, int is_contact_refresh)
{
RAII_VAR(struct ast_sip_contact_status *, status, NULL, ao2_cleanup);
RAII_VAR(struct ast_sip_contact_status *, update, NULL, ao2_cleanup);
status = ast_res_pjsip_find_or_create_contact_status(contact);
if (!status) {
ast_log(LOG_ERROR, "Unable to find ast_sip_contact_status for contact %s\n",
contact->uri);
return;
}
if (is_contact_refresh
&& status->status == CREATED) {
/*
* The contact status hasn't been updated since creation
* and we don't want to re-send a created status.
*/
if (contact->qualify_frequency
|| status->rtt_start.tv_sec > 0) {
/* Ignore, the status will change soon. */
return;
}
/*
* Convert to a regular contact status update
* because the status may never change.
*/
is_contact_refresh = 0;
value = UNKNOWN;
}
update = ast_sorcery_alloc(ast_sip_get_sorcery(), CONTACT_STATUS,
ast_sorcery_object_get_id(status));
if (!update) {
ast_log(LOG_ERROR, "Unable to allocate ast_sip_contact_status for contact %s\n",
contact->uri);
return;
}
ast_string_field_set(update, uri, contact->uri);
if (is_contact_refresh) {
/* Copy everything just to set the refresh flag. */
update->status = status->status;
update->last_status = status->last_status;
update->rtt = status->rtt;
update->rtt_start = status->rtt_start;
update->refresh = 1;
} else {
update->last_status = status->status;
update->status = value;
/*
* if the contact is available calculate the rtt as
* the diff between the last start time and "now"
*/
update->rtt = update->status == AVAILABLE && status->rtt_start.tv_sec > 0
? ast_tvdiff_us(ast_tvnow(), status->rtt_start)
: 0;
update->rtt_start = ast_tv(0, 0);
ast_test_suite_event_notify("AOR_CONTACT_QUALIFY_RESULT",
"Contact: %s\r\n"
"Status: %s\r\n"
"RTT: %" PRId64,
ast_sorcery_object_get_id(update),
ast_sip_get_contact_status_label(update->status),
update->rtt);
}
if (ast_sorcery_update(ast_sip_get_sorcery(), update)) {
ast_log(LOG_ERROR, "Unable to update ast_sip_contact_status for contact %s\n",
contact->uri);
}
}
struct ast_frame *ast_translate(struct ast_trans_pvt *path, struct ast_frame *f, int consume)
{
struct ast_trans_pvt *p;
struct ast_frame *out;
struct timeval delivery;
p = path;
/* Feed the first frame into the first translator */
p->step->framein(p->state, f);
if (!ast_tvzero(f->delivery)) {
if (!ast_tvzero(path->nextin)) {
/* Make sure this is in line with what we were expecting */
if (!ast_tveq(path->nextin, f->delivery)) {
/* The time has changed between what we expected and this
most recent time on the new packet. If we have a
valid prediction adjust our output time appropriately */
if (!ast_tvzero(path->nextout)) {
path->nextout = ast_tvadd(path->nextout,
ast_tvsub(f->delivery, path->nextin));
}
path->nextin = f->delivery;
}
} else {
/* This is our first pass. Make sure the timing looks good */
path->nextin = f->delivery;
path->nextout = f->delivery;
}
/* Predict next incoming sample */
path->nextin = ast_tvadd(path->nextin, ast_samp2tv(f->samples, 8000));
}
delivery = f->delivery;
if (consume)
ast_frfree(f);
while(p) {
out = p->step->frameout(p->state);
/* If we get nothing out, return NULL */
if (!out)
return NULL;
/* If there is a next state, feed it in there. If not,
return this frame */
if (p->next)
p->next->step->framein(p->next->state, out);
else {
if (!ast_tvzero(delivery)) {
/* Regenerate prediction after a discontinuity */
if (ast_tvzero(path->nextout))
path->nextout = ast_tvnow();
/* Use next predicted outgoing timestamp */
out->delivery = path->nextout;
/* Predict next outgoing timestamp from samples in this
frame. */
path->nextout = ast_tvadd(path->nextout, ast_samp2tv( out->samples, 8000));
} else {
out->delivery = ast_tv(0, 0);
}
/* Invalidate prediction if we're entering a silence period */
if (out->frametype == AST_FRAME_CNG)
path->nextout = ast_tv(0, 0);
return out;
}
p = p->next;
}
ast_log(LOG_WARNING, "I should never get here...\n");
return NULL;
}
/*! \brief Wait for the \ref test_msg_handler to receive the message */
static int handler_wait_for_message(struct ast_test *test)
{
int error = 0;
struct timeval wait = ast_tvadd(ast_tvnow(), ast_tv(5 /* seconds */, 0));
struct timespec wait_time = { .tv_sec = wait.tv_sec, .tv_nsec = wait.tv_usec * 1000 };
ast_mutex_lock(&handler_lock);
while (!handler_received_message) {
error = ast_cond_timedwait(&handler_cond, &handler_lock, &wait_time);
if (error == ETIMEDOUT) {
ast_test_status_update(test, "Test timed out while waiting for handler to get message\n");
ast_test_set_result(test, AST_TEST_FAIL);
break;
}
}
ast_mutex_unlock(&handler_lock);
return (error != ETIMEDOUT);
}
/*! \brief Wait for the expected number of user events to be received */
static int user_event_wait_for_events(struct ast_test *test, int expected_events)
{
int error;
struct timeval wait = ast_tvadd(ast_tvnow(), ast_tv(5 /* seconds */, 0));
struct timespec wait_time = { .tv_sec = wait.tv_sec, .tv_nsec = wait.tv_usec * 1000 };
expected_user_events = expected_events;
ast_mutex_lock(&user_event_lock);
while (received_user_events != expected_user_events) {
error = ast_cond_timedwait(&user_event_cond, &user_event_lock, &wait_time);
if (error == ETIMEDOUT) {
ast_test_status_update(test, "Test timed out while waiting for %d expected user events\n", expected_events);
ast_test_set_result(test, AST_TEST_FAIL);
break;
}
}
ast_mutex_unlock(&user_event_lock);
ast_test_status_update(test, "Received %d of %d user events\n", received_user_events, expected_events);
return !(received_user_events == expected_events);
}
static int verify_bad_headers(struct ast_test *test)
{
int res = 0;
int i;
for (i = 0; i < AST_VECTOR_SIZE(&bad_headers); i++) {
struct ast_variable *headers;
struct ast_variable *current;
headers = AST_VECTOR_GET(&bad_headers, i);
if (!headers) {
continue;
}
res = -1;
for (current = headers; current; current = current->next) {
ast_test_status_update(test, "Expected UserEvent %d: Failed to match %s: %s\n",
i, current->name, current->value);
ast_test_set_result(test, AST_TEST_FAIL);
}
}
return res;
}
/*! \brief Custom handler for translating from a string timeval to actual structure */
static int expiration_str2struct(const struct aco_option *opt, struct ast_variable *var, void *obj)
{
struct ast_sip_contact *contact = obj;
return ast_get_timeval(var->value, &contact->expiration_time, ast_tv(0, 0), NULL);
}
static int app_exec(struct ast_channel *chan, void *data)
{
int res = 0, argc = 0, max_digits = 0, timeout = 0, alreadyran = 0, old_writeformat = 0;
int ms, len, availatend;
char *argv[3], *parse = NULL, *text = NULL, *rc = NULL;
char tmp_exten[2], results[20];
struct ast_module_user *u;
struct ast_frame *f;
struct timeval next;
struct stuff *ps;
struct myframe {
struct ast_frame f;
unsigned char offset[AST_FRIENDLY_OFFSET];
unsigned char frdata[framesize];
} myf;
swift_engine *engine;
swift_port *port = NULL;
swift_voice *voice;
swift_params *params;
swift_result_t sresult;
swift_background_t tts_stream;
unsigned int event_mask;
memset(results, 0 ,20);
memset(tmp_exten, 0, 2);
memset(argv, 0, 3);
parse = ast_strdupa(data);
u = ast_module_user_add(chan);
argc = ast_app_separate_args(parse, ',', argv, 3);
text = argv[0];
if (!ast_strlen_zero(argv[1])) {
timeout = strtol(argv[1], NULL, 0);
}
if (!ast_strlen_zero(argv[2])) {
max_digits = strtol(argv[2], NULL, 0);
}
if (ast_strlen_zero(text)) {
ast_log(LOG_WARNING, "%s requires text to speak!\n", app);
return -1;
}
if (!ast_strlen_zero(text)) {
ast_log(LOG_DEBUG, "Text to Speak : %s\n", text);
}
if (timeout > 0) {
ast_log(LOG_DEBUG, "Timeout : %d\n", timeout);
}
if (max_digits > 0) {
ast_log(LOG_DEBUG, "Max Digits : %d\n", max_digits);
}
ps = malloc(sizeof(struct stuff));
swift_init_stuff(ps);
/* Setup synthesis */
if ((engine = swift_engine_open(NULL)) == NULL) {
ast_log(LOG_ERROR, "Failed to open Swift Engine.\n");
goto exception;
}
params = swift_params_new(NULL);
swift_params_set_string(params, "audio/encoding", "ulaw");
swift_params_set_string(params, "audio/sampling-rate", "8000");
swift_params_set_string(params, "audio/output-format", "raw");
swift_params_set_string(params, "tts/text-encoding", "utf-8");
/* Additional swift parameters
*
* swift_params_set_float(params, "speech/pitch/shift", 1.0);
* swift_params_set_int(params, "speech/rate", 150);
* swift_params_set_int(params, "audio/volume", 110);
* swift_params_set_int(params, "audio/deadair", 0);
*/
if ((port = swift_port_open(engine, params)) == NULL) {
ast_log(LOG_ERROR, "Failed to open Swift Port.\n");
goto exception;
}
if ((voice = swift_port_set_voice_by_name(port, cfg_voice)) == NULL) {
ast_log(LOG_ERROR, "Failed to set voice.\n");
goto exception;
}
event_mask = SWIFT_EVENT_AUDIO | SWIFT_EVENT_END;
swift_port_set_callback(port, &swift_cb, event_mask, ps);
if (SWIFT_FAILED(swift_port_speak_text(port, text, 0, NULL, &tts_stream, NULL))) {
ast_log(LOG_ERROR, "Failed to speak.\n");
goto exception;
}
if (chan->_state != AST_STATE_UP) {
ast_answer(chan);
}
ast_stopstream(chan);
old_writeformat = chan->writeformat;
if (ast_set_write_format(chan, AST_FORMAT_ULAW) < 0) {
ast_log(LOG_WARNING, "Unable to set write format.\n");
goto exception;
}
res = 0;
/* Wait 100ms first for synthesis to start crankin'; if that's not
* enough the
*/
next = ast_tvadd(ast_tvnow(), ast_tv(0, 100000));
while (swift_generator_running(ps)) {
ms = ast_tvdiff_ms(next, ast_tvnow());
if (ms <= 0) {
if (swift_bytes_available(ps) > 0) {
ASTOBJ_WRLOCK(ps);
len = fmin(framesize, ps->qc);
availatend = cfg_buffer_size - (ps->pq_r - ps->q);
if (len > availatend) {
/* read #1: to end of q buf */
memcpy(myf.frdata, ps->pq_r, availatend);
ps->qc -= availatend;
/* read #2: reset to start of q buf and get rest */
ps->pq_r = ps->q;
memcpy(myf.frdata + availatend, ps->pq_r, len - availatend);
ps->qc -= len - availatend;
ps->pq_r += len - availatend;
} else {
ast_log(LOG_DEBUG, "Easy read; %d bytes and %d at end, %d free\n", len, availatend, cfg_buffer_size - ps->qc);
memcpy(myf.frdata, ps->pq_r, len);
ps->qc -= len;
ps->pq_r += len;
}
myf.f.frametype = AST_FRAME_VOICE;
myf.f.subclass = AST_FORMAT_ULAW;
myf.f.datalen = len;
myf.f.samples = len;
myf.f.data.ptr = myf.frdata;
myf.f.mallocd = 0;
myf.f.offset = AST_FRIENDLY_OFFSET;
myf.f.src = __PRETTY_FUNCTION__;
myf.f.delivery.tv_sec = 0;
myf.f.delivery.tv_usec = 0;
if (ast_write(chan, &myf.f) < 0) {
ast_log(LOG_DEBUG, "ast_write failed\n");
}
ast_log(LOG_DEBUG, "wrote a frame of %d\n", len);
if (ps->qc < 0) {
ast_log(LOG_DEBUG, "queue claims to contain negative bytes. Huh? qc < 0\n");
}
ASTOBJ_UNLOCK(ps);
next = ast_tvadd(next, ast_samp2tv(myf.f.samples, samplerate));
} else {
next = ast_tvadd(next, ast_samp2tv(framesize / 2, samplerate));
ast_log(LOG_DEBUG, "Whoops, writer starved for audio\n");
}
} else {
ms = ast_waitfor(chan, ms);
if (ms < 0) {
ast_log(LOG_DEBUG, "Hangup detected\n");
res = -1;
ASTOBJ_WRLOCK(ps);
ps->immediate_exit = 1;
ASTOBJ_UNLOCK(ps);
} else if (ms) {
f = ast_read(chan);
if (!f) {
ast_log(LOG_DEBUG, "Null frame == hangup() detected\n");
res = -1;
ASTOBJ_WRLOCK(ps);
ps->immediate_exit = 1;
ASTOBJ_UNLOCK(ps);
} else if (f->frametype == AST_FRAME_DTMF && timeout > 0 && max_digits > 0) {
char originDTMF = f->subclass;
alreadyran = 1;
res = 0;
ASTOBJ_WRLOCK(ps);
ps->immediate_exit = 1;
ASTOBJ_UNLOCK(ps);
if (max_digits > 1) {
rc = listen_for_dtmf(chan, timeout, max_digits - 1);
}
if (rc) {
sprintf(results, "%c%s", originDTMF, rc);
} else {
sprintf(results, "%c", originDTMF);
}
ast_log(LOG_NOTICE, "DTMF = %s\n", results);
pbx_builtin_setvar_helper(chan, "SWIFT_DTMF", results);
}
ast_frfree(f);
}
}
ASTOBJ_RDLOCK(ps);
if (ps->immediate_exit && !ps->generating_done) {
if (SWIFT_FAILED(sresult = swift_port_stop(port, tts_stream, SWIFT_EVENT_NOW))) {
ast_log(LOG_NOTICE, "Early top of swift port failed\n");
}
}
ASTOBJ_UNLOCK(ps);
}
if (alreadyran == 0 && timeout > 0 && max_digits > 0) {
rc = listen_for_dtmf(chan, timeout, max_digits);
if (rc != NULL) {
sprintf(results, "%s", rc);
ast_log(LOG_NOTICE, "DTMF = %s\n", results);
pbx_builtin_setvar_helper(chan, "SWIFT_DTMF", results);
}
}
if (max_digits >= 1 && results != NULL) {
if (cfg_goto_exten) {
ast_log(LOG_NOTICE, "GoTo(%s|%s|%d) : ", chan->context, results, 1);
if (ast_exists_extension (chan, chan->context, results, 1, chan->cid.cid_num)) {
ast_log(LOG_NOTICE, "OK\n");
ast_copy_string(chan->exten, results, sizeof(chan->exten) - 1);
chan->priority = 0;
} else {
ast_log(LOG_NOTICE, "FAILED\n");
}
}
}
exception:
if (port != NULL) {
swift_port_close(port);
}
if (engine != NULL) {
swift_engine_close(engine);
}
if (ps && ps->q) {
ast_free(ps->q);
ps->q = NULL;
}
if (ps) {
ast_free(ps);
ps = NULL;
}
if (!res && old_writeformat) {
ast_set_write_format(chan, old_writeformat);
}
ast_module_user_remove(u);
return res;
}
