#define SWITCH_MODULE_INTERFACES_H
#include <switch.h>
+#include "switch_resample.h"
SWITCH_BEGIN_EXTERN_C
/*! \brief A table of functions to execute at various states
unsigned int samples;
/*! the current samplerate */
uint32_t samplerate;
+ /*! the current native samplerate */
+ uint32_t native_rate;
/*! the number of channels */
uint8_t channels;
/*! integer representation of the format */
uint32_t offset_pos;
uint32_t last_pos;
int32_t vol;
+ switch_audio_resampler_t *resampler;
+ switch_buffer_t *buffer;
+ switch_byte_t *dbuf;
+ switch_size_t dbuflen;
};
/*! \brief Abstract interface to an asr module */
\brief Destroy an existing resampler handle
\param resampler the resampler handle to destroy
*/
-SWITCH_DECLARE(void) switch_resample_destroy(switch_audio_resampler_t *resampler);
+SWITCH_DECLARE(void) switch_resample_destroy(switch_audio_resampler_t **resampler);
/*!
\brief Resample one float buffer into another using specifications of a given handle
}
}
+ switch_resample_destroy(&member->read_resampler);
+ switch_resample_destroy(&member->mux_resampler);
+
switch_clear_flag_locked(member, MFLAG_ITHREAD);
return NULL;
int argc;
char *mydata, *argv[4] = { 0 };
char *l = NULL;
-
+ const char *tmp;
+ int rate;
+
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
}
}
+ if ((tmp = switch_channel_get_variable(channel, "record_rate"))) {
+ rate = atoi(tmp);
+ if (rate > 0) {
+ fh.samplerate = rate;
+ }
+ }
+
args.input_callback = on_dtmf;
status = switch_ivr_record_file(session, &fh, path, &args, limit);
local_stream_context_t *cp;
char file_buf[128] = "", path_buf[512] = "";
switch_timer_t timer = {0};
-
+ int fd = -1;
if (switch_core_timer_init(&timer, source->timer_name, source->interval, source->samples, source->pool) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Can't start timer.\n");
while(RUNNING) {
const char *fname;
-
+
if (switch_dir_open(&source->dir_handle, source->location, source->pool) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Can't open directory: %s\n", source->location);
return NULL;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "open directory: %s\n", source->location);
switch_yield(1000000);
- while(RUNNING && (fname = switch_dir_next_file(source->dir_handle, file_buf, sizeof(file_buf)))) {
+ while(RUNNING) {
switch_size_t olen;
uint8_t abuf[SWITCH_RECOMMENDED_BUFFER_SIZE] = {0};
- snprintf(path_buf, sizeof(path_buf), "%s%s%s", source->location, SWITCH_PATH_SEPARATOR, fname);
- if (switch_stristr(".loc", path_buf)) {
- int fd, bytes;
+ if (fd > -1) {
char *p;
+ if (switch_fd_read_line(fd, path_buf, sizeof(path_buf))) {
+ if ((p = strchr(path_buf, '\r')) ||
+ (p = strchr(path_buf, '\n'))) {
+ *p = '\0';
+ }
+ } else {
+ close(fd);
+ fd = -1;
+ continue;
+ }
+ } else {
+ if (!(fname = switch_dir_next_file(source->dir_handle, file_buf, sizeof(file_buf)))) {
+ break;
+ }
+
+ snprintf(path_buf, sizeof(path_buf), "%s%s%s", source->location, SWITCH_PATH_SEPARATOR, fname);
- if ((fd = open(path_buf, O_RDONLY)) < 0) {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't open %s\n", fname);
- switch_yield(1000000);
+ if (switch_stristr(".loc", path_buf)) {
+ if ((fd = open(path_buf, O_RDONLY)) < 0) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't open %s\n", fname);
+ switch_yield(1000000);
+ }
continue;
}
- bytes = read(fd, path_buf, sizeof(path_buf));
- if ((p = strchr(path_buf, '\r')) ||
- (p = strchr(path_buf, '\n'))) {
- *p = '\0';
- }
- close(fd);
}
fname = path_buf;
while (RUNNING) {
switch_core_timer_next(&timer);
olen = source->samples;
+
if (switch_core_file_read(&fh, abuf, &olen) != SWITCH_STATUS_SUCCESS || !olen) {
switch_core_file_close(&fh);
break;
}
switch_dir_close(source->dir_handle);
+ source->dir_handle = NULL;
}
+
+ if (fd > -1) {
+ close(fd);
+ }
switch_core_destroy_memory_pool(&source->pool);
{
local_stream_context_t *context;
local_stream_source_t *source;
+ char *alt_path = NULL;
+ switch_status_t status = SWITCH_STATUS_SUCCESS;
if (switch_test_flag(handle, SWITCH_FILE_FLAG_WRITE)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "This format does not support writing!\n");
return SWITCH_STATUS_FALSE;
}
+ alt_path = switch_mprintf("%s/%d", path, handle->samplerate);
+
switch_mutex_lock(globals.mutex);
- source = switch_core_hash_find(globals.source_hash, path);
+ if ((source = switch_core_hash_find(globals.source_hash, alt_path))) {
+ path = alt_path;
+ } else {
+ source = switch_core_hash_find(globals.source_hash, path);
+ }
switch_mutex_unlock(globals.mutex);
if (!source) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "unknown source %s\n", path);
- return SWITCH_STATUS_FALSE;
+ status = SWITCH_STATUS_FALSE;
+ goto end;
}
if ((context = switch_core_alloc(handle->memory_pool, sizeof(*context))) == 0) {
- return SWITCH_STATUS_MEMERR;
+ status = SWITCH_STATUS_MEMERR;
+ goto end;
}
+
+
handle->samples = 0;
handle->samplerate = source->rate;
handle->channels = source->channels;
switch_mutex_init(&context->audio_mutex, SWITCH_MUTEX_NESTED, handle->memory_pool);
if (switch_buffer_create_dynamic(&context->audio_buffer, 512, 1024, 0) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Memory Error!\n");
- return SWITCH_STATUS_MEMERR;
+ status = SWITCH_STATUS_MEMERR;
+ goto end;
}
context->source = source;
source->context_list = context;
switch_mutex_unlock(source->mutex);
-
- return SWITCH_STATUS_SUCCESS;
+ end:
+ switch_safe_free(alt_path);
+ return status;
}
static switch_status_t local_stream_file_close(switch_file_handle_t *handle)
}
source->samples = switch_bytes_per_frame(source->rate, source->interval);
+
switch_core_hash_insert(globals.source_hash, source->name, source);
switch_mutex_init(&source->mutex, SWITCH_MUTEX_NESTED, source->pool);
* Anthony Minessale II <anthmct@yahoo.com>
*
*
- * mod_native_file.c -- Framework Demo Module
+ * mod_native_file.c -- Native Files
*
*/
#include <switch.h>
int mode = 0;
char *ext;
struct format_map *map = NULL;
+ switch_status_t status = SWITCH_STATUS_SUCCESS;
+ char *alt_path = NULL, *next, *last, *ldup = NULL;
+ size_t alt_len = 0;
if ((ext = strrchr(path, '.')) == 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Format\n");
if ((mode & SFM_WRITE) && sf_format_check(&context->sfinfo) == 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error : file format is invalid (0x%08X).\n", context->sfinfo.format);
return SWITCH_STATUS_GENERR;
- };
+ }
- if ((context->handle = sf_open(path, mode, &context->sfinfo)) == 0) {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening File [%s] [%s]\n", path, sf_strerror(context->handle));
- return SWITCH_STATUS_GENERR;
+ alt_len = strlen(path) + 10;
+ switch_zmalloc(alt_path, alt_len);
+
+ switch_copy_string(alt_path, path, alt_len);
+ if ((last = strrchr(alt_path, *SWITCH_PATH_SEPARATOR))) {
+ next = ++last;
+ ldup = strdup(last);
+ switch_assert(ldup);
+ switch_snprintf(next, alt_len - (last - alt_path), "%d%s%s", handle->samplerate, SWITCH_PATH_SEPARATOR, ldup);
+ if ((context->handle = sf_open(alt_path, mode, &context->sfinfo))) {
+ path = alt_path;
+ }
+ }
+
+ if (!context->handle) {
+ if ((context->handle = sf_open(path, mode, &context->sfinfo)) == 0) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening File [%s] [%s]\n", path, sf_strerror(context->handle));
+ status = SWITCH_STATUS_GENERR;
+ goto end;
+ }
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Opening File [%s] %dhz\n", path, context->sfinfo.samplerate);
handle->seekable = context->sfinfo.seekable;
handle->speed = 0;
handle->private_info = context;
+
- return SWITCH_STATUS_SUCCESS;
+ end:
+
+ switch_safe_free(alt_path);
+ switch_safe_free(ldup);
+
+
+ return status;
}
static switch_status_t sndfile_file_close(switch_file_handle_t *handle)
fh->handler = switch_core_strdup(fh->memory_pool, rhs);
}
- if (rate) {
- fh->samplerate = rate;
- } else {
- rate = 8000;
+ if (!fh->samplerate) {
+ if (!(fh->samplerate = rate)) {
+ fh->samplerate = 8000;
+ }
}
if (channels) {
fh->channels = 1;
}
- if ((status = fh->file_interface->file_open(fh, file_path)) == SWITCH_STATUS_SUCCESS) {
- switch_set_flag(fh, SWITCH_FILE_OPEN);
+ if ((status = fh->file_interface->file_open(fh, file_path)) != SWITCH_STATUS_SUCCESS) {
+ return status;
+ }
+
+ if ((flags & SWITCH_FILE_FLAG_READ)) {
+ fh->native_rate = fh->samplerate;
+ } else {
+ fh->native_rate = rate;
+ }
+
+ if (fh->samplerate != rate) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Sample rate doesn't match\n");
+ if ((flags & SWITCH_FILE_FLAG_READ)) {
+ fh->samplerate = rate;
+ }
}
+ switch_set_flag(fh, SWITCH_FILE_OPEN);
+
return status;
}
SWITCH_DECLARE(switch_status_t) switch_core_file_read(switch_file_handle_t *fh, void *data, switch_size_t *len)
{
+ switch_status_t status;
+ switch_size_t orig_len = *len;
+
switch_assert(fh != NULL);
switch_assert(fh->file_interface != NULL);
- return fh->file_interface->file_read(fh, data, len);
+ if (fh->buffer && switch_buffer_inuse(fh->buffer)) {
+ *len = switch_buffer_read(fh->buffer, data, orig_len);
+ return SWITCH_STATUS_SUCCESS;
+ }
+
+ if ((status = fh->file_interface->file_read(fh, data, len)) != SWITCH_STATUS_SUCCESS) {
+ goto done;
+ }
+
+ if (!switch_test_flag(fh, SWITCH_FILE_NATIVE) && fh->native_rate != fh->samplerate) {
+ if (!fh->resampler) {
+ if (switch_resample_create(&fh->resampler,
+ fh->native_rate,
+ orig_len * 10,
+ fh->samplerate,
+ orig_len * 10,
+ fh->memory_pool) != SWITCH_STATUS_SUCCESS) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Unable to create resampler!\n");
+ return SWITCH_STATUS_GENERR;
+ }
+ }
+
+ fh->resampler->from_len = switch_short_to_float(data, fh->resampler->from, (int) *len);
+ fh->resampler->to_len =
+ switch_resample_process(fh->resampler, fh->resampler->from, fh->resampler->from_len, fh->resampler->to, fh->resampler->to_size, 0);
+
+ if (fh->resampler->to_len > orig_len) {
+ if (!fh->buffer) {
+ switch_buffer_create_dynamic(&fh->buffer, fh->resampler->to_len * 2, fh->resampler->to_len * 4, fh->resampler->to_len * 8);
+ switch_assert(fh->buffer);
+ }
+ if (!fh->dbuf) {
+ fh->dbuflen = fh->resampler->to_len * 2;
+ fh->dbuf = switch_core_alloc(fh->memory_pool, fh->dbuflen);
+ }
+ switch_assert(fh->resampler->to_len <= fh->dbuflen);
+
+ switch_float_to_short(fh->resampler->to, (int16_t *) fh->dbuf, fh->resampler->to_len);
+ switch_buffer_write(fh->buffer, fh->dbuf, fh->resampler->to_len * 2);
+ *len = switch_buffer_read(fh->buffer, data, orig_len);
+ } else {
+ switch_float_to_short(fh->resampler->to, data, fh->resampler->to_len);
+ *len = fh->resampler->to_len;
+ }
+
+ }
+
+ done:
+
+ return status;
}
SWITCH_DECLARE(switch_status_t) switch_core_file_write(switch_file_handle_t *fh, void *data, switch_size_t *len)
{
+ switch_size_t orig_len = *len;
+
switch_assert(fh != NULL);
switch_assert(fh->file_interface != NULL);
+
+ if (!switch_test_flag(fh, SWITCH_FILE_NATIVE) && fh->native_rate != fh->samplerate) {
+ if (!fh->resampler) {
+ if (switch_resample_create(&fh->resampler,
+ fh->native_rate,
+ orig_len * 10,
+ fh->samplerate,
+ orig_len * 10,
+ fh->memory_pool) != SWITCH_STATUS_SUCCESS) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Unable to create resampler!\n");
+ return SWITCH_STATUS_GENERR;
+ }
+ }
+
+ fh->resampler->from_len = switch_short_to_float(data, fh->resampler->from, (int) *len);
+ fh->resampler->to_len =
+ switch_resample_process(fh->resampler, fh->resampler->from, fh->resampler->from_len, fh->resampler->to, fh->resampler->to_size, 0);
+ if (fh->resampler->to_len > orig_len) {
+ if (!fh->dbuf) {
+ fh->dbuflen = fh->resampler->to_len * 2;
+ fh->dbuf = switch_core_alloc(fh->memory_pool, fh->dbuflen);
+ }
+ switch_assert(fh->resampler->to_len <= fh->dbuflen);
+ switch_float_to_short(fh->resampler->to, (int16_t *) fh->dbuf, fh->resampler->to_len);
+ data = fh->dbuf;
+ } else {
+ switch_float_to_short(fh->resampler->to, data, fh->resampler->to_len);
+ }
+
+ *len = fh->resampler->to_len;
+
+ }
+
+ if (!*len) {
+ return SWITCH_STATUS_SUCCESS;
+ }
return fh->file_interface->file_write(fh, data, len);
}
switch_clear_flag(fh, SWITCH_FILE_OPEN);
status = fh->file_interface->file_close(fh);
+ if (fh->buffer) {
+ switch_buffer_destroy(&fh->buffer);
+ }
+
+ switch_resample_destroy(&fh->resampler);
+
+
if (switch_test_flag(fh, SWITCH_FILE_FLAG_FREE_POOL)) {
switch_core_destroy_memory_pool(&fh->memory_pool);
}
char buf[256];
switch_size_t has;
- /* sweep theese under the rug, they wont be leaked they will be reclaimed
- when the session ends.
- */
- session->read_resampler = NULL;
- session->write_resampler = NULL;
+ /* clear resamplers*/
+ switch_resample_destroy(&session->read_resampler);
+ switch_resample_destroy(&session->write_resampler);
/* clear indications */
switch_core_session_flush_message(session);
const char *vval;
time_t start = 0;
uint32_t org_silence_hits = 0;
- switch_audio_resampler_t *resampler = NULL;
- int16_t resamp_out[2048];
if (!fh) {
fh = &lfh;
switch_assert(read_codec != NULL);
fh->channels = read_codec->implementation->number_of_channels;
+ fh->native_rate = read_codec->implementation->actual_samples_per_second;
- if (fh->samplerate) {
- if (fh->samplerate != read_codec->implementation->actual_samples_per_second) {
- if (switch_resample_create(&resampler,
- read_codec->implementation->actual_samples_per_second,
- read_codec->implementation->actual_samples_per_second * 20,
- fh->samplerate,
- fh->samplerate * 20,
- switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Unable to create resampler!\n");
- return SWITCH_STATUS_GENERR;
- }
- }
- } else {
- fh->samplerate = read_codec->implementation->actual_samples_per_second;
- }
if (switch_core_file_open(fh,
file,
fh->channels,
- fh->samplerate,
+ read_codec->implementation->actual_samples_per_second,
SWITCH_FILE_FLAG_WRITE | SWITCH_FILE_DATA_SHORT, switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
switch_core_session_reset(session);
}
}
- if (!switch_test_flag(fh, SWITCH_FILE_PAUSE)) {
+ if (!switch_test_flag(fh, SWITCH_FILE_PAUSE) && !switch_test_flag(read_frame, SFF_CNG)) {
int16_t *data = read_frame->data;
len = (switch_size_t) read_frame->datalen / 2;
- if (resampler) {
- resampler->from_len = switch_short_to_float(read_frame->data, resampler->from, (int) len);
- resampler->to_len = switch_resample_process(resampler, resampler->from, resampler->from_len, resampler->to, resampler->to_size, 0);
- switch_float_to_short(resampler->to, resamp_out, read_frame->datalen);
- len = resampler->to_len;
- data = resamp_out;
- }
-
if (switch_core_file_write(fh, data, &len) != SWITCH_STATUS_SUCCESS) {
break;
}
#endif
}
-SWITCH_DECLARE(void) switch_resample_destroy(switch_audio_resampler_t *resampler)
+SWITCH_DECLARE(void) switch_resample_destroy(switch_audio_resampler_t **resampler)
{
+
+ if (resampler && *resampler) {
#ifndef DISABLE_RESAMPLE
- resample_close(resampler->resampler);
+ if ((*resampler)->resampler) {
+ resample_close((*resampler)->resampler);
+ }
#endif
+ *resampler = NULL;
+ }
}
projects / thirdparty / freeswitch.git / commitdiff
