/**
* Thread to prefetch URLs
* @param thread the thread
* @param obj started flag
* @return NULL
*/
static void *SWITCH_THREAD_FUNC prefetch_thread(switch_thread_t *thread, void *obj)
{
int *started = obj;
void *url = NULL;
switch_thread_rwlock_rdlock(gcache.shutdown_lock);
*started = 1;
// process prefetch requests
while (!gcache.shutdown) {
if (switch_queue_pop(gcache.prefetch_queue, &url) == SWITCH_STATUS_SUCCESS) {
switch_stream_handle_t stream = { 0 };
SWITCH_STANDARD_STREAM(stream);
switch_api_execute("http_get", url, NULL, &stream);
switch_safe_free(stream.data);
switch_safe_free(url);
}
url = NULL;
}
// shutting down- clear the queue
while (switch_queue_trypop(gcache.prefetch_queue, &url) == SWITCH_STATUS_SUCCESS) {
switch_safe_free(url);
url = NULL;
}
switch_thread_rwlock_unlock(gcache.shutdown_lock);
return NULL;
}
void AsyncIOServer::Stop() {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "AsyncIOServer::Stop() \n");
mRunning = false;
// 停止监听socket
mTcpServer.Stop();
// 停止处理线程
if( mpHandleThreads != NULL ) {
for(int i = 0; i < mThreadCount; i++) {
switch_status_t retval;
switch_thread_join(&retval, mpHandleThreads[i]);
}
}
// 销毁处理队列
unsigned int size;
void* pop = NULL;
while(true) {
size = switch_queue_size(mpHandleQueue);
if( size == 0 ) {
break;
} else {
switch_queue_pop(mpHandleQueue, &pop);
}
}
mpPool = NULL;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "AsyncIOServer::Stop( finish ) \n");
}
SWITCH_DECLARE(Event *) EventConsumer::pop(int block, int timeout)
{
void *pop = NULL;
Event *ret = NULL;
switch_event_t *event;
if (!ready) {
return NULL;
}
if (block) {
if (timeout > 0) {
switch_queue_pop_timeout(events, &pop, (switch_interval_time_t) timeout * 1000); // millisec rather than microsec
} else {
switch_queue_pop(events, &pop);
}
} else {
switch_queue_trypop(events, &pop);
}
if ((event = (switch_event_t *) pop)) {
ret = new Event(event, 1);
}
return ret;
}
/**
* Thread that delivers logs to graylog2 server
* @param thread this thread
* @param obj unused
* @return NULL
*/
static void *SWITCH_THREAD_FUNC deliver_graylog2_thread(switch_thread_t *thread, void *obj)
{
switch_socket_t *graylog2_sock = NULL;
char *log;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "graylog2 delivery thread started\n");
switch_thread_rwlock_rdlock(globals.shutdown_rwlock);
graylog2_sock = open_graylog2_socket(globals.server_host, globals.server_port, globals.pool);
if (graylog2_sock) {
while (!globals.shutdown) {
if (switch_queue_pop(globals.log_queue, (void *)&log) == SWITCH_STATUS_SUCCESS) {
if (!zstr(log)) {
switch_size_t len = strlen(log);
switch_size_t max_len = globals.send_uncompressed_header ? MAX_GELF_LOG_LEN - UNCOMPRESSED_MAGIC_LEN : MAX_GELF_LOG_LEN;
if (len <= max_len) {
if (globals.send_uncompressed_header) {
char buf[MAX_GELF_LOG_LEN];
memcpy(buf, UNCOMPRESSED_MAGIC, UNCOMPRESSED_MAGIC_LEN);
memcpy(buf + UNCOMPRESSED_MAGIC_LEN, log, len);
len += UNCOMPRESSED_MAGIC_LEN;
switch_socket_send_nonblock(graylog2_sock, (void *)buf, &len);
} else {
switch_socket_send_nonblock(graylog2_sock, (void *)log, &len);
}
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Skipping large log\n");
}
}
switch_safe_free(log);
}
}
}
globals.shutdown = 1;
/* clean up remaining logs */
while(switch_queue_trypop(globals.log_queue, (void *)&log) == SWITCH_STATUS_SUCCESS) {
switch_safe_free(log);
}
if (graylog2_sock) {
switch_socket_close(graylog2_sock);
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "graylog2 delivery thread finished\n");
switch_thread_rwlock_unlock(globals.shutdown_rwlock);
return NULL;
}
SWITCH_DECLARE(Event *) EventConsumer::pop(int block)
{
void *pop = NULL;
Event *ret = NULL;
switch_event_t *event;
if (block) {
switch_queue_pop(events, &pop);
} else {
switch_queue_trypop(events, &pop);
}
if ((event = (switch_event_t *) pop)) {
ret = new Event(event, 1);
}
return ret;
}
static void *SWITCH_THREAD_FUNC log_thread(switch_thread_t *t, void *obj)
{
if (!obj) {
obj = NULL;
}
THREAD_RUNNING = 1;
while (THREAD_RUNNING == 1) {
void *pop = NULL;
switch_log_node_t *node = NULL;
switch_log_binding_t *binding;
if (switch_queue_pop(LOG_QUEUE, &pop) != SWITCH_STATUS_SUCCESS) {
break;
}
if (!pop) {
break;
}
node = (switch_log_node_t *) pop;
switch_mutex_lock(BINDLOCK);
for (binding = BINDINGS; binding; binding = binding->next) {
if (binding->level >= node->level) {
binding->function(node, node->level);
}
}
switch_mutex_unlock(BINDLOCK);
switch_log_node_free(&node);
}
THREAD_RUNNING = 0;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Logger Ended.\n");
return NULL;
}
static void *SWITCH_THREAD_FUNC pool_thread(switch_thread_t *thread, void *obj)
{
memory_manager.pool_thread_running = 1;
while (memory_manager.pool_thread_running == 1) {
int len = switch_queue_size(memory_manager.pool_queue);
if (len) {
int x = len, done = 0;
switch_yield(1000000);
#ifdef USE_MEM_LOCK
switch_mutex_lock(memory_manager.mem_lock);
#endif
while (x > 0) {
void *pop = NULL;
if (switch_queue_pop(memory_manager.pool_queue, &pop) != SWITCH_STATUS_SUCCESS || !pop) {
done = 1;
break;
}
#if defined(PER_POOL_LOCK) || defined(DESTROY_POOLS)
#ifdef USE_MEM_LOCK
switch_mutex_lock(memory_manager.mem_lock);
#endif
#ifdef DEBUG_ALLOC
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%p DESTROY POOL\n", (void *) pop);
#endif
apr_pool_destroy(pop);
#ifdef USE_MEM_LOCK
switch_mutex_unlock(memory_manager.mem_lock);
#endif
#else
apr_pool_mutex_set(pop, NULL);
#ifdef DEBUG_ALLOC
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%p DESTROY POOL\n", (void *) pop);
#endif
apr_pool_clear(pop);
if (switch_queue_trypush(memory_manager.pool_recycle_queue, pop) != SWITCH_STATUS_SUCCESS) {
#ifdef USE_MEM_LOCK
switch_mutex_lock(memory_manager.mem_lock);
#endif
#ifdef DEBUG_ALLOC
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "%p DESTROY POOL\n", (void *) pop);
#endif
apr_pool_destroy(pop);
#ifdef USE_MEM_LOCK
switch_mutex_unlock(memory_manager.mem_lock);
#endif
}
#endif
x--;
}
#ifdef USE_MEM_LOCK
switch_mutex_unlock(memory_manager.mem_lock);
#endif
if (done) {
goto done;
}
} else {
switch_yield(1000000);
}
}
done:
switch_core_memory_reclaim();
{
void *pop = NULL;
while (switch_queue_trypop(memory_manager.pool_queue, &pop) == SWITCH_STATUS_SUCCESS && pop) {
#ifdef USE_MEM_LOCK
switch_mutex_lock(memory_manager.mem_lock);
#endif
apr_pool_destroy(pop);
pop = NULL;
#ifdef USE_MEM_LOCK
switch_mutex_unlock(memory_manager.mem_lock);
#endif
}
}
memory_manager.pool_thread_running = 0;
return NULL;
}
static switch_status_t local_stream_file_read_video(switch_file_handle_t *handle, switch_frame_t *frame, switch_video_read_flag_t flags)
{
void *pop;
local_stream_context_t *context = handle->private_info;
switch_status_t status;
switch_time_t now;
if (!(context->ready && context->source->ready)) {
return SWITCH_STATUS_FALSE;
}
if (!context->source->has_video) {
if (frame) {
switch_image_t *src_img = context->source->cover_art;
if (!src_img) {
src_img = context->source->blank_img;
}
if (src_img) {
switch_image_t *img = NULL;
if (context->sent_png && --context->sent_png > 0) {
return SWITCH_STATUS_BREAK;
}
context->sent_png = 50;
switch_img_copy(src_img, &img);
if (context->last_w && context->last_h) {
switch_img_fit(&img, context->last_w, context->last_h, SWITCH_FIT_SIZE);
}
frame->img = img;
goto got_img;
}
}
return SWITCH_STATUS_IGNORE;
}
if ((flags & SVR_CHECK)) {
return SWITCH_STATUS_BREAK;
}
while(context->ready && context->source->ready && (flags & SVR_FLUSH) && switch_queue_size(context->video_q) > 1) {
if (switch_queue_trypop(context->video_q, &pop) == SWITCH_STATUS_SUCCESS) {
switch_image_t *img = (switch_image_t *) pop;
switch_img_free(&img);
}
}
if (!(context->ready && context->source->ready)) {
return SWITCH_STATUS_FALSE;
}
if ((flags & SVR_BLOCK)) {
status = switch_queue_pop(context->video_q, &pop);
} else {
status = switch_queue_trypop(context->video_q, &pop);
}
if (status == SWITCH_STATUS_SUCCESS) {
if (!pop) {
return SWITCH_STATUS_FALSE;
}
frame->img = (switch_image_t *) pop;
context->sent_png = 0;
context->last_w = frame->img->d_w;
context->last_h = frame->img->d_h;
goto got_img;
}
return (flags & SVR_FLUSH) ? SWITCH_STATUS_BREAK : status;
got_img:
if (context->pop_count > 0) {
switch_rgb_color_t bgcolor = { 0 };
switch_color_set_rgb(&bgcolor, "#000000");
switch_img_fill(frame->img, 0, 0, frame->img->d_w, frame->img->d_h, &bgcolor);
context->pop_count--;
}
now = switch_micro_time_now();
if (context->banner_img) {
if (now >= context->banner_timeout) {
switch_img_free(&context->banner_img);
}
}
if (context->serno != context->source->serno) {
switch_img_free(&context->banner_img);
context->banner_timeout = 0;
context->serno = context->source->serno;
context->pop_count = 5;
}
if (context->source->banner_txt) {
if ((!context->banner_timeout || context->banner_timeout >= now)) {
if (!context->banner_img) {
context->banner_img = switch_img_write_text_img(context->last_w, context->last_h, SWITCH_TRUE, context->source->banner_txt);
context->banner_timeout = now + 5000000;
}
}
} else {
if (context->banner_img) {
switch_img_free(&context->banner_img);
}
context->banner_timeout = 0;
}
if (frame->img && context->banner_img && frame->img->d_w >= context->banner_img->d_w) {
//switch_img_overlay(frame->img, context->banner_img, 0, frame->img->d_h - context->banner_img->d_h, 100);
switch_img_patch(frame->img, context->banner_img, 0, frame->img->d_h - context->banner_img->d_h);
}
return SWITCH_STATUS_SUCCESS;
}
