ast_cli(a->fd, " User name and group: %s/%s\n", ast_config_AST_RUN_USER, ast_config_AST_RUN_GROUP);
ast_cli(a->fd, " Executable includes: %s\n", ast_test_flag(&ast_options, AST_OPT_FLAG_EXEC_INCLUDES) ? "Enabled" : "Disabled");
ast_cli(a->fd, " Transcode via SLIN: %s\n", ast_test_flag(&ast_options, AST_OPT_FLAG_TRANSCODE_VIA_SLIN) ? "Enabled" : "Disabled");
- ast_cli(a->fd, " Internal timing: %s\n", ast_test_flag(&ast_options, AST_OPT_FLAG_INTERNAL_TIMING) ? "Enabled" : "Disabled");
ast_cli(a->fd, " Transmit silence during rec: %s\n", ast_test_flag(&ast_options, AST_OPT_FLAG_TRANSMIT_SILENCE) ? "Enabled" : "Disabled");
ast_cli(a->fd, " Generic PLC: %s\n", ast_test_flag(&ast_options, AST_OPT_FLAG_GENERIC_PLC) ? "Enabled" : "Disabled");
ast_cli(a->fd, " Min DTMF duration:: %u\n", option_dtmfminduration);
printf(" -g Dump core in case of a crash\n");
printf(" -h This help screen\n");
printf(" -i Initialize crypto keys at startup\n");
- printf(" -I Enable internal timing if DAHDI timer is available\n");
printf(" -L <load> Limit the maximum load average before rejecting new calls\n");
printf(" -M <value> Limit the maximum number of calls to the specified value\n");
printf(" -m Mute debugging and console output on the console\n");
/* Transmit SLINEAR silence while a channel is being recorded or DTMF is being generated on a channel */
} else if (!strcasecmp(v->name, "transmit_silence_during_record") || !strcasecmp(v->name, "transmit_silence")) {
ast_set2_flag(&ast_options, ast_true(v->value), AST_OPT_FLAG_TRANSMIT_SILENCE);
- /* Enable internal timing */
- } else if (!strcasecmp(v->name, "internal_timing")) {
- ast_set2_flag(&ast_options, ast_true(v->value), AST_OPT_FLAG_INTERNAL_TIMING);
} else if (!strcasecmp(v->name, "mindtmfduration")) {
if (sscanf(v->value, "%30u", &option_dtmfminduration) != 1) {
option_dtmfminduration = AST_MIN_DTMF_DURATION;
case 'h':
show_cli_help();
exit(0);
- case 'I':
- ast_set_flag(&ast_options, AST_OPT_FLAG_INTERNAL_TIMING);
- break;
case 'i':
ast_set_flag(&ast_options, AST_OPT_FLAG_INIT_KEYS);
break;
return (ast_tvdiff_ms(ast_tvnow(), ast_channel_answertime(chan)) / 1000);
}
-void ast_deactivate_generator(struct ast_channel *chan)
+static void deactivate_generator_nolock(struct ast_channel *chan)
{
- ast_channel_lock(chan);
if (ast_channel_generatordata(chan)) {
- if (ast_channel_generator(chan) && ast_channel_generator(chan)->release) {
- ast_channel_generator(chan)->release(chan, ast_channel_generatordata(chan));
+ struct ast_generator *generator = ast_channel_generator(chan);
+
+ if (generator && generator->release) {
+ generator->release(chan, ast_channel_generatordata(chan));
}
ast_channel_generatordata_set(chan, NULL);
ast_channel_generator_set(chan, NULL);
ast_clear_flag(ast_channel_flags(chan), AST_FLAG_WRITE_INT);
ast_settimeout(chan, 0, NULL, NULL);
}
+}
+
+void ast_deactivate_generator(struct ast_channel *chan)
+{
+ ast_channel_lock(chan);
+ deactivate_generator_nolock(chan);
ast_channel_unlock(chan);
}
static void generator_write_format_change(struct ast_channel *chan)
{
+ struct ast_generator *generator;
+
ast_channel_lock(chan);
- if (ast_channel_generator(chan) && ast_channel_generator(chan)->write_format_change) {
- ast_channel_generator(chan)->write_format_change(chan, ast_channel_generatordata(chan));
+ generator = ast_channel_generator(chan);
+ if (generator && generator->write_format_change) {
+ generator->write_format_change(chan, ast_channel_generatordata(chan));
}
ast_channel_unlock(chan);
}
ast_channel_lock(chan);
if (ast_channel_generatordata(chan)) {
- if (ast_channel_generator(chan) && ast_channel_generator(chan)->release) {
- ast_channel_generator(chan)->release(chan, ast_channel_generatordata(chan));
+ struct ast_generator *generator_old = ast_channel_generator(chan);
+
+ if (generator_old && generator_old->release) {
+ generator_old->release(chan, ast_channel_generatordata(chan));
}
}
if (gen->alloc && !(generatordata = gen->alloc(chan, params))) {
static void ast_read_generator_actions(struct ast_channel *chan, struct ast_frame *f)
{
- if (ast_channel_generator(chan) && ast_channel_generator(chan)->generate && ast_channel_generatordata(chan) && !ast_internal_timing_enabled(chan)) {
- void *tmp = ast_channel_generatordata(chan);
- int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples) = ast_channel_generator(chan)->generate;
- int res;
- int samples;
+ struct ast_generator *generator;
+ void *gendata;
+ int res;
+ int samples;
+
+ generator = ast_channel_generator(chan);
+ if (!generator
+ || !generator->generate
+ || f->frametype != AST_FRAME_VOICE
+ || !ast_channel_generatordata(chan)
+ || ast_channel_timingfunc(chan)) {
+ return;
+ }
- if (ast_channel_timingfunc(chan)) {
- ast_debug(1, "Generator got voice, switching to phase locked mode\n");
- ast_settimeout(chan, 0, NULL, NULL);
- }
+ /*
+ * We must generate frames in phase locked mode since
+ * we have no internal timer available.
+ */
- ast_channel_generatordata_set(chan, NULL); /* reset, to let writes go through */
+ if (ast_format_cmp(&f->subclass.format, ast_channel_writeformat(chan)) == AST_FORMAT_CMP_NOT_EQUAL) {
+ float factor;
- if (ast_format_cmp(&f->subclass.format, ast_channel_writeformat(chan)) == AST_FORMAT_CMP_NOT_EQUAL) {
- float factor;
- factor = ((float) ast_format_rate(ast_channel_writeformat(chan))) / ((float) ast_format_rate(&f->subclass.format));
- samples = (int) ( ((float) f->samples) * factor );
- } else {
- samples = f->samples;
- }
+ factor = ((float) ast_format_rate(ast_channel_writeformat(chan))) / ((float) ast_format_rate(&f->subclass.format));
+ samples = (int) (((float) f->samples) * factor);
+ } else {
+ samples = f->samples;
+ }
- /* This unlock is here based on two assumptions that hold true at this point in the
- * code. 1) this function is only called from within __ast_read() and 2) all generators
- * call ast_write() in their generate callback.
- *
- * The reason this is added is so that when ast_write is called, the lock that occurs
- * there will not recursively lock the channel. Doing this will cause intended deadlock
- * avoidance not to work in deeper functions
- */
- ast_channel_unlock(chan);
- res = generate(chan, tmp, f->datalen, samples);
- ast_channel_lock(chan);
- ast_channel_generatordata_set(chan, tmp);
+ gendata = ast_channel_generatordata(chan);
+ ast_channel_generatordata_set(chan, NULL); /* reset, to let writes go through */
+
+ /*
+ * This unlock is here based on two assumptions that hold true at
+ * this point in the code. 1) this function is only called from
+ * within __ast_read() and 2) all generators call ast_write() in
+ * their generate callback.
+ *
+ * The reason this is added is so that when ast_write is called,
+ * the lock that occurs there will not recursively lock the
+ * channel. Doing this will allow deadlock avoidance to work in
+ * deeper functions.
+ */
+ ast_channel_unlock(chan);
+ res = generator->generate(chan, gendata, f->datalen, samples);
+ ast_channel_lock(chan);
+ if (generator == ast_channel_generator(chan)) {
+ ast_channel_generatordata_set(chan, gendata);
if (res) {
ast_debug(1, "Auto-deactivating generator\n");
ast_deactivate_generator(chan);
}
-
- } else if (f->frametype == AST_FRAME_CNG) {
- if (ast_channel_generator(chan) && !ast_channel_timingfunc(chan) && (ast_channel_timingfd(chan) > -1)) {
- ast_debug(1, "Generator got CNG, switching to timed mode\n");
- ast_settimeout(chan, 50, generator_force, chan);
- }
}
}
return f;
}
-int ast_internal_timing_enabled(struct ast_channel *chan)
-{
- return (ast_opt_internal_timing && ast_channel_timingfd(chan) > -1);
-}
-
struct ast_frame *ast_read(struct ast_channel *chan)
{
return __ast_read(chan, 0);
return state;
}
-static int internal_deactivate_generator(struct ast_channel *chan, void* generator)
+static int deactivate_silence_generator(struct ast_channel *chan)
{
ast_channel_lock(chan);
if (!ast_channel_generatordata(chan)) {
- ast_debug(1, "Trying to stop silence generator when there is no "
- "generator on '%s'\n", ast_channel_name(chan));
+ ast_debug(1, "Trying to stop silence generator when there is no generator on '%s'\n",
+ ast_channel_name(chan));
ast_channel_unlock(chan);
return 0;
}
- if (ast_channel_generator(chan) != generator) {
- ast_debug(1, "Trying to stop silence generator when it is not the current "
- "generator on '%s'\n", ast_channel_name(chan));
+ if (ast_channel_generator(chan) != &silence_generator) {
+ ast_debug(1, "Trying to stop silence generator when it is not the current generator on '%s'\n",
+ ast_channel_name(chan));
ast_channel_unlock(chan);
return 0;
}
- if (ast_channel_generator(chan) && ast_channel_generator(chan)->release) {
- ast_channel_generator(chan)->release(chan, ast_channel_generatordata(chan));
- }
- ast_channel_generatordata_set(chan, NULL);
- ast_channel_generator_set(chan, NULL);
- ast_channel_set_fd(chan, AST_GENERATOR_FD, -1);
- ast_clear_flag(ast_channel_flags(chan), AST_FLAG_WRITE_INT);
- ast_settimeout(chan, 0, NULL, NULL);
+ deactivate_generator_nolock(chan);
+
ast_channel_unlock(chan);
return 1;
void ast_channel_stop_silence_generator(struct ast_channel *chan, struct ast_silence_generator *state)
{
- if (!state)
+ if (!state) {
return;
+ }
- if (internal_deactivate_generator(chan, &silence_generator)) {
+ if (deactivate_silence_generator(chan)) {
ast_debug(1, "Stopped silence generator on '%s'\n", ast_channel_name(chan));
if (ast_set_write_format(chan, &state->old_write_format) < 0)
ast_log(LOG_ERROR, "Could not return write format to its original state\n");
projects / thirdparty / asterisk.git / commitdiff
