SWITCH_DECLARE_CONSTRUCTOR EventConsumer::EventConsumer(const char *event_name, const char *subclass_name)
{
switch_core_new_memory_pool(&pool);
switch_queue_create(&events, 5000, pool);
node_index = 0;
if (!zstr(event_name)) {
bind(event_name, subclass_name);
}
}
SWITCH_DECLARE(void) switch_scheduler_task_thread_start(void)
{
switch_threadattr_t *thd_attr;
switch_core_new_memory_pool(&globals.memory_pool);
switch_threadattr_create(&thd_attr, globals.memory_pool);
switch_mutex_init(&globals.task_mutex, SWITCH_MUTEX_NESTED, globals.memory_pool);
switch_queue_create(&globals.event_queue, 250000, globals.memory_pool);
switch_threadattr_detach_set(thd_attr, 1);
switch_thread_create(&task_thread_p, thd_attr, switch_scheduler_task_thread, NULL, globals.memory_pool);
}
SWITCH_DECLARE(switch_status_t) switch_log_init(switch_memory_pool_t *pool, switch_bool_t colorize)
{
switch_threadattr_t *thd_attr;;
switch_assert(pool != NULL);
LOG_POOL = pool;
switch_threadattr_create(&thd_attr, LOG_POOL);
switch_threadattr_detach_set(thd_attr, 1);
switch_queue_create(&LOG_QUEUE, SWITCH_CORE_QUEUE_LEN, LOG_POOL);
#ifdef SWITCH_LOG_RECYCLE
switch_queue_create(&LOG_RECYCLE_QUEUE, SWITCH_CORE_QUEUE_LEN, LOG_POOL);
#endif
switch_mutex_init(&BINDLOCK, SWITCH_MUTEX_NESTED, LOG_POOL);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
switch_thread_create(&thread, thd_attr, log_thread, NULL, LOG_POOL);
while (!THREAD_RUNNING) {
switch_cond_next();
}
if (colorize) {
#ifdef WIN32
hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
if (switch_core_get_console() == stdout && hStdout != INVALID_HANDLE_VALUE && GetConsoleScreenBufferInfo(hStdout, &csbiInfo)) {
wOldColorAttrs = csbiInfo.wAttributes;
COLORIZE = SWITCH_TRUE;
}
#else
COLORIZE = SWITCH_TRUE;
#endif
}
return SWITCH_STATUS_SUCCESS;
}
switch_status_t mongo_connection_pool_create(mongo_connection_pool_t **conn_pool, switch_size_t min_connections, switch_size_t max_connections,
const char *conn_str)
{
switch_memory_pool_t *pool = NULL;
switch_status_t status = SWITCH_STATUS_SUCCESS;
mongo_connection_pool_t *cpool = NULL;
DBClientBase *conn = NULL;
if ((status = switch_core_new_memory_pool(&pool)) != SWITCH_STATUS_SUCCESS) {
return status;
}
if (!(cpool = (mongo_connection_pool_t *)switch_core_alloc(pool, sizeof(mongo_connection_pool_t)))) {
switch_goto_status(SWITCH_STATUS_MEMERR, done);
}
if ((status = switch_mutex_init(&cpool->mutex, SWITCH_MUTEX_NESTED, pool)) != SWITCH_STATUS_SUCCESS) {
goto done;
}
if ((status = switch_queue_create(&cpool->connections, max_connections, pool)) != SWITCH_STATUS_SUCCESS) {
goto done;
}
cpool->min_connections = min_connections;
cpool->max_connections = max_connections;
cpool->conn_str = switch_core_strdup(pool, conn_str);
cpool->pool = pool;
for (cpool->size = 0; cpool->size < min_connections; cpool->size++) {
if (mongo_connection_create(&conn, conn_str) == SWITCH_STATUS_SUCCESS) {
mongo_connection_pool_put(cpool, conn);
} else {
break;
}
}
done:
if (status == SWITCH_STATUS_SUCCESS) {
*conn_pool = cpool;
} else {
switch_core_destroy_memory_pool(&pool);
}
return status;
}
bool AsyncIOServer::Start(
switch_memory_pool_t *pool,
int iThreadCount,
const char *ip,
switch_port_t port
) {
bool bFlag = false;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "AsyncIOServer::Start( "
"iThreadCount : %d, "
"ip : %s, "
"port : %d "
") \n",
iThreadCount,
ip,
port
);
mRunning = true;
mpPool = pool;
mThreadCount = iThreadCount;
// 创建处理队列
switch_queue_create(&mpHandleQueue, SWITCH_CORE_QUEUE_LEN, mpPool);
// 创建处理线程
switch_threadattr_t *thd_handle_attr = NULL;
switch_threadattr_create(&thd_handle_attr, mpPool);
switch_threadattr_detach_set(thd_handle_attr, 1);
switch_threadattr_stacksize_set(thd_handle_attr, SWITCH_THREAD_STACKSIZE);
switch_threadattr_priority_set(thd_handle_attr, SWITCH_PRI_IMPORTANT);
mpHandleThreads = (switch_thread_t**)switch_core_alloc(mpPool, mThreadCount * sizeof(switch_thread_t*));
for(int i = 0; i < mThreadCount; i++) {
switch_thread_create(&mpHandleThreads[i], thd_handle_attr, ws_handle_thread, this, mpPool);
}
// 开始监听socket
bFlag = mTcpServer.Start(mpPool, ip, port);
if( bFlag ) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "AsyncIOServer::Start( success ) \n");
} else {
Stop();
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "AsyncIOServer::Start( fail ) \n");
}
return bFlag;
}
SWITCH_DECLARE_CONSTRUCTOR EventConsumer::EventConsumer(const char *event_name, const char *subclass_name)
{
switch_name_event(event_name, &e_event_id);
switch_core_new_memory_pool(&pool);
if (!zstr(subclass_name)) {
e_subclass_name = switch_core_strdup(pool, subclass_name);
} else {
e_subclass_name = NULL;
}
switch_queue_create(&events, 5000, pool);
if (switch_event_bind_removable(__FILE__, e_event_id, e_subclass_name, event_handler, this, &node) == SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "bound to %s %s\n", event_name, switch_str_nil(e_subclass_name));
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot bind to %s %s\n", event_name, switch_str_nil(e_subclass_name));
}
}
static switch_status_t tech_init(private_t *tech_pvt, switch_core_session_t *session, switch_codec_t *codec)
{
const char *iananame = "L16";
int rate = 8000;
int interval = 20;
switch_status_t status = SWITCH_STATUS_SUCCESS;
switch_channel_t *channel = switch_core_session_get_channel(session);
const switch_codec_implementation_t *read_impl;
if (codec) {
iananame = codec->implementation->iananame;
rate = codec->implementation->samples_per_second;
interval = codec->implementation->microseconds_per_packet / 1000;
}
if (switch_core_codec_ready(&tech_pvt->read_codec)) {
switch_core_codec_destroy(&tech_pvt->read_codec);
}
if (switch_core_codec_ready(&tech_pvt->write_codec)) {
switch_core_codec_destroy(&tech_pvt->write_codec);
}
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s setup codec %s/%d/%d\n", switch_channel_get_name(channel), iananame, rate,
interval);
status = switch_core_codec_init(&tech_pvt->read_codec,
iananame,
NULL,
rate, interval, 1, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL, switch_core_session_get_pool(session));
if (status != SWITCH_STATUS_SUCCESS || !tech_pvt->read_codec.implementation || !switch_core_codec_ready(&tech_pvt->read_codec)) {
goto end;
}
status = switch_core_codec_init(&tech_pvt->write_codec,
iananame,
NULL,
rate, interval, 1, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL, switch_core_session_get_pool(session));
if (status != SWITCH_STATUS_SUCCESS) {
switch_core_codec_destroy(&tech_pvt->read_codec);
goto end;
}
tech_pvt->read_frame.data = tech_pvt->databuf;
tech_pvt->read_frame.buflen = sizeof(tech_pvt->databuf);
tech_pvt->read_frame.codec = &tech_pvt->read_codec;
tech_pvt->cng_frame.data = tech_pvt->cng_databuf;
tech_pvt->cng_frame.buflen = sizeof(tech_pvt->cng_databuf);
//switch_set_flag((&tech_pvt->cng_frame), SFF_CNG);
tech_pvt->cng_frame.datalen = 2;
tech_pvt->bowout_frame_count = (tech_pvt->read_codec.implementation->actual_samples_per_second /
tech_pvt->read_codec.implementation->samples_per_packet) * 3;
switch_core_session_set_read_codec(session, &tech_pvt->read_codec);
switch_core_session_set_write_codec(session, &tech_pvt->write_codec);
if (tech_pvt->flag_mutex) {
switch_core_timer_destroy(&tech_pvt->timer);
}
read_impl = tech_pvt->read_codec.implementation;
switch_core_timer_init(&tech_pvt->timer, "soft",
read_impl->microseconds_per_packet / 1000, read_impl->samples_per_packet * 4, switch_core_session_get_pool(session));
if (!tech_pvt->flag_mutex) {
switch_mutex_init(&tech_pvt->flag_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
switch_mutex_init(&tech_pvt->mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
switch_core_session_set_private(session, tech_pvt);
switch_queue_create(&tech_pvt->frame_queue, FRAME_QUEUE_LEN, switch_core_session_get_pool(session));
tech_pvt->session = session;
tech_pvt->channel = switch_core_session_get_channel(session);
}
end:
return status;
}
switch_memory_pool_t *switch_core_memory_init(void)
{
#ifndef INSTANTLY_DESTROY_POOLS
switch_threadattr_t *thd_attr;
#endif
#ifdef PER_POOL_LOCK
apr_allocator_t *my_allocator = NULL;
apr_thread_mutex_t *my_mutex;
#endif
memset(&memory_manager, 0, sizeof(memory_manager));
#ifdef PER_POOL_LOCK
if ((apr_allocator_create(&my_allocator)) != APR_SUCCESS) {
abort();
}
if ((apr_pool_create_ex(&memory_manager.memory_pool, NULL, NULL, my_allocator)) != APR_SUCCESS) {
apr_allocator_destroy(my_allocator);
my_allocator = NULL;
abort();
}
if ((apr_thread_mutex_create(&my_mutex, APR_THREAD_MUTEX_NESTED, memory_manager.memory_pool)) != APR_SUCCESS) {
abort();
}
apr_allocator_mutex_set(my_allocator, my_mutex);
apr_pool_mutex_set(memory_manager.memory_pool, my_mutex);
apr_allocator_owner_set(my_allocator, memory_manager.memory_pool);
apr_pool_tag(memory_manager.memory_pool, "core_pool");
#else
apr_pool_create(&memory_manager.memory_pool, NULL);
switch_assert(memory_manager.memory_pool != NULL);
#endif
#ifdef USE_MEM_LOCK
switch_mutex_init(&memory_manager.mem_lock, SWITCH_MUTEX_NESTED, memory_manager.memory_pool);
#endif
#ifdef INSTANTLY_DESTROY_POOLS
{
void *foo;
foo = (void *) (intptr_t) pool_thread;
}
#else
switch_queue_create(&memory_manager.pool_queue, 50000, memory_manager.memory_pool);
switch_queue_create(&memory_manager.pool_recycle_queue, 50000, memory_manager.memory_pool);
switch_threadattr_create(&thd_attr, memory_manager.memory_pool);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
switch_thread_create(&pool_thread_p, thd_attr, pool_thread, NULL, memory_manager.memory_pool);
while (!memory_manager.pool_thread_running) {
switch_cond_next();
}
#endif
return memory_manager.memory_pool;
}
static switch_status_t local_stream_file_open(switch_file_handle_t *handle, const char *path)
{
local_stream_context_t *context;
local_stream_source_t *source;
char *alt_path = NULL;
switch_status_t status = SWITCH_STATUS_SUCCESS;
/* already buffering a step back, so always disable it */
handle->pre_buffer_datalen = 0;
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;
}
switch_mutex_lock(globals.mutex);
top:
alt_path = switch_mprintf("%s/%d", path, handle->samplerate);
if ((source = switch_core_hash_find(globals.source_hash, alt_path))) {
path = alt_path;
} else {
source = switch_core_hash_find(globals.source_hash, path);
}
if (source) {
if (switch_thread_rwlock_tryrdlock(source->rwlock) != SWITCH_STATUS_SUCCESS) {
source = NULL;
}
} else {
if (!switch_stristr("default", alt_path) && !switch_stristr("default", path)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Unknown source %s, trying 'default'\n", path);
free(alt_path);
path = "default";
goto top;
}
}
switch_mutex_unlock(globals.mutex);
if (!source) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unknown source %s\n", path);
status = SWITCH_STATUS_FALSE;
goto end;
}
if ((context = switch_core_alloc(handle->memory_pool, sizeof(*context))) == 0) {
status = SWITCH_STATUS_MEMERR;
goto end;
}
switch_queue_create(&context->video_q, 500, handle->memory_pool);
handle->samples = 0;
handle->samplerate = source->rate;
handle->channels = source->channels;
handle->format = 0;
handle->sections = 0;
handle->seekable = 0;
handle->speed = 0;
handle->private_info = context;
handle->interval = source->interval;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Opening Stream [%s] %dhz\n", path, handle->samplerate);
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");
status = SWITCH_STATUS_MEMERR;
goto end;
}
if (!switch_core_has_video() ||
(switch_test_flag(handle, SWITCH_FILE_FLAG_VIDEO) && !source->has_video && !source->blank_img && !source->cover_art && !source->banner_txt)) {
switch_clear_flag(handle, SWITCH_FILE_FLAG_VIDEO);
}
context->source = source;
context->file = handle->file;
context->func = handle->func;
context->line = handle->line;
context->handle = handle;
context->ready = 1;
switch_mutex_lock(source->mutex);
context->next = source->context_list;
source->context_list = context;
source->total++;
switch_mutex_unlock(source->mutex);
end:
switch_safe_free(alt_path);
return status;
}
static void *SWITCH_THREAD_FUNC read_stream_thread(switch_thread_t *thread, void *obj)
{
local_stream_source_t *source = obj;
switch_file_handle_t fh = { 0 };
local_stream_context_t *cp;
char file_buf[128] = "", path_buf[512] = "", last_path[512], png_buf[512] = "", tmp_buf[512] = "";
switch_timer_t timer = { 0 };
int fd = -1;
switch_buffer_t *audio_buffer;
switch_byte_t *dist_buf;
switch_size_t used;
int skip = 0;
switch_memory_pool_t *temp_pool = NULL;
uint32_t dir_count = 0, do_shuffle = 0;
char *p;
switch_mutex_lock(globals.mutex);
THREADS++;
switch_mutex_unlock(globals.mutex);
if (!source->prebuf) {
source->prebuf = DEFAULT_PREBUFFER_SIZE;
}
if (source->shuffle) {
do_shuffle = 1;
}
switch_queue_create(&source->video_q, 500, source->pool);
switch_buffer_create_dynamic(&audio_buffer, 1024, source->prebuf + 10, 0);
dist_buf = switch_core_alloc(source->pool, source->prebuf + 10);
switch_thread_rwlock_create(&source->rwlock, source->pool);
if (RUNNING) {
switch_mutex_lock(globals.mutex);
switch_core_hash_insert(globals.source_hash, source->name, source);
switch_mutex_unlock(globals.mutex);
source->ready = 1;
}
while (RUNNING && !source->stopped) {
const char *fname;
if (temp_pool) {
switch_core_destroy_memory_pool(&temp_pool);
}
if (switch_core_new_memory_pool(&temp_pool) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Error creating pool");
goto done;
}
if (switch_dir_open(&source->dir_handle, source->location, temp_pool) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Can't open directory: %s\n", source->location);
goto done;
}
if (fd > -1) {
dir_count = 0;
while (switch_fd_read_line(fd, path_buf, sizeof(path_buf))) {
dir_count++;
}
lseek(fd, 0, SEEK_SET);
} else {
dir_count = switch_dir_count(source->dir_handle);
}
if (do_shuffle) {
skip = do_rand(dir_count);
do_shuffle = 0;
}
switch_yield(1000000);
while (RUNNING && !source->stopped) {
switch_size_t olen;
uint8_t abuf[SWITCH_RECOMMENDED_BUFFER_SIZE] = { 0 };
const char *artist = NULL, *title = NULL;
if (fd > -1) {
char *pb;
if (switch_fd_read_line(fd, path_buf, sizeof(path_buf))) {
if ((pb = strchr(path_buf, '\r')) || (pb = strchr(path_buf, '\n'))) {
*pb = '\0';
}
} else {
close(fd);
fd = -1;
continue;
}
} else {
if (!(fname = switch_dir_next_file(source->dir_handle, file_buf, sizeof(file_buf)))) {
break;
}
switch_snprintf(path_buf, sizeof(path_buf), "%s%s%s", source->location, SWITCH_PATH_SEPARATOR, fname);
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;
}
}
if (dir_count > 1 && !strcmp(last_path, path_buf)) {
continue;
}
if (skip > 0) {
skip--;
continue;
}
switch_set_string(last_path, path_buf);
fname = path_buf;
fh.prebuf = source->prebuf;
fh.pre_buffer_datalen = source->prebuf;
if (switch_core_file_open(&fh,
(char *) fname,
source->channels, source->rate, SWITCH_FILE_FLAG_VIDEO | SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, NULL) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't open %s\n", fname);
switch_yield(1000000);
continue;
}
if (switch_core_file_has_video(&fh)) {
flush_video_queue(source->video_q);
}
if (switch_core_timer_init(&timer, source->timer_name, source->interval, (int)source->samples, temp_pool) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Can't start timer.\n");
switch_dir_close(source->dir_handle);
source->dir_handle = NULL;
goto done;
}
switch_img_free(&source->cover_art);
switch_set_string(tmp_buf, path_buf);
if ((p = strrchr(tmp_buf, '/'))) {
*p++ = '\0';
switch_snprintf(png_buf, sizeof(png_buf), "%s/art/%s.png", tmp_buf, p);
if (switch_file_exists(png_buf, source->pool) == SWITCH_STATUS_SUCCESS) {
source->cover_art = switch_img_read_png(png_buf, SWITCH_IMG_FMT_I420);
}
}
source->serno++;
switch_safe_free(source->banner_txt);
title = artist = NULL;
switch_core_file_get_string(&fh, SWITCH_AUDIO_COL_STR_ARTIST, &artist);
switch_core_file_get_string(&fh, SWITCH_AUDIO_COL_STR_TITLE, &title);
if (title && (source->cover_art || switch_core_file_has_video(&fh))) {
const char *format = "#cccccc:#333333:FreeSans.ttf:3%:";
if (artist) {
source->banner_txt = switch_mprintf("%s%s (%s)", format, title, artist);
} else {
source->banner_txt = switch_mprintf("%s%s", format, title);
}
}
while (RUNNING && !source->stopped) {
int is_open;
switch_file_handle_t *use_fh = &fh;
switch_core_timer_next(&timer);
olen = source->samples;
if (source->chime_total) {
if (source->chime_counter > 0) {
source->chime_counter -= (int32_t)source->samples;
}
if (!switch_test_flag((&source->chime_fh), SWITCH_FILE_OPEN) && source->chime_counter <= 0) {
char *val;
val = source->chime_list[source->chime_cur++];
if (source->chime_cur >= source->chime_total) {
source->chime_cur = 0;
}
if (switch_core_file_open(&source->chime_fh,
(char *) val,
source->channels,
source->rate, SWITCH_FILE_FLAG_VIDEO | SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, NULL) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't open %s\n", val);
}
if (switch_core_file_has_video(&source->chime_fh)) {
flush_video_queue(source->video_q);
}
}
if (switch_test_flag((&source->chime_fh), SWITCH_FILE_OPEN)) {
use_fh = &source->chime_fh;
}
}
retry:
source->has_video = switch_core_file_has_video(use_fh) || source->cover_art || source->banner_txt;
is_open = switch_test_flag(use_fh, SWITCH_FILE_OPEN);
if (source->hup) {
source->hup = 0;
if (is_open) {
is_open = 0;
switch_core_file_close(use_fh);
flush_video_queue(source->video_q);
if (use_fh == &source->chime_fh) {
source->chime_counter = source->rate * source->chime_freq;
switch_core_file_close(&fh);
use_fh = &fh;
}
goto retry;
}
}
if (is_open) {
if (switch_core_has_video() && switch_core_file_has_video(use_fh)) {
switch_frame_t vid_frame = { 0 };
if (use_fh == &source->chime_fh && switch_core_file_has_video(&fh)) {
if (switch_core_file_read_video(&fh, &vid_frame, SVR_FLUSH) == SWITCH_STATUS_SUCCESS) {
switch_img_free(&vid_frame.img);
}
}
if (switch_core_file_read_video(use_fh, &vid_frame, SVR_FLUSH) == SWITCH_STATUS_SUCCESS) {
if (vid_frame.img) {
int flush = 1;
source->has_video = 1;
if (source->total) {
if (switch_queue_trypush(source->video_q, vid_frame.img) == SWITCH_STATUS_SUCCESS) {
flush = 0;
}
}
if (flush) {
switch_img_free(&vid_frame.img);
flush_video_queue(source->video_q);
}
}
}
} else {
source->has_video = 0;
}
if (use_fh == &source->chime_fh) {
olen = source->samples;
switch_core_file_read(&fh, abuf, &olen);
olen = source->samples;
}
if (switch_core_file_read(use_fh, abuf, &olen) != SWITCH_STATUS_SUCCESS || !olen) {
switch_core_file_close(use_fh);
flush_video_queue(source->video_q);
if (use_fh == &source->chime_fh) {
source->chime_counter = source->rate * source->chime_freq;
use_fh = &fh;
} else {
is_open = 0;
}
} else {
if (use_fh == &source->chime_fh && source->chime_max) {
source->chime_max_counter += (int32_t)source->samples;
if (source->chime_max_counter >= source->chime_max) {
source->chime_max_counter = 0;
switch_core_file_close(use_fh);
flush_video_queue(source->video_q);
source->chime_counter = source->rate * source->chime_freq;
use_fh = &fh;
goto retry;
}
}
if (source->total) {
switch_buffer_write(audio_buffer, abuf, olen * 2 * source->channels);
} else {
switch_buffer_zero(audio_buffer);
}
}
}
used = switch_buffer_inuse(audio_buffer);
if (!used && !is_open) {
break;
}
if (!is_open || used >= source->prebuf || (source->total && used > source->samples * 2 * source->channels)) {
void *pop;
used = switch_buffer_read(audio_buffer, dist_buf, source->samples * 2 * source->channels);
if (!source->total) {
flush_video_queue(source->video_q);
} else {
uint32_t bused = 0;
switch_mutex_lock(source->mutex);
for (cp = source->context_list; cp && RUNNING; cp = cp->next) {
if (source->has_video) {
switch_set_flag(cp->handle, SWITCH_FILE_FLAG_VIDEO);
} else {
switch_clear_flag(cp->handle, SWITCH_FILE_FLAG_VIDEO);
}
if (switch_test_flag(cp->handle, SWITCH_FILE_CALLBACK)) {
continue;
}
switch_mutex_lock(cp->audio_mutex);
bused = (uint32_t)switch_buffer_inuse(cp->audio_buffer);
if (bused > source->samples * 768) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "Flushing Stream Handle Buffer [%s() %s:%d] size: %u samples: %ld\n",
cp->func, cp->file, cp->line, bused, (long)source->samples);
switch_buffer_zero(cp->audio_buffer);
} else {
switch_buffer_write(cp->audio_buffer, dist_buf, used);
}
switch_mutex_unlock(cp->audio_mutex);
}
switch_mutex_unlock(source->mutex);
while (switch_queue_trypop(source->video_q, &pop) == SWITCH_STATUS_SUCCESS) {
switch_image_t *img = (switch_image_t *) pop;
switch_image_t *imgcp = NULL;
if (source->total == 1) {
switch_queue_push(source->context_list->video_q, img);
} else {
if (source->context_list) {
switch_mutex_lock(source->mutex);
for (cp = source->context_list; cp && RUNNING; cp = cp->next) {
if (cp->video_q) {
imgcp = NULL;
switch_img_copy(img, &imgcp);
if (imgcp) {
if (switch_queue_trypush(cp->video_q, imgcp) != SWITCH_STATUS_SUCCESS) {
flush_video_queue(cp->video_q);
}
}
}
}
switch_mutex_unlock(source->mutex);
}
switch_img_free(&img);
}
}
}
}
}
switch_core_timer_destroy(&timer);
if (RUNNING && source->shuffle) {
skip = do_rand(dir_count);
}
}
switch_dir_close(source->dir_handle);
source->dir_handle = NULL;
if (source->full_reload) {
if (source->rwlock && switch_thread_rwlock_trywrlock(source->rwlock) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Cannot stop local_stream://%s because it is in use.\n",source->name);
if (source->part_reload) {
switch_xml_t cfg, xml, directory, param;
if (!(xml = switch_xml_open_cfg(global_cf, &cfg, NULL))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Open of %s failed\n", global_cf);
}
if ((directory = switch_xml_find_child(cfg, "directory", "name", source->name))) {
for (param = switch_xml_child(directory, "param"); param; param = param->next) {
char *var = (char *) switch_xml_attr_soft(param, "name");
char *val = (char *) switch_xml_attr_soft(param, "value");
if (!strcasecmp(var, "shuffle")) {
source->shuffle = switch_true(val);
} else if (!strcasecmp(var, "chime-freq")) {
int tmp = atoi(val);
if (tmp > 1) {
source->chime_freq = tmp;
}
} else if (!strcasecmp(var, "chime-max")) {
int tmp = atoi(val);
if (tmp > 1) {
source->chime_max = tmp;
}
} else if (!strcasecmp(var, "chime-list")) {
char *list_dup = switch_core_strdup(source->pool, val);
source->chime_total =
switch_separate_string(list_dup, ',', source->chime_list, (sizeof(source->chime_list) / sizeof(source->chime_list[0])));
} else if (!strcasecmp(var, "interval")) {
int tmp = atoi(val);
if (SWITCH_ACCEPTABLE_INTERVAL(tmp)) {
source->interval = tmp;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
"Interval must be multiple of 10 and less than %d, Using default of 20\n", SWITCH_MAX_INTERVAL);
}
}
if (source->chime_max) {
source->chime_max *= source->rate;
}
if (source->chime_total) {
source->chime_counter = source->rate * source->chime_freq;
}
}
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "local_stream://%s partially reloaded.\n",source->name);
source->part_reload = 0;
}
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "local_stream://%s fully reloaded.\n",source->name);
launch_streams(source->name);
goto done;
}
}
}
done:
switch_safe_free(source->banner_txt);
if (switch_test_flag((&fh), SWITCH_FILE_OPEN)) {
switch_core_file_close(&fh);
}
if (switch_test_flag((&source->chime_fh), SWITCH_FILE_OPEN)) {
switch_core_file_close(&source->chime_fh);
}
source->ready = 0;
switch_mutex_lock(globals.mutex);
switch_core_hash_delete(globals.source_hash, source->name);
switch_mutex_unlock(globals.mutex);
switch_thread_rwlock_wrlock(source->rwlock);
switch_thread_rwlock_unlock(source->rwlock);
switch_buffer_destroy(&audio_buffer);
flush_video_queue(source->video_q);
if (fd > -1) {
close(fd);
}
if (temp_pool) {
switch_core_destroy_memory_pool(&temp_pool);
}
switch_core_destroy_memory_pool(&source->pool);
switch_mutex_lock(globals.mutex);
THREADS--;
switch_mutex_unlock(globals.mutex);
return NULL;
}
switch_status_t mod_amqp_logging_create(char *name, switch_xml_t cfg)
{
mod_amqp_logging_profile_t *profile = NULL;
switch_xml_t params, param, connections, connection;
switch_threadattr_t *thd_attr = NULL;
char *exchange = NULL, *exchange_type = NULL;
int exchange_durable = 1; /* durable */
switch_memory_pool_t *pool;
if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
goto err;
}
profile = switch_core_alloc(pool, sizeof(mod_amqp_logging_profile_t));
profile->pool = pool;
profile->name = switch_core_strdup(profile->pool, name);
profile->running = 1;
profile->conn_root = NULL;
profile->conn_active = NULL;
profile->log_level_mask = 0;
profile->send_queue_size = 5000;
if ((params = switch_xml_child(cfg, "params")) != NULL) {
for (param = switch_xml_child(params, "param"); param; param = param->next) {
char *var = (char *) switch_xml_attr_soft(param, "name");
char *val = (char *) switch_xml_attr_soft(param, "value");
if (!var) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Profile[%s] param missing 'name' attribute\n", profile->name);
continue;
}
if (!val) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Profile[%s] param[%s] missing 'value' attribute\n", profile->name, var);
continue;
}
if (!strncmp(var, "reconnect_interval_ms", 21)) {
int interval = atoi(val);
if ( interval && interval > 0 ) {
profile->reconnect_interval_ms = interval;
}
} else if (!strncmp(var, "send_queue_size", 15)) {
int interval = atoi(val);
if ( interval && interval > 0 ) {
profile->send_queue_size = interval;
}
} else if (!strncmp(var, "exchange-type", 13)) {
exchange_type = switch_core_strdup(profile->pool, val);
} else if (!strncmp(var, "exchange-name", 13)) {
exchange = switch_core_strdup(profile->pool, val);
} else if (!strncmp(var, "exchange-durable", 16)) {
exchange_durable = switch_true(val);
} else if (!strncmp(var, "log-levels", 10)) {
profile->log_level_mask = switch_log_str2mask(val);
}
} /* params for loop */
}
/* Handle defaults of string types */
profile->exchange = exchange ? exchange : switch_core_strdup(profile->pool, "TAP.Events");
profile->exchange_type = exchange_type ? exchange_type : switch_core_strdup(profile->pool, "topic");
profile->exchange_durable = exchange_durable;
if ((connections = switch_xml_child(cfg, "connections")) != NULL) {
for (connection = switch_xml_child(connections, "connection"); connection; connection = connection->next) {
if ( ! profile->conn_root ) { /* Handle first root node */
if (mod_amqp_connection_create(&(profile->conn_root), connection, profile->pool) != SWITCH_STATUS_SUCCESS) {
/* Handle connection create failure */
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Profile[%s] failed to create connection\n", profile->name);
continue;
}
profile->conn_active = profile->conn_root;
} else {
if (mod_amqp_connection_create(&(profile->conn_active->next), connection, profile->pool) != SWITCH_STATUS_SUCCESS) {
/* Handle connection create failure */
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Profile[%s] failed to create connection\n", profile->name);
continue;
}
profile->conn_active = profile->conn_active->next;
}
}
}
profile->conn_active = NULL;
if ( mod_amqp_connection_open(profile->conn_root, &(profile->conn_active), profile->name, profile->custom_attr) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Profile[%s] was unable to connect to any connection\n", profile->name);
goto err;
}
amqp_exchange_declare(profile->conn_active->state, 1,
amqp_cstring_bytes(profile->exchange),
amqp_cstring_bytes(profile->exchange_type),
0, /* passive */
profile->exchange_durable,
amqp_empty_table);
if (mod_amqp_log_if_amqp_error(amqp_get_rpc_reply(profile->conn_active->state), "Declaring exchange")) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Profile[%s] failed to create exchange\n", profile->name);
goto err;
}
/* Create a bounded FIFO queue for sending messages */
if (switch_queue_create(&(profile->send_queue), profile->send_queue_size, profile->pool) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot create send queue of size %d!\n", profile->send_queue_size);
goto err;
}
/* Start the event send thread. This will set up the initial connection */
switch_threadattr_create(&thd_attr, profile->pool);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
if (switch_thread_create(&profile->logging_thread, thd_attr, mod_amqp_logging_thread, profile, profile->pool)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot create 'amqp event sender' thread!\n");
goto err;
}
if ( switch_core_hash_insert(globals.logging_hash, name, (void *) profile) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to insert new profile [%s] into mod_amqp profile hash\n", name);
goto err;
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Profile[%s] Successfully started\n", profile->name);
return SWITCH_STATUS_SUCCESS;
err:
/* Cleanup */
mod_amqp_logging_destroy(&profile);
return SWITCH_STATUS_GENERR;
}
