void PjsipCallFront::dump_info(pj_thread_t *thread)
{
Q_ASSERT(thread != NULL);
qLogx()<<"pj_thread_is_registered:"<<pj_thread_is_registered();
qLogx()<<"pj_thread_get_prio:"<<pj_thread_get_prio(thread);
qLogx()<<"pj_thread_get_prio_min:"<<pj_thread_get_prio_min(thread);
qLogx()<<"pj_thread_get_prio_max:"<<pj_thread_get_prio_max(thread);
qLogx()<<"pj_thread_get_name:"<<pj_thread_get_name(thread);
qLogx()<<"pj_getpid:"<<pj_getpid();
}
/*
* The thread's entry point.
*
* Each of the thread mainly will just execute the loop which
* increments a variable.
*/
static void* thread_proc(pj_uint32_t *pcounter)
{
/* Test that pj_thread_register() works. */
pj_thread_desc desc;
pj_thread_t *this_thread;
unsigned id;
pj_status_t rc;
id = *pcounter;
PJ_UNUSED_ARG(id); /* Warning about unused var if TRACE__ is disabled */
TRACE__((THIS_FILE, " thread %d running..", id));
pj_bzero(desc, sizeof(desc));
rc = pj_thread_register("thread", desc, &this_thread);
if (rc != PJ_SUCCESS) {
app_perror("...error in pj_thread_register", rc);
return NULL;
}
/* Test that pj_thread_this() works */
this_thread = pj_thread_this();
if (this_thread == NULL) {
PJ_LOG(3,(THIS_FILE, "...error: pj_thread_this() returns NULL!"));
return NULL;
}
/* Test that pj_thread_get_name() works */
if (pj_thread_get_name(this_thread) == NULL) {
PJ_LOG(3,(THIS_FILE, "...error: pj_thread_get_name() returns NULL!"));
return NULL;
}
/* Main loop */
for (;!quit_flag;) {
(*pcounter)++;
//Must sleep if platform doesn't do time-slicing.
//pj_thread_sleep(0);
}
TRACE__((THIS_FILE, " thread %d quitting..", id));
return NULL;
}
PJ_DEF(void) pj_log( const char *sender, int level,
const char *format, va_list marker)
{
pj_time_val now;
pj_parsed_time ptime;
char *pre;
#if PJ_LOG_USE_STACK_BUFFER
char log_buffer[PJ_LOG_MAX_SIZE];
#endif
int saved_level, len, print_len;
PJ_CHECK_STACK();
if (level > pj_log_max_level)
return;
if (is_logging_suspended())
return;
/* Temporarily disable logging for this thread. Some of PJLIB APIs that
* this function calls below will recursively call the logging function
* back, hence it will cause infinite recursive calls if we allow that.
*/
suspend_logging(&saved_level);
/* Get current date/time. */
pj_gettimeofday(&now);
pj_time_decode(&now, &ptime);
pre = log_buffer;
if (log_decor & PJ_LOG_HAS_LEVEL_TEXT) {
static const char *ltexts[] = { "FATAL:", "ERROR:", " WARN:",
" INFO:", "DEBUG:", "TRACE:", "DETRC:"};
pj_ansi_strcpy(pre, ltexts[level]);
pre += 6;
}
if (log_decor & PJ_LOG_HAS_DAY_NAME) {
static const char *wdays[] = { "Sun", "Mon", "Tue", "Wed",
"Thu", "Fri", "Sat"};
pj_ansi_strcpy(pre, wdays[ptime.wday]);
pre += 3;
}
if (log_decor & PJ_LOG_HAS_YEAR) {
*pre++ = ' ';
pre += pj_utoa(ptime.year, pre);
}
if (log_decor & PJ_LOG_HAS_MONTH) {
*pre++ = '-';
pre += pj_utoa_pad(ptime.mon+1, pre, 2, '0');
}
if (log_decor & PJ_LOG_HAS_DAY_OF_MON) {
*pre++ = '-';
pre += pj_utoa_pad(ptime.day, pre, 2, '0');
}
if (log_decor & PJ_LOG_HAS_TIME) {
*pre++ = ' ';
pre += pj_utoa_pad(ptime.hour, pre, 2, '0');
*pre++ = ':';
pre += pj_utoa_pad(ptime.min, pre, 2, '0');
*pre++ = ':';
pre += pj_utoa_pad(ptime.sec, pre, 2, '0');
}
if (log_decor & PJ_LOG_HAS_MICRO_SEC) {
*pre++ = '.';
pre += pj_utoa_pad(ptime.msec, pre, 3, '0');
}
if (log_decor & PJ_LOG_HAS_SENDER) {
enum { SENDER_WIDTH = 14 };
int sender_len = strlen(sender);
*pre++ = ' ';
if (sender_len <= SENDER_WIDTH) {
while (sender_len < SENDER_WIDTH)
*pre++ = ' ', ++sender_len;
while (*sender)
*pre++ = *sender++;
} else {
int i;
for (i=0; i<SENDER_WIDTH; ++i)
*pre++ = *sender++;
}
}
if (log_decor & PJ_LOG_HAS_THREAD_ID) {
enum { THREAD_WIDTH = 12 };
const char *thread_name = pj_thread_get_name(pj_thread_this());
int thread_len = strlen(thread_name);
*pre++ = ' ';
if (thread_len <= THREAD_WIDTH) {
while (thread_len < THREAD_WIDTH)
*pre++ = ' ', ++thread_len;
while (*thread_name)
*pre++ = *thread_name++;
} else {
int i;
for (i=0; i<THREAD_WIDTH; ++i)
*pre++ = *thread_name++;
}
}
if (log_decor != 0 && log_decor != PJ_LOG_HAS_NEWLINE)
*pre++ = ' ';
if (log_decor & PJ_LOG_HAS_SPACE) {
*pre++ = ' ';
}
len = pre - log_buffer;
/* Print the whole message to the string log_buffer. */
print_len = pj_ansi_vsnprintf(pre, sizeof(log_buffer)-len, format,
marker);
if (print_len < 0) {
level = 1;
print_len = pj_ansi_snprintf(pre, sizeof(log_buffer)-len,
"<logging error: msg too long>");
}
len = len + print_len;
if (len > 0 && len < (int)sizeof(log_buffer)-2) {
if (log_decor & PJ_LOG_HAS_CR) {
log_buffer[len++] = '\r';
}
if (log_decor & PJ_LOG_HAS_NEWLINE) {
log_buffer[len++] = '\n';
}
log_buffer[len] = '\0';
} else {
len = sizeof(log_buffer)-1;
if (log_decor & PJ_LOG_HAS_CR) {
log_buffer[sizeof(log_buffer)-3] = '\r';
}
if (log_decor & PJ_LOG_HAS_NEWLINE) {
log_buffer[sizeof(log_buffer)-2] = '\n';
}
log_buffer[sizeof(log_buffer)-1] = '\0';
}
/* It should be safe to resume logging at this point. Application can
* recursively call the logging function inside the callback.
*/
resume_logging(&saved_level);
if (log_writer)
(*log_writer)(level, log_buffer, len);
}
//
// Get thread name.
//
static const char *get_name(pj_thread_t *thread)
{
return pj_thread_get_name(thread);
}
